@global-torque/invest-core 0.2.2

package/src/kyc/__tests__/kycAlert.formatter.test.ts

@@ -0,0 +1,47 @@
+import { describe, expect, it } from 'vitest';
+import { InvestKycTypes } from '@global-torque/domain-types/kycTypes';
+import { formatKycAlertModel } from '@global-torque/invest-core/kyc/kycAlert';
+
+describe('formatKycAlertModel', () => {
+  it.each([
+    [InvestKycTypes.none, true, 'error', 'Verify Identity', 'Verify Identity'],
+    [InvestKycTypes.new, true, 'error', 'Verify Identity', 'Verify Identity'],
+    [InvestKycTypes.pending, true, 'error', 'Finish Your KYC', 'Continue'],
+    [InvestKycTypes.in_progress, true, 'info', 'Verification In Progress', undefined],
+    [InvestKycTypes.declined, true, 'error', 'Verification Declined', undefined],
+  ])('maps %s into the normalized alert model', (status, show, variant, title, buttonText) => {
+    const model = formatKycAlertModel({ status });
+
+    expect(model.show).toBe(show);
+    expect(model.variant).toBe(variant);
+    expect(model.title).toBe(title);
+    expect(model.buttonText).toBe(buttonText);
+  });
+
+  it('hides the alert for approved KYC status', () => {
+    const model = formatKycAlertModel({ status: InvestKycTypes.approved });
+
+    expect(model.show).toBe(false);
+    expect(model.title).toBe('');
+    expect(model.buttonText).toBeUndefined();
+  });
+
+  it('hides the alert when the profile is already approved even if the status is stale', () => {
+    const model = formatKycAlertModel({
+      status: InvestKycTypes.pending,
+      isKycApproved: true,
+    });
+
+    expect(model.show).toBe(false);
+  });
+
+  it('mirrors Plaid loading into CTA loading and disabled state', () => {
+    const model = formatKycAlertModel({
+      status: InvestKycTypes.pending,
+      isPlaidLoading: true,
+    });
+
+    expect(model.isLoading).toBe(true);
+    expect(model.isDisabled).toBe(true);
+  });
+});

package/src/kyc/__tests__/kycAlert.test.ts

@@ -0,0 +1,47 @@
+import { describe, expect, it } from 'vitest';
+import { InvestKycTypes } from '../status.ts';
+import { formatKycAlertModel } from '../kycAlert.ts';
+
+describe('formatKycAlertModel', () => {
+  it.each([
+    [InvestKycTypes.none, true, 'error', 'Verify Identity', 'Verify Identity'],
+    [InvestKycTypes.new, true, 'error', 'Verify Identity', 'Verify Identity'],
+    [InvestKycTypes.pending, true, 'error', 'Finish Your KYC', 'Continue'],
+    [InvestKycTypes.in_progress, true, 'info', 'Verification In Progress', undefined],
+    [InvestKycTypes.declined, true, 'error', 'Verification Declined', undefined],
+  ])('maps %s into the normalized alert model', (status, show, variant, title, buttonText) => {
+    const model = formatKycAlertModel({ status });
+
+    expect(model.show).toBe(show);
+    expect(model.variant).toBe(variant);
+    expect(model.title).toBe(title);
+    expect(model.buttonText).toBe(buttonText);
+  });
+
+  it('hides the alert for approved KYC status', () => {
+    const model = formatKycAlertModel({ status: InvestKycTypes.approved });
+
+    expect(model.show).toBe(false);
+    expect(model.title).toBe('');
+    expect(model.buttonText).toBeUndefined();
+  });
+
+  it('hides the alert when the profile is already approved even if the status is stale', () => {
+    const model = formatKycAlertModel({
+      status: InvestKycTypes.pending,
+      isKycApproved: true,
+    });
+
+    expect(model.show).toBe(false);
+  });
+
+  it('mirrors Plaid loading into CTA loading and disabled state', () => {
+    const model = formatKycAlertModel({
+      status: InvestKycTypes.pending,
+      isPlaidLoading: true,
+    });
+
+    expect(model.isLoading).toBe(true);
+    expect(model.isDisabled).toBe(true);
+  });
+});

package/src/kyc/__tests__/thirdPartyScreen.test.ts

