@dashforge/tw 0.4.0-beta → 0.6.0-beta

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

@@ -0,0 +1,32 @@
+import type { PaginationProps } from './pagination.types.js';
+/**
+ * Dashforge TW `<Pagination>` — controlled pagination primitive.
+ *
+ * Three variants:
+ *  - `default`  — page-size selector + summary + page numbers + nav buttons + jump input
+ *  - `compact`  — page numbers + nav buttons only (no summary, no selector, no jump)
+ *  - `minimal`  — "Page X of Y" + prev/next only
+ *
+ * Always controlled (no internal state besides the jump-input draft).
+ *
+ * A11Y:
+ *  - `<nav aria-label="Pagination">` root
+ *  - `aria-current="page"` on the active page button
+ *  - `aria-label` on every interactive element
+ *
+ * @example
+ * ```tsx
+ * const [page, setPage] = useState(1);
+ * const [pageSize, setPageSize] = useState(20);
+ *
+ * <Pagination
+ *   page={page}
+ *   pageSize={pageSize}
+ *   totalCount={1437}
+ *   onPageChange={setPage}
+ *   onPageSizeChange={setPageSize}
+ * />
+ * ```
+ */
+export declare function Pagination(props: PaginationProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=Pagination.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Pagination.d.ts","sourceRoot":"","sources":["../../../../src/components/Pagination/Pagination.tsx"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,eAAe,EAAoB,MAAM,uBAAuB,CAAC;AAgB/E;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,eAAe,2CAiOhD"}

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

@@ -0,0 +1,23 @@
+/**
+ * Compute the array of page indices (or `'ellipsis'` sentinels) to
+ * render for a `<Pagination>`.
+ *
+ * Algorithm (standard "siblings + boundaries + ellipsis fill"):
+ *  1. Always show `boundaryCount` pages at the start and `boundaryCount`
+ *     at the end.
+ *  2. Show `siblingCount` pages on each side of the current page.
+ *  3. Fill gaps wider than 1 with `'ellipsis'`.
+ *  4. If a gap is exactly 1 page wide, include that page directly
+ *     (no ellipsis for a single hidden number).
+ *
+ * Output is 1-indexed page numbers OR the literal string `'ellipsis'`.
+ *
+ * @example
+ * ```ts
+ * range(1, 10, 1, 1)  // [1, 'ellipsis', 5, 'ellipsis', 10] when current=5
+ * range(1, 5, 1, 1)   // [1, 2, 3, 4, 5]
+ * range(1, 100, 1, 1) // edges varying with current
+ * ```
+ */
+export declare function computePageRange(currentPage: number, totalPages: number, siblingCount: number, boundaryCount: number): (number | 'ellipsis')[];
+//# sourceMappingURL=pagination.helpers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pagination.helpers.d.ts","sourceRoot":"","sources":["../../../../src/components/Pagination/pagination.helpers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,gBAAgB,CAC9B,WAAW,EAAE,MAAM,EACnB,UAAU,EAAE,MAAM,EAClB,YAAY,EAAE,MAAM,EACpB,aAAa,EAAE,MAAM,GACpB,CAAC,MAAM,GAAG,UAAU,CAAC,EAAE,CAsEzB"}

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

