@dashforge/tw 0.10.0-beta → 1.0.0

package/dist/components/Button/button.types.d.ts

@@ -0,0 +1,66 @@
+import type { ButtonHTMLAttributes } from 'react';
+import type { AccessRequirement } from '@dashforge/rbac';
+import type { ButtonVariants } from './button.variants.js';
+/**
+ * Props for the Dashforge TW `<Button>` component.
+ *
+ * Extends the native `<button>` attributes (so `onClick`, `type`,
+ * `aria-*`, `data-*` etc. all flow through), narrowed in two places:
+ *
+ *   - `disabled` is kept (combines with RBAC + loading via OR)
+ *   - `className` is omitted — use `sx` instead. This keeps the
+ *     override path **single and explicit**: `sx` is the escape hatch
+ *     for adding utility classes, and `tailwind-merge` (via `cn()`)
+ *     guarantees it wins over any conflicting variant class.
+ *
+ * Plus the variant axes from `tailwind-variants` and Dashforge-specific
+ * additions:
+ *
+ *   - `access` — RBAC requirement (hide / disable / readonly)
+ *   - `asChild` — Radix Slot polymorphism: when `true`, renders the
+ *     immediate child element with the Button's class merged in, so
+ *     `<Button asChild><a href="/x">Go</a></Button>` produces a styled
+ *     `<a>` with no extra wrapper DOM
+ */
+export interface ButtonProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'className' | 'color'>, Pick<ButtonVariants, 'variant' | 'color' | 'size' | 'fullWidth' | 'loading'> {
+    /**
+     * RBAC access control requirement.
+     *
+     * Controls button visibility and interaction based on user
+     * permissions:
+     *   - `onUnauthorized: 'hide'`     → button does not render
+     *   - `onUnauthorized: 'disable'`  → button renders disabled
+     *   - `onUnauthorized: 'readonly'` → button renders disabled
+     *     (buttons do not support true readonly semantics; disabled is
+     *     used as fallback)
+     *
+     * Combines with `disabled` and `loading` props via OR logic.
+     */
+    access?: AccessRequirement;
+    /**
+     * When `true`, the immediate child element is rendered with the
+     * Button's classes merged in (via `@radix-ui/react-slot`). The
+     * Button DOM element is not emitted.
+     *
+     * Common pattern: render a router `Link` with Button styling.
+     *
+     * @example
+     * ```tsx
+     * <Button asChild variant="solid">
+     *   <Link to="/dashboard">Dashboard</Link>
+     * </Button>
+     * ```
+     */
+    asChild?: boolean;
+    /**
+     * Tailwind utility classes appended **after** the variant classes,
+     * so they win on any conflict via `tailwind-merge`.
+     *
+     * @example
+     * ```tsx
+     * <Button sx="md:w-1/2 shadow-xl">Save</Button>
+     * ```
+     */
+    sx?: string;
+}
+//# sourceMappingURL=button.types.d.ts.map

package/dist/components/Button/button.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"button.types.d.ts","sourceRoot":"","sources":["../../../src/components/Button/button.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,OAAO,CAAC;AAClD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AACzD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAE3D;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,WAAW,WAKf,SAAQ,IAAI,CAAC,oBAAoB,CAAC,iBAAiB,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,EAC1E,IAAI,CAAC,cAAc,EAAE,SAAS,GAAG,OAAO,GAAG,MAAM,GAAG,WAAW,GAAG,SAAS,CAAC;IAC9E;;;;;;;;;;;;OAYG;IACH,MAAM,CAAC,EAAE,iBAAiB,CAAC;IAE3B;;;;;;;;;;;;;OAaG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAElB;;;;;;;;OAQG;IACH,EAAE,CAAC,EAAE,MAAM,CAAC;CACb"}

package/dist/components/Button/button.variants.d.ts

