@incodetech/core 0.0.0-dev-20260313-486e658 → 0.0.0-dev-20260313-bc2dab4

package/dist/emailManager-e7j__XBB.esm.js

@@ -0,0 +1,486 @@
+import { d as addEvent, n as eventModuleNames, r as eventScreenNames } from "./events-3HzCcoEy.esm.js";
+import { A as createManager, g as BrowserTimerProvider } from "./src-BmVrWkLJ.esm.js";
+import { a as createActor, i as fromPromise, n as assign, r as fromCallback, t as setup } from "./xstate.esm-CcoTezCZ.esm.js";
+import { t as api } from "./api-C2uzxrpN.esm.js";
+import { t as endpoints } from "./endpoints-IAlXA1zN.esm.js";
+
+//#region src/modules/email/emailServices.ts
+async function fetchEmail(signal) {
+	const res = await api.get(endpoints.getEmail, { signal });
+	if (!res.ok) throw new Error(`GET ${endpoints.getEmail} failed: ${res.status} ${res.statusText}`);
+	return res.data;
+}
+async function addEmail(params, signal) {
+	const res = await api.post(endpoints.email, { email: params.email }, { signal });
+	if (!res.ok) throw new Error(`POST ${endpoints.email} failed: ${res.status} ${res.statusText}`);
+	return res.data;
+}
+async function sendEmailOtp(signal) {
+	const res = await api.get(`${endpoints.sendSmsOtp}?communicationchannel=EMAIL`, { signal });
+	if (!res.ok) throw new Error(`GET ${endpoints.sendSmsOtp} failed: ${res.status} ${res.statusText}`);
+}
+async function verifyEmailOtp(code, signal) {
+	const res = await api.get(`${endpoints.compareOtp}?code=${code}&channel=EMAIL`, { signal });
+	if (!res.ok) throw new Error(`GET ${endpoints.compareOtp} failed: ${res.status} ${res.statusText}`);
+	return res.data;
+}
+
+//#endregion
+//#region src/modules/email/emailStateMachine.ts
+const RESEND_TIMER_SECONDS = 30;
+const emailMachine = setup({
+	types: {
+		context: {},
+		events: {},
+		input: {}
+	},
+	actors: {
+		fetchEmail: fromPromise(async ({ signal }) => {
+			return fetchEmail(signal);
+		}),
+		submitEmail: fromPromise(async ({ input, signal }) => {
+			return addEmail({ email: input.email }, signal);
+		}),
+		sendOtp: fromPromise(async ({ signal }) => {
+			return sendEmailOtp(signal);
+		}),
+		verifyOtp: fromPromise(async ({ input, signal }) => {
+			return verifyEmailOtp(input.code, signal);
+		}),
+		resendTimer: fromCallback(({ sendBack }) => {
+			const timer = BrowserTimerProvider.getInstance();
+			let seconds = RESEND_TIMER_SECONDS;
+			const interval = timer.setInterval(() => {
+				seconds -= 1;
+				sendBack({ type: "TICK" });
+				if (seconds <= 0) timer.clearInterval(interval);
+			}, 1e3);
+			return () => timer.clearInterval(interval);
+		})
+	},
+	actions: {
+		setPrefilledEmail: assign(({ event }) => {
+			const email = event.output.email;
+			return {
+				prefilledEmail: email,
+				email
+			};
+		}),
+		setEmail: assign(({ event }) => {
+			const e = event;
+			return {
+				email: e.email,
+				isValid: e.isValid,
+				emailError: e.isValid ? void 0 : "Invalid email address"
+			};
+		}),
+		setEmailError: assign(({ event }) => ({ emailError: String(event.error) })),
+		setError: assign(({ event }) => ({ error: String(event.error) })),
+		clearError: assign({ error: () => void 0 }),
+		clearEmailError: assign({ emailError: () => void 0 }),
+		setOtpCode: assign(({ event }) => ({
+			otpCode: event.code,
+			otpError: void 0
+		})),
+		setOtpError: assign(({ context, event }) => ({
+			otpError: String(event.error),
+			attemptsRemaining: context.attemptsRemaining - 1
+		})),
+		clearOtpError: assign({
+			otpError: () => void 0,
+			otpCode: () => ""
+		}),
+		startResendTimer: assign({
+			resendTimer: () => RESEND_TIMER_SECONDS,
+			resendTimerActive: () => true
+		}),
+		tickResendTimer: assign(({ context }) => {
+			const newTimer = Math.max(0, context.resendTimer - 1);
+			return {
+				resendTimer: newTimer,
+				resendTimerActive: newTimer > 0
+			};
+		}),
+		stopResendTimer: assign({ resendTimerActive: () => false }),
+		resetContext: assign(({ context }) => ({
+			config: context.config,
+			email: "",
+			isValid: false,
+			emailError: void 0,
+			prefilledEmail: void 0,
+			error: void 0,
+			otpCode: "",
+			otpError: void 0,
+			attemptsRemaining: context.config.maxOtpAttempts ?? 3,
+			resendTimer: 0,
+			resendTimerActive: false
+		})),
+		sendEmailSubmitEvent: () => {
+			addEvent({
+				code: "continue",
+				module: eventModuleNames.email,
+				screen: eventScreenNames.emailInput
+			});
+		}
+	},
+	guards: {
+		hasPrefill: ({ context }) => context.config.prefill,
+		hasOtpVerification: ({ context }) => context.config.otpVerification,
+		isValidEmail: ({ context }) => context.isValid,
+		hasAttemptsRemaining: ({ context }) => context.attemptsRemaining > 0,
+		canResend: ({ context }) => !context.resendTimerActive
+	}
+}).createMachine({
+	id: "email",
+	initial: "idle",
+	context: ({ input }) => ({
+		config: input.config,
+		email: "",
+		isValid: false,
+		emailError: void 0,
+		prefilledEmail: void 0,
+		error: void 0,
+		otpCode: "",
+		otpError: void 0,
+		attemptsRemaining: input.config.maxOtpAttempts ?? 3,
+		resendTimer: 0,
+		resendTimerActive: false
+	}),
+	states: {
+		idle: { on: { LOAD: [{
+			target: "loadingPrefill",
+			guard: "hasPrefill"
+		}, { target: "inputting" }] } },
+		loadingPrefill: { invoke: {
+			id: "fetchEmail",
+			src: "fetchEmail",
+			onDone: {
+				target: "inputting",
+				actions: "setPrefilledEmail"
+			},
+			onError: { target: "inputting" }
+		} },
+		inputting: {
+			entry: "clearEmailError",
+			on: {
+				EMAIL_CHANGED: { actions: "setEmail" },
+				SUBMIT: {
+					target: "submitting",
+					guard: "isValidEmail"
+				}
+			}
+		},
+		submitting: { invoke: {
+			id: "submitEmail",
+			src: "submitEmail",
+			input: ({ context }) => ({ email: context.email }),
+			onDone: [{
+				target: "sendingOtp",
+				guard: "hasOtpVerification",
+				actions: "sendEmailSubmitEvent"
+			}, {
+				target: "finished",
+				actions: "sendEmailSubmitEvent"
+			}],
+			onError: {
+				target: "inputting",
+				actions: "setEmailError"
+			}
+		} },
+		sendingOtp: { invoke: {
+			id: "sendOtp",
+			src: "sendOtp",
+			onDone: { target: "awaitingOtp" },
+			onError: {
+				target: "awaitingOtp",
+				actions: "setError"
+			}
+		} },
+		awaitingOtp: {
+			entry: "startResendTimer",
+			invoke: {
+				id: "resendTimer",
+				src: "resendTimer"
+			},
+			on: {
+				TICK: { actions: "tickResendTimer" },
+				OTP_CHANGED: { actions: "setOtpCode" },
+				VERIFY_OTP: { target: "verifyingOtp" },
+				RESEND_OTP: {
+					target: "sendingOtp",
+					guard: "canResend"
+				},
+				BACK: { target: "inputting" }
+			}
+		},
+		verifyingOtp: { invoke: {
+			id: "verifyOtp",
+			src: "verifyOtp",
+			input: ({ context }) => ({ code: context.otpCode }),
+			onDone: [
+				{
+					target: "finished",
+					guard: ({ event }) => event.output.success === true
+				},
+				{
+					target: "otpError",
+					guard: "hasAttemptsRemaining",
+					actions: assign(({ context }) => ({
+						otpError: "Invalid OTP code",
+						attemptsRemaining: context.attemptsRemaining - 1
+					}))
+				},
+				{
+					target: "error",
+					actions: assign({ error: () => "Maximum OTP attempts exceeded" })
+				}
+			],
+			onError: [{
+				target: "otpError",
+				guard: "hasAttemptsRemaining",
+				actions: "setOtpError"
+			}, {
+				target: "error",
+				actions: "setError"
+			}]
+		} },
+		otpError: { on: {
+			OTP_CHANGED: {
+				target: "awaitingOtp",
+				actions: "setOtpCode"
+			},
+			RESEND_OTP: {
+				target: "sendingOtp",
+				guard: "canResend"
+			},
+			BACK: { target: "inputting" }
+		} },
+		finished: { type: "final" },
+		error: { on: { RESET: {
+			target: "idle",
+			actions: "resetContext"
+		} } }
+	}
+});
+
+//#endregion
+//#region src/modules/email/emailActor.ts
+function createEmailActor(options) {
+	return createActor(emailMachine, { input: { config: options.config } }).start();
+}
+
+//#endregion
+//#region src/modules/email/emailManager.ts
+/**
+* @module @incodetech/core/email
+*
+* Email verification module for the Incode Web SDK.
+* Supports both headless (programmatic) and UI-driven usage patterns.
+*
+* ## Headless Usage
+*
+* The email manager can be used entirely without UI for backend integrations,
+* custom UI implementations, or automated workflows.
+*
+* @example Basic headless email verification with OTP
+* ```typescript
+* import { createEmailManager } from '@incodetech/core/email';
+* import { setup } from '@incodetech/core';
+*
+* // 1. Configure the SDK (required before using any module)
+* setup({ apiURL: 'https://api.example.com', token: 'your-token' });
+*
+* // 2. Create the email manager
+* const emailManager = createEmailManager({
+*   config: {
+*     otpVerification: true,
+*     otpExpirationInMinutes: 5,
+*     prefill: false,
+*   },
+* });
+*
+* // 3. Subscribe to state changes (optional but recommended)
+* emailManager.subscribe((state) => {
+*   console.log('Email state:', state.status);
+*   if (state.status === 'finished') {
+*     console.log('Email verified successfully!');
+*   }
+*   if (state.status === 'error') {
+*     console.error('Error:', state.error);
+*   }
+* });
+*
+* // 4. Start the flow
+* emailManager.load();
+*
+* // 5. When state is 'inputting', set the email address
+* emailManager.setEmail('user@example.com', true);
+*
+* // 6. Submit the email address
+* emailManager.submit();
+*
+* // 7. When state is 'awaitingOtp', submit the OTP code
+* emailManager.submitOtp('ABC123');
+*
+* // 8. Clean up when done
+* emailManager.stop();
+* ```
+*
+* @example Polling-based headless usage
+* ```typescript
+* const emailManager = createEmailManager({ config });
+*
+* emailManager.load();
+*
+* // Poll for state changes
+* const interval = setInterval(() => {
+*   const state = emailManager.getState();
+*
+*   switch (state.status) {
+*     case 'inputting':
+*       emailManager.setEmail('user@example.com', true);
+*       emailManager.submit();
+*       break;
+*     case 'awaitingOtp':
+*       // Get OTP from user or external source
+*       emailManager.submitOtp(otpCode);
+*       break;
+*     case 'finished':
+*       clearInterval(interval);
+*       emailManager.stop();
+*       break;
+*     case 'error':
+*       clearInterval(interval);
+*       console.error(state.error);
+*       emailManager.stop();
+*       break;
+*   }
+* }, 100);
+* ```
+*/
+function mapState(snapshot) {
+	const typedSnapshot = snapshot;
+	const { context } = typedSnapshot;
+	if (typedSnapshot.matches("idle")) return { status: "idle" };
+	if (typedSnapshot.matches("loadingPrefill")) return { status: "loadingPrefill" };
+	if (typedSnapshot.matches("inputting")) return {
+		status: "inputting",
+		prefilledEmail: context.prefilledEmail,
+		emailError: context.emailError
+	};
+	if (typedSnapshot.matches("submitting")) return { status: "submitting" };
+	if (typedSnapshot.matches("sendingOtp")) return { status: "sendingOtp" };
+	if (typedSnapshot.matches("awaitingOtp")) return {
+		status: "awaitingOtp",
+		resendTimer: context.resendTimer,
+		canResend: !context.resendTimerActive,
+		attemptsRemaining: context.attemptsRemaining
+	};
+	if (typedSnapshot.matches("verifyingOtp")) return { status: "verifyingOtp" };
+	if (typedSnapshot.matches("otpError")) return {
+		status: "otpError",
+		error: context.otpError ?? "Invalid OTP code",
+		attemptsRemaining: context.attemptsRemaining
+	};
+	if (typedSnapshot.matches("finished")) return { status: "finished" };
+	if (typedSnapshot.matches("error")) return {
+		status: "error",
+		error: context.error ?? "An error occurred"
+	};
+	return { status: "idle" };
+}
+function createApi({ actor }) {
+	return {
+		load() {
+			actor.send({ type: "LOAD" });
+		},
+		setEmail(email, isValid) {
+			actor.send({
+				type: "EMAIL_CHANGED",
+				email,
+				isValid
+			});
+		},
+		submit() {
+			actor.send({ type: "SUBMIT" });
+		},
+		setOtpCode(code) {
+			actor.send({
+				type: "OTP_CHANGED",
+				code
+			});
+		},
+		submitOtp(code) {
+			actor.send({
+				type: "OTP_CHANGED",
+				code
+			});
+			actor.send({ type: "VERIFY_OTP" });
+		},
+		resendOtp() {
+			actor.send({ type: "RESEND_OTP" });
+		},
+		back() {
+			actor.send({ type: "BACK" });
+		},
+		reset() {
+			actor.send({ type: "RESET" });
+		}
+	};
+}
+/**
+* Creates an email verification manager for headless or UI-driven usage.
+*
+* The manager provides a state machine-based API for email address verification
+* with optional OTP (one-time password) verification.
+*
+* @param options - Configuration options
+* @param options.config - Email verification configuration
+* @param options.config.otpVerification - Whether to require OTP verification
+* @param options.config.otpExpirationInMinutes - How long the OTP is valid
+* @param options.config.prefill - Whether to fetch a pre-filled email address
+* @param options.config.maxOtpAttempts - Maximum OTP verification attempts (default: 3)
+*
+* @returns Email manager with state, API methods, and subscription
+*
+* @example Headless usage
+* ```typescript
+* const manager = createEmailManager({
+*   config: { otpVerification: true, otpExpirationInMinutes: 5, prefill: false },
+* });
+*
+* manager.subscribe((state) => console.log(state.status));
+* manager.load();
+* manager.setEmail('user@example.com', true);
+* manager.submit();
+* // ... wait for 'awaitingOtp' state ...
+* manager.submitOtp('ABC123');
+* manager.stop();
+* ```
+*
+* @example With React/Preact UI hook
+* ```tsx
+* const [state, manager] = useManager(() => createEmailManager({ config }));
+*
+* if (state.status === 'inputting') {
+*   return <input onChange={(e) => manager.setEmail(e.target.value, true)} />;
+* }
+* ```
+*/
+function createEmailManager(options) {
+	return createManager({
+		actor: createEmailActor(options),
+		mapState,
+		createApi
+	});
+}
+function createEmailManagerFromActor(actor) {
+	return createManager({
+		actor,
+		mapState,
+		createApi
+	});
+}
+
+//#endregion
+export { createEmailManagerFromActor as n, emailMachine as r, createEmailManager as t };

