@accelint/design-toolkit 9.13.0 → 10.1.0

package/dist/components/stepper/types.d.ts

@@ -0,0 +1,205 @@
+/*
+ * Copyright 2026 Hypergiant Galactic Systems Inc. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+import { ButtonProps } from "../button/types.js";
+import { PropsWithChildren, ReactNode, RefAttributes } from "react";
+import { Key } from "@react-types/shared";
+
+//#region src/components/stepper/types.d.ts
+/**
+ * Orientation of the stepper layout.
+ */
+type Orientation = 'horizontal' | 'vertical';
+/**
+ * Props for the root Stepper component.
+ *
+ * Supports controlled and uncontrolled navigation, completed-step tracking,
+ * disabled-step constraints, and horizontal or vertical layouts.
+ */
+type StepperProps = PropsWithChildren<RefAttributes<HTMLDivElement> & {
+  /**
+   * CSS class for the stepper container.
+   */
+  className?: string;
+  /**
+   * Controlled current step key.
+   */
+  currentStep?: Key;
+  /**
+   * Default step key for uncontrolled mode.
+   */
+  defaultStep?: Key;
+  /**
+   * Callback invoked when the current step changes.
+   */
+  onStepChange?: (key: Key) => void;
+  /**
+   * Validation callback invoked before step change.
+   * Return false to block navigation.
+   *
+   * @param fromKey - The current step key
+   * @param toKey - The target step key
+   * @returns true to allow navigation, false to block
+   */
+  onBeforeStepChange?: (fromKey: Key, toKey: Key) => boolean;
+  /**
+   * Layout orientation of the stepper.
+   *
+   * @default 'horizontal'
+   */
+  orientation?: Orientation;
+  /**
+   * Controlled set of completed step keys.
+   */
+  completedSteps?: Set<Key>;
+  /**
+   * Default set of completed step keys for uncontrolled mode.
+   */
+  defaultCompletedSteps?: Set<Key>;
+  /**
+   * Set of disabled step keys that block navigation.
+   */
+  disabledKeys?: Set<Key>;
+}>;
+/**
+ * Render state describing the current stepper status.
+ */
+type StepperRenderState = {
+  /**
+   * Current step key.
+   */
+  currentStep: Key | undefined;
+  /**
+   * Orientation of the stepper.
+   */
+  orientation: Orientation;
+  /**
+   * Whether the current step is the first step.
+   */
+  isFirstStep: boolean;
+  /**
+   * Whether the current step is the last step.
+   */
+  isLastStep: boolean;
+};
+/**
+ * Props for the StepperList component.
+ *
+ * Applied to the navigation container that owns keyboard step navigation.
+ */
+type StepperListProps = PropsWithChildren<RefAttributes<HTMLDivElement> & {
+  /**
+   * CSS class for the list container.
+   */
+  className?: string;
+}>;
+/**
+ * Render state describing the current StepperList navigation status.
+ */
+type StepperListRenderState = {
+  /**
+   * Current step key.
+   */
+  currentStep: Key | undefined;
+  /**
+   * Orientation of the stepper.
+   */
+  orientation: Orientation;
+};
+/**
+ * Render state describing an individual step button.
+ */
+type StepperStepRenderState = {
+  /**
+   * Whether this step is the current active step.
+   */
+  isCurrent: boolean;
+  /**
+   * Whether this step has been completed.
+   */
+  isCompleted: boolean;
+  /**
+   * Whether this step is disabled.
+   */
+  isDisabled: boolean;
+  /**
+   * The numeric position of this step (1-indexed).
+   */
+  stepNumber: number;
+  /**
+   * Total number of steps.
+   */
+  totalSteps: number;
+};
+/**
+ * Props for the StepperStep component.
+ *
+ * Each step must provide an `id` that matches the corresponding
+ * {@link StepperPanelProps.id} so the step button and panel stay in sync.
+ */
+type StepperStepProps = PropsWithChildren<RefAttributes<HTMLButtonElement> & {
+  /**
+   * Unique identifier for the step. Must match corresponding StepperPanel id.
+   */
+  id: Key;
+  /**
+   * CSS class for the step button.
+   */
+  className?: string;
+  /**
+   * Whether this step is disabled and blocks navigation.
+   */
+  isDisabled?: boolean;
+}>;
+/**
+ * Props for the StepperPanel component.
+ *
+ * The panel renders only when its `id` matches the current step.
+ */
+type StepperPanelProps = RefAttributes<HTMLDivElement> & {
+  /**
+   * Unique identifier for the panel. Must match corresponding StepperStep id.
+   */
+  id: Key;
+  /**
+   * Child content to display when this panel is active.
+   */
+  children?: ReactNode;
+  /**
+   * CSS class for the panel container.
+   */
+  className?: string;
+};
+/**
+ * Render state describing whether a panel is currently active.
+ */
+type StepperPanelRenderState = {
+  /**
+   * Whether this panel is currently active.
+   */
+  isCurrent: boolean;
+};
+/**
+ * Props for the StepperBack component.
+ *
+ * Inherits all button props and adds no stepper-specific fields.
+ */
+type StepperBackProps = ButtonProps;
+/**
+ * Props for the StepperNext component.
+ *
+ * Inherits all button props and adds no stepper-specific fields.
+ */
+type StepperNextProps = ButtonProps;
+//#endregion
+export { Orientation, StepperBackProps, StepperListProps, StepperListRenderState, StepperNextProps, StepperPanelProps, StepperPanelRenderState, StepperProps, StepperRenderState, StepperStepProps, StepperStepRenderState };
+//# sourceMappingURL=types.d.ts.map

