@incodetech/web 2.2.0 → 2.3.0-rc.1

package/dist/useModuleLoader-DpcbSKBH.js

@@ -0,0 +1,176 @@
+import { _ as y, c as A, f as d } from "./vendor-preact-C0jX1Cbq.js";
+//#region src/modules/flow/headlessModule.ts
+var HeadlessWorkflowModule = () => null;
+var lazyHeadlessWorkflowModule = () => Promise.resolve(HeadlessWorkflowModule);
+var HEADLESS_WORKFLOW_MODULE_KEYS = new Set(["IDENTITY_SEARCH"]);
+//#endregion
+//#region src/modules/flow/useModuleLoader.ts
+function getLoadErrorMessage(error, fallbackMessage) {
+	return error instanceof Error ? error.message : fallbackMessage;
+}
+var loadedComponents = /* @__PURE__ */ new WeakMap();
+var inflightLoaders = /* @__PURE__ */ new WeakMap();
+function getLoaderKey(loader) {
+	return loader;
+}
+function getCachedComponent(loader) {
+	if (!loader) return void 0;
+	return loadedComponents.get(getLoaderKey(loader));
+}
+function loadComponent(loader) {
+	const key = getLoaderKey(loader);
+	const cached = loadedComponents.get(key);
+	if (cached) return Promise.resolve(cached);
+	const inflight = inflightLoaders.get(key);
+	if (inflight) return inflight;
+	const promise = loader().then((Component) => {
+		loadedComponents.set(key, Component);
+		inflightLoaders.delete(key);
+		return Component;
+	}).catch((error) => {
+		inflightLoaders.delete(key);
+		throw error;
+	});
+	inflightLoaders.set(key, promise);
+	return promise;
+}
+function computeInitialState(loader) {
+	if (!loader) return { status: "idle" };
+	const cached = getCachedComponent(loader);
+	if (cached) return {
+		status: "loaded",
+		Component: cached
+	};
+	return { status: "loading" };
+}
+function resolveModuleLoader(moduleKey, modules, headlessModuleKeys) {
+	if (!moduleKey) return void 0;
+	return modules[moduleKey] ?? (headlessModuleKeys?.has(moduleKey) ? lazyHeadlessWorkflowModule : void 0);
+}
+function useLazyComponentLoader(options) {
+	const { loader, onLoading, onLoaded, onError } = options;
+	const [state, setState] = d(() => computeInitialState(loader));
+	const prevLoaderRef = A(loader);
+	const onLoadingRef = A(onLoading);
+	const onLoadedRef = A(onLoaded);
+	const onErrorRef = A(onError);
+	y(() => {
+		onLoadingRef.current = onLoading;
+		onLoadedRef.current = onLoaded;
+		onErrorRef.current = onError;
+	}, [
+		onLoading,
+		onLoaded,
+		onError
+	]);
+	if (prevLoaderRef.current !== loader) {
+		prevLoaderRef.current = loader;
+		setState(computeInitialState(loader));
+	}
+	y(() => {
+		if (!loader) return;
+		if (getCachedComponent(loader)) {
+			onLoadedRef.current?.();
+			return;
+		}
+		onLoadingRef.current?.();
+		let cancelled = false;
+		loadComponent(loader).then((Component) => {
+			if (!cancelled) {
+				setState({
+					status: "loaded",
+					Component
+				});
+				onLoadedRef.current?.();
+			}
+		}).catch((error) => {
+			if (!cancelled) {
+				const errorMessage = getLoadErrorMessage(error, "Failed to load component");
+				setState({
+					status: "error",
+					error: errorMessage
+				});
+				onErrorRef.current?.(errorMessage);
+			}
+		});
+		return () => {
+			cancelled = true;
+		};
+	}, [loader]);
+	return state;
+}
+function useModuleLoader(options) {
+	const { moduleKey, modules, headlessModuleKeys, onModuleLoading, onModuleLoaded, onError } = options;
+	const [unsupportedModuleKey, setUnsupportedModuleKey] = d(void 0);
+	const loader = resolveModuleLoader(moduleKey, modules, headlessModuleKeys);
+	const state = useLazyComponentLoader({
+		loader,
+		onLoading: moduleKey ? () => onModuleLoading?.(moduleKey) : void 0,
+		onLoaded: moduleKey ? () => onModuleLoaded?.(moduleKey) : void 0,
+		onError: moduleKey ? (errorMessage) => onError?.(`Failed to load ${moduleKey}: ${errorMessage}`) : void 0
+	});
+	y(() => {
+		if (!moduleKey) {
+			setUnsupportedModuleKey(void 0);
+			return;
+		}
+		if (!loader) setUnsupportedModuleKey(moduleKey);
+		else setUnsupportedModuleKey(void 0);
+	}, [loader, moduleKey]);
+	if (!moduleKey) return { status: "idle" };
+	if (unsupportedModuleKey) return {
+		status: "unsupported",
+		moduleKey: unsupportedModuleKey
+	};
+	if (state.status === "idle" || state.status === "loading") return {
+		status: "loading",
+		moduleKey
+	};
+	if (state.status === "error") return {
+		status: "error",
+		moduleKey,
+		error: state.error
+	};
+	return {
+		status: "loaded",
+		moduleKey,
+		Component: state.Component
+	};
+}
+function useModulePreloader(options) {
+	const { moduleKey, modules } = options;
+	const loader = moduleKey ? modules[moduleKey] : void 0;
+	const state = useLazyComponentLoader({ loader });
+	return loader != null && state.status === "loaded";
+}
+function schedulePrefetch(run) {
+	if (typeof requestIdleCallback !== "undefined") requestIdleCallback(() => {
+		run();
+	});
+	else setTimeout(run, 0);
+}
+function usePrefetchNextModule(steps, currentStepIndex, modules, currentModuleLoaded) {
+	const prefetchedRef = A(/* @__PURE__ */ new Set());
+	y(() => {
+		if (!currentModuleLoaded) return;
+		if (currentStepIndex < steps.length - 1) {
+			const nextStep = steps[currentStepIndex + 1];
+			if (nextStep && !prefetchedRef.current.has(nextStep)) {
+				prefetchedRef.current.add(nextStep);
+				const loader = modules[nextStep];
+				if (loader) schedulePrefetch(() => {
+					loader().catch(() => {
+						prefetchedRef.current.delete(nextStep);
+					});
+				});
+			}
+		}
+	}, [
+		steps,
+		currentStepIndex,
+		modules,
+		currentModuleLoaded
+	]);
+}
+//#endregion
+export { HEADLESS_WORKFLOW_MODULE_KEYS as a, usePrefetchNextModule as i, useModuleLoader as n, useModulePreloader as r, useLazyComponentLoader as t };