package/dist/{events-b4_xvENs.esm.js → events-3HzCcoEy.esm.js}

@@ -1,5 +1,5 @@
-import { i as isApiConfigured, r as getToken, t as api } from "./api-3fZO5bmj.esm.js";
-import { t as endpoints } from "./endpoints-5sPFFmaB.esm.js";
+import { i as isApiConfigured, r as getToken, t as api } from "./api-C2uzxrpN.esm.js";
+import { t as endpoints } from "./endpoints-IAlXA1zN.esm.js";
 
 //#region ../infra/src/capabilities/IBrowserEnvironmentCapability.ts
 function getTimestamp() {

package/dist/extensibility.d.ts

@@ -0,0 +1,95 @@
+import { S as CaptureIdResponse, i as createIdCaptureManagerFromActor, n as IdCaptureState, t as IdCaptureManager } from "./idCaptureManager-D8FwP0TW.js";
+import { a as IStorageCapability } from "./deepsightService-UhtHJCFb.js";
+import { C as WasmUtilConfig, S as VirtualCameraCheckOutput, b as BaseWasmProvider, c as FaceCaptureEvent, f as SendFaceImageResponse, l as FaceCaptureInput, n as FaceCaptureManagerState, s as FaceCaptureContext, t as FaceCaptureManager, u as faceCaptureMachine, x as IWasmUtilCapability } from "./faceCaptureManagerFactory-CiQWYHp2.js";
+import "./warmup-Bp_1oXoL.js";
+import "./Manager-CXnC-tN_.js";
+import "./camera-DDn9ILon.js";
+import { n as createActor } from "./Actor-BAf9LRYf.js";
+import { r as fromPromise } from "./StateMachine-DJpZF_HP.js";
+import "./types-BugcSDaO.js";
+import "./types-C9Jo2XOb.js";
+import { a as ProcessFaceResponse, i as createSelfieManagerFromActor, n as SelfieState, t as SelfieManager } from "./selfieManager-Czysy-lv.js";
+import { i as createAuthenticationManagerFromActor, n as AuthenticationState, t as AuthenticationManager } from "./authenticationManager-DQL9XsaI.js";
+import { i as createEmailManagerFromActor, n as EmailState, t as EmailManager } from "./emailManager-DZeOYBQ6.js";
+import { i as createPhoneManagerFromActor, n as PhoneState, t as PhoneManager } from "./phoneManager-BsamACjL.js";
+
+//#region ../infra/src/providers/browser/BrowserStorageProvider.d.ts
+/**
+ * Browser-based storage provider wrapping localStorage.
+ * Handles JSON serialization/deserialization automatically.
+ */
+declare class BrowserStorageProvider implements IStorageCapability {
+  /**
+   * Retrieves a value from localStorage.
+   * @param key - The storage key
+   * @returns The stored value or null if not found
+   * @throws Error if stored value is invalid JSON
+   */
+  get<T>(key: string): Promise<T | null>;
+  /**
+   * Stores a value in localStorage.
+   * @param key - The storage key
+   * @param value - The value to store (will be serialized as JSON)
+   * @throws Error if value cannot be serialized or quota is exceeded
+   */
+  set<T>(key: string, value: T): Promise<void>;
+  /**
+   * Removes a value from localStorage.
+   * @param key - The storage key to remove
+   */
+  remove(key: string): Promise<void>;
+  /**
+   * Clears all values from localStorage.
+   */
+  clear(): Promise<void>;
+}
+//#endregion
+//#region ../infra/src/providers/wasm/WasmUtilProvider.d.ts
+declare class WasmUtilProvider extends BaseWasmProvider implements IWasmUtilCapability {
+  private static instance;
+  private static initPromise;
+  static getInstance(): Promise<WasmUtilProvider>;
+  static resetInstance(): void;
+  constructor();
+  initialize(config: WasmUtilConfig): Promise<void>;
+  processFrame(_image: ImageData): Promise<void>;
+  encryptImage(image: string): string;
+  setSdkVersion(version: string): void;
+  setSdkPlatform(platform: string): void;
+  setDeviceInfo(deviceInfo: object, overrideExisting?: boolean): void;
+  setBrowserInfo(browserInfo: object, overrideExisting?: boolean): void;
+  setCameraInfo(cameraInfo: object, overrideExisting?: boolean): void;
+  setMotionStatus(status: string): void;
+  setBackgroundMode(backgroundMode: boolean): void;
+  setZc(zc: string): void;
+  setInspectorOpened(opened: boolean): void;
+  getMetadata(): string;
+  analyzeFrame(image: ImageData): Promise<void>;
+  getCheck(): string;
+  getPipelineState(): string;
+  estimatePerformance(): string;
+  isVirtualCamera(label: string | null): boolean;
+  prc(): Promise<void>;
+  poc(output: VirtualCameraCheckOutput): Promise<void>;
+  ckvcks(data: ArrayBuffer): void;
+  getVersions(): Promise<unknown>;
+}
+//#endregion
+//#region src/modules/authentication/authenticationUploadService.d.ts
+type AuthenticationUploadResponse = {
+  overallStatus: 'PASS' | 'FAIL';
+  captureAttemptsLimit: {
+    max: number;
+    remaining: number;
+  };
+  candidate: string;
+  error: {
+    name: string;
+    message: string;
+  };
+  imageBase64?: string;
+  selfieEncryptedBase64?: string;
+  metadata?: string;
+};
+//#endregion
+export { type AuthenticationManager, type AuthenticationState, type AuthenticationUploadResponse, BrowserStorageProvider, type CaptureIdResponse, type EmailManager, type EmailState, type FaceCaptureContext, type FaceCaptureEvent, type FaceCaptureInput, type FaceCaptureManager, type FaceCaptureManagerState, type IdCaptureManager, type IdCaptureState, type PhoneManager, type PhoneState, type ProcessFaceResponse, type SelfieManager, type SelfieState, type SendFaceImageResponse, WasmUtilProvider, createActor, createAuthenticationManagerFromActor, createEmailManagerFromActor, createIdCaptureManagerFromActor, createPhoneManagerFromActor, createSelfieManagerFromActor, faceCaptureMachine, fromPromise };

package/dist/extensibility.esm.js

@@ -0,0 +1,17 @@
+import "./events-3HzCcoEy.esm.js";
+import "./backCameraStream-4aLwsDOv.esm.js";
+import { _ as BrowserStorageProvider, a as WasmUtilProvider } from "./src-BmVrWkLJ.esm.js";
+import { a as createActor, i as fromPromise } from "./xstate.esm-CcoTezCZ.esm.js";
+import "./streamingEvents-Cw6kqXEh.esm.js";
+import "./deepsightService-BgqD33AH.esm.js";
+import "./api-C2uzxrpN.esm.js";
+import "./endpoints-IAlXA1zN.esm.js";
+import { n as createIdCaptureManagerFromActor } from "./idCaptureManager-B9BsU7-M.esm.js";
+import "./stats-kLtQIgsA.esm.js";
+import { n as faceCaptureMachine } from "./faceCaptureSetup-CF9TJlsc.esm.js";
+import { n as createAuthenticationManagerFromActor } from "./authenticationManager-4j4j8ac9.esm.js";
+import { n as createEmailManagerFromActor } from "./emailManager-e7j__XBB.esm.js";
+import { n as createSelfieManagerFromActor } from "./selfieManager-ByV0akn-.esm.js";
+import { n as createPhoneManagerFromActor } from "./phoneManager-B6fNmxhw.esm.js";
+
+export { BrowserStorageProvider, WasmUtilProvider, createActor, createAuthenticationManagerFromActor, createEmailManagerFromActor, createIdCaptureManagerFromActor, createPhoneManagerFromActor, createSelfieManagerFromActor, faceCaptureMachine, fromPromise };

package/dist/face-match.d.ts

@@ -1,4 +1,4 @@
-import { t as Manager } from "./Manager-CG5CQ1kY.js";
+import { t as Manager } from "./Manager-CXnC-tN_.js";
 
 //#region src/modules/face-match/types.d.ts
 

package/dist/face-match.esm.js

@@ -1,8 +1,8 @@
-import { d as addEvent, n as eventModuleNames, r as eventScreenNames } from "./events-b4_xvENs.esm.js";
-import { A as createManager } from "./src-D3v6I2la.esm.js";
-import { a as createActor, i as fromPromise, n as assign, t as setup } from "./xstate.esm-07M59Cte.esm.js";
-import { t as api } from "./api-3fZO5bmj.esm.js";
-import { t as endpoints } from "./endpoints-5sPFFmaB.esm.js";
+import { d as addEvent, n as eventModuleNames, r as eventScreenNames } from "./events-3HzCcoEy.esm.js";
+import { A as createManager } from "./src-BmVrWkLJ.esm.js";
+import { a as createActor, i as fromPromise, n as assign, t as setup } from "./xstate.esm-CcoTezCZ.esm.js";
+import { t as api } from "./api-C2uzxrpN.esm.js";
+import { t as endpoints } from "./endpoints-IAlXA1zN.esm.js";
 
 //#region src/modules/face-match/faceMatchServices.ts
 /**