@incodetech/core 2.0.0 → 2.0.1-rc.0

package/dist/types-BP1m8VRw.d.ts

@@ -0,0 +1,340 @@
+import { t as DocumentUploadConfig } from "./types-CFV9G_7j.js";
+
+//#region src/modules/flow/types.d.ts
+type EmptyConfig = Record<string, never>;
+type RegulationTypes = 'US' | 'Worldwide' | 'Other' | 'US_Illinois' | 'US_Texas' | 'US_California' | 'US_Washington';
+type TutorialIdConfig = {
+  showTutorial: boolean;
+  enableId: boolean;
+  enablePassport: boolean;
+  deviceWallet: boolean;
+  onlyFront: boolean;
+  onlyBack: boolean;
+  barcodeCapture: boolean;
+  fetchAdditionalPage: boolean;
+  secondId: boolean;
+  /** @deprecated Third ID capture is deprecated; config is ignored and flow continues to next step */
+  thirdId: boolean;
+  autoCaptureTimeout: number;
+  deviceIdleTimeout: number;
+  captureAttempts: number;
+  manualUploadIdCapture: boolean;
+  digitalIdsUpload: boolean;
+  showDocumentChooserScreen: boolean;
+  enableIdRecording: boolean;
+  usSmartCapture: boolean;
+  showCaptureButtonInAuto?: boolean;
+  alwaysCaptureBackOfId?: boolean;
+  perCountryPerDocOverrides: Record<string, Record<string, {
+    onlyFront: boolean;
+    onlyBack: boolean;
+    fetchAdditionalPage: boolean;
+  }>>;
+};
+type FlowModuleConfig = {
+  AUTHENTICATION: {
+    showTutorial: boolean;
+    autoCaptureTimeout: number;
+    numberOfAttempts: number;
+    type: 'ONE_TO_ONE';
+    deepsightLiveness: 'SINGLE_FRAME' | 'MULTIMODAL' | 'VIDEOLIVENESS';
+    validateClosedEyes: boolean;
+    validateFaceMask: boolean;
+    validateHeadCover: boolean;
+    validateLenses: boolean;
+    /**
+     * When true, the AUTHENTICATION module runs face analysis on-device via
+     * the OnDevice WASM workflow and POSTs only the results JSON to
+     * `/omni/add/face-results` instead of `/omni/onboarding-authentications/authenticate`.
+     * Recording is skipped.
+     */
+    onDeviceFaceResultsSubmissionEnabled?: boolean;
+  };
+  ADDRESS: {
+    disableSkipPoa: boolean;
+    title: string;
+    text: string;
+  };
+  AE_SIGNATURE: {
+    uploadDocument: boolean;
+    downloadDocument: boolean;
+    issuePermanentCertificate: boolean;
+    allowWithoutScoreValidation: boolean;
+    validationsToSkip: ('ID' | 'FACE_RECOGNITION' | 'OTP' | 'TOTAL_SCORE')[];
+  };
+  CURP_VALIDATION: {
+    curpDataMatch: boolean;
+    deceasedStatusVerification: boolean;
+  };
+  CUSTOM_FIELDS: {
+    title: string;
+    customFields: {
+      name: string;
+      alias: string;
+      type: 'INTEGER' | 'DOUBLE' | 'BOOLEAN' | 'STRING' | 'DATE';
+    }[];
+  };
+  DOCUMENT_CAPTURE: {
+    processingType: 'capture' | 'processPoaOcr' | 'processLoaOcr' | 'processAsylumSeekerVisaZaf' | 'processBankStatementOCR' | 'processBankCheck' | 'processV5CLogbook' | 'processCarInvoice' | 'processCirculationCard' | 'processFinanceSettlement';
+    title: string;
+    text: string;
+    allowSkipDocumentCapture: boolean;
+  };
+  EKYB: {
+    checkBusinessName: boolean;
+    businessNameSource: 'userInput';
+    checkAddress: boolean;
+    address: 'userInput';
+    checkTaxId: boolean;
+    taxIdSource: 'userInput';
+    checkUniqueBeneficialOwner: boolean;
+    uniqueBeneficialOwnerSource: 'userInput';
+  };
+  EXTERNAL_VERIFICATION: {
+    source: 'US_DRIVERS_LICENSE_1' | 'US_TELCO_1' | 'US_TELCO_2' | 'US_CONSUMER_1' | 'US_CREDIT_BUREAU_1' | 'MX_CONSUMER_1' | 'BR_GOVT_1' | 'CA_RES_CREDIT' | 'UK_CREDIT_BUREAU_1' | 'ES_1' | 'CL_1' | 'AR_1' | 'GR_1' | 'GT_1' | 'BR_CPF_1';
+    checkName: boolean;
+    nameSource: 'userInput' | 'document' | 'poa' | 'phoneModuleInput' | 'emailModuleInput';
+    checkEmail: boolean;
+    emailSource: 'userInput' | 'document' | 'poa' | 'phoneModuleInput' | 'emailModuleInput';
+    checkAddress: boolean;
+    addressSource: 'userInput' | 'document' | 'poa' | 'phoneModuleInput' | 'emailModuleInput';
+    checkPhone: boolean;
+    phoneSource: 'userInput' | 'document' | 'poa' | 'phoneModuleInput' | 'emailModuleInput';
+    checkSsn: boolean;
+    ssnSource: 'userInput' | 'document' | 'poa' | 'phoneModuleInput' | 'emailModuleInput';
+    checkDob: boolean;
+    dobSource: 'userInput' | 'document' | 'poa' | 'phoneModuleInput' | 'emailModuleInput';
+    checkNationality: boolean;
+    nationalitySource: 'userInput' | 'document' | 'poa' | 'phoneModuleInput' | 'emailModuleInput';
+    checkDlNumber: boolean;
+    dlNumberSource: 'userInput' | 'document' | 'poa' | 'phoneModuleInput' | 'emailModuleInput';
+    checkDlState: boolean;
+    dlStateSource: 'userInput' | 'document' | 'poa' | 'phoneModuleInput' | 'emailModuleInput';
+    checkDlExpireAt: boolean;
+    dlExpireAtSource: 'userInput' | 'document' | 'poa' | 'phoneModuleInput' | 'emailModuleInput';
+    checkLast4SSN: boolean;
+    last4SSNSource: 'userInput' | 'document' | 'poa' | 'phoneModuleInput' | 'emailModuleInput';
+    checkIdNum: boolean;
+    idNumSource: 'userInput' | 'document' | 'poa' | 'phoneModuleInput' | 'emailModuleInput';
+    checkIdNum1: boolean;
+    idNum1Source: 'userInput' | 'document' | 'poa' | 'phoneModuleInput' | 'emailModuleInput';
+    checkGender: boolean;
+    genderSource: 'userInput' | 'document' | 'poa' | 'phoneModuleInput' | 'emailModuleInput';
+  };
+  EMAIL: {
+    otpVerification: boolean;
+    otpExpirationInMinutes: number;
+    prefill?: boolean;
+  };
+  FACE_MATCH: {
+    matchingType: 'selfieVsId' | 'selfieVsNfc' | 'idVsNfc' | 'nfc3Way';
+    disableFaceMatchAnimation: boolean;
+  };
+  FINISH_GPT: {
+    finishgptCompanyName: string;
+  };
+  GEOLOCATION: {
+    allowUserToSkipGeolocation: boolean;
+  };
+  INE_VALIDATION: {
+    facialValidation: boolean;
+    alternativeFacialValidation: boolean;
+    fallbackEnabled: boolean;
+    scrapingMethod: boolean;
+    scrapingV2: boolean;
+    scrapingV3: boolean;
+    failUnsupportedId: boolean;
+    dataValidation: boolean;
+    backgroundExecution: boolean;
+    mockConnectionError: boolean;
+    mockUserNotFoundError: boolean;
+    mockOK: boolean;
+  };
+  GOVT_VALIDATION_PROVISIONING: {
+    validationCountries: string[];
+    facialValidation: boolean;
+    dataValidation: boolean;
+    faceAndDataValidation: boolean;
+    addressValidation: boolean;
+    backgroundExecution: boolean;
+    faceMatchOverrideDataScore: boolean;
+    useCroppedIdFacePhoto: boolean;
+  };
+  TUTORIAL_ID: TutorialIdConfig;
+  ID: TutorialIdConfig;
+  SECOND_ID: TutorialIdConfig;
+  /** @deprecated Third ID step is deprecated; SDK skips this step and continues flow */
+  THIRD_ID: DocumentUploadConfig;
+  ID_OCR: {
+    editableOcr: boolean;
+    /** When true, OCR is collected for the second captured ID after the first. */
+    secondId?: boolean;
+    /** Set by orchestrated flow UI from the active session (`flow.flowId`). */
+    flowId?: string;
+  };
+  INCODE_WATCHLIST: {
+    failIfFaceOnBlocklist: boolean;
+    addSuspectedFraudAutomatically: boolean;
+    autoExecution: boolean;
+  };
+  INSTANT_BAV: {
+    bavVendorCountry: 'US' | 'CA' | 'AU' | 'NZ' | 'BR' | 'MX' | 'CO' | 'UK' | 'EU';
+    bavNumberOfRetries: number;
+  };
+  MANDATORY_CONSENT: {
+    consentType: RegulationTypes;
+  };
+  ML_CONSENT: {
+    consentType: RegulationTypes;
+  };
+  NFC_SCAN: {
+    nfcAvailability: boolean;
+    nfcValidation: boolean;
+    showInitialDataConfirmationScreen: boolean;
+  };
+  PHONE: {
+    otpVerification: boolean;
+    otpExpirationInMinutes: number;
+    prefill: boolean;
+  };
+  SELFIE: {
+    showTutorial: boolean;
+    showPreview: boolean;
+    assistedOnboarding: boolean;
+    enableFaceRecording: boolean;
+    autoCaptureTimeout: number;
+    captureAttempts: number;
+    validateLenses: boolean;
+    validateFaceMask: boolean;
+    validateHeadCover: boolean;
+    validateClosedEyes: boolean;
+    validateBrightness: boolean;
+    deepsightLiveness: 'SINGLE_FRAME' | 'MULTIMODAL' | 'VIDEOLIVENESS';
+    /**
+     * When true, the SELFIE module runs face analysis on-device via the
+     * OnDevice WASM workflow and POSTs only the results JSON to
+     * `/omni/add/face-results` instead of `/omni/add/face`. Recording is
+     * skipped and the `/omni/process/face` step is bypassed.
+     */
+    onDeviceFaceResultsSubmissionEnabled?: boolean;
+  };
+  SIGNATURE: {
+    title: string;
+    subTitle: string;
+  };
+  USER_CONSENT: {
+    title: string;
+    text: string;
+  };
+  CONFERENCE: {
+    enableConferenceOtp: boolean;
+  };
+  VIDEO_ONBOARDING: {
+    useAsSelfie: boolean;
+    showTutorials: boolean;
+    companyName: string;
+    checkLiveness: boolean;
+    checkIdScan: boolean;
+    checkDocumentScan: boolean;
+    compareIdEnabled: boolean;
+    compareOcrEnabled: boolean;
+    compareBackIdEnabled: boolean;
+    compareBackOcrEnabled: boolean;
+    checkVoiceConsent: boolean;
+    voiceConsentQuestions: number;
+    selfieQualityAffectsScore: boolean;
+    maxWaitingVideoSelfieFile: number;
+    lastSecondsVideoQualityCheck: boolean;
+    lastSecondsVideoQualityCheckDuration: number;
+    validateClosedEyes: boolean;
+    validateFaceMask: boolean;
+    validateHeadCover: boolean;
+    validateLenses: boolean;
+  };
+  DYNAMIC_FORMS: {
+    screens: {
+      title: string;
+      hideTitle: boolean;
+      questions: {
+        questionId: string;
+        overrides: string | null;
+        isPredefined: boolean;
+        isOptional: boolean;
+        predefinedQuestionType: string | null;
+        question: string;
+        inputType: 'NUMBER' | 'CPF' | 'COUNTRY' | 'NATIONALITY' | 'DATE' | 'PHONE' | 'EMAIL' | 'TEXT' | 'MULTISELECT' | 'YESNO' | 'SELECT';
+        options: string[];
+      }[];
+    }[];
+  };
+  COMBINED_CONSENT: {
+    combinedConsents: string;
+  };
+  QE_SIGNATURE: {
+    uploadDocument: boolean;
+    downloadDocument: boolean;
+  };
+  CERTIFICATE_ISSUANCE: {
+    region: string;
+    type: 'ONE_TIME' | 'SHORT_TERM' | 'LONG_TERM';
+  };
+  ANTIFRAUD: EmptyConfig;
+  CHECKBOX_SIGNATURE: EmptyConfig;
+  CROSS_DOCUMENT_DATA_MATCH: EmptyConfig;
+  CPF_OCR: EmptyConfig;
+  DEVICE_FINGERPRINT: EmptyConfig;
+  FACE_ONBOARDING: EmptyConfig;
+  FIELD_COMPARISON: EmptyConfig;
+  FISCAL_QR: EmptyConfig;
+  GENERATE_QR: EmptyConfig;
+  HOME: EmptyConfig;
+  INSTANT_VERIFY: EmptyConfig;
+  IP_ADDRESS: EmptyConfig;
+  NAME_CAPTURE: EmptyConfig;
+  REDIRECT_TO_MOBILE: {
+    flowId: string;
+    disableSmsOption?: boolean;
+    addContinueToDesktop?: boolean;
+    qrPhishingResistance?: boolean;
+    authHint?: string;
+    lang?: string;
+  };
+  SHOW_RESULTS: EmptyConfig;
+  STADIUM_SELECTOR: EmptyConfig;
+  UNIVERSAL_IDENTITY: EmptyConfig;
+  WATCHLIST: EmptyConfig;
+  TRUST_GRAPH: EmptyConfig;
+  WATCHLIST_BUSINESS: EmptyConfig;
+};
+type FlowModule = { [K in keyof FlowModuleConfig]: {
+  key: K;
+  configuration: FlowModuleConfig[K];
+} }[keyof FlowModuleConfig];
+type Flow = {
+  flowId: string;
+  name: string;
+  autoApproveEnabled?: boolean;
+  autoApproveLevel?: 'LOW' | 'MEDIUM' | 'HIGH';
+  checkTutorials?: boolean;
+  checkAuthorization?: boolean;
+  redirectDesktopToMobile?: boolean;
+  disableUnsupportedBrowserScreen?: boolean;
+  qrPhishingResistance?: boolean;
+  addContinueToDesktop?: boolean;
+  redirectOriginOnly?: boolean;
+  displayOnboardingResultOnDesktop?: boolean;
+  enableMultipleOnboardings?: boolean;
+  disableLaunchScreen?: boolean;
+  enableSardineRisk?: boolean;
+  mandatoryConsentCheck?: boolean;
+  disableSmsOption?: boolean;
+  mergeSessionRecordings?: boolean;
+  ageAssurance?: boolean;
+  flowModules: FlowModule[];
+  enforceCaptureAttemptLimits?: boolean;
+  enableFraudAi?: boolean;
+  getEnableIdOnlyIdentity?: boolean;
+  ds?: boolean;
+};
+//#endregion
+export { RegulationTypes as a, FlowModuleConfig as i, Flow as n, TutorialIdConfig as o, FlowModule as r, EmptyConfig as t };

