react-wizard-engine 0.1.0

package/dist/index.cjs

@@ -0,0 +1,2349 @@
+"use client";
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  TypedEmitter: () => TypedEmitter,
+  WizardActiveProgressStrategy: () => WizardActiveProgressStrategy,
+  WizardActiveStepRule: () => WizardActiveStepRule,
+  WizardBack: () => WizardBack,
+  WizardCategory: () => WizardCategory,
+  WizardCategoryDirection: () => WizardCategoryDirection,
+  WizardCompleteEvent: () => WizardCompleteEvent,
+  WizardCompleteTreeState: () => WizardCompleteTreeState,
+  WizardComponentsProvider: () => WizardComponentsProvider,
+  WizardConfig: () => WizardConfig,
+  WizardDefaultInitializer: () => WizardDefaultInitializer,
+  WizardDefaultVisibilityStrategy: () => WizardDefaultVisibilityStrategy,
+  WizardEngine: () => WizardEngine,
+  WizardEngineContext: () => WizardEngineContext,
+  WizardEngineRefCapture: () => WizardEngineRefCapture,
+  WizardError: () => WizardError,
+  WizardEvent: () => WizardEvent,
+  WizardEventType: () => WizardEventType,
+  WizardExitEvent: () => WizardExitEvent,
+  WizardExitTreeState: () => WizardExitTreeState,
+  WizardHeader: () => WizardHeader,
+  WizardInitializationError: () => WizardInitializationError,
+  WizardInitializer: () => WizardInitializer,
+  WizardInitializerService: () => WizardInitializerService,
+  WizardLastActiveVisibilityStrategy: () => WizardLastActiveVisibilityStrategy,
+  WizardListener: () => WizardListener,
+  WizardLog: () => WizardLog,
+  WizardNavigation: () => WizardNavigation,
+  WizardNavigationCancelledEvent: () => WizardNavigationCancelledEvent,
+  WizardNavigationEndEvent: () => WizardNavigationEndEvent,
+  WizardNavigationError: () => WizardNavigationError,
+  WizardNavigationErrorEvent: () => WizardNavigationErrorEvent,
+  WizardNavigationIgnoredEvent: () => WizardNavigationIgnoredEvent,
+  WizardNavigationService: () => WizardNavigationService,
+  WizardNavigationStartEvent: () => WizardNavigationStartEvent,
+  WizardNext: () => WizardNext,
+  WizardPassedPrevCategoriesRule: () => WizardPassedPrevCategoriesRule,
+  WizardPassedPrevStepsRule: () => WizardPassedPrevStepsRule,
+  WizardProgressStrategy: () => WizardProgressStrategy,
+  WizardProvider: () => WizardProvider,
+  WizardRail: () => WizardRail,
+  WizardResolveEndEvent: () => WizardResolveEndEvent,
+  WizardResolveStartEvent: () => WizardResolveStartEvent,
+  WizardResolverError: () => WizardResolverError,
+  WizardRule: () => WizardRule,
+  WizardScrollEndEvent: () => WizardScrollEndEvent,
+  WizardScrollStartEvent: () => WizardScrollStartEvent,
+  WizardScrollStrategy: () => WizardScrollStrategy,
+  WizardShownActiveCategoryRule: () => WizardShownActiveCategoryRule,
+  WizardSingleActiveCategoryRule: () => WizardSingleActiveCategoryRule,
+  WizardSmoothScrollStrategy: () => WizardSmoothScrollStrategy,
+  WizardStateService: () => WizardStateService,
+  WizardStep: () => WizardStep,
+  WizardStepHideEvent: () => WizardStepHideEvent,
+  WizardStepShowEvent: () => WizardStepShowEvent,
+  WizardStepper: () => WizardStepper,
+  WizardStepperDot: () => WizardStepperDot,
+  WizardStore: () => WizardStore,
+  WizardTreeStateBuilder: () => WizardTreeStateBuilder,
+  WizardVisibilityStrategy: () => WizardVisibilityStrategy,
+  buildWizardBranchState: () => buildWizardBranchState,
+  buildWizardCategoryState: () => buildWizardCategoryState,
+  buildWizardTreeState: () => buildWizardTreeState,
+  composeWizardProviders: () => composeWizardProviders,
+  scrollToStep: () => scrollToStep,
+  useWizard: () => useWizard,
+  useWizardCategoriesView: () => useWizardCategoriesView,
+  useWizardComponents: () => useWizardComponents,
+  useWizardEngineRef: () => useWizardEngineRef,
+  useWizardEvent: () => useWizardEvent,
+  useWizardStep: () => useWizardStep,
+  withConfig: () => withConfig,
+  withInitializer: () => withInitializer,
+  withListener: () => withListener,
+  withProgressStrategy: () => withProgressStrategy,
+  withScrollContainer: () => withScrollContainer,
+  withScrollStrategy: () => withScrollStrategy,
+  withVisibilityStrategy: () => withVisibilityStrategy,
+  wizardDefaultBranch: () => wizardDefaultBranch,
+  wizardDefaultConfig: () => wizardDefaultConfig,
+  wizardDefaultState: () => wizardDefaultState,
+  wizardRules: () => wizardRules
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/enums/wizard-event-type.enum.ts
+var WizardEventType = /* @__PURE__ */ ((WizardEventType2) => {
+  WizardEventType2["Complete"] = "complete";
+  WizardEventType2["Exit"] = "exit";
+  WizardEventType2["NavigationCancelled"] = "navigation_cancelled";
+  WizardEventType2["NavigationEnd"] = "navigation_end";
+  WizardEventType2["NavigationError"] = "navigation_error";
+  WizardEventType2["NavigationIgnored"] = "navigation_ignored";
+  WizardEventType2["NavigationStart"] = "navigation_start";
+  WizardEventType2["ResolveEnd"] = "resolve_end";
+  WizardEventType2["ResolveStart"] = "resolve_start";
+  WizardEventType2["ScrollEnd"] = "scroll_end";
+  WizardEventType2["ScrollStart"] = "scroll_start";
+  WizardEventType2["StepHide"] = "step_hide";
+  WizardEventType2["StepShow"] = "step_show";
+  return WizardEventType2;
+})(WizardEventType || {});
+
+// src/core/utils/general/last.ts
+var last = (arr) => arr[arr.length - 1];
+
+// src/core/utils/general/to-array.ts
+var toArray = (arr) => Array.isArray(arr) ? arr : [arr];
+
+// src/core/utils/state/get-step-id.ts
+var getStepId = (stepState) => {
+  const branchesId = stepState.branches.join(",");
+  return `${stepState.htmlIndex}:${branchesId}.${stepState.categoryId}.${stepState.id}`;
+};
+var getStepStateId = (stepState) => {
+  return `${+stepState.isShow}${+stepState.isCompleted}${+stepState.isSkipped}${+stepState.isActive}`;
+};
+
+// src/core/utils/state/get-shape-id.ts
+var getShapeId = (state, prefix = "") => {
+  const id = state.map(getStepId).join("|");
+  return prefix !== "" && prefix !== void 0 ? `@${prefix}@${id}` : id;
+};
+
+// src/core/utils/state/get-state-id.ts
+var getStateId = (state, prefix = "") => {
+  const id = state.map(getStepStateId).join("|");
+  return prefix ? `@${prefix}@${id}` : id;
+};
+
+// src/core/builders/build-tree-state.ts
+function buildWizardBranchState(id, categories) {
+  const shownCategories = [];
+  const activeCategories = [];
+  const completedCategories = [];
+  const skippedCategories = [];
+  const passedCategories = [];
+  for (const category of categories) {
+    if (category.isActive) activeCategories.push(category);
+    if (category.isShow) shownCategories.push(category);
+    if (category.isCompleted) completedCategories.push(category);
+    if (category.isSkipped) skippedCategories.push(category);
+    if (category.isPassed) passedCategories.push(category);
+  }
+  const activeCategory = activeCategories[0] ?? shownCategories[0];
+  const getShownCategoryIndex = (category) => shownCategories.indexOf(category);
+  const activeCategoryIndex = getShownCategoryIndex(activeCategory);
+  const firstCategory = shownCategories[0];
+  const lastCategory = last(shownCategories);
+  const prevCategory = activeCategoryIndex > 0 ? shownCategories[activeCategoryIndex - 1] ?? null : null;
+  const nextCategory = activeCategoryIndex >= 0 ? shownCategories[activeCategoryIndex + 1] ?? null : null;
+  const getShownCategories = (fromIndex, toIndex) => shownCategories.slice(fromIndex, toIndex + 1);
+  return {
+    activeCategories,
+    activeCategory,
+    activeCategoryIndex,
+    categories: [...categories],
+    completedCategories,
+    firstCategory,
+    getShownCategories,
+    getShownCategoryIndex,
+    id,
+    lastCategory,
+    nextCategory,
+    passedCategories,
+    prevCategory,
+    shownCategories,
+    skippedCategories
+  };
+}
+function buildWizardCategoryState(id, htmlIndex, steps) {
+  const branches = steps[0]?.branches ?? [];
+  const shownSteps = [];
+  const activeSteps = [];
+  const completedSteps = [];
+  const skippedSteps = [];
+  const passedSteps = [];
+  for (const step of steps) {
+    if (step.isActive) activeSteps.push(step);
+    if (step.isShow) shownSteps.push(step);
+    if (step.isSkipped) skippedSteps.push(step);
+    if (step.isCompleted) completedSteps.push(step);
+    if (step.isSkipped || step.isCompleted) passedSteps.push(step);
+  }
+  const isActive = activeSteps.length > 0;
+  const isShow = shownSteps.length > 0;
+  const skippedAt = shownSteps.findIndex((step) => step.isSkipped);
+  const isSkipped = skippedAt !== -1;
+  const completedShownSteps = shownSteps.filter((step) => step.isCompleted || step.isSkipped);
+  const isCompleted = completedShownSteps.length === shownSteps.length && shownSteps.length > 0;
+  const isPassed = isCompleted || isSkipped;
+  const lastActiveStep = last(activeSteps);
+  const activeStepIndex = lastActiveStep ? shownSteps.indexOf(lastActiveStep) : -1;
+  const firstStep = shownSteps[0];
+  const lastStep = last(shownSteps);
+  const firstActiveStep = activeSteps[0];
+  const prevStep = activeStepIndex > 0 ? shownSteps[activeStepIndex - 1] ?? null : null;
+  const nextStep = activeStepIndex >= 0 ? shownSteps[activeStepIndex + 1] ?? null : null;
+  return {
+    activeStepIndex,
+    activeSteps,
+    branches: [...branches],
+    completedSteps,
+    firstActiveStep,
+    firstStep,
+    htmlIndex,
+    id,
+    isActive,
+    isCompleted,
+    isPassed,
+    isShow,
+    isSkipped,
+    lastActiveStep,
+    lastStep,
+    nextStep,
+    passedSteps,
+    prevStep,
+    shownSteps,
+    skippedAt,
+    skippedSteps,
+    steps: [...steps]
+  };
+}
+function buildWizardTreeState(state, activeBranchId) {
+  const stepMap = {};
+  const categoryOrder = [];
+  const stepsByCategory = {};
+  for (const step of state) {
+    stepMap[step.id] = step;
+    if (!stepsByCategory[step.categoryId]) {
+      categoryOrder.push(step.categoryId);
+      stepsByCategory[step.categoryId] = [];
+    }
+    stepsByCategory[step.categoryId].push(step);
+  }
+  const categoryMap = {};
+  const categoriesByBranch = {};
+  for (const [index, categoryId] of categoryOrder.entries()) {
+    const categoryState = buildWizardCategoryState(
+      categoryId,
+      index,
+      stepsByCategory[categoryId]
+    );
+    categoryMap[categoryId] = categoryState;
+    for (const branchId of categoryState.branches) {
+      (categoriesByBranch[branchId] ??= []).push(categoryState);
+    }
+  }
+  const branchMap = {};
+  const branches = [];
+  for (const branchId of Object.keys(categoriesByBranch)) {
+    const branchState = buildWizardBranchState(branchId, categoriesByBranch[branchId]);
+    branchMap[branchId] = branchState;
+    branches.push(branchState);
+  }
+  const activeBranch = pickActiveBranch(branches, branchMap, activeBranchId);
+  const activeCategory = activeBranch.activeCategory;
+  const activeSteps = activeCategory.activeSteps;
+  const lastActiveStep = last(activeSteps);
+  return {
+    activeBranch,
+    activeCategory,
+    activeSteps,
+    branches,
+    branchMap,
+    categoryMap,
+    id: getStateId(state),
+    lastActiveStep,
+    state: [...state],
+    stepMap
+  };
+}
+function pickActiveBranch(branches, branchMap, activeBranchId) {
+  if (branches.length === 1) {
+    return branches[0];
+  }
+  const activeBranches = branches.filter((branch) => branch.activeCategories.length > 0);
+  if (activeBranches.length === 1) {
+    return activeBranches[0];
+  }
+  if (activeBranchId && branchMap[activeBranchId]) {
+    return branchMap[activeBranchId];
+  }
+  return activeBranches[0] ?? branches[0];
+}
+
+// src/core/builders/wizard-default.const.ts
+var wizardDefaultState = {
+  isActive: false,
+  isCompleted: false,
+  isShow: true,
+  isSkipped: false
+};
+var wizardDefaultBranch = "main";
+
+// src/core/errors/wizard.error.ts
+var WizardError = class extends Error {
+  name = "WizardError";
+  constructor(message) {
+    super(message);
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var WizardInitializationError = class extends WizardError {
+  name = "WizardInitializationError";
+};
+var WizardNavigationError = class extends WizardError {
+  name = "WizardNavigationError";
+};
+var WizardResolverError = class extends WizardError {
+  name = "WizardResolverError";
+};
+
+// src/core/rules/wizard-rule.ts
+var WizardRule = class {
+};
+
+// src/core/rules/wizard-active-step.rule.ts
+var WizardActiveStepRule = class extends WizardRule {
+  verify({ lastActiveStep }) {
+    if (!lastActiveStep) {
+      throw new WizardError("[WizardActiveStepRule]: There are no available active step in tree state.");
+    }
+  }
+};
+
+// src/core/rules/wizard-passed-prev-categories.rule.ts
+var WizardPassedPrevCategoriesRule = class extends WizardRule {
+  verify({ activeBranch, activeCategory }) {
+    const prevCategories = activeBranch.shownCategories.slice(0, activeBranch.activeCategoryIndex);
+    const hasUnpassedPrevCategories = prevCategories.some((prevCategory) => !prevCategory.isPassed);
+    if (hasUnpassedPrevCategories) {
+      const prevCategoryNames = prevCategories.map((prevCategory) => prevCategory.id).join(",");
+      throw new WizardError(
+        `[WizardPassedPrevCategoriesRule]: Active category "${activeCategory.id}" has neither completed nor skipped prev categories. Please, skip or complete categories: "${prevCategoryNames}".`
+      );
+    }
+  }
+};
+
+// src/core/rules/wizard-passed-prev-steps.rule.ts
+var WizardPassedPrevStepsRule = class extends WizardRule {
+  verify({ activeCategory }) {
+    const prevSteps = activeCategory.shownSteps.slice(0, activeCategory.activeStepIndex);
+    const prevUnpassedSteps = prevSteps.filter((prevStep) => !prevStep.isCompleted && !prevStep.isSkipped);
+    if (prevUnpassedSteps.length) {
+      const prevStepNames = prevUnpassedSteps.map((prevStep) => prevStep.id).join(",");
+      throw new WizardError(
+        `[WizardPassedPrevStepsRule]: Last active step "${activeCategory.lastActiveStep.id}" has not completed steps before. Please, complete or hide steps: "${prevStepNames}".`
+      );
+    }
+  }
+};
+
+// src/core/rules/wizard-shown-active-category.rule.ts
+var WizardShownActiveCategoryRule = class extends WizardRule {
+  verify({ activeCategory }) {
+    if (!activeCategory.isShow) {
+      throw new WizardError(
+        `[WizardShownActiveCategoryRule]: Active category is hidden. Please, show category "${activeCategory.id}" to be able to activate it.`
+      );
+    }
+  }
+};
+
+// src/core/rules/wizard-single-active-category.rule.ts
+var WizardSingleActiveCategoryRule = class extends WizardRule {
+  verify({ activeBranch }) {
+    if (activeBranch.activeCategories.length > 1) {
+      const activeCategoryNames = activeBranch.activeCategories.map((c) => c.id).join(",");
+      throw new WizardError(
+        `[WizardSingleActiveCategoryRule]: There are 2 active categories at the same time: ${activeCategoryNames}.`
+      );
+    }
+  }
+};
+
+// src/core/rules/wizard-rules.ts
+var wizardRules = [
+  new WizardActiveStepRule(),
+  new WizardSingleActiveCategoryRule(),
+  new WizardShownActiveCategoryRule(),
+  new WizardPassedPrevStepsRule(),
+  new WizardPassedPrevCategoriesRule()
+];
+
+// src/core/state/wizard-tree.state.ts
+var WizardCompleteTreeState = class {
+  constructor(originTree) {
+    this.originTree = originTree;
+  }
+  originTree;
+  state = "complete";
+};
+var WizardExitTreeState = class {
+  constructor(originTree) {
+    this.originTree = originTree;
+  }
+  originTree;
+  state = "exit";
+};
+
+// src/core/state/project-to-tree.ts
+var projectToTree = (target) => target instanceof WizardExitTreeState || target instanceof WizardCompleteTreeState ? target.originTree : target;
+
+// src/core/builders/wizard-tree-state.builder.ts
+var WizardTreeStateBuilder = class _WizardTreeStateBuilder {
+  branch;
+  state;
+  constructor(treeState, branch) {
+    this.state = treeState.state.map((step) => ({ ...step }));
+    this.branch = branch ?? treeState.activeBranch.id;
+  }
+  static validate(tree) {
+    wizardRules.forEach((rule) => rule.verify(tree));
+    return tree;
+  }
+  /** Activate completed steps + the next step after the last completed one. */
+  activateCategory(categoryId) {
+    const shown = this.getCategoryStepStates(categoryId).filter((s) => s.isShow);
+    for (let i = 0; i < shown.length; i++) {
+      const step = shown[i];
+      const prev = shown[i - 1];
+      step.isActive = step.isCompleted || (prev?.isCompleted ?? true);
+    }
+    return this;
+  }
+  /** Activate first shown step of a category; deactivate the rest. */
+  activateFirstStep(categoryId) {
+    const shown = this.getCategoryStepStates(categoryId).filter((step) => step.isShow);
+    if (shown.length === 0) return this;
+    shown[0].isActive = true;
+    for (let i = 1; i < shown.length; i++) {
+      shown[i].isActive = false;
+    }
+    return this;
+  }
+  // ================
+  // Step actions
+  // ================
+  activateStep(step) {
+    this.getStepState(step).isActive = true;
+    return this;
+  }
+  build() {
+    const tree = buildWizardTreeState(this.state, this.branch);
+    _WizardTreeStateBuilder.validate(tree);
+    return Object.freeze(tree);
+  }
+  /** Build a terminal complete tree (skips rule validation since the tree is sealed). */
+  buildComplete() {
+    const tree = buildWizardTreeState(this.state, this.branch);
+    return Object.freeze(new WizardCompleteTreeState(tree));
+  }
+  /** Build a terminal exit tree (skips rule validation since the tree is sealed). */
+  buildExit() {
+    const tree = buildWizardTreeState(this.state, this.branch);
+    return Object.freeze(new WizardExitTreeState(tree));
+  }
+  completeCategory(categoryId) {
+    this.getCategoryStepStates(categoryId).forEach((step) => step.isCompleted = true);
+    return this;
+  }
+  // ================
+  // Category actions
+  // ================
+  completeStep(step) {
+    this.getStepState(step).isCompleted = true;
+    return this;
+  }
+  deactivateCategory(categoryId) {
+    this.getCategoryStepStates(categoryId).forEach((step) => step.isActive = false);
+    return this;
+  }
+  deactivateStep(step) {
+    this.getStepState(step).isActive = false;
+    return this;
+  }
+  getCategoryStepStates(categoryId) {
+    return this.state.filter((step) => step.categoryId === categoryId);
+  }
+  /** Reset every step in the tree to `wizardDefaultState`. */
+  getResetTree() {
+    this.state.forEach((step) => Object.assign(step, wizardDefaultState));
+    const firstStep = this.state[0];
+    if (firstStep) {
+      firstStep.isActive = true;
+    }
+    return Object.freeze(buildWizardTreeState(this.state, this.branch));
+  }
+  getStepState(step) {
+    const found = this.state.find((s) => s.id === step);
+    if (!found) {
+      throw new Error(`[WizardTreeStateBuilder] Unknown step "${step}"`);
+    }
+    return found;
+  }
+  hideCategory(categoryId) {
+    this.getCategoryStepStates(categoryId).forEach((step) => step.isShow = false);
+    return this;
+  }
+  hideStep(step) {
+    this.getStepState(step).isShow = false;
+    return this;
+  }
+  /** Reset category steps from `from` index onward; deactivate all but first. */
+  resetCategory(categoryId, from = 0) {
+    const slice = this.getCategoryStepStates(categoryId).slice(from);
+    slice.forEach((step, index) => {
+      step.isActive = step.isActive && index === 0;
+      step.isCompleted = false;
+    });
+    return this;
+  }
+  showCategory(categoryId) {
+    this.getCategoryStepStates(categoryId).forEach((step) => step.isShow = true);
+    return this;
+  }
+  // ================
+  // Build / reset
+  // ================
+  showStep(step) {
+    this.getStepState(step).isShow = true;
+    return this;
+  }
+  skipCategory(categoryId) {
+    this.getCategoryStepStates(categoryId).forEach((step) => step.isSkipped = true);
+    return this;
+  }
+  skipCategoryUncompleted(categoryId) {
+    this.getCategoryStepStates(categoryId).filter((step) => !step.isCompleted).forEach((step) => step.isSkipped = true);
+    return this;
+  }
+  uncompleteStep(step) {
+    this.getStepState(step).isCompleted = false;
+    return this;
+  }
+  unskipCategory(categoryId) {
+    this.getCategoryStepStates(categoryId).forEach((step) => step.isSkipped = false);
+    return this;
+  }
+};
+
+// src/core/compose-wizard-providers.ts
+function composeWizardProviders(...mods) {
+  const props = {
+    config: {},
+    initializers: [],
+    listeners: [],
+    strategies: {}
+  };
+  for (const mod of mods) {
+    mod(props);
+  }
+  return props;
+}
+var withConfig = (options) => (props) => {
+  props.config = { ...props.config, ...options };
+};
+var withInitializer = (initializer) => (props) => {
+  props.initializers.push(initializer);
+};
+var withListener = (listener) => (props) => {
+  props.listeners.push(listener);
+};
+var withScrollStrategy = (strategy) => (props) => {
+  props.strategies.scroll = strategy;
+};
+var withScrollContainer = (container) => (props) => {
+  props.scrollContainer = container;
+};
+var withProgressStrategy = (strategy) => (props) => {
+  props.strategies.progress = strategy;
+};
+var withVisibilityStrategy = (strategy) => (props) => {
+  props.strategies.visibility = strategy;
+};
+
+// src/core/events/wizard-events.ts
+var WizardEvent = class {
+  /** @param navigation - Specific navigation data associated with event */
+  constructor(navigation) {
+    this.navigation = navigation;
+  }
+  navigation;
+};
+var WizardCompleteEvent = class extends WizardEvent {
+  constructor(navigation) {
+    super(navigation);
+    this.navigation = navigation;
+  }
+  navigation;
+  type = "complete" /* Complete */;
+};
+var WizardExitEvent = class extends WizardEvent {
+  type = "exit" /* Exit */;
+};
+var WizardNavigationCancelledEvent = class extends WizardEvent {
+  constructor(navigation, reason) {
+    super(navigation);
+    this.navigation = navigation;
+    this.reason = reason;
+  }
+  navigation;
+  reason;
+  type = "navigation_cancelled" /* NavigationCancelled */;
+};
+var WizardNavigationEndEvent = class extends WizardEvent {
+  constructor(navigation) {
+    super(navigation);
+    this.navigation = navigation;
+  }
+  navigation;
+  type = "navigation_end" /* NavigationEnd */;
+};
+var WizardNavigationErrorEvent = class extends WizardEvent {
+  constructor(navigation) {
+    super(navigation);
+    this.navigation = navigation;
+  }
+  navigation;
+  type = "navigation_error" /* NavigationError */;
+};
+var WizardNavigationIgnoredEvent = class extends WizardEvent {
+  constructor(navigation, reason) {
+    super(navigation);
+    this.navigation = navigation;
+    this.reason = reason;
+  }
+  navigation;
+  reason;
+  type = "navigation_ignored" /* NavigationIgnored */;
+};
+var WizardNavigationStartEvent = class extends WizardEvent {
+  constructor(navigation) {
+    super(navigation);
+    this.navigation = navigation;
+  }
+  navigation;
+  type = "navigation_start" /* NavigationStart */;
+};
+var WizardResolveEndEvent = class extends WizardEvent {
+  constructor(navigation) {
+    super(navigation);
+    this.navigation = navigation;
+  }
+  navigation;
+  type = "resolve_end" /* ResolveEnd */;
+};
+var WizardResolveStartEvent = class extends WizardEvent {
+  constructor(navigation) {
+    super(navigation);
+    this.navigation = navigation;
+  }
+  navigation;
+  type = "resolve_start" /* ResolveStart */;
+};
+var WizardScrollEndEvent = class extends WizardEvent {
+  constructor(navigation) {
+    super(navigation);
+    this.navigation = navigation;
+  }
+  navigation;
+  type = "scroll_end" /* ScrollEnd */;
+};
+var WizardScrollStartEvent = class extends WizardEvent {
+  constructor(navigation) {
+    super(navigation);
+    this.navigation = navigation;
+  }
+  navigation;
+  type = "scroll_start" /* ScrollStart */;
+};
+var WizardStepHideEvent = class extends WizardEvent {
+  constructor(navigation) {
+    super(navigation);
+    this.navigation = navigation;
+  }
+  navigation;
+  type = "step_hide" /* StepHide */;
+};
+var WizardStepShowEvent = class extends WizardEvent {
+  constructor(navigation) {
+    super(navigation);
+    this.navigation = navigation;
+  }
+  navigation;
+  type = "step_show" /* StepShow */;
+};
+
+// src/core/initializers/wizard-initializer.ts
+var WizardInitializer = class {
+};
+
+// src/core/initializers/wizard-default.initializer.ts
+var WizardDefaultInitializer = class extends WizardInitializer {
+  getState(tree) {
+    const builder = new WizardTreeStateBuilder(tree);
+    if (tree.activeSteps.length > 0) {
+      return builder.build();
+    }
+    const firstUnpassed = tree.activeBranch.shownCategories.find((category) => !category.isPassed) ?? tree.activeCategory;
+    return builder.activateCategory(firstUnpassed.id).build();
+  }
+};
+
+// src/core/listeners/wizard-listener.ts
+var WizardListener = class {
+  onDestroy(_tree) {
+    return;
+  }
+  onEvent(_event) {
+    return;
+  }
+  onInit(_tree) {
+    return;
+  }
+  onTreeChange(_tree) {
+    return;
+  }
+};
+
+// src/core/navigation/initializer-service.ts
+var WizardInitializerService = class {
+  constructor(wizardLog, wizardInitializers) {
+    this.wizardLog = wizardLog;
+    this.wizardInitializers = wizardInitializers;
+  }
+  wizardLog;
+  wizardInitializers;
+  async getInitialState(state, activeBranch) {
+    const htmlTree = buildWizardTreeState(state, activeBranch);
+    this.wizardLog.trace("HTML tree", htmlTree);
+    try {
+      this.validateHtmlTree(htmlTree);
+      this.validateActiveBranch(htmlTree, activeBranch);
+      let tree = htmlTree;
+      for (const initializer of this.wizardInitializers) {
+        tree = await initializer.getState(tree, htmlTree);
+        this.wizardLog.trace("Initializer", initializer, tree);
+      }
+      return tree;
+    } catch (e) {
+      this.wizardLog.error(e);
+      return htmlTree;
+    }
+  }
+  validateActiveBranch(htmlTree, activeBranch) {
+    if (!activeBranch) return;
+    if (!htmlTree.branchMap[activeBranch]) {
+      const branchIds = htmlTree.branches.map((branch) => branch.id).join(",");
+      throw new WizardError(
+        `[WizardInitializerService02]: There is no branch with id "${activeBranch}". List of available branches: ${branchIds}.`
+      );
+    }
+  }
+  validateHtmlTree(htmlTree) {
+    const seen = /* @__PURE__ */ new Set();
+    const duplicates = [];
+    for (const s of htmlTree.state) {
+      if (seen.has(s.id)) duplicates.push(s.id);
+      else seen.add(s.id);
+    }
+    if (duplicates.length > 0) {
+      throw new WizardInitializationError(
+        `[WizardInitializerService01]: There are steps with the same ID: ${duplicates.join(",")}.`
+      );
+    }
+  }
+};
+
+// src/core/navigation/typed-emitter.ts
+var TypedEmitter = class {
+  map = /* @__PURE__ */ new Map();
+  dispose() {
+    this.map.clear();
+  }
+  emit(event) {
+    const specific = this.map.get(event.type);
+    if (specific) {
+      for (const handler of [...specific]) handler(event);
+    }
+    const wildcard = this.map.get("*");
+    if (wildcard) {
+      for (const handler of [...wildcard]) handler(event);
+    }
+  }
+  on(type, handler) {
+    let set = this.map.get(type);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.map.set(type, set);
+    }
+    set.add(handler);
+    return () => {
+      set.delete(handler);
+    };
+  }
+};
+
+// src/core/navigation/wizard-navigation.ts
+var WizardNavigation = class _WizardNavigation {
+  constructor(from, to) {
+    this.from = from;
+    this.to = to;
+    const toTree = projectToTree(to);
+    this.id = `${from.id}=>${toTree.id}`;
+    this.direction = _WizardNavigation.getDirection(from, toTree);
+    this.isSkipping = _WizardNavigation.isSkipping(from, toTree, this.direction);
+    this.isCategoryChanging = _WizardNavigation.isCategoryChanging(from, toTree);
+    this.isScrollChanging = _WizardNavigation.isScrollChanging(from, toTree);
+    this.isExit = to instanceof WizardExitTreeState;
+    this.isComplete = to instanceof WizardCompleteTreeState;
+  }
+  from;
+  to;
+  direction;
+  id;
+  isCategoryChanging;
+  isComplete;
+  isExit;
+  isScrollChanging;
+  isSkipping;
+  static getDirection(from, to) {
+    if (_WizardNavigation.isCategoryChanging(from, to)) {
+      return from.activeCategory.htmlIndex > to.activeCategory.htmlIndex ? "back" : "next";
+    }
+    if (from.activeCategory.activeStepIndex === to.activeCategory.activeStepIndex) {
+      return to.activeCategory.id === to.activeBranch.firstCategory.id ? "back" : "next";
+    }
+    return from.activeCategory.activeStepIndex > to.activeCategory.activeStepIndex ? "back" : "next";
+  }
+  static isCategoryChanging(from, to) {
+    return from.activeCategory.id !== to.activeCategory.id;
+  }
+  static isScrollChanging(from, to) {
+    const isSamePosition = from.activeCategory.activeStepIndex === to.activeCategory.activeStepIndex;
+    const isSameStep = from.activeCategory.lastActiveStep.id === to.activeCategory.lastActiveStep.id;
+    return !isSameStep || !isSamePosition;
+  }
+  /**
+   * Navigation counted as skipped when Category "A" was "active" and not "skipped" before transition
+   * and became "inactive" and "skipped" after transition.
+   */
+  static isSkipping(from, to, direction = _WizardNavigation.getDirection(from, to)) {
+    if (direction === "back") {
+      return false;
+    }
+    const isPrevCategoryAlreadySkipped = from.activeCategory.isSkipped;
+    const isPrevCategorySkipped = to.categoryMap[from.activeCategory.id].isSkipped;
+    return !isPrevCategoryAlreadySkipped && isPrevCategorySkipped;
+  }
+};
+
+// src/core/navigation/navigation-service.ts
+var WizardNavigationService = class {
+  constructor(wizardStore, wizardConfig, wizardStateService, wizardScrollStrategy) {
+    this.wizardStore = wizardStore;
+    this.wizardConfig = wizardConfig;
+    this.wizardStateService = wizardStateService;
+    this.wizardScrollStrategy = wizardScrollStrategy;
+  }
+  wizardStore;
+  wizardConfig;
+  wizardStateService;
+  wizardScrollStrategy;
+  get isNavigating() {
+    return !!this.inFlight;
+  }
+  disposed = false;
+  emitter = new TypedEmitter();
+  inFlight = null;
+  prevSuccessId = null;
+  async completeWizard() {
+    const tree = this.wizardStore.getTreeSnapshot();
+    const to = new WizardCompleteTreeState(tree);
+    return this.navigate(to);
+  }
+  dispose() {
+    this.disposed = true;
+    if (this.inFlight) {
+      this.inFlight.abort.abort();
+      this.inFlight = null;
+    }
+    this.emitter.dispose();
+  }
+  async exitWizard() {
+    try {
+      const tree = this.wizardStore.getTreeSnapshot();
+      const to = new WizardExitTreeState(tree);
+      return this.navigate(to);
+    } catch {
+      this.emitter.emit(new WizardExitEvent());
+      return true;
+    }
+  }
+  async hideCategory(categoryId) {
+    const to = this.wizardStateService.hideCategory(categoryId);
+    return this.hide(this.projectTree(to));
+  }
+  async hideStep(step) {
+    const tree = this.wizardStore.getTreeSnapshot();
+    const to = toArray(step).reduce((acc, id) => {
+      const accTree = this.projectTree(acc);
+      return this.wizardStateService.hideStep(id, accTree);
+    }, tree);
+    return this.hide(this.projectTree(to));
+  }
+  async navigate(to) {
+    if (this.disposed) return false;
+    const fromTree = this.wizardStore.getTreeSnapshot();
+    const navigation = new WizardNavigation(fromTree, to);
+    if (navigation.id === this.prevSuccessId && !navigation.isExit && !navigation.isComplete) {
+      this.emitter.emit(new WizardNavigationIgnoredEvent(navigation, "same_navigation"));
+      return false;
+    }
+    if (this.inFlight) {
+      const prior = this.inFlight;
+      prior.abort.abort();
+      this.inFlight = null;
+      this.emitter.emit(new WizardNavigationCancelledEvent(prior.navigation, "new_navigation"));
+    }
+    const abort = new AbortController();
+    this.inFlight = { abort, navigation };
+    try {
+      this.emitter.emit(new WizardNavigationStartEvent(navigation));
+      this.emitter.emit(new WizardResolveStartEvent(navigation));
+      try {
+        await this.runResolverChain(navigation, abort.signal);
+      } catch (e) {
+        if (this.isAbortReason(e, abort.signal)) {
+          return false;
+        }
+        if (e instanceof WizardResolverError) {
+          this.emitter.emit(new WizardNavigationCancelledEvent(navigation, "resolver"));
+          return false;
+        }
+        this.emitter.emit(new WizardNavigationErrorEvent(navigation));
+        console.error(e);
+        throw e;
+      }
+      if (abort.signal.aborted) return false;
+      this.emitter.emit(new WizardResolveEndEvent(navigation));
+      this.commitTree(navigation, to);
+      this.emitVisibilityFlips(navigation, fromTree, to);
+      this.emitter.emit(new WizardNavigationEndEvent(navigation));
+      if (navigation.isExit) this.emitter.emit(new WizardExitEvent(navigation));
+      if (navigation.isComplete) this.emitter.emit(new WizardCompleteEvent(navigation));
+      if (!navigation.isExit && !navigation.isComplete && navigation.isScrollChanging) {
+        this.emitter.emit(new WizardScrollStartEvent(navigation));
+        await this.wizardScrollStrategy.onNavigate(navigation);
+        this.emitter.emit(new WizardScrollEndEvent(navigation));
+      }
+      this.prevSuccessId = navigation.id;
+      return true;
+    } finally {
+      if (this.inFlight && this.inFlight.navigation === navigation) {
+        this.inFlight = null;
+      }
+    }
+  }
+  on(type, handler) {
+    return this.emitter.on(type, handler);
+  }
+  async showCategory(categoryId) {
+    const to = this.wizardStateService.showCategory(categoryId);
+    return this.show(to);
+  }
+  async showStep(step) {
+    const tree = this.wizardStore.getTreeSnapshot();
+    const to = toArray(step).reduce(
+      (acc, id) => this.wizardStateService.showStep(id, acc),
+      tree
+    );
+    return this.show(to);
+  }
+  // --- internals ---
+  commitTree(navigation, to) {
+    if (navigation.isExit || navigation.isComplete) {
+      const tree = this.projectTree(to);
+      this.wizardStore.setState(tree);
+      return;
+    }
+    this.wizardStore.setState(to);
+  }
+  emitVisibilityFlips(navigation, from, to) {
+    const toTree = this.projectTree(to);
+    for (const stepId of Object.keys(from.stepMap)) {
+      const before = from.stepMap[stepId];
+      const after = toTree.stepMap[stepId];
+      if (!before || !after) continue;
+      if (before.isShow === after.isShow) continue;
+      if (after.isShow) {
+        this.emitter.emit(new WizardStepShowEvent(navigation));
+      } else {
+        this.emitter.emit(new WizardStepHideEvent(navigation));
+      }
+    }
+  }
+  async hide(to) {
+    const fromTree = this.wizardStore.getTreeSnapshot();
+    const navigation = new WizardNavigation(fromTree, to);
+    this.wizardStore.setState(to);
+    this.emitter.emit(new WizardStepHideEvent(navigation));
+    if (navigation.isScrollChanging) {
+      await this.wizardScrollStrategy.onToggle(navigation);
+    }
+    return true;
+  }
+  async invokeResolver(resolver, navigation, signal) {
+    if (!resolver) return;
+    if (signal.aborted) throw new DOMException("aborted", "AbortError");
+    const abortPromise = new Promise((_, reject) => {
+      const onAbort = () => reject(new DOMException("aborted", "AbortError"));
+      if (signal.aborted) {
+        onAbort();
+      } else {
+        signal.addEventListener("abort", onAbort, { once: true });
+      }
+    });
+    const result = await Promise.race([Promise.resolve(resolver(navigation)), abortPromise]);
+    if (signal.aborted) throw new DOMException("aborted", "AbortError");
+    if (!result) {
+      throw new WizardResolverError(`Resolver rejected navigation ${navigation.id}`);
+    }
+  }
+  isAbortReason(error, signal) {
+    if (!signal.aborted) return false;
+    if (error instanceof DOMException && error.name === "AbortError") return true;
+    return false;
+  }
+  projectTree(to) {
+    if (to instanceof WizardExitTreeState || to instanceof WizardCompleteTreeState) {
+      return to.originTree;
+    }
+    return to;
+  }
+  async runResolverChain(navigation, signal) {
+    const config = this.wizardConfig.getOptions();
+    if (navigation.direction === "next" && navigation.isCategoryChanging && !navigation.isSkipping) {
+      await this.invokeResolver(config.resolveCategoryComplete, navigation, signal);
+    }
+    if (navigation.isCategoryChanging) {
+      await this.invokeResolver(config.resolveCategoryChange, navigation, signal);
+    }
+    if (navigation.isCategoryChanging) {
+      await this.invokeResolver(config.resolveCategoryEnter, navigation, signal);
+    }
+    await this.invokeResolver(config.resolveStepChange, navigation, signal);
+  }
+  async show(to) {
+    const fromTree = this.wizardStore.getTreeSnapshot();
+    const toTree = this.projectTree(to);
+    const navigation = new WizardNavigation(fromTree, toTree);
+    this.wizardStore.setState(toTree);
+    this.emitter.emit(new WizardStepShowEvent(navigation));
+    if (navigation.isScrollChanging) {
+      await this.wizardScrollStrategy.onToggle(navigation);
+    }
+    return true;
+  }
+};
+
+// src/core/navigation/state-service.ts
+var WizardStateService = class {
+  constructor(wizardStore, wizardConfig) {
+    this.wizardStore = wizardStore;
+    this.wizardConfig = wizardConfig;
+  }
+  wizardStore;
+  wizardConfig;
+  completeCategory(category, tree = this.currentTree()) {
+    const { activeBranch } = tree;
+    const { activeCategory, nextCategory } = activeBranch;
+    const builder = new WizardTreeStateBuilder(tree);
+    builder.completeCategory(category);
+    if (activeCategory.id === category && nextCategory) {
+      return builder.deactivateCategory(category).activateCategory(nextCategory.id).build();
+    }
+    if (activeCategory.id === category && !nextCategory) {
+      return builder.buildComplete();
+    }
+    return builder.build();
+  }
+  goToCategory(categoryId, tree = this.currentTree()) {
+    const { activeBranch, activeCategory, branchMap, categoryMap } = tree;
+    const builder = new WizardTreeStateBuilder(tree);
+    const toCategory = categoryMap[categoryId];
+    const toCategoryFirstBranch = branchMap[toCategory.branches[0]];
+    const toCategoryBranch = toCategory.branches.includes(activeBranch.id) ? activeBranch : toCategoryFirstBranch;
+    const toCategoryIndex = toCategoryBranch.getShownCategoryIndex(toCategory);
+    const activeCategoryIndex = toCategoryBranch.getShownCategoryIndex(activeCategory);
+    if (activeBranch !== toCategoryBranch && toCategoryIndex > activeCategoryIndex) {
+      throw new WizardError(
+        `[State02]: Trying to switch to category "${categoryId}" in different branch "${toCategoryBranch.id}" from current active branch "${activeBranch.id}", but new category has uncompleted prev category in new branch.`
+      );
+    }
+    if (toCategoryIndex > activeCategoryIndex) {
+      activeBranch.getShownCategories(activeCategoryIndex, toCategoryIndex - 1).forEach((mid) => builder.skipCategoryUncompleted(mid.id));
+    }
+    if (this.wizardConfig.getOptions().isBackResetCompleted && toCategoryIndex < activeCategoryIndex) {
+      activeBranch.getShownCategories(toCategoryIndex + 1, activeCategoryIndex).forEach((mid) => builder.resetCategory(mid.id));
+    }
+    builder.deactivateCategory(activeCategory.id);
+    if (this.wizardConfig.getOptions().isShowFirstStepOnCategoryChange) {
+      return builder.activateFirstStep(categoryId).build();
+    }
+    return builder.activateCategory(categoryId).build();
+  }
+  hideCategory(categoryId, tree = this.currentTree()) {
+    const { activeBranch, activeCategory } = tree;
+    const projected = activeCategory.id === categoryId ? this.projectShownCategory(categoryId, tree) : tree;
+    const builder = new WizardTreeStateBuilder(projected, activeBranch.id);
+    return builder.hideCategory(categoryId).build();
+  }
+  hideStep(step, tree = this.currentTree()) {
+    const { activeBranch, lastActiveStep } = tree;
+    const projected = lastActiveStep.id === step ? this.projectShownStep(step, tree) : tree;
+    const builder = new WizardTreeStateBuilder(projected, activeBranch.id);
+    return builder.hideStep(step).deactivateStep(step).build();
+  }
+  next(branch, tree = this.currentTree()) {
+    const { activeBranch, branchMap } = tree;
+    const nextBranch = branch ? branchMap[branch] : activeBranch;
+    const builder = new WizardTreeStateBuilder(tree, branch ?? activeBranch.id);
+    const activeCategory = nextBranch.activeCategory;
+    const activeStep = activeCategory.lastActiveStep;
+    const nextCategory = nextBranch.nextCategory;
+    const nextStep = activeCategory.nextStep;
+    if (activeBranch.activeCategory !== nextBranch.activeCategory) {
+      throw new WizardError(
+        `[State01]: In order to move to the "${branch}" branch, you need to have common category between 2 branches`
+      );
+    }
+    builder.unskipCategory(activeCategory.id).completeStep(activeStep.id);
+    if (nextStep) {
+      return builder.activateStep(nextStep.id).build();
+    }
+    if (nextCategory) {
+      builder.deactivateCategory(activeCategory.id);
+      if (this.wizardConfig.getOptions().isShowFirstStepOnCategoryChange) {
+        return builder.activateFirstStep(nextCategory.id).build();
+      }
+      return builder.activateCategory(nextCategory.id).build();
+    }
+    return builder.buildComplete();
+  }
+  nextCategory(branch, tree = this.currentTree()) {
+    const { activeBranch, branchMap } = tree;
+    const nextBranch = branch ? branchMap[branch] : activeBranch;
+    const builder = new WizardTreeStateBuilder(tree, branch ?? activeBranch.id);
+    const activeCategory = nextBranch.activeCategory;
+    const activeStep = activeCategory.lastActiveStep;
+    const nextCategory = nextBranch.nextCategory;
+    if (activeBranch.activeCategory !== nextBranch.activeCategory) {
+      throw new WizardError(
+        `[State01]: In order to move to the "${branch}" branch, you need to have common category between 2 branches`
+      );
+    }
+    builder.deactivateCategory(activeCategory.id).completeStep(activeStep.id);
+    if (nextCategory) {
+      builder.skipCategoryUncompleted(activeCategory.id);
+      if (this.wizardConfig.getOptions().isShowFirstStepOnCategoryChange) {
+        return builder.activateFirstStep(nextCategory.id).build();
+      }
+      return builder.activateCategory(nextCategory.id).build();
+    }
+    return builder.buildComplete();
+  }
+  prev(tree = this.currentTree()) {
+    const { activeBranch } = tree;
+    const builder = new WizardTreeStateBuilder(tree);
+    const activeCategory = activeBranch.activeCategory;
+    const activeStep = activeCategory.lastActiveStep;
+    const prevCategory = activeBranch.prevCategory;
+    const prevStep = activeCategory.prevStep;
+    if (this.wizardConfig.getOptions().isBackResetCompleted) {
+      builder.uncompleteStep(activeStep.id);
+    }
+    if (prevStep) {
+      return builder.deactivateStep(activeStep.id).build();
+    }
+    if (prevCategory) {
+      return builder.deactivateCategory(activeCategory.id).activateCategory(prevCategory.id).build();
+    }
+    return builder.buildExit();
+  }
+  prevCategory(tree = this.currentTree()) {
+    const { activeBranch } = tree;
+    const builder = new WizardTreeStateBuilder(tree);
+    const activeCategory = activeBranch.activeCategory;
+    const prevCategory = activeBranch.prevCategory;
+    if (prevCategory && this.wizardConfig.getOptions().isBackResetCompleted) {
+      builder.resetCategory(activeCategory.id);
+    }
+    if (prevCategory) {
+      return builder.deactivateCategory(activeCategory.id).activateCategory(prevCategory.id).build();
+    }
+    return builder.buildExit();
+  }
+  resetCategory(category, from = 0, tree = this.currentTree()) {
+    const { activeCategory } = tree;
+    const builder = new WizardTreeStateBuilder(tree);
+    builder.resetCategory(category, from);
+    if (activeCategory.id === category) {
+      return builder.activateStep(activeCategory.firstStep.id).build();
+    }
+    return builder.build();
+  }
+  resetTree(tree = this.currentTree()) {
+    const reset = new WizardTreeStateBuilder(tree).getResetTree();
+    return new WizardTreeStateBuilder(reset, tree.activeBranch.id).activateStep(reset.activeCategory.firstStep.id).build();
+  }
+  showCategory(categoryId, tree = this.currentTree()) {
+    const { activeBranch } = tree;
+    const builder = new WizardTreeStateBuilder(tree);
+    const activeCategoryIndex = activeBranch.categories.indexOf(activeBranch.activeCategory);
+    const categoryIndex = activeBranch.categories.findIndex((category) => category.id === categoryId);
+    const isBeforeActiveCategory = activeCategoryIndex > categoryIndex;
+    builder.showCategory(categoryId);
+    if (isBeforeActiveCategory) builder.skipCategory(categoryId);
+    return builder.build();
+  }
+  showStep(step, tree = this.currentTree()) {
+    const { activeCategory, lastActiveStep, stepMap } = tree;
+    const builder = new WizardTreeStateBuilder(tree);
+    const stepState = stepMap[step];
+    const isInActiveCategory = activeCategory.steps.some((s) => s.id === step);
+    const isBeforeLastActiveStep = lastActiveStep.htmlIndex > stepState.htmlIndex;
+    builder.showStep(step);
+    if (isBeforeLastActiveStep) builder.completeStep(step);
+    if (isInActiveCategory && isBeforeLastActiveStep) builder.activateStep(step);
+    return builder.build();
+  }
+  skipCategory(category, tree = this.currentTree()) {
+    const { activeBranch } = tree;
+    const { activeCategory, nextCategory } = activeBranch;
+    const builder = new WizardTreeStateBuilder(tree);
+    builder.skipCategory(category);
+    if (activeCategory.id === category && nextCategory) {
+      return builder.deactivateCategory(category).activateCategory(nextCategory.id).build();
+    }
+    if (activeCategory.id === category && !nextCategory) {
+      return builder.buildComplete();
+    }
+    return builder.build();
+  }
+  currentTree() {
+    return this.wizardStore.getTreeSnapshot();
+  }
+  projectShownCategory(categoryId, tree) {
+    const { activeBranch } = tree;
+    const result = categoryId === activeBranch.firstCategory.id ? this.nextCategory(null, tree) : this.prevCategory(tree);
+    return result;
+  }
+  projectShownStep(step, tree) {
+    const { activeBranch, activeCategory, stepMap } = tree;
+    const stepState = stepMap[step];
+    const isFirstCategory = stepState.categoryId === activeBranch.firstCategory.id;
+    const isFirstStep = step === activeCategory.firstStep.id;
+    const result = isFirstCategory && isFirstStep ? this.next(null, tree) : this.prev(tree);
+    return result;
+  }
+};
+
+// src/core/strategies/progress/wizard-progress.strategy.ts
+var WizardProgressStrategy = class {
+};
+
+// src/core/strategies/progress/wizard-active-progress.strategy.ts
+var WizardActiveProgressStrategy = class extends WizardProgressStrategy {
+  getProgress(tree) {
+    const { activeCategory, categoryMap } = tree;
+    const progress = {};
+    for (const category of Object.keys(categoryMap)) {
+      const categoryState = categoryMap[category];
+      if (categoryState.htmlIndex !== activeCategory.htmlIndex) {
+        progress[category] = categoryState.htmlIndex < activeCategory.htmlIndex ? 100 : 0;
+        continue;
+      }
+      progress[category] = categoryState.shownSteps.length > 0 ? (categoryState.activeSteps.length - 1) * 100 / categoryState.shownSteps.length : 0;
+    }
+    return progress;
+  }
+};
+
+// src/core/strategies/scroll/wizard-scroll.strategy.ts
+var WizardScrollStrategy = class {
+  // Thin re-export so subclasses keep the existing call site.
+  static projectToTree = projectToTree;
+  container;
+  /** Called when toggling step/category visibility (instant scroll by default). */
+  onToggle(navigation) {
+    const tree = projectToTree(navigation.to);
+    if (!tree) return Promise.resolve(false);
+    const isFirstStepOfCategory = tree.lastActiveStep?.id === tree.activeCategory.firstStep?.id;
+    return scrollToStep(isFirstStepOfCategory ? null : tree.lastActiveStep?.id, "auto", this.container);
+  }
+  /**
+   * Imperative scroll-to-top of the configured container (or window). Useful
+   * for surfacing top-of-page state — e.g. an error banner — after a failed
+   * submit, without re-running the navigation pipeline.
+   */
+  scrollToTop(behavior = "smooth") {
+    return scrollToStep(null, behavior, this.container);
+  }
+  setContainer(container) {
+    this.container = container;
+  }
+};
+function scrollToStep(stepId, behavior, container) {
+  if (typeof document === "undefined") return Promise.resolve(false);
+  const reducedMotion = typeof window !== "undefined" && typeof window.matchMedia === "function" ? window.matchMedia("(prefers-reduced-motion: reduce)").matches : false;
+  const effectiveBehavior = reducedMotion ? "auto" : behavior;
+  if (!stepId) {
+    const containerEl = resolveScrollContainer(container);
+    if (containerEl) {
+      containerEl.scrollTo({ behavior: effectiveBehavior, top: 0 });
+    } else if (typeof window !== "undefined") {
+      window.scrollTo({ behavior: effectiveBehavior, top: 0 });
+    }
+    return Promise.resolve(true);
+  }
+  const element = document.getElementById(stepId);
+  if (!element) return Promise.resolve(false);
+  element.scrollIntoView({ behavior: effectiveBehavior, block: "start" });
+  return Promise.resolve(true);
+}
+function resolveScrollContainer(c) {
+  if (!c) return null;
+  if (typeof c === "function") return c();
+  if ("current" in c) return c.current;
+  return c;
+}
+
+// src/core/strategies/scroll/wizard-smooth-scroll.strategy.ts
+var WizardSmoothScrollStrategy = class extends WizardScrollStrategy {
+  constructor(wizardConfig) {
+    super();
+    this.wizardConfig = wizardConfig;
+  }
+  wizardConfig;
+  onNavigate(navigation) {
+    const tree = WizardScrollStrategy.projectToTree(navigation.to);
+    if (!tree) return Promise.resolve(false);
+    const isFirstStepOfCategory = tree.lastActiveStep?.id === tree.activeCategory.firstStep?.id;
+    const stepId = isFirstStepOfCategory ? null : tree.lastActiveStep?.id;
+    const useInstant = navigation.isCategoryChanging || (this.wizardConfig?.isMobile ?? false);
+    return scrollToStep(stepId, useInstant ? "auto" : "smooth", this.container);
+  }
+};
+
+// src/core/strategies/visibility/wizard-visibility.strategy.ts
+var WizardVisibilityStrategy = class {
+};
+
+// src/core/strategies/visibility/wizard-default-visibility.strategy.ts
+var WizardDefaultVisibilityStrategy = class extends WizardVisibilityStrategy {
+  constructor(wizardConfig) {
+    super();
+    this.wizardConfig = wizardConfig;
+  }
+  wizardConfig;
+  isStepVisible(step, tree) {
+    const isShowStep = step.isActive && step.isShow;
+    const isLastActiveStep = step.id === tree.lastActiveStep?.id;
+    return this.wizardConfig.isMobile ? isShowStep && isLastActiveStep : isShowStep;
+  }
+};
+
+// src/core/strategies/visibility/wizard-last-active-visibility.strategy.ts
+var WizardLastActiveVisibilityStrategy = class extends WizardVisibilityStrategy {
+  isStepVisible(step, tree) {
+    const isShowStep = step.isActive && step.isShow;
+    const isLastActiveStep = step.id === tree.lastActiveStep?.id;
+    return isShowStep && isLastActiveStep;
+  }
+};
+
+// src/core/wizard-default.config.ts
+var passResolver = () => true;
+var wizardDefaultConfig = {
+  backBtnClass: "",
+  backBtnText: "Back",
+  doneDotText: "Finish",
+  enableTracing: "none",
+  finishText: "Finish",
+  headerI18n: null,
+  isActiveCategoryClickReset: true,
+  isBackResetCompleted: true,
+  isDoneDot: false,
+  isShowFirstStepOnCategoryChange: false,
+  isShowWizardHeader: true,
+  isShowWizardHeaderSteps: true,
+  nextBtnClass: "",
+  nextBtnText: "Next",
+  nextCategoryText: "Continue",
+  resolveCategoryChange: passResolver,
+  resolveCategoryComplete: passResolver,
+  resolveCategoryEnter: passResolver,
+  resolveStepChange: passResolver,
+  silenceErrors: false,
+  stickyHeader: true
+};
+
+// src/core/wizard-config.ts
+var WizardConfig = class {
+  /**
+   * Whether the wizard is rendering on a mobile viewport. Used by the default
+   * visibility and scroll strategies. The React adapter (Phase 15) updates this
+   * via a media-query subscription; in plain Node (tests/SSR), it stays `false`.
+   */
+  isMobile = false;
+  get options() {
+    return this.current;
+  }
+  current;
+  disposed = false;
+  listeners = /* @__PURE__ */ new Set();
+  notifyScheduled = false;
+  constructor(overrides = {}) {
+    this.current = { ...wizardDefaultConfig, ...overrides };
+  }
+  dispose() {
+    this.disposed = true;
+    this.listeners.clear();
+  }
+  getOptions() {
+    return this.current;
+  }
+  setOptions(options) {
+    if (this.disposed) return this;
+    let changed = false;
+    for (const k of Object.keys(options)) {
+      if (!Object.is(options[k], this.current[k])) {
+        changed = true;
+        break;
+      }
+    }
+    if (!changed) return this;
+    this.current = { ...this.current, ...options };
+    this.scheduleNotify();
+    return this;
+  }
+  subscribe(listener) {
+    if (this.disposed) return () => {
+    };
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  scheduleNotify() {
+    if (this.notifyScheduled) return;
+    this.notifyScheduled = true;
+    queueMicrotask(() => {
+      this.notifyScheduled = false;
+      if (this.disposed) return;
+      const snapshot = this.current;
+      for (const listener of [...this.listeners]) {
+        listener(snapshot);
+      }
+    });
+  }
+};
+
+// src/core/wizard-log.ts
+var WizardLog = class {
+  constructor(wizardConfig) {
+    this.wizardConfig = wizardConfig;
+  }
+  wizardConfig;
+  error(e) {
+    if (!(e instanceof WizardError)) {
+      console.error(e);
+      return;
+    }
+    if (this.wizardConfig.getOptions().silenceErrors) {
+      return;
+    }
+    console.error(e);
+  }
+  trace(...args) {
+    if (this.wizardConfig.getOptions().enableTracing !== "none") {
+      console.log(...args);
+    }
+  }
+};
+
+// src/core/wizard-store.ts
+var WizardStore = class {
+  constructor(storagePrefix) {
+    this.storagePrefix = storagePrefix;
+    this.initOnce = new Promise((resolve) => {
+      this.resolveInitOnce = resolve;
+    });
+  }
+  storagePrefix;
+  initOnce;
+  get shapeId() {
+    return this._shapeId ?? "";
+  }
+  _shapeId = null;
+  current = null;
+  disposed = false;
+  initialTree = null;
+  listeners = /* @__PURE__ */ new Set();
+  resolveInitOnce;
+  dispose() {
+    this.disposed = true;
+    this.listeners.clear();
+  }
+  getTreeSnapshot() {
+    if (!this.current) {
+      throw new WizardInitializationError("[WizardStore] getTreeSnapshot called before init");
+    }
+    return this.current;
+  }
+  init(initialTree) {
+    if (this.disposed) return;
+    if (this.initialTree) {
+      console.warn("[WizardStore] init() called more than once; ignoring subsequent call.");
+      return;
+    }
+    this.initialTree = initialTree;
+    this._shapeId = getShapeId(initialTree.state, this.storagePrefix);
+    this.setState(initialTree);
+    this.resolveInitOnce(initialTree);
+  }
+  setState(tree) {
+    if (this.disposed) return;
+    if (!this.initialTree) {
+      throw new WizardInitializationError("[WizardStore] setState called before init");
+    }
+    if (this.current === tree) return;
+    this.current = tree;
+    for (const listener of [...this.listeners]) {
+      listener();
+    }
+  }
+  subscribe = (listener) => {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  };
+};
+
+// src/core/wizard-engine.ts
+var WizardEngine = class {
+  get configOptions() {
+    return this.config.options;
+  }
+  get isInitialized() {
+    return this.initialized;
+  }
+  get lastActiveStep() {
+    return this.tree.lastActiveStep;
+  }
+  get progress() {
+    return this.progressStrategy.getProgress(this.tree);
+  }
+  get shapeId() {
+    return this.store.shapeId;
+  }
+  get steps() {
+    return this.tree.stepMap;
+  }
+  get tree() {
+    return this.store.getTreeSnapshot();
+  }
+  committed = false;
+  // commitRegistration() entered
+  config;
+  disposed = false;
+  initialBranch;
+  initialized = false;
+  // store.init() ran successfully
+  initialState;
+  initService;
+  listeners;
+  log;
+  // ------------- snapshots -------------
+  navService;
+  pendingPostInitTasks = [];
+  progressStrategy;
+  scrollStrategy;
+  stateService;
+  store;
+  visibilityStrategy;
+  constructor(options) {
+    this.config = new WizardConfig(options.config ?? {});
+    const storagePrefix = options.config?.storagePrefix ?? void 0;
+    this.store = new WizardStore(storagePrefix);
+    this.log = new WizardLog(this.config);
+    this.scrollStrategy = options.strategies?.scroll ?? new WizardSmoothScrollStrategy(this.config);
+    if (options.scrollContainer !== void 0) {
+      this.scrollStrategy.setContainer(options.scrollContainer);
+    }
+    this.visibilityStrategy = options.strategies?.visibility ?? new WizardDefaultVisibilityStrategy(this.config);
+    this.progressStrategy = options.strategies?.progress ?? new WizardActiveProgressStrategy();
+    this.stateService = new WizardStateService(this.store, this.config);
+    this.navService = new WizardNavigationService(
+      this.store,
+      this.config,
+      this.stateService,
+      this.scrollStrategy
+    );
+    const initializers = options.initializers ?? [new WizardDefaultInitializer()];
+    this.initService = new WizardInitializerService(this.log, initializers);
+    this.listeners = options.listeners ?? [];
+    this.initialState = options.state;
+    this.initialBranch = options.activeBranch;
+  }
+  // ------------- React adapter wiring -------------
+  back() {
+    return this.runOrQueue(() => this.navService.navigate(this.stateService.prev()));
+  }
+  backCategory() {
+    return this.runOrQueue(() => this.navService.navigate(this.stateService.prevCategory()));
+  }
+  async commitRegistration() {
+    if (this.disposed) return;
+    if (this.committed) return;
+    this.committed = true;
+    const tree = await this.initService.getInitialState(this.initialState, this.initialBranch);
+    if (this.disposed) {
+      for (const task of this.pendingPostInitTasks.splice(0)) task.resolve(false);
+      return;
+    }
+    this.store.init(tree);
+    this.initialized = true;
+    for (const listener of this.listeners) {
+      try {
+        listener.onInit(tree);
+      } catch (e) {
+        this.log.error(e);
+      }
+    }
+    this.store.subscribe(() => {
+      const current = this.store.getTreeSnapshot();
+      for (const listener of this.listeners) {
+        try {
+          listener.onTreeChange(current);
+        } catch (e) {
+          this.log.error(e);
+        }
+      }
+    });
+    this.navService.on("*", (event) => {
+      for (const listener of this.listeners) {
+        try {
+          listener.onEvent(event);
+        } catch (e) {
+          this.log.error(e);
+        }
+      }
+    });
+    for (const task of this.pendingPostInitTasks.splice(0)) {
+      task.run();
+    }
+  }
+  // ------------- bootstrap -------------
+  completeWizard() {
+    return this.runOrQueue(() => this.navService.completeWizard());
+  }
+  // ------------- imperative API -------------
+  dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    for (const task of this.pendingPostInitTasks.splice(0)) task.resolve(false);
+    const lastTree = this.initialized ? this.store.getTreeSnapshot() : null;
+    for (const listener of this.listeners) {
+      try {
+        listener.onDestroy(lastTree);
+      } catch (e) {
+        this.log.error(e);
+      }
+    }
+    this.navService.dispose();
+    this.store.dispose();
+    this.config.dispose();
+  }
+  exitWizard() {
+    return this.runOrQueue(() => this.navService.exitWizard());
+  }
+  getTreeSnapshot = () => this.store.getTreeSnapshot();
+  go(tree) {
+    return this.runOrQueue(() => this.navService.navigate(tree));
+  }
+  goToCategory(category) {
+    return this.runOrQueue(() => this.navService.navigate(this.stateService.goToCategory(category)));
+  }
+  hideCategory(category) {
+    return this.runOrQueue(() => this.navService.hideCategory(category));
+  }
+  hideStep(step) {
+    return this.runOrQueue(() => this.navService.hideStep(step));
+  }
+  isStepVisible(stepId) {
+    const tree = this.store.getTreeSnapshot();
+    const step = tree.stepMap[stepId];
+    if (!step) return false;
+    return this.visibilityStrategy.isStepVisible(step, tree);
+  }
+  next(branch) {
+    return this.runOrQueue(() => this.navService.navigate(this.stateService.next(branch ?? null)));
+  }
+  nextCategory(branch) {
+    return this.runOrQueue(() => this.navService.navigate(this.stateService.nextCategory(branch ?? null)));
+  }
+  on(type, handler) {
+    return this.navService.on(type, handler);
+  }
+  resetActiveCategory(from = 0) {
+    return this.runOrQueue(
+      () => this.navService.navigate(this.stateService.resetCategory(this.tree.activeCategory.id, from))
+    );
+  }
+  resetCategory(category, from = 0) {
+    return this.runOrQueue(() => this.navService.navigate(this.stateService.resetCategory(category, from)));
+  }
+  resetWizard() {
+    return this.runOrQueue(() => this.navService.navigate(this.stateService.resetTree()));
+  }
+  scrollToTop(behavior = "smooth") {
+    return this.scrollStrategy.scrollToTop(behavior);
+  }
+  showCategory(category) {
+    return this.runOrQueue(() => this.navService.showCategory(category));
+  }
+  showStep(step) {
+    return this.runOrQueue(() => this.navService.showStep(step));
+  }
+  skipActiveCategory() {
+    return this.runOrQueue(
+      () => this.navService.navigate(this.stateService.skipCategory(this.tree.activeCategory.id))
+    );
+  }
+  skipCategory(category) {
+    return this.runOrQueue(
+      () => this.navService.navigate(this.stateService.skipCategory(category ?? this.tree.activeCategory.id))
+    );
+  }
+  subscribe = (listener) => this.store.subscribe(listener);
+  toggleCategory(category, show) {
+    return show ? this.showCategory(category) : this.hideCategory(category);
+  }
+  // ------------- lifecycle -------------
+  toggleStep(step, show) {
+    return show ? this.showStep(step) : this.hideStep(step);
+  }
+  // ------------- internal -------------
+  runOrQueue(action) {
+    if (this.disposed) {
+      return Promise.resolve(false);
+    }
+    if (!this.initialized) {
+      return new Promise((resolve, reject) => {
+        this.pendingPostInitTasks.push({
+          resolve,
+          run: () => {
+            action().then(resolve, reject);
+          }
+        });
+      });
+    }
+    return action();
+  }
+};
+
+// src/enums/wizard-category-direction.enum.ts
+var WizardCategoryDirection = /* @__PURE__ */ ((WizardCategoryDirection2) => {
+  WizardCategoryDirection2["Backward"] = "backward";
+  WizardCategoryDirection2["Forward"] = "forward";
+  return WizardCategoryDirection2;
+})(WizardCategoryDirection || {});
+
+// src/react/components-provider.tsx
+var import_react = require("react");
+var import_jsx_runtime = require("react/jsx-runtime");
+var FallbackButton = (props) => {
+  const { children, asChild: _asChild, variant: _variant, size: _size, ...rest } = props;
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("button", { ...rest, type: props.type ?? "button", children });
+};
+var FallbackBackArrowIcon = ({ className }) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)("svg", { className, width: "16", height: "16", viewBox: "0 0 16 16", fill: "currentColor", "aria-hidden": true, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("path", { d: "M10 4 L6 8 L10 12", stroke: "currentColor", strokeWidth: "1.5", fill: "none" }) });
+var defaults = { Button: FallbackButton, BackArrowIcon: FallbackBackArrowIcon };
+var WizardComponentsContext = (0, import_react.createContext)(defaults);
+function WizardComponentsProvider(props) {
+  const { Button, BackArrowIcon, children } = props;
+  const value = {
+    Button: Button ?? defaults.Button,
+    BackArrowIcon: BackArrowIcon ?? defaults.BackArrowIcon
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(WizardComponentsContext.Provider, { value, children });
+}
+function useWizardComponents() {
+  return (0, import_react.useContext)(WizardComponentsContext);
+}
+
+// src/react/use-wizard.ts
+var import_react3 = require("react");
+
+// src/react/context.ts
+var import_react2 = require("react");
+var WizardEngineContext = (0, import_react2.createContext)(null);
+
+// src/react/use-wizard.ts
+function useWizard() {
+  const engine = (0, import_react3.useContext)(WizardEngineContext);
+  if (!engine) {
+    throw new WizardError("useWizard must be used inside <WizardProvider>");
+  }
+  (0, import_react3.useSyncExternalStore)(engine.subscribe, engine.getTreeSnapshot, engine.getTreeSnapshot);
+  return engine;
+}
+
+// src/react/components/wizard-action-button.tsx
+var import_react_slot = require("@radix-ui/react-slot");
+var import_jsx_runtime2 = require("react/jsx-runtime");
+function WizardActionButton(props) {
+  const { Button } = useWizardComponents();
+  if (props.asChild) {
+    return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react_slot.Slot, { className: props.className, onClick: props.onClick, children: props.children });
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Button, { className: props.className, onClick: props.onClick, type: "button", variant: props.variant, children: props.children ?? props.defaultLabel });
+}
+
+// src/react/components/wizard-back.tsx
+var import_jsx_runtime3 = require("react/jsx-runtime");
+function WizardBack(props) {
+  const wizard = useWizard();
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+    WizardActionButton,
+    {
+      asChild: props.asChild,
+      className: props.className,
+      defaultLabel: "Back",
+      onClick: () => void wizard.back(),
+      variant: "ghost",
+      children: props.children
+    }
+  );
+}
+
+// src/react/components/wizard-category.tsx
+var import_jsx_runtime4 = require("react/jsx-runtime");
+function WizardCategory(props) {
+  const wizard = useWizard();
+  if (wizard.tree.activeCategory.id !== props.categoryId) return null;
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_jsx_runtime4.Fragment, { children: props.children });
+}
+
+// src/utils/cn.ts
+var import_clsx = require("clsx");
+var import_tailwind_merge = require("tailwind-merge");
+function cn(...inputs) {
+  return (0, import_tailwind_merge.twMerge)((0, import_clsx.clsx)(...inputs));
+}
+
+// src/react/components/wizard-stepper-dot.tsx
+var import_lucide_react = require("lucide-react");
+var import_jsx_runtime5 = require("react/jsx-runtime");
+function WizardStepperDot(props) {
+  const { clickable = false, isLast = false, label, onClick, progress, state } = props;
+  const isInteractive = clickable && !!onClick;
+  return /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)("li", { className: "relative flex flex-1 items-center", "data-state": state, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
+      "button",
+      {
+        "aria-current": state === "active" ? "step" : void 0,
+        "aria-label": label ?? state,
+        className: cn(
+          "relative flex size-3 shrink-0 items-center justify-center rounded-full border-2 transition-colors",
+          state === "pending" && "border-border bg-background",
+          state === "active" && "border-success-text bg-success-text ring-2 ring-success-border/40 ring-offset-2 ring-offset-background",
+          state === "completed" && "border-success-border bg-success-text",
+          state === "skipped" && "border-border bg-background opacity-60",
+          isInteractive && "cursor-pointer hover:bg-success-bg",
+          !isInteractive && "cursor-default"
+        ),
+        disabled: !isInteractive,
+        onClick: isInteractive ? onClick : void 0,
+        type: "button",
+        children: state === "completed" && /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_lucide_react.CheckIcon, { className: "size-2 text-background" })
+      }
+    ),
+    !isLast && /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("span", { "aria-hidden": true, className: "relative ml-1 mr-1 h-px flex-1 bg-border", children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
+      "span",
+      {
+        className: "absolute inset-y-0 left-0 bg-success-border transition-[width]",
+        style: { width: `${Math.max(0, Math.min(100, progress))}%` }
+      }
+    ) }),
+    label && /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
+      "span",
+      {
+        className: cn(
+          "absolute -top-6 left-0 -translate-x-[calc(50%-0.375rem)] text-sm font-semibold whitespace-nowrap",
+          state === "active" && "text-success-text",
+          state !== "active" && "text-muted-foreground"
+        ),
+        children: label
+      }
+    )
+  ] });
+}
+
+// src/react/components/wizard-stepper.tsx
+var import_jsx_runtime6 = require("react/jsx-runtime");
+function WizardStepper(props) {
+  const { canAccessCategory, categories, doneDot, headerI18n, onCategoryClick, progress } = props;
+  const lastIdx = categories.length - 1;
+  return /* @__PURE__ */ (0, import_jsx_runtime6.jsxs)("ol", { "aria-label": "Wizard progress", className: "relative flex flex-1 items-center pt-6", children: [
+    categories.map((category, idx) => {
+      const isLast = idx === lastIdx && !doneDot;
+      const clickable = canAccessCategory?.(category) ?? false;
+      return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(
+        WizardStepperDot,
+        {
+          clickable,
+          isLast,
+          label: headerI18n?.[category.id],
+          onClick: onCategoryClick ? () => onCategoryClick(category) : void 0,
+          progress: progress[category.id] ?? 0,
+          state: getDotState(category, progress[category.id] ?? 0)
+        },
+        category.id
+      );
+    }),
+    doneDot && /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(WizardStepperDot, { isLast: true, label: doneDot.text, progress: 0, state: "pending" })
+  ] });
+}
+function getDotState(category, progress) {
+  if (category.isActive) return "active";
+  if (progress >= 100) return "completed";
+  if (category.isSkipped) return "skipped";
+  return "pending";
+}
+
+// src/react/components/wizard-header.tsx
+var import_jsx_runtime7 = require("react/jsx-runtime");
+function WizardHeader() {
+  const wizard = useWizard();
+  const tree = wizard.tree;
+  const config = wizard.configOptions;
+  if (!config.isShowWizardHeader) return null;
+  const oneCategory = tree.activeBranch.shownCategories.length === 1 && !config.isDoneDot;
+  const stepHeaderEnabled = true;
+  const showSteps = config.isShowWizardHeaderSteps && stepHeaderEnabled && !oneCategory;
+  const canAccessCategory = (category) => {
+    if (config.isBackResetCompleted) return false;
+    if (category.isCompleted) return true;
+    const idx = tree.activeBranch.shownCategories.indexOf(category);
+    return !!tree.activeBranch.shownCategories[idx - 1]?.isCompleted;
+  };
+  const onCategoryClick = (category) => {
+    if (config.isBackResetCompleted) return;
+    const isCategoryStart = category.activeSteps.length === 1;
+    if (config.isActiveCategoryClickReset && category.isActive && !isCategoryStart) {
+      void wizard.resetCategory(category.id);
+      return;
+    }
+    if (!category.isActive && category.isCompleted) {
+      void wizard.goToCategory(category.id);
+      return;
+    }
+    if (!category.isActive && canAccessCategory(category)) {
+      void wizard.goToCategory(category.id);
+    }
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)(
+    "header",
+    {
+      className: cn(
+        "relative mb-8 flex items-center gap-4 border-b border-border bg-background px-4 py-3",
+        config.stickyHeader && "sticky top-0 z-10"
+      ),
+      children: [
+        /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(WizardBack, {}),
+        showSteps && /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(
+          WizardStepper,
+          {
+            canAccessCategory,
+            categories: tree.activeBranch.shownCategories,
+            doneDot: config.isDoneDot ? { text: config.doneDotText } : void 0,
+            headerI18n: config.headerI18n,
+            onCategoryClick,
+            progress: wizard.progress
+          }
+        )
+      ]
+    }
+  );
+}
+
+// src/react/components/wizard-next.tsx
+var import_jsx_runtime8 = require("react/jsx-runtime");
+function WizardNext(props) {
+  const wizard = useWizard();
+  const defaultLabel = !props.asChild && props.children === void 0 ? getNextLabel(wizard) : "";
+  return /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(
+    WizardActionButton,
+    {
+      asChild: props.asChild,
+      className: props.className,
+      defaultLabel,
+      onClick: () => void wizard.next(),
+      children: props.children
+    }
+  );
+}
+function getNextLabel(wizard) {
+  const config = wizard.configOptions;
+  const tree = wizard.tree;
+  const activeStep = tree.lastActiveStep;
+  const category = tree.categoryMap[activeStep.categoryId];
+  const isLastStep = category.lastStep.id === activeStep.id;
+  const isLastCategory = tree.activeBranch.lastCategory.id === category.id;
+  if (!isLastStep) return config.nextBtnText;
+  return isLastCategory ? config.finishText : config.nextCategoryText;
+}
+
+// src/react/components/wizard-rail.tsx
+var import_lucide_react2 = require("lucide-react");
+
+// src/react/hooks/use-wizard-categories-view.ts
+var EMPTY_SUB_STEPS = [];
+function useWizardCategoriesView() {
+  const wizard = useWizard();
+  return wizard.tree.activeBranch.shownCategories.map((category) => projectCategory(category));
+}
+function getCategoryState(category) {
+  if (category.isActive) return "active";
+  if (category.isCompleted) return "completed";
+  if (category.isSkipped) return "skipped";
+  return "pending";
+}
+function projectCategory(category) {
+  const shown = category.shownSteps;
+  const subSteps = shown.length > 1 ? shown.slice().sort((a, b) => a.htmlIndex - b.htmlIndex).map((step) => ({ id: step.id, isActive: step.isActive })) : EMPTY_SUB_STEPS;
+  return {
+    id: category.id,
+    isActive: category.isActive,
+    state: getCategoryState(category),
+    subSteps
+  };
+}
+
+// src/react/components/wizard-rail.tsx
+var import_jsx_runtime9 = require("react/jsx-runtime");
+function WizardRail(props) {
+  const { canAccessCategory, className, headerI18n, subStepLabels } = props;
+  const wizard = useWizard();
+  const view = useWizardCategoriesView();
+  const labels = headerI18n ?? wizard.configOptions.headerI18n;
+  const isClickable = (category) => canAccessCategory?.(category) ?? defaultClickable(category.state);
+  return /* @__PURE__ */ (0, import_jsx_runtime9.jsx)("nav", { "aria-label": "Wizard steps", className: cn("flex flex-col gap-1", className), children: /* @__PURE__ */ (0, import_jsx_runtime9.jsx)("ol", { className: "relative flex flex-col gap-1", children: view.map((category, idx) => {
+    const label = labels?.[category.id] ?? String(category.id);
+    const clickable = isClickable(category);
+    const isLast = idx === view.length - 1;
+    const isPassed = category.state === "completed" || category.state === "skipped";
+    return /* @__PURE__ */ (0, import_jsx_runtime9.jsxs)("li", { className: "relative", children: [
+      !isLast && /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(
+        "span",
+        {
+          "aria-hidden": true,
+          className: cn(
+            "pointer-events-none absolute top-7 -bottom-2 left-5 w-px -translate-x-1/2 transition-colors duration-200",
+            isPassed ? "bg-success-border" : "bg-border"
+          )
+        }
+      ),
+      /* @__PURE__ */ (0, import_jsx_runtime9.jsxs)(
+        "button",
+        {
+          "aria-current": category.isActive ? "step" : void 0,
+          className: cn(
+            "group flex w-full items-center gap-3 rounded-md px-3 py-2 text-left text-sm font-medium transition-[color,background-color,transform] duration-200 ease-(--ease-out-strong)",
+            category.state === "active" && "bg-success-bg/60 text-success-text",
+            category.state === "completed" && "text-foreground",
+            category.state === "skipped" && "text-muted-foreground opacity-70",
+            category.state === "pending" && "text-muted-foreground",
+            clickable ? "cursor-pointer hover:bg-foreground/[0.06] motion-safe:active:scale-[0.97]" : "cursor-default"
+          ),
+          "data-state": category.state,
+          disabled: !clickable,
+          onClick: () => {
+            void wizard.goToCategory(category.id);
+          },
+          type: "button",
+          children: [
+            /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(RailDot, { state: category.state }),
+            /* @__PURE__ */ (0, import_jsx_runtime9.jsx)("span", { children: label })
+          ]
+        }
+      ),
+      category.isActive && category.subSteps.length > 0 && /* @__PURE__ */ (0, import_jsx_runtime9.jsx)("ol", { className: "mt-1 ml-7 flex flex-col gap-1 border-l border-border pl-3", children: category.subSteps.map((step) => /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(
+        "li",
+        {
+          "aria-current": step.isActive ? "step" : void 0,
+          className: cn(
+            "rounded px-2 py-1 text-sm",
+            step.isActive ? "text-success-text font-medium" : "text-muted-foreground"
+          ),
+          children: subStepLabels?.[step.id] ?? String(step.id)
+        },
+        step.id
+      )) })
+    ] }, category.id);
+  }) }) });
+}
+function defaultClickable(state) {
+  return state !== "pending";
+}
+function RailDot({ state }) {
+  return /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(
+    "span",
+    {
+      "aria-hidden": true,
+      className: cn(
+        "flex size-4 shrink-0 items-center justify-center rounded-full border-2 transition-colors",
+        state === "pending" && "border-border bg-background",
+        state === "active" && "border-success-border bg-success-bg",
+        state === "completed" && "border-success-border bg-success-text",
+        state === "skipped" && "border-border bg-background opacity-60"
+      ),
+      children: state === "completed" && /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(import_lucide_react2.CheckIcon, { className: "size-2.5 text-background motion-safe:animate-in motion-safe:fade-in motion-safe:zoom-in-75 motion-safe:duration-200" })
+    }
+  );
+}
+
+// src/react/components/wizard-step.tsx
+var import_react4 = require("react");
+var import_jsx_runtime10 = require("react/jsx-runtime");
+function WizardStep(props) {
+  const engine = (0, import_react4.useContext)(WizardEngineContext);
+  if (!engine) {
+    throw new WizardError("WizardStep must be used inside <WizardProvider>");
+  }
+  const getSnapshot = (0, import_react4.useCallback)(() => engine.isStepVisible(props.id), [engine, props.id]);
+  const isVisible = (0, import_react4.useSyncExternalStore)(engine.subscribe, getSnapshot, getSnapshot);
+  if (!isVisible) return null;
+  return /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(
+    "div",
+    {
+      className: "motion-safe:animate-in motion-safe:fade-in motion-safe:slide-in-from-bottom-1 motion-safe:duration-300 motion-safe:ease-(--ease-out-strong)",
+      id: props.id,
+      children: props.children
+    }
+  );
+}
+
+// src/react/provider.tsx
+var import_react5 = require("react");
+var import_jsx_runtime11 = require("react/jsx-runtime");
+function WizardProvider(props) {
+  const { activeBranch, children, config, initializers, listeners, scrollContainer, state, strategies } = props;
+  const [bootOptions] = (0, import_react5.useState)(() => ({
+    activeBranch,
+    config,
+    initializers,
+    listeners,
+    scrollContainer,
+    state,
+    strategies
+  }));
+  const [engine, setEngine] = (0, import_react5.useState)(null);
+  (0, import_react5.useEffect)(() => {
+    const newEngine = new WizardEngine(bootOptions);
+    let cancelled = false;
+    newEngine.commitRegistration().then(() => {
+      if (!cancelled) setEngine(newEngine);
+    });
+    return () => {
+      cancelled = true;
+      newEngine.dispose();
+      setEngine((prev) => prev === newEngine ? null : prev);
+    };
+  }, [bootOptions]);
+  if (!engine) {
+    return null;
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(WizardEngineContext.Provider, { value: engine, children });
+}
+
+// src/react/use-wizard-engine-ref.ts
+var import_react6 = require("react");
+function useWizardEngineRef() {
+  return (0, import_react6.useRef)(null);
+}
+function WizardEngineRefCapture({
+  engineRef
+}) {
+  const wizard = useWizard();
+  (0, import_react6.useEffect)(() => {
+    engineRef.current = wizard;
+    return () => {
+      engineRef.current = null;
+    };
+  }, [engineRef, wizard]);
+  return null;
+}
+
+// src/react/use-wizard-event.ts
+var import_react7 = require("react");
+function useWizardEvent(type, handler) {
+  const engine = (0, import_react7.useContext)(WizardEngineContext);
+  if (!engine) {
+    throw new WizardError("useWizardEvent must be used inside <WizardProvider>");
+  }
+  const handlerRef = (0, import_react7.useRef)(handler);
+  (0, import_react7.useEffect)(() => {
+    handlerRef.current = handler;
+  });
+  (0, import_react7.useEffect)(() => {
+    return engine.on(type, (event) => handlerRef.current(event));
+  }, [engine, type]);
+}
+
+// src/react/use-wizard-step.ts
+var import_react8 = require("react");
+function useWizardStep(stepId) {
+  const engine = (0, import_react8.useContext)(WizardEngineContext);
+  if (!engine) {
+    throw new WizardError("useWizardStep must be used inside <WizardProvider>");
+  }
+  const lastRef = (0, import_react8.useRef)(null);
+  const getSnapshot = (0, import_react8.useCallback)(() => {
+    const tree = engine.getTreeSnapshot();
+    const next = tree.stepMap[stepId] ?? null;
+    const prev = lastRef.current;
+    if (prev !== null && next !== null && prev.isActive === next.isActive && prev.isShow === next.isShow && prev.isCompleted === next.isCompleted && prev.isSkipped === next.isSkipped) {
+      return prev;
+    }
+    lastRef.current = next;
+    return next;
+  }, [engine, stepId]);
+  return (0, import_react8.useSyncExternalStore)(engine.subscribe, getSnapshot, getSnapshot);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TypedEmitter,
+  WizardActiveProgressStrategy,
+  WizardActiveStepRule,
+  WizardBack,
+  WizardCategory,
+  WizardCategoryDirection,
+  WizardCompleteEvent,
+  WizardCompleteTreeState,
+  WizardComponentsProvider,
+  WizardConfig,
+  WizardDefaultInitializer,
+  WizardDefaultVisibilityStrategy,
+  WizardEngine,
+  WizardEngineContext,
+  WizardEngineRefCapture,
+  WizardError,
+  WizardEvent,
+  WizardEventType,
+  WizardExitEvent,
+  WizardExitTreeState,
+  WizardHeader,
+  WizardInitializationError,
+  WizardInitializer,
+  WizardInitializerService,
+  WizardLastActiveVisibilityStrategy,
+  WizardListener,
+  WizardLog,
+  WizardNavigation,
+  WizardNavigationCancelledEvent,
+  WizardNavigationEndEvent,
+  WizardNavigationError,
+  WizardNavigationErrorEvent,
+  WizardNavigationIgnoredEvent,
+  WizardNavigationService,
+  WizardNavigationStartEvent,
+  WizardNext,
+  WizardPassedPrevCategoriesRule,
+  WizardPassedPrevStepsRule,
+  WizardProgressStrategy,
+  WizardProvider,
+  WizardRail,
+  WizardResolveEndEvent,
+  WizardResolveStartEvent,
+  WizardResolverError,
+  WizardRule,
+  WizardScrollEndEvent,
+  WizardScrollStartEvent,
+  WizardScrollStrategy,
+  WizardShownActiveCategoryRule,
+  WizardSingleActiveCategoryRule,
+  WizardSmoothScrollStrategy,
+  WizardStateService,
+  WizardStep,
+  WizardStepHideEvent,
+  WizardStepShowEvent,
+  WizardStepper,
+  WizardStepperDot,
+  WizardStore,
+  WizardTreeStateBuilder,
+  WizardVisibilityStrategy,
+  buildWizardBranchState,
+  buildWizardCategoryState,
+  buildWizardTreeState,
+  composeWizardProviders,
+  scrollToStep,
+  useWizard,
+  useWizardCategoriesView,
+  useWizardComponents,
+  useWizardEngineRef,
+  useWizardEvent,
+  useWizardStep,
+  withConfig,
+  withInitializer,
+  withListener,
+  withProgressStrategy,
+  withScrollContainer,
+  withScrollStrategy,
+  withVisibilityStrategy,
+  wizardDefaultBranch,
+  wizardDefaultConfig,
+  wizardDefaultState,
+  wizardRules
+});
+//# sourceMappingURL=index.cjs.map