@dashforge/tw 1.1.1 → 1.2.0

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

@@ -0,0 +1,358 @@
+import type { ReactNode } from 'react';
+import type { Engine } from '@dashforge/ui-core';
+import type { AccessRequirement } from '@dashforge/rbac';
+import type { StepperVariants } from './stepper.variants.js';
+/**
+ * The lifecycle state of a single step within the visible sequence.
+ *
+ * - `pending`   — step comes AFTER the current step (not yet visited).
+ * - `current`   — the step the user is on right now.
+ * - `completed` — step was visited AND the consumer has advanced past it
+ *                 (implies `visitedSteps.has(step.name)` AND it is not
+ *                 the current step and is before it in the sequence).
+ * - `invalid`   — the step has an entry in `errors`, populated after a
+ *                 failed `goNext()` attempt (from `fields` trigger or
+ *                 `isValid` callback returning false).
+ * - `skipped`   — reserved for future non-linear skip semantics; unused
+ *                 in v1.
+ */
+export type StepState = 'pending' | 'current' | 'completed' | 'invalid' | 'skipped';
+/**
+ * Per-step error record surfaced on `useStep().errors`. Populated when
+ * `<Step fields={...}>` fails its RHF `trigger` call, or when a step's
+ * `isValid` callback returns `false`.
+ *
+ * The error routing pattern (Review step with clickable list) reads
+ * this array to render jump-links back to the step that failed.
+ */
+export interface StepError {
+    /** The step's `name` (unique key). */
+    step: string;
+    /** The step's `label` (for consumer-friendly display). */
+    label: ReactNode;
+    /** How the step became invalid. */
+    reason: 'fields' | 'isValid';
+    /** RHF `formState.errors` at the moment of the failed transition. */
+    errors: Record<string, unknown> | null;
+}
+/**
+ * Payload emitted to `<Stepper onStepInvalid>` when a `goNext()` attempt
+ * fails validation.
+ */
+export interface OnStepInvalidPayload {
+    /** The step that failed. */
+    step: string;
+    /** Its index within the visible sequence. */
+    index: number;
+    /** How it failed. */
+    reason: 'fields' | 'isValid';
+    /** RHF errors, if the failure came from `fields` trigger. */
+    errors: Record<string, unknown> | null;
+}
+/**
+ * The shape returned by `useStep()` — the consumer-facing API of the
+ * current Stepper context. Available to any component rendered inside
+ * a `<Stepper>` tree (typically the current `<Step>`'s children or a
+ * custom footer).
+ *
+ * The hook is the ONLY public path to the Stepper's internal state —
+ * consumers do NOT reach into the internal context directly.
+ */
+export interface UseStepReturn {
+    /** The current step's `name`. */
+    currentStep: string;
+    /** Its index within the visible sequence. */
+    currentStepIndex: number;
+    /**
+     * The filtered visible sequence, in declaration order. Steps whose
+     * `visibleWhen` returned `false` are absent.
+     */
+    visibleSteps: Array<{
+        name: string;
+        label: ReactNode;
+    }>;
+    /**
+     * Set of step names the user has visited so far. Reset by `reset()`,
+     * pre-populated by `initialStep` (every step before the initial one
+     * is treated as visited so a resumed wizard doesn't break the
+     * `allowJumpTo="visited"` gate).
+     */
+    visitedSteps: Set<string>;
+    /**
+     * Errors recorded from the most recent failed `goNext()` calls. Cleared
+     * for a step when it is re-visited AND successfully re-validated.
+     */
+    errors: StepError[];
+    /**
+     * Advance to the next step. Runs the current step's validation
+     * (`fields` trigger via `bridge.trigger` + optional `isValid` callback
+     * with AND semantics) and, on failure, records the error + fires
+     * `onStepInvalid`. On success beyond the last step, fires
+     * `onComplete()`.
+     *
+     * @returns `true` when the transition succeeded, `false` when blocked.
+     */
+    goNext: () => Promise<boolean>;
+    /**
+     * Go back one step. Does not run validation — pending steps between
+     * the current and the target are marked pending again, but the
+     * consumer's state (RHF values) is preserved.
+     */
+    goBack: () => void;
+    /**
+     * Jump directly to a step by name. Gated by `allowJumpTo`:
+     *   - `'visited'` — allowed only if `visitedSteps.has(name)`.
+     *   - `'none'`    — always rejected (silent no-op).
+     * The Review-step error-routing pattern uses this to send the user
+     * back to a failed step from the error summary.
+     */
+    goToStep: (name: string) => void;
+    /**
+     * Reset to `initialStep` (or the first visible step if `initialStep`
+     * is unset). Clears `visitedSteps` and `errors`.
+     */
+    reset: () => void;
+    /** `true` when the current step is the first in the visible sequence. */
+    isFirstStep: boolean;
+    /** `true` when the current step is the last in the visible sequence. */
+    isLastStep: boolean;
+    /**
+     * `true` when `goNext()` would succeed as of this render. Consumers
+     * can use this to render the Next button as `disabled`. Note this is
+     * a SYNC readout (based on `bridge.getError(field)` for each `fields`
+     * entry) — the `isValid` callback is NOT invoked here, since it may
+     * be async and consumers wouldn't want a render-time promise.
+     */
+    canGoNext: boolean;
+}
+/**
+ * Per-slot overrides — same shape as every other tw catalog entry.
+ */
+export interface StepperSlotProps {
+    root?: {
+        className?: string;
+    };
+    strip?: {
+        className?: string;
+    };
+    step?: {
+        className?: string;
+    };
+    indicator?: {
+        className?: string;
+    };
+    labelGroup?: {
+        className?: string;
+    };
+    label?: {
+        className?: string;
+    };
+    helperText?: {
+        className?: string;
+    };
+    optionalTag?: {
+        className?: string;
+    };
+    connector?: {
+        className?: string;
+    };
+    content?: {
+        className?: string;
+    };
+    footer?: {
+        className?: string;
+    };
+}
+/**
+ * Subset of `<Stepper>` props theme-configurable via
+ * `theme.components.Stepper.defaults` (Option C).
+ */
+export type StepperVariantProps = Pick<StepperVariants, 'color' | 'size' | 'orientation' | 'labelPlacement'>;
+declare module '@dashforge/tw-tokens' {
+    interface TWComponentDefaults {
+        Stepper?: {
+            defaults?: Partial<StepperVariantProps>;
+            slotProps?: StepperSlotProps;
+        };
+    }
+}
+/**
+ * Props for `<Step>` — a config-carrier child of `<Stepper>`.
+ *
+ * `<Step>` renders no DOM of its own; the parent `<Stepper>` walks the
+ * children, reads each `<Step>`'s props, and drives rendering from
+ * there. This mirrors the MUI / Chakra "compound children as config"
+ * pattern (`<Tabs><Tab /><Tab /></Tabs>`).
+ */
+export interface StepProps {
+    /**
+     * Unique step key. Also used by `visitedSteps`, `goToStep`, `errors`,
+     * and `initialStep`. Required — every step must have a distinct name.
+     */
+    name: string;
+    /** Short label rendered next to (or below) the indicator dot. */
+    label: ReactNode;
+    /**
+     * Secondary line rendered under the label. Optional.
+     * Common uses: "2 min", "Enter card info", "Optional".
+     */
+    helperText?: ReactNode;
+    /**
+     * Custom icon rendered inside the indicator dot for the `pending` and
+     * `current` states. Not shown when `completed` (a check mark takes
+     * over) or `invalid` (an alert-triangle icon takes over).
+     *
+     * MUI-parity — an escape hatch for domain-specific dots
+     * (`<Eye />` on a Review step, `<Cog />` on a Settings step).
+     */
+    icon?: ReactNode;
+    /**
+     * Marks the step as optional. `true` renders a default "Optional"
+     * italic caption below the label; passing a ReactNode substitutes the
+     * caption (`optional={<span>Skip if remote</span>}`). MUI-parity.
+     *
+     * NOTE: `optional` is display-only — it does NOT skip validation. A
+     * step that should be skippable at the flow level should use
+     * `visibleWhen` to hide itself, not `optional`.
+     */
+    optional?: boolean | ReactNode;
+    /**
+     * List of RHF field names to validate on `goNext()`. Runs
+     * `bridge.trigger(fields)` and blocks the transition if any field
+     * fails. Combined with `isValid` via **AND** semantics: both must
+     * pass for the step to be considered valid.
+     *
+     * Requires a wrapping `<DashForm>` — outside a form context this prop
+     * is a no-op (dev-warn).
+     */
+    fields?: string[];
+    /**
+     * Custom validation callback with AND-semantics against `fields`.
+     * Runs AFTER `fields` (only if `fields` passes). Return `false` (sync
+     * or async) to block the transition.
+     *
+     * Use for domain rules that can't be expressed as RHF field
+     * validators (e.g., "at least one item in the cart", "the payment
+     * gateway acknowledged the pre-auth").
+     */
+    isValid?: () => boolean | Promise<boolean>;
+    /**
+     * Reactive visibility predicate — catalog-uniform closure. Steps
+     * whose predicate returns `false` are excluded from `visibleSteps`,
+     * skipped by `goNext()` / `goBack()`, and hidden from the indicator
+     * strip. This is the primary hook for dynamic step composition
+     * (e.g., a "Legal address" step that only shows for EU customers).
+     */
+    visibleWhen?: (engine: Engine) => boolean;
+    /** RBAC gate — hides or disables the step. */
+    access?: AccessRequirement;
+    /** The step's content — rendered inside the `content` slot when active. */
+    children?: ReactNode;
+}
+/**
+ * Props for `<Stepper>` — the compound parent.
+ *
+ * @example Linear wizard with form-driven validation
+ * ```tsx
+ * <DashForm defaultValues={{ email: '', card: '' }}>
+ *   <Stepper name="cardActivation" onComplete={handleActivate}>
+ *     <Step name="account" label="Account" fields={['email']}>
+ *       <TextField name="email" label="Email" />
+ *     </Step>
+ *     <Step name="card" label="Card details" fields={['card']}>
+ *       <TextField name="card" label="Card number" />
+ *     </Step>
+ *     <Step name="review" label="Review">
+ *       <ReviewPanel />
+ *     </Step>
+ *   </Stepper>
+ * </DashForm>
+ * ```
+ *
+ * @example Dynamic step with `visibleWhen`
+ * ```tsx
+ * <Step
+ *   name="contract"
+ *   label="Contract"
+ *   visibleWhen={(engine) => engine.get('activation') === 'deferred'}
+ * >
+ *   ...
+ * </Step>
+ * ```
+ */
+export interface StepperProps {
+    /** Optional identifier — used for logging / test IDs. */
+    name?: string;
+    /**
+     * `<Step>` children. Non-`<Step>` children are dev-warned and
+     * ignored — the parent only recognizes its own compound child type.
+     */
+    children: ReactNode;
+    /**
+     * Name of the step to render on mount. Every step declared BEFORE
+     * `initialStep` in the visible sequence is marked as visited (so
+     * `allowJumpTo="visited"` allows the user to walk back through them).
+     *
+     * Common uses: resuming an interrupted wizard from persistent state,
+     * deep-linking to a specific step from a URL query.
+     *
+     * If the name doesn't match any visible step, falls back to the first
+     * visible step and dev-warns.
+     */
+    initialStep?: string;
+    /**
+     * Controls the `goToStep` (indicator-click) affordance:
+     *   - `'visited'` (default) — the user can jump only to steps they've
+     *                             already visited. Forward jumps are blocked
+     *                             because they'd bypass validation.
+     *   - `'none'`              — no jumping; navigation is strictly
+     *                             `goNext` / `goBack`.
+     *
+     * @default 'visited'
+     */
+    allowJumpTo?: 'visited' | 'none';
+    /**
+     * Fires when the user advances past the LAST visible step via
+     * `goNext()`. If this Stepper is wrapped in a `<DashForm>` and
+     * `onComplete` is omitted, the DashForm's own submit handler runs
+     * naturally on the consumer's Next button (typical pattern:
+     * `<Button type="submit">Finish</Button>` on the last step). Optional.
+     */
+    onComplete?: () => void;
+    /**
+     * Fires on every successful transition — moving forward, moving back,
+     * or jumping. Receives the previous step name, next step name, and
+     * the direction.
+     */
+    onStepChange?: (prev: string, next: string, reason: 'next' | 'back' | 'jump') => void;
+    /**
+     * Fires when `goNext()` blocks because validation failed. Useful for
+     * side-effects like scrolling the first invalid field into view or
+     * emitting a Snackbar toast.
+     */
+    onStepInvalid?: (payload: OnStepInvalidPayload) => void;
+    /** Colour intent applied to the indicator + connector fills. @default 'primary' */
+    color?: StepperVariants['color'];
+    /** Density knob (indicator diameter + label size). @default 'md' */
+    size?: StepperVariants['size'];
+    /** `horizontal` (default) or `vertical` strip layout. @default 'horizontal' */
+    orientation?: StepperVariants['orientation'];
+    /**
+     * `end` (label next to indicator, default) or `below` (label under
+     * the indicator, MUI `alternativeLabel` semantics). Horizontal only —
+     * ignored on `orientation='vertical'`.
+     * @default 'end'
+     */
+    labelPlacement?: StepperVariants['labelPlacement'];
+    /** Reactive visibility predicate for the whole Stepper. */
+    visibleWhen?: (engine: Engine) => boolean;
+    /** RBAC gate for the whole Stepper. */
+    access?: AccessRequirement;
+    /** Utility-class shortcut for `slotProps.root.className`. */
+    sx?: string;
+    /** Per-slot overrides. */
+    slotProps?: StepperSlotProps;
+    /** `data-testid` on the root wrapper. */
+    testId?: string;
+}
+//# sourceMappingURL=stepper.types.d.ts.map

