@incodetech/core 2.0.0-alpha.8 → 2.0.0-rc.0

package/dist/index-BcRG8rtJ.d.ts

@@ -0,0 +1,97 @@
+import { n as Flow } from "./types-BP1m8VRw.js";
+import { t as FinishStatus } from "./flowCompletionService-DhkT4SRY.js";
+
+//#region src/internal/flow-events/flowEvents.d.ts
+type FlowStartedEvent = {
+  type: 'flow.started';
+  interviewId?: string;
+  timestamp: number;
+};
+type FlowReadyEvent = {
+  type: 'flow.ready';
+  interviewId?: string;
+  flowId?: string;
+  payload: {
+    flow: Flow;
+    steps: string[];
+    currentStep?: string;
+    currentStepIndex: number;
+  };
+  timestamp: number;
+};
+type FlowCompletedEvent = {
+  type: 'flow.completed';
+  interviewId?: string;
+  flowId?: string;
+  payload?: FinishStatus;
+  timestamp: number;
+};
+type FlowErrorEvent = {
+  type: 'flow.error';
+  interviewId?: string;
+  flowId?: string;
+  error: string;
+  timestamp: number;
+};
+type FlowClosedEvent = {
+  type: 'flow.closed';
+  interviewId?: string;
+  flowId?: string;
+  timestamp: number;
+};
+type FlowModuleStartedEvent = {
+  type: 'flow.module.started';
+  interviewId?: string;
+  flowId?: string;
+  module: string;
+  payload: {
+    moduleIndex?: number;
+    totalModules?: number;
+  };
+  timestamp: number;
+};
+type FlowModuleCompletedEvent = {
+  type: 'flow.module.completed';
+  interviewId?: string;
+  flowId?: string;
+  module: string;
+  payload: {
+    moduleIndex?: number;
+    totalModules?: number;
+  };
+  timestamp: number;
+};
+/**
+ * Curated flow event for consumers that need stable integration milestones.
+ *
+ * This local-only stream covers high-level flow state changes such as loading,
+ * readiness, module changes, completion, errors, and closure. For raw analytics
+ * events such as `screenOpened`, `elementClicked`, and
+ * `captureAttemptFinished`, use `Event` from `@incodetech/core/events`.
+ */
+type FlowEvent = FlowStartedEvent | FlowReadyEvent | FlowCompletedEvent | FlowErrorEvent | FlowClosedEvent | FlowModuleStartedEvent | FlowModuleCompletedEvent;
+type FlowEventListener = (event: FlowEvent) => void;
+/**
+ * Manager API for subscribing to curated flow milestones emitted by that
+ * specific manager instance.
+ *
+ * For raw SDK analytics events such as `screenOpened`, `elementClicked`, and
+ * `captureAttemptFinished`, use `subscribeEvent` from `@incodetech/core/events`.
+ */
+type FlowEventSubscribable = {
+  /**
+   * Subscribes to curated flow milestones for this manager instance.
+   *
+   * Use this local-only stream for product and integration milestones such as
+   * `flow.started`, `flow.ready`, `flow.module.started`,
+   * `flow.module.completed`, `flow.completed`, and `flow.error`.
+   *
+   * This stream does not queue events or post to the analytics API.
+   *
+   * @param listener - Callback function that receives each flow event.
+   * @returns Unsubscribe function to remove the listener.
+   */
+  subscribeFlowEvent(listener: FlowEventListener): () => void;
+};
+//#endregion
+export { FlowEventListener as a, FlowModuleStartedEvent as c, FlowEvent as i, FlowReadyEvent as l, FlowCompletedEvent as n, FlowEventSubscribable as o, FlowErrorEvent as r, FlowModuleCompletedEvent as s, FlowClosedEvent as t, FlowStartedEvent as u };

package/dist/index.d.ts