package/dist/types-CAD4va6a.d.ts

@@ -0,0 +1,5 @@
+//#region src/internal/permissions/types.d.ts
+type PermissionResult = 'granted' | 'denied' | 'prompt';
+type PermissionStatus = 'idle' | 'requesting' | 'denied' | 'learnMore';
+//#endregion
+export { PermissionStatus as n, PermissionResult as t };

package/dist/types-CFV9G_7j.d.ts

@@ -0,0 +1,24 @@
+import { t as CameraStream } from "./camera-DBSxa6ML.js";
+
+//#region src/modules/document-upload/types.d.ts
+
+/**
+ * Configuration for document upload (e.g., third ID capture).
+ * The documentType determines the backend endpoint query parameter.
+ */
+type DocumentUploadConfig = {
+  /** Document type for the upload endpoint (e.g., 'thirdId') */
+  documentType: string;
+};
+type DocumentUploadContext = {
+  config: DocumentUploadConfig;
+  stream: CameraStream | undefined;
+  imageBase64: string | undefined;
+  progress: number;
+  error: string | undefined;
+};
+type DocumentUploadInput = {
+  config: DocumentUploadConfig;
+};
+//#endregion
+export { DocumentUploadContext as n, DocumentUploadInput as r, DocumentUploadConfig as t };