package/dist/src/components/Stepper/stepper.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stepper.types.d.ts","sourceRoot":"","sources":["../../../../src/components/Stepper/stepper.types.ts"],"names":[],"mappings":"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"}

package/dist/src/components/Stepper/stepper.variants.d.ts

@@ -0,0 +1,253 @@
+import { type VariantProps } from 'tailwind-variants';
+/**
+ * Tailwind-variants recipe for `<Stepper>` — declarative multi-step
+ * navigation with per-step config carried by `<Step>` children.
+ *
+ * Slots:
+ *   - `root`        — outer wrapper (strip + content + footer are direct children).
+ *   - `strip`       — the indicator strip (a flex/grid row for horizontal, a column stack for vertical).
+ *   - `step`        — each rendered step item (indicator + label group).
+ *   - `indicator`   — the round dot that carries the step number, check, alert, or `icon`.
+ *   - `labelGroup`  — vertical stack holding label + helper + optional caption.
+ *   - `label`       — the step's short title.
+ *   - `helperText`  — the secondary line below the label.
+ *   - `optionalTag` — the italic "Optional" (or consumer-supplied node) tag below the label.
+ *   - `connector`   — the line drawn between two adjacent indicators.
+ *   - `content`     — the panel that renders the current step's children.
+ *   - `footer`      — reserved slot for consumer-authored Back / Next controls.
+ *
+ * State axes (data-* attributes on the `step` slot):
+ *   - `data-state="pending"|"current"|"completed"|"invalid"|"skipped"`.
+ *   Consumers can theme with `[data-state='invalid']` selectors in `slotProps`.
+ */
+export declare const stepperVariants: import("tailwind-variants").TVReturnType<{
+    color: {
+        primary: {
+            indicator: string[];
+            connector: string;
+        };
+        secondary: {
+            indicator: string[];
+            connector: string;
+        };
+        success: {
+            indicator: string[];
+            connector: string;
+        };
+        warning: {
+            indicator: string[];
+            connector: string;
+        };
+        danger: {
+            indicator: string[];
+            connector: string;
+        };
+        neutral: {
+            indicator: string[];
+            connector: string;
+        };
+    };
+    size: {
+        sm: {
+            indicator: string;
+            label: string;
+            helperText: string;
+        };
+        md: {
+            indicator: string;
+            label: string;
+            helperText: string;
+        };
+        lg: {
+            indicator: string;
+            label: string;
+            helperText: string;
+        };
+    };
+    orientation: {
+        horizontal: {
+            root: string;
+            strip: string;
+            connector: string;
+        };
+        vertical: {
+            root: string;
+            strip: string;
+            step: string;
+            connector: string;
+        };
+    };
+    labelPlacement: {
+        end: {};
+        below: {
+            step: string;
+            labelGroup: string;
+        };
+    };
+}, {
+    root: string;
+    strip: string;
+    step: string;
+    indicator: string[];
+    labelGroup: string;
+    label: string[];
+    helperText: string;
+    optionalTag: string;
+    connector: string;
+    content: string;
+    footer: string;
+}, undefined, {
+    color: {
+        primary: {
+            indicator: string[];
+            connector: string;
+        };
+        secondary: {
+            indicator: string[];
+            connector: string;
+        };
+        success: {
+            indicator: string[];
+            connector: string;
+        };
+        warning: {
+            indicator: string[];
+            connector: string;
+        };
+        danger: {
+            indicator: string[];
+            connector: string;
+        };
+        neutral: {
+            indicator: string[];
+            connector: string;
+        };
+    };
+    size: {
+        sm: {
+            indicator: string;
+            label: string;
+            helperText: string;
+        };
+        md: {
+            indicator: string;
+            label: string;
+            helperText: string;
+        };
+        lg: {
+            indicator: string;
+            label: string;
+            helperText: string;
+        };
+    };
+    orientation: {
+        horizontal: {
+            root: string;
+            strip: string;
+            connector: string;
+        };
+        vertical: {
+            root: string;
+            strip: string;
+            step: string;
+            connector: string;
+        };
+    };
+    labelPlacement: {
+        end: {};
+        below: {
+            step: string;
+            labelGroup: string;
+        };
+    };
+}, {
+    root: string;
+    strip: string;
+    step: string;
+    indicator: string[];
+    labelGroup: string;
+    label: string[];
+    helperText: string;
+    optionalTag: string;
+    connector: string;
+    content: string;
+    footer: string;
+}, import("tailwind-variants").TVReturnType<{
+    color: {
+        primary: {
+            indicator: string[];
+            connector: string;
+        };
+        secondary: {
+            indicator: string[];
+            connector: string;
+        };
+        success: {
+            indicator: string[];
+            connector: string;
+        };
+        warning: {
+            indicator: string[];
+            connector: string;
+        };
+        danger: {
+            indicator: string[];
+            connector: string;
+        };
+        neutral: {
+            indicator: string[];
+            connector: string;
+        };
+    };
+    size: {
+        sm: {
+            indicator: string;
+            label: string;
+            helperText: string;
+        };
+        md: {
+            indicator: string;
+            label: string;
+            helperText: string;
+        };
+        lg: {
+            indicator: string;
+            label: string;
+            helperText: string;
+        };
+    };
+    orientation: {
+        horizontal: {
+            root: string;
+            strip: string;
+            connector: string;
+        };
+        vertical: {
+            root: string;
+            strip: string;
+            step: string;
+            connector: string;
+        };
+    };
+    labelPlacement: {
+        end: {};
+        below: {
+            step: string;
+            labelGroup: string;
+        };
+    };
+}, {
+    root: string;
+    strip: string;
+    step: string;
+    indicator: string[];
+    labelGroup: string;
+    label: string[];
+    helperText: string;
+    optionalTag: string;
+    connector: string;
+    content: string;
+    footer: string;
+}, undefined, unknown, unknown, undefined>>;
+export type StepperVariants = VariantProps<typeof stepperVariants>;
+//# sourceMappingURL=stepper.variants.d.ts.map

