@dashforge/tw 0.11.0-beta → 1.0.0

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

@@ -0,0 +1,61 @@
+import type { ElementType, HTMLAttributes, ReactNode } from 'react';
+import type { StackVariants } from './stack.variants.js';
+/**
+ * Props for `<Stack>` — flex container 1D, the layout primitive.
+ *
+ * Axes:
+ *   • direction              — flex-direction (default 'col')
+ *   • align                  — items-* (cross-axis)
+ *   • justify                — justify-* (main-axis)
+ *   • gap                    — token-scale spacing step
+ *   • wrap                   — flex-wrap
+ *   • fullWidth/fullHeight   — w-full / h-full
+ *   • divider                — node rendered N-1 times between children
+ *
+ * Polymorphism:
+ *   • as            — override the HTML tag (default 'div')
+ *   • asChild       — render via Radix Slot onto the single child
+ *
+ * What Stack does NOT do (route to other primitives):
+ *   • Surface chrome (border, bg, shadow)   → wrap in <Box>
+ *   • 2D layout (rows AND columns)          → use <Grid>
+ *   • Text styling                          → <Typography>
+ */
+export interface StackProps extends Omit<HTMLAttributes<HTMLDivElement>, 'className'>, Pick<StackVariants, 'direction' | 'align' | 'justify' | 'gap' | 'wrap' | 'fullWidth' | 'fullHeight'> {
+    /**
+     * Node rendered N-1 times BETWEEN children — mirror of MUI Stack's
+     * divider prop. Useful for visual separators (a `<hr>`, a thin
+     * `<Box variant="outlined" sx="h-px border-0 border-t">`, an
+     * `<svg>` glyph) that need to follow the flex direction.
+     *
+     * The node is cloned for each insertion via `cloneElement`; pass a
+     * stable element (not a function) for best React reconciliation.
+     * `React.Children.toArray` flattens fragments before the walk, so
+     * `<Stack divider={...}><><...></></Stack>` works as expected.
+     */
+    divider?: ReactNode;
+    /**
+     * Override the rendered HTML tag. Defaults to `'div'`. Use when the
+     * Stack also has semantic meaning — `<Stack as="nav">` for a nav
+     * bar, `<Stack as="ul">` for a list (children become `<li>` via
+     * native HTML, not by us).
+     *
+     * Ignored when `asChild` is true.
+     */
+    as?: ElementType;
+    /**
+     * Render via Radix `Slot` — the Stack styles paint onto the single
+     * React child instead of wrapping it. Mutually exclusive with `as`
+     * (when both are passed, `asChild` wins). The `divider` prop is
+     * ignored when `asChild` is true (the Slot pattern wraps a single
+     * node, so the N-1 insertion logic has no place to act).
+     */
+    asChild?: boolean;
+    /**
+     * Utility classes appended to the variant chain. Resolved via
+     * `tailwind-merge` so the consumer's classes always win over the
+     * variant defaults.
+     */
+    sx?: string;
+}
+//# sourceMappingURL=stack.types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"stack.types.d.ts","sourceRoot":"","sources":["../../../src/components/Stack/stack.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AACpE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEzD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,WAAW,UACf,SAAQ,IAAI,CAAC,cAAc,CAAC,cAAc,CAAC,EAAE,WAAW,CAAC,EACjD,IAAI,CAAC,aAAa,EAChB,WAAW,GAAG,OAAO,GAAG,SAAS,GAAG,KAAK,GAAG,MAAM,GAChD,WAAW,GAAG,YAAY,CAAC;IACvC;;;;;;;;;;OAUG;IACH,OAAO,CAAC,EAAE,SAAS,CAAC;IAEpB;;;;;;;OAOG;IACH,EAAE,CAAC,EAAE,WAAW,CAAC;IAEjB;;;;;;OAMG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAElB;;;;OAIG;IACH,EAAE,CAAC,EAAE,MAAM,CAAC;CACb"}

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