@@ -0,0 +1,120 @@
+import type { PaginationVariants } from './pagination.variants.js';
+export interface PaginationSlotProps {
+    root?: {
+        className?: string;
+    };
+    summary?: {
+        className?: string;
+    };
+    list?: {
+        className?: string;
+    };
+    pageButton?: {
+        className?: string;
+    };
+    activeButton?: {
+        className?: string;
+    };
+    navButton?: {
+        className?: string;
+    };
+    ellipsis?: {
+        className?: string;
+    };
+    pageSizeSelector?: {
+        className?: string;
+    };
+    jumpInput?: {
+        className?: string;
+    };
+}
+/**
+ * I18n strings for `<Pagination>`. Default = English. Override the
+ * subset you need to translate; the rest fall back to defaults.
+ */
+export interface PaginationLabels {
+    first?: string;
+    prev?: string;
+    next?: string;
+    last?: string;
+    page?: string;
+    of?: string;
+    showing?: string;
+    perPage?: string;
+    goToPage?: string;
+}
+/**
+ * Props for `<Pagination>`.
+ *
+ * Controlled component: the consumer owns `page` + `pageSize`. The
+ * component emits `onPageChange` / `onPageSizeChange` and recomputes
+ * the visible page range from `totalCount`.
+ *
+ * @example
+ * ```tsx
+ * const [page, setPage] = useState(1);
+ * const [pageSize, setPageSize] = useState(20);
+ *
+ * <Pagination
+ *   page={page}
+ *   pageSize={pageSize}
+ *   totalCount={1437}
+ *   onPageChange={setPage}
+ *   onPageSizeChange={setPageSize}
+ *   pageSizeOptions={[10, 20, 50, 100]}
+ * />
+ * ```
+ */
+export interface PaginationProps extends Pick<PaginationVariants, 'variant' | 'size'> {
+    /** Current page, **1-indexed**. */
+    page: number;
+    /** Items per page. */
+    pageSize: number;
+    /** Total items in the underlying data set (NOT total pages — we compute that). */
+    totalCount: number;
+    /** Fired when the user picks a different page. */
+    onPageChange: (page: number) => void;
+    /**
+     * Fired when the user picks a different page size. Omit (or pass
+     * undefined) to hide the page-size selector.
+     */
+    onPageSizeChange?: (pageSize: number) => void;
+    /**
+     * Options shown in the page-size selector.
+     * @default [10, 20, 50, 100]
+     */
+    pageSizeOptions?: number[];
+    /**
+     * How many page buttons to show on each side of the current page.
+     * @default 1
+     */
+    siblingCount?: number;
+    /**
+     * How many page buttons to always show at the start/end of the
+     * sequence (acts as "boundary"). @default 1
+     */
+    boundaryCount?: number;
+    /**
+     * Show first/last buttons (`«` / `»`). @default true
+     */
+    showFirstLast?: boolean;
+    /**
+     * Show the direct page-jump input (variant=`default` only).
+     * @default true
+     */
+    showJumpInput?: boolean;
+    /**
+     * Disable all interactive elements (kept rendered but inert).
+     */
+    disabled?: boolean;
+    /**
+     * I18n strings. Defaults are English; pass the subset you need
+     * to translate.
+     */
+    labels?: PaginationLabels;
+    /** Root-level Tailwind override. */
+    sx?: string;
+    /** Per-slot overrides. */
+    slotProps?: PaginationSlotProps;
+}
+//# sourceMappingURL=pagination.types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pagination.types.d.ts","sourceRoot":"","sources":["../../../../src/components/Pagination/pagination.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAEnE,MAAM,WAAW,mBAAmB;IAClC,IAAI,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAC9B,OAAO,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IACjC,IAAI,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAC9B,UAAU,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IACpC,YAAY,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IACtC,SAAS,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IACnC,QAAQ,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAClC,gBAAgB,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAC1C,SAAS,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CACpC;AAED;;;GAGG;AACH,MAAM,WAAW,gBAAgB;IAC/B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,WAAW,eAAgB,SAAQ,IAAI,CAAC,kBAAkB,EAAE,SAAS,GAAG,MAAM,CAAC;IACnF,mCAAmC;IACnC,IAAI,EAAE,MAAM,CAAC;IAEb,sBAAsB;IACtB,QAAQ,EAAE,MAAM,CAAC;IAEjB,kFAAkF;IAClF,UAAU,EAAE,MAAM,CAAC;IAEnB,kDAAkD;IAClD,YAAY,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAErC;;;OAGG;IACH,gBAAgB,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;IAE9C;;;OAGG;IACH,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;IAE3B;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IAEvB;;OAEG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IAExB;;;OAGG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IAExB;;OAEG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IAEnB;;;OAGG;IACH,MAAM,CAAC,EAAE,gBAAgB,CAAC;IAE1B,oCAAoC;IACpC,EAAE,CAAC,EAAE,MAAM,CAAC;IAEZ,0BAA0B;IAC1B,SAAS,CAAC,EAAE,mBAAmB,CAAC;CACjC"}

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/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/Table/Table.d.ts