package/dist/components/stepper/types.js

@@ -0,0 +1,12 @@
+/*
+ * Copyright 2026 Hypergiant Galactic Systems Inc. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+

package/dist/components/stepper/use-stepper-state.d.ts

@@ -0,0 +1,175 @@
+/*
+ * Copyright 2026 Hypergiant Galactic Systems Inc. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+import { Orientation as Orientation$1 } from "./types.js";
+import { Key } from "@react-types/shared";
+
+//#region src/components/stepper/use-stepper-state.d.ts
+/**
+ * Configuration options for {@link useStepperState}.
+ *
+ * Supports controlled and uncontrolled current-step state, completed-step
+ * tracking, disabled-step constraints, and orientation metadata consumed by
+ * stepper UI components.
+ */
+type UseStepperStateProps = {
+  /**
+   * Controlled current step key.
+   */
+  currentStep?: Key;
+  /**
+   * Default step key for uncontrolled mode.
+   */
+  defaultStep?: Key;
+  /**
+   * Callback invoked when the current step changes.
+   */
+  onStepChange?: (key: Key) => void;
+  /**
+   * Validation callback invoked before step change.
+   * Return false to block navigation.
+   */
+  onBeforeStepChange?: (fromKey: Key, toKey: Key) => boolean;
+  /**
+   * Controlled set of completed step keys.
+   */
+  completedSteps?: Set<Key>;
+  /**
+   * Default set of completed step keys for uncontrolled mode.
+   */
+  defaultCompletedSteps?: Set<Key>;
+  /**
+   * Set of disabled step keys that block navigation.
+   */
+  disabledKeys?: Set<Key>;
+  /**
+   * Layout orientation of the stepper.
+   */
+  orientation?: Orientation$1;
+};
+/**
+ * State and navigation helpers returned by {@link useStepperState}.
+ *
+ * This shape is shared through {@link StepperContext} and consumed by the
+ * stepper component family.
+ */
+type StepperState = {
+  /**
+   * Current active step key.
+   * `undefined` when no steps have been registered yet or no default/controlled value provided.
+   */
+  currentStep: Key | undefined;
+  /**
+   * Set of completed step keys.
+   */
+  completedSteps: Set<Key>;
+  /**
+   * Set of disabled step keys.
+   */
+  disabledKeys: Set<Key>;
+  /**
+   * Orientation of the stepper.
+   */
+  orientation: Orientation$1;
+  /**
+   * Array of registered step keys in order.
+   */
+  steps: Key[];
+  /**
+   * Registers a step key in navigation order.
+   * Duplicate registrations are ignored.
+   */
+  register: (key: Key) => void;
+  /**
+   * Removes a step key from the registered navigation order.
+   * Missing keys are ignored.
+   */
+  unregister: (key: Key) => void;
+  /**
+   * Attempts to navigate to the provided step key.
+   * Does nothing when the target step is disabled, unregistered, or blocked by validation.
+   */
+  goToStep: (key: Key) => void;
+  /**
+   * Navigate to the next step.
+   */
+  next: () => void;
+  /**
+   * Navigate to the previous step.
+   */
+  previous: () => void;
+  /**
+   * Check if a step is disabled.
+   */
+  isDisabled: (key: Key) => boolean;
+  /**
+   * Whether current step is the first step.
+   */
+  isFirstStep: boolean;
+  /**
+   * Whether the current step is the last step.
+   */
+  isLastStep: boolean;
+  /**
+   * Get the index of a step in the registered steps array.
+   */
+  getStepIndex: (key: Key) => number;
+};
+/**
+ * Manages state for the stepper component family.
+ *
+ * Tracks registered steps, resolves controlled versus uncontrolled state,
+ * updates completed-step bookkeeping, and exposes navigation helpers used by
+ * the stepper UI components.
+ *
+ * @param props - The stepper state configuration.
+ * @param props.currentStep - Controlled active step key.
+ * @param props.defaultStep - Initial active step key for uncontrolled usage.
+ * @param props.onStepChange - Called after navigation changes the active step.
+ * @param props.onBeforeStepChange - Called before navigation; return `false` to block it.
+ * @param props.completedSteps - Controlled set of completed step keys.
+ * @param props.defaultCompletedSteps - Initial completed step keys for uncontrolled usage.
+ * @param props.disabledKeys - Step keys that cannot be navigated to.
+ * @param props.orientation - Layout orientation metadata for the consuming UI.
+ * @returns State and navigation helpers for the registered step sequence.
+ *
+ * @remarks
+ * Steps register on mount and unregister on unmount. Moving forward marks the
+ * previous step as completed, while moving backward clears completed state from
+ * the destination step onward in uncontrolled mode.
+ *
+ * @example
+ * ```tsx
+ * const state = useStepperState({
+ *   defaultStep: 'account',
+ *   orientation: 'horizontal',
+ * });
+ * ```
+ *
+ * @example
+ * ```tsx
+ * const [currentStep, setCurrentStep] = useState<Key>('account');
+ *
+ * const state = useStepperState({
+ *   currentStep,
+ *   onStepChange: setCurrentStep,
+ *   onBeforeStepChange: (fromKey, toKey) => {
+ *     return validateStep(fromKey, toKey);
+ *   },
+ *   disabledKeys: new Set<Key>(['review']),
+ * });
+ * ```
+ */
+declare function useStepperState(props?: UseStepperStateProps): StepperState;
+//#endregion
+export { StepperState, UseStepperStateProps, useStepperState };
+//# sourceMappingURL=use-stepper-state.d.ts.map