@@ -0,0 +1,163 @@
+import { type VariantProps } from 'tailwind-variants';
+/**
+ * `stackVariants` — flex container 1D, the layout primitive of @dashforge/tw.
+ *
+ * Architectural role (planned with the user — F9 deep dive):
+ *
+ *   Stack is the ONLY way to do flex in this library. Box is the
+ *   surface (border / bg / shadow); Stack is the arrangement (direction
+ *   / align / justify / gap). Two primitives, two responsibilities,
+ *   zero overlap.
+ *
+ *   This rules out the MUI failure mode where every `<Box display="flex"
+ *   gap={2}>` quietly becomes the de-facto flex container, drowning
+ *   the surface vs layout distinction. Here, if you see `<Stack>` in
+ *   the JSX, you KNOW it's flex; if you see `<Box>`, you KNOW it's
+ *   not. The component name carries the intent.
+ *
+ * Axes:
+ *   • direction         — row / col (+ reverse variants)
+ *   • align / justify   — cross-axis / main-axis alignment
+ *   • gap               — token-scale step (mirror Box spacing scale)
+ *   • wrap              — flex-wrap
+ *   • divider           — runtime-only (handled in Stack.tsx, not here)
+ *
+ * Sizing (`fullWidth`, `fullHeight`) is duplicated from Box because
+ * Stack often plays the role of a full-width strip / full-height
+ * column — re-typing `sx="w-full"` every time would be friction.
+ */
+export declare const stackVariants: import("tailwind-variants").TVReturnType<{
+    direction: {
+        row: string;
+        col: string;
+        'row-reverse': string;
+        'col-reverse': string;
+    };
+    align: {
+        start: string;
+        center: string;
+        end: string;
+        stretch: string;
+        baseline: string;
+    };
+    justify: {
+        start: string;
+        center: string;
+        end: string;
+        between: string;
+        around: string;
+        evenly: string;
+    };
+    gap: {
+        0: string;
+        '0.5': string;
+        1: string;
+        2: string;
+        3: string;
+        4: string;
+        6: string;
+        8: string;
+        12: string;
+        16: string;
+        24: string;
+    };
+    wrap: {
+        true: string;
+    };
+    fullWidth: {
+        true: string;
+    };
+    fullHeight: {
+        true: string;
+    };
+}, undefined, "flex", {
+    direction: {
+        row: string;
+        col: string;
+        'row-reverse': string;
+        'col-reverse': string;
+    };
+    align: {
+        start: string;
+        center: string;
+        end: string;
+        stretch: string;
+        baseline: string;
+    };
+    justify: {
+        start: string;
+        center: string;
+        end: string;
+        between: string;
+        around: string;
+        evenly: string;
+    };
+    gap: {
+        0: string;
+        '0.5': string;
+        1: string;
+        2: string;
+        3: string;
+        4: string;
+        6: string;
+        8: string;
+        12: string;
+        16: string;
+        24: string;
+    };
+    wrap: {
+        true: string;
+    };
+    fullWidth: {
+        true: string;
+    };
+    fullHeight: {
+        true: string;
+    };
+}, undefined, import("tailwind-variants").TVReturnType<{
+    direction: {
+        row: string;
+        col: string;
+        'row-reverse': string;
+        'col-reverse': string;
+    };
+    align: {
+        start: string;
+        center: string;
+        end: string;
+        stretch: string;
+        baseline: string;
+    };
+    justify: {
+        start: string;
+        center: string;
+        end: string;
+        between: string;
+        around: string;
+        evenly: string;
+    };
+    gap: {
+        0: string;
+        '0.5': string;
+        1: string;
+        2: string;
+        3: string;
+        4: string;
+        6: string;
+        8: string;
+        12: string;
+        16: string;
+        24: string;
+    };
+    wrap: {
+        true: string;
+    };
+    fullWidth: {
+        true: string;
+    };
+    fullHeight: {
+        true: string;
+    };
+}, undefined, "flex", unknown, unknown, undefined>>;
+export type StackVariants = VariantProps<typeof stackVariants>;
+//# sourceMappingURL=stack.variants.d.ts.map

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

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

package/dist/components/Switch/Switch.d.ts

@@ -0,0 +1,15 @@
+import type { SwitchProps } from './switch.types.js';
+/**
+ * Dashforge TW Switch — bridge-integrated toggle.
+ *
+ * Implementation mirrors `<Checkbox>` (same 8-step bridge integration
+ * pattern, same StrictMode-safe unregister, same controlled-vs-
+ * uncontrolled Radix props logic) — the only differences are:
+ *
+ *  - Renders Radix `Switch.Root` + `Switch.Thumb` instead of `Checkbox`.
+ *  - No indicator icon (the thumb position is the visual state).
+ *  - Variants drive both control track dimensions AND the thumb
+ *    translate-x distance so the knob lands flush at each end.
+ */
+export declare function Switch(props: SwitchProps): import("react/jsx-runtime").JSX.Element | null;
+//# sourceMappingURL=Switch.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Switch.d.ts","sourceRoot":"","sources":["../../../src/components/Switch/Switch.tsx"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAErD;;;;;;;;;;;GAWG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,WAAW,kDAsIxC"}

package/dist/components/Switch/switch.types.d.ts

