@incodetech/core 2.0.0 → 2.0.1-rc.0

package/dist/faceMatchStateMachine-DNFrxTFS.esm.js

@@ -0,0 +1,127 @@
+import { t as api } from "./api-CESGtpbH.esm.js";
+import { t as endpoints } from "./endpoints-CnN3SyDa.esm.js";
+import { a as fromPromise, r as assign, t as setup } from "./xstate.esm-B70JrNqo.esm.js";
+
+//#region src/modules/face-match/faceMatchServices.ts
+/**
+* Fetches cropped face images from the backend.
+*/
+async function fetchFaceMatchImages(signal) {
+	const res = await api.post(endpoints.getImagesV2, { images: [
+		"croppedFace",
+		"croppedIDFace",
+		"croppedAuthenticationSelfie"
+	] }, { signal });
+	if (!res.ok) throw new Error(`POST ${endpoints.getImagesV2} failed: ${res.status} ${res.statusText}`);
+	const data = res.data;
+	return {
+		idFace: data.croppedIDFace ?? null,
+		selfie: data.croppedFace ?? data.croppedAuthenticationSelfie ?? null,
+		secondIdFace: void 0
+	};
+}
+/**
+* Fetches face recognition score from the backend.
+*/
+async function fetchScore(signal) {
+	const res = await api.get(endpoints.getScore, { signal });
+	if (!res.ok) throw new Error(`GET ${endpoints.getScore} failed: ${res.status} ${res.statusText}`);
+	const data = res.data;
+	return {
+		matched: data.faceRecognition?.overall?.status === "OK" ? true : data.faceRecognition?.overall?.status === "FAIL" ? false : null,
+		liveness: data.deepsight ? data.deepsight.multimodalIntelligence?.overall?.status === "OK" : data.liveness?.overall?.status === "OK"
+	};
+}
+/**
+* Fetches second ID face images from the backend.
+*/
+async function fetchSecondIdImages(signal) {
+	const res = await api.post(endpoints.getImagesSecondId, { images: ["croppedIDFace"] }, { signal });
+	if (!res.ok) throw new Error(`POST ${endpoints.getImagesSecondId} failed: ${res.status} ${res.statusText}`);
+	return { secondIdFace: res.data.croppedIDFace ?? null };
+}
+/**
+* Fetches all face match data in parallel (images, score, and optionally second ID images).
+*/
+async function fetchFaceMatchData(config, signal) {
+	const promises = [fetchFaceMatchImages(signal), fetchScore(signal)];
+	if (config.matchingType === "secondId") promises.push(fetchSecondIdImages(signal));
+	const [imagesRes, resultRes, secondIdRes] = await Promise.all(promises);
+	return {
+		images: {
+			...imagesRes,
+			secondIdFace: secondIdRes?.secondIdFace ?? null
+		},
+		result: resultRes
+	};
+}
+
+//#endregion
+//#region src/modules/face-match/faceMatchStateMachine.ts
+const faceMatchMachine = setup({
+	types: {
+		context: {},
+		events: {},
+		input: {}
+	},
+	actors: { fetchData: fromPromise(async ({ input, signal }) => {
+		return fetchFaceMatchData(input.config, signal);
+	}) },
+	actions: {
+		setData: assign(({ event }) => {
+			const output = event.output;
+			return {
+				images: output.images,
+				result: output.result
+			};
+		}),
+		setError: assign(({ event }) => ({ error: String(event.error) })),
+		clearError: assign({ error: () => void 0 }),
+		resetContext: assign(({ context }) => ({
+			config: context.config,
+			images: null,
+			result: null,
+			error: void 0
+		}))
+	},
+	guards: { isAnimationDisabled: ({ context }) => context.config.disableFaceMatchAnimation === true }
+}).createMachine({
+	id: "faceMatch",
+	initial: "idle",
+	context: ({ input }) => ({
+		config: input.config,
+		images: null,
+		result: null,
+		error: void 0
+	}),
+	states: {
+		idle: { on: { LOAD: { target: "loading" } } },
+		loading: { invoke: {
+			id: "fetchData",
+			src: "fetchData",
+			input: ({ context }) => ({ config: context.config }),
+			onDone: [{
+				target: "finished",
+				guard: "isAnimationDisabled",
+				actions: "setData"
+			}, {
+				target: "animating",
+				actions: "setData"
+			}],
+			onError: {
+				target: "error",
+				actions: "setError"
+			}
+		} },
+		animating: { on: { ANIMATION_COMPLETE: { target: "result" } } },
+		result: { on: { CONTINUE: { target: "finished" } } },
+		finished: { type: "final" },
+		error: { on: { RESET: {
+			target: "idle",
+			actions: "resetContext"
+		} } }
+	}
+});
+
+//#endregion
+export { faceMatchMachine as t };

