@pisell/materials 6.12.39 → 6.12.41

package/es/components/PisellSelectionFlow/hooks/useFlowModuleLifecycle.js

@@ -0,0 +1,236 @@
+import { _objectSpread2 } from "../../../_virtual/_@oxc-project_runtime@0.122.0/helpers/objectSpread2.js";
+import { _asyncToGenerator } from "../../../_virtual/_@oxc-project_runtime@0.122.0/helpers/asyncToGenerator.js";
+import { hasSelectionDraftFieldValue, resolveFlowModuleAdapter } from "../compiler.js";
+import { getSelectionFlowErrorMessage } from "../utils.js";
+import { useCallback, useEffect } from "react";
+//#region src/components/PisellSelectionFlow/hooks/useFlowModuleLifecycle.ts
+/** 负责依赖失效、清理、校正、刷新和异步 latest-wins。 */
+const useFlowModuleLifecycle = ({ registry, draftAdapter, createRuntimeIssue, mountedRef, flowGenerationRef, draftRevisionRef, draftRef, moduleRevisionRef, moduleInitializationRef, moduleDependencyLifecycleRef, pendingModuleChangeRef, compiledStepsRef, moduleStateRef, processDraftChangeRef, commitModuleState, getFreshContext, currentStep, configurationError, compiledSteps, resolvedCurrentStepIndex, draft, moduleState }) => {
+	processDraftChangeRef.current = useCallback((change) => {
+		const changedFields = new Set(change.changedFields);
+		const flowGeneration = flowGenerationRef.current;
+		if (!mountedRef.current) return;
+		for (const step of compiledStepsRef.current) for (const module of step.modules) {
+			if (module.key === change.sourceModuleKey) continue;
+			const adapter = resolveFlowModuleAdapter(registry, module.type);
+			if (!adapter) continue;
+			const dependencyChanged = [...new Set([...adapter.refreshOn || [], ...adapter.hardRequires || []])].some((field) => changedFields.has(field));
+			let shouldRefresh = dependencyChanged;
+			if (dependencyChanged && adapter.shouldRefresh) try {
+				const refreshContext = getFreshContext();
+				shouldRefresh = Boolean(refreshContext && adapter.shouldRefresh(refreshContext, change, module));
+			} catch (error) {
+				const revision = (moduleRevisionRef.current.get(module.key) || 0) + 1;
+				moduleRevisionRef.current.set(module.key, revision);
+				moduleInitializationRef.current.delete(module.key);
+				moduleDependencyLifecycleRef.current.delete(module.key);
+				commitModuleState(module.key, {
+					status: "error",
+					message: getSelectionFlowErrorMessage(error),
+					error
+				});
+				continue;
+			}
+			if (!shouldRefresh) continue;
+			const previousPendingChange = pendingModuleChangeRef.current.get(module.key);
+			const lifecycleChange = previousPendingChange ? _objectSpread2(_objectSpread2({}, change), {}, {
+				previousDraft: previousPendingChange.previousDraft,
+				changedFields: Array.from(new Set([...previousPendingChange.changedFields, ...change.changedFields]))
+			}) : change;
+			pendingModuleChangeRef.current.set(module.key, lifecycleChange);
+			const revision = (moduleRevisionRef.current.get(module.key) || 0) + 1;
+			moduleRevisionRef.current.set(module.key, revision);
+			commitModuleState(module.key, {
+				status: "loading",
+				reason: createRuntimeIssue("dependencies-reconciling")
+			});
+			let dependencyLifecycle;
+			const runDependencyLifecycle = () => Promise.resolve().then(_asyncToGenerator(function* () {
+				var _adapter$clearDepende, _adapter$reconcile;
+				const buildLifecycleContext = () => {
+					const freshContext = getFreshContext();
+					const isCurrentLifecycle = () => mountedRef.current && flowGenerationRef.current === flowGeneration && moduleRevisionRef.current.get(module.key) === revision;
+					if (!freshContext || !isCurrentLifecycle()) return null;
+					return _objectSpread2(_objectSpread2({}, freshContext), {}, {
+						updateDraft: (update, meta) => {
+							if (isCurrentLifecycle()) freshContext.updateDraft(update, meta);
+						},
+						setModuleState: (moduleKey, state) => {
+							if (isCurrentLifecycle()) freshContext.setModuleState(moduleKey, state);
+						},
+						setModuleStatus: (moduleKey, status, message, error) => {
+							if (isCurrentLifecycle()) freshContext.setModuleStatus(moduleKey, status, message, error);
+						},
+						setModuleData: (moduleKey, value) => {
+							if (isCurrentLifecycle()) freshContext.setModuleData(moduleKey, value);
+						},
+						clearModuleData: (moduleKey) => {
+							if (isCurrentLifecycle()) freshContext.clearModuleData(moduleKey);
+						}
+					});
+				};
+				const clearContext = buildLifecycleContext();
+				if (!clearContext) return false;
+				yield (_adapter$clearDepende = adapter.clearDependencies) === null || _adapter$clearDepende === void 0 ? void 0 : _adapter$clearDepende.call(adapter, clearContext, lifecycleChange, module);
+				const reconcileContext = buildLifecycleContext();
+				if (!reconcileContext) return false;
+				yield (_adapter$reconcile = adapter.reconcile) === null || _adapter$reconcile === void 0 ? void 0 : _adapter$reconcile.call(adapter, reconcileContext, lifecycleChange, module);
+				if (mountedRef.current && flowGenerationRef.current === flowGeneration && moduleRevisionRef.current.get(module.key) === revision) commitModuleState(module.key, { status: "stale" });
+				return true;
+			})).catch((error) => {
+				if (mountedRef.current && flowGenerationRef.current === flowGeneration && moduleRevisionRef.current.get(module.key) === revision) commitModuleState(module.key, {
+					status: "error",
+					message: getSelectionFlowErrorMessage(error),
+					error
+				});
+				return false;
+			});
+			const setLifecyclePromise = () => {
+				dependencyLifecycle.status = "pending";
+				const promise = runDependencyLifecycle();
+				dependencyLifecycle.promise = promise;
+				promise.then((success) => {
+					if (moduleDependencyLifecycleRef.current.get(module.key) !== dependencyLifecycle) return;
+					if (success) {
+						moduleDependencyLifecycleRef.current.delete(module.key);
+						if (pendingModuleChangeRef.current.get(module.key) === lifecycleChange) pendingModuleChangeRef.current.delete(module.key);
+					} else dependencyLifecycle.status = "failed";
+				});
+				return promise;
+			};
+			dependencyLifecycle = {
+				revision,
+				status: "pending",
+				promise: Promise.resolve(false),
+				retry: setLifecyclePromise
+			};
+			moduleDependencyLifecycleRef.current.set(module.key, dependencyLifecycle);
+			setLifecyclePromise();
+		}
+	}, [
+		commitModuleState,
+		createRuntimeIssue,
+		getFreshContext,
+		registry
+	]);
+	const ensureModuleReady = useCallback((module) => {
+		if (!mountedRef.current) return Promise.resolve(false);
+		const revision = moduleRevisionRef.current.get(module.key) || 0;
+		const flowGeneration = flowGenerationRef.current;
+		const existing = moduleInitializationRef.current.get(module.key);
+		if ((existing === null || existing === void 0 ? void 0 : existing.revision) === revision) return existing.promise;
+		const currentState = moduleStateRef.current[module.key];
+		const pendingDependencyLifecycle = moduleDependencyLifecycleRef.current.get(module.key);
+		if ((currentState === null || currentState === void 0 ? void 0 : currentState.status) === "ready" && (pendingDependencyLifecycle === null || pendingDependencyLifecycle === void 0 ? void 0 : pendingDependencyLifecycle.revision) !== revision) return Promise.resolve(true);
+		const isCurrentRun = () => mountedRef.current && flowGenerationRef.current === flowGeneration && (moduleRevisionRef.current.get(module.key) || 0) === revision;
+		const getRunContext = () => {
+			const freshContext = getFreshContext();
+			if (!freshContext || !isCurrentRun()) return null;
+			return _objectSpread2(_objectSpread2({}, freshContext), {}, {
+				updateDraft: (update, meta) => {
+					if (isCurrentRun()) freshContext.updateDraft(update, meta);
+				},
+				setModuleState: (moduleKey, state) => {
+					if (isCurrentRun()) freshContext.setModuleState(moduleKey, state);
+				},
+				setModuleStatus: (moduleKey, status, message, error) => {
+					if (isCurrentRun()) freshContext.setModuleStatus(moduleKey, status, message, error);
+				},
+				setModuleData: (moduleKey, value) => {
+					if (isCurrentRun()) freshContext.setModuleData(moduleKey, value);
+				},
+				clearModuleData: (moduleKey) => {
+					if (isCurrentRun()) freshContext.clearModuleData(moduleKey);
+				}
+			});
+		};
+		const run = _asyncToGenerator(function* () {
+			var _adapter$hardRequires;
+			const adapter = resolveFlowModuleAdapter(registry, module.type);
+			if (!adapter) return false;
+			const dependencyLifecycle = moduleDependencyLifecycleRef.current.get(module.key);
+			if ((dependencyLifecycle === null || dependencyLifecycle === void 0 ? void 0 : dependencyLifecycle.revision) === revision) {
+				if (!(dependencyLifecycle.status === "failed" ? yield dependencyLifecycle.retry() : yield dependencyLifecycle.promise) || !isCurrentRun()) return false;
+			}
+			let context = getRunContext();
+			if (!context) return false;
+			const missingField = (_adapter$hardRequires = adapter.hardRequires) === null || _adapter$hardRequires === void 0 ? void 0 : _adapter$hardRequires.find((field) => !hasSelectionDraftFieldValue(draftAdapter, draftRef.current, field));
+			if (missingField) {
+				if (isCurrentRun()) commitModuleState(module.key, {
+					status: "stale",
+					reason: createRuntimeIssue("waiting-field", { field: missingField })
+				});
+				return false;
+			}
+			try {
+				var _await$adapter$canIni, _adapter$canInitializ, _moduleStateRef$curre2;
+				const canInitialize = (_await$adapter$canIni = yield (_adapter$canInitializ = adapter.canInitialize) === null || _adapter$canInitializ === void 0 ? void 0 : _adapter$canInitializ.call(adapter, context, module)) !== null && _await$adapter$canIni !== void 0 ? _await$adapter$canIni : true;
+				if (!isCurrentRun()) return false;
+				if (!canInitialize) {
+					commitModuleState(module.key, {
+						status: "stale",
+						reason: createRuntimeIssue("prerequisites-not-ready")
+					});
+					return false;
+				}
+				do {
+					var _adapter$refresh, _moduleStateRef$curre;
+					commitModuleState(module.key, { status: "loading" });
+					context = getRunContext();
+					if (!context || !isCurrentRun()) return false;
+					yield (_adapter$refresh = adapter.refresh) === null || _adapter$refresh === void 0 ? void 0 : _adapter$refresh.call(adapter, context, module);
+					if (!isCurrentRun()) return false;
+					if (((_moduleStateRef$curre = moduleStateRef.current[module.key]) === null || _moduleStateRef$curre === void 0 ? void 0 : _moduleStateRef$curre.status) === "error") return false;
+				} while (((_moduleStateRef$curre2 = moduleStateRef.current[module.key]) === null || _moduleStateRef$curre2 === void 0 ? void 0 : _moduleStateRef$curre2.status) === "stale");
+				commitModuleState(module.key, { status: "ready" });
+				return true;
+			} catch (error) {
+				if (isCurrentRun()) commitModuleState(module.key, {
+					status: "error",
+					message: getSelectionFlowErrorMessage(error),
+					error
+				});
+				return false;
+			}
+		})();
+		const initialization = {
+			revision,
+			promise: run
+		};
+		moduleInitializationRef.current.set(module.key, initialization);
+		run.finally(() => {
+			if (moduleInitializationRef.current.get(module.key) === initialization) moduleInitializationRef.current.delete(module.key);
+		});
+		return run;
+	}, [
+		commitModuleState,
+		createRuntimeIssue,
+		draftAdapter,
+		getFreshContext,
+		registry
+	]);
+	useEffect(() => {
+		if (!currentStep || configurationError) return;
+		const backgroundModules = compiledSteps.flatMap((step) => step.modules).filter((module) => {
+			const adapter = resolveFlowModuleAdapter(registry, module.type);
+			return (adapter === null || adapter === void 0 ? void 0 : adapter.initializeWhileInactive) && module.stepIndex < resolvedCurrentStepIndex;
+		});
+		for (const module of [...currentStep.modules, ...backgroundModules]) {
+			var _moduleStateRef$curre3;
+			const status = ((_moduleStateRef$curre3 = moduleStateRef.current[module.key]) === null || _moduleStateRef$curre3 === void 0 ? void 0 : _moduleStateRef$curre3.status) || "idle";
+			if (status === "idle" || status === "stale") ensureModuleReady(module);
+		}
+	}, [
+		compiledSteps,
+		configurationError,
+		currentStep,
+		draft,
+		ensureModuleReady,
+		moduleState,
+		registry,
+		resolvedCurrentStepIndex
+	]);
+	return { ensureModuleReady };
+};
+//#endregion
+export { useFlowModuleLifecycle };