@@ -0,0 +1,24 @@
+import type { TableProps } from './table.types.js';
+/**
+ * Dashforge TW `<Table>` — declarative-first, market-grounded table.
+ *
+ * Design references:
+ *  - Visual: Stripe (clean line dividers, hover row actions, sticky header)
+ *  - Density: Pencil & Paper UX research (compact / comfortable / spacious)
+ *  - A11Y: W3C WAI Table tutorial (semantic `<table>`, scope, aria-sort)
+ *  - Column model: extended from Dashforge MUI Table existing API
+ *
+ * Smart defaults: column types auto-detected → numbers right-aligned
+ * + tabular-nums, dates monospace, booleans center-aligned. Override
+ * via explicit `align` / `monospace` per column.
+ *
+ * State (sort / search / filter / selection / expansion) is internal
+ * by default; pass the controlled prop + matching change handler to
+ * lift state up — same pattern as `<TextField>` value.
+ *
+ * i18n: pass `header: t('users.name')` for column headers; pass
+ * `labels={{ searchPlaceholder: t('...'), ... }}` for internal default
+ * strings.
+ */
+export declare function Table<T extends object>(props: TableProps<T>): import("react/jsx-runtime").JSX.Element | null;
+//# sourceMappingURL=Table.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Table.d.ts","sourceRoot":"","sources":["../../../../src/components/Table/Table.tsx"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EACV,UAAU,EAKX,MAAM,kBAAkB,CAAC;AA0B1B;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,KAAK,CAAC,CAAC,SAAS,MAAM,EAAE,KAAK,EAAE,UAAU,CAAC,CAAC,CAAC,kDAgW3D"}

package/dist/src/components/Table/_internal/getNestedValue.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Walk a dotted path through an object and return the value, or
+ * `undefined` if any segment is missing / nullish.
+ *
+ * Bug fix from the MUI-side Table (Sprint 4.1 motivation): the
+ * existing wrapper typed `field: NestedKeyOf<T>` but performed a
+ * flat `row[col.field]` lookup at runtime — nested keys silently
+ * returned `undefined`. This helper makes the runtime match the
+ * type contract.
+ *
+ * @example
+ * ```ts
+ * getNestedValue({ user: { name: 'Jane' } }, 'user.name')  // 'Jane'
+ * getNestedValue({ user: null }, 'user.name')              // undefined
+ * getNestedValue({}, 'a.b.c')                              // undefined
+ * getNestedValue({ a: { b: 0 } }, 'a.b')                   // 0 (NOT undefined)
+ * ```
+ */
+export declare function getNestedValue<T extends object>(row: T, path: string): unknown;
+//# sourceMappingURL=getNestedValue.d.ts.map

package/dist/src/components/Table/_internal/getNestedValue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getNestedValue.d.ts","sourceRoot":"","sources":["../../../../../src/components/Table/_internal/getNestedValue.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,cAAc,CAAC,CAAC,SAAS,MAAM,EAC7C,GAAG,EAAE,CAAC,EACN,IAAI,EAAE,MAAM,GACX,OAAO,CAUT"}

package/dist/src/components/Table/_internal/useColumnAutoDetect.d.ts

