@dashforge/tw 1.0.0 → 1.1.0

package/dist/components/TopBar/topBar.variants.d.ts

@@ -1,79 +0,0 @@
-import { type VariantProps } from 'tailwind-variants';
-/**
- * Tailwind-variants recipe for `<TopBar>`.
- *
- * Slots:
- *   - `root`   — outer `<header>` (or `<div>` with `asDiv`)
- *   - `start`  — left region (shrink-to-content)
- *   - `center` — middle region (grows to fill)
- *   - `end`    — right region (shrink-to-content)
- */
-export declare const topBarVariants: import("tailwind-variants").TVReturnType<{
-    height: {
-        sm: {
-            root: string;
-        };
-        md: {
-            root: string;
-        };
-        lg: {
-            root: string;
-        };
-    };
-    sticky: {
-        true: {
-            root: string;
-        };
-    };
-}, {
-    root: string[];
-    start: string;
-    center: string;
-    end: string;
-}, undefined, {
-    height: {
-        sm: {
-            root: string;
-        };
-        md: {
-            root: string;
-        };
-        lg: {
-            root: string;
-        };
-    };
-    sticky: {
-        true: {
-            root: string;
-        };
-    };
-}, {
-    root: string[];
-    start: string;
-    center: string;
-    end: string;
-}, import("tailwind-variants").TVReturnType<{
-    height: {
-        sm: {
-            root: string;
-        };
-        md: {
-            root: string;
-        };
-        lg: {
-            root: string;
-        };
-    };
-    sticky: {
-        true: {
-            root: string;
-        };
-    };
-}, {
-    root: string[];
-    start: string;
-    center: string;
-    end: string;
-}, undefined, unknown, unknown, undefined>>;
-export type TopBarVariants = VariantProps<typeof topBarVariants>;
-//# sourceMappingURL=topBar.variants.d.ts.map

package/dist/components/TopBar/topBar.variants.d.ts.map

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

package/dist/components/Typography/Typography.d.ts

@@ -1,42 +0,0 @@
-import type { TypographyProps } from './typography.types.js';
-/**
- * `<Typography>` — semantic typed text, the foundation of every readable
- * surface in @dashforge/tw.
- *
- * Why this exists:
- *   Tailwind ships a typographic scale (`text-xl`, `font-bold`,
- *   `leading-relaxed`) but leaves the SEMANTIC HTML tag and the
- *   intent-coloured palette to the consumer. That's fine for one-off
- *   marketing surfaces, but at app scale it means every `<h2>` and every
- *   body paragraph re-derives its own utility chain — and they drift.
- *
- *   Typography moves that decision into a typed prop set: the visual
- *   scale, the intent colour, the alignment, the truncation all live in
- *   `tailwind-variants` and resolve to the same utility chain everywhere
- *   in the app. The default HTML tag is inferred from `variant` so the
- *   semantic layer follows the visual layer; `as` and `asChild` are the
- *   two escape hatches when you need something else.
- *
- * Layering:
- *   • Sits BENEATH every component that renders text — `<Button>`'s
- *     label, `<TextField>`'s helper text, MDX prose in our own docs.
- *   • Composes ON TOP of `@dashforge/tw-tokens` colour scales (so
- *     `color="primary"` paints `text-primary-700` in light, `-400` in dark,
- *     reactive to `setMode()`).
- *   • Polymorphic via Radix Slot — pairs cleanly with router `<Link>`,
- *     `<button>`, or `<a>` without injecting an extra wrapper element.
- *
- * Polymorphism rules — `as` vs `asChild`:
- *   • `as` swaps the rendered tag (we still render the element ourselves).
- *   • `asChild` removes our element entirely — the single React child
- *     becomes the rendered tag, with our className/ref merged onto it.
- *     This is the Radix Slot pattern; use when you need a router Link
- *     to style as a heading.
- *   When BOTH are passed, `asChild` wins. We considered making this a
- *   compile-time error via discriminated unions, but the API surface
- *   already has 8 axes and adding one more dimension to the props type
- *   would inflate IntelliSense suggestions for marginal benefit. The
- *   runtime preference is documented; the test asserts it.
- */
-export declare const Typography: import("react").ForwardRefExoticComponent<TypographyProps & import("react").RefAttributes<HTMLElement>>;
-//# sourceMappingURL=Typography.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"Typography.d.ts","sourceRoot":"","sources":["../../../src/components/Typography/Typography.tsx"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AA0B7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,eAAO,MAAM,UAAU,yGAwCtB,CAAC"}