@@ -0,0 +1,47 @@
+import type { ReactNode } from 'react';
+import type { AccessRequirement } from '@dashforge/rbac';
+import type { Engine } from '@dashforge/ui-core';
+import type { SwitchVariants } from './switch.variants.js';
+export interface SwitchSlotProps {
+    root?: {
+        className?: string;
+    };
+    control?: {
+        className?: string;
+    };
+    thumb?: {
+        className?: string;
+    };
+    label?: {
+        className?: string;
+    };
+    helperText?: {
+        className?: string;
+    };
+    errorText?: {
+        className?: string;
+    };
+}
+/**
+ * Props for the Dashforge TW `<Switch>` component.
+ *
+ * Mirrors the bridge contract of `@dashforge/ui/Switch` (MUI). Same
+ * `name` / `rules` / `visibleWhen` / `access` semantics, same
+ * validation gating. Renders through Radix `Switch.Root` + `Switch.Thumb`.
+ */
+export interface SwitchProps extends Pick<SwitchVariants, 'size'> {
+    name: string;
+    label?: ReactNode;
+    rules?: unknown;
+    visibleWhen?: (engine: Engine) => boolean;
+    checked?: boolean;
+    defaultChecked?: boolean;
+    disabled?: boolean;
+    helperText?: ReactNode;
+    error?: boolean;
+    access?: AccessRequirement;
+    sx?: string;
+    slotProps?: SwitchSlotProps;
+    onCheckedChange?: (checked: boolean) => void;
+}
+//# sourceMappingURL=switch.types.d.ts.map

package/dist/components/Switch/switch.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"switch.types.d.ts","sourceRoot":"","sources":["../../../src/components/Switch/switch.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AACvC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AACzD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAE3D,MAAM,WAAW,eAAe;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,KAAK,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAC/B,KAAK,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAC/B,UAAU,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IACpC,SAAS,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CACpC;AAED;;;;;;GAMG;AACH,MAAM,WAAW,WAAY,SAAQ,IAAI,CAAC,cAAc,EAAE,MAAM,CAAC;IAC/D,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,SAAS,CAAC;IAClB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,WAAW,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC;IAC1C,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,UAAU,CAAC,EAAE,SAAS,CAAC;IACvB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,MAAM,CAAC,EAAE,iBAAiB,CAAC;IAC3B,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,SAAS,CAAC,EAAE,eAAe,CAAC;IAC5B,eAAe,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC;CAC9C"}

package/dist/components/Switch/switch.variants.d.ts

@@ -0,0 +1,105 @@
+import { type VariantProps } from 'tailwind-variants';
+/**
+ * Tailwind-variants recipe for `<Switch>` with slots.
+ *
+ * Slots:
+ *   - `root`       — outer flex wrapper (control + label)
+ *   - `control`    — the visible track (Radix `Switch.Root`)
+ *   - `thumb`      — the moving knob (Radix `Switch.Thumb`); animated
+ *                    via translate-x on data-state="checked"
+ *   - `label`      — text next to the control
+ *   - `helperText` / `errorText` — informational lines below
+ */
+export declare const switchVariants: import("tailwind-variants").TVReturnType<{
+    size: {
+        sm: {
+            control: string;
+            thumb: string;
+            label: string;
+        };
+        md: {
+            control: string;
+            thumb: string;
+            label: string;
+        };
+        lg: {
+            control: string;
+            thumb: string;
+            label: string;
+        };
+    };
+    error: {
+        true: {
+            control: string;
+        };
+    };
+}, {
+    root: string;
+    control: string[];
+    thumb: string[];
+    label: string;
+    helperText: string;
+    errorText: string;
+}, undefined, {
+    size: {
+        sm: {
+            control: string;
+            thumb: string;
+            label: string;
+        };
+        md: {
+            control: string;
+            thumb: string;
+            label: string;
+        };
+        lg: {
+            control: string;
+            thumb: string;
+            label: string;
+        };
+    };
+    error: {
+        true: {
+            control: string;
+        };
+    };
+}, {
+    root: string;
+    control: string[];
+    thumb: string[];
+    label: string;
+    helperText: string;
+    errorText: string;
+}, import("tailwind-variants").TVReturnType<{
+    size: {
+        sm: {
+            control: string;
+            thumb: string;
+            label: string;
+        };
+        md: {
+            control: string;
+            thumb: string;
+            label: string;
+        };
+        lg: {
+            control: string;
+            thumb: string;
+            label: string;
+        };
+    };
+    error: {
+        true: {
+            control: string;
+        };
+    };
+}, {
+    root: string;
+    control: string[];
+    thumb: string[];
+    label: string;
+    helperText: string;
+    errorText: string;
+}, undefined, unknown, unknown, undefined>>;
+export type SwitchVariants = VariantProps<typeof switchVariants>;
+//# sourceMappingURL=switch.variants.d.ts.map

package/dist/components/Switch/switch.variants.d.ts.map

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

package/dist/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/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;AAqC1B;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,KAAK,CAAC,CAAC,SAAS,MAAM,EAAE,KAAK,EAAE,UAAU,CAAC,CAAC,CAAC,kDAgY3D"}

package/dist/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/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/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/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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qDAmEhB,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/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/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/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/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/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/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/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/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"}