@dashforge/tw 0.3.0-beta → 0.5.0-beta

package/dist/src/components/Pagination/pagination.variants.d.ts

@@ -0,0 +1,150 @@
+import { type VariantProps } from 'tailwind-variants';
+/**
+ * `<Pagination>` variant recipe.
+ *
+ * Slots:
+ *  - `root`             — outer `<nav>` container
+ *  - `summary`          — "Showing X-Y of Z" text
+ *  - `list`             — `<ul>` of page buttons
+ *  - `pageButton`       — individual page number button
+ *  - `activeButton`     — modifier applied to the current page
+ *  - `navButton`        — first/prev/next/last buttons
+ *  - `ellipsis`         — `…` rendered when range gap
+ *  - `pageSizeSelector` — native `<select>` for page size
+ *  - `jumpInput`        — direct page jump `<input>`
+ *
+ * Variant axes:
+ *  - `variant` — `default` (full kit) | `compact` (number buttons +
+ *    prev/next only) | `minimal` ("X / Y pages" + prev/next only).
+ *  - `size` — `sm` | `md` (default) | `lg`. Drives padding + text
+ *    size on the buttons.
+ */
+export declare const paginationVariants: import("tailwind-variants").TVReturnType<{
+    variant: {
+        default: {};
+        compact: {};
+        minimal: {};
+    };
+    size: {
+        sm: {
+            summary: string;
+            pageButton: string;
+            navButton: string;
+            ellipsis: string;
+            pageSizeSelector: string;
+            jumpInput: string;
+        };
+        md: {
+            summary: string;
+            pageButton: string;
+            navButton: string;
+            ellipsis: string;
+            pageSizeSelector: string;
+            jumpInput: string;
+        };
+        lg: {
+            summary: string;
+            pageButton: string;
+            navButton: string;
+            ellipsis: string;
+            pageSizeSelector: string;
+            jumpInput: string;
+        };
+    };
+}, {
+    root: string;
+    summary: string;
+    list: string;
+    pageButton: string[];
+    activeButton: string[];
+    navButton: string[];
+    ellipsis: string;
+    pageSizeSelector: string[];
+    jumpInput: string[];
+}, undefined, {
+    variant: {
+        default: {};
+        compact: {};
+        minimal: {};
+    };
+    size: {
+        sm: {
+            summary: string;
+            pageButton: string;
+            navButton: string;
+            ellipsis: string;
+            pageSizeSelector: string;
+            jumpInput: string;
+        };
+        md: {
+            summary: string;
+            pageButton: string;
+            navButton: string;
+            ellipsis: string;
+            pageSizeSelector: string;
+            jumpInput: string;
+        };
+        lg: {
+            summary: string;
+            pageButton: string;
+            navButton: string;
+            ellipsis: string;
+            pageSizeSelector: string;
+            jumpInput: string;
+        };
+    };
+}, {
+    root: string;
+    summary: string;
+    list: string;
+    pageButton: string[];
+    activeButton: string[];
+    navButton: string[];
+    ellipsis: string;
+    pageSizeSelector: string[];
+    jumpInput: string[];
+}, import("tailwind-variants").TVReturnType<{
+    variant: {
+        default: {};
+        compact: {};
+        minimal: {};
+    };
+    size: {
+        sm: {
+            summary: string;
+            pageButton: string;
+            navButton: string;
+            ellipsis: string;
+            pageSizeSelector: string;
+            jumpInput: string;
+        };
+        md: {
+            summary: string;
+            pageButton: string;
+            navButton: string;
+            ellipsis: string;
+            pageSizeSelector: string;
+            jumpInput: string;
+        };
+        lg: {
+            summary: string;
+            pageButton: string;
+            navButton: string;
+            ellipsis: string;
+            pageSizeSelector: string;
+            jumpInput: string;
+        };
+    };
+}, {
+    root: string;
+    summary: string;
+    list: string;
+    pageButton: string[];
+    activeButton: string[];
+    navButton: string[];
+    ellipsis: string;
+    pageSizeSelector: string[];
+    jumpInput: string[];
+}, undefined, unknown, unknown, undefined>>;
+export type PaginationVariants = VariantProps<typeof paginationVariants>;
+//# sourceMappingURL=pagination.variants.d.ts.map