@@ -0,0 +1,104 @@
+import { type VariantProps } from 'tailwind-variants';
+/**
+ * Tailwind-variants recipe for `<Button>`.
+ *
+ * Three independent axes plus two booleans:
+ *   - `variant`: visual treatment (solid / outline / ghost / link)
+ *   - `color`:   semantic intent role (primary / secondary / success /
+ *                warning / danger)
+ *   - `size`:    sm / md / lg
+ *   - `fullWidth`: stretches to container width
+ *   - `loading`:   visually + functionally disabled, used together with
+ *                  an inline spinner rendered by the component
+ *
+ * Color × variant combinations are expressed via `compoundVariants` so
+ * each pair owns its bg / text / border / hover / focus quartet without
+ * a `dark:` variant explosion. Dark mode swap is delegated entirely to
+ * the runtime CSS-vars from `@dashforge/tw-theme` — the same class
+ * resolves to a different value when `data-dash-tw-theme="dark"` flips.
+ *
+ * Token references:
+ *   - Surface bg / border / text   →  `*-primary-*`, `*-danger-*`, etc.
+ *                                     (resolved via `dashforgePreset()`)
+ *   - Hover / focus / active states→  one tone deeper on the same scale
+ *                                     (`primary-600` from `primary-500`)
+ *   - Disabled                     →  opacity drop + no pointer-events
+ */
+export declare const buttonVariants: import("tailwind-variants").TVReturnType<{
+    variant: {
+        solid: string;
+        outline: string;
+        ghost: string;
+        link: string;
+    };
+    color: {
+        primary: string;
+        secondary: string;
+        success: string;
+        warning: string;
+        danger: string;
+    };
+    size: {
+        sm: string;
+        md: string;
+        lg: string;
+    };
+    fullWidth: {
+        true: string;
+    };
+    loading: {
+        true: string;
+    };
+}, undefined, string[], {
+    variant: {
+        solid: string;
+        outline: string;
+        ghost: string;
+        link: string;
+    };
+    color: {
+        primary: string;
+        secondary: string;
+        success: string;
+        warning: string;
+        danger: string;
+    };
+    size: {
+        sm: string;
+        md: string;
+        lg: string;
+    };
+    fullWidth: {
+        true: string;
+    };
+    loading: {
+        true: string;
+    };
+}, undefined, import("tailwind-variants").TVReturnType<{
+    variant: {
+        solid: string;
+        outline: string;
+        ghost: string;
+        link: string;
+    };
+    color: {
+        primary: string;
+        secondary: string;
+        success: string;
+        warning: string;
+        danger: string;
+    };
+    size: {
+        sm: string;
+        md: string;
+        lg: string;
+    };
+    fullWidth: {
+        true: string;
+    };
+    loading: {
+        true: string;
+    };
+}, undefined, string[], unknown, unknown, undefined>>;
+export type ButtonVariants = VariantProps<typeof buttonVariants>;
+//# sourceMappingURL=button.variants.d.ts.map

package/dist/components/Button/button.variants.d.ts.map

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

package/dist/components/Calendar/Calendar.d.ts

@@ -0,0 +1,14 @@
+import type { CalendarProps } from './calendar.types.js';
+/**
+ * `<Calendar>` — a standalone, inline month-grid date picker.
+ *
+ * The Tailwind presentation layer over the headless `useCalendar` engine
+ * from `@dashforge/calendar-core` (the same engine the MUI `@dashforge/ui`
+ * calendar consumes — only the skin differs). Implements the WCAG grid
+ * pattern with roving tab-index focus.
+ *
+ * It is a primitive: no form-bridge / RBAC integration — use `<DatePicker>`
+ * for a form-bound date field.
+ */
+export declare function Calendar(props: CalendarProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=Calendar.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Calendar.d.ts","sourceRoot":"","sources":["../../../src/components/Calendar/Calendar.tsx"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AA2CzD;;;;;;;;;;GAUG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,aAAa,2CAuM5C"}

package/dist/components/Calendar/calendar.types.d.ts

