@dashforge/tw 0.5.0-beta → 0.6.0-beta

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"useControllableState.d.ts","sourceRoot":"","sources":["../../../../../src/components/Table/_internal/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/src/components/Table/_internal/useDebouncedValue.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 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/src/components/Table/_internal/useDebouncedValue.d.ts.map

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

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

@@ -0,0 +1,13 @@
+import type { TableFilterModel } from '../table.types.js';
+/**
+ * Filters `rows` by the per-column filter model. v1 only supports
+ * the `contains` operator (text substring) — additional ops
+ * (`equals`, `in`, `gte`, `lte`, `between`, `before`, `after`)
+ * land in v1-bis once the filter UI surface for each shape is
+ * fleshed out.
+ *
+ * AND semantics across columns: a row must match EVERY active
+ * filter. Within a single filter, the op decides the predicate.
+ */
+export declare function useTableFilter<T extends object>(rows: T[], filterModel: TableFilterModel): T[];
+//# sourceMappingURL=useTableFilter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useTableFilter.d.ts","sourceRoot":"","sources":["../../../../../src/components/Table/_internal/useTableFilter.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAE1D;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAAC,CAAC,SAAS,MAAM,EAC7C,IAAI,EAAE,CAAC,EAAE,EACT,WAAW,EAAE,gBAAgB,GAC5B,CAAC,EAAE,CAkBL"}

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

@@ -0,0 +1,23 @@
+import type { TableColumn } from '../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/src/components/Table/_internal/useTableSearch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTableSearch.d.ts","sourceRoot":"","sources":["../../../../../src/components/Table/_internal/useTableSearch.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAErD;;;;;;;;;;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"}

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

@@ -0,0 +1,25 @@
+import type { TableRowSelectionMode } from '../table.types.js';
+export interface UseTableSelectionResult {
+    selectedRowIds: string[];
+    isSelected: (rowId: string) => boolean;
+    toggleRow: (rowId: string) => void;
+    toggleAll: (allRowIds: string[]) => void;
+    clearSelection: () => void;
+    /** True when EVERY id in `allRowIds` is selected. */
+    isAllSelected: (allRowIds: string[]) => boolean;
+    /** True when at least one (but not all) of `allRowIds` is selected. */
+    isIndeterminate: (allRowIds: string[]) => boolean;
+}
+/**
+ * Selection logic helper. Given the controllable selection state +
+ * the setter (from `useControllableState`), exposes ergonomic
+ * helpers the Table calls from its render path.
+ *
+ *  - `single` mode: at most one row selected. Toggling another
+ *    replaces the previous.
+ *  - `multiple` mode: any subset selectable; toggling adds/removes.
+ *  - `none` mode: every toggle is a no-op (the Table shouldn't
+ *    render the checkbox cells anyway, but this is defensive).
+ */
+export declare function useTableSelection(mode: TableRowSelectionMode, selectedRowIds: string[], setSelectedRowIds: (next: string[] | ((prev: string[]) => string[])) => void): UseTableSelectionResult;
+//# sourceMappingURL=useTableSelection.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useTableSelection.d.ts","sourceRoot":"","sources":["../../../../../src/components/Table/_internal/useTableSelection.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAE/D,MAAM,WAAW,uBAAuB;IACtC,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,UAAU,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC;IACvC,SAAS,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IACnC,SAAS,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,IAAI,CAAC;IACzC,cAAc,EAAE,MAAM,IAAI,CAAC;IAC3B,qDAAqD;IACrD,aAAa,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,OAAO,CAAC;IAChD,uEAAuE;IACvE,eAAe,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,OAAO,CAAC;CACnD;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,qBAAqB,EAC3B,cAAc,EAAE,MAAM,EAAE,EACxB,iBAAiB,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,MAAM,EAAE,CAAC,KAAK,IAAI,GAC3E,uBAAuB,CAqEzB"}

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

@@ -0,0 +1,20 @@
+import type { TableColumn, TableSortModel } from '../table.types.js';
+/**
+ * Applies the `sortModel` to `rows`. Returns a NEW sorted array
+ * (does not mutate input). Stable sort guaranteed by the underlying
+ * `Array.prototype.sort` in modern engines.
+ *
+ * Multi-column sort: items earlier in `sortModel` have higher
+ * precedence. Equal values fall through to the next sort item; if
+ * all sort items tie, the original order is preserved (stable).
+ */
+export declare function useTableSort<T extends object>(rows: T[], cols: TableColumn<T>[], sortModel: TableSortModel): T[];
+/**
+ * Three-state sort cycler: `none` → `asc` → `desc` → `none`.
+ *
+ * Used by the header click handler. Returns the next sort model
+ * to apply, given the current model + the clicked field + whether
+ * the user is multi-sorting (shift key).
+ */
+export declare function cycleSortFor(current: TableSortModel, field: string, multi: boolean): TableSortModel;
+//# sourceMappingURL=useTableSort.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useTableSort.d.ts","sourceRoot":"","sources":["../../../../../src/components/Table/_internal/useTableSort.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,WAAW,EACX,cAAc,EAEf,MAAM,mBAAmB,CAAC;AA+C3B;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAAC,CAAC,SAAS,MAAM,EAC3C,IAAI,EAAE,CAAC,EAAE,EACT,IAAI,EAAE,WAAW,CAAC,CAAC,CAAC,EAAE,EACtB,SAAS,EAAE,cAAc,GACxB,CAAC,EAAE,CA2CL;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAC1B,OAAO,EAAE,cAAc,EACvB,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,OAAO,GACb,cAAc,CAkBhB"}

package/dist/src/components/Table/cells/RenderButton.d.ts

@@ -0,0 +1,13 @@
+import type { MouseEvent, ReactNode } from 'react';
+import type { ButtonProps } from '../../Button/button.types.js';
+export interface RenderButtonProps extends Pick<ButtonProps, 'variant' | 'color' | 'size' | 'disabled' | 'access'> {
+    label: ReactNode;
+    onClick?: (event: MouseEvent<HTMLButtonElement>) => void;
+}
+/**
+ * Inline button cell renderer. Thin wrapper over `<Button>` with
+ * the size narrowed to `sm` by default (table density expects compact
+ * controls).
+ */
+export declare function RenderButton(props: RenderButtonProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=RenderButton.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"RenderButton.d.ts","sourceRoot":"","sources":["../../../../../src/components/Table/cells/RenderButton.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAEnD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAEhE,MAAM,WAAW,iBACf,SAAQ,IAAI,CAAC,WAAW,EAAE,SAAS,GAAG,OAAO,GAAG,MAAM,GAAG,UAAU,GAAG,QAAQ,CAAC;IAC/E,KAAK,EAAE,SAAS,CAAC;IACjB,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,UAAU,CAAC,iBAAiB,CAAC,KAAK,IAAI,CAAC;CAC1D;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,iBAAiB,2CAOpD"}

package/dist/src/components/Table/cells/RenderChip.d.ts

@@ -0,0 +1,80 @@
+import type { ReactNode } from 'react';
+import { type VariantProps } from 'tailwind-variants';
+/**
+ * Internal mini-chip used by the cell renderer library. Not exported
+ * from `@dashforge/tw` as a standalone component (per Sprint 4.1
+ * scope decision — a standalone `<Chip>` may ship in Sprint 5 if
+ * demand emerges).
+ *
+ * Variants:
+ *  - `color`: 7 intents (neutral / primary / success / warning /
+ *    danger / info / secondary)
+ *  - `variant`: `soft` (default) / `solid` / `outline`
+ *  - `size`: `sm` / `md`
+ */
+declare const chipVariants: import("tailwind-variants").TVReturnType<{
+    color: {
+        neutral: string;
+        primary: string;
+        success: string;
+        warning: string;
+        danger: string;
+        info: string;
+        secondary: string;
+    };
+    variant: {
+        soft: string;
+        solid: string;
+        outline: string;
+    };
+    size: {
+        sm: string;
+        md: string;
+    };
+}, undefined, string[], {
+    color: {
+        neutral: string;
+        primary: string;
+        success: string;
+        warning: string;
+        danger: string;
+        info: string;
+        secondary: string;
+    };
+    variant: {
+        soft: string;
+        solid: string;
+        outline: string;
+    };
+    size: {
+        sm: string;
+        md: string;
+    };
+}, undefined, import("tailwind-variants").TVReturnType<{
+    color: {
+        neutral: string;
+        primary: string;
+        success: string;
+        warning: string;
+        danger: string;
+        info: string;
+        secondary: string;
+    };
+    variant: {
+        soft: string;
+        solid: string;
+        outline: string;
+    };
+    size: {
+        sm: string;
+        md: string;
+    };
+}, undefined, string[], unknown, unknown, undefined>>;
+type ChipVariants = VariantProps<typeof chipVariants>;
+export interface RenderChipProps extends ChipVariants {
+    children: ReactNode;
+    className?: string;
+}
+export declare function RenderChip(props: RenderChipProps): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=RenderChip.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"RenderChip.d.ts","sourceRoot":"","sources":["../../../../../src/components/Table/cells/RenderChip.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AACvC,OAAO,EAAM,KAAK,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAG1D;;;;;;;;;;;GAWG;AACH,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qDAsEhB,CAAC;AAEH,KAAK,YAAY,GAAG,YAAY,CAAC,OAAO,YAAY,CAAC,CAAC;AAEtD,MAAM,WAAW,eAAgB,SAAQ,YAAY;IACnD,QAAQ,EAAE,SAAS,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,eAAe,2CAOhD"}

package/dist/src/components/Table/cells/RenderText.d.ts

@@ -0,0 +1,21 @@
+import type { ReactNode } from 'react';
+export interface RenderTextProps {
+    value: ReactNode;
+    /** Truncate to one line with ellipsis on overflow. @default false */
+    truncate?: boolean;
+    /** Secondary text color (less prominent). @default false */
+    muted?: boolean;
+    /** Extra class merged via `tailwind-merge`. */
+    className?: string;
+}
+/**
+ * Plain text cell renderer. Wraps the value in a `<span>` and
+ * optionally truncates on overflow. Use this for the most common
+ * case: render a single string value.
+ *
+ * The Table component does NOT use this by default for plain
+ * string columns — it just renders `{value}` directly. Use
+ * `RenderText` when you need the truncate / muted styling.
+ */
+export declare function RenderText(props: RenderTextProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=RenderText.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"RenderText.d.ts","sourceRoot":"","sources":["../../../../../src/components/Table/cells/RenderText.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAGvC,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,SAAS,CAAC;IACjB,qEAAqE;IACrE,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,4DAA4D;IAC5D,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,+CAA+C;IAC/C,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,eAAe,2CAchD"}

package/dist/src/components/Table/cells/RenderTwoLine.d.ts

@@ -0,0 +1,20 @@
+import type { ReactNode } from 'react';
+export interface RenderTwoLineProps {
+    primary: ReactNode;
+    secondary: ReactNode;
+    className?: string;
+}
+/**
+ * Two-line cell renderer: a bold primary line stacked above a muted
+ * secondary line. Useful for `Name + email`, `Title + ID`, etc.
+ *
+ * Replaces the MUI-side `RenderTwoLineCell` without the magic-number
+ * vertical-align fudges (`mt: 0.8 / 0.2`) — flexbox handles the
+ * vertical layout cleanly.
+ *
+ * Dashforge identity rule: text colors auto-invert via the
+ * `dashforgePreset()` CSS-variable swap. No `dark:` variants needed
+ * on neutral palette.
+ */
+export declare function RenderTwoLine(props: RenderTwoLineProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=RenderTwoLine.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"RenderTwoLine.d.ts","sourceRoot":"","sources":["../../../../../src/components/Table/cells/RenderTwoLine.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAGvC,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,SAAS,CAAC;IACnB,SAAS,EAAE,SAAS,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,kBAAkB,2CAYtD"}

package/dist/src/components/Table/cells/RowActionsMenu.d.ts

@@ -0,0 +1,36 @@
+import { type ReactNode } from 'react';
+import type { AccessRequirement } from '@dashforge/rbac';
+/**
+ * Single action definition for `<RowActionsMenu>`.
+ *
+ * `access` (optional) gates the action via RBAC:
+ *  - `onUnauthorized: 'hide'`     → action not rendered
+ *  - `onUnauthorized: 'disable'`  → action visible, disabled
+ *  - `onUnauthorized: 'readonly'` → action visible, disabled
+ */
+export interface TableRowAction<T> {
+    label: ReactNode;
+    onClick: (row: T) => void;
+    icon?: ReactNode;
+    color?: 'default' | 'danger' | 'warning';
+    disabled?: boolean;
+    access?: AccessRequirement;
+}
+export interface RowActionsMenuProps<T> {
+    row: T;
+    actions: TableRowAction<T>[];
+    /** Custom trigger element. Defaults to a ⋮ icon button. */
+    trigger?: ReactNode;
+    /** Aria-label for the default trigger. */
+    ariaLabel?: string;
+}
+/**
+ * 3-dot row actions menu. Renders a trigger button that opens a
+ * Popover (Sprint 3 component) with a list of action menu items.
+ *
+ * Replaces the MUI-side `RowActions.tsx` (IconButton + Menu) with
+ * the TW equivalents. Per-action RBAC honored: hidden actions are
+ * filtered out, disabled actions render disabled.
+ */
+export declare function RowActionsMenu<T>(props: RowActionsMenuProps<T>): import("react/jsx-runtime").JSX.Element | null;
+//# sourceMappingURL=RowActionsMenu.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"RowActionsMenu.d.ts","sourceRoot":"","sources":["../../../../../src/components/Table/cells/RowActionsMenu.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAY,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AACjD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAKzD;;;;;;;GAOG;AACH,MAAM,WAAW,cAAc,CAAC,CAAC;IAC/B,KAAK,EAAE,SAAS,CAAC;IACjB,OAAO,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,IAAI,CAAC;IAC1B,IAAI,CAAC,EAAE,SAAS,CAAC;IACjB,KAAK,CAAC,EAAE,SAAS,GAAG,QAAQ,GAAG,SAAS,CAAC;IACzC,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,MAAM,CAAC,EAAE,iBAAiB,CAAC;CAC5B;AAED,MAAM,WAAW,mBAAmB,CAAC,CAAC;IACpC,GAAG,EAAE,CAAC,CAAC;IACP,OAAO,EAAE,cAAc,CAAC,CAAC,CAAC,EAAE,CAAC;IAC7B,2DAA2D;IAC3D,OAAO,CAAC,EAAE,SAAS,CAAC;IACpB,0CAA0C;IAC1C,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,KAAK,EAAE,mBAAmB,CAAC,CAAC,CAAC,kDA8D9D"}

package/dist/src/components/Table/cells/index.d.ts

@@ -0,0 +1,11 @@
+export { RenderText } from './RenderText.js';
+export type { RenderTextProps } from './RenderText.js';
+export { RenderTwoLine } from './RenderTwoLine.js';
+export type { RenderTwoLineProps } from './RenderTwoLine.js';
+export { RenderChip } from './RenderChip.js';
+export type { RenderChipProps } from './RenderChip.js';
+export { RenderButton } from './RenderButton.js';
+export type { RenderButtonProps } from './RenderButton.js';
+export { RowActionsMenu } from './RowActionsMenu.js';
+export type { RowActionsMenuProps, TableRowAction } from './RowActionsMenu.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/components/Table/cells/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,YAAY,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAEvD,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,YAAY,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAE7D,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,YAAY,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAEvD,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,YAAY,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAE3D,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACrD,YAAY,EAAE,mBAAmB,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC"}