package/dist/warmup-CEcppFiS.d.ts

@@ -0,0 +1,63 @@
+//#region ../infra/src/wasm/warmup.d.ts
+/**
+ * All available ML pipelines in the SDK.
+ * - 'selfie' - Face detection for selfie capture (default 4-model bundle)
+ * - 'onDeviceSelfie' - Face detection + on-device liveness + age estimation
+ *   (6-model bundle for the on-device face-results submission flow). Mutually
+ *   exclusive with 'selfie' for a given session — both use FaceProcessingApi.
+ * - 'idCapture' - Document detection for ID capture
+ */
+type WasmPipeline = 'selfie' | 'onDeviceSelfie' | 'idCapture';
+interface WarmupConfig {
+  wasmPath: string;
+  wasmSimdPath?: string;
+  glueCodePath: string;
+  /**
+   * Path to the SIMD-optimized WASM glue code (paired with `wasmSimdPath`).
+   * If omitted, defaults to a sibling `.js` derived from `wasmSimdPath`.
+   */
+  glueCodeSimdPath?: string;
+  useSimd?: boolean;
+  pipelines?: readonly WasmPipeline[];
+  /**
+   * Base path for ML model files. Models will be loaded from `${modelsBasePath}/${modelFileName}`.
+   * If not provided, models are expected to be in the same directory as the WASM files.
+   */
+  modelsBasePath?: string;
+  /**
+   * Custom model files per pipeline. If not provided, uses default models.
+   * Keys are pipeline names, values are arrays of model file names.
+   */
+  pipelineModels?: Partial<Record<WasmPipeline, string[]>>;
+}
+/**
+ * Preloads WASM binary and ML models at app startup.
+ * Runs asynchronously - app can continue while WASM loads in background.
+ *
+ * Model files are automatically loaded based on the pipeline type.
+ * By default, models are expected in a 'models' subdirectory relative to the WASM binary.
+ *
+ * @param config - Configuration for WASM warmup
+ * @returns Promise that resolves when WASM is ready
+ *
+ * @example
+ * ```ts
+ * // Basic usage - models loaded from /wasm/v2/models/
+ * warmupWasm({
+ *   wasmPath: '/wasm/v2/ml-wasm.wasm',
+ *   glueCodePath: '/wasm/v2/ml-wasm.js',
+ *   pipelines: ['selfie', 'idCapture'],
+ * });
+ *
+ * // With explicit models path
+ * warmupWasm({
+ *   wasmPath: '/wasm/v2/ml-wasm.wasm',
+ *   glueCodePath: '/wasm/v2/ml-wasm.js',
+ *   modelsBasePath: 'https://cdn.example.com/wasm/v2/models',
+ *   pipelines: ['selfie'],
+ * });
+ * ```
+ */
+declare function warmupWasm(config: WarmupConfig): Promise<void>;
+//#endregion
+export { WasmPipeline as n, warmupWasm as r, WarmupConfig as t };

