@dashforge/tw 0.1.0-beta

package/dist/src/components/Snackbar/snackbar.variants.d.ts

@@ -0,0 +1,153 @@
+import { type VariantProps } from 'tailwind-variants';
+/**
+ * Tailwind-variants recipe for `<Snackbar>` (stacked toast surface).
+ *
+ * Slots:
+ *   - `container`   — fixed-position outer stack
+ *   - `item`        — single snackbar surface
+ *   - `icon`        — leading severity icon
+ *   - `message`     — main text
+ *   - `action`      — optional action button
+ *   - `closeButton` — trailing `×` button
+ */
+export declare const snackbarVariants: import("tailwind-variants").TVReturnType<{
+    position: {
+        'top-left': {
+            container: string;
+        };
+        'top-center': {
+            container: string;
+        };
+        'top-right': {
+            container: string;
+        };
+        'bottom-left': {
+            container: string;
+        };
+        'bottom-center': {
+            container: string;
+        };
+        'bottom-right': {
+            container: string;
+        };
+    };
+    severity: {
+        info: {
+            item: string;
+            icon: string;
+        };
+        success: {
+            item: string;
+            icon: string;
+        };
+        warning: {
+            item: string;
+            icon: string;
+        };
+        danger: {
+            item: string;
+            icon: string;
+        };
+    };
+}, {
+    container: string[];
+    item: string[];
+    icon: string;
+    message: string;
+    action: string[];
+    closeButton: string[];
+}, undefined, {
+    position: {
+        'top-left': {
+            container: string;
+        };
+        'top-center': {
+            container: string;
+        };
+        'top-right': {
+            container: string;
+        };
+        'bottom-left': {
+            container: string;
+        };
+        'bottom-center': {
+            container: string;
+        };
+        'bottom-right': {
+            container: string;
+        };
+    };
+    severity: {
+        info: {
+            item: string;
+            icon: string;
+        };
+        success: {
+            item: string;
+            icon: string;
+        };
+        warning: {
+            item: string;
+            icon: string;
+        };
+        danger: {
+            item: string;
+            icon: string;
+        };
+    };
+}, {
+    container: string[];
+    item: string[];
+    icon: string;
+    message: string;
+    action: string[];
+    closeButton: string[];
+}, import("tailwind-variants").TVReturnType<{
+    position: {
+        'top-left': {
+            container: string;
+        };
+        'top-center': {
+            container: string;
+        };
+        'top-right': {
+            container: string;
+        };
+        'bottom-left': {
+            container: string;
+        };
+        'bottom-center': {
+            container: string;
+        };
+        'bottom-right': {
+            container: string;
+        };
+    };
+    severity: {
+        info: {
+            item: string;
+            icon: string;
+        };
+        success: {
+            item: string;
+            icon: string;
+        };
+        warning: {
+            item: string;
+            icon: string;
+        };
+        danger: {
+            item: string;
+            icon: string;
+        };
+    };
+}, {
+    container: string[];
+    item: string[];
+    icon: string;
+    message: string;
+    action: string[];
+    closeButton: string[];
+}, undefined, unknown, unknown, undefined>>;
+export type SnackbarVariants = VariantProps<typeof snackbarVariants>;
+//# sourceMappingURL=snackbar.variants.d.ts.map

package/dist/src/components/Snackbar/snackbar.variants.d.ts.map

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

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

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

@@ -0,0 +1,25 @@
+import type { TextFieldProps } from './textField.types.js';
+/**
+ * Dashforge TW TextField — bridge-integrated text input.
+ *
+ * Implementation mirrors `@dashforge/ui/TextField` (MUI) at the bridge
+ * level — same `name` / `rules` / `visibleWhen` / `access` semantics,
+ * same validation gating, same StrictMode-safe unregister pattern.
+ * Renderer differences:
+ *
+ *  - Native `<input>` element wrapped in a TV-styled
+ *    `<div role-less wrapper>` so the focus ring extends to the entire
+ *    field (consistent with shadcn-style inputs).
+ *  - Layout modes: `stacked` (default — label above) and `inline`
+ *    (label left of input). MUI's `floating` mode is deferred to a
+ *    follow-up sprint; consumers needing the visual can layer it via
+ *    `slotProps`.
+ *  - No Select-integration hook (Select lands in F4 as its own component).
+ *
+ * **A11y**:
+ *   - `aria-invalid` is set from the resolved validation state.
+ *   - `aria-describedby` links the input to the helper/error text node.
+ *   - Required fields get the native `required` attribute + a visual `*`.
+ */
+export declare function TextField(props: TextFieldProps): import("react/jsx-runtime").JSX.Element | null;
+//# sourceMappingURL=TextField.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TextField.d.ts","sourceRoot":"","sources":["../../../../src/components/TextField/TextField.tsx"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAE3D;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,cAAc,kDAuL9C"}