@@ -1,226 +1,3 @@
-import { n as warmupWasm, t as WasmPipeline } from "./warmup-CEJTfxQr.js";
-import { n as PermissionStatus, t as PermissionResult } from "./types-iZi2rawo.js";
-
-//#region ../infra/src/http/types.d.ts
-type CreateApiConfig = {
-  apiURL: string;
-  customHeaders?: Record<string, string>;
-  timeout?: number;
-};
-type RequestConfig = {
-  method?: string;
-  url: string;
-  headers?: Record<string, string>;
-  query?: Record<string, string | number | boolean | undefined>;
-  params?: Record<string, string | number | boolean | undefined>;
-  body?: unknown;
-  signal?: AbortSignal;
-  timeout?: number;
-  parse?: 'json' | 'text' | 'blob' | 'arrayBuffer' | 'response';
-};
-type HttpResponse<T = unknown> = {
-  ok: boolean;
-  status: number;
-  statusText: string;
-  url: string;
-  headers: Record<string, string>;
-  data: T;
-};
-type HttpClient = {
-  defaults: {
-    baseURL: string;
-    headers: Record<string, string>;
-  };
-  request<T = unknown>(config: RequestConfig): Promise<HttpResponse<T>>;
-  get<T = unknown>(url: string, config?: Omit<RequestConfig, 'method' | 'url'>): Promise<HttpResponse<T>>;
-  post<T = unknown>(url: string, body?: unknown, config?: Omit<RequestConfig, 'method' | 'url' | 'body'>): Promise<HttpResponse<T>>;
-  put<T = unknown>(url: string, body?: unknown, config?: Omit<RequestConfig, 'method' | 'url' | 'body'>): Promise<HttpResponse<T>>;
-  patch<T = unknown>(url: string, body?: unknown, config?: Omit<RequestConfig, 'method' | 'url' | 'body'>): Promise<HttpResponse<T>>;
-  delete<T = unknown>(url: string, config?: Omit<RequestConfig, 'method' | 'url'>): Promise<HttpResponse<T>>;
-  head<T = unknown>(url: string, config?: Omit<RequestConfig, 'method' | 'url'>): Promise<HttpResponse<T>>;
-  options<T = unknown>(url: string, config?: Omit<RequestConfig, 'method' | 'url'>): Promise<HttpResponse<T>>;
-  setHeader(name: string, value: string): void;
-};
-//#endregion
-//#region ../infra/src/http/createApi.d.ts
-declare const createApi: (config: CreateApiConfig) => HttpClient;
-//#endregion
-//#region src/internal/device/getBrowser.d.ts
-type Browser = 'chrome' | 'firefox' | 'safari' | 'edge' | 'other';
-declare function getBrowser(): Browser;
-//#endregion
-//#region src/internal/device/getDeviceClass.d.ts
-type DeviceClass = 'ios' | 'android' | 'desktop';
-declare function getDeviceClass(): DeviceClass;
-//#endregion
-//#region src/internal/http/api.d.ts
-type MethodConfig = {
-  headers?: Record<string, string>;
-  signal?: AbortSignal;
-  timeout?: number;
-  query?: Record<string, string | number | boolean | undefined>;
-};
-type ApiClient = {
-  get<T>(url: string, config?: MethodConfig): Promise<HttpResponse<T>>;
-  post<T>(url: string, data?: unknown, config?: MethodConfig): Promise<HttpResponse<T>>;
-  put<T>(url: string, data?: unknown, config?: MethodConfig): Promise<HttpResponse<T>>;
-  patch<T>(url: string, data?: unknown, config?: MethodConfig): Promise<HttpResponse<T>>;
-  delete<T>(url: string, config?: MethodConfig): Promise<HttpResponse<T>>;
-};
-declare function getApi(): HttpClient;
-declare const api: ApiClient;
-//#endregion
-//#region src/internal/permissions/permissionServices.d.ts
-/**
- * Checks the current camera permission state without prompting the user.
- */
-declare function checkPermission(): Promise<PermissionResult>;
-/**
- * Requests camera permission by attempting to access the camera, then immediately
- * stops the obtained stream. This function does not keep or return the stream.
- */
-declare function requestPermission(): Promise<PermissionResult>;
-//#endregion
-//#region src/internal/session/sessionService.d.ts
-type CreateSessionOptions = {
-  /** The configuration/flow ID from the Incode dashboard */
-  configurationId: string;
-  /** External ID to associate with this session */
-  externalId?: string;
-  /** External customer ID */
-  externalCustomerId?: string;
-  /** Language for the session (e.g., 'en-US', 'es-MX') */
-  language?: string;
-  /** Custom fields to attach to the session */
-  customFields?: Record<string, unknown>;
-  /** UUID for continuing an existing session */
-  uuid?: string;
-  /** Interview ID for continuing an existing interview */
-  interviewId?: string;
-};
-type Session = {
-  token: string;
-  interviewId: string;
-  uuid?: string;
-  regulationType?: string;
-  showMandatoryConsent?: boolean;
-};
-/**
- * Creates a new onboarding session.
- *
- * @param apiKey - The API key from the Incode dashboard
- * @param options - Session creation options
- * @param signal - Optional AbortSignal for request cancellation
- * @returns The created session with token
- *
- * @example
- * ```ts
- * const session = await createSession('your-api-key', {
- *   configurationId: 'your-flow-id',
- *   language: 'en-US',
- * });
- * console.log(session.token); // Use this token for subsequent API calls
- * ```
- */
-declare function createSession(apiKey: string, options: CreateSessionOptions, signal?: AbortSignal): Promise<Session>;
-//#endregion
-//#region src/setup.d.ts
-/**
- * WASM warmup configuration.
- */
-type WasmConfig = {
-  /** Path to the WASM binary */
-  wasmPath: string;
-  /** Path to the SIMD-optimized WASM binary (optional) */
-  wasmSimdPath?: string;
-  /** Path to the WASM glue code */
-  glueCodePath: string;
-  /** Whether to use SIMD optimizations (default: true) */
-  useSimd?: boolean;
-  /** Which pipelines to preload models for */
-  pipelines?: WasmPipeline[];
-  /**
-   * Base path for ML model files. Models will be loaded from `${modelsBasePath}/${modelFileName}`.
-   * If not provided, models are expected in a 'models' subdirectory relative to the WASM binary.
-   */
-  modelsBasePath?: string;
-};
-/**
- * Configuration options for the SDK setup.
- */
-type SetupOptions = {
-  /** The base URL for the API */
-  apiURL: string;
-  /** The session token for API requests (optional - can be set later or omitted for createSession calls) */
-  token?: string;
-  /** Custom headers to include in all requests */
-  customHeaders?: Record<string, string>;
-  /** Request timeout in milliseconds */
-  timeout?: number;
-  /** Optional WASM warmup config - if provided, preloads WASM and ML models */
-  wasm?: WasmConfig;
-};
-/**
- * Initializes the SDK with the provided configuration.
- * Must be called before using any SDK functionality.
- *
- * If `wasm` config is provided, this function becomes async and will
- * preload WASM binary and ML models. Otherwise, it's synchronous.
- *
- * @param options - Configuration options for the SDK
- *
- * @example
- * ```ts
- * import { setup, createSession } from '@incodetech/core';
- *
- * // Setup with API URL first (for session creation)
- * await setup({ apiURL: 'https://api.incode.com' });
- * const session = await createSession('api-key', { configurationId: 'flow-id' });
- *
- * // Basic setup with token
- * await setup({
- *   apiURL: 'https://api.incode.com',
- *   token: 'session-token',
- * });
- *
- * // Setup with WASM warmup
- * await setup({
- *   apiURL: 'https://api.incode.com',
- *   token: 'session-token',
- *   wasm: {
- *     wasmPath: '/wasm/ml-wasm.wasm',
- *     glueCodePath: '/wasm/ml-wasm.js',
- *     pipelines: ['selfie', 'idCapture'],
- *   },
- * });
- * ```
- */
-declare function setup(options: SetupOptions): Promise<void>;
-/**
- * Sets the WASM configuration without performing warmup.
- * Useful when WASM warmup is handled separately (e.g., conditionally based on flow).
- *
- * @param config - WASM configuration to store
- */
-declare function setWasmConfig(config: WasmConfig): void;
-/**
- * Initializes WasmUtilProvider with the stored WASM configuration.
- * Should be called after warmupWasm() completes when using conditional warmup.
- * This ensures image encryption works properly.
- *
- * @param config - Optional WASM configuration. If not provided, uses the stored config from setWasmConfig().
- * @throws Error if no config is provided and none is stored
- */
-declare function initializeWasmUtil(config?: WasmConfig): Promise<void>;
-/**
- * Checks if the SDK has been configured.
- *
- * @returns true if setup() has been called, false otherwise
- */
-declare function isConfigured(): boolean;
-/**
- * Resets the SDK configuration. Useful for testing.
- */
-declare function reset(): void;
-//#endregion
-export { type Browser, type CreateSessionOptions, type DeviceClass, type HttpClient, type PermissionResult, type PermissionStatus, type Session, type SetupOptions, type WasmConfig, type WasmPipeline, api, checkPermission as checkCameraPermission, createApi, createSession, getApi, getBrowser, getDeviceClass, initializeWasmUtil, isConfigured, requestPermission as requestCameraPermission, reset, setWasmConfig, setup, warmupWasm };
+import "./warmup-CEcppFiS.js";
+import { a as reset, i as isConfigured, s as setup, t as SetupOptions } from "./setup-C5AITV8m.js";
+export { type SetupOptions, isConfigured, reset, setup };

