@dashforge/tw 0.11.0-beta → 1.0.0

package/dist/components/RadioGroup/radioGroup.variants.d.ts

@@ -0,0 +1,166 @@
+import { type VariantProps } from 'tailwind-variants';
+/**
+ * Tailwind-variants recipe for `<RadioGroup>` with slots.
+ *
+ * Slots:
+ *   - `root`         — outer wrapper (label + option list + helper/error)
+ *   - `label`        — group-level label (rendered above the option list)
+ *   - `requiredMark` — red asterisk for required groups
+ *   - `optionList`   — container for the radio options (flex direction
+ *                      decided by the `layout` variant)
+ *   - `option`       — wrapper for a single option (control + label)
+ *   - `control`      — visible circle (Radix `RadioGroup.Item`)
+ *   - `indicator`    — inner dot (Radix `RadioGroup.Indicator`)
+ *   - `optionLabel`  — text label associated with the control
+ *   - `helperText`   — descriptive line below the option list
+ *   - `errorText`    — semantic counterpart of helperText for error mode
+ *
+ * Variants:
+ *   - `size`   : sm / md / lg — drives control circle + label text size
+ *   - `layout` : stacked (vertical, default) / row (horizontal)
+ *   - `error`  : bool — swaps borders + helperText color to danger tones
+ */
+export declare const radioGroupVariants: import("tailwind-variants").TVReturnType<{
+    size: {
+        sm: {
+            control: string;
+            indicator: string;
+            optionLabel: string;
+        };
+        md: {
+            control: string;
+            indicator: string;
+            optionLabel: string;
+        };
+        lg: {
+            control: string;
+            indicator: string;
+            optionLabel: string;
+        };
+    };
+    layout: {
+        stacked: {
+            optionList: string;
+        };
+        row: {
+            optionList: string;
+        };
+    };
+    error: {
+        true: {
+            control: string;
+        };
+    };
+    disabled: {
+        true: {
+            control: string;
+        };
+    };
+}, {
+    root: string;
+    label: string;
+    requiredMark: string;
+    optionList: string;
+    option: string;
+    control: string[];
+    indicator: string;
+    optionLabel: string;
+    helperText: string;
+    errorText: string;
+}, undefined, {
+    size: {
+        sm: {
+            control: string;
+            indicator: string;
+            optionLabel: string;
+        };
+        md: {
+            control: string;
+            indicator: string;
+            optionLabel: string;
+        };
+        lg: {
+            control: string;
+            indicator: string;
+            optionLabel: string;
+        };
+    };
+    layout: {
+        stacked: {
+            optionList: string;
+        };
+        row: {
+            optionList: string;
+        };
+    };
+    error: {
+        true: {
+            control: string;
+        };
+    };
+    disabled: {
+        true: {
+            control: string;
+        };
+    };
+}, {
+    root: string;
+    label: string;
+    requiredMark: string;
+    optionList: string;
+    option: string;
+    control: string[];
+    indicator: string;
+    optionLabel: string;
+    helperText: string;
+    errorText: string;
+}, import("tailwind-variants").TVReturnType<{
+    size: {
+        sm: {
+            control: string;
+            indicator: string;
+            optionLabel: string;
+        };
+        md: {
+            control: string;
+            indicator: string;
+            optionLabel: string;
+        };
+        lg: {
+            control: string;
+            indicator: string;
+            optionLabel: string;
+        };
+    };
+    layout: {
+        stacked: {
+            optionList: string;
+        };
+        row: {
+            optionList: string;
+        };
+    };
+    error: {
+        true: {
+            control: string;
+        };
+    };
+    disabled: {
+        true: {
+            control: string;
+        };
+    };
+}, {
+    root: string;
+    label: string;
+    requiredMark: string;
+    optionList: string;
+    option: string;
+    control: string[];
+    indicator: string;
+    optionLabel: string;
+    helperText: string;
+    errorText: string;
+}, undefined, unknown, unknown, undefined>>;
+export type RadioGroupVariants = VariantProps<typeof radioGroupVariants>;
+//# sourceMappingURL=radioGroup.variants.d.ts.map

package/dist/components/RadioGroup/radioGroup.variants.d.ts.map

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