package/dist/src/components/TextField/textField.types.d.ts

@@ -0,0 +1,72 @@
+import type { InputHTMLAttributes, ReactNode } from 'react';
+import type { AccessRequirement } from '@dashforge/rbac';
+import type { Engine } from '@dashforge/ui-core';
+import type { TextFieldVariants } from './textField.variants.js';
+/**
+ * Per-slot overrides for `<TextField>`.
+ *
+ * Each slot accepts `{ className: string }` so the override path is
+ * extensible (style / aria-* / data-* can be added without a breaking
+ * change). Mirrors the MUI-side `slotProps` shape.
+ */
+export interface TextFieldSlotProps {
+    root?: {
+        className?: string;
+    };
+    label?: {
+        className?: string;
+    };
+    requiredMark?: {
+        className?: string;
+    };
+    inputWrapper?: {
+        className?: string;
+    };
+    input?: {
+        className?: string;
+    };
+    helperText?: {
+        className?: string;
+    };
+    errorText?: {
+        className?: string;
+    };
+}
+/**
+ * Props for the Dashforge TW `<TextField>`.
+ *
+ * Extends the native `<input>` attributes (so `placeholder`, `type`,
+ * `autoComplete`, `aria-*` etc. all flow through), narrowed in two
+ * places:
+ *
+ *   - `size` is omitted because HTML's legacy `size` attribute (number)
+ *     collides with our variant axis (`'sm' | 'md' | 'lg'`).
+ *   - `className` is omitted — use `sx` instead (the canonical override
+ *     path that wins over variant classes via `tailwind-merge`).
+ *
+ * Plus the variant axes and Dashforge form-bridge wiring (`name`,
+ * `rules`, `visibleWhen`, `access`).
+ */
+export interface TextFieldProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'size' | 'className'>, Pick<TextFieldVariants, 'size' | 'layout' | 'fullWidth'> {
+    /** Bridge field name (required when used inside `DashFormProvider`). */
+    name: string;
+    /** Visible label. */
+    label?: ReactNode;
+    /** Forwarded to the bridge as RHF rules — opaque to this component. */
+    rules?: unknown;
+    /** Engine predicate. Component returns null when false. */
+    visibleWhen?: (engine: Engine) => boolean;
+    /** Helper line below the input. */
+    helperText?: ReactNode;
+    /** Explicit error semaphore. Overrides bridge auto-error. */
+    error?: boolean;
+    /** Render the asterisk + set the native `required` attribute. */
+    required?: boolean;
+    /** RBAC requirement. */
+    access?: AccessRequirement;
+    /** Root-level Tailwind override — wins over variant classes via `cn()`. */
+    sx?: string;
+    /** Per-slot overrides — see `TextFieldSlotProps`. */
+    slotProps?: TextFieldSlotProps;
+}
+//# sourceMappingURL=textField.types.d.ts.map