package/dist/src/components/Stepper/stepper.variants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stepper.variants.d.ts","sourceRoot":"","sources":["../../../../src/components/Stepper/stepper.variants.ts"],"names":[],"mappings":"AAAA,OAAO,EAAM,KAAK,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAE1D;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2CAqI1B,CAAC;AAEH,MAAM,MAAM,eAAe,GAAG,YAAY,CAAC,OAAO,eAAe,CAAC,CAAC"}

package/dist/src/components/Stepper/useStep.d.ts

@@ -0,0 +1,53 @@
+import type { UseStepReturn } from './stepper.types.js';
+/**
+ * Access the Stepper state + navigation API from any component rendered
+ * inside a `<Stepper>` tree.
+ *
+ * The canonical use is inside the current step's children — a "Next" /
+ * "Back" footer, a review summary showing the visible sequence, or an
+ * error-routing Alert that turns each entry in `errors` into a clickable
+ * link that calls `goToStep(name)`.
+ *
+ * Throws (dev only) when called outside a Stepper. In production the
+ * hook returns a null-safe stub so a stale reference doesn't crash the
+ * app — but the consumer's navigation buttons will be no-ops. Fix the
+ * placement.
+ *
+ * @throws Error in dev if used outside `<Stepper>`.
+ *
+ * @example Custom footer
+ * ```tsx
+ * function StepFooter() {
+ *   const step = useStep();
+ *   return (
+ *     <Stack direction="row" justify="between">
+ *       <Button variant="outline" onClick={step.goBack} disabled={step.isFirstStep}>
+ *         Back
+ *       </Button>
+ *       <Button onClick={step.goNext} disabled={!step.canGoNext}>
+ *         {step.isLastStep ? 'Confirm' : 'Next'}
+ *       </Button>
+ *     </Stack>
+ *   );
+ * }
+ * ```
+ *
+ * @example Error routing on the review step
+ * ```tsx
+ * function ReviewErrors() {
+ *   const { errors, goToStep } = useStep();
+ *   if (errors.length === 0) return null;
+ *   return (
+ *     <Alert color="danger" title="Fix these issues before submitting">
+ *       {errors.map((e) => (
+ *         <Link key={e.step} onClick={() => goToStep(e.step)}>
+ *           {e.label}
+ *         </Link>
+ *       ))}
+ *     </Alert>
+ *   );
+ * }
+ * ```
+ */
+export declare function useStep(): UseStepReturn;
+//# sourceMappingURL=useStep.d.ts.map

package/dist/src/components/Stepper/useStep.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useStep.d.ts","sourceRoot":"","sources":["../../../../src/components/Stepper/useStep.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAExD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH,wBAAgB,OAAO,IAAI,aAAa,CA8BvC"}

package/dist/src/components/Switch/Switch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Switch.d.ts","sourceRoot":"","sources":["../../../../src/components/Switch/Switch.tsx"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAErD;;;;;;;;;;;GAWG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,WAAW,kDAsIxC"}
+{"version":3,"file":"Switch.d.ts","sourceRoot":"","sources":["../../../../src/components/Switch/Switch.tsx"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAErD;;;;;;;;;;;GAWG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,WAAW,kDAoJxC"}