package/dist/components/Typography/typography.types.d.ts

@@ -1,61 +0,0 @@
-import type { ElementType, HTMLAttributes } from 'react';
-import type { TypographyVariants } from './typography.variants.js';
-/**
- * Props for `<Typography>`.
- *
- * Composition with native `HTMLAttributes`:
- *   • `className` is omitted in favour of `sx` (string of utility classes)
- *     — same convention as Button/TextField/Checkbox/Switch in this
- *     package. `sx` is merged via `tailwind-merge`, so the consumer's
- *     classes always win over variant defaults.
- *   • `color` is omitted because the native HTML attribute (the
- *     deprecated `color="red"` from HTML4) collides with our intent
- *     prop — TypeScript would otherwise widen to a confusing union.
- *
- * Variant axes picked from `TypographyVariants`:
- *   • `variant`  — the type scale (h1–h6, subtitle1/2, body1/2, caption, overline)
- *   • `color`    — the intent (primary, secondary, success, warning, danger, info, neutral, muted, inherit)
- *   • `weight`   — overrides the variant's default font-weight
- *   • `align`    — text-align
- *   • `truncate` — one-line ellipsis
- *   • `noWrap`   — one-line without ellipsis
- *   • `gutterBottom` — adds mb-3 (mirror of MUI's same prop)
- *
- * Polymorphism:
- *   • `as` — override the HTML tag while keeping the variant's visual
- *            style (e.g. `<Typography variant="h1" as="h2">` renders an
- *            `<h2>` styled like h1 — useful when the semantic heading
- *            level matters more than the type scale).
- *   • `asChild` — render as the single child element via Radix Slot
- *            (so the styles paint onto a `<Link>`, `<a>`, etc.).
- *            Mutually exclusive with `as` — see component header for
- *            the rationale.
- */
-export interface TypographyProps extends Omit<HTMLAttributes<HTMLElement>, 'className' | 'color'>, Pick<TypographyVariants, 'variant' | 'color' | 'weight' | 'align' | 'truncate' | 'noWrap' | 'gutterBottom'> {
-    /**
-     * Override the HTML tag. Defaults to a sensible mapping per variant
-     * (h1→h1, …, body1→p, caption→span, overline→span). Use when the
-     * semantic heading level should differ from the visual scale —
-     * e.g. a "hero" rendered as an `<h2>` but styled like `h1`.
-     *
-     * Ignored when `asChild` is true.
-     */
-    as?: ElementType;
-    /**
-     * Render via Radix `Slot` — the Typography styles paint onto the
-     * single React child instead of wrapping it in our own tag. Useful
-     * for `<Typography asChild><Link>...</Link></Typography>` to get a
-     * styled router link with no extra DOM.
-     *
-     * Mutually exclusive with `as` (when both are passed, `asChild` wins
-     * and `as` is ignored — see Typography.tsx for the reason).
-     */
-    asChild?: boolean;
-    /**
-     * Utility classes appended to the variant chain. Resolved via
-     * `tailwind-merge` so the consumer's classes always win over the
-     * variant defaults — e.g. `sx="text-pink-500"` overrides `color="primary"`.
-     */
-    sx?: string;
-}
-//# sourceMappingURL=typography.types.d.ts.map

