@incodetech/core 2.0.0-alpha.1 → 2.0.0-alpha.11

package/dist/index.d.ts

@@ -0,0 +1,226 @@
+import { n as warmupWasm, t as WasmPipeline } from "./warmup-Cijuyvoc.js";
+import { n as PermissionStatus, t as PermissionResult } from "./types-Dif6MQmX.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 };

package/dist/index.esm.js

@@ -0,0 +1,156 @@
+import { a as resetApi, c as WasmUtilProvider, n as api, o as setClient, r as getApi, s as setToken, t as endpoints, u as warmupWasm, x as createApi_default } from "./endpoints-B0ltwtb5.esm.js";
+import "./getBrowser-CLEzz0Hi.esm.js";
+import { i as getBrowser, n as requestPermission, r as getDeviceClass, t as checkPermission } from "./permissionServices-BhD0KxsO.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 };