package/dist/components/stepper/use-stepper-state.js

@@ -0,0 +1,225 @@
+/*
+ * Copyright 2026 Hypergiant Galactic Systems Inc. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+
+import { useCallback, useMemo, useRef, useState } from "react";
+import { useControlledState } from "react-stately/useControlledState";
+
+//#region src/components/stepper/use-stepper-state.ts
+/**
+* Empty Set constant for stable default reference.
+*/
+const EMPTY_SET = /* @__PURE__ */ new Set();
+/**
+* Manages state for the stepper component family.
+*
+* Tracks registered steps, resolves controlled versus uncontrolled state,
+* updates completed-step bookkeeping, and exposes navigation helpers used by
+* the stepper UI components.
+*
+* @param props - The stepper state configuration.
+* @param props.currentStep - Controlled active step key.
+* @param props.defaultStep - Initial active step key for uncontrolled usage.
+* @param props.onStepChange - Called after navigation changes the active step.
+* @param props.onBeforeStepChange - Called before navigation; return `false` to block it.
+* @param props.completedSteps - Controlled set of completed step keys.
+* @param props.defaultCompletedSteps - Initial completed step keys for uncontrolled usage.
+* @param props.disabledKeys - Step keys that cannot be navigated to.
+* @param props.orientation - Layout orientation metadata for the consuming UI.
+* @returns State and navigation helpers for the registered step sequence.
+*
+* @remarks
+* Steps register on mount and unregister on unmount. Moving forward marks the
+* previous step as completed, while moving backward clears completed state from
+* the destination step onward in uncontrolled mode.
+*
+* @example
+* ```tsx
+* const state = useStepperState({
+*   defaultStep: 'account',
+*   orientation: 'horizontal',
+* });
+* ```
+*
+* @example
+* ```tsx
+* const [currentStep, setCurrentStep] = useState<Key>('account');
+*
+* const state = useStepperState({
+*   currentStep,
+*   onStepChange: setCurrentStep,
+*   onBeforeStepChange: (fromKey, toKey) => {
+*     return validateStep(fromKey, toKey);
+*   },
+*   disabledKeys: new Set<Key>(['review']),
+* });
+* ```
+*/
+function useStepperState(props = {}) {
+	const { currentStep: currentStepProp, defaultStep, onStepChange, onBeforeStepChange, completedSteps: completedStepsProp, defaultCompletedSteps, disabledKeys = EMPTY_SET, orientation = "horizontal" } = props;
+	const [currentStep, setCurrentStep] = useControlledState(currentStepProp, defaultStep ?? void 0, onStepChange);
+	const [completedSteps, setCompletedSteps] = useControlledState(completedStepsProp, defaultCompletedSteps ?? EMPTY_SET);
+	const [steps, setSteps] = useState([]);
+	const stepsRegistry = useRef(/* @__PURE__ */ new Set());
+	const orderedSteps = useRef([]);
+	/**
+	* Register a step.
+	*/
+	const register = useCallback((key) => {
+		if (stepsRegistry.current.has(key)) return;
+		stepsRegistry.current.add(key);
+		orderedSteps.current.push(key);
+		setSteps(orderedSteps.current.slice());
+	}, []);
+	/**
+	* Unregister a step.
+	*/
+	const unregister = useCallback((key) => {
+		if (!stepsRegistry.current.has(key)) return;
+		stepsRegistry.current.delete(key);
+		const keyIndex = orderedSteps.current.indexOf(key);
+		if (keyIndex === -1) return;
+		orderedSteps.current.splice(keyIndex, 1);
+		setSteps(orderedSteps.current.slice());
+	}, []);
+	/**
+	* Memoized step-key lookup table used to avoid repeated linear scans of `steps`
+	* during navigation and derived state checks.
+	*/
+	const stepIndexByKey = useMemo(() => {
+		const nextStepIndexByKey = /* @__PURE__ */ new Map();
+		for (let index = 0; index < steps.length; index++) {
+			const step = steps[index];
+			if (step !== void 0) nextStepIndexByKey.set(step, index);
+		}
+		return nextStepIndexByKey;
+	}, [steps]);
+	const getStepIndex = useCallback((key) => {
+		return stepIndexByKey.get(key) ?? -1;
+	}, [stepIndexByKey]);
+	/**
+	* Check if a step is disabled.
+	*/
+	const isDisabled = useCallback((key) => {
+		return disabledKeys.has(key);
+	}, [disabledKeys]);
+	const currentStepIndex = useMemo(() => {
+		if (currentStep === void 0) return -1;
+		return stepIndexByKey.get(currentStep) ?? -1;
+	}, [currentStep, stepIndexByKey]);
+	/**
+	* Check if the current step is the first step.
+	*/
+	const isFirstStep = currentStepIndex === 0;
+	/**
+	* Check if the current step is the last step.
+	*/
+	const isLastStep = currentStepIndex !== -1 && currentStepIndex === steps.length - 1;
+	/**
+	* Check if navigation to target step is blocked.
+	*/
+	const isNavigationBlocked = useCallback((targetKey) => {
+		if (isDisabled(targetKey)) return true;
+		if (!stepsRegistry.current.has(targetKey)) return true;
+		if (currentStep === targetKey) return true;
+		return false;
+	}, [isDisabled, currentStep]);
+	/**
+	* Run validation callback if provided.
+	*/
+	const runValidation = useCallback((fromKey, toKey) => {
+		if (!onBeforeStepChange || fromKey === void 0) return true;
+		return onBeforeStepChange(fromKey, toKey);
+	}, [onBeforeStepChange]);
+	/**
+	* Update completed steps based on navigation direction.
+	* Moving forward: mark the step we're leaving as completed.
+	* Moving backward: remove completed state from all steps at or after the destination.
+	*/
+	const updateCompletedSteps = useCallback((fromKey, toKey) => {
+		if (fromKey === void 0) return;
+		const fromIndex = getStepIndex(fromKey);
+		const toIndex = getStepIndex(toKey);
+		const isForward = toIndex > fromIndex;
+		setCompletedSteps((previousCompletedSteps) => {
+			const nextCompletedSteps = new Set(previousCompletedSteps);
+			if (isForward) {
+				nextCompletedSteps.add(fromKey);
+				nextCompletedSteps.delete(toKey);
+				return nextCompletedSteps;
+			}
+			for (let index = toIndex; index < steps.length; index++) {
+				const step = steps[index];
+				if (step !== void 0) nextCompletedSteps.delete(step);
+			}
+			return nextCompletedSteps;
+		});
+	}, [
+		setCompletedSteps,
+		getStepIndex,
+		steps
+	]);
+	/**
+	* Navigate to a specific step.
+	* Respects disabled keys and validation callbacks.
+	*/
+	const goToStep = useCallback((targetKey) => {
+		if (isNavigationBlocked(targetKey)) return;
+		if (!runValidation(currentStep, targetKey)) return;
+		updateCompletedSteps(currentStep, targetKey);
+		setCurrentStep(targetKey);
+	}, [
+		currentStep,
+		isNavigationBlocked,
+		runValidation,
+		updateCompletedSteps,
+		setCurrentStep
+	]);
+	return {
+		currentStep,
+		completedSteps,
+		disabledKeys,
+		orientation,
+		steps,
+		register,
+		unregister,
+		goToStep,
+		next: useCallback(() => {
+			if (currentStepIndex === -1 || currentStepIndex >= steps.length - 1) return;
+			const nextKey = steps[currentStepIndex + 1];
+			if (nextKey === void 0) return;
+			goToStep(nextKey);
+		}, [
+			currentStepIndex,
+			steps,
+			goToStep
+		]),
+		previous: useCallback(() => {
+			if (currentStepIndex <= 0) return;
+			const previousKey = steps[currentStepIndex - 1];
+			if (previousKey === void 0) return;
+			goToStep(previousKey);
+		}, [
+			currentStepIndex,
+			steps,
+			goToStep
+		]),
+		isDisabled,
+		isFirstStep,
+		isLastStep,
+		getStepIndex
+	};
+}
+
+//#endregion
+export { useStepperState };
+//# sourceMappingURL=use-stepper-state.js.map