@@ -0,0 +1,16 @@
+import { describe, expect, it } from 'vitest';
+import { formatKycThirdPartyScreen } from '../thirdPartyScreen.ts';
+
+describe('formatKycThirdPartyScreen', () => {
+  it('returns the launching screen copy', () => {
+    expect(formatKycThirdPartyScreen('launching')).toEqual({
+      title: 'Opening identity verification',
+      description: 'Please wait while we connect you to our verification partner.',
+    });
+  });
+
+  it('uses the same fallback copy for terminal error states', () => {
+    expect(formatKycThirdPartyScreen('invalidToken')).toEqual(formatKycThirdPartyScreen('error'));
+    expect(formatKycThirdPartyScreen('incomplete')).toEqual(formatKycThirdPartyScreen('error'));
+  });
+});

package/src/kyc/kycAlert.ts

@@ -0,0 +1,47 @@
+import {
+  InvestKycTypes,
+  KycAlerts,
+  KycTextStatuses,
+  type KycAlertModel,
+} from './status.ts';
+
+export interface KycAlertFormatterInput {
+  isKycApproved?: boolean | null;
+  isPlaidLoading?: boolean;
+  status?: InvestKycTypes | null;
+}
+
+export const createHiddenKycAlertModel = (): KycAlertModel => ({
+  show: false,
+  variant: 'error',
+  title: '',
+  description: '',
+  buttonText: undefined,
+  isLoading: false,
+  isDisabled: false,
+});
+
+export const formatKycAlertModel = ({
+  isKycApproved = false,
+  isPlaidLoading = false,
+  status = InvestKycTypes.none,
+}: KycAlertFormatterInput): KycAlertModel => {
+  const resolvedStatus = status ?? InvestKycTypes.none;
+
+  if (isKycApproved || resolvedStatus === InvestKycTypes.approved) {
+    return createHiddenKycAlertModel();
+  }
+
+  const alert = KycAlerts[resolvedStatus];
+  const statusText = KycTextStatuses[resolvedStatus];
+
+  return {
+    show: true,
+    variant: resolvedStatus === InvestKycTypes.in_progress ? 'info' : 'error',
+    title: alert.title,
+    description: alert.description,
+    buttonText: statusText.button ? statusText.text : undefined,
+    isLoading: isPlaidLoading,
+    isDisabled: isPlaidLoading,
+  };
+};

package/src/kyc/status.ts

