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

package/dist/flow.esm.js

@@ -0,0 +1,628 @@
+import { g as createManager, n as api, t as endpoints } from "./endpoints-BSTFaHYo.esm.js";
+import { a as createActor, i as fromPromise, n as assign, r as fromCallback, t as setup } from "./xstate.esm-B_rda9yU.esm.js";
+
+//#region src/modules/flow/flowAnalyzer.ts
+const WASM_MODULE_PIPELINES = {
+	SELFIE: "selfie",
+	AUTHENTICATION: "selfie",
+	FACE_MATCH: "selfie",
+	VIDEO_ONBOARDING: "selfie",
+	ID: "idCapture",
+	TUTORIAL_ID: "idCapture",
+	SECOND_ID: "idCapture",
+	THIRD_ID: "idCapture"
+};
+/**
+* Analyzes a flow configuration and returns the WASM pipelines needed.
+* Use this to conditionally warmup WASM only when required by the flow.
+*
+* @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 });
+* }
+* ```
+*/
+function getRequiredWasmPipelines(flow) {
+	const pipelines = /* @__PURE__ */ new Set();
+	for (const module of flow.flowModules) {
+		const pipeline = WASM_MODULE_PIPELINES[module.key];
+		if (pipeline) pipelines.add(pipeline);
+	}
+	return [...pipelines];
+}
+
+//#endregion
+//#region src/modules/flow/flowServices.ts
+const getFlow = async (signal) => {
+	const res = await api.get(endpoints.flow, { signal });
+	if (!res.ok) throw new Error(`GET /flow failed: ${res.status} ${res.statusText}`);
+	return res.data;
+};
+
+//#endregion
+//#region src/modules/flow/flowStateMachine.ts
+const flowMachine = setup({
+	types: {
+		context: {},
+		events: {},
+		input: {}
+	},
+	actors: { fetchFlow: fromPromise(async ({ input, signal }) => {
+		return input.getFlow(signal);
+	}) },
+	actions: {
+		resetContext: assign(({ context }) => ({
+			flow: void 0,
+			error: void 0,
+			steps: [],
+			currentStepIndex: -1,
+			currentStep: void 0,
+			config: void 0,
+			getFlow: context.getFlow
+		})),
+		setFlowData: assign(({ event }) => {
+			const flow = event.output;
+			return {
+				flow,
+				steps: (flow.flowModules ?? []).map((m) => m.key),
+				currentStepIndex: (flow.flowModules ?? []).length > 0 ? 0 : -1,
+				currentStep: flow.flowModules?.[0]?.key,
+				config: flow.flowModules?.[0]?.configuration
+			};
+		}),
+		setError: assign(({ event }) => ({ error: String(event.error) })),
+		incrementStep: assign(({ context }) => {
+			const nextIndex = context.currentStepIndex + 1;
+			const module = context.flow?.flowModules?.[nextIndex];
+			return {
+				currentStepIndex: nextIndex,
+				currentStep: module?.key,
+				config: module?.configuration
+			};
+		}),
+		decrementStep: assign(({ context }) => {
+			const prevIndex = context.currentStepIndex - 1;
+			const module = context.flow?.flowModules?.[prevIndex];
+			return {
+				currentStepIndex: prevIndex,
+				currentStep: module?.key,
+				config: module?.configuration
+			};
+		})
+	},
+	guards: {
+		isLastStep: ({ context }) => context.currentStepIndex >= 0 && context.currentStepIndex === context.steps.length - 1,
+		canGoNext: ({ context }) => context.currentStepIndex >= 0 && context.currentStepIndex < context.steps.length - 1,
+		canGoPrev: ({ context }) => context.currentStepIndex > 0
+	}
+}).createMachine({
+	id: "flow",
+	initial: "idle",
+	context: ({ input }) => ({
+		flow: void 0,
+		error: void 0,
+		steps: [],
+		currentStepIndex: -1,
+		currentStep: void 0,
+		config: void 0,
+		getFlow: input.getFlow
+	}),
+	states: {
+		idle: { on: { LOAD: {
+			target: "loading",
+			actions: "resetContext"
+		} } },
+		loading: {
+			invoke: {
+				id: "fetchFlow",
+				src: "fetchFlow",
+				input: ({ context }) => ({ getFlow: context.getFlow }),
+				onDone: {
+					target: "ready",
+					actions: "setFlowData"
+				},
+				onError: {
+					target: "error",
+					actions: "setError"
+				}
+			},
+			on: { CANCEL: {
+				target: "idle",
+				actions: "resetContext"
+			} }
+		},
+		ready: { on: {
+			NEXT_STEP: [{
+				target: "finished",
+				guard: "isLastStep"
+			}, {
+				target: "ready",
+				guard: "canGoNext",
+				actions: "incrementStep"
+			}],
+			PREV_STEP: {
+				target: "ready",
+				guard: "canGoPrev",
+				actions: "decrementStep"
+			},
+			RESET: {
+				target: "idle",
+				actions: "resetContext"
+			}
+		} },
+		finished: { on: { RESET: {
+			target: "idle",
+			actions: "resetContext"
+		} } },
+		error: { on: { RESET: {
+			target: "idle",
+			actions: "resetContext"
+		} } }
+	}
+});
+
+//#endregion
+//#region src/modules/flow/flowActor.ts
+function createFlowActor(options) {
+	return createActor(flowMachine, { input: { getFlow: options?.getFlow ?? getFlow } }).start();
+}
+
+//#endregion
+//#region src/modules/flow/flowManager.ts
+function mapState$1(snapshot) {
+	const { value, context } = snapshot;
+	switch (value) {
+		case "idle": return { status: "idle" };
+		case "loading": return { status: "loading" };
+		case "ready": return {
+			status: "ready",
+			flow: context.flow ?? {},
+			steps: context.steps,
+			currentStepIndex: context.currentStepIndex,
+			currentStep: context.currentStep,
+			config: context.config
+		};
+		case "finished": return {
+			status: "finished",
+			flow: context.flow ?? {}
+		};
+		case "error": return {
+			status: "error",
+			error: context.error ?? "Unknown error"
+		};
+		default: return { status: "idle" };
+	}
+}
+function createApi$1({ actor, getSnapshot }) {
+	function getCanNext() {
+		const snapshot = getSnapshot();
+		const { currentStepIndex, steps } = snapshot.context;
+		return snapshot.matches("ready") && currentStepIndex >= 0 && currentStepIndex < steps.length - 1;
+	}
+	function getCanPrev() {
+		const snapshot = getSnapshot();
+		return snapshot.matches("ready") && snapshot.context.currentStepIndex > 0;
+	}
+	function getModuleConfig(moduleKey) {
+		const snapshot = getSnapshot();
+		if (!snapshot.matches("ready")) return;
+		return (snapshot.context.flow?.flowModules.find((m) => m.key === moduleKey))?.configuration;
+	}
+	function isModuleEnabled(moduleKey) {
+		const snapshot = getSnapshot();
+		if (!snapshot.matches("ready")) return false;
+		return !!snapshot.context.flow?.flowModules.some((m) => m.key === moduleKey);
+	}
+	return {
+		load() {
+			actor.send({ type: "LOAD" });
+		},
+		cancel() {
+			actor.send({ type: "CANCEL" });
+		},
+		reset() {
+			actor.send({ type: "RESET" });
+		},
+		nextStep() {
+			actor.send({ type: "NEXT_STEP" });
+		},
+		prevStep() {
+			actor.send({ type: "PREV_STEP" });
+		},
+		get canNext() {
+			return getCanNext();
+		},
+		get canPrev() {
+			return getCanPrev();
+		},
+		getModuleConfig,
+		isModuleEnabled
+	};
+}
+/**
+* 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' });
+* ```
+*/
+function createFlowManager(options) {
+	return createManager({
+		actor: createFlowActor(options),
+		mapState: mapState$1,
+		createApi: createApi$1
+	});
+}
+
+//#endregion
+//#region src/modules/flow/moduleLoader.ts
+var ModuleLoaderImpl = class {
+	constructor(registry) {
+		this.registry = registry;
+		this.loadedModules = /* @__PURE__ */ new Map();
+		this.prefetchedModules = /* @__PURE__ */ new Set();
+	}
+	async load(moduleKey) {
+		if (!this.registry[moduleKey]) throw new Error(`Module ${moduleKey} not found in registry`);
+		const cached = this.loadedModules.get(moduleKey);
+		if (cached) return await cached;
+		const loadPromise = this.registry[moduleKey]().then((module) => {
+			if (module && typeof module === "object" && "default" in module) return module.default;
+			return module;
+		});
+		this.loadedModules.set(moduleKey, loadPromise);
+		try {
+			return await loadPromise;
+		} catch (error) {
+			this.loadedModules.delete(moduleKey);
+			throw error;
+		}
+	}
+	prefetch(moduleKey) {
+		if (!this.registry[moduleKey]) return;
+		if (this.prefetchedModules.has(moduleKey) || this.loadedModules.has(moduleKey)) return;
+		this.prefetchedModules.add(moduleKey);
+		this.registry[moduleKey]().catch(() => {
+			this.prefetchedModules.delete(moduleKey);
+		});
+	}
+	isLoaded(moduleKey) {
+		return this.loadedModules.has(moduleKey);
+	}
+};
+function createModuleLoader(registry) {
+	return new ModuleLoaderImpl(registry);
+}
+
+//#endregion
+//#region src/modules/flow/flowCompletionService.ts
+const getFinishStatus = async (flowId, signal) => {
+	const url = `/omni/finish-status${flowId ? `?flowId=${flowId}` : ""}`;
+	const res = await api.get(url, { signal });
+	if (!res.ok) throw new Error(`GET ${url} failed: ${res.status} ${res.statusText}`);
+	return res.data;
+};
+
+//#endregion
+//#region src/modules/flow/orchestratedFlowStateMachine.ts
+const orchestratedFlowMachine = setup({
+	types: {
+		context: {},
+		events: {},
+		input: {}
+	},
+	actors: {
+		fetchFlow: fromPromise(async ({ input, signal }) => {
+			return input.getFlow(signal);
+		}),
+		notifyBackend: fromPromise(async ({ input, signal }) => {
+			return await input.getFinishStatus(input.flowId, signal);
+		}),
+		runChildModule: fromCallback(({ sendBack, input }) => {
+			const { machine, config } = input;
+			const actor = createActor(machine, { input: { config } });
+			const subscription = actor.subscribe({
+				complete: () => {
+					sendBack({ type: "MODULE_COMPLETE" });
+				},
+				error: (err) => {
+					sendBack({
+						type: "MODULE_ERROR",
+						error: err
+					});
+				}
+			});
+			actor.start();
+			return () => {
+				subscription.unsubscribe();
+				actor.stop();
+			};
+		})
+	},
+	actions: {
+		resetContext: assign(({ context }) => ({
+			flow: void 0,
+			error: void 0,
+			steps: [],
+			currentStepIndex: -1,
+			currentStep: void 0,
+			config: void 0,
+			getFlow: context.getFlow,
+			registeredModules: context.registeredModules,
+			getFinishStatus: context.getFinishStatus,
+			finishStatus: void 0
+		})),
+		setFlowData: assign(({ event }) => {
+			const flow = event.output;
+			return {
+				flow,
+				steps: (flow.flowModules ?? []).map((m) => m.key),
+				currentStepIndex: (flow.flowModules ?? []).length > 0 ? 0 : -1,
+				currentStep: flow.flowModules?.[0]?.key,
+				config: flow.flowModules?.[0]?.configuration
+			};
+		}),
+		setError: assign(({ event }) => ({ error: String(event.error) })),
+		incrementStep: assign(({ context }) => {
+			const nextIndex = context.currentStepIndex + 1;
+			const module = context.flow?.flowModules?.[nextIndex];
+			return {
+				currentStepIndex: nextIndex,
+				currentStep: module?.key,
+				config: module?.configuration
+			};
+		}),
+		setFinishStatus: assign(({ event }) => ({ finishStatus: event.output }))
+	},
+	guards: {
+		isLastStep: ({ context }) => context.currentStepIndex >= 0 && context.currentStepIndex === context.steps.length - 1,
+		canGoNext: ({ context }) => context.currentStepIndex >= 0 && context.currentStepIndex < context.steps.length - 1,
+		hasModule: ({ context, event }) => {
+			if (!("output" in event)) return false;
+			const firstModuleKey = event.output.flowModules?.[0]?.key;
+			if (!firstModuleKey) return false;
+			return context.registeredModules[firstModuleKey] != null;
+		}
+	}
+}).createMachine({
+	id: "orchestratedFlow",
+	initial: "idle",
+	context: ({ input }) => ({
+		flow: void 0,
+		error: void 0,
+		steps: [],
+		currentStepIndex: -1,
+		currentStep: void 0,
+		config: void 0,
+		getFlow: input.getFlow,
+		registeredModules: input.modules,
+		getFinishStatus: input.getFinishStatus ?? getFinishStatus,
+		finishStatus: void 0
+	}),
+	states: {
+		idle: { on: { LOAD: {
+			target: "loading",
+			actions: "resetContext"
+		} } },
+		loading: {
+			invoke: {
+				id: "fetchFlow",
+				src: "fetchFlow",
+				input: ({ context }) => ({ getFlow: context.getFlow }),
+				onDone: [{
+					target: "runningModule",
+					guard: "hasModule",
+					actions: "setFlowData"
+				}, {
+					target: "error",
+					actions: assign({ error: () => "No registered module found for flow" })
+				}],
+				onError: {
+					target: "error",
+					actions: "setError"
+				}
+			},
+			on: { CANCEL: {
+				target: "idle",
+				actions: "resetContext"
+			} }
+		},
+		runningModule: {
+			invoke: {
+				id: "currentModule",
+				src: "runChildModule",
+				input: ({ context }) => {
+					if (!context.currentStep) throw new Error("No current step");
+					const machine = context.registeredModules[context.currentStep];
+					if (!machine) throw new Error(`Module ${context.currentStep} not registered`);
+					return {
+						machine,
+						config: context.config
+					};
+				},
+				onDone: [{
+					target: "completing",
+					guard: "isLastStep"
+				}, {
+					target: "runningModule",
+					actions: "incrementStep",
+					reenter: true
+				}],
+				onError: {
+					target: "error",
+					actions: "setError"
+				}
+			},
+			on: {
+				MODULE_COMPLETE: [{
+					target: "completing",
+					guard: "isLastStep"
+				}, {
+					target: "runningModule",
+					actions: "incrementStep",
+					reenter: true
+				}],
+				MODULE_ERROR: {
+					target: "error",
+					actions: assign(({ event }) => ({ error: String(event.error) }))
+				},
+				RESET: {
+					target: "idle",
+					actions: "resetContext"
+				}
+			}
+		},
+		completing: {
+			invoke: {
+				id: "notifyBackend",
+				src: "notifyBackend",
+				input: ({ context }) => ({
+					getFinishStatus: context.getFinishStatus,
+					flowId: context.flow?.flowId
+				}),
+				onDone: {
+					target: "finished",
+					actions: "setFinishStatus"
+				},
+				onError: {
+					target: "error",
+					actions: "setError"
+				}
+			},
+			on: { RESET: {
+				target: "idle",
+				actions: "resetContext"
+			} }
+		},
+		finished: { on: { RESET: {
+			target: "idle",
+			actions: "resetContext"
+		} } },
+		error: { on: { RESET: {
+			target: "idle",
+			actions: "resetContext"
+		} } }
+	}
+});
+
+//#endregion
+//#region src/modules/flow/orchestratedFlowManager.ts
+function mapState(snapshot) {
+	const { value, context } = snapshot;
+	switch (value) {
+		case "idle": return { status: "idle" };
+		case "loading": return { status: "loading" };
+		case "runningModule": {
+			const childSnapshot = snapshot.children.currentModule?.getSnapshot();
+			return {
+				status: "ready",
+				flow: context.flow ?? {},
+				steps: context.steps,
+				currentStepIndex: context.currentStepIndex,
+				currentStep: context.currentStep,
+				config: context.config,
+				moduleState: childSnapshot ?? null
+			};
+		}
+		case "finished": return {
+			status: "finished",
+			flow: context.flow ?? {},
+			finishStatus: context.finishStatus ?? {
+				redirectionUrl: "",
+				action: "none",
+				scoreStatus: "UNKNOWN"
+			}
+		};
+		case "error": return {
+			status: "error",
+			error: context.error ?? "Unknown error"
+		};
+		default: return { status: "idle" };
+	}
+}
+function createApi({ actor, getSnapshot }) {
+	function getCanNext() {
+		const snapshot = getSnapshot();
+		const { currentStepIndex, steps } = snapshot.context;
+		return snapshot.value === "runningModule" && currentStepIndex >= 0 && currentStepIndex < steps.length - 1;
+	}
+	function getModuleConfig(moduleKey) {
+		const snapshot = getSnapshot();
+		if (snapshot.value !== "runningModule") return;
+		return (snapshot.context.flow?.flowModules.find((m) => m.key === moduleKey))?.configuration;
+	}
+	function isModuleEnabled(moduleKey) {
+		const snapshot = getSnapshot();
+		if (snapshot.value !== "runningModule") return false;
+		return !!snapshot.context.flow?.flowModules.some((m) => m.key === moduleKey);
+	}
+	return {
+		load() {
+			actor.send({ type: "LOAD" });
+		},
+		cancel() {
+			actor.send({ type: "CANCEL" });
+		},
+		reset() {
+			actor.send({ type: "RESET" });
+		},
+		completeModule() {
+			actor.send({ type: "MODULE_COMPLETE" });
+		},
+		errorModule(error) {
+			actor.send({
+				type: "MODULE_ERROR",
+				error
+			});
+		},
+		send(event) {
+			actor.send(event);
+		},
+		get canNext() {
+			return getCanNext();
+		},
+		getModuleConfig,
+		isModuleEnabled
+	};
+}
+function createOrchestratedFlowActor(options) {
+	return createActor(orchestratedFlowMachine, { input: {
+		getFlow: options.getFlow ?? getFlow,
+		modules: options.modules,
+		getFinishStatus: options.getFinishStatus
+	} }).start();
+}
+function createOrchestratedFlowManager(options) {
+	return createManager({
+		actor: createOrchestratedFlowActor(options),
+		mapState,
+		createApi
+	});
+}
+
+//#endregion
+export { createFlowManager, createModuleLoader, createOrchestratedFlowManager, getRequiredWasmPipelines };