package/dist/components/Skeleton/Skeleton.d.ts

@@ -0,0 +1,23 @@
+import type { SkeletonProps } from './skeleton.types.js';
+/**
+ * Dashforge TW `<Skeleton>` — loading placeholder primitive.
+ *
+ * Renders as a non-interactive `<span aria-hidden="true">` so screen
+ * readers skip it. The surrounding component is responsible for
+ * announcing loading state via `aria-busy` or `aria-live` if needed.
+ *
+ * Variants:
+ *   - `variant` — `text` (default, line shape) / `rectangle` / `circle`
+ *   - `animation` — `pulse` (default) / `wave` / `none`
+ *
+ * Both animations are gated by `prefers-reduced-motion` (WCAG 2.3.3).
+ *
+ * @example
+ * ```tsx
+ * <Skeleton variant="text" width="200px" />
+ * <Skeleton variant="rectangle" width="100%" height="120px" />
+ * <Skeleton variant="circle" width="40px" />
+ * ```
+ */
+export declare function Skeleton(props: SkeletonProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=Skeleton.d.ts.map

package/dist/components/Skeleton/Skeleton.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Skeleton.d.ts","sourceRoot":"","sources":["../../../src/components/Skeleton/Skeleton.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEzD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,aAAa,2CAuB5C"}

package/dist/components/Skeleton/skeleton.types.d.ts

@@ -0,0 +1,56 @@
+import type { SkeletonVariants } from './skeleton.variants.js';
+export interface SkeletonSlotProps {
+    /** Root element override. */
+    root?: {
+        className?: string;
+    };
+}
+/**
+ * Props for `<Skeleton>`.
+ *
+ * Visual loading placeholder shown while data / images / components
+ * are being prepared. Three shapes (`variant`), three animations
+ * (`animation`), and free-form `width` / `height` for arbitrary
+ * dimensions.
+ *
+ * Rendered as a non-interactive `<span aria-hidden="true">` so screen
+ * readers skip it entirely.
+ *
+ * Compose by nesting: e.g. avatar + two text lines for a card
+ * placeholder.
+ *
+ * @example
+ * ```tsx
+ * <Skeleton variant="text"      width="200px" />
+ * <Skeleton variant="rectangle" width="100%" height="120px" />
+ * <Skeleton variant="circle"    width="40px" />
+ *
+ * // Compose to mimic a card shape
+ * <div className="flex gap-3">
+ *   <Skeleton variant="circle" width="48px" />
+ *   <div className="flex flex-col gap-2 flex-1">
+ *     <Skeleton variant="text" width="60%" />
+ *     <Skeleton variant="text" width="40%" />
+ *   </div>
+ * </div>
+ * ```
+ */
+export interface SkeletonProps extends Pick<SkeletonVariants, 'variant' | 'animation'> {
+    /**
+     * CSS width (e.g. `"200px"`, `"100%"`, `"60%"`).
+     *
+     * Defaults: `text` → `100%`, `rectangle` → `100%`, `circle` → `40px`.
+     */
+    width?: string;
+    /**
+     * CSS height (e.g. `"1em"`, `"120px"`).
+     *
+     * Defaults: `text` → `1em`, `rectangle` → `100px`, `circle` → matches `width`.
+     */
+    height?: string;
+    /** Root-level Tailwind override (wins via `tailwind-merge`). */
+    sx?: string;
+    /** Per-slot overrides. */
+    slotProps?: SkeletonSlotProps;
+}
+//# sourceMappingURL=skeleton.types.d.ts.map

package/dist/components/Skeleton/skeleton.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skeleton.types.d.ts","sourceRoot":"","sources":["../../../src/components/Skeleton/skeleton.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAE/D,MAAM,WAAW,iBAAiB;IAChC,6BAA6B;IAC7B,IAAI,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CAC/B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,MAAM,WAAW,aACf,SAAQ,IAAI,CAAC,gBAAgB,EAAE,SAAS,GAAG,WAAW,CAAC;IACvD;;;;OAIG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf;;;;OAIG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB,gEAAgE;IAChE,EAAE,CAAC,EAAE,MAAM,CAAC;IAEZ,0BAA0B;IAC1B,SAAS,CAAC,EAAE,iBAAiB,CAAC;CAC/B"}

package/dist/components/Skeleton/skeleton.variants.d.ts

@@ -0,0 +1,110 @@
+import { type VariantProps } from 'tailwind-variants';
+/**
+ * `<Skeleton>` variant recipe.
+ *
+ * Slots:
+ *  - `root` — single element (atomic component)
+ *
+ * Variant axes:
+ *  - `variant` (`text` | `rectangle` | `circle`) — shape / radius
+ *  - `animation` (`pulse` | `wave` | `none`) — how the placeholder
+ *    "breathes" while data loads. Always gated on
+ *    `prefers-reduced-motion` (no exception — animations are
+ *    purely cosmetic).
+ *
+ * Implementation notes:
+ *
+ *  - `pulse` uses Tailwind's built-in `animate-pulse` (opacity
+ *    1.0 ↔ 0.5 over 2s, ease-in-out infinite).
+ *  - `wave` overlays a moving gradient. Implemented with a
+ *    `relative` container + an `::after` pseudo-element via a
+ *    Tailwind arbitrary-value class. The gradient slides
+ *    horizontally over the surface, mimicking the MUI Skeleton
+ *    "wave" look.
+ *  - Color uses neutral-200 (light) and neutral-800 (dark) for
+ *    the base, picked up automatically by the dashforge preset's
+ *    CSS-variable layer.
+ *
+ * Accessibility: the root has `aria-hidden="true"` (set on the JSX
+ * side, not here). Screen readers skip the skeleton entirely;
+ * the surrounding component is responsible for announcing
+ * loading state via `aria-busy` or `aria-live` if needed.
+ */
+export declare const skeletonVariants: import("tailwind-variants").TVReturnType<{
+    variant: {
+        text: {
+            root: string;
+        };
+        rectangle: {
+            root: string;
+        };
+        circle: {
+            root: string;
+        };
+    };
+    animation: {
+        pulse: {
+            root: string;
+        };
+        wave: {
+            root: string[];
+        };
+        none: {
+            root: string;
+        };
+    };
+}, {
+    root: string[];
+}, undefined, {
+    variant: {
+        text: {
+            root: string;
+        };
+        rectangle: {
+            root: string;
+        };
+        circle: {
+            root: string;
+        };
+    };
+    animation: {
+        pulse: {
+            root: string;
+        };
+        wave: {
+            root: string[];
+        };
+        none: {
+            root: string;
+        };
+    };
+}, {
+    root: string[];
+}, import("tailwind-variants").TVReturnType<{
+    variant: {
+        text: {
+            root: string;
+        };
+        rectangle: {
+            root: string;
+        };
+        circle: {
+            root: string;
+        };
+    };
+    animation: {
+        pulse: {
+            root: string;
+        };
+        wave: {
+            root: string[];
+        };
+        none: {
+            root: string;
+        };
+    };
+}, {
+    root: string[];
+}, undefined, unknown, unknown, undefined>>;
+export type SkeletonVariants = VariantProps<typeof skeletonVariants>;
+//# sourceMappingURL=skeleton.variants.d.ts.map

package/dist/components/Skeleton/skeleton.variants.d.ts.map

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

package/dist/components/Snackbar/Snackbar.d.ts

@@ -0,0 +1,37 @@
+import type { SnackbarApi, SnackbarProviderProps } from './snackbar.types.js';
+/**
+ * `useSnackbar()` — returns `{ enqueue, dismiss, dismissAll }`.
+ *
+ * Throws if called outside `<SnackbarProvider>` — silent no-op would
+ * be a footgun for "Saved!" toasts that silently vanish.
+ */
+export declare function useSnackbar(): SnackbarApi;
+/**
+ * Dashforge TW Snackbar provider — transient, stacked toast notifications.
+ *
+ * **Behaviour**:
+ *   - `enqueue(opts)` returns the assigned `id`.
+ *   - Items appear in a fixed-corner stack (`position` prop).
+ *   - At most `maxVisible` (default 5) are shown — extras queue FIFO.
+ *   - Each item auto-dismisses after `autoHideMs` (default 4000); set
+ *     `0` for a persistent snackbar.
+ *   - Re-enqueueing with the SAME `id` reuses the slot and resets the
+ *     timer (de-dup pattern for repeated "Saved" toasts).
+ *
+ * **A11y**:
+ *   - Container is an `aria-live="polite"` region (assistive techs
+ *     announce new messages without stealing focus).
+ *   - Severity icon is `aria-hidden` — the message text carries the
+ *     semantic.
+ *   - Close + action buttons are focusable via Tab; the visual stack
+ *     order is the same as the announcement order.
+ *
+ * **Re-render contract**:
+ *   - Provider re-renders ONLY when the visible set changes.
+ *   - The `api` (returned by `useSnackbar()`) is stable across re-renders
+ *     — `useCallback`'d with no deps, mutates a ref internally.
+ *   - Consumers calling `useSnackbar()` get the same identity each time
+ *     so they can safely pass `enqueue` to `useEffect` deps.
+ */
+export declare function SnackbarProvider(props: SnackbarProviderProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=Snackbar.d.ts.map

package/dist/components/Snackbar/Snackbar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Snackbar.d.ts","sourceRoot":"","sources":["../../../src/components/Snackbar/Snackbar.tsx"],"names":[],"mappings":"AAWA,OAAO,KAAK,EACV,WAAW,EAEX,qBAAqB,EAGtB,MAAM,qBAAqB,CAAC;AAI7B;;;;;GAKG;AACH,wBAAgB,WAAW,IAAI,WAAW,CAQzC;AAeD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,qBAAqB,2CA4N5D"}

package/dist/components/Snackbar/snackbar.types.d.ts

@@ -0,0 +1,86 @@
+import type { ReactNode } from 'react';
+import type { SnackbarVariants } from './snackbar.variants.js';
+/** Visual severity — drives icon color + accent on the snackbar surface. */
+export type SnackbarSeverity = 'info' | 'success' | 'warning' | 'danger';
+/** Corner anchor for the snackbar stack. */
+export type SnackbarPosition = 'top-left' | 'top-center' | 'top-right' | 'bottom-left' | 'bottom-center' | 'bottom-right';
+/** One snackbar instance — what `useSnackbar().enqueue()` accepts. */
+export interface SnackbarOptions {
+    /** Required text/content. */
+    message: ReactNode;
+    /** Visual severity. @default 'info' */
+    severity?: SnackbarSeverity;
+    /**
+     * Auto-dismiss after this many ms. `0` / negative ⇒ persistent
+     * (only dismissed by the close button or `dismiss(id)`).
+     * @default 4000
+     */
+    autoHideMs?: number;
+    /** Optional action button label + handler. */
+    action?: {
+        label: ReactNode;
+        onClick: () => void;
+    };
+    /** Per-instance close-button visibility. @default true */
+    showClose?: boolean;
+    /**
+     * Stable identifier for de-duplication. If a snackbar with the same
+     * `id` is enqueued while already visible, the existing one is REUSED
+     * (auto-dismiss timer reset) instead of stacking a duplicate. Useful
+     * for "Saved" toasts triggered repeatedly from the same action.
+     */
+    id?: string;
+}
+/** Internal model — every enqueued snackbar gets a unique id + a tick. */
+export interface SnackbarRecord extends SnackbarOptions {
+    id: string;
+    /**
+     * Monotonic creation tick, used to drive the entry CSS transition
+     * (the consumer's CSS can target `data-state="entered"` keyed by tick).
+     */
+    tick: number;
+}
+export interface SnackbarSlotProps {
+    container?: {
+        className?: string;
+    };
+    item?: {
+        className?: string;
+    };
+    icon?: {
+        className?: string;
+    };
+    message?: {
+        className?: string;
+    };
+    action?: {
+        className?: string;
+    };
+    closeButton?: {
+        className?: string;
+    };
+}
+/** API exposed by `useSnackbar()`. */
+export interface SnackbarApi {
+    /** Show a snackbar — returns its assigned id (auto-generated if not provided). */
+    enqueue: (options: SnackbarOptions) => string;
+    /** Dismiss a specific snackbar. */
+    dismiss: (id: string) => void;
+    /** Dismiss every visible snackbar. */
+    dismissAll: () => void;
+}
+export interface SnackbarProviderProps extends SnackbarVariants {
+    children: ReactNode;
+    /** Corner the stack anchors to. @default 'bottom-right' */
+    position?: SnackbarPosition;
+    /**
+     * Hard cap on simultaneously visible snackbars. Excess enqueued
+     * items wait FIFO until a slot frees up. @default 5
+     */
+    maxVisible?: number;
+    /** Defaults merged into every enqueue. */
+    defaults?: Pick<SnackbarOptions, 'severity' | 'autoHideMs' | 'showClose'>;
+    /** Per-slot className overrides. */
+    slotProps?: SnackbarSlotProps;
+}
+//# sourceMappingURL=snackbar.types.d.ts.map

package/dist/components/Snackbar/snackbar.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"snackbar.types.d.ts","sourceRoot":"","sources":["../../../src/components/Snackbar/snackbar.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AACvC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAE/D,4EAA4E;AAC5E,MAAM,MAAM,gBAAgB,GAAG,MAAM,GAAG,SAAS,GAAG,SAAS,GAAG,QAAQ,CAAC;AAEzE,4CAA4C;AAC5C,MAAM,MAAM,gBAAgB,GACxB,UAAU,GACV,YAAY,GACZ,WAAW,GACX,aAAa,GACb,eAAe,GACf,cAAc,CAAC;AAEnB,sEAAsE;AACtE,MAAM,WAAW,eAAe;IAC9B,6BAA6B;IAC7B,OAAO,EAAE,SAAS,CAAC;IACnB,uCAAuC;IACvC,QAAQ,CAAC,EAAE,gBAAgB,CAAC;IAC5B;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,8CAA8C;IAC9C,MAAM,CAAC,EAAE;QAAE,KAAK,EAAE,SAAS,CAAC;QAAC,OAAO,EAAE,MAAM,IAAI,CAAA;KAAE,CAAC;IACnD,0DAA0D;IAC1D,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB;;;;;OAKG;IACH,EAAE,CAAC,EAAE,MAAM,CAAC;CACb;AAED,0EAA0E;AAC1E,MAAM,WAAW,cAAe,SAAQ,eAAe;IACrD,EAAE,EAAE,MAAM,CAAC;IACX;;;OAGG;IACH,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,iBAAiB;IAChC,SAAS,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IACnC,IAAI,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAC9B,IAAI,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAC9B,OAAO,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IACjC,MAAM,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAChC,WAAW,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CACtC;AAED,sCAAsC;AACtC,MAAM,WAAW,WAAW;IAC1B,kFAAkF;IAClF,OAAO,EAAE,CAAC,OAAO,EAAE,eAAe,KAAK,MAAM,CAAC;IAC9C,mCAAmC;IACnC,OAAO,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,CAAC;IAC9B,sCAAsC;IACtC,UAAU,EAAE,MAAM,IAAI,CAAC;CACxB;AAED,MAAM,WAAW,qBAAsB,SAAQ,gBAAgB;IAC7D,QAAQ,EAAE,SAAS,CAAC;IACpB,2DAA2D;IAC3D,QAAQ,CAAC,EAAE,gBAAgB,CAAC;IAC5B;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,0CAA0C;IAC1C,QAAQ,CAAC,EAAE,IAAI,CAAC,eAAe,EAAE,UAAU,GAAG,YAAY,GAAG,WAAW,CAAC,CAAC;IAC1E,oCAAoC;IACpC,SAAS,CAAC,EAAE,iBAAiB,CAAC;CAC/B"}

package/dist/components/Snackbar/snackbar.variants.d.ts

@@ -0,0 +1,153 @@
+import { type VariantProps } from 'tailwind-variants';
+/**
+ * Tailwind-variants recipe for `<Snackbar>` (stacked toast surface).
+ *
+ * Slots:
+ *   - `container`   — fixed-position outer stack
+ *   - `item`        — single snackbar surface
+ *   - `icon`        — leading severity icon
+ *   - `message`     — main text
+ *   - `action`      — optional action button
+ *   - `closeButton` — trailing `×` button
+ */
+export declare const snackbarVariants: import("tailwind-variants").TVReturnType<{
+    position: {
+        'top-left': {
+            container: string;
+        };
+        'top-center': {
+            container: string;
+        };
+        'top-right': {
+            container: string;
+        };
+        'bottom-left': {
+            container: string;
+        };
+        'bottom-center': {
+            container: string;
+        };
+        'bottom-right': {
+            container: string;
+        };
+    };
+    severity: {
+        info: {
+            item: string;
+            icon: string;
+        };
+        success: {
+            item: string;
+            icon: string;
+        };
+        warning: {
+            item: string;
+            icon: string;
+        };
+        danger: {
+            item: string;
+            icon: string;
+        };
+    };
+}, {
+    container: string[];
+    item: string[];
+    icon: string;
+    message: string;
+    action: string[];
+    closeButton: string[];
+}, undefined, {
+    position: {
+        'top-left': {
+            container: string;
+        };
+        'top-center': {
+            container: string;
+        };
+        'top-right': {
+            container: string;
+        };
+        'bottom-left': {
+            container: string;
+        };
+        'bottom-center': {
+            container: string;
+        };
+        'bottom-right': {
+            container: string;
+        };
+    };
+    severity: {
+        info: {
+            item: string;
+            icon: string;
+        };
+        success: {
+            item: string;
+            icon: string;
+        };
+        warning: {
+            item: string;
+            icon: string;
+        };
+        danger: {
+            item: string;
+            icon: string;
+        };
+    };
+}, {
+    container: string[];
+    item: string[];
+    icon: string;
+    message: string;
+    action: string[];
+    closeButton: string[];
+}, import("tailwind-variants").TVReturnType<{
+    position: {
+        'top-left': {
+            container: string;
+        };
+        'top-center': {
+            container: string;
+        };
+        'top-right': {
+            container: string;
+        };
+        'bottom-left': {
+            container: string;
+        };
+        'bottom-center': {
+            container: string;
+        };
+        'bottom-right': {
+            container: string;
+        };
+    };
+    severity: {
+        info: {
+            item: string;
+            icon: string;
+        };
+        success: {
+            item: string;
+            icon: string;
+        };
+        warning: {
+            item: string;
+            icon: string;
+        };
+        danger: {
+            item: string;
+            icon: string;
+        };
+    };
+}, {
+    container: string[];
+    item: string[];
+    icon: string;
+    message: string;
+    action: string[];
+    closeButton: string[];
+}, undefined, unknown, unknown, undefined>>;
+export type SnackbarVariants = VariantProps<typeof snackbarVariants>;
+//# sourceMappingURL=snackbar.variants.d.ts.map

package/dist/components/Snackbar/snackbar.variants.d.ts.map

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

package/dist/components/Stack/Stack.d.ts

@@ -0,0 +1,24 @@
+import type { StackProps } from './stack.types.js';
+/**
+ * `<Stack>` — flex container 1D, the layout primitive.
+ *
+ * This is the ONLY component in @dashforge/tw that does flex. Box
+ * doesn't, Grid does CSS Grid (not flex). The strict naming → engine
+ * mapping is the whole point: when you read `<Stack>` in a JSX tree,
+ * you instantly know it's flex. No `<Box display="flex" ...>` traps.
+ *
+ * Direction defaults to `'col'` (vertical stack) — the most common
+ * case for forms, sidebars, settings panels. Pass `direction="row"`
+ * for horizontal layouts (toolbars, button rows, breadcrumbs).
+ *
+ * The `divider` prop is the runtime-only piece: TV can't encode the
+ * "render this between each child" logic as a class, so we walk the
+ * children at render time. The walk is O(n); for n ≤ ~10 (typical
+ * Stack content) the cost is negligible. For very long Stacks (1000+
+ * items), prefer to render dividers as part of each child instead.
+ *
+ * When `asChild` is true, the divider prop is silently ignored — Slot
+ * requires a single child, and the N-1 insertion has nowhere to act.
+ */
+export declare const Stack: import("react").ForwardRefExoticComponent<StackProps & import("react").RefAttributes<HTMLElement>>;
+//# sourceMappingURL=Stack.d.ts.map

package/dist/components/Stack/Stack.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Stack.d.ts","sourceRoot":"","sources":["../../../src/components/Stack/Stack.tsx"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAqCnD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,KAAK,oGAyCjB,CAAC"}