package/dist/components/Typography/typography.types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"typography.types.d.ts","sourceRoot":"","sources":["../../../src/components/Typography/typography.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,OAAO,CAAC;AACzD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAEnE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,MAAM,WAAW,eACf,SAAQ,IAAI,CAAC,cAAc,CAAC,WAAW,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,EACxD,IAAI,CAAC,kBAAkB,EAAE,SAAS,GAAG,OAAO,GAAG,QAAQ,GAAG,OAAO,GAAG,UAAU,GAAG,QAAQ,GAAG,cAAc,CAAC;IACnH;;;;;;;OAOG;IACH,EAAE,CAAC,EAAE,WAAW,CAAC;IAEjB;;;;;;;;OAQG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAElB;;;;OAIG;IACH,EAAE,CAAC,EAAE,MAAM,CAAC;CACb"}

package/dist/components/Typography/typography.variants.d.ts

@@ -1,167 +0,0 @@
-import { type VariantProps } from 'tailwind-variants';
-/**
- * `typographyVariants` — the full type scale for the @dashforge/tw library.
- *
- * Mirrors the MUI Typography variant set (h1–h6 · subtitle1/2 · body1/2 ·
- * caption · overline) so the mental model carries over for developers
- * moving between the two ecosystems. Each variant baseline maps to a
- * Tailwind utility chain that resolves through the @dashforge/tw-tokens
- * scale (so the visual stays in sync with the rest of the system when the
- * token theme is patched).
- *
- * Variant axes are intentionally ORTHOGONAL — `variant` chooses the type
- * scale, `weight` overrides the variant's default weight (useful for "h2
- * but lighter"), `color` picks the intent, `align` picks the axis. They
- * never collide, so consumers can mix them freely.
- *
- * Two boolean flags (`truncate`, `noWrap`) encode the most common one-line
- * patterns; `gutterBottom` adds the conventional bottom margin used when a
- * heading precedes a paragraph block (mirror of MUI's same flag).
- */
-export declare const typographyVariants: import("tailwind-variants").TVReturnType<{
-    variant: {
-        h1: string;
-        h2: string;
-        h3: string;
-        h4: string;
-        h5: string;
-        h6: string;
-        subtitle1: string;
-        subtitle2: string;
-        body1: string;
-        body2: string;
-        caption: string;
-        overline: string;
-    };
-    color: {
-        inherit: string;
-        primary: string;
-        secondary: string;
-        success: string;
-        warning: string;
-        danger: string;
-        info: string;
-        neutral: string;
-        muted: string;
-    };
-    weight: {
-        normal: string;
-        medium: string;
-        semibold: string;
-        bold: string;
-        extrabold: string;
-    };
-    align: {
-        left: string;
-        center: string;
-        right: string;
-        justify: string;
-    };
-    truncate: {
-        true: string;
-    };
-    noWrap: {
-        true: string;
-    };
-    gutterBottom: {
-        true: string;
-    };
-}, undefined, "text-inherit", {
-    variant: {
-        h1: string;
-        h2: string;
-        h3: string;
-        h4: string;
-        h5: string;
-        h6: string;
-        subtitle1: string;
-        subtitle2: string;
-        body1: string;
-        body2: string;
-        caption: string;
-        overline: string;
-    };
-    color: {
-        inherit: string;
-        primary: string;
-        secondary: string;
-        success: string;
-        warning: string;
-        danger: string;
-        info: string;
-        neutral: string;
-        muted: string;
-    };
-    weight: {
-        normal: string;
-        medium: string;
-        semibold: string;
-        bold: string;
-        extrabold: string;
-    };
-    align: {
-        left: string;
-        center: string;
-        right: string;
-        justify: string;
-    };
-    truncate: {
-        true: string;
-    };
-    noWrap: {
-        true: string;
-    };
-    gutterBottom: {
-        true: string;
-    };
-}, undefined, import("tailwind-variants").TVReturnType<{
-    variant: {
-        h1: string;
-        h2: string;
-        h3: string;
-        h4: string;
-        h5: string;
-        h6: string;
-        subtitle1: string;
-        subtitle2: string;
-        body1: string;
-        body2: string;
-        caption: string;
-        overline: string;
-    };
-    color: {
-        inherit: string;
-        primary: string;
-        secondary: string;
-        success: string;
-        warning: string;
-        danger: string;
-        info: string;
-        neutral: string;
-        muted: string;
-    };
-    weight: {
-        normal: string;
-        medium: string;
-        semibold: string;
-        bold: string;
-        extrabold: string;
-    };
-    align: {
-        left: string;
-        center: string;
-        right: string;
-        justify: string;
-    };
-    truncate: {
-        true: string;
-    };
-    noWrap: {
-        true: string;
-    };
-    gutterBottom: {
-        true: string;
-    };
-}, undefined, "text-inherit", unknown, unknown, undefined>>;
-export type TypographyVariants = VariantProps<typeof typographyVariants>;
-//# sourceMappingURL=typography.variants.d.ts.map