@@ -0,0 +1,109 @@
+import { InvestKycTypes as InvestKycTypesValue } from '@global-torque/domain-types/kycTypes';
+import type { InvestKycTypes as InvestKycStatus } from '@global-torque/domain-types/kycTypes';
+
+export { InvestKycTypes } from '@global-torque/domain-types/kycTypes';
+
+export type KycAlertVariant = 'error' | 'info';
+
+export type KycThirdPartyStatus =
+  | 'idle'
+  | 'launching'
+  | 'success'
+  | 'incomplete'
+  | 'invalidToken'
+  | 'error';
+
+export interface KycAlertModel {
+  show: boolean;
+  variant: KycAlertVariant;
+  title: string;
+  description: string;
+  buttonText?: string;
+  isLoading: boolean;
+  isDisabled: boolean;
+}
+
+export interface KycThirdPartyScreenModel {
+  title: string;
+  description: string;
+}
+
+export interface KycTextStatus {
+  text: string;
+  class: string;
+  button?: boolean;
+  tooltip?: string;
+  mobileText?: string;
+}
+
+export interface KycAlertContent {
+  title: string;
+  class: string;
+  description: string;
+  button?: boolean;
+  tooltip?: string;
+}
+
+const VERIFY_IDENTITY_TEXT: KycTextStatus = {
+  text: 'Verify Identity',
+  mobileText: 'Verify',
+  class: 'none',
+  button: true,
+};
+
+const VERIFY_IDENTITY_ALERT: KycAlertContent = {
+  title: 'Verify Identity',
+  description: 'Complete identity verification to unlock investing access for this profile.',
+  class: 'none',
+  button: true,
+};
+
+export const KycTextStatuses: Record<InvestKycStatus, KycTextStatus> = {
+  [InvestKycTypesValue.none]: VERIFY_IDENTITY_TEXT,
+  [InvestKycTypesValue.new]: VERIFY_IDENTITY_TEXT,
+  [InvestKycTypesValue.declined]: {
+    text: 'Declined',
+    class: 'failed',
+  },
+  [InvestKycTypesValue.pending]: {
+    text: 'Continue',
+    class: 'pending',
+    button: true,
+  },
+  [InvestKycTypesValue.in_progress]: {
+    text: 'Verification In Progress',
+    mobileText: 'In Progress',
+    class: 'pending',
+    tooltip: 'Pending until all associated parties complete KYC.',
+  },
+  [InvestKycTypesValue.approved]: {
+    text: 'Verified',
+    class: 'success',
+  },
+};
+
+export const KycAlerts: Record<InvestKycStatus, KycAlertContent> = {
+  [InvestKycTypesValue.none]: VERIFY_IDENTITY_ALERT,
+  [InvestKycTypesValue.new]: VERIFY_IDENTITY_ALERT,
+  [InvestKycTypesValue.pending]: {
+    title: 'Finish Your KYC',
+    description: 'Complete the remaining identity verification steps so we can continue reviewing your submission.',
+    class: 'pending',
+    button: true,
+  },
+  [InvestKycTypesValue.in_progress]: {
+    title: 'Verification In Progress',
+    description: 'Your KYC review is in progress. We will notify you as soon as there is an update.',
+    class: 'pending',
+  },
+  [InvestKycTypesValue.declined]: {
+    title: 'Verification Declined',
+    description: 'Your identity verification was declined. <a href="#contact-us-dialog" class="is--link-1" data-action="contact-us">Contact support</a> and we will help resolve the issue.',
+    class: 'failed',
+  },
+  [InvestKycTypesValue.approved]: {
+    title: 'Identity Verified',
+    description: 'Your identity has been successfully verified for this investment profile.',
+    class: 'success',
+  },
+};

package/src/kyc/thirdPartyScreen.ts

@@ -0,0 +1,28 @@
+import type {
+  KycThirdPartyScreenModel,
+  KycThirdPartyStatus,
+} from './status.ts';
+
+const FALLBACK_SCREEN: KycThirdPartyScreenModel = {
+  title: 'We could not complete identity verification',
+  description: 'Please retry from the original verification link. If the problem continues, contact support.',
+};
+
+const SCREEN_BY_STATUS: Record<KycThirdPartyStatus, KycThirdPartyScreenModel> = {
+  idle: FALLBACK_SCREEN,
+  launching: {
+    title: 'Opening identity verification',
+    description: 'Please wait while we connect you to our verification partner.',
+  },
+  success: {
+    title: 'Thank you for completing KYC',
+    description: 'Your KYC process is now complete.',
+  },
+  incomplete: FALLBACK_SCREEN,
+  invalidToken: FALLBACK_SCREEN,
+  error: FALLBACK_SCREEN,
+};
+
+export function formatKycThirdPartyScreen(status: KycThirdPartyStatus): KycThirdPartyScreenModel {
+  return SCREEN_BY_STATUS[status];
+}

package/src/markdown/tableWrap.ts

@@ -0,0 +1,29 @@
+import type MarkdownIt from 'markdown-it';
+
+/**
+ * Plugin to wrap tables in a div with overflow scrolling
+ * This allows tables to be horizontally scrollable on smaller screens
+ * Matches the VTable component's wrapper structure
+ */
+export const tableWrap = (md: MarkdownIt): void => {
+  // Store the original table renderers if they exist
+  const defaultTableOpen = md.renderer.rules.table_open || ((tokens, idx, options, env, self) => {
+    return self.renderToken(tokens, idx, options);
+  });
+  const defaultTableClose = md.renderer.rules.table_close || ((tokens, idx, options, env, self) => {
+    return self.renderToken(tokens, idx, options);
+  });
+
+  // Override table_open to add opening wrapper div
+  md.renderer.rules.table_open = (tokens, idx, options, env, self) => {
+    return '<div class="v-table__wrap">\n' + defaultTableOpen(tokens, idx, options, env, self);
+  };
+
+  // Override table_close to add closing wrapper div
+  md.renderer.rules.table_close = (tokens, idx, options, env, self) => {
+    return defaultTableClose(tokens, idx, options, env, self) + '\n</div>';
+  };
+};
+
+export default tableWrap;
+