@@ -0,0 +1,72 @@
+import type { ISODate, WeekDay } from '@dashforge/calendar-core';
+/** Per-slot `className` overrides for `<Calendar>`. */
+export interface CalendarSlotProps {
+    root?: {
+        className?: string;
+    };
+    header?: {
+        className?: string;
+    };
+    grid?: {
+        className?: string;
+    };
+    /** Applied to every day-cell button. */
+    day?: {
+        className?: string;
+    };
+}
+/**
+ * Props for the `<Calendar>` primitive — a standalone, inline month grid.
+ *
+ * `Calendar` is NOT a form field (no bridge / RBAC integration). It is the
+ * low-level building block used inside `<DatePicker>`. For a form-bound date
+ * input use `<DatePicker>`.
+ *
+ * Dates are ISO `YYYY-MM-DD` strings throughout. The headless date engine is
+ * `@dashforge/calendar-core` — shared with the MUI `@dashforge/ui` calendar.
+ */
+export interface CalendarProps {
+    /** Selected date (controlled). */
+    value?: ISODate | null;
+    /** Initial selected date (uncontrolled). */
+    defaultValue?: ISODate | null;
+    /** Fired when a day is chosen. */
+    onChange?: (value: ISODate) => void;
+    /** Controlled displayed month (1-indexed). Pair with `year`. */
+    month?: number;
+    /** Controlled displayed year. Pair with `month`. */
+    year?: number;
+    /** Initial displayed month (1-indexed, uncontrolled). */
+    defaultMonth?: number;
+    /** Initial displayed year (uncontrolled). */
+    defaultYear?: number;
+    /** Fired when the displayed month changes. */
+    onMonthChange?: (month: number, year: number) => void;
+    /** Earliest selectable date (inclusive). */
+    minDate?: ISODate;
+    /** Latest selectable date (inclusive). */
+    maxDate?: ISODate;
+    /** Explicit list of disabled dates. */
+    disabledDates?: readonly ISODate[];
+    /** Predicate marking arbitrary dates disabled. */
+    isDateDisabled?: (date: ISODate) => boolean;
+    /** Weekday of the grid's first column (`0` = Sunday). Default `0`. */
+    weekStartDay?: WeekDay;
+    /** BCP-47 locale for month/weekday names. Default `"en-US"`. */
+    locale?: string;
+    /** Overrides "today" (ISO `YYYY-MM-DD`), mainly for testing. */
+    today?: ISODate;
+    /** Disables the whole calendar. */
+    disabled?: boolean;
+    /** Moves DOM focus to the active day cell on mount. */
+    autoFocus?: boolean;
+    /** Accessible label for the grid. Default `"Calendar"`. */
+    'aria-label'?: string;
+    /** Root-level Tailwind class override. */
+    sx?: string;
+    /** Per-slot `className` overrides. */
+    slotProps?: CalendarSlotProps;
+    /** Test id applied to the root element. */
+    testId?: string;
+}
+//# sourceMappingURL=calendar.types.d.ts.map

package/dist/components/Calendar/calendar.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"calendar.types.d.ts","sourceRoot":"","sources":["../../../src/components/Calendar/calendar.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,0BAA0B,CAAC;AAEjE,uDAAuD;AACvD,MAAM,WAAW,iBAAiB;IAChC,IAAI,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAC9B,MAAM,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAChC,IAAI,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAC9B,wCAAwC;IACxC,GAAG,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CAC9B;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,aAAa;IAC5B,kCAAkC;IAClC,KAAK,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IACvB,4CAA4C;IAC5C,YAAY,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IAC9B,kCAAkC;IAClC,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;IACpC,gEAAgE;IAChE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,oDAAoD;IACpD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,yDAAyD;IACzD,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,6CAA6C;IAC7C,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,8CAA8C;IAC9C,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACtD,4CAA4C;IAC5C,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,0CAA0C;IAC1C,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,uCAAuC;IACvC,aAAa,CAAC,EAAE,SAAS,OAAO,EAAE,CAAC;IACnC,kDAAkD;IAClD,cAAc,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,OAAO,CAAC;IAC5C,sEAAsE;IACtE,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,gEAAgE;IAChE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,gEAAgE;IAChE,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,mCAAmC;IACnC,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,uDAAuD;IACvD,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,2DAA2D;IAC3D,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,0CAA0C;IAC1C,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,sCAAsC;IACtC,SAAS,CAAC,EAAE,iBAAiB,CAAC;IAC9B,2CAA2C;IAC3C,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB"}