package/dist/wasm.d.ts

@@ -0,0 +1,15 @@
+import { n as WasmPipeline, r as warmupWasm, t as WarmupConfig } from "./warmup-CEcppFiS.js";
+import { c as upgradeToWasmHttpClient, n as WasmConfig, o as setWasmConfig, r as initializeWasmUtil } from "./setup-C5AITV8m.js";
+
+//#region ../infra/src/wasm/wasmDefaults.d.ts
+/** The WASM version bundled and tested with this SDK release. */
+declare const DEFAULT_WASM_VERSION = "v2.13.21";
+/** Builds the standard WarmupConfig from the Incode CDN. */
+declare function buildDefaultWasmConfig(): WarmupConfig;
+/**
+ * Merges optional WASM path overrides with CDN defaults. Explicit non-blank
+ * paths take precedence. Blank override strings log a warning and fall back to defaults.
+ */
+declare function resolveWasmConfig(overrides?: Partial<WarmupConfig>): WarmupConfig;
+//#endregion
+export { DEFAULT_WASM_VERSION, type WasmConfig, type WasmPipeline, buildDefaultWasmConfig, initializeWasmUtil, resolveWasmConfig, setWasmConfig, upgradeToWasmHttpClient, warmupWasm };

package/dist/wasm.esm.js