package/dist/src/components/TextField/textField.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"textField.types.d.ts","sourceRoot":"","sources":["../../../../src/components/TextField/textField.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAC5D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AACzD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAEjE;;;;;;GAMG;AACH,MAAM,WAAW,kBAAkB;IACjC,IAAI,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAC9B,KAAK,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAC/B,YAAY,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IACtC,YAAY,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IACtC,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;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,cACf,SAAQ,IAAI,CAAC,mBAAmB,CAAC,gBAAgB,CAAC,EAAE,MAAM,GAAG,WAAW,CAAC,EACvE,IAAI,CAAC,iBAAiB,EAAE,MAAM,GAAG,QAAQ,GAAG,WAAW,CAAC;IAC1D,wEAAwE;IACxE,IAAI,EAAE,MAAM,CAAC;IAEb,qBAAqB;IACrB,KAAK,CAAC,EAAE,SAAS,CAAC;IAElB,uEAAuE;IACvE,KAAK,CAAC,EAAE,OAAO,CAAC;IAEhB,2DAA2D;IAC3D,WAAW,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC;IAE1C,mCAAmC;IACnC,UAAU,CAAC,EAAE,SAAS,CAAC;IAEvB,6DAA6D;IAC7D,KAAK,CAAC,EAAE,OAAO,CAAC;IAEhB,iEAAiE;IACjE,QAAQ,CAAC,EAAE,OAAO,CAAC;IAEnB,wBAAwB;IACxB,MAAM,CAAC,EAAE,iBAAiB,CAAC;IAE3B,2EAA2E;IAC3E,EAAE,CAAC,EAAE,MAAM,CAAC;IAEZ,qDAAqD;IACrD,SAAS,CAAC,EAAE,kBAAkB,CAAC;CAChC"}

package/dist/src/components/TextField/textField.variants.d.ts

@@ -0,0 +1,160 @@
+import { type VariantProps } from 'tailwind-variants';
+/**
+ * Tailwind-variants recipe for `<TextField>` with 7 slots.
+ *
+ * The MUI-side `TextField` supports three layout modes (floating /
+ * stacked / inline) plus a Select-integration hook. The TW-side
+ * port covers **stacked** + **inline** in F3 (label outside the
+ * input wrapper) and ships a CSS-only floating label using
+ * Tailwind's `peer` modifier.
+ *
+ * The Select integration (`__selectAvailableValues` etc.) is
+ * deferred to F4 when the dedicated `<Select>` component arrives.
+ */
+export declare const textFieldVariants: import("tailwind-variants").TVReturnType<{
+    size: {
+        sm: {
+            inputWrapper: string;
+            input: string;
+        };
+        md: {
+            inputWrapper: string;
+            input: string;
+        };
+        lg: {
+            inputWrapper: string;
+            input: string;
+        };
+    };
+    layout: {
+        stacked: {
+            root: string;
+        };
+        inline: {
+            root: string;
+            label: string;
+        };
+    };
+    error: {
+        true: {
+            inputWrapper: string;
+        };
+    };
+    fullWidth: {
+        true: {
+            root: string;
+            inputWrapper: string;
+        };
+    };
+    disabled: {
+        true: {
+            inputWrapper: string;
+        };
+    };
+}, {
+    root: string;
+    label: string;
+    requiredMark: string;
+    inputWrapper: string[];
+    input: string[];
+    helperText: string;
+    errorText: string;
+}, undefined, {
+    size: {
+        sm: {
+            inputWrapper: string;
+            input: string;
+        };
+        md: {
+            inputWrapper: string;
+            input: string;
+        };
+        lg: {
+            inputWrapper: string;
+            input: string;
+        };
+    };
+    layout: {
+        stacked: {
+            root: string;
+        };
+        inline: {
+            root: string;
+            label: string;
+        };
+    };
+    error: {
+        true: {
+            inputWrapper: string;
+        };
+    };
+    fullWidth: {
+        true: {
+            root: string;
+            inputWrapper: string;
+        };
+    };
+    disabled: {
+        true: {
+            inputWrapper: string;
+        };
+    };
+}, {
+    root: string;
+    label: string;
+    requiredMark: string;
+    inputWrapper: string[];
+    input: string[];
+    helperText: string;
+    errorText: string;
+}, import("tailwind-variants").TVReturnType<{
+    size: {
+        sm: {
+            inputWrapper: string;
+            input: string;
+        };
+        md: {
+            inputWrapper: string;
+            input: string;
+        };
+        lg: {
+            inputWrapper: string;
+            input: string;
+        };
+    };
+    layout: {
+        stacked: {
+            root: string;
+        };
+        inline: {
+            root: string;
+            label: string;
+        };
+    };
+    error: {
+        true: {
+            inputWrapper: string;
+        };
+    };
+    fullWidth: {
+        true: {
+            root: string;
+            inputWrapper: string;
+        };
+    };
+    disabled: {
+        true: {
+            inputWrapper: string;
+        };
+    };
+}, {
+    root: string;
+    label: string;
+    requiredMark: string;
+    inputWrapper: string[];
+    input: string[];
+    helperText: string;
+    errorText: string;
+}, undefined, unknown, unknown, undefined>>;
+export type TextFieldVariants = VariantProps<typeof textFieldVariants>;
+//# sourceMappingURL=textField.variants.d.ts.map