@@ -0,0 +1,45 @@
+import type { TableColumn, TableColumnInferredType } from '../table.types.js';
+/**
+ * Auto-detects the primitive type of each column by scanning the
+ * first non-null value across the supplied rows. Drives smart
+ * defaults for `align` and `monospace` on the cell render path.
+ *
+ * Scans only the first N rows (default 50) for performance — if the
+ * dataset's first 50 rows are unrepresentative, the consumer can
+ * override per-column via explicit `align` / `monospace` props.
+ *
+ * Returns `Map<columnField, inferredType>`.
+ */
+export declare function useColumnAutoDetect<T extends object>(rows: T[], cols: TableColumn<T>[], sampleSize?: number): Map<string, TableColumnInferredType>;
+/**
+ * Resolves the effective `align` for a column, honoring explicit
+ * `col.align` first and falling back to the inferred type.
+ */
+export declare function resolveAlign(col: {
+    align?: 'left' | 'right' | 'center';
+}, inferred: TableColumnInferredType | undefined): 'left' | 'right' | 'center';
+/**
+ * Resolves the effective `tabularNums` flag for a column.
+ *
+ * `tabular-nums` is a `font-variant-numeric` rule that makes every
+ * digit occupy the same width — it does NOT change the font family.
+ * Auto-applied for `number` and `date` columns so currency values
+ * and ISO dates align cleanly. Explicit `col.tabularNums` wins.
+ */
+export declare function resolveTabularNums(col: {
+    tabularNums?: boolean;
+}, inferred: TableColumnInferredType | undefined): boolean;
+/**
+ * Resolves the effective `monospace` flag for a column.
+ *
+ * `font-mono` changes the font FAMILY to a monospace stack, which
+ * would override the consumer's theme `font-sans`. The library
+ * never auto-applies it — only an explicit `col.monospace: true`
+ * opts in. Consumers wanting a custom mono stack configure it
+ * through Tailwind's `theme.extend.fontFamily.mono` in their own
+ * preset (the dashforgePreset does not own the `fontFamily` axis).
+ */
+export declare function resolveMonospace(col: {
+    monospace?: boolean;
+}): boolean;
+//# sourceMappingURL=useColumnAutoDetect.d.ts.map

package/dist/src/components/Table/_internal/useColumnAutoDetect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useColumnAutoDetect.d.ts","sourceRoot":"","sources":["../../../../../src/components/Table/_internal/useColumnAutoDetect.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,uBAAuB,EAAE,MAAM,mBAAmB,CAAC;AAE9E;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,SAAS,MAAM,EAClD,IAAI,EAAE,CAAC,EAAE,EACT,IAAI,EAAE,WAAW,CAAC,CAAC,CAAC,EAAE,EACtB,UAAU,SAAK,GACd,GAAG,CAAC,MAAM,EAAE,uBAAuB,CAAC,CAiBtC;AAcD;;;GAGG;AACH,wBAAgB,YAAY,CAC1B,GAAG,EAAE;IAAE,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,GAAG,QAAQ,CAAA;CAAE,EAC5C,QAAQ,EAAE,uBAAuB,GAAG,SAAS,GAC5C,MAAM,GAAG,OAAO,GAAG,QAAQ,CAU7B;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAChC,GAAG,EAAE;IAAE,WAAW,CAAC,EAAE,OAAO,CAAA;CAAE,EAC9B,QAAQ,EAAE,uBAAuB,GAAG,SAAS,GAC5C,OAAO,CAGT;AAED;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAC9B,GAAG,EAAE;IAAE,SAAS,CAAC,EAAE,OAAO,CAAA;CAAE,GAC3B,OAAO,CAET"}

package/dist/src/components/Table/_internal/useControllableState.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Generic "controllable" state hook — switches between controlled
+ * (via parent-supplied value + setter) and uncontrolled (internal
+ * `useState`).
+ *
+ * - If `controlledValue !== undefined`, the hook is in **controlled**
+ *   mode: the internal state is ignored; the returned setter calls
+ *   `onControlledChange` only.
+ * - Otherwise it's in **uncontrolled** mode: internal `useState`,
+ *   defaulting to `defaultValue`. The optional `onControlledChange`
+ *   is still fired on every change so the parent can react.
+ *
+ * The control mode is determined per-render. Mixing modes (passing
+ * `controlledValue` undefined sometimes) is a consumer bug — we don't
+ * try to "remember" the last mode (React's rules-of-hooks make that
+ * unsafe).
+ */
+export declare function useControllableState<T>(args: {
+    controlledValue: T | undefined;
+    defaultValue: T;
+    onChange?: (value: T) => void;
+}): [T, (next: T | ((prev: T) => T)) => void];
+//# sourceMappingURL=useControllableState.d.ts.map