package/dist/flow-events.d.ts

@@ -0,0 +1,6 @@
+import "./camera-DBSxa6ML.js";
+import "./types-CFV9G_7j.js";
+import "./types-BP1m8VRw.js";
+import "./flowCompletionService-DhkT4SRY.js";
+import { a as FlowEventListener, c as FlowModuleStartedEvent, i as FlowEvent, l as FlowReadyEvent, n as FlowCompletedEvent, o as FlowEventSubscribable, r as FlowErrorEvent, s as FlowModuleCompletedEvent, t as FlowClosedEvent, u as FlowStartedEvent } from "./index-BcRG8rtJ.js";
+export { FlowClosedEvent, FlowCompletedEvent, FlowErrorEvent, FlowEvent, FlowEventListener, FlowEventSubscribable, FlowModuleCompletedEvent, FlowModuleStartedEvent, FlowReadyEvent, FlowStartedEvent };

package/dist/flow.d.ts

@@ -0,0 +1,358 @@
+import { n as WasmPipeline } from "./warmup-CEcppFiS.js";
+import { t as Manager } from "./Manager-C8PrhBOx.js";
+import { t as AnyStateMachine } from "./StateMachine-BCQrZJhf.js";
+import "./camera-DBSxa6ML.js";
+import "./types-CFV9G_7j.js";
+import { i as FlowModuleConfig, n as Flow, r as FlowModule } from "./types-BP1m8VRw.js";
+import { n as GetFinishStatusFn, t as FinishStatus } from "./flowCompletionService-DhkT4SRY.js";
+import { o as FlowEventSubscribable } from "./index-BcRG8rtJ.js";
+import { n as ModuleRegistry } from "./types-B06Ypu2F.js";
+import * as xstate651 from "xstate";
+
+//#region src/modules/flow/flowUtils.d.ts
+type NormalizeFlowModulesOptions = {
+  isDesktop?: boolean;
+  authHint?: string;
+  lang?: string;
+  useCPF?: boolean;
+};
+type FlowForNormalization = Pick<Flow, 'flowId' | 'flowModules' | 'redirectDesktopToMobile' | 'disableSmsOption' | 'addContinueToDesktop' | 'qrPhishingResistance'>;
+/**
+ * Analyzes a flow configuration and returns the WASM pipelines needed.
+ * Use this to conditionally warmup WASM only when required by the flow.
+ *
+ * Modules with `onDeviceFaceResultsSubmissionEnabled: true` (currently SELFIE
+ * and AUTHENTICATION) select the 6-model `'onDeviceSelfie'` bundle instead of
+ * the default 4-model `'selfie'` bundle.
+ *
+ * @param flow - The flow configuration from /omni/onboarding/flow
+ * @returns Array of WASM pipelines needed (e.g., ['selfie', 'idCapture'])
+ *
+ * @example
+ * ```typescript
+ * const pipelines = getRequiredWasmPipelines(flow);
+ * if (pipelines.length > 0) {
+ *   warmupWasm({ ...wasmConfig, pipelines });
+ * }
+ * ```
+ */
+declare function getRequiredWasmPipelines(flow: Flow): WasmPipeline[];
+/**
+ * Normalizes flow modules by expanding TUTORIAL_ID into ID + SECOND_ID
+ * based on configuration flags. Matches legacy flowService behavior.
+ *
+ * - TUTORIAL_ID becomes ID (with same config)
+ * - If secondId: true, adds SECOND_ID module with isSecondId: true
+ * - thirdId is deprecated and ignored; the flow continues to the next step
+ * - Bare ID following TUTORIAL_ID is dropped (already merged)
+ */
+declare function normalizeFlowModules(flow: FlowForNormalization, options?: NormalizeFlowModulesOptions): FlowModule[];
+//#endregion
+//#region src/modules/flow/flowServices.d.ts
+type GetFlowOptions = {
+  isDesktop?: boolean;
+  authHint?: string;
+  lang?: string;
+  useCPF?: boolean;
+};
+type GetFlow = (signal: AbortSignal, options?: GetFlowOptions) => Promise<Flow>;
+declare const getFlow: GetFlow;
+//#endregion
+//#region src/modules/flow/noOpFlowModuleMachine.d.ts
+declare const noOpFlowModuleMachine: xstate651.StateMachine<xstate651.MachineContext, xstate651.AnyEventObject, {}, never, never, never, never, "finished", string, xstate651.NonReducibleUnknown, xstate651.NonReducibleUnknown, xstate651.EventObject, xstate651.MetaObject, {
+  readonly id: "noOpFlowModule";
+  readonly initial: "finished";
+  readonly states: {
+    readonly finished: {
+      readonly type: "final";
+    };
+  };
+}>;
+//#endregion
+//#region src/modules/flow/flowActor.d.ts
+type CreateFlowActorOptions = {
+  getFlow?: GetFlow;
+};
+//#endregion
+//#region src/modules/flow/flowManager.d.ts
+/** Flow manager is waiting to be started */
+type FlowIdleState = {
+  status: 'idle';
+};
+/** Flow is being fetched from the server */
+type FlowLoadingState = {
+  status: 'loading';
+};
+/** Flow is loaded and ready for navigation */
+type FlowReadyState = {
+  status: 'ready';
+  /** The complete flow configuration from the server */
+  flow: Flow;
+  /** Array of module keys in order */
+  steps: string[];
+  /** Zero-based index of the current step */
+  currentStepIndex: number;
+  /** The module key of the current step (e.g., 'SELFIE', 'ID', 'FACE_MATCH') */
+  currentStep: string | undefined;
+  /** The configuration object for the current module. Type varies by module. */
+  config: unknown;
+};
+/** All steps have been completed */
+type FlowFinishedState = {
+  status: 'finished';
+  /** The complete flow configuration */
+  flow: Flow;
+};
+/** An error occurred while loading or processing the flow */
+type FlowErrorState = {
+  status: 'error';
+  /** The error message */
+  error: string;
+};
+/** Union of all possible flow states */
+type FlowState = FlowIdleState | FlowLoadingState | FlowReadyState | FlowFinishedState | FlowErrorState;
+/**
+ * Creates a flow manager instance for managing onboarding flow state and navigation.
+ *
+ * The flow manager provides:
+ * - State management with statuses: `idle`, `loading`, `ready`, `finished`, `error`
+ * - Step navigation with `nextStep()` and `prevStep()`
+ * - Current step info via `state.currentStep` and `state.config` when in `ready` state
+ * - Module configuration lookup via `getModuleConfig()`
+ *
+ * @param options - Optional configuration for the flow actor
+ * @param options.getFlow - Custom function to fetch flow data. Defaults to `getOnboardingFlow`
+ * @returns A manager instance with state subscription, API methods, and lifecycle controls
+ *
+ * @example
+ * ```ts
+ * const flowManager = createFlowManager();
+ *
+ * flowManager.subscribe((state) => {
+ *   if (state.status === 'ready') {
+ *     console.log(state.currentStep, state.config);
+ *   }
+ * });
+ *
+ * flowManager.load({ token: 'session-token' });
+ * ```
+ */
+declare function createFlowManager(options?: CreateFlowActorOptions): Manager<FlowState> & {
+  /**
+   * Loads the flow from the server.
+   * Transitions the state from `idle` to `loading`, then to `ready` on success or `error` on failure.
+   * Requires setup() to have been called with a token first.
+   */
+  load(): void;
+  /**
+   * Cancels the current loading operation and returns to `idle` state.
+   * Only effective when in `loading` state.
+   */
+  cancel(): void;
+  /**
+   * Resets the flow manager to its initial `idle` state.
+   * Can be called from `ready`, `finished`, or `error` states.
+   */
+  reset(): void;
+  /**
+   * Advances to the next step in the flow.
+   * If on the last step, transitions to `finished` state.
+   * Only effective when in `ready` state.
+   */
+  nextStep(): void;
+  /**
+   * Goes back to the previous step in the flow.
+   * Does nothing if already on the first step.
+   * Only effective when in `ready` state.
+   */
+  prevStep(): void;
+  /**
+   * Whether the flow can advance to the next step.
+   * Returns `true` if in `ready` state and not on the last step.
+   */
+  readonly canNext: boolean;
+  /**
+   * Whether the flow can go back to the previous step.
+   * Returns `true` if in `ready` state and not on the first step.
+   */
+  readonly canPrev: boolean;
+  /**
+   * Gets the configuration for a specific module by its key.
+   * Useful for accessing config of modules other than the current one.
+   * @param moduleKey - The unique key identifier of the module
+   * @returns The module configuration or `undefined` if not found or not in `ready` state
+   */
+  getModuleConfig: <T$1 = unknown>(moduleKey: string) => T$1 | undefined;
+  /**
+   * Checks if a module is enabled in the current flow.
+   * @param moduleKey - The unique key identifier of the module
+   * @returns `true` if the module exists in the flow, `false` otherwise or if not in `ready` state
+   */
+  isModuleEnabled: (moduleKey: string) => boolean;
+} & FlowEventSubscribable;
+//#endregion
+//#region src/modules/flow/moduleLoader.d.ts
+type LazyModule<T$1> = () => Promise<T$1>;
+type ModuleLoaderRegistry = {
+  [key: string]: LazyModule<{
+    default: unknown;
+  }>;
+};
+interface ModuleLoader {
+  load<T$1>(moduleKey: string): Promise<T$1>;
+  prefetch(moduleKey: string): void;
+  isLoaded(moduleKey: string): boolean;
+}
+declare function createModuleLoader(registry: ModuleLoaderRegistry): ModuleLoader;
+//#endregion
+//#region src/modules/flow/orchestratedFlowStateMachine.d.ts
+type GetFlowFn = (signal: AbortSignal) => Promise<Flow>;
+type LazyModuleRegistry = {
+  [key: string]: (() => Promise<AnyStateMachine | {
+    default: AnyStateMachine;
+  }>) | undefined;
+};
+type OrchestratedFlowInput = {
+  getFlow: GetFlowFn;
+  modules?: ModuleRegistry;
+  lazyModules?: LazyModuleRegistry;
+  getFinishStatus?: GetFinishStatusFn;
+  enableHome?: boolean;
+};
+type OrchestratedFlowEvent = {
+  type: 'LOAD';
+} | {
+  type: 'CANCEL';
+} | {
+  type: 'RESET';
+} | {
+  type: 'MODULE_COMPLETE';
+} | {
+  type: 'COMPLETE_FLOW';
+} | {
+  type: 'HOME_CONTINUE';
+} | {
+  type: '*';
+  [key: string]: unknown;
+} | {
+  type: string;
+  [key: string]: unknown;
+};
+//#endregion
+//#region src/modules/flow/orchestratedFlowManager.d.ts
+type OrchestratedFlowHomeScreen = {
+  visible: boolean;
+  isContinueLoading: boolean;
+};
+type OrchestratedFlowPresentation = {
+  isAwaitingReady: boolean;
+  lazyModuleKey: string | undefined;
+  shouldPrefetchHome: boolean;
+};
+type OrchestratedFlowIdleState = {
+  status: 'idle';
+  homeScreen: OrchestratedFlowHomeScreen;
+  presentation: OrchestratedFlowPresentation;
+};
+type OrchestratedFlowLoadingState = {
+  status: 'loading';
+  homeScreen: OrchestratedFlowHomeScreen;
+  presentation: OrchestratedFlowPresentation;
+};
+type OrchestratedFlowReadyState = {
+  status: 'ready';
+  flow: Flow;
+  steps: string[];
+  currentStepIndex: number;
+  currentStep: string | undefined;
+  config: unknown;
+  moduleState: unknown;
+  homeScreen: OrchestratedFlowHomeScreen;
+  presentation: OrchestratedFlowPresentation;
+};
+type OrchestratedFlowFinishedState = {
+  status: 'finished';
+  flow: Flow;
+  finishStatus: {
+    redirectionUrl: string;
+    action: 'approved' | 'rejected' | 'none';
+    scoreStatus: 'OK' | 'WARN' | 'MANUAL_OK' | 'FAIL' | 'UNKNOWN' | 'MANUAL_FAIL';
+  };
+  homeScreen: OrchestratedFlowHomeScreen;
+  presentation: OrchestratedFlowPresentation;
+};
+type OrchestratedFlowErrorState = {
+  status: 'error';
+  error: string;
+  errorCode?: number;
+  homeScreen: OrchestratedFlowHomeScreen;
+  presentation: OrchestratedFlowPresentation;
+};
+type OrchestratedFlowState = OrchestratedFlowIdleState | OrchestratedFlowLoadingState | OrchestratedFlowReadyState | OrchestratedFlowFinishedState | OrchestratedFlowErrorState;
+type CreateOrchestratedFlowActorOptions = {
+  getFlow?: GetFlowFn;
+  modules?: ModuleRegistry;
+  lazyModules?: LazyModuleRegistry;
+  getFinishStatus?: OrchestratedFlowInput['getFinishStatus'];
+  enableHome?: boolean;
+};
+declare function createOrchestratedFlowManager(options: CreateOrchestratedFlowActorOptions): Manager<OrchestratedFlowState> & {
+  /**
+   * Start loading the flow configuration from the backend.
+   */
+  load(): void;
+  /**
+   * Cancel an in-progress flow load.
+   */
+  cancel(): void;
+  /**
+   * Reset the flow to its initial idle state.
+   */
+  reset(): void;
+  /**
+   * Signal that the current module has completed successfully.
+   * Call this from your UI component's `onFinish` callback.
+   *
+   * @example
+   * ```tsx
+   * <Phone
+   *   config={config}
+   *   onFinish={() => flowManager.completeModule()}
+   * />
+   * ```
+   */
+  completeModule(): void;
+  /**
+   * Skip all remaining modules and go straight to the completion step.
+   * Used when the flow was completed externally (e.g. via redirect to mobile).
+   */
+  completeFlow(): void;
+  /**
+   * Signal that the current module encountered an error.
+   * Call this from your UI component's `onError` callback if you want
+   * the flow to transition to an error state.
+   *
+   * @param error - Error message describing what went wrong
+   */
+  errorModule(error: string): void;
+  /**
+   * Send a raw event to the flow state machine.
+   * Prefer using the typed methods (completeModule, errorModule) when possible.
+   */
+  send(event: OrchestratedFlowEvent): void;
+  readonly canNext: boolean;
+  getModuleConfig: <T$1 = unknown>(moduleKey: string) => T$1 | undefined;
+  isModuleEnabled: (moduleKey: string) => boolean;
+  isAwaitingOrchestratorReady(): boolean;
+  /**
+   * Resolve once the orchestrator has finished loading the flow and the first
+   * module is ready to render. Useful for gating an initialization spinner
+   * alongside other parallel async work (e.g. theme fetching).
+   */
+  waitForReady(): Promise<void>;
+  getLazyModuleKey(): string | undefined;
+  shouldRenderHomeScreen(): boolean;
+  continueFromHome(): Promise<void>;
+} & FlowEventSubscribable;
+//#endregion
+export { type FinishStatus, type Flow, type FlowModule, type FlowModuleConfig, type FlowReadyState, type FlowState, type LazyModule, type LazyModuleRegistry, type ModuleLoader, type ModuleLoaderRegistry, type ModuleRegistry, type OrchestratedFlowFinishedState, type OrchestratedFlowHomeScreen, type OrchestratedFlowInput, type OrchestratedFlowPresentation, type OrchestratedFlowReadyState, type OrchestratedFlowState, createFlowManager, createModuleLoader, createOrchestratedFlowManager, getFlow, getRequiredWasmPipelines, noOpFlowModuleMachine, normalizeFlowModules };