@incodetech/core 0.0.0-dev-20260416-bf5b221 → 0.0.0-dev-20260417-78468b3

package/dist/flow.esm.js

@@ -4,7 +4,7 @@ import "./session-4kX3TYAC.esm.js";
 import "./BrowserEnvironmentProvider-D7IR7V-D.esm.js";
 import "./browserSimulation-UTYyQOiB.esm.js";
 import { a as createActor, i as fromPromise, n as assign, o as createManager, t as setup } from "./xstate.esm-BlgyVBVv.esm.js";
-import { n as getRequiredWasmPipelines, r as normalizeFlowModules, t as getFlow } from "./flowServices-BjihIhLr.esm.js";
+import { n as getRequiredWasmPipelines, r as normalizeFlowModules, t as getFlow } from "./flowServices-ibDApkcC.esm.js";
 import { t as getFinishStatus } from "./flowCompletionService-BoRh9z5O.esm.js";
 import { t as runChildModule } from "./runChildModule-CPESMGyI.esm.js";
 
@@ -137,7 +137,7 @@ function createFlowActor(options) {
 
 //#endregion
 //#region src/modules/flow/flowManager.ts
-function mapState$1(snapshot) {
+function mapState(snapshot) {
 	const { value, context } = snapshot;
 	switch (value) {
 		case "idle": return { status: "idle" };
@@ -161,7 +161,7 @@ function mapState$1(snapshot) {
 		default: return { status: "idle" };
 	}
 }
-function createApi$1({ actor, getSnapshot, trackElementClicked }) {
+function createApi({ actor, getSnapshot, trackElementClicked }) {
 	function getCanNext() {
 		const snapshot = getSnapshot();
 		const { currentStepIndex, steps } = snapshot.context;
@@ -239,8 +239,8 @@ function createApi$1({ actor, getSnapshot, trackElementClicked }) {
 function createFlowManager(options) {
 	return createManager({
 		actor: createFlowActor(options),
-		mapState: mapState$1,
-		createApi: createApi$1,
+		mapState,
+		createApi,
 		instrumentation: createManagerInstrumentation("FLOW")
 	});
 }
@@ -287,6 +287,48 @@ function createModuleLoader(registry) {
 
 //#endregion
 //#region src/modules/flow/orchestratedFlowStateMachine.ts
+function createBaseContext(context, isHomeContinueLoading) {
+	return {
+		flow: void 0,
+		error: void 0,
+		steps: [],
+		currentStepIndex: -1,
+		currentStep: void 0,
+		config: void 0,
+		getFlow: context.getFlow,
+		registeredModules: context.registeredModules,
+		lazyRegisteredModules: context.lazyRegisteredModules,
+		currentModuleMachine: void 0,
+		getFinishStatus: context.getFinishStatus,
+		enableHome: context.enableHome,
+		finishStatus: void 0,
+		isHomeContinueLoading
+	};
+}
+function createInitialContext(input) {
+	return createBaseContext({
+		getFlow: input.getFlow,
+		registeredModules: input.modules ?? {},
+		lazyRegisteredModules: input.lazyModules ?? {},
+		getFinishStatus: input.getFinishStatus ?? getFinishStatus,
+		enableHome: input.enableHome === true
+	}, false);
+}
+function shouldEnterHome(context) {
+	return context.enableHome === true && context.currentStepIndex === 0 && context.isHomeContinueLoading === false;
+}
+const prefetchedLazyModules = /* @__PURE__ */ new WeakSet();
+function prefetchNextLazyModule(context) {
+	const nextStep = context.steps[context.currentStepIndex + 1];
+	if (!nextStep) return;
+	const nextLazyModule = context.lazyRegisteredModules[nextStep];
+	if (!nextLazyModule || prefetchedLazyModules.has(nextLazyModule)) return;
+	prefetchedLazyModules.add(nextLazyModule);
+	nextLazyModule().catch(() => {
+		prefetchedLazyModules.delete(nextLazyModule);
+	});
+}
+const homeContinueOn = { HOME_CONTINUE: { actions: "setHomeContinueLoading" } };
 const orchestratedFlowMachine = setup({
 	types: {
 		context: {},
@@ -313,20 +355,10 @@ const orchestratedFlowMachine = setup({
 		})
 	},
 	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,
-			lazyRegisteredModules: context.lazyRegisteredModules,
-			currentModuleMachine: void 0,
-			getFinishStatus: context.getFinishStatus,
-			finishStatus: void 0
-		})),
+		resetContext: assign(({ context }) => createBaseContext(context, false)),
+		resetContextForLoad: assign(({ context }) => createBaseContext(context, context.isHomeContinueLoading)),
+		setHomeContinueLoading: assign({ isHomeContinueLoading: true }),
+		clearHomeContinueLoading: assign({ isHomeContinueLoading: false }),
 		setFlowData: assign(({ event }) => {
 			const flow = event.output;
 			const flowModules = flow.flowModules ?? [];
@@ -360,11 +392,15 @@ const orchestratedFlowMachine = setup({
 			};
 		}),
 		setCurrentModuleMachine: assign(({ event }) => ({ currentModuleMachine: event.output })),
+		prefetchNextModule: ({ context }) => {
+			prefetchNextLazyModule(context);
+		},
 		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,
+		shouldEnterHome: ({ context }) => shouldEnterHome(context),
 		hasModule: ({ context, event }) => {
 			if (!("output" in event)) return false;
 			const firstModuleKey = event.output.flowModules?.[0]?.key;
@@ -379,25 +415,15 @@ const orchestratedFlowMachine = setup({
 }).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 ?? {},
-		lazyRegisteredModules: input.lazyModules ?? {},
-		currentModuleMachine: void 0,
-		getFinishStatus: input.getFinishStatus ?? getFinishStatus,
-		finishStatus: void 0
-	}),
+	context: ({ input }) => createInitialContext(input),
 	states: {
-		idle: { on: { LOAD: {
-			target: "loading",
-			actions: "resetContext"
-		} } },
+		idle: { on: {
+			LOAD: {
+				target: "loading",
+				actions: "resetContextForLoad"
+			},
+			...homeContinueOn
+		} },
 		loading: {
 			invoke: {
 				id: "fetchFlow",
@@ -419,10 +445,13 @@ const orchestratedFlowMachine = setup({
 					actions: "setError"
 				}
 			},
-			on: { CANCEL: {
-				target: "idle",
-				actions: "resetContext"
-			} }
+			on: {
+				CANCEL: {
+					target: "idle",
+					actions: "resetContext"
+				},
+				...homeContinueOn
+			}
 		},
 		resolvingModule: {
 			invoke: {
@@ -433,25 +462,47 @@ const orchestratedFlowMachine = setup({
 					modules: context.registeredModules,
 					lazyModules: context.lazyRegisteredModules
 				}),
-				onDone: [{
-					target: "runningModule",
-					guard: "hasCurrentModuleMachine",
-					actions: "setCurrentModuleMachine"
-				}, {
-					target: "error",
-					actions: assign(({ context }) => ({ error: context.currentStep ? `No registered module found for: ${context.currentStep}` : "No registered module found: flow has no modules" }))
-				}],
+				onDone: [
+					{
+						target: "home",
+						guard: "shouldEnterHome",
+						actions: ["setCurrentModuleMachine", "prefetchNextModule"]
+					},
+					{
+						target: "runningModule",
+						guard: "hasCurrentModuleMachine",
+						actions: ["setCurrentModuleMachine", "prefetchNextModule"]
+					},
+					{
+						target: "error",
+						actions: assign(({ context }) => ({ error: context.currentStep ? `No registered module found for: ${context.currentStep}` : "No registered module found: flow has no modules" }))
+					}
+				],
 				onError: {
 					target: "error",
 					actions: "setError"
 				}
 			},
-			on: { RESET: {
+			on: {
+				RESET: {
+					target: "idle",
+					actions: "resetContext"
+				},
+				...homeContinueOn
+			}
+		},
+		home: { on: {
+			HOME_CONTINUE: {
+				target: "runningModule",
+				actions: "clearHomeContinueLoading"
+			},
+			RESET: {
 				target: "idle",
 				actions: "resetContext"
-			} }
-		},
+			}
+		} },
 		runningModule: {
+			entry: "clearHomeContinueLoading",
 			invoke: {
 				id: "currentModule",
 				src: "runChildModule",
@@ -519,49 +570,124 @@ const orchestratedFlowMachine = setup({
 			target: "idle",
 			actions: "resetContext"
 		} } },
-		error: { on: { RESET: {
-			target: "idle",
-			actions: "resetContext"
-		} } }
+		error: {
+			entry: "clearHomeContinueLoading",
+			on: { RESET: {
+				target: "idle",
+				actions: "resetContext"
+			} }
+		}
 	}
 });
 
 //#endregion
 //#region src/modules/flow/orchestratedFlowManager.ts
-function mapState(snapshot) {
+function deriveUiModel(snapshot, mappedStatus, isHomePhase, options) {
+	const { enableHome } = options;
+	const isTerminal = mappedStatus === "finished" || mappedStatus === "error";
+	const awaitingOrchestrator = mappedStatus === "idle" || mappedStatus === "loading";
+	const visible = isTerminal === false && enableHome === true ? awaitingOrchestrator || isHomePhase : false;
+	const lazyModuleKey = mappedStatus === "ready" && visible === false ? snapshot.context.currentStep : void 0;
+	const shouldPrefetchHome = isTerminal === false && enableHome === true && snapshot.context.isHomeContinueLoading === false && (awaitingOrchestrator || isHomePhase);
+	return {
+		homeScreen: {
+			visible,
+			isContinueLoading: isTerminal ? false : snapshot.context.isHomeContinueLoading
+		},
+		presentation: {
+			isAwaitingReady: awaitingOrchestrator,
+			lazyModuleKey,
+			shouldPrefetchHome
+		}
+	};
+}
+function getMappedStatus(snapshot) {
+	const { value } = snapshot;
+	if (value === "idle") return "idle";
+	if (value === "loading" || value === "resolvingModule" || typeof value === "object") return "loading";
+	if (value === "finished") return "finished";
+	if (value === "error") return "error";
+	return "ready";
+}
+function mapOrchestratedFlowState(snapshot, uiOptions) {
 	const { value, context } = snapshot;
-	if (value === "idle") return { status: "idle" };
-	if (value === "loading" || value === "resolvingModule" || typeof value === "object") return { status: "loading" };
-	switch (value) {
-		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
-			};
+	const mappedStatus = getMappedStatus(snapshot);
+	const uiModel = deriveUiModel(snapshot, mappedStatus, value === "home", uiOptions);
+	if (mappedStatus === "idle") return {
+		status: "idle",
+		homeScreen: uiModel.homeScreen,
+		presentation: uiModel.presentation
+	};
+	if (mappedStatus === "loading") return {
+		status: "loading",
+		homeScreen: uiModel.homeScreen,
+		presentation: uiModel.presentation
+	};
+	if (mappedStatus === "finished") return {
+		status: "finished",
+		flow: context.flow ?? {},
+		finishStatus: context.finishStatus ?? {
+			redirectionUrl: "",
+			action: "none",
+			scoreStatus: "UNKNOWN"
+		},
+		homeScreen: uiModel.homeScreen,
+		presentation: uiModel.presentation
+	};
+	if (mappedStatus === "error") return {
+		status: "error",
+		error: context.error ?? "Unknown error",
+		homeScreen: uiModel.homeScreen,
+		presentation: uiModel.presentation
+	};
+	const childSnapshot = value === "runningModule" ? snapshot.children.currentModule?.getSnapshot() : null;
+	return {
+		status: "ready",
+		flow: context.flow ?? {},
+		steps: context.steps,
+		currentStepIndex: context.currentStepIndex,
+		currentStep: context.currentStep,
+		config: context.config,
+		moduleState: childSnapshot ?? null,
+		homeScreen: uiModel.homeScreen,
+		presentation: uiModel.presentation
+	};
+}
+function waitForOrchestratorReadyFromActor(actor, mapState$1, isResolved) {
+	return new Promise((resolve, reject) => {
+		const initial = mapState$1(actor.getSnapshot());
+		if (isResolved(initial)) {
+			resolve();
+			return;
 		}
-		case "finished": return {
-			status: "finished",
-			flow: context.flow ?? {},
-			finishStatus: context.finishStatus ?? {
-				redirectionUrl: "",
-				action: "none",
-				scoreStatus: "UNKNOWN"
+		if (initial.status === "error") {
+			reject(new Error(initial.error));
+			return;
+		}
+		if (initial.status === "finished") {
+			reject(/* @__PURE__ */ new Error("Flow finished"));
+			return;
+		}
+		const subscription = actor.subscribe(() => {
+			const next = mapState$1(actor.getSnapshot());
+			if (isResolved(next)) {
+				subscription.unsubscribe();
+				resolve();
+			} else if (next.status === "error") {
+				subscription.unsubscribe();
+				reject(new Error(next.error));
+			} else if (next.status === "finished") {
+				subscription.unsubscribe();
+				reject(/* @__PURE__ */ new Error("Flow finished"));
 			}
-		};
-		case "error": return {
-			status: "error",
-			error: context.error ?? "Unknown error"
-		};
-		default: return { status: "idle" };
-	}
+		});
+	});
 }
-function createApi({ actor, getSnapshot, trackElementClicked }) {
+function createOrchestratedFlowApi({ actor, getSnapshot, trackElementClicked }, uiOptions) {
+	const { enableHome } = uiOptions;
+	function mapSnapshot() {
+		return mapOrchestratedFlowState(getSnapshot(), { enableHome });
+	}
 	function getCanNext() {
 		const snapshot = getSnapshot();
 		const { currentStepIndex, steps } = snapshot.context;
@@ -609,7 +735,34 @@ function createApi({ actor, getSnapshot, trackElementClicked }) {
 			return getCanNext();
 		},
 		getModuleConfig,
-		isModuleEnabled
+		isModuleEnabled,
+		isAwaitingOrchestratorReady() {
+			return mapSnapshot().presentation.isAwaitingReady;
+		},
+		getLazyModuleKey() {
+			return mapSnapshot().presentation.lazyModuleKey;
+		},
+		shouldRenderHomeScreen() {
+			return mapSnapshot().homeScreen.visible;
+		},
+		async continueFromHome() {
+			const state = mapSnapshot();
+			if (!state.homeScreen.visible) return;
+			if (state.status === "ready") {
+				trackElementClicked?.("homeContinue");
+				actor.send({ type: "HOME_CONTINUE" });
+				return;
+			}
+			if (state.presentation.isAwaitingReady) {
+				trackElementClicked?.("homeContinue");
+				actor.send({ type: "HOME_CONTINUE" });
+				try {
+					await waitForOrchestratorReadyFromActor(actor, (snap) => mapOrchestratedFlowState(snap, { enableHome }), (next) => next.status === "ready" && next.homeScreen.visible === false);
+				} catch {
+					return;
+				}
+			}
+		}
 	};
 }
 function createOrchestratedFlowActor(options) {
@@ -617,14 +770,18 @@ function createOrchestratedFlowActor(options) {
 		getFlow: options.getFlow ?? getFlow,
 		modules: options.modules,
 		lazyModules: options.lazyModules,
-		getFinishStatus: options.getFinishStatus
+		getFinishStatus: options.getFinishStatus,
+		enableHome: options.enableHome
 	} }).start();
 }
 function createOrchestratedFlowManager(options) {
+	const actor = createOrchestratedFlowActor(options);
+	const enableHome = options.enableHome === true;
+	const uiOpts = { enableHome };
 	return createManager({
-		actor: createOrchestratedFlowActor(options),
-		mapState,
-		createApi,
+		actor,
+		mapState: (snapshot) => mapOrchestratedFlowState(snapshot, uiOpts),
+		createApi: (apiOpts) => createOrchestratedFlowApi(apiOpts, { enableHome }),
 		instrumentation: createManagerInstrumentation("FLOW")
 	});
 }

package/dist/{flowServices-BjihIhLr.esm.js → flowServices-ibDApkcC.esm.js}

@@ -46,7 +46,6 @@ function getRequiredWasmPipelines(flow) {
 */
 function normalizeFlowModules(flow, options = {}) {
 	let modules = normalizeIdModules(flow.flowModules);
-	if (options.enableHome === true && !hasModule(modules, "HOME")) modules = addHome(modules);
 	if (shouldInjectRedirect(flow, modules, options)) modules = addRedirect(flow, modules, options);
 	return modules;
 }
@@ -72,17 +71,10 @@ function normalizeIdModules(modules) {
 		return [module];
 	});
 }
-function addHome(modules) {
-	return [{
-		key: "HOME",
-		configuration: {}
-	}, ...modules];
-}
 function shouldInjectRedirect(flow, modules, options) {
 	return options.isDesktop === true && flow.redirectDesktopToMobile === true && !hasModule(modules, "REDIRECT_TO_MOBILE");
 }
 function addRedirect(flow, modules, options) {
-	const modulesWithoutHome = modules.filter((module) => module.key !== "HOME");
 	return [{
 		key: "REDIRECT_TO_MOBILE",
 		configuration: {
@@ -93,7 +85,7 @@ function addRedirect(flow, modules, options) {
 			authHint: options.authHint,
 			lang: options.lang
 		}
-	}, ...modulesWithoutHome];
+	}, ...modules];
 }
 function hasModule(modules, key) {
 	return modules.some((module) => module.key === key);

package/dist/home.d.ts

@@ -2,7 +2,7 @@ import { t as Manager } from "./Manager-C1r-74H0.js";
 import "./camera-C1Lz6NFz.js";
 import "./types-DGwsRYfm.js";
 import { t as EmptyConfig } from "./types-x6tue2ld.js";
-import * as xstate149 from "xstate";
+import * as xstate1140 from "xstate";
 
 //#region src/modules/home/types.d.ts
 type HomeConfig = EmptyConfig;
@@ -34,41 +34,41 @@ type HomeContext = {
 type HomeInput = {
   config: EmptyConfig;
 };
-declare const homeMachine: xstate149.StateMachine<HomeContext, {
+declare const homeMachine: xstate1140.StateMachine<HomeContext, {
   type: "LOAD";
 } | {
   type: "COMPLETE";
 } | {
   type: "RESET";
-}, {}, never, never, never, never, "idle" | "finished" | "main", string, HomeInput, xstate149.NonReducibleUnknown, xstate149.EventObject, xstate149.MetaObject, {
+}, {}, never, never, never, never, "idle" | "finished" | "main", string, HomeInput, xstate1140.NonReducibleUnknown, xstate1140.EventObject, xstate1140.MetaObject, {
   readonly id: "home";
   readonly initial: "idle";
   readonly context: ({
     input
   }: {
     spawn: {
-      <TSrc extends never>(logic: TSrc, ...[options]: never): xstate149.ActorRefFromLogic<never>;
-      <TLogic extends xstate149.AnyActorLogic>(src: TLogic, ...[options]: xstate149.ConditionalRequired<[options?: ({
+      <TSrc extends never>(logic: TSrc, ...[options]: never): xstate1140.ActorRefFromLogic<never>;
+      <TLogic extends xstate1140.AnyActorLogic>(src: TLogic, ...[options]: xstate1140.ConditionalRequired<[options?: ({
         id?: never;
         systemId?: string;
-        input?: xstate149.InputFrom<TLogic> | undefined;
+        input?: xstate1140.InputFrom<TLogic> | undefined;
         syncSnapshot?: boolean;
-      } & { [K in xstate149.RequiredLogicInput<TLogic>]: unknown }) | undefined], xstate149.IsNotNever<xstate149.RequiredLogicInput<TLogic>>>): xstate149.ActorRefFromLogic<TLogic>;
+      } & { [K in xstate1140.RequiredLogicInput<TLogic>]: unknown }) | undefined], xstate1140.IsNotNever<xstate1140.RequiredLogicInput<TLogic>>>): xstate1140.ActorRefFromLogic<TLogic>;
     };
     input: HomeInput;
-    self: xstate149.ActorRef<xstate149.MachineSnapshot<HomeContext, {
+    self: xstate1140.ActorRef<xstate1140.MachineSnapshot<HomeContext, {
       type: "LOAD";
     } | {
       type: "COMPLETE";
     } | {
       type: "RESET";
-    }, Record<string, xstate149.AnyActorRef | undefined>, xstate149.StateValue, string, unknown, any, any>, {
+    }, Record<string, xstate1140.AnyActorRef | undefined>, xstate1140.StateValue, string, unknown, any, any>, {
       type: "LOAD";
     } | {
       type: "COMPLETE";
     } | {
       type: "RESET";
-    }, xstate149.AnyEventObject>;
+    }, xstate1140.AnyEventObject>;
   }) => {
     config: EmptyConfig;
   };