package/dist/src/components/Pagination/pagination.variants.d.ts.map

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

package/dist/src/components/Popover/Popover.d.ts

@@ -0,0 +1,15 @@
+import type { PopoverProps } from './popover.types.js';
+/**
+ * Dashforge TW `<Popover>` — clickable floating content panel.
+ *
+ * Built on `@radix-ui/react-popover`:
+ *  - Focus trap inside the popover (Tab cycles within).
+ *  - Outside-click + Escape dismiss.
+ *  - APG dialog-like semantics (`role="dialog"` on content).
+ *  - Portal-rendered.
+ *
+ * Use `<Popover>` for menus / pickers / settings panels with
+ * interactive children. Use `<Tooltip>` for read-only hints.
+ */
+export declare function Popover(props: PopoverProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=Popover.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Popover.d.ts","sourceRoot":"","sources":["../../../../src/components/Popover/Popover.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAEvD;;;;;;;;;;;GAWG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,YAAY,2CAqC1C"}

package/dist/src/components/Popover/popover.types.d.ts

@@ -0,0 +1,45 @@
+import type { ReactNode } from 'react';
+export interface PopoverSlotProps {
+    content?: {
+        className?: string;
+    };
+    arrow?: {
+        className?: string;
+    };
+}
+/**
+ * Props for `<Popover>`.
+ *
+ * Built on `@radix-ui/react-popover`. Use for richer floating UI
+ * than a tooltip — e.g. action menus, color pickers, settings
+ * panels.
+ *
+ * Differences vs `<Tooltip>`:
+ *  - Popover is **clickable** and captures focus inside (focus trap).
+ *  - Popover supports arbitrary interactive content (forms, buttons).
+ *  - Popover dismisses on outside-click / Escape (Radix-managed).
+ *  - No `role="tooltip"` — popovers are conceptually mini-dialogs.
+ */
+export interface PopoverProps {
+    /** The trigger element (wrapped in Radix's `asChild` slot). */
+    children: ReactNode;
+    /** Popover body content. */
+    content: ReactNode;
+    /** Side of the trigger to render on. @default 'bottom' */
+    side?: 'top' | 'right' | 'bottom' | 'left';
+    /** Alignment along the perpendicular axis. @default 'center' */
+    align?: 'start' | 'center' | 'end';
+    /** Show an arrow indicator. @default false */
+    showArrow?: boolean;
+    /** Controlled open state. */
+    open?: boolean;
+    /** Called when open state changes. */
+    onOpenChange?: (open: boolean) => void;
+    /** Side offset in pixels. @default 8 */
+    sideOffset?: number;
+    /** Width of the popover content. CSS value. */
+    width?: string;
+    /** Per-slot overrides. */
+    slotProps?: PopoverSlotProps;
+}
+//# sourceMappingURL=popover.types.d.ts.map

package/dist/src/components/Popover/popover.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"popover.types.d.ts","sourceRoot":"","sources":["../../../../src/components/Popover/popover.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAEvC,MAAM,WAAW,gBAAgB;IAC/B,OAAO,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IACjC,KAAK,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CAChC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,YAAY;IAC3B,+DAA+D;IAC/D,QAAQ,EAAE,SAAS,CAAC;IACpB,4BAA4B;IAC5B,OAAO,EAAE,SAAS,CAAC;IACnB,0DAA0D;IAC1D,IAAI,CAAC,EAAE,KAAK,GAAG,OAAO,GAAG,QAAQ,GAAG,MAAM,CAAC;IAC3C,gEAAgE;IAChE,KAAK,CAAC,EAAE,OAAO,GAAG,QAAQ,GAAG,KAAK,CAAC;IACnC,8CAA8C;IAC9C,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,6BAA6B;IAC7B,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,sCAAsC;IACtC,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,CAAC;IACvC,wCAAwC;IACxC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,+CAA+C;IAC/C,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,0BAA0B;IAC1B,SAAS,CAAC,EAAE,gBAAgB,CAAC;CAC9B"}

package/dist/src/components/Popover/popover.variants.d.ts

@@ -0,0 +1,34 @@
+import { type VariantProps } from 'tailwind-variants';
+export declare const popoverVariants: import("tailwind-variants").TVReturnType<{
+    [key: string]: {
+        [key: string]: import("tailwind-merge").ClassNameValue | {
+            content?: import("tailwind-merge").ClassNameValue;
+            arrow?: import("tailwind-merge").ClassNameValue;
+        };
+    };
+} | {
+    [x: string]: {
+        [x: string]: import("tailwind-merge").ClassNameValue | {
+            content?: import("tailwind-merge").ClassNameValue;
+            arrow?: import("tailwind-merge").ClassNameValue;
+        };
+    };
+} | {}, {
+    content: string[];
+    arrow: string;
+}, undefined, {
+    [key: string]: {
+        [key: string]: import("tailwind-merge").ClassNameValue | {
+            content?: import("tailwind-merge").ClassNameValue;
+            arrow?: import("tailwind-merge").ClassNameValue;
+        };
+    };
+} | {}, {
+    content: string[];
+    arrow: string;
+}, import("tailwind-variants").TVReturnType<unknown, {
+    content: string[];
+    arrow: string;
+}, undefined, unknown, unknown, undefined>>;
+export type PopoverVariants = VariantProps<typeof popoverVariants>;
+//# sourceMappingURL=popover.variants.d.ts.map

package/dist/src/components/Popover/popover.variants.d.ts.map

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

package/dist/src/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/src/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/src/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/src/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/src/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/src/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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2CAkD3B,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,YAAY,CAAC,OAAO,gBAAgB,CAAC,CAAC"}

package/dist/src/components/Tabs/Tabs.d.ts

@@ -0,0 +1,15 @@
+import type { TabsProps } from './tabs.types.js';
+/**
+ * Dashforge TW `<Tabs>` — declarative tab navigation.
+ *
+ * Built on `@radix-ui/react-tabs`:
+ *  - APG tabs pattern (arrow-key navigation, automatic activation,
+ *    `role="tablist"` + `role="tab"` + `role="tabpanel"`).
+ *  - Controlled / uncontrolled (`value` / `defaultValue`).
+ *
+ * Two variant axes:
+ *  - `variant` — `underline` (default) | `pill`
+ *  - `orientation` — `horizontal` (default) | `vertical`
+ */
+export declare function Tabs(props: TabsProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=Tabs.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Tabs.d.ts","sourceRoot":"","sources":["../../../../src/components/Tabs/Tabs.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAEjD;;;;;;;;;;;GAWG;AACH,wBAAgB,IAAI,CAAC,KAAK,EAAE,SAAS,2CAgDpC"}

package/dist/src/components/Tabs/tabs.types.d.ts

@@ -0,0 +1,55 @@
+import type { ReactNode } from 'react';
+import type { TabsVariants } from './tabs.variants.js';
+export interface TabsSlotProps {
+    root?: {
+        className?: string;
+    };
+    list?: {
+        className?: string;
+    };
+    trigger?: {
+        className?: string;
+    };
+    content?: {
+        className?: string;
+    };
+}
+/**
+ * Single tab item — paired `{ value, label, content }`. The `value`
+ * is the canonical id (selected via the `value` / `defaultValue`
+ * props on the root); the `label` is the trigger button text, and
+ * `content` is what renders in the panel when this tab is active.
+ */
+export interface TabItem {
+    value: string;
+    label: ReactNode;
+    /** Tab panel content. */
+    content: ReactNode;
+    /** Per-tab disabled flag. */
+    disabled?: boolean;
+}
+/**
+ * Props for `<Tabs>`.
+ *
+ * Built on `@radix-ui/react-tabs`. Two variant axes:
+ *  - `variant` — `underline` (default) | `pill`
+ *  - `orientation` — `horizontal` (default) | `vertical`
+ *
+ * Supports controlled (`value` + `onValueChange`) and uncontrolled
+ * (`defaultValue`) modes — the `value` prop wins when both are set.
+ */
+export interface TabsProps extends TabsVariants {
+    /** Tab items array (declarative — alternative to passing children). */
+    items: TabItem[];
+    /** Controlled active value. */
+    value?: string;
+    /** Default active value (uncontrolled). Defaults to first item's value. */
+    defaultValue?: string;
+    /** Fires when the active tab changes. */
+    onValueChange?: (value: string) => void;
+    /** Root className shortcut. */
+    sx?: string;
+    /** Per-slot overrides. */
+    slotProps?: TabsSlotProps;
+}
+//# sourceMappingURL=tabs.types.d.ts.map

package/dist/src/components/Tabs/tabs.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tabs.types.d.ts","sourceRoot":"","sources":["../../../../src/components/Tabs/tabs.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AACvC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAEvD,MAAM,WAAW,aAAa;IAC5B,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,OAAO,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CAClC;AAED;;;;;GAKG;AACH,MAAM,WAAW,OAAO;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,SAAS,CAAC;IACjB,yBAAyB;IACzB,OAAO,EAAE,SAAS,CAAC;IACnB,6BAA6B;IAC7B,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,SAAU,SAAQ,YAAY;IAC7C,uEAAuE;IACvE,KAAK,EAAE,OAAO,EAAE,CAAC;IACjB,+BAA+B;IAC/B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,2EAA2E;IAC3E,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,yCAAyC;IACzC,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IACxC,+BAA+B;IAC/B,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,0BAA0B;IAC1B,SAAS,CAAC,EAAE,aAAa,CAAC;CAC3B"}

package/dist/src/components/Tabs/tabs.variants.d.ts

@@ -0,0 +1,82 @@
+import { type VariantProps } from 'tailwind-variants';
+export declare const tabsVariants: import("tailwind-variants").TVReturnType<{
+    variant: {
+        underline: {
+            list: string;
+            trigger: string[];
+        };
+        pill: {
+            list: string;
+            trigger: string[];
+        };
+    };
+    orientation: {
+        horizontal: {
+            root: string;
+            list: string;
+        };
+        vertical: {
+            root: string;
+            list: string;
+        };
+    };
+}, {
+    root: string;
+    list: string;
+    trigger: string[];
+    content: string[];
+}, undefined, {
+    variant: {
+        underline: {
+            list: string;
+            trigger: string[];
+        };
+        pill: {
+            list: string;
+            trigger: string[];
+        };
+    };
+    orientation: {
+        horizontal: {
+            root: string;
+            list: string;
+        };
+        vertical: {
+            root: string;
+            list: string;
+        };
+    };
+}, {
+    root: string;
+    list: string;
+    trigger: string[];
+    content: string[];
+}, import("tailwind-variants").TVReturnType<{
+    variant: {
+        underline: {
+            list: string;
+            trigger: string[];
+        };
+        pill: {
+            list: string;
+            trigger: string[];
+        };
+    };
+    orientation: {
+        horizontal: {
+            root: string;
+            list: string;
+        };
+        vertical: {
+            root: string;
+            list: string;
+        };
+    };
+}, {
+    root: string;
+    list: string;
+    trigger: string[];
+    content: string[];
+}, undefined, unknown, unknown, undefined>>;
+export type TabsVariants = VariantProps<typeof tabsVariants>;
+//# sourceMappingURL=tabs.variants.d.ts.map

package/dist/src/components/Tabs/tabs.variants.d.ts.map

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

package/dist/src/components/Tooltip/Tooltip.d.ts

@@ -0,0 +1,29 @@
+import type { TooltipProps } from './tooltip.types.js';
+/**
+ * Dashforge TW `<Tooltip>` — hoverable / focusable tooltip.
+ *
+ * Built on `@radix-ui/react-tooltip`:
+ *  - APG tooltip pattern: `role="tooltip"`, `aria-describedby` wired
+ *    to the trigger automatically (Radix manages the id linkage).
+ *  - Shows on hover OR keyboard focus.
+ *  - Dismissed on Escape or pointer leave.
+ *
+ * Wrap any single React node — it becomes the trigger via Radix's
+ * `asChild` slot. The trigger inherits `aria-describedby` so screen
+ * readers announce the tooltip content along with the trigger.
+ *
+ * @example
+ * ```tsx
+ * <Tooltip content="Delete this item">
+ *   <Button variant="ghost">
+ *     <TrashIcon />
+ *   </Button>
+ * </Tooltip>
+ * ```
+ *
+ * Each consumer can also wrap the entire app once in
+ * `<RadixTooltip.Provider>` to share delay/skip configuration; we
+ * include a per-component provider here for ease-of-use.
+ */
+export declare function Tooltip(props: TooltipProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=Tooltip.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Tooltip.d.ts","sourceRoot":"","sources":["../../../../src/components/Tooltip/Tooltip.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAEvD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,YAAY,2CAsC1C"}