package/dist/components/Calendar/calendar.variants.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Structural slots for `<Calendar>`.
+ *
+ * Theme identity: every class is a bare neutral / brand token-backed
+ * Tailwind class. The `dashforgePreset()` CSS-variable swap auto-inverts
+ * the neutral palette, so there are NO `dark:` variants here (a `dark:` on
+ * a neutral class would double-invert — see `_shared/themeIdentity.test.ts`).
+ */
+export declare const calendarVariants: import("tailwind-variants").TVReturnType<{
+    disabled: {
+        true: {
+            root: string;
+        };
+    };
+}, {
+    root: string;
+    header: string;
+    navButton: string;
+    monthLabel: string;
+    grid: string;
+    weekdayRow: string;
+    weekday: string;
+    weekRow: string;
+}, undefined, {
+    disabled: {
+        true: {
+            root: string;
+        };
+    };
+}, {
+    root: string;
+    header: string;
+    navButton: string;
+    monthLabel: string;
+    grid: string;
+    weekdayRow: string;
+    weekday: string;
+    weekRow: string;
+}, import("tailwind-variants").TVReturnType<{
+    disabled: {
+        true: {
+            root: string;
+        };
+    };
+}, {
+    root: string;
+    header: string;
+    navButton: string;
+    monthLabel: string;
+    grid: string;
+    weekdayRow: string;
+    weekday: string;
+    weekRow: string;
+}, undefined, unknown, unknown, undefined>>;
+/**
+ * Per-day-cell recipe. Each of the 42 grid cells is rendered with its own
+ * state (`siblingMonth` / `today` / `selected` / `disabled`).
+ */
+export declare const calendarDayVariants: import("tailwind-variants").TVReturnType<{
+    siblingMonth: {
+        true: string;
+    };
+    today: {
+        true: string;
+    };
+    selected: {
+        true: string;
+    };
+    disabled: {
+        true: string;
+    };
+}, undefined, "flex h-9 w-9 items-center justify-center rounded-md text-sm text-neutral-900 transition-colors hover:bg-neutral-100 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-inset focus-visible:ring-primary-500", {
+    siblingMonth: {
+        true: string;
+    };
+    today: {
+        true: string;
+    };
+    selected: {
+        true: string;
+    };
+    disabled: {
+        true: string;
+    };
+}, undefined, import("tailwind-variants").TVReturnType<{
+    siblingMonth: {
+        true: string;
+    };
+    today: {
+        true: string;
+    };
+    selected: {
+        true: string;
+    };
+    disabled: {
+        true: string;
+    };
+}, undefined, "flex h-9 w-9 items-center justify-center rounded-md text-sm text-neutral-900 transition-colors hover:bg-neutral-100 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-inset focus-visible:ring-primary-500", unknown, unknown, undefined>>;
+//# sourceMappingURL=calendar.variants.d.ts.map