@@ -0,0 +1,12 @@
+import { c as buildDefaultWasmConfig, i as setWasmConfig, l as resolveWasmConfig, o as upgradeToWasmHttpClient, s as DEFAULT_WASM_VERSION, t as initializeWasmUtil } from "./setup-DsM8IG7k.esm.js";
+import { n as warmupWasm } from "./BaseWasmProvider-C_DLEI40.esm.js";
+import "./WasmUtilProvider-j98OJf-S.esm.js";
+import "./BrowserTimerProvider-DhNc_x02.esm.js";
+import "./api-CESGtpbH.esm.js";
+import "./events-D6-e4vok.esm.js";
+import "./endpoints-CnN3SyDa.esm.js";
+import "./session-CGtQJJzB.esm.js";
+import "./IpifyProvider-D7jx52AL.esm.js";
+import "./browserSimulation-gxD8cSpM.esm.js";
+
+export { DEFAULT_WASM_VERSION, buildDefaultWasmConfig, initializeWasmUtil, resolveWasmConfig, setWasmConfig, upgradeToWasmHttpClient, warmupWasm };

package/dist/watchlist-for-business.d.ts

@@ -0,0 +1,79 @@
+import { t as Manager } from "./Manager-C8PrhBOx.js";
+
+//#region src/modules/watchlist-for-business/watchlistForBusinessManager.d.ts
+/** Waiting for `load()` to be called. */
+type WatchlistForBusinessIdleState = {
+  status: 'idle';
+};
+/** Form is ready — use `setCountry()`, `setBusinessName()`, and `submit()`. */
+type WatchlistForBusinessFormState = {
+  status: 'form';
+  country: string;
+  businessName: string;
+  isValid: boolean;
+};
+/** API request in flight. */
+type WatchlistForBusinessSubmittingState = {
+  status: 'submitting';
+};
+/**
+ * API succeeded — success screen visible for ~3 s before transitioning
+ * to `finished`.
+ */
+type WatchlistForBusinessSuccessState = {
+  status: 'success';
+};
+/** Module complete. Fires regardless of API outcome (fire-and-forget). */
+type WatchlistForBusinessFinishedState = {
+  status: 'finished';
+};
+/**
+ * Discriminated union of all possible watchlist-for-business manager states.
+ */
+type WatchlistForBusinessState = WatchlistForBusinessIdleState | WatchlistForBusinessFormState | WatchlistForBusinessSubmittingState | WatchlistForBusinessSuccessState | WatchlistForBusinessFinishedState;
+/**
+ * Creates a watchlist-for-business manager for headless or UI-driven usage.
+ *
+ * On API error the module completes silently (fire-and-forget).
+ *
+ * @example Headless usage
+ * ```typescript
+ * import { createWatchlistForBusinessManager } from '@incodetech/core/watchlist-for-business';
+ *
+ * const manager = createWatchlistForBusinessManager();
+ * manager.subscribe((state) => {
+ *   if (state.status === 'finished') console.log('Done');
+ * });
+ * manager.load();
+ * manager.setCountry('MX');
+ * manager.setBusinessName('Acme Corp');
+ * manager.submit();
+ * manager.stop();
+ * ```
+ */
+declare function createWatchlistForBusinessManager(): Manager<WatchlistForBusinessState> & {
+  /** Transitions from `idle` to the form. Must be called before any other method. */
+  load(): void;
+  /** Updates the selected country code (ISO 3166-1 alpha-2). */
+  setCountry(country: string): void;
+  /** Updates the business name field and recomputes validity. */
+  setBusinessName(value: string): void;
+  /** Submits the form. Only transitions when `isValid` is true. */
+  submit(): void;
+};
+type WatchlistForBusinessManager = ReturnType<typeof createWatchlistForBusinessManager>;
+//#endregion
+//#region src/modules/watchlist-for-business/watchlistForBusinessStateMachine.d.ts
+declare const watchlistForBusinessMachine: any;
+//#endregion
+//#region src/modules/watchlist-for-business/types.d.ts
+/**
+ * Configuration for the watchlist-for-business module.
+ *
+ * No server-side configuration is required — the module collects
+ * country and business name from the user and submits them to the
+ * business watchlist endpoint.
+ */
+type WatchlistForBusinessConfig = Record<string, never>;
+//#endregion
+export { type WatchlistForBusinessConfig, type WatchlistForBusinessFinishedState, type WatchlistForBusinessFormState, type WatchlistForBusinessManager, type WatchlistForBusinessState, createWatchlistForBusinessManager, watchlistForBusinessMachine };