package/dist/components/Typography/typography.variants.d.ts.map

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

package/dist/components/VisuallyHidden/VisuallyHidden.d.ts

@@ -1,42 +0,0 @@
-import type { VisuallyHiddenProps } from './visuallyHidden.types.js';
-/**
- * `<VisuallyHidden>` — the accessibility primitive.
- *
- * Hides children from sighted users (zero pixels rendered, no layout
- * impact) while keeping them in the accessibility tree. Screen readers
- * speak the content; voice control software uses it for click targets;
- * keyboard users see nothing — same as if it weren't there.
- *
- * Implementation: Tailwind's built-in `sr-only` utility, which expands to:
- *
- *   .sr-only {
- *     position: absolute;
- *     width: 1px;
- *     height: 1px;
- *     padding: 0;
- *     margin: -1px;
- *     overflow: hidden;
- *     clip: rect(0,0,0,0);
- *     white-space: nowrap;
- *     border-width: 0;
- *   }
- *
- * This is the canonical "visually-hidden but screen-reader-accessible"
- * pattern, also known as the WebAIM clip technique. Critically:
- *
- *   • NOT `display: none` (removes from a11y tree)
- *   • NOT `visibility: hidden` (also removes from a11y tree)
- *   • NOT `opacity: 0` (technically still rendered, doesn't help AT)
- *   • NOT `width/height: 0` (collapses, some AT skips it)
- *
- * Default tag is `<span>` (inline) — the 99% case is "label inside a
- * button or link". For block content, override with `as="div"`, but
- * be aware nesting block inside inline is invalid HTML.
- *
- * The component is intentionally tiny (~30 LoC total): one className,
- * one tag. The value is the COMPONENT NAME — `<VisuallyHidden>` reads
- * as an intentional a11y decision in code review, while
- * `className="sr-only"` looks like a typo or a forgotten utility.
- */
-export declare const VisuallyHidden: import("react").ForwardRefExoticComponent<VisuallyHiddenProps & import("react").RefAttributes<HTMLElement>>;
-//# sourceMappingURL=VisuallyHidden.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"VisuallyHidden.d.ts","sourceRoot":"","sources":["../../../src/components/VisuallyHidden/VisuallyHidden.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAErE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,eAAO,MAAM,cAAc,6GAa1B,CAAC"}

package/dist/components/VisuallyHidden/visuallyHidden.types.d.ts

@@ -1,42 +0,0 @@
-import type { ElementType, HTMLAttributes, ReactElement } from 'react';
-/**
- * Props for `<VisuallyHidden>` — the a11y primitive.
- *
- * Hides content visually (zero pixels rendered) while keeping it
- * accessible to assistive technology (screen readers, voice control).
- * The canonical use case: icon-only buttons that need an audible label
- * for non-visual users.
- *
- *   <button>
- *     <CloseIcon />
- *     <VisuallyHidden>Close dialog</VisuallyHidden>
- *   </button>
- *
- * Implementation uses Tailwind's `sr-only` utility, which sets
- * `position: absolute; width: 1px; height: 1px; padding: 0;
- * margin: -1px; overflow: hidden; clip: rect(0,0,0,0);
- * white-space: nowrap; border-width: 0;` — the canonical
- * "visually-hidden but screen-reader-accessible" pattern. Better
- * than `display: none` (removes from a11y tree) and better than
- * `visibility: hidden` (also removes from a11y tree).
- */
-export interface VisuallyHiddenProps extends Omit<HTMLAttributes<HTMLElement>, 'className'> {
-    /**
-     * The text or markup hidden from sighted users but read by AT.
-     * Most often a string label.
-     */
-    children?: ReactElement | string | number;
-    /**
-     * Override the rendered HTML tag. Defaults to `'span'` — inline
-     * placement is the most common case (label inside a button or link).
-     * Use `as="div"` when the hidden content is block-level, but be
-     * aware: nesting a block inside an inline parent is invalid HTML.
-     */
-    as?: ElementType;
-    /**
-     * Utility classes appended to `sr-only`. RARELY needed for this
-     * primitive (it's just hidden text) — kept for API parity.
-     */
-    sx?: string;
-}
-//# sourceMappingURL=visuallyHidden.types.d.ts.map