package/es/components/PisellSelectionFlow/hooks/useFlowNavigation.js

@@ -0,0 +1,320 @@
+import { _objectSpread2 } from "../../../_virtual/_@oxc-project_runtime@0.122.0/helpers/objectSpread2.js";
+import { _asyncToGenerator } from "../../../_virtual/_@oxc-project_runtime@0.122.0/helpers/asyncToGenerator.js";
+import { resolveFlowModuleAdapter } from "../compiler.js";
+import { getCompiledStepsFingerprint, getSelectionFlowErrorMessage, normalizeFlowBeforeLeaveResult, normalizeFlowValidationResult } from "../utils.js";
+import { useCallback } from "react";
+//#region src/components/PisellSelectionFlow/hooks/useFlowNavigation.ts
+/** 导航、校验与提交门禁独立于模块加载生命周期。 */
+const useFlowNavigation = ({ registry, draftAdapter, createRuntimeIssue, mountedRef, moduleStateRef, moduleRevisionRef, draftRevisionRef, flowGenerationRef, moduleHandlesRef, configurationErrorRef, compiledStepsRef, currentStepIndexRef, currentStepKeyRef, validatedCompletionRef, navigationRevisionRef, transitionPendingRef, completedRef, completionPromiseRef, isCompletingRef, draftRef, onCompleteRef, ensureModuleReady, commitModuleState, getFreshContext, onValidationFailed, setCurrentStepIndex, setCompletionError, setCompletionReason, setIsCompleting }) => {
+	const validateModule = useCallback(function() {
+		var _ref = _asyncToGenerator(function* (module) {
+			const adapter = resolveFlowModuleAdapter(registry, module.type);
+			if (!adapter || !mountedRef.current) return false;
+			const ready = yield ensureModuleReady(module);
+			if (!mountedRef.current || !ready) {
+				const state = moduleStateRef.current[module.key];
+				onValidationFailed === null || onValidationFailed === void 0 || onValidationFailed(module, {
+					message: state === null || state === void 0 ? void 0 : state.message,
+					reason: state === null || state === void 0 ? void 0 : state.reason
+				});
+				return false;
+			}
+			const validationRevision = moduleRevisionRef.current.get(module.key) || 0;
+			const validationDraftRevision = draftRevisionRef.current;
+			const validationGeneration = flowGenerationRef.current;
+			const isCurrentValidationRun = () => mountedRef.current && flowGenerationRef.current === validationGeneration && (moduleRevisionRef.current.get(module.key) || 0) === validationRevision;
+			const isCurrentValidation = () => isCurrentValidationRun() && draftRevisionRef.current === validationDraftRevision;
+			commitModuleState(module.key, { status: "loading" });
+			try {
+				var _handle$validate;
+				const context = getFreshContext();
+				if (!context) return false;
+				const validationContext = _objectSpread2(_objectSpread2({}, context), {}, {
+					updateDraft: (update, meta) => {
+						if (isCurrentValidation()) context.updateDraft(update, meta);
+					},
+					setModuleState: (moduleKey, state) => {
+						if (isCurrentValidation()) context.setModuleState(moduleKey, state);
+					},
+					setModuleStatus: (moduleKey, status, message, error) => {
+						if (isCurrentValidation()) context.setModuleStatus(moduleKey, status, message, error);
+					},
+					setModuleData: (moduleKey, value) => {
+						if (isCurrentValidation()) context.setModuleData(moduleKey, value);
+					},
+					clearModuleData: (moduleKey) => {
+						if (isCurrentValidation()) context.clearModuleData(moduleKey);
+					}
+				});
+				const handle = moduleHandlesRef.current.get(module.key) || null;
+				const result = normalizeFlowValidationResult(adapter.validate ? yield adapter.validate(validationContext, handle, module) : yield handle === null || handle === void 0 || (_handle$validate = handle.validate) === null || _handle$validate === void 0 ? void 0 : _handle$validate.call(handle));
+				if (!isCurrentValidation()) {
+					if (isCurrentValidationRun()) commitModuleState(module.key, {
+						status: "stale",
+						reason: createRuntimeIssue("selection-changed-validation")
+					});
+					return false;
+				}
+				if (!result.valid) {
+					const fallbackReason = result.message ? void 0 : createRuntimeIssue("module-validation-failed");
+					commitModuleState(module.key, {
+						status: "error",
+						message: result.message,
+						reason: fallbackReason
+					});
+					onValidationFailed === null || onValidationFailed === void 0 || onValidationFailed(module, {
+						message: result.message,
+						reason: fallbackReason
+					});
+					return false;
+				}
+				commitModuleState(module.key, { status: "ready" });
+				return true;
+			} catch (error) {
+				const message = getSelectionFlowErrorMessage(error);
+				if (isCurrentValidation()) {
+					commitModuleState(module.key, {
+						status: "error",
+						message,
+						error
+					});
+					onValidationFailed === null || onValidationFailed === void 0 || onValidationFailed(module, { message });
+				} else if (isCurrentValidationRun()) commitModuleState(module.key, {
+					status: "stale",
+					reason: createRuntimeIssue("selection-changed-validation")
+				});
+				return false;
+			}
+		});
+		return function(_x) {
+			return _ref.apply(this, arguments);
+		};
+	}(), [
+		commitModuleState,
+		ensureModuleReady,
+		createRuntimeIssue,
+		getFreshContext,
+		onValidationFailed,
+		registry
+	]);
+	const validateCurrentStep = useCallback(_asyncToGenerator(function* () {
+		if (configurationErrorRef.current) return false;
+		const step = compiledStepsRef.current[currentStepIndexRef.current];
+		if (!step) return false;
+		for (const module of step.modules) if (!(yield validateModule(module))) return false;
+		return true;
+	}), [validateModule]);
+	const runBeforeLeaveForCurrentStep = useCallback(_asyncToGenerator(function* () {
+		if (configurationErrorRef.current) return false;
+		const stepIndex = currentStepIndexRef.current;
+		const step = compiledStepsRef.current[stepIndex];
+		if (!step) return false;
+		for (const module of step.modules) {
+			const adapter = resolveFlowModuleAdapter(registry, module.type);
+			const handle = moduleHandlesRef.current.get(module.key) || null;
+			if (!((adapter === null || adapter === void 0 ? void 0 : adapter.beforeLeave) || (handle === null || handle === void 0 ? void 0 : handle.beforeLeave))) continue;
+			const draftRevision = draftRevisionRef.current;
+			const moduleRevision = moduleRevisionRef.current.get(module.key) || 0;
+			try {
+				var _handle$beforeLeave, _compiledStepsRef$cur;
+				const context = getFreshContext();
+				if (!context) return false;
+				const result = normalizeFlowBeforeLeaveResult((adapter === null || adapter === void 0 ? void 0 : adapter.beforeLeave) ? yield adapter.beforeLeave(context, handle, module) : yield handle === null || handle === void 0 || (_handle$beforeLeave = handle.beforeLeave) === null || _handle$beforeLeave === void 0 ? void 0 : _handle$beforeLeave.call(handle));
+				if (!mountedRef.current || currentStepIndexRef.current !== stepIndex || ((_compiledStepsRef$cur = compiledStepsRef.current[stepIndex]) === null || _compiledStepsRef$cur === void 0 ? void 0 : _compiledStepsRef$cur.key) !== step.key || draftRevisionRef.current !== draftRevision || (moduleRevisionRef.current.get(module.key) || 0) !== moduleRevision) {
+					commitModuleState(module.key, {
+						status: "stale",
+						reason: createRuntimeIssue("selection-changed-confirmation")
+					});
+					onValidationFailed === null || onValidationFailed === void 0 || onValidationFailed(module, { reason: createRuntimeIssue("selection-changed-confirmation") });
+					return false;
+				}
+				if (!result.allowed) {
+					if (result.message) {
+						commitModuleState(module.key, {
+							status: "error",
+							message: result.message
+						});
+						onValidationFailed === null || onValidationFailed === void 0 || onValidationFailed(module, { message: result.message });
+					}
+					return false;
+				}
+			} catch (error) {
+				const message = getSelectionFlowErrorMessage(error);
+				commitModuleState(module.key, {
+					status: "error",
+					message,
+					error
+				});
+				onValidationFailed === null || onValidationFailed === void 0 || onValidationFailed(module, { message });
+				return false;
+			}
+		}
+		return true;
+	}), [
+		commitModuleState,
+		createRuntimeIssue,
+		getFreshContext,
+		onValidationFailed,
+		registry
+	]);
+	const validateFlowForCompletion = useCallback(_asyncToGenerator(function* () {
+		validatedCompletionRef.current = null;
+		if (configurationErrorRef.current) return false;
+		const currentIndex = currentStepIndexRef.current;
+		const allSteps = compiledStepsRef.current;
+		const compiledFingerprint = getCompiledStepsFingerprint(allSteps);
+		const revisionFingerprint = allSteps.flatMap((step) => step.modules).map((module) => `${module.key}:${moduleRevisionRef.current.get(module.key) || 0}`).join("|");
+		const draftRevision = draftRevisionRef.current;
+		for (const step of allSteps) {
+			if (step.index >= currentIndex) break;
+			for (const module of step.modules) {
+				const state = moduleStateRef.current[module.key];
+				if ((state === null || state === void 0 ? void 0 : state.status) !== "ready") {
+					currentStepIndexRef.current = step.index;
+					currentStepKeyRef.current = step.key;
+					setCurrentStepIndex(step.index);
+					onValidationFailed === null || onValidationFailed === void 0 || onValidationFailed(module, {
+						message: state === null || state === void 0 ? void 0 : state.message,
+						reason: (state === null || state === void 0 ? void 0 : state.reason) || createRuntimeIssue("previous-step-review")
+					});
+					return false;
+				}
+			}
+		}
+		if (!(yield validateCurrentStep())) return false;
+		if (configurationErrorRef.current) return false;
+		const latestSteps = compiledStepsRef.current;
+		const latestCompiledFingerprint = getCompiledStepsFingerprint(latestSteps);
+		const latestRevisionFingerprint = latestSteps.flatMap((step) => step.modules).map((module) => `${module.key}:${moduleRevisionRef.current.get(module.key) || 0}`).join("|");
+		if (compiledFingerprint !== latestCompiledFingerprint || revisionFingerprint !== latestRevisionFingerprint || draftRevision !== draftRevisionRef.current) {
+			const targetStep = latestSteps.find((step) => step.modules.some((module) => {
+				var _moduleStateRef$curre;
+				return ((_moduleStateRef$curre = moduleStateRef.current[module.key]) === null || _moduleStateRef$curre === void 0 ? void 0 : _moduleStateRef$curre.status) !== "ready";
+			})) || latestSteps[0];
+			const targetModule = targetStep === null || targetStep === void 0 ? void 0 : targetStep.modules[0];
+			if (targetStep && targetModule) {
+				currentStepIndexRef.current = targetStep.index;
+				currentStepKeyRef.current = targetStep.key;
+				setCurrentStepIndex(targetStep.index);
+				onValidationFailed === null || onValidationFailed === void 0 || onValidationFailed(targetModule, { reason: createRuntimeIssue("changed-review") });
+			}
+			return false;
+		}
+		for (const step of latestSteps) for (const module of step.modules) {
+			const state = moduleStateRef.current[module.key];
+			if ((state === null || state === void 0 ? void 0 : state.status) === "ready") continue;
+			currentStepIndexRef.current = step.index;
+			currentStepKeyRef.current = step.key;
+			setCurrentStepIndex(step.index);
+			onValidationFailed === null || onValidationFailed === void 0 || onValidationFailed(module, {
+				message: state === null || state === void 0 ? void 0 : state.message,
+				reason: (state === null || state === void 0 ? void 0 : state.reason) || createRuntimeIssue("current-step-review")
+			});
+			return false;
+		}
+		validatedCompletionRef.current = {
+			draftRevision: draftRevisionRef.current,
+			compiledFingerprint: getCompiledStepsFingerprint(latestSteps),
+			moduleRevisionFingerprint: latestSteps.flatMap((step) => step.modules).map((module) => `${module.key}:${moduleRevisionRef.current.get(module.key) || 0}`).join("|")
+		};
+		return true;
+	}), [
+		createRuntimeIssue,
+		onValidationFailed,
+		validateCurrentStep
+	]);
+	const complete = useCallback(() => {
+		if (!mountedRef.current) return Promise.resolve(false);
+		if (completedRef.current) return Promise.resolve(true);
+		if (completionPromiseRef.current) return completionPromiseRef.current;
+		if (transitionPendingRef.current) return Promise.resolve(false);
+		transitionPendingRef.current = true;
+		const navigationRevision = navigationRevisionRef.current + 1;
+		navigationRevisionRef.current = navigationRevision;
+		isCompletingRef.current = true;
+		setIsCompleting(true);
+		const run = _asyncToGenerator(function* () {
+			try {
+				setCompletionError(void 0);
+				setCompletionReason(void 0);
+				if (!(yield validateFlowForCompletion())) return false;
+				if (!(yield runBeforeLeaveForCurrentStep())) return false;
+				const validated = validatedCompletionRef.current;
+				const latestSteps = compiledStepsRef.current;
+				if (!mountedRef.current || navigationRevisionRef.current !== navigationRevision || !validated || validated.draftRevision !== draftRevisionRef.current || validated.compiledFingerprint !== getCompiledStepsFingerprint(latestSteps) || validated.moduleRevisionFingerprint !== latestSteps.flatMap((step) => step.modules).map((module) => `${module.key}:${moduleRevisionRef.current.get(module.key) || 0}`).join("|")) {
+					if (mountedRef.current) setCompletionReason(createRuntimeIssue("changed-confirm-again"));
+					return false;
+				}
+				const snapshot = draftAdapter.createSnapshot ? draftAdapter.createSnapshot(draftRef.current) : draftRef.current;
+				const completionResult = yield onCompleteRef.current(snapshot);
+				if (!mountedRef.current || navigationRevisionRef.current !== navigationRevision) return false;
+				if (completionResult === false) return false;
+				completedRef.current = true;
+				return true;
+			} catch (error) {
+				if (mountedRef.current) setCompletionError(getSelectionFlowErrorMessage(error));
+				return false;
+			} finally {
+				isCompletingRef.current = false;
+				transitionPendingRef.current = false;
+				if (mountedRef.current) setIsCompleting(false);
+			}
+		})();
+		completionPromiseRef.current = run;
+		run.finally(() => {
+			if (completionPromiseRef.current === run) completionPromiseRef.current = null;
+		});
+		return run;
+	}, [
+		draftAdapter,
+		createRuntimeIssue,
+		runBeforeLeaveForCurrentStep,
+		setCompletionReason,
+		validateFlowForCompletion
+	]);
+	return {
+		validateCurrentStep,
+		runBeforeLeaveForCurrentStep,
+		complete,
+		next: useCallback(_asyncToGenerator(function* () {
+			if (!mountedRef.current || configurationErrorRef.current || transitionPendingRef.current) return false;
+			const currentIndex = currentStepIndexRef.current;
+			const allSteps = compiledStepsRef.current;
+			if (!allSteps[currentIndex]) return false;
+			if (currentIndex >= allSteps.length - 1) return complete();
+			const currentStepKey = allSteps[currentIndex].key;
+			const navigationRevision = navigationRevisionRef.current + 1;
+			navigationRevisionRef.current = navigationRevision;
+			transitionPendingRef.current = true;
+			try {
+				var _compiledStepsRef$cur2, _allSteps$nextIndex;
+				if (!(yield validateCurrentStep())) return false;
+				if (!(yield runBeforeLeaveForCurrentStep())) return false;
+				if (!mountedRef.current || navigationRevisionRef.current !== navigationRevision || currentStepIndexRef.current !== currentIndex || ((_compiledStepsRef$cur2 = compiledStepsRef.current[currentIndex]) === null || _compiledStepsRef$cur2 === void 0 ? void 0 : _compiledStepsRef$cur2.key) !== currentStepKey) return false;
+				const nextIndex = currentIndex + 1;
+				currentStepIndexRef.current = nextIndex;
+				currentStepKeyRef.current = (_allSteps$nextIndex = allSteps[nextIndex]) === null || _allSteps$nextIndex === void 0 ? void 0 : _allSteps$nextIndex.key;
+				setCurrentStepIndex(nextIndex);
+				return true;
+			} finally {
+				transitionPendingRef.current = false;
+			}
+		}), [
+			complete,
+			runBeforeLeaveForCurrentStep,
+			validateCurrentStep
+		]),
+		back: useCallback(() => {
+			var _compiledStepsRef$cur3;
+			if (!mountedRef.current || transitionPendingRef.current || currentStepIndexRef.current <= 0) return false;
+			navigationRevisionRef.current += 1;
+			const nextIndex = currentStepIndexRef.current - 1;
+			currentStepIndexRef.current = nextIndex;
+			currentStepKeyRef.current = (_compiledStepsRef$cur3 = compiledStepsRef.current[nextIndex]) === null || _compiledStepsRef$cur3 === void 0 ? void 0 : _compiledStepsRef$cur3.key;
+			setCurrentStepIndex(nextIndex);
+			return true;
+		}, [])
+	};
+};
+//#endregion
+export { useFlowNavigation };