package/dist/watchlist-for-business.esm.js

@@ -0,0 +1,148 @@
+import { t as api } from "./api-CESGtpbH.esm.js";
+import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-D6-e4vok.esm.js";
+import { t as endpoints } from "./endpoints-CnN3SyDa.esm.js";
+import { a as fromPromise, c as createManager, r as assign, s as createActor, t as setup } from "./xstate.esm-B70JrNqo.esm.js";
+
+//#region src/modules/watchlist-for-business/watchlistForBusinessServices.ts
+async function submitWatchlistForBusiness(data, signal) {
+	const res = await api.post(endpoints.watchlistForBusinessSubmit, data, { signal });
+	if (!res.ok) throw new Error(`POST ${endpoints.watchlistForBusinessSubmit} failed: ${res.status} ${res.statusText}`);
+	return res.data;
+}
+
+//#endregion
+//#region src/modules/watchlist-for-business/watchlistForBusinessStateMachine.ts
+const DEFAULT_COUNTRY = "US";
+function computeIsValid(businessName) {
+	return businessName.trim().length > 0;
+}
+const watchlistForBusinessMachine = setup({
+	types: {
+		context: {},
+		events: {}
+	},
+	actors: { submitWatchlistForBusiness: fromPromise(async ({ input, signal }) => {
+		await submitWatchlistForBusiness(input, signal);
+	}) },
+	actions: {
+		setCountry: assign(({ event }) => {
+			const { country } = event;
+			return { country };
+		}),
+		setBusinessName: assign(({ event }) => {
+			const { value } = event;
+			return {
+				businessName: value,
+				isValid: computeIsValid(value)
+			};
+		})
+	},
+	guards: { isValid: ({ context }) => context.isValid }
+}).createMachine({
+	id: "watchlist-for-business",
+	initial: "idle",
+	context: {
+		country: DEFAULT_COUNTRY,
+		businessName: "",
+		isValid: false
+	},
+	states: {
+		idle: { on: { LOAD: { target: "form" } } },
+		form: { on: {
+			SET_COUNTRY: { actions: "setCountry" },
+			SET_BUSINESS_NAME: { actions: "setBusinessName" },
+			SUBMIT: {
+				target: "submitting",
+				guard: "isValid"
+			}
+		} },
+		submitting: { invoke: {
+			id: "submitWatchlistForBusiness",
+			src: "submitWatchlistForBusiness",
+			input: ({ context }) => ({
+				countryCodes: [context.country],
+				businessName: context.businessName
+			}),
+			onDone: { target: "success" },
+			onError: { target: "finished" }
+		} },
+		success: { after: { 3e3: { target: "finished" } } },
+		finished: { type: "final" }
+	}
+});
+
+//#endregion
+//#region src/modules/watchlist-for-business/watchlistForBusinessActor.ts
+function createWatchlistForBusinessActor() {
+	return createActor(watchlistForBusinessMachine).start();
+}
+
+//#endregion
+//#region src/modules/watchlist-for-business/watchlistForBusinessManager.ts
+function mapState(snapshot) {
+	const typedSnapshot = snapshot;
+	const { context } = typedSnapshot;
+	if (typedSnapshot.matches("form")) return {
+		status: "form",
+		country: context.country,
+		businessName: context.businessName,
+		isValid: context.isValid
+	};
+	if (typedSnapshot.matches("submitting")) return { status: "submitting" };
+	if (typedSnapshot.matches("success")) return { status: "success" };
+	if (typedSnapshot.matches("finished")) return { status: "finished" };
+	return { status: "idle" };
+}
+function createApi({ actor }) {
+	return {
+		load() {
+			actor.send({ type: "LOAD" });
+		},
+		setCountry(country) {
+			actor.send({
+				type: "SET_COUNTRY",
+				country
+			});
+		},
+		setBusinessName(value) {
+			actor.send({
+				type: "SET_BUSINESS_NAME",
+				value
+			});
+		},
+		submit() {
+			actor.send({ type: "SUBMIT" });
+		}
+	};
+}
+/**
+* Creates a watchlist-for-business manager for headless or UI-driven usage.
+*
+* On API error the module completes silently (fire-and-forget).
+*
+* @example Headless usage
+* ```typescript
+* import { createWatchlistForBusinessManager } from '@incodetech/core/watchlist-for-business';
+*
+* const manager = createWatchlistForBusinessManager();
+* manager.subscribe((state) => {
+*   if (state.status === 'finished') console.log('Done');
+* });
+* manager.load();
+* manager.setCountry('MX');
+* manager.setBusinessName('Acme Corp');
+* manager.submit();
+* manager.stop();
+* ```
+*/
+function createWatchlistForBusinessManager() {
+	return createManager({
+		actor: createWatchlistForBusinessActor(),
+		mapState,
+		createApi,
+		instrumentation: createManagerInstrumentation(eventModuleNames.watchlistForBusiness)
+	});
+}
+
+//#endregion
+export { createWatchlistForBusinessManager, watchlistForBusinessMachine };