package/dist/components/VisuallyHidden/visuallyHidden.types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"visuallyHidden.types.d.ts","sourceRoot":"","sources":["../../../src/components/VisuallyHidden/visuallyHidden.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,OAAO,CAAC;AAEvE;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,WAAW,mBACf,SAAQ,IAAI,CAAC,cAAc,CAAC,WAAW,CAAC,EAAE,WAAW,CAAC;IACtD;;;OAGG;IACH,QAAQ,CAAC,EAAE,YAAY,GAAG,MAAM,GAAG,MAAM,CAAC;IAE1C;;;;;OAKG;IACH,EAAE,CAAC,EAAE,WAAW,CAAC;IAEjB;;;OAGG;IACH,EAAE,CAAC,EAAE,MAAM,CAAC;CACb"}

package/dist/components/_shared/data/getNestedValue.d.ts

@@ -1,20 +0,0 @@
-/**
- * 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/components/_shared/data/getNestedValue.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"getNestedValue.d.ts","sourceRoot":"","sources":["../../../../src/components/_shared/data/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/components/_shared/data/useColumnAutoDetect.d.ts

@@ -1,45 +0,0 @@
-import type { TableColumn, TableColumnInferredType } from '../../Table/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/components/_shared/data/useColumnAutoDetect.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useColumnAutoDetect.d.ts","sourceRoot":"","sources":["../../../../src/components/_shared/data/useColumnAutoDetect.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,uBAAuB,EAAE,MAAM,4BAA4B,CAAC;AAEvF;;;;;;;;;;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/components/_shared/data/useControllableState.d.ts

@@ -1,23 +0,0 @@
-/**
- * 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

package/dist/components/_shared/data/useControllableState.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useControllableState.d.ts","sourceRoot":"","sources":["../../../../src/components/_shared/data/useControllableState.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,IAAI,EAAE;IAC5C,eAAe,EAAE,CAAC,GAAG,SAAS,CAAC;IAC/B,YAAY,EAAE,CAAC,CAAC;IAChB,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CAAC;CAC/B,GAAG,CAAC,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC,KAAK,IAAI,CAAC,CAwB5C"}

package/dist/components/_shared/data/useDebouncedValue.d.ts

@@ -1,10 +0,0 @@
-/**
- * Returns a debounced version of `value` — only updates after `delayMs`
- * of no further changes. Used by the search input so we don't re-filter
- * the entire row set on every keystroke.
- *
- * `delayMs <= 0` short-circuits to the input value (no debounce —
- * useful for tests).
- */
-export declare function useDebouncedValue<T>(value: T, delayMs: number): T;
-//# sourceMappingURL=useDebouncedValue.d.ts.map

package/dist/components/_shared/data/useDebouncedValue.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useDebouncedValue.d.ts","sourceRoot":"","sources":["../../../../src/components/_shared/data/useDebouncedValue.ts"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,OAAO,EAAE,MAAM,GAAG,CAAC,CAajE"}

package/dist/components/_shared/data/useTableFilter.d.ts

