@wizzard-packages/core 0.1.0

package/dist/index.js

@@ -0,0 +1,848 @@
+// src/utils/data.ts
+var pathCache = /* @__PURE__ */ new Map();
+function toPath(path) {
+  if (!path) return [];
+  if (pathCache.has(path)) {
+    return pathCache.get(path);
+  }
+  let keys;
+  if (path.includes("[")) {
+    keys = path.replace(/\[(\d+)\]/g, ".$1").split(".").filter(Boolean);
+  } else {
+    keys = path.split(".").filter(Boolean);
+  }
+  pathCache.set(path, keys);
+  return keys;
+}
+function getByPath(obj, path, defaultValue) {
+  if (!path || obj === void 0 || obj === null) return defaultValue ?? obj;
+  if (!path.includes(".") && !path.includes("[")) {
+    const val = obj[path];
+    return val !== void 0 ? val : defaultValue;
+  }
+  const keys = toPath(path);
+  let result = obj;
+  for (let i = 0; i < keys.length; i++) {
+    if (result === void 0 || result === null) return defaultValue;
+    result = result[keys[i]];
+  }
+  return result !== void 0 ? result : defaultValue;
+}
+function setByPath(obj, path, value) {
+  if (!path) return value;
+  if (!path.includes(".") && !path.includes("[")) {
+    if (Array.isArray(obj)) {
+      const copy = [...obj];
+      copy[path] = value;
+      return copy;
+    }
+    return { ...obj, [path]: value };
+  }
+  const keys = toPath(path);
+  if (keys.length === 0) return value;
+  const root = Array.isArray(obj) ? [...obj] : { ...obj };
+  let current = root;
+  for (let i = 0; i < keys.length - 1; i++) {
+    const key = keys[i];
+    const nextKey = keys[i + 1];
+    const existing = current[key];
+    let nextLevel;
+    if (existing && typeof existing === "object") {
+      nextLevel = Array.isArray(existing) ? [...existing] : { ...existing };
+    } else {
+      const isNumeric = /^\d+$/.test(nextKey);
+      nextLevel = isNumeric ? [] : {};
+    }
+    current[key] = nextLevel;
+    current = nextLevel;
+  }
+  const lastKey = keys[keys.length - 1];
+  current[lastKey] = value;
+  return root;
+}
+function shallowEqual(a, b) {
+  if (Object.is(a, b)) return true;
+  if (typeof a !== "object" || a === null || typeof b !== "object" || b === null) {
+    return false;
+  }
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+  if (keysA.length !== keysB.length) return false;
+  for (let i = 0; i < keysA.length; i++) {
+    const key = keysA[i];
+    if (!Object.prototype.hasOwnProperty.call(b, key) || !Object.is(a[key], b[key])) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// src/store/WizardStore.ts
+var WizardStore = class {
+  constructor(initialData, middlewares = []) {
+    this.dirtyFields = /* @__PURE__ */ new Set();
+    this.listeners = /* @__PURE__ */ new Set();
+    this.actionListeners = /* @__PURE__ */ new Set();
+    this.errorsMap = /* @__PURE__ */ new Map();
+    this.persistenceDebounceTimers = /* @__PURE__ */ new Map();
+    this.stepsMap = /* @__PURE__ */ new Map();
+    /**
+     * Returns the current immutable snapshot of the wizard state.
+     */
+    this.getSnapshot = () => {
+      return this.state;
+    };
+    this.subscribe = (listener) => {
+      this.listeners.add(listener);
+      return () => this.listeners.delete(listener);
+    };
+    // Caching for condition resolution
+    this.conditionCache = /* @__PURE__ */ new Map();
+    this.initialData = typeof structuredClone === "function" ? structuredClone(initialData) : JSON.parse(JSON.stringify(initialData));
+    this.state = {
+      data: initialData,
+      errors: {},
+      isDirty: false,
+      dirtyFields: this.dirtyFields,
+      visitedSteps: /* @__PURE__ */ new Set(),
+      completedSteps: /* @__PURE__ */ new Set(),
+      errorSteps: /* @__PURE__ */ new Set(),
+      currentStep: null,
+      currentStepId: "",
+      currentStepIndex: 0,
+      isFirstStep: true,
+      isLastStep: false,
+      isLoading: true,
+      isPending: false,
+      isBusy: false,
+      activeSteps: [],
+      history: [],
+      busySteps: /* @__PURE__ */ new Set(),
+      progress: 0,
+      activeStepsCount: 0,
+      breadcrumbs: [],
+      config: {},
+      goToStepResult: null
+    };
+    this.middlewareChain = this.setupMiddlewares(middlewares);
+  }
+  // Cache for O(1) step lookup
+  subscribeToActions(listener) {
+    this.actionListeners.add(listener);
+    return () => this.actionListeners.delete(listener);
+  }
+  notifyActions(action) {
+    this.actionListeners.forEach((l) => l(action));
+  }
+  setupMiddlewares(middlewares) {
+    const middlewareAPI = {
+      getState: () => this.state.data,
+      getSnapshot: () => this.getSnapshot(),
+      dispatch: (action) => this.dispatch(action)
+    };
+    const chain = middlewares.map((middleware) => middleware(middlewareAPI));
+    return chain.reduceRight(
+      (next, middleware) => middleware(next),
+      this.internalDispatch.bind(this)
+    );
+  }
+  /**
+   * Processes an action through the middleware chain and updates the state.
+   * This is the primary way to trigger any state change in the wizard.
+   *
+   * @param action The action to perform
+   */
+  dispatch(action) {
+    this.middlewareChain(action);
+  }
+  /**
+   * Internal dispatch that actually performs the state updates
+   */
+  internalDispatch(action) {
+    this.notifyActions(action);
+    switch (action.type) {
+      case "INIT":
+        this.initialData = typeof structuredClone === "function" ? structuredClone(action.payload.data) : JSON.parse(JSON.stringify(action.payload.data));
+        const initialActiveSteps = action.payload.config.steps.filter((s) => !s.condition);
+        this.stepsMap.clear();
+        action.payload.config.steps.forEach((step) => {
+          this.stepsMap.set(step.id, step);
+        });
+        this.state = {
+          ...this.state,
+          data: action.payload.data,
+          config: action.payload.config,
+          activeSteps: initialActiveSteps,
+          activeStepsCount: initialActiveSteps.length
+        };
+        if (action.payload.config.persistence?.adapter) {
+          this.persistenceAdapter = action.payload.config.persistence.adapter;
+        }
+        this.notify();
+        break;
+      case "SET_CURRENT_STEP_ID":
+        if (this.state.currentStepId) {
+          this.handleStepChangePersistence(this.state.currentStepId);
+        }
+        this.state = {
+          ...this.state,
+          currentStepId: action.payload.stepId
+        };
+        this.notify();
+        break;
+      case "SET_HISTORY":
+        this.state = {
+          ...this.state,
+          history: action.payload.history
+        };
+        this.notify();
+        break;
+      case "SET_ACTIVE_STEPS":
+        this.state = {
+          ...this.state,
+          activeSteps: action.payload.steps,
+          activeStepsCount: action.payload.steps.length
+        };
+        this.notify();
+        break;
+      case "SET_DATA":
+        this.updateDataByPath(action.payload.path, action.payload.value, action.payload.options);
+        break;
+      case "UPDATE_DATA":
+        this.updateBulkData(action.payload.data, action.payload.options);
+        break;
+      case "VALIDATE_START":
+        this.state.busySteps.add(action.payload.stepId);
+        this.state = {
+          ...this.state,
+          busySteps: new Set(this.state.busySteps)
+        };
+        break;
+      case "VALIDATE_END":
+        this.state.busySteps.delete(action.payload.stepId);
+        this.state = {
+          ...this.state,
+          busySteps: new Set(this.state.busySteps)
+        };
+        if (action.payload.result.errors) {
+          this.setStepErrors(action.payload.stepId, action.payload.result.errors);
+        }
+        break;
+      case "SET_STEP_ERRORS":
+        this.setStepErrors(action.payload.stepId, action.payload.errors);
+        break;
+      case "RESET":
+        this.setInitialData(action.payload.data);
+        break;
+      case "SET_ERROR_STEPS":
+        this.state = { ...this.state, errorSteps: action.payload.steps };
+        break;
+      case "SET_VISITED_STEPS":
+        this.state = { ...this.state, visitedSteps: action.payload.steps };
+        this.saveMeta();
+        break;
+      case "SET_COMPLETED_STEPS":
+        this.state = { ...this.state, completedSteps: action.payload.steps };
+        this.saveMeta();
+        break;
+      case "RESTORE_SNAPSHOT":
+        this.state = { ...action.payload.snapshot };
+        this.saveMeta();
+        break;
+      case "GO_TO_STEP":
+        this.state = {
+          ...this.state,
+          goToStepResult: action.payload.result
+        };
+        if (action.payload.result === true) {
+          if (action.payload.nextVisitedSteps) {
+            this.dispatch({
+              type: "SET_VISITED_STEPS",
+              payload: {
+                steps: action.payload.nextVisitedSteps
+              }
+            });
+          }
+          if (action.payload.nextHistory) {
+            this.dispatch({
+              type: "SET_HISTORY",
+              payload: {
+                history: action.payload.nextHistory
+              }
+            });
+          }
+          if (action.payload.to) {
+            this.dispatch({
+              type: "SET_CURRENT_STEP_ID",
+              payload: {
+                stepId: action.payload.to
+              }
+            });
+          }
+        }
+        break;
+      case "UPDATE_META":
+        this.state = {
+          ...this.state,
+          ...action.payload.meta
+        };
+        if (action.payload.meta.visitedSteps || action.payload.meta.completedSteps || action.payload.meta.history || action.payload.meta.currentStepId) {
+          this.saveMeta();
+        }
+        break;
+    }
+    this.syncDerivedState();
+    this.notify();
+  }
+  // Refactor update methods to be called from internalDispatch
+  updateDataByPath(path, value, _options) {
+    const newData = setByPath(this.state.data, path, value);
+    if (newData === this.state.data) return;
+    this.update(newData, path);
+  }
+  updateBulkData(data, options) {
+    let newData;
+    if (options?.replace) {
+      newData = data;
+    } else {
+      newData = JSON.parse(JSON.stringify(this.state.data));
+      Object.keys(data).forEach((key) => {
+        newData[key] = data[key];
+      });
+    }
+    this.update(newData, Object.keys(data));
+  }
+  /**
+   * Performs a granular data update at a specific path.
+   * Automatically calculates dirty fields and triggers auto-save if configured.
+   *
+   * @param newData Full new data object
+   * @param changedPath Path(s) that were modified
+   */
+  update(newData, changedPath) {
+    if (changedPath) {
+      const paths = Array.isArray(changedPath) ? changedPath : [changedPath];
+      paths.forEach((path) => {
+        const initialValue = getByPath(this.initialData, path);
+        const newValue = getByPath(newData, path);
+        if (JSON.stringify(initialValue) !== JSON.stringify(newValue)) {
+          this.dirtyFields.add(path);
+        } else {
+          this.dirtyFields.delete(path);
+        }
+      });
+    }
+    this.state = {
+      ...this.state,
+      data: newData,
+      isDirty: this.dirtyFields.size > 0,
+      dirtyFields: new Set(this.dirtyFields)
+    };
+    if (changedPath) {
+      const paths = Array.isArray(changedPath) ? changedPath : [changedPath];
+      this.checkAutoSave(paths);
+    } else {
+      this.checkAutoSave(Object.keys(newData));
+    }
+    this.notify();
+  }
+  updateMeta(newMeta) {
+    this.dispatch({
+      type: "UPDATE_META",
+      payload: { meta: newMeta }
+    });
+  }
+  syncDerivedState() {
+    const { activeSteps, currentStepId, visitedSteps, completedSteps, errorSteps } = this.state;
+    const currentStepIndex = Math.max(
+      0,
+      activeSteps.findIndex((s) => s.id === currentStepId)
+    );
+    const currentStep = activeSteps[currentStepIndex] || null;
+    const breadcrumbs = activeSteps.map((step) => {
+      let status = "upcoming";
+      if (step.id === currentStepId) status = "current";
+      else if (errorSteps.has(step.id)) status = "error";
+      else if (completedSteps.has(step.id)) status = "completed";
+      else if (visitedSteps.has(step.id)) status = "visited";
+      return {
+        id: step.id,
+        label: step.label,
+        status
+      };
+    });
+    this.state = {
+      ...this.state,
+      currentStep,
+      currentStepIndex,
+      isFirstStep: currentStepIndex === 0,
+      isLastStep: activeSteps.length > 0 && currentStepIndex === activeSteps.length - 1,
+      progress: activeSteps.length > 0 ? Math.round((currentStepIndex + 1) / activeSteps.length * 100) : 0,
+      breadcrumbs
+    };
+  }
+  /**
+   * Sets the initial data for the wizard.
+   * Resets dirty tracking based on this new data.
+   */
+  setInitialData(data) {
+    this.initialData = typeof structuredClone === "function" ? structuredClone(data) : JSON.parse(JSON.stringify(data));
+    this.dirtyFields.clear();
+    this.state = {
+      ...this.state,
+      data,
+      isDirty: false,
+      dirtyFields: /* @__PURE__ */ new Set()
+    };
+    this.notify();
+  }
+  syncErrors() {
+    const newErrorsObj = {};
+    for (const [stepId, fieldErrors] of this.errorsMap.entries()) {
+      if (fieldErrors.size > 0) {
+        newErrorsObj[stepId] = Object.fromEntries(fieldErrors);
+      }
+    }
+    this.state = { ...this.state, errors: newErrorsObj };
+    this.notify();
+  }
+  updateErrors(newErrors) {
+    this.errorsMap.clear();
+    for (const [stepId, fieldErrors] of Object.entries(newErrors)) {
+      const stepMap = /* @__PURE__ */ new Map();
+      for (const [field, msg] of Object.entries(fieldErrors)) {
+        stepMap.set(field, msg);
+      }
+      if (stepMap.size > 0) this.errorsMap.set(stepId, stepMap);
+    }
+    this.state = { ...this.state, errors: newErrors };
+    this.notify();
+  }
+  setStepErrors(stepId, errors) {
+    if (!errors || Object.keys(errors).length === 0) {
+      if (this.errorsMap.has(stepId)) {
+        this.errorsMap.delete(stepId);
+        this.syncErrors();
+        return true;
+      }
+      return false;
+    }
+    const stepMap = /* @__PURE__ */ new Map();
+    for (const [field, msg] of Object.entries(errors)) {
+      stepMap.set(field, msg);
+    }
+    this.errorsMap.set(stepId, stepMap);
+    this.syncErrors();
+    return true;
+  }
+  deleteError(stepId, path) {
+    const stepErrors = this.errorsMap.get(stepId);
+    if (!stepErrors) return false;
+    if (stepErrors.has(path)) {
+      stepErrors.delete(path);
+      if (stepErrors.size === 0) {
+        this.errorsMap.delete(stepId);
+      }
+      this.syncErrors();
+      return true;
+    }
+    return false;
+  }
+  notify() {
+    this.listeners.forEach((l) => l());
+  }
+  injectPersistence(adapter) {
+    this.persistenceAdapter = adapter;
+  }
+  /**
+   * Restores wizard state from persistence storage.
+   * Implements "latest wins" conflict resolution based on step timestamps.
+   */
+  hydrate() {
+    if (!this.persistenceAdapter) return;
+    let latestTimestamp = -1;
+    let latestData = null;
+    let hasHydrated = false;
+    const config = this.state.config;
+    config.steps.forEach((step) => {
+      const adapter = step.persistenceAdapter || this.persistenceAdapter;
+      if (!adapter) return;
+      try {
+        let candidateData;
+        let candidateTimestamp = 0;
+        if (adapter.getStepWithMeta) {
+          const result = adapter.getStepWithMeta(step.id);
+          if (result) {
+            candidateData = result.data;
+            candidateTimestamp = result.timestamp;
+          }
+        } else {
+          candidateData = adapter.getStep(step.id);
+        }
+        if (candidateData) {
+          if (candidateTimestamp >= latestTimestamp) {
+            latestTimestamp = candidateTimestamp;
+            latestData = candidateData;
+            hasHydrated = true;
+          }
+        }
+      } catch (e) {
+        console.warn(`[WizardStore] \u26A0\uFE0F Failed to hydrate step ${step.id}:`, e);
+      }
+    });
+    if (hasHydrated && latestData) {
+      this.updateBulkData(latestData, { replace: true });
+    }
+  }
+  saveMeta() {
+    const config = this.state.config;
+    const persistenceMode = config.persistence?.mode || "onStepChange";
+    if (persistenceMode !== "manual" && this.persistenceAdapter) {
+      this.persistenceAdapter.saveStep("__wizzard_meta__", {
+        currentStepId: this.state.currentStepId,
+        visited: Array.from(this.state.visitedSteps),
+        completed: Array.from(this.state.completedSteps),
+        history: this.state.history
+      });
+    }
+  }
+  clearStepStorage(stepId) {
+    const step = this.stepsMap.get(stepId) || this.state.config.steps.find((s) => s.id === stepId);
+    const adapter = step?.persistenceAdapter || this.persistenceAdapter;
+    if (adapter && adapter.clearStep) {
+      adapter.clearStep(stepId);
+    }
+  }
+  /**
+   * Manually triggers data persistence for specific steps or the current step.
+   *
+   * @param stepId Optional ID of step to save. If omitted, saves current step.
+   */
+  save(stepId) {
+    if (stepId) {
+      this.saveStepData(stepId);
+      return;
+    }
+    if (this.state.currentStepId) {
+      this.saveStepData(this.state.currentStepId);
+    }
+  }
+  saveStepData(stepId) {
+    const step = this.stepsMap.get(stepId) || this.state.config.steps.find((s) => s.id === stepId);
+    if (!step) return;
+    const adapter = step.persistenceAdapter || this.persistenceAdapter;
+    if (!adapter) return;
+    adapter.saveStep(stepId, this.state.data);
+  }
+  handleStepChangePersistence(stepId) {
+    const step = this.stepsMap.get(stepId) || this.state.config.steps.find((s) => s.id === stepId);
+    if (!step) return;
+    const mode = step.persistenceMode || this.state.config.persistence?.mode || "onStepChange";
+    if (mode === "onStepChange") {
+      this.saveStepData(stepId);
+    }
+  }
+  // Internal helper to handle auto-save on data change
+  checkAutoSave(_changedPaths) {
+    const { config, currentStepId } = this.state;
+    if (!currentStepId) return;
+    const step = this.stepsMap.get(currentStepId) || config.steps.find((s) => s.id === currentStepId);
+    if (!step) return;
+    const mode = step.persistenceMode || config.persistence?.mode || "onStepChange";
+    if (mode !== "onChange") return;
+    const debounceTime = config.persistence?.debounceTime ?? 300;
+    const timerKey = currentStepId;
+    if (this.persistenceDebounceTimers.has(timerKey)) {
+      clearTimeout(this.persistenceDebounceTimers.get(timerKey));
+    }
+    this.persistenceDebounceTimers.set(
+      timerKey,
+      setTimeout(() => {
+        this.saveStepData(currentStepId);
+      }, debounceTime)
+    );
+  }
+  /**
+   * Evaluates visibility conditions for all steps and returns only those that should be active.
+   * Uses memoization to avoid redundant async calls if dependencies haven't changed.
+   *
+   * @param data Optional data override for evaluation
+   */
+  async resolveActiveSteps(data) {
+    const currentData = data || this.state.data;
+    const config = this.state.config;
+    this.updateMeta({ isBusy: true });
+    try {
+      const steps = config.steps || [];
+      const results = await Promise.all(
+        steps.map(async (step) => {
+          if (!step.condition) return { step, ok: true };
+          if (step.conditionDependsOn) {
+            const currentDepsValues = step.conditionDependsOn.map(
+              (path) => getByPath(currentData, path)
+            );
+            const cached = this.conditionCache.get(step.id);
+            if (cached && cached.depsValues.length === currentDepsValues.length && cached.depsValues.every((val, idx) => val === currentDepsValues[idx])) {
+              return { step, ok: cached.result };
+            }
+            try {
+              const res = step.condition(currentData || {}, this.getSnapshot());
+              const ok = res instanceof Promise ? await res : res;
+              this.conditionCache.set(step.id, {
+                result: ok,
+                depsValues: currentDepsValues
+              });
+              return { step, ok };
+            } catch (e) {
+              console.error(`[Wizard] Condition failed for ${step.id}:`, e);
+              return { step, ok: false };
+            }
+          }
+          const nextBusyStart = new Set(this.state.busySteps);
+          nextBusyStart.add(step.id);
+          this.updateMeta({
+            busySteps: nextBusyStart,
+            isBusy: true
+          });
+          try {
+            const res = step.condition(currentData || {}, this.getSnapshot());
+            const ok = res instanceof Promise ? await res : res;
+            return { step, ok };
+          } catch (e) {
+            console.error(`[Wizard] Condition failed for ${step.id}:`, e);
+            return { step, ok: false };
+          } finally {
+            const currentSnapshot = this.getSnapshot();
+            const nextBusyEnd = new Set(currentSnapshot.busySteps);
+            nextBusyEnd.delete(step.id);
+            this.updateMeta({
+              busySteps: nextBusyEnd,
+              isBusy: nextBusyEnd.size > 0
+            });
+          }
+        })
+      );
+      return results.filter((r) => r.ok).map((r) => r.step);
+    } finally {
+      const currentSnapshot = this.getSnapshot();
+      if (currentSnapshot.busySteps.size === 0) {
+        this.updateMeta({ isBusy: false });
+      }
+    }
+  }
+  async validateStep(stepId) {
+    const steps = this.state.config.steps || [];
+    const step = this.stepsMap.get(stepId) || steps.find((s) => s.id === stepId);
+    if (!step || !step.validationAdapter) return true;
+    this.dispatch({ type: "VALIDATE_START", payload: { stepId } });
+    let isValid = true;
+    try {
+      const result = await step.validationAdapter.validate(this.state.data);
+      isValid = result.isValid;
+      if (result.isValid) {
+        this.setStepErrors(stepId, null);
+        const nextErrorSteps = new Set(this.state.errorSteps);
+        nextErrorSteps.delete(stepId);
+        this.dispatch({
+          type: "SET_ERROR_STEPS",
+          payload: { steps: nextErrorSteps }
+        });
+        return true;
+      } else {
+        this.setStepErrors(stepId, result.errors || null);
+        if (this.state.config.analytics?.onEvent) {
+          this.state.config.analytics.onEvent("validation_error", {
+            stepId,
+            errors: result.errors,
+            timestamp: Date.now()
+          });
+        }
+        const nextErrorSteps = new Set(this.state.errorSteps);
+        nextErrorSteps.add(stepId);
+        this.dispatch({
+          type: "SET_ERROR_STEPS",
+          payload: { steps: nextErrorSteps }
+        });
+        const nextCompleted = new Set(this.state.completedSteps);
+        if (nextCompleted.has(stepId)) {
+          nextCompleted.delete(stepId);
+          this.dispatch({
+            type: "SET_COMPLETED_STEPS",
+            payload: { steps: nextCompleted }
+          });
+        }
+        return false;
+      }
+    } finally {
+      this.dispatch({
+        type: "VALIDATE_END",
+        payload: { stepId, result: { isValid } }
+      });
+    }
+  }
+  async validateAll() {
+    this.updateMeta({ isBusy: true });
+    try {
+      const data = this.getSnapshot().data;
+      const activeSteps = await this.resolveActiveSteps(data);
+      const results = await Promise.all(
+        activeSteps.map((step) => this.validateStep(step.id))
+      );
+      return {
+        isValid: results.every(Boolean),
+        errors: this.getSnapshot().errors
+      };
+    } finally {
+      const currentSnapshot = this.getSnapshot();
+      if (currentSnapshot.busySteps.size === 0) {
+        this.updateMeta({ isBusy: false });
+      }
+    }
+  }
+  async goToStep(stepId, options = { validate: true }) {
+    const { currentStepId, config, data: currentData } = this.state;
+    const allSteps = config.steps || [];
+    const currentIdx = allSteps.findIndex((s) => s.id === currentStepId);
+    const targetIdx = allSteps.findIndex((s) => s.id === stepId);
+    this.dispatch({
+      type: "GO_TO_STEP",
+      payload: { result: "init", to: stepId, from: currentStepId }
+    });
+    if (this.getSnapshot().goToStepResult !== "init") {
+      console.warn("[WizardStore] Navigation aborted by middleware interceptor");
+      return false;
+    }
+    if (targetIdx === currentIdx) return true;
+    if (targetIdx > currentIdx && currentStepId && options.validate) {
+      const step = this.stepsMap.get(currentStepId) || allSteps.find((s) => s.id === currentStepId);
+      const shouldVal = step?.autoValidate ?? config.autoValidate ?? !!step?.validationAdapter;
+      if (shouldVal) {
+        const ok = await this.validateStep(currentStepId);
+        if (!ok) {
+          this.dispatch({
+            type: "GO_TO_STEP",
+            payload: { result: false, to: stepId, from: currentStepId }
+          });
+          return false;
+        }
+      }
+    }
+    this.updateMeta({ isBusy: true });
+    try {
+      const resolvedSteps = options.providedActiveSteps || await this.resolveActiveSteps(currentData);
+      const target = resolvedSteps.find((s) => s.id === stepId);
+      if (!target) {
+        this.dispatch({
+          type: "GO_TO_STEP",
+          payload: { result: false, to: stepId, from: currentStepId }
+        });
+        return false;
+      }
+      if (target.canNavigateTo) {
+        const snapshot = this.getSnapshot();
+        const canNavigate = await target.canNavigateTo(currentData, snapshot);
+        if (!canNavigate) {
+          console.warn(
+            `[WizardStore] Navigation to step "${stepId}" blocked by canNavigateTo function`
+          );
+          this.dispatch({
+            type: "GO_TO_STEP",
+            payload: { result: false, to: stepId, from: currentStepId }
+          });
+          return false;
+        }
+      } else {
+        const navigationMode = config.navigationMode || "visited";
+        const currentSnapshot2 = this.getSnapshot();
+        const currentIndex = resolvedSteps.findIndex((s) => s.id === currentStepId);
+        const targetIndex = resolvedSteps.findIndex((s) => s.id === stepId);
+        const isAdjacent = Math.abs(targetIndex - currentIndex) === 1;
+        if (stepId !== currentStepId) {
+          switch (navigationMode) {
+            case "sequential":
+              if (!isAdjacent) {
+                console.warn(
+                  `[WizardStore] Navigation to step "${stepId}" blocked: sequential mode allows only adjacent steps`
+                );
+                this.dispatch({
+                  type: "GO_TO_STEP",
+                  payload: {
+                    result: false,
+                    to: stepId,
+                    from: currentStepId
+                  }
+                });
+                return false;
+              }
+              break;
+            case "visited":
+              const isVisitedOrCompleted = currentSnapshot2.visitedSteps.has(stepId) || currentSnapshot2.completedSteps.has(stepId);
+              if (!isAdjacent && !isVisitedOrCompleted) {
+                console.warn(
+                  `[WizardStore] Navigation to step "${stepId}" blocked: step not visited or completed`
+                );
+                this.dispatch({
+                  type: "GO_TO_STEP",
+                  payload: {
+                    result: false,
+                    to: stepId,
+                    from: currentStepId
+                  }
+                });
+                return false;
+              }
+              break;
+            case "free":
+              break;
+          }
+        }
+      }
+      const step = this.stepsMap.get(currentStepId) || allSteps.find((s) => s.id === currentStepId);
+      if (step?.beforeLeave) {
+        const snapshot = this.getSnapshot();
+        const direction = targetIdx > currentIdx ? "next" : "prev";
+        const ok = await step.beforeLeave(currentData, direction, snapshot);
+        if (ok === false) {
+          this.dispatch({
+            type: "GO_TO_STEP",
+            payload: { result: false, to: stepId, from: currentStepId }
+          });
+          return false;
+        }
+      }
+      const currentSnapshot = this.getSnapshot();
+      const nextVisited = new Set(currentSnapshot.visitedSteps);
+      if (currentStepId) nextVisited.add(currentStepId);
+      nextVisited.add(stepId);
+      const nextHistory = [...currentSnapshot.history, stepId];
+      this.dispatch({
+        type: "GO_TO_STEP",
+        payload: {
+          result: true,
+          to: stepId,
+          from: currentStepId,
+          nextHistory,
+          nextVisitedSteps: nextVisited
+        }
+      });
+      this.saveMeta();
+      if (config.onStepChange) {
+        config.onStepChange(currentStepId || null, stepId, currentData);
+      }
+      if (config.analytics?.onEvent) {
+        config.analytics.onEvent("step_change", {
+          from: currentStepId || null,
+          to: stepId,
+          timestamp: Date.now()
+        });
+      }
+      return true;
+    } finally {
+      this.updateMeta({ isBusy: false });
+    }
+  }
+};
+
+export { WizardStore, getByPath, setByPath, shallowEqual, toPath };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map