package/dist/components/stepper/use-stepper-state.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-stepper-state.js","names":[],"sources":["../../../src/components/stepper/use-stepper-state.ts"],"sourcesContent":["/*\n * Copyright 2026 Hypergiant Galactic Systems Inc. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */\n\nimport { useCallback, useMemo, useRef, useState } from 'react';\nimport { useControlledState } from 'react-stately/useControlledState';\nimport type { Key } from '@react-types/shared';\nimport type { Orientation } from './types';\n\n/**\n * Empty Set constant for stable default reference.\n */\nconst EMPTY_SET = new Set<Key>();\n\n/**\n * Configuration options for {@link useStepperState}.\n *\n * Supports controlled and uncontrolled current-step state, completed-step\n * tracking, disabled-step constraints, and orientation metadata consumed by\n * stepper UI components.\n */\nexport type UseStepperStateProps = {\n  /**\n   * Controlled current step key.\n   */\n  currentStep?: Key;\n\n  /**\n   * Default step key for uncontrolled mode.\n   */\n  defaultStep?: Key;\n\n  /**\n   * Callback invoked when the current step changes.\n   */\n  onStepChange?: (key: Key) => void;\n\n  /**\n   * Validation callback invoked before step change.\n   * Return false to block navigation.\n   */\n  onBeforeStepChange?: (fromKey: Key, toKey: Key) => boolean;\n\n  /**\n   * Controlled set of completed step keys.\n   */\n  completedSteps?: Set<Key>;\n\n  /**\n   * Default set of completed step keys for uncontrolled mode.\n   */\n  defaultCompletedSteps?: Set<Key>;\n\n  /**\n   * Set of disabled step keys that block navigation.\n   */\n  disabledKeys?: Set<Key>;\n\n  /**\n   * Layout orientation of the stepper.\n   */\n  orientation?: Orientation;\n};\n\n/**\n * State and navigation helpers returned by {@link useStepperState}.\n *\n * This shape is shared through {@link StepperContext} and consumed by the\n * stepper component family.\n */\nexport type StepperState = {\n  /**\n   * Current active step key.\n   * `undefined` when no steps have been registered yet or no default/controlled value provided.\n   */\n  currentStep: Key | undefined;\n\n  /**\n   * Set of completed step keys.\n   */\n  completedSteps: Set<Key>;\n\n  /**\n   * Set of disabled step keys.\n   */\n  disabledKeys: Set<Key>;\n\n  /**\n   * Orientation of the stepper.\n   */\n  orientation: Orientation;\n\n  /**\n   * Array of registered step keys in order.\n   */\n  steps: Key[];\n\n  /**\n   * Registers a step key in navigation order.\n   * Duplicate registrations are ignored.\n   */\n  register: (key: Key) => void;\n\n  /**\n   * Removes a step key from the registered navigation order.\n   * Missing keys are ignored.\n   */\n  unregister: (key: Key) => void;\n\n  /**\n   * Attempts to navigate to the provided step key.\n   * Does nothing when the target step is disabled, unregistered, or blocked by validation.\n   */\n  goToStep: (key: Key) => void;\n\n  /**\n   * Navigate to the next step.\n   */\n  next: () => void;\n\n  /**\n   * Navigate to the previous step.\n   */\n  previous: () => void;\n\n  /**\n   * Check if a step is disabled.\n   */\n  isDisabled: (key: Key) => boolean;\n\n  /**\n   * Whether current step is the first step.\n   */\n  isFirstStep: boolean;\n\n  /**\n   * Whether the current step is the last step.\n   */\n  isLastStep: boolean;\n\n  /**\n   * Get the index of a step in the registered steps array.\n   */\n  getStepIndex: (key: Key) => number;\n};\n\n/**\n * Manages state for the stepper component family.\n *\n * Tracks registered steps, resolves controlled versus uncontrolled state,\n * updates completed-step bookkeeping, and exposes navigation helpers used by\n * the stepper UI components.\n *\n * @param props - The stepper state configuration.\n * @param props.currentStep - Controlled active step key.\n * @param props.defaultStep - Initial active step key for uncontrolled usage.\n * @param props.onStepChange - Called after navigation changes the active step.\n * @param props.onBeforeStepChange - Called before navigation; return `false` to block it.\n * @param props.completedSteps - Controlled set of completed step keys.\n * @param props.defaultCompletedSteps - Initial completed step keys for uncontrolled usage.\n * @param props.disabledKeys - Step keys that cannot be navigated to.\n * @param props.orientation - Layout orientation metadata for the consuming UI.\n * @returns State and navigation helpers for the registered step sequence.\n *\n * @remarks\n * Steps register on mount and unregister on unmount. Moving forward marks the\n * previous step as completed, while moving backward clears completed state from\n * the destination step onward in uncontrolled mode.\n *\n * @example\n * ```tsx\n * const state = useStepperState({\n *   defaultStep: 'account',\n *   orientation: 'horizontal',\n * });\n * ```\n *\n * @example\n * ```tsx\n * const [currentStep, setCurrentStep] = useState<Key>('account');\n *\n * const state = useStepperState({\n *   currentStep,\n *   onStepChange: setCurrentStep,\n *   onBeforeStepChange: (fromKey, toKey) => {\n *     return validateStep(fromKey, toKey);\n *   },\n *   disabledKeys: new Set<Key>(['review']),\n * });\n * ```\n */\nexport function useStepperState(\n  props: UseStepperStateProps = {},\n): StepperState {\n  const {\n    currentStep: currentStepProp,\n    defaultStep,\n    onStepChange,\n    onBeforeStepChange,\n    completedSteps: completedStepsProp,\n    defaultCompletedSteps,\n    disabledKeys = EMPTY_SET,\n    orientation = 'horizontal',\n  } = props;\n\n  // Controlled/uncontrolled state for current step using react-stately.\n  // Pass undefined as the fallback to handle the case where no default is provided.\n  // Cast through unknown to satisfy TypeScript when defaultStep is undefined.\n  const [currentStep, setCurrentStep] = useControlledState(\n    currentStepProp,\n    defaultStep ?? (undefined as unknown as Key),\n    onStepChange,\n  );\n\n  // Controlled/uncontrolled state for completed steps using react-stately.\n  // This works with useControlledState because we always provide a default (empty Set).\n  const [completedSteps, setCompletedSteps] = useControlledState<Set<Key>>(\n    completedStepsProp,\n    defaultCompletedSteps ?? EMPTY_SET,\n  );\n\n  const [steps, setSteps] = useState<Key[]>([]);\n\n  // Registry of registered step keys for membership checks.\n  const stepsRegistry = useRef(new Set<Key>());\n\n  // Ordered registered step keys used to preserve navigation sequence\n  // and publish React state snapshots efficiently.\n  const orderedSteps = useRef<Key[]>([]);\n\n  /**\n   * Register a step.\n   */\n  const register = useCallback((key: Key): void => {\n    if (stepsRegistry.current.has(key)) {\n      return;\n    }\n\n    stepsRegistry.current.add(key);\n    orderedSteps.current.push(key);\n    setSteps(orderedSteps.current.slice());\n  }, []);\n\n  /**\n   * Unregister a step.\n   */\n  const unregister = useCallback((key: Key): void => {\n    if (!stepsRegistry.current.has(key)) {\n      return;\n    }\n\n    stepsRegistry.current.delete(key);\n\n    const keyIndex = orderedSteps.current.indexOf(key);\n    if (keyIndex === -1) {\n      return;\n    }\n\n    orderedSteps.current.splice(keyIndex, 1);\n    setSteps(orderedSteps.current.slice());\n  }, []);\n\n  /**\n   * Memoized step-key lookup table used to avoid repeated linear scans of `steps`\n   * during navigation and derived state checks.\n   */\n  const stepIndexByKey = useMemo((): Map<Key, number> => {\n    const nextStepIndexByKey = new Map<Key, number>();\n\n    for (let index = 0; index < steps.length; index++) {\n      const step = steps[index];\n      if (step !== undefined) {\n        nextStepIndexByKey.set(step, index);\n      }\n    }\n\n    return nextStepIndexByKey;\n  }, [steps]);\n\n  const getStepIndex = useCallback(\n    (key: Key): number => {\n      return stepIndexByKey.get(key) ?? -1;\n    },\n    [stepIndexByKey],\n  );\n\n  /**\n   * Check if a step is disabled.\n   */\n  const isDisabled = useCallback(\n    (key: Key): boolean => {\n      return disabledKeys.has(key);\n    },\n    [disabledKeys],\n  );\n\n  const currentStepIndex = useMemo((): number => {\n    if (currentStep === undefined) {\n      return -1;\n    }\n\n    return stepIndexByKey.get(currentStep) ?? -1;\n  }, [currentStep, stepIndexByKey]);\n\n  /**\n   * Check if the current step is the first step.\n   */\n  const isFirstStep = currentStepIndex === 0;\n\n  /**\n   * Check if the current step is the last step.\n   */\n  const isLastStep =\n    currentStepIndex !== -1 && currentStepIndex === steps.length - 1;\n\n  /**\n   * Check if navigation to target step is blocked.\n   */\n  const isNavigationBlocked = useCallback(\n    (targetKey: Key): boolean => {\n      if (isDisabled(targetKey)) {\n        return true;\n      }\n      if (!stepsRegistry.current.has(targetKey)) {\n        return true;\n      }\n      if (currentStep === targetKey) {\n        return true;\n      }\n      return false;\n    },\n    [isDisabled, currentStep],\n  );\n\n  /**\n   * Run validation callback if provided.\n   */\n  const runValidation = useCallback(\n    (fromKey: Key | undefined, toKey: Key): boolean => {\n      if (!onBeforeStepChange || fromKey === undefined) {\n        return true;\n      }\n      return onBeforeStepChange(fromKey, toKey);\n    },\n    [onBeforeStepChange],\n  );\n\n  /**\n   * Update completed steps based on navigation direction.\n   * Moving forward: mark the step we're leaving as completed.\n   * Moving backward: remove completed state from all steps at or after the destination.\n   */\n  const updateCompletedSteps = useCallback(\n    (fromKey: Key | undefined, toKey: Key): void => {\n      if (fromKey === undefined) {\n        return;\n      }\n\n      const fromIndex = getStepIndex(fromKey);\n      const toIndex = getStepIndex(toKey);\n      const isForward = toIndex > fromIndex;\n\n      setCompletedSteps((previousCompletedSteps) => {\n        const nextCompletedSteps = new Set(previousCompletedSteps);\n        if (isForward) {\n          nextCompletedSteps.add(fromKey);\n          // The active destination step is not considered completed.\n          nextCompletedSteps.delete(toKey);\n          return nextCompletedSteps;\n        }\n\n        for (let index = toIndex; index < steps.length; index++) {\n          const step = steps[index];\n          if (step !== undefined) {\n            nextCompletedSteps.delete(step);\n          }\n        }\n        return nextCompletedSteps;\n      });\n    },\n    [setCompletedSteps, getStepIndex, steps],\n  );\n\n  /**\n   * Navigate to a specific step.\n   * Respects disabled keys and validation callbacks.\n   */\n  const goToStep = useCallback(\n    (targetKey: Key): void => {\n      if (isNavigationBlocked(targetKey)) {\n        return;\n      }\n\n      const allowed = runValidation(currentStep, targetKey);\n      if (!allowed) {\n        return;\n      }\n\n      updateCompletedSteps(currentStep, targetKey);\n\n      // useControlledState handles both controlled and uncontrolled modes,\n      // and calls onStepChange callback automatically\n      setCurrentStep(targetKey);\n    },\n    [\n      currentStep,\n      isNavigationBlocked,\n      runValidation,\n      updateCompletedSteps,\n      setCurrentStep,\n    ],\n  );\n\n  /**\n   * Navigate to the next step in sequence.\n   */\n  const next = useCallback((): void => {\n    if (currentStepIndex === -1 || currentStepIndex >= steps.length - 1) {\n      return;\n    }\n\n    const nextKey = steps[currentStepIndex + 1];\n    if (nextKey === undefined) {\n      return;\n    }\n\n    goToStep(nextKey);\n  }, [currentStepIndex, steps, goToStep]);\n\n  /**\n   * Navigate to the previous step in sequence.\n   */\n  const previous = useCallback((): void => {\n    if (currentStepIndex <= 0) {\n      return;\n    }\n\n    const previousKey = steps[currentStepIndex - 1];\n    if (previousKey === undefined) {\n      return;\n    }\n\n    goToStep(previousKey);\n  }, [currentStepIndex, steps, goToStep]);\n\n  return {\n    currentStep,\n    completedSteps,\n    disabledKeys,\n    orientation,\n    steps,\n    register,\n    unregister,\n    goToStep,\n    next,\n    previous,\n    isDisabled,\n    isFirstStep,\n    isLastStep,\n    getStepIndex,\n  };\n}\n"],"mappings":"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"}

package/dist/components/switch/context.d.ts

@@ -13,13 +13,13 @@
 import { ProviderProps } from "../../lib/types.js";
 import { SwitchProps } from "./types.js";
 import "client-only";
-import * as react32 from "react";
-import * as react_jsx_runtime108 from "react/jsx-runtime";
+import * as react50 from "react";
+import * as react_jsx_runtime216 from "react/jsx-runtime";
 import { ContextValue } from "react-aria-components/slots";
 
 //#region src/components/switch/context.d.ts
 /** Context for sharing props across Switch components */
-declare const SwitchContext: react32.Context<ContextValue<SwitchProps, HTMLLabelElement>>;
+declare const SwitchContext: react50.Context<ContextValue<SwitchProps, HTMLLabelElement>>;
 /**
  * Sets default props for all Switch components within.
  *
@@ -38,7 +38,7 @@ declare const SwitchContext: react32.Context<ContextValue<SwitchProps, HTMLLabel
 declare function SwitchProvider({
   children,
   ...props
-}: ProviderProps<SwitchProps>): react_jsx_runtime108.JSX.Element;
+}: ProviderProps<SwitchProps>): react_jsx_runtime216.JSX.Element;
 //#endregion
 export { SwitchContext, SwitchProvider };
 //# sourceMappingURL=context.d.ts.map