package/src/notifications/shareFields.ts

@@ -0,0 +1,15 @@
+import type {
+  INotification,
+  INotificationDataFields,
+} from '@global-torque/domain-types/notificationsTypes';
+import { assertCanonicalDecimalString } from '../decimal/canonicalDecimal.ts';
+
+export function assertNotificationShareFields(notification: INotification): void {
+  const fields = notification?.data?.fields ?? {} as INotificationDataFields;
+  if (fields.confirmed_shares !== undefined) {
+    assertCanonicalDecimalString(fields.confirmed_shares, 'confirmed_shares');
+  }
+  if (fields.subscribed_shares !== undefined) {
+    assertCanonicalDecimalString(fields.subscribed_shares, 'subscribed_shares');
+  }
+}

package/src/offer/__tests__/metrics.test.ts

@@ -0,0 +1,67 @@
+import { describe, expect, it } from 'vitest';
+import { OfferStatuses } from '@global-torque/domain-types/offerTypes';
+import {
+  calculateOfferFundedPercent,
+  calculateOfferMinimumInvestment,
+  isOfferClosingSoon,
+  isOfferFullyFunded,
+  isOfferFundingCompleted,
+  isOfferNewWithinDays,
+  isOfferSharesReached,
+  isRegD506cOffer,
+} from '../metrics.ts';
+
+describe('offer metrics', () => {
+  it('uses existing funded-percent rounding behavior', () => {
+    expect(calculateOfferFundedPercent('0', '0')).toBe(0);
+    expect(calculateOfferFundedPercent('421', '1000')).toBe(43);
+    expect(calculateOfferFundedPercent('856', '1000')).toBe(85);
+    expect(calculateOfferFundedPercent('999', '1000')).toBe(99);
+  });
+
+  it('derives funding progress booleans', () => {
+    expect(isOfferFullyFunded(100)).toBe(true);
+    expect(isOfferFullyFunded(99)).toBe(false);
+    expect(isOfferClosingSoon(91)).toBe(true);
+    expect(isOfferClosingSoon(100)).toBe(false);
+  });
+
+  it('calculates minimum investment and remaining-share cutoff', () => {
+    expect(calculateOfferMinimumInvestment('25', '12')).toBe('25');
+    expect(calculateOfferMinimumInvestment('0', '12')).toBe('0');
+    expect(isOfferSharesReached('100', '96', '50', '12')).toBe(true);
+    expect(isOfferSharesReached('100', '95', '50', '12')).toBe(false);
+    expect(isOfferSharesReached('0', '99999999999999999999', '1')).toBe(false);
+  });
+
+  it('keeps fractional and unsafe share values exact', () => {
+    expect(calculateOfferFundedPercent(
+      '9007199254740992.000000000000000001',
+      '18014398509481984.000000000000000002',
+    )).toBe(50);
+    expect(calculateOfferMinimumInvestment('2000.000000000000000001', '12.5'))
+      .toBe('2000.000000000000000001');
+    expect(isOfferSharesReached(
+      '9007199254740993.000000000000000001',
+      '9007199254740992.999999999999999999',
+      '0.000000000000000026',
+      '12.5',
+    )).toBe(true);
+  });
+
+  it('detects new and Reg D 506(c) offers', () => {
+    const now = new Date('2026-04-10T12:00:00.000Z');
+
+    expect(isOfferNewWithinDays('2026-04-09T12:00:00.000Z', 2, now)).toBe(true);
+    expect(isOfferNewWithinDays('2026-04-07T11:59:00.000Z', 2, now)).toBe(false);
+    expect(isOfferNewWithinDays('', 2, now)).toBe(false);
+    expect(isRegD506cOffer('Reg D 506(c)')).toBe(true);
+    expect(isRegD506cOffer('Reg CF')).toBe(false);
+  });
+
+  it('detects completed funding statuses', () => {
+    expect(isOfferFundingCompleted(OfferStatuses.legal_closed)).toBe(true);
+    expect(isOfferFundingCompleted(OfferStatuses.closed_successfully)).toBe(true);
+    expect(isOfferFundingCompleted(OfferStatuses.published)).toBe(false);
+  });
+});