package/es/components/PisellSelectionFlow/index.d.ts

@@ -0,0 +1,4 @@
+import { CompiledSelectionFlowModuleConfig, CompiledSelectionFlowStep, FlowModuleBeforeLeaveResult, FlowModuleBeforeLeaveReturn, FlowModuleDataMap, FlowModuleHandle, FlowModuleState, FlowModuleStateMap, FlowModuleStatus, FlowModuleValidationResult, FlowModuleValidationReturn, PisellSelectionFlowController, PisellSelectionFlowProps, SelectionFlowCompileError, SelectionFlowCompileIssue, SelectionFlowCompileIssueCode, SelectionFlowContextValue, SelectionFlowDraftAdapter, SelectionFlowDraftChange, SelectionFlowDraftUpdateMeta, SelectionFlowMessageCode, SelectionFlowMetadata, SelectionFlowModuleAdapter, SelectionFlowModuleConfig, SelectionFlowModuleInput, SelectionFlowModuleRegistry, SelectionFlowRef, SelectionFlowRuntimeIssue, SelectionFlowSnapshot, SelectionFlowStepConfig, SelectionFlowValidationFeedback } from "./types.js";
+import { _default } from "./PisellSelectionFlow.js";
+import { useSelectionFlowContext, useTypedSelectionFlowContext } from "./context.js";
+import { compileSelectionFlow, compileSelectionFlowSteps, hasSelectionDraftFieldValue, isSelectionModuleType, resolveFlowModuleAdapter } from "./compiler.js";