package/dist/index.esm.js

@@ -1,155 +1,12 @@
-import { i as getBrowser, n as requestPermission, r as getDeviceClass, t as checkPermission } from "./permissionServices-I6vX6DBy.esm.js";
-import { _ as createApi_default, a as setClient, i as resetApi, l as warmupWasm, n as api, o as setToken, r as getApi, s as WasmUtilProvider, t as endpoints } from "./endpoints-BSTFaHYo.esm.js";
+import { a as setup, n as isConfigured, r as reset } from "./setup-Buy-hyj4.esm.js";
+import "./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-BS-d_vuE.esm.js";
+import "./IpifyProvider-D7jx52AL.esm.js";
+import "./browserSimulation-gxD8cSpM.esm.js";
 
-//#region src/internal/session/sessionService.ts
-/**
-* Creates a new onboarding session.
-*
-* @param apiKey - The API key from the Incode dashboard
-* @param options - Session creation options
-* @param signal - Optional AbortSignal for request cancellation
-* @returns The created session with token
-*
-* @example
-* ```ts
-* const session = await createSession('your-api-key', {
-*   configurationId: 'your-flow-id',
-*   language: 'en-US',
-* });
-* console.log(session.token); // Use this token for subsequent API calls
-* ```
-*/
-async function createSession(apiKey, options, signal) {
-	const res = await getApi().post(endpoints.createSession, {
-		configurationId: options.configurationId,
-		externalId: options.externalId,
-		externalCustomerId: options.externalCustomerId,
-		language: options.language ?? "en-US",
-		customFields: options.customFields,
-		uuid: options.uuid ?? null,
-		interviewId: options.interviewId ?? null
-	}, {
-		headers: {
-			"x-api-key": apiKey,
-			"api-version": "1.0"
-		},
-		signal
-	});
-	if (!res.ok) throw new Error(`POST ${endpoints.createSession} failed: ${res.status} ${res.statusText}`);
-	return res.data;
-}
-
-//#endregion
-//#region src/setup.ts
-let wasmConfig;
-let configured = false;
-/**
-* Initializes the SDK with the provided configuration.
-* Must be called before using any SDK functionality.
-*
-* If `wasm` config is provided, this function becomes async and will
-* preload WASM binary and ML models. Otherwise, it's synchronous.
-*
-* @param options - Configuration options for the SDK
-*
-* @example
-* ```ts
-* import { setup, createSession } from '@incodetech/core';
-*
-* // Setup with API URL first (for session creation)
-* await setup({ apiURL: 'https://api.incode.com' });
-* const session = await createSession('api-key', { configurationId: 'flow-id' });
-*
-* // Basic setup with token
-* await setup({
-*   apiURL: 'https://api.incode.com',
-*   token: 'session-token',
-* });
-*
-* // Setup with WASM warmup
-* await setup({
-*   apiURL: 'https://api.incode.com',
-*   token: 'session-token',
-*   wasm: {
-*     wasmPath: '/wasm/ml-wasm.wasm',
-*     glueCodePath: '/wasm/ml-wasm.js',
-*     pipelines: ['selfie', 'idCapture'],
-*   },
-* });
-* ```
-*/
-async function setup(options) {
-	setClient(createApi_default({
-		apiURL: options.apiURL,
-		customHeaders: options.customHeaders,
-		timeout: options.timeout
-	}));
-	if (options.token) setToken(options.token);
-	configured = true;
-	if (options.wasm) {
-		await warmupWasm({
-			wasmPath: options.wasm.wasmPath,
-			wasmSimdPath: options.wasm.wasmSimdPath,
-			glueCodePath: options.wasm.glueCodePath,
-			useSimd: options.wasm.useSimd,
-			pipelines: options.wasm.pipelines,
-			modelsBasePath: options.wasm.modelsBasePath
-		});
-		await (await WasmUtilProvider.getInstance()).initialize({
-			wasmPath: options.wasm.wasmPath,
-			wasmSimdPath: options.wasm.wasmSimdPath,
-			glueCodePath: options.wasm.glueCodePath,
-			useSimd: options.wasm.useSimd,
-			pipelines: options.wasm.pipelines,
-			modelsBasePath: options.wasm.modelsBasePath
-		});
-	}
-}
-/**
-* Sets the WASM configuration without performing warmup.
-* Useful when WASM warmup is handled separately (e.g., conditionally based on flow).
-*
-* @param config - WASM configuration to store
-*/
-function setWasmConfig(config) {
-	wasmConfig = config;
-}
-/**
-* Initializes WasmUtilProvider with the stored WASM configuration.
-* Should be called after warmupWasm() completes when using conditional warmup.
-* This ensures image encryption works properly.
-*
-* @param config - Optional WASM configuration. If not provided, uses the stored config from setWasmConfig().
-* @throws Error if no config is provided and none is stored
-*/
-async function initializeWasmUtil(config) {
-	const wasmConfigToUse = config ?? wasmConfig;
-	if (!wasmConfigToUse) throw new Error("WASM config is required. Provide config parameter or call setWasmConfig() first.");
-	await (await WasmUtilProvider.getInstance()).initialize({
-		wasmPath: wasmConfigToUse.wasmPath,
-		wasmSimdPath: wasmConfigToUse.wasmSimdPath,
-		glueCodePath: wasmConfigToUse.glueCodePath,
-		useSimd: wasmConfigToUse.useSimd,
-		pipelines: wasmConfigToUse.pipelines,
-		modelsBasePath: wasmConfigToUse.modelsBasePath
-	});
-}
-/**
-* Checks if the SDK has been configured.
-*
-* @returns true if setup() has been called, false otherwise
-*/
-function isConfigured() {
-	return configured;
-}
-/**
-* Resets the SDK configuration. Useful for testing.
-*/
-function reset() {
-	resetApi();
-	configured = false;
-	WasmUtilProvider.resetInstance();
-}
-
-//#endregion
-export { api, checkPermission as checkCameraPermission, createApi_default as createApi, createSession, getApi, getBrowser, getDeviceClass, initializeWasmUtil, isConfigured, requestPermission as requestCameraPermission, reset, setWasmConfig, setup, warmupWasm };
+export { isConfigured, reset, setup };

package/dist/invokeOnCaptureCallback-rc6kBHo5.esm.js

@@ -0,0 +1,30 @@
+import { h as addEvent } from "./events-D6-e4vok.esm.js";
+
+//#region src/internal/captureOnly/invokeOnCaptureCallback.ts
+/**
+* Invokes an integrator-provided `onCapture` callback with the assembled
+* payload. Catches sync throws and rejected promises and reports them via
+* telemetry so an integration bug never escapes into the state machine —
+* the machine has already reached its terminal `finished` state by the
+* time this runs, so there is nothing to unwind.
+*/
+function invokeOnCaptureCallback(callback, payload, module) {
+	try {
+		const result = callback(payload);
+		if (result && typeof result.then === "function") result.catch((error) => {
+			reportError(error, module);
+		});
+	} catch (error) {
+		reportError(error, module);
+	}
+}
+function reportError(error, module) {
+	addEvent({
+		code: "onCaptureCallbackError",
+		module,
+		payload: { message: error instanceof Error ? error.message : String(error) }
+	});
+}
+
+//#endregion
+export { invokeOnCaptureCallback as t };