package/dist/components/Calendar/calendar.variants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"calendar.variants.d.ts","sourceRoot":"","sources":["../../../src/components/Calendar/calendar.variants.ts"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2CAqB3B,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0QA0B9B,CAAC"}

package/dist/components/Checkbox/Checkbox.d.ts

@@ -0,0 +1,31 @@
+import type { CheckboxProps } from './checkbox.types.js';
+/**
+ * Dashforge TW Checkbox — bridge-integrated form control.
+ *
+ * Renders through Radix `Checkbox.Root` + `Checkbox.Indicator`, styled
+ * with the `checkboxVariants` TV recipe. Behaviour at the bridge level
+ * is a direct port of `@dashforge/ui/Checkbox` (MUI):
+ *
+ *  - When mounted inside `DashFormProvider`, registers with the bridge
+ *    (`bridge.register`), reads `bridge.getValue` for the checked
+ *    state, writes `bridge.setValue` on change, fires
+ *    `registration.onChange` / `onBlur` for RHF.
+ *  - When mounted outside, behaves as a plain uncontrolled checkbox.
+ *  - `visibleWhen` predicates the engine state; `false` → returns null.
+ *  - `useAccessState(access)` resolves RBAC; `visible: false` → null.
+ *  - `unregister`-on-unmount is StrictMode-safe (queueMicrotask +
+ *    `isMountedRef`, mirrors the MUI-side pattern).
+ *  - Error gating: bridge error shows only after `touched` or after
+ *    the form has been submitted (`submitCount > 0`).
+ *
+ * Renderer differences vs MUI:
+ *
+ *  - No `FormControlLabel` wrapper — uses a native `<label htmlFor>`
+ *    bound via `useId()`. The label click toggles via HTML semantics.
+ *  - The Radix root is a `<button>`, so it's keyboard-accessible by
+ *    default (Space toggles).
+ *  - Slot overrides are class-based (`slotProps={{ control: { className } }}`)
+ *    rather than MUI slot components.
+ */
+export declare function Checkbox(props: CheckboxProps): import("react/jsx-runtime").JSX.Element | null;
+//# sourceMappingURL=Checkbox.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Checkbox.d.ts","sourceRoot":"","sources":["../../../src/components/Checkbox/Checkbox.tsx"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AA0DzD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,aAAa,kDA8L5C"}

package/dist/components/Checkbox/checkbox.types.d.ts

@@ -0,0 +1,86 @@
+import type { ReactNode } from 'react';
+import type { AccessRequirement } from '@dashforge/rbac';
+import type { Engine } from '@dashforge/ui-core';
+import type { CheckboxVariants } from './checkbox.variants.js';
+/**
+ * Per-slot className overrides for `<Checkbox>`. Shape mirrors the
+ * MUI-side `slotProps` convention: object-per-slot with a `className`
+ * key, so future extensions (style, aria-*, data-*) are additive.
+ */
+export interface CheckboxSlotProps {
+    root?: {
+        className?: string;
+    };
+    control?: {
+        className?: string;
+    };
+    indicator?: {
+        className?: string;
+    };
+    label?: {
+        className?: string;
+    };
+    helperText?: {
+        className?: string;
+    };
+    errorText?: {
+        className?: string;
+    };
+}
+/**
+ * Props for the Dashforge TW `<Checkbox>` component.
+ *
+ * Behaves identically to `@dashforge/ui/Checkbox` (MUI) at the bridge
+ * level — same `name` / `rules` / `visibleWhen` / `access` semantics,
+ * same validation gating (touched OR submitCount > 0). The visual
+ * surface is rendered via Radix Checkbox + Tailwind classes.
+ *
+ * Note: the `error` prop here is the **public** form-validation
+ * semaphore (boolean override); it threads into the variant via
+ * `checkboxVariants({ error })` internally. The variant axis name and
+ * the prop name happen to coincide — same meaning.
+ */
+export interface CheckboxProps extends Pick<CheckboxVariants, 'size'> {
+    /** Bridge field name (required when used inside `DashFormProvider`). */
+    name: string;
+    /** Visible label rendered next to the control. Click also toggles the box. */
+    label?: ReactNode;
+    /** Forwarded to the bridge as RHF rules — opaque to this component. */
+    rules?: unknown;
+    /**
+     * Engine predicate. When provided, the component renders only when
+     * the predicate returns truthy against the current engine state.
+     */
+    visibleWhen?: (engine: Engine) => boolean;
+    /** Initial / controlled checked state. */
+    checked?: boolean;
+    /** Default checked when used uncontrolled. */
+    defaultChecked?: boolean;
+    /** Disabled — combined with RBAC disabled via OR. */
+    disabled?: boolean;
+    /**
+     * Forces helper text below the control. When the bridge surfaces an
+     * error and `helperText` is undefined, the bridge's error message
+     * shows up here (gated by `touched || submitCount > 0`).
+     */
+    helperText?: ReactNode;
+    /**
+     * Explicit error flag. When `true`, the control renders with the
+     * danger ring + the error-text slot is used for `helperText`.
+     * Overrides the bridge's auto-detected error.
+     */
+    error?: boolean;
+    /** RBAC requirement. */
+    access?: AccessRequirement;
+    /** Root-level Tailwind override. Wins over variant classes via `cn()`. */
+    sx?: string;
+    /** Per-slot overrides — see `CheckboxSlotProps`. */
+    slotProps?: CheckboxSlotProps;
+    /**
+     * Called when the user toggles the control. When inside a
+     * `DashFormProvider`, the bridge update happens first, then this
+     * callback fires with the new checked state.
+     */
+    onCheckedChange?: (checked: boolean) => void;
+}
+//# sourceMappingURL=checkbox.types.d.ts.map

package/dist/components/Checkbox/checkbox.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkbox.types.d.ts","sourceRoot":"","sources":["../../../src/components/Checkbox/checkbox.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,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAE/D;;;;GAIG;AACH,MAAM,WAAW,iBAAiB;IAChC,IAAI,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAC9B,OAAO,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IACjC,SAAS,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IACnC,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;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,aACf,SAAQ,IAAI,CAAC,gBAAgB,EAAE,MAAM,CAAC;IACtC,wEAAwE;IACxE,IAAI,EAAE,MAAM,CAAC;IAEb,8EAA8E;IAC9E,KAAK,CAAC,EAAE,SAAS,CAAC;IAElB,uEAAuE;IACvE,KAAK,CAAC,EAAE,OAAO,CAAC;IAEhB;;;OAGG;IACH,WAAW,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC;IAE1C,0CAA0C;IAC1C,OAAO,CAAC,EAAE,OAAO,CAAC;IAElB,8CAA8C;IAC9C,cAAc,CAAC,EAAE,OAAO,CAAC;IAEzB,qDAAqD;IACrD,QAAQ,CAAC,EAAE,OAAO,CAAC;IAEnB;;;;OAIG;IACH,UAAU,CAAC,EAAE,SAAS,CAAC;IAEvB;;;;OAIG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;IAEhB,wBAAwB;IACxB,MAAM,CAAC,EAAE,iBAAiB,CAAC;IAE3B,0EAA0E;IAC1E,EAAE,CAAC,EAAE,MAAM,CAAC;IAEZ,oDAAoD;IACpD,SAAS,CAAC,EAAE,iBAAiB,CAAC;IAE9B;;;;OAIG;IACH,eAAe,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC;CAC9C"}

package/dist/components/Checkbox/checkbox.variants.d.ts

@@ -0,0 +1,109 @@
+import { type VariantProps } from 'tailwind-variants';
+/**
+ * Tailwind-variants recipe for `<Checkbox>` with slots.
+ *
+ * Slots:
+ *   - `root`        — outer flex wrapper enclosing the control + label
+ *   - `control`     — the visible square (Radix `Checkbox.Root`)
+ *   - `indicator`   — checkmark SVG container (Radix `Checkbox.Indicator`)
+ *   - `label`       — text label associated with the control
+ *   - `helperText`  — descriptive line below
+ *   - `errorText`   — error message line (semantic counterpart of helperText)
+ *
+ * Variants:
+ *   - `size`  : sm / md / lg (drives control box dimensions + label text size)
+ *   - `error` : bool — swaps borders + helper-text color to danger tones
+ */
+export declare const checkboxVariants: import("tailwind-variants").TVReturnType<{
+    size: {
+        sm: {
+            control: string;
+            label: string;
+            indicator: string;
+        };
+        md: {
+            control: string;
+            label: string;
+            indicator: string;
+        };
+        lg: {
+            control: string;
+            label: string;
+            indicator: string;
+        };
+    };
+    error: {
+        true: {
+            control: string;
+        };
+    };
+}, {
+    root: string;
+    control: string[];
+    indicator: string;
+    label: string;
+    helperText: string;
+    errorText: string;
+}, undefined, {
+    size: {
+        sm: {
+            control: string;
+            label: string;
+            indicator: string;
+        };
+        md: {
+            control: string;
+            label: string;
+            indicator: string;
+        };
+        lg: {
+            control: string;
+            label: string;
+            indicator: string;
+        };
+    };
+    error: {
+        true: {
+            control: string;
+        };
+    };
+}, {
+    root: string;
+    control: string[];
+    indicator: string;
+    label: string;
+    helperText: string;
+    errorText: string;
+}, import("tailwind-variants").TVReturnType<{
+    size: {
+        sm: {
+            control: string;
+            label: string;
+            indicator: string;
+        };
+        md: {
+            control: string;
+            label: string;
+            indicator: string;
+        };
+        lg: {
+            control: string;
+            label: string;
+            indicator: string;
+        };
+    };
+    error: {
+        true: {
+            control: string;
+        };
+    };
+}, {
+    root: string;
+    control: string[];
+    indicator: string;
+    label: string;
+    helperText: string;
+    errorText: string;
+}, undefined, unknown, unknown, undefined>>;
+export type CheckboxVariants = VariantProps<typeof checkboxVariants>;
+//# sourceMappingURL=checkbox.variants.d.ts.map

package/dist/components/Checkbox/checkbox.variants.d.ts.map

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

package/dist/components/ConfirmDialog/ConfirmDialog.d.ts

@@ -0,0 +1,38 @@
+import type { ConfirmDialogProviderProps, ConfirmFn } from './confirmDialog.types.js';
+/**
+ * `useConfirm()` — returns the imperative `confirm()` function.
+ *
+ * Throws if called outside a `<ConfirmDialogProvider>`. The thrown error
+ * tells the developer exactly what to do — no silent no-op (silently
+ * resolving `false` would be a footgun for destructive actions).
+ */
+export declare function useConfirm(): ConfirmFn;
+/**
+ * Dashforge TW ConfirmDialog provider.
+ *
+ * Imperative confirmation modal built on the native HTML `<dialog>`
+ * element + `showModal()`. Why native:
+ *
+ *  1. **AAA-grade a11y for free** — browsers implement focus trap,
+ *     Escape key, inert background, and `aria-modal` semantics natively.
+ *  2. **Zero new deps** — no `@radix-ui/react-dialog` or Aria stack.
+ *  3. **Smaller bundle** — ~1 KB of logic vs. ~25 KB for Aria Dialog.
+ *
+ * **Behaviour**:
+ *   - `confirm(opts)` returns a `Promise<boolean>`.
+ *   - Backdrop click resolves `false` (unless `disableBackdropClose`).
+ *   - Escape key resolves `false` (unless `disableEscapeClose`).
+ *   - Cancel button resolves `false`.
+ *   - Confirm button resolves `true`.
+ *   - At most ONE dialog open at a time — concurrent `confirm()` calls
+ *     queue and fire FIFO (so a destructive action can't accidentally
+ *     race a benign one).
+ *
+ * **A11y**:
+ *   - `<dialog>` ⇒ implicit `role="dialog"` + `aria-modal="true"`.
+ *   - `aria-labelledby` wires the title id to the dialog.
+ *   - Focus is auto-trapped by `showModal()`.
+ *   - First focusable element receives focus on open (browser-managed).
+ */
+export declare function ConfirmDialogProvider(props: ConfirmDialogProviderProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=ConfirmDialog.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ConfirmDialog.d.ts","sourceRoot":"","sources":["../../../src/components/ConfirmDialog/ConfirmDialog.tsx"],"names":[],"mappings":"AAWA,OAAO,KAAK,EACV,0BAA0B,EAC1B,SAAS,EAGV,MAAM,0BAA0B,CAAC;AAalC;;;;;;GAMG;AACH,wBAAgB,UAAU,IAAI,SAAS,CAQtC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,0BAA0B,2CAkLtE"}