@@ -1,36 +0,0 @@
-import type { TableFilterModel } from '../../Table/table.types.js';
-/**
- * Coerce a value to a number for range comparison. Returns
- * `null` if not coercible.
- */
-declare function toNumber(value: unknown): number | null;
-/**
- * Coerce a value to a Date's epoch ms for date-range comparison.
- * Accepts `Date` instances + ISO 8601 strings. Returns `null` if
- * not coercible.
- */
-declare function toDateMs(value: unknown): number | null;
-/**
- * Test one row × one filter. Returns `true` if the row passes the
- * filter. The operator decides the predicate:
- *
- *  - `contains` → substring match on stringified value (text filter)
- *  - `equals` → strict equality (boolean filter mostly)
- *  - `between` → `value: [min, max]` tuple. Each end can be `null`
- *    for an open range. Used by number range + date range filters.
- *
- * Empty filter is a no-op (passes every row).
- */
-declare function passesFilter(rowValue: unknown, op: string, filterValue: unknown): boolean;
-/**
- * Filters `rows` by the per-column filter model. AND semantics
- * across columns — a row must pass EVERY active filter.
- *
- * Each filter item specifies an `op` (`'contains'` / `'equals'` /
- * `'between'`) and a `value` whose shape matches the operator
- * (string for contains; primitive for equals; `[min, max]` tuple
- * for between).
- */
-export declare function useTableFilter<T extends object>(rows: T[], filterModel: TableFilterModel): T[];
-export { passesFilter, toNumber, toDateMs };
-//# sourceMappingURL=useTableFilter.d.ts.map

package/dist/components/_shared/data/useTableFilter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useTableFilter.d.ts","sourceRoot":"","sources":["../../../../src/components/_shared/data/useTableFilter.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAEnE;;;GAGG;AACH,iBAAS,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAS/C;AAED;;;;GAIG;AACH,iBAAS,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAS/C;AAED;;;;;;;;;;GAUG;AACH,iBAAS,YAAY,CAAC,QAAQ,EAAE,OAAO,EAAE,EAAE,EAAE,MAAM,EAAE,WAAW,EAAE,OAAO,GAAG,OAAO,CA2ClF;AAED;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,CAAC,SAAS,MAAM,EAC7C,IAAI,EAAE,CAAC,EAAE,EACT,WAAW,EAAE,gBAAgB,GAC5B,CAAC,EAAE,CAUL;AAGD,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAE,QAAQ,EAAE,CAAC"}

package/dist/components/_shared/data/useTableSearch.d.ts

@@ -1,23 +0,0 @@
-import type { TableColumn } from '../../Table/table.types.js';
-/**
- * Stringify any value into a search-comparable form. Handles all
- * the edge cases that bit the MUI-side Table:
- *
- *   - `null` / `undefined`      → `''`
- *   - `string`                  → as-is
- *   - `number` / `bigint`       → `String(value)`
- *   - `boolean`                 → `'true'` / `'false'`
- *   - `Date`                    → ISO 8601
- *   - `Array` / object          → `JSON.stringify` (best effort)
- */
-export declare function stringifyForSearch(value: unknown): string;
-/**
- * Filters `rows` by `query` against the columns flagged
- * `searchable: true`. Empty / whitespace-only query is a no-op
- * (returns the original rows).
- *
- * Case-insensitive substring match. The caller is responsible for
- * debouncing the input (use `useDebouncedValue`).
- */
-export declare function useTableSearch<T extends object>(rows: T[], cols: TableColumn<T>[], query: string): T[];
-//# sourceMappingURL=useTableSearch.d.ts.map

package/dist/components/_shared/data/useTableSearch.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useTableSearch.d.ts","sourceRoot":"","sources":["../../../../src/components/_shared/data/useTableSearch.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAE9D;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAqBzD;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,CAAC,SAAS,MAAM,EAC7C,IAAI,EAAE,CAAC,EAAE,EACT,IAAI,EAAE,WAAW,CAAC,CAAC,CAAC,EAAE,EACtB,KAAK,EAAE,MAAM,GACZ,CAAC,EAAE,CAeL"}