wizzard-stepper-react 1.3.1 → 1.5.0

package/dist/index.cjs

@@ -25,12 +25,20 @@ __export(index_exports, {
   LocalStorageAdapter: () => LocalStorageAdapter,
   MemoryAdapter: () => MemoryAdapter,
   WizardProvider: () => WizardProvider,
+  WizardStepRenderer: () => WizardStepRenderer,
+  WizardStore: () => WizardStore,
   YupAdapter: () => YupAdapter,
   ZodAdapter: () => ZodAdapter,
+  createWizardFactory: () => createWizardFactory,
   getByPath: () => getByPath,
   setByPath: () => setByPath,
   useWizard: () => useWizard,
-  useWizardContext: () => useWizardContext
+  useWizardActions: () => useWizardActions,
+  useWizardContext: () => useWizardContext,
+  useWizardError: () => useWizardError,
+  useWizardSelector: () => useWizardSelector,
+  useWizardState: () => useWizardState,
+  useWizardValue: () => useWizardValue
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -66,6 +74,9 @@ function getByPath(obj, path, defaultValue) {
 }
 function setByPath(obj, path, value) {
   if (!path) return value;
+  if (!path.includes(".") && !path.includes("[") && !path.includes("]")) {
+    return { ...obj, [path]: value };
+  }
   const keys = path.replace(/\[(\d+)\]/g, ".$1").split(".").filter(Boolean);
   const update = (current, index) => {
     if (index === keys.length) return value;
@@ -86,39 +97,93 @@ function setByPath(obj, path, value) {
 
 // src/context/WizardContext.tsx
 var import_jsx_runtime = require("react/jsx-runtime");
-var WizardContext = (0, import_react.createContext)(void 0);
+var WizardStateContext = (0, import_react.createContext)(
+  void 0
+);
+var WizardActionsContext = (0, import_react.createContext)(
+  void 0
+);
+var WizardStore = class {
+  constructor(initialData) {
+    __publicField(this, "state");
+    __publicField(this, "listeners", /* @__PURE__ */ new Set());
+    __publicField(this, "getSnapshot", () => this.state);
+    __publicField(this, "subscribe", (listener) => {
+      this.listeners.add(listener);
+      return () => this.listeners.delete(listener);
+    });
+    this.state = { data: initialData, errors: {} };
+  }
+  update(newData) {
+    this.state = { ...this.state, data: newData };
+    this.notify();
+  }
+  updateErrors(newErrors) {
+    this.state = { ...this.state, errors: newErrors };
+    this.notify();
+  }
+  notify() {
+    this.listeners.forEach((l) => l());
+  }
+};
 function WizardProvider({
   config,
   initialData,
+  initialStepId,
   children
 }) {
   const [currentStepId, setCurrentStepId] = (0, import_react.useState)("");
-  const [wizardData, setWizardData] = (0, import_react.useState)(initialData || {});
   const [visitedSteps, setVisitedSteps] = (0, import_react.useState)(/* @__PURE__ */ new Set());
   const [completedSteps, setCompletedSteps] = (0, import_react.useState)(/* @__PURE__ */ new Set());
   const [errorSteps, setErrorSteps] = (0, import_react.useState)(/* @__PURE__ */ new Set());
-  const [allErrors, setAllErrors] = (0, import_react.useState)({});
+  const [, setAllErrorsState] = (0, import_react.useState)({});
   const [isLoading, setIsLoading] = (0, import_react.useState)(true);
+  const [isPending, startTransition] = (0, import_react.useTransition)();
+  const storeRef = (0, import_react.useRef)(new WizardStore(initialData || {}));
+  const [wizardData, setWizardData] = (0, import_react.useState)(initialData || {});
   const persistenceAdapter = (0, import_react.useMemo)(() => {
     return config.persistence?.adapter || new MemoryAdapter();
   }, [config.persistence?.adapter]);
   const persistenceMode = config.persistence?.mode || "onStepChange";
-  const activeSteps = (0, import_react.useMemo)(() => {
-    return config.steps.filter((step) => {
+  const [activeSteps, setActiveSteps] = (0, import_react.useState)(
+    () => config.steps.filter((s) => !s.condition || s.condition(wizardData))
+  );
+  (0, import_react.useEffect)(() => {
+    const nextActiveSteps = config.steps.filter((step) => {
       if (step.condition) {
         return step.condition(wizardData);
       }
       return true;
     });
-  }, [config.steps, wizardData]);
+    const currentIds = activeSteps.map((s) => s.id).join(",");
+    const nextIds = nextActiveSteps.map((s) => s.id).join(",");
+    if (currentIds !== nextIds) {
+      setActiveSteps(nextActiveSteps);
+    }
+  }, [config.steps, wizardData, activeSteps]);
   (0, import_react.useEffect)(() => {
     if (!currentStepId && activeSteps.length > 0) {
-      setCurrentStepId(activeSteps[0].id);
+      if (initialStepId) {
+        const target = activeSteps.find((s) => s.id === initialStepId);
+        if (target) {
+          setCurrentStepId(target.id);
+        } else {
+          setCurrentStepId(activeSteps[0].id);
+        }
+      } else {
+        setCurrentStepId(activeSteps[0].id);
+      }
       setIsLoading(false);
     }
-  }, [activeSteps, currentStepId]);
-  const currentStep = (0, import_react.useMemo)(() => activeSteps.find((s) => s.id === currentStepId) || null, [activeSteps, currentStepId]);
-  const currentStepIndex = (0, import_react.useMemo)(() => activeSteps.findIndex((s) => s.id === currentStepId), [activeSteps, currentStepId]);
+  }, [activeSteps, currentStepId, initialStepId]);
+  const currentStep = (0, import_react.useMemo)(
+    () => activeSteps.find((s) => s.id === currentStepId) || null,
+    [activeSteps, currentStepId]
+  );
+  const currentStepIndex = (0, import_react.useMemo)(
+    () => activeSteps.findIndex((s) => s.id === currentStepId),
+    [activeSteps, currentStepId]
+  );
   const isFirstStep = currentStepIndex === 0;
   const isLastStep = currentStepIndex === activeSteps.length - 1;
   const META_KEY = "__wizzard_meta__";
@@ -138,103 +203,186 @@ function WizardProvider({
       }
     });
     if (Object.keys(loadedData).length > 0) {
-      setWizardData((prev) => ({ ...prev, ...loadedData }));
+      setWizardData((prev) => {
+        const newData = { ...prev, ...loadedData };
+        storeRef.current.update(newData);
+        return newData;
+      });
     }
     setIsLoading(false);
   }, [config.steps, persistenceAdapter]);
   (0, import_react.useEffect)(() => {
     hydrate();
   }, [hydrate]);
-  const saveData = (0, import_react.useCallback)((mode, stepId, data) => {
-    if (mode === persistenceMode || mode === "manual") {
-      persistenceAdapter.saveStep(stepId, data);
-    }
-  }, [persistenceAdapter, persistenceMode]);
-  const setStepData = (0, import_react.useCallback)((stepId, data) => {
-    setWizardData((prev) => {
-      const newData = { ...prev, ...data };
+  const saveData = (0, import_react.useCallback)(
+    (mode, stepId, data) => {
+      const stepConfig = config.steps.find((s) => s.id === stepId);
+      const stepAdapter = stepConfig?.persistenceAdapter;
+      const adapterToUse = stepAdapter || persistenceAdapter;
+      if (mode === persistenceMode || mode === "manual") {
+        adapterToUse.saveStep(stepId, data);
+      }
+    },
+    [persistenceAdapter, persistenceMode, config.steps]
+  );
+  const validationTimeoutRef = (0, import_react.useRef)(
+    null
+  );
+  const validateStep = (0, import_react.useCallback)(
+    async (stepId, data) => {
+      const step = config.steps.find((s) => s.id === stepId);
+      if (!step || !step.validationAdapter) return true;
+      const result = await step.validationAdapter.validate(data);
+      if (!result.isValid) {
+        const newAllErrors = {
+          ...storeRef.current.getSnapshot().errors,
+          [stepId]: result.errors || {}
+        };
+        storeRef.current.updateErrors(newAllErrors);
+        setAllErrorsState(newAllErrors);
+        setErrorSteps((prev) => {
+          const next = new Set(prev);
+          next.add(stepId);
+          return next;
+        });
+        return false;
+      } else {
+        const newAllErrors = { ...storeRef.current.getSnapshot().errors };
+        delete newAllErrors[stepId];
+        storeRef.current.updateErrors(newAllErrors);
+        setAllErrorsState(newAllErrors);
+        setErrorSteps((prev) => {
+          const next = new Set(prev);
+          next.delete(stepId);
+          return next;
+        });
+        return true;
+      }
+    },
+    [config.steps]
+  );
+  const setStepData = (0, import_react.useCallback)(
+    (stepId, data) => {
+      const prevData = storeRef.current.getSnapshot().data;
+      const newData = { ...prevData, ...data };
+      storeRef.current.update(newData);
+      startTransition(() => {
+        setWizardData(newData);
+      });
       if (persistenceMode === "onChange") {
         saveData("onChange", stepId, newData);
       }
-      return newData;
-    });
-  }, [persistenceMode, saveData]);
-  const setData = (0, import_react.useCallback)((path, value2) => {
-    setWizardData((prev) => {
-      const newData = setByPath(prev, path, value2);
+    },
+    [persistenceMode, saveData]
+  );
+  const setData = (0, import_react.useCallback)(
+    (path, value, options) => {
+      const prevData = storeRef.current.getSnapshot().data;
+      const newData = setByPath(prevData, path, value);
+      storeRef.current.update(newData);
+      startTransition(() => {
+        setWizardData(newData);
+      });
+      if (options?.debounceValidation) {
+        if (validationTimeoutRef.current)
+          clearTimeout(validationTimeoutRef.current);
+        validationTimeoutRef.current = setTimeout(() => {
+          try {
+            validateStep(currentStepId, newData).catch((err) => {
+              console.error("[Wizard] Debounced validation failed:", err);
+            });
+          } catch (e) {
+            console.error("[Wizard] Error starting validation:", e);
+          }
+        }, options.debounceValidation);
+      } else {
+        validateStep(currentStepId, newData);
+      }
       if (persistenceMode === "onChange") {
         saveData("onChange", currentStepId, newData);
       }
-      return newData;
-    });
-  }, [persistenceMode, saveData, currentStepId]);
-  const getData = (0, import_react.useCallback)((path, defaultValue) => {
-    return getByPath(wizardData, path, defaultValue);
-  }, [wizardData]);
-  const handleStepChange = (0, import_react.useCallback)((field, value2) => {
-    if (!currentStepId) return;
-    setData(field, value2);
-  }, [setData, currentStepId]);
-  const validateStep = (0, import_react.useCallback)(async (stepId) => {
-    const step = config.steps.find((s) => s.id === stepId);
-    if (!step) return true;
-    if (!step.validationAdapter) return true;
-    const result = await step.validationAdapter.validate(wizardData);
-    if (!result.isValid) {
-      setAllErrors((prev) => ({
-        ...prev,
-        [stepId]: result.errors || {}
-      }));
-      setErrorSteps((prev) => new Set(prev).add(stepId));
-      return false;
-    } else {
-      setAllErrors((prev) => {
-        const next = { ...prev };
-        delete next[stepId];
-        return next;
+    },
+    [persistenceMode, saveData, currentStepId, validateStep]
+  );
+  const updateData = (0, import_react.useCallback)(
+    (data, options) => {
+      const prevData = storeRef.current.getSnapshot().data;
+      const newData = options?.replace ? data : { ...prevData, ...data };
+      storeRef.current.update(newData);
+      startTransition(() => {
+        setWizardData(newData);
       });
-      setErrorSteps((prev) => {
-        const next = new Set(prev);
-        next.delete(stepId);
-        return next;
+      config.steps.forEach((step) => {
+        saveData("manual", step.id, newData);
       });
-      return true;
-    }
-  }, [config.steps, wizardData]);
+    },
+    [saveData, config.steps]
+  );
+  const getData = (0, import_react.useCallback)((path, defaultValue) => {
+    return getByPath(storeRef.current.getSnapshot().data, path, defaultValue);
+  }, []);
+  const handleStepChange = (0, import_react.useCallback)(
+    (field, value) => {
+      if (!currentStepId) return;
+      setData(field, value);
+    },
+    [setData, currentStepId]
+  );
   const validateAll = (0, import_react.useCallback)(async () => {
     let isValid = true;
+    const currentData = storeRef.current.getSnapshot().data;
     for (const step of activeSteps) {
-      const stepValid = await validateStep(step.id);
+      const stepValid = await validateStep(step.id, currentData);
       if (!stepValid) isValid = false;
     }
-    return isValid;
+    const finalErrors = storeRef.current.getSnapshot().errors;
+    return { isValid, errors: finalErrors };
   }, [activeSteps, validateStep]);
-  const goToStep = (0, import_react.useCallback)(async (stepId) => {
-    const targetIndex = activeSteps.findIndex((s) => s.id === stepId);
-    if (targetIndex === -1) return false;
-    if (targetIndex > currentStepIndex) {
-      const shouldValidate = currentStep?.autoValidate ?? config.autoValidate ?? true;
-      if (shouldValidate) {
-        const isValid = await validateStep(currentStepId);
-        if (!isValid) return false;
+  const goToStep = (0, import_react.useCallback)(
+    async (stepId) => {
+      const targetIndex = activeSteps.findIndex((s) => s.id === stepId);
+      if (targetIndex === -1) return false;
+      const currentData = storeRef.current.getSnapshot().data;
+      if (targetIndex > currentStepIndex) {
+        const shouldValidate = currentStep?.autoValidate ?? config.autoValidate ?? true;
+        if (shouldValidate) {
+          const isValid = await validateStep(currentStepId, currentData);
+          if (!isValid) return false;
+        }
       }
-    }
-    if (persistenceMode === "onStepChange" && currentStep) {
-      saveData("onStepChange", currentStepId, wizardData);
-    }
-    const nextVisited = new Set(visitedSteps).add(currentStepId);
-    setVisitedSteps(nextVisited);
-    setCurrentStepId(stepId);
-    if (persistenceMode !== "manual") {
-      persistenceAdapter.saveStep(META_KEY, {
-        currentStepId: stepId,
-        visited: Array.from(nextVisited),
-        completed: Array.from(completedSteps)
-      });
-    }
-    window.scrollTo(0, 0);
-    return true;
-  }, [activeSteps, currentStepId, currentStep, currentStepIndex, config.autoValidate, persistenceMode, saveData, wizardData, validateStep, visitedSteps, completedSteps, persistenceAdapter]);
+      if (persistenceMode === "onStepChange" && currentStep) {
+        saveData("onStepChange", currentStepId, currentData);
+      }
+      const nextVisited = new Set(visitedSteps).add(currentStepId);
+      setVisitedSteps(nextVisited);
+      setCurrentStepId(stepId);
+      if (persistenceMode !== "manual") {
+        persistenceAdapter.saveStep(META_KEY, {
+          currentStepId: stepId,
+          visited: Array.from(nextVisited),
+          completed: Array.from(completedSteps)
+        });
+      }
+      if (config.onStepChange) {
+        config.onStepChange(currentStepId, stepId, currentData);
+      }
+      window.scrollTo(0, 0);
+      return true;
+    },
+    [
+      activeSteps,
+      currentStepId,
+      currentStep,
+      currentStepIndex,
+      config.autoValidate,
+      persistenceMode,
+      saveData,
+      validateStep,
+      visitedSteps,
+      completedSteps,
+      persistenceAdapter
+    ]
+  );
   const goToNextStep = (0, import_react.useCallback)(async () => {
     if (isLastStep) return;
     const nextStep = activeSteps[currentStepIndex + 1];
@@ -248,12 +396,21 @@ function WizardProvider({
             currentStepId: nextStep.id,
             visited: Array.from(new Set(visitedSteps).add(currentStepId)),
             completed: Array.from(nextCompleted)
-            // Updated completed steps
           });
         }
       }
     }
-  }, [activeSteps, currentStepIndex, isLastStep, currentStepId, goToStep, visitedSteps, completedSteps, persistenceMode, persistenceAdapter]);
+  }, [
+    activeSteps,
+    currentStepIndex,
+    isLastStep,
+    currentStepId,
+    goToStep,
+    visitedSteps,
+    completedSteps,
+    persistenceMode,
+    persistenceAdapter
+  ]);
   const goToPrevStep = (0, import_react.useCallback)(() => {
     if (isFirstStep) return;
     const prevStep = activeSteps[currentStepIndex - 1];
@@ -261,45 +418,235 @@ function WizardProvider({
       goToStep(prevStep.id);
     }
   }, [activeSteps, currentStepIndex, isFirstStep, goToStep]);
-  const value = {
-    currentStep,
-    currentStepIndex,
-    isFirstStep,
-    isLastStep,
-    isLoading,
-    activeSteps,
-    wizardData,
-    allErrors,
-    visitedSteps,
-    completedSteps,
-    errorSteps,
-    goToNextStep,
-    goToPrevStep,
-    goToStep,
-    setStepData,
-    handleStepChange,
-    validateStep,
-    validateAll,
-    save: (0, import_react.useCallback)(() => saveData("manual", currentStepId, wizardData), [saveData, currentStepId, wizardData]),
-    clearStorage: (0, import_react.useCallback)(() => persistenceAdapter.clear(), [persistenceAdapter]),
-    setData,
-    getData
-  };
-  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(WizardContext.Provider, { value, children });
+  const clearStorage = (0, import_react.useCallback)(
+    () => persistenceAdapter.clear(),
+    [persistenceAdapter]
+  );
+  const save = (0, import_react.useCallback)(
+    () => saveData("manual", currentStepId, storeRef.current.getSnapshot().data),
+    [saveData, currentStepId]
+  );
+  const stateValue = (0, import_react.useMemo)(
+    () => ({
+      currentStep,
+      currentStepIndex,
+      isFirstStep,
+      isLastStep,
+      isLoading,
+      isPending,
+      activeSteps,
+      visitedSteps,
+      completedSteps,
+      errorSteps,
+      store: storeRef.current
+    }),
+    [
+      currentStep,
+      currentStepIndex,
+      isFirstStep,
+      isLastStep,
+      isLoading,
+      isPending,
+      activeSteps,
+      visitedSteps,
+      completedSteps,
+      errorSteps
+    ]
+  );
+  const actionsValue = (0, import_react.useMemo)(
+    () => ({
+      goToNextStep,
+      goToPrevStep,
+      goToStep,
+      setStepData,
+      handleStepChange,
+      validateStep: (sid) => validateStep(sid, storeRef.current.getSnapshot().data),
+      validateAll,
+      save,
+      clearStorage,
+      setData,
+      updateData,
+      getData
+    }),
+    [
+      goToNextStep,
+      goToPrevStep,
+      goToStep,
+      setStepData,
+      handleStepChange,
+      validateStep,
+      validateAll,
+      save,
+      clearStorage,
+      setData,
+      updateData,
+      getData
+    ]
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(WizardStateContext.Provider, { value: stateValue, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(WizardActionsContext.Provider, { value: actionsValue, children }) });
 }
-function useWizardContext() {
-  const context = (0, import_react.useContext)(WizardContext);
+function useWizardState() {
+  const context = (0, import_react.useContext)(WizardStateContext);
+  if (!context) {
+    throw new Error("useWizardState must be used within a WizardProvider");
+  }
+  return context;
+}
+function useWizardValue(path) {
+  const { store } = useWizardState();
+  const lastStateRef = (0, import_react.useRef)(null);
+  const lastValueRef = (0, import_react.useRef)(null);
+  const getSnapshot = (0, import_react.useCallback)(() => {
+    const fullState = store.getSnapshot();
+    const data = fullState.data;
+    if (data === lastStateRef.current) {
+      return lastValueRef.current;
+    }
+    const value = getByPath(data, path);
+    lastStateRef.current = data;
+    lastValueRef.current = value;
+    return value;
+  }, [store, path]);
+  return (0, import_react.useSyncExternalStore)(store.subscribe, getSnapshot);
+}
+function useWizardError(path) {
+  const { store } = useWizardState();
+  const lastStateRef = (0, import_react.useRef)(null);
+  const lastValueRef = (0, import_react.useRef)(null);
+  const getSnapshot = (0, import_react.useCallback)(() => {
+    const fullState = store.getSnapshot();
+    const errors = fullState.errors;
+    if (errors === lastStateRef.current) {
+      return lastValueRef.current;
+    }
+    let foundError;
+    Object.values(errors).forEach((stepErrors) => {
+      const typedStepErrors = stepErrors;
+      if (typedStepErrors[path]) foundError = typedStepErrors[path];
+    });
+    lastStateRef.current = errors;
+    lastValueRef.current = foundError;
+    return foundError;
+  }, [store, path]);
+  return (0, import_react.useSyncExternalStore)(store.subscribe, getSnapshot);
+}
+function useWizardSelector(selector) {
+  const { store } = useWizardState();
+  const lastStateRef = (0, import_react.useRef)(null);
+  const lastResultRef = (0, import_react.useRef)(null);
+  const getSnapshot = (0, import_react.useCallback)(() => {
+    const fullState = store.getSnapshot();
+    if (fullState === lastStateRef.current) {
+      return lastResultRef.current;
+    }
+    const result = selector(fullState.data);
+    lastStateRef.current = fullState;
+    lastResultRef.current = result;
+    return result;
+  }, [store, selector]);
+  return (0, import_react.useSyncExternalStore)(store.subscribe, getSnapshot);
+}
+function useWizardActions() {
+  const context = (0, import_react.useContext)(WizardActionsContext);
   if (!context) {
-    throw new Error("useWizardContext must be used within a WizardProvider");
+    throw new Error("useWizardActions must be used within a WizardProvider");
   }
   return context;
 }
+function useWizardContext() {
+  const state = useWizardState();
+  const actions = useWizardActions();
+  const wizardData = useWizardSelector((s) => s);
+  const fullState = state.store.getSnapshot();
+  return (0, import_react.useMemo)(
+    () => ({
+      ...state,
+      ...actions,
+      wizardData,
+      allErrors: fullState.errors
+    }),
+    [state, actions, wizardData, fullState.errors]
+  );
+}
+
+// src/components/WizardStepRenderer.tsx
+var import_react2 = require("react");
+var import_jsx_runtime2 = require("react/jsx-runtime");
+var WizardStepRenderer = ({
+  wrapper: Wrapper
+}) => {
+  const { currentStep } = useWizardContext();
+  const StepComponent = (0, import_react2.useMemo)(() => {
+    if (!currentStep?.component) return null;
+    return currentStep.component;
+  }, [currentStep]);
+  if (!currentStep || !StepComponent) {
+    return null;
+  }
+  const content = /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(StepComponent, {});
+  if (Wrapper) {
+    return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Wrapper, { children: content }, currentStep.id);
+  }
+  return content;
+};
 
 // src/hooks/useWizard.ts
 var useWizard = () => {
   return useWizardContext();
 };
 
+// src/factory.tsx
+var import_jsx_runtime3 = require("react/jsx-runtime");
+function createWizardFactory() {
+  const WizardProvider2 = ({
+    config,
+    initialData,
+    children
+  }) => {
+    return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+      WizardProvider,
+      {
+        config,
+        initialData,
+        children
+      }
+    );
+  };
+  const useWizard2 = () => {
+    return useWizard();
+  };
+  const useWizardContext2 = () => {
+    return useWizardContext();
+  };
+  const useWizardValue2 = (path) => {
+    return useWizardValue(path);
+  };
+  const useWizardSelector2 = (selector) => {
+    return useWizardSelector(selector);
+  };
+  const useWizardError2 = (path) => {
+    return useWizardError(path);
+  };
+  const useWizardActions2 = () => {
+    return useWizardActions();
+  };
+  const useWizardState2 = () => {
+    return useWizardState();
+  };
+  const createStep = (config) => config;
+  return {
+    WizardProvider: WizardProvider2,
+    useWizard: useWizard2,
+    useWizardContext: useWizardContext2,
+    useWizardValue: useWizardValue2,
+    useWizardSelector: useWizardSelector2,
+    useWizardError: useWizardError2,
+    useWizardActions: useWizardActions2,
+    useWizardState: useWizardState2,
+    createStep
+  };
+}
+
 // src/adapters/persistence/LocalStorageAdapter.ts
 var LocalStorageAdapter = class {
   constructor(prefix = "wizard_") {
@@ -349,16 +696,17 @@ var ZodAdapter = class {
       return { isValid: true };
     }
     const errors = {};
-    result.error.issues.forEach((err) => {
-      const path = err.path.join(".");
-      errors[path] = err.message;
-    });
+    if (result.error) {
+      result.error.issues.forEach((err) => {
+        const path = err.path.join(".");
+        errors[path] = err.message;
+      });
+    }
     return { isValid: false, errors };
   }
 };
 
 // src/adapters/validation/YupAdapter.ts
-var import_yup = require("yup");
 var YupAdapter = class {
   constructor(schema) {
     __publicField(this, "schema");
@@ -369,9 +717,10 @@ var YupAdapter = class {
       await this.schema.validate(data, { abortEarly: false });
       return { isValid: true };
     } catch (err) {
-      if (err instanceof import_yup.ValidationError) {
+      if (err && typeof err === "object" && "inner" in err) {
+        const yupError = err;
         const errors = {};
-        err.inner.forEach((error) => {
+        yupError.inner.forEach((error) => {
           if (error.path) {
             errors[error.path] = error.message;
           }
@@ -387,11 +736,19 @@ var YupAdapter = class {
   LocalStorageAdapter,
   MemoryAdapter,
   WizardProvider,
+  WizardStepRenderer,
+  WizardStore,
   YupAdapter,
   ZodAdapter,
+  createWizardFactory,
   getByPath,
   setByPath,
   useWizard,
-  useWizardContext
+  useWizardActions,
+  useWizardContext,
+  useWizardError,
+  useWizardSelector,
+  useWizardState,
+  useWizardValue
 });
 //# sourceMappingURL=index.cjs.map