package/dist/src/components/TextField/textField.variants.d.ts.map

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

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

@@ -0,0 +1,16 @@
+import type { TextareaProps } from './textarea.types.js';
+/**
+ * Dashforge TW Textarea — bridge-integrated multi-line input.
+ *
+ * Sibling of `<TextField>` (same slot taxonomy, same bridge wiring) but
+ * renders a `<textarea>` element instead of a single-line `<input>`.
+ *
+ * Defaults to `rows={3}` and `resize="vertical"` — both overridable via
+ * variant prop or per-instance `rows` attribute.
+ *
+ * **A11y**: `aria-invalid` from the resolved validation state,
+ * `aria-describedby` links to the helper/error text node, required
+ * fields get the native `required` attribute + a visual `*`.
+ */
+export declare function Textarea(props: TextareaProps): import("react/jsx-runtime").JSX.Element | null;
+//# sourceMappingURL=Textarea.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Textarea.d.ts","sourceRoot":"","sources":["../../../../src/components/Textarea/Textarea.tsx"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEzD;;;;;;;;;;;;GAYG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,aAAa,kDAsK5C"}

package/dist/src/components/Textarea/textarea.types.d.ts

@@ -0,0 +1,63 @@
+import type { ChangeEventHandler, FocusEventHandler, ReactNode, TextareaHTMLAttributes } from 'react';
+import type { Engine } from '@dashforge/ui-core';
+import type { AccessRequirement } from '@dashforge/rbac';
+import type { TextareaVariants } from './textarea.variants.js';
+export interface TextareaSlotProps {
+    root?: {
+        className?: string;
+    };
+    label?: {
+        className?: string;
+    };
+    requiredMark?: {
+        className?: string;
+    };
+    inputWrapper?: {
+        className?: string;
+    };
+    input?: {
+        className?: string;
+    };
+    helperText?: {
+        className?: string;
+    };
+    errorText?: {
+        className?: string;
+    };
+}
+/**
+ * Props for `<Textarea>`.
+ *
+ * Mirrors `<TextField>` semantics (bridge integration, RBAC, gating)
+ * but renders a multi-line `<textarea>` and exposes a `resize` variant
+ * (default `'vertical'`). Inherits standard HTMLTextarea attributes
+ * (`rows`, `cols`, `maxLength`, etc.) via `TextareaHTMLAttributes`.
+ */
+export interface TextareaProps extends Omit<TextareaHTMLAttributes<HTMLTextAreaElement>, 'name' | 'size' | 'onChange' | 'onBlur' | 'value' | 'defaultValue'>, TextareaVariants {
+    name: string;
+    rules?: unknown;
+    label?: ReactNode;
+    helperText?: ReactNode;
+    required?: boolean;
+    error?: boolean;
+    disabled?: boolean;
+    /** Engine predicate — textarea not rendered when it returns `false`. */
+    visibleWhen?: (engine: Engine) => boolean;
+    /** RBAC access requirement (combines with explicit `disabled`). */
+    access?: AccessRequirement;
+    /** Root className shortcut (`cn`'d with the variant root class). */
+    sx?: string;
+    /** Per-slot className overrides. */
+    slotProps?: TextareaSlotProps;
+    /** Controlled value (form mode reads from the bridge if omitted). */
+    value?: string;
+    /** Default value (uncontrolled, standalone mode only). */
+    defaultValue?: string;
+    /** User-supplied change handler — fires *after* bridge update. */
+    onChange?: ChangeEventHandler<HTMLTextAreaElement>;
+    /** User-supplied blur handler — fires *after* bridge `onBlur`. */
+    onBlur?: FocusEventHandler<HTMLTextAreaElement>;
+    /** Minimum visible row count for the textarea. Default: 3. */
+    rows?: number;
+}
+//# sourceMappingURL=textarea.types.d.ts.map