themelia-react-ui 0.0.0-stage → 1.0.0

package/dist/components/base/repeaters/repeater.d.ts

@@ -0,0 +1,87 @@
+import { type ReactNode } from 'react';
+import { type StringsProp } from '../../../lib/strings';
+export interface RepeaterStrings {
+    /** Empty state copy — shown when `items` is empty. */
+    emptyState: string;
+    /** Label of the trailing "+" button. */
+    addButton: string;
+    /** Per-row remove button aria-label. */
+    removeAriaLabel: string;
+    /** Drag-handle aria-label (only relevant when `sortable`). */
+    dragHandleAriaLabel: string;
+}
+export declare const defaultRepeaterPrimitiveStrings: RepeaterStrings;
+/**
+ * Visual density of a row. `inline` is the canonical compact admin row
+ * (single input + remove icon). `card` wraps richer content in a
+ * bordered surface — used by `ObjectRepeater` and any consumer with
+ * multi-field rows that need their own delete affordance.
+ */
+export type RepeaterRowVariant = 'inline' | 'card';
+export type RepeaterRemoveVariant = 'ghost' | 'icon-button';
+export interface RepeaterItem {
+    /** Stable id (RHF `field.id`, generated UUID, etc.) — used as React key
+     *  and as the drag handle id when sortable. */
+    id: string;
+}
+export interface RepeaterRowRenderContext {
+    /** Index of the row in the items array. */
+    index: number;
+    /** True while the row is being actively dragged. */
+    isDragging: boolean;
+}
+interface RepeaterBaseProps<T extends RepeaterItem> {
+    /** Entries to render, in order. */
+    items: ReadonlyArray<T>;
+    /** Render the body of a single row. */
+    renderRow: (item: T, ctx: RepeaterRowRenderContext) => ReactNode;
+    /** Called when the consumer presses the "+ add" button. */
+    onAdd: () => void;
+    /** Called when the consumer presses a per-row remove button. */
+    onRemove: (index: number) => void;
+    /** Visual style of each row's outer chrome. Default `'inline'`. */
+    rowVariant?: RepeaterRowVariant;
+    /** Remove button style. Default `'ghost'` (subtle X icon, hover →
+     *  destructive tint). `'icon-button'` mirrors `<Button icon={Trash2}>`
+     *  — used by card rows that need a more prominent affordance. */
+    removeVariant?: RepeaterRemoveVariant;
+    /** Hide the per-row remove button. Default `false`. Useful when the
+     *  consumer renders its own remove inside the row body. */
+    hideRemove?: boolean;
+    /** Disable add + remove + drag affordances. */
+    disabled?: boolean;
+    /** Hide the trailing "+ add" button. Useful when the consumer composes
+     *  it elsewhere or has a maxItems cap. */
+    hideAdd?: boolean;
+    /** Override default strings. */
+    strings?: StringsProp<RepeaterStrings>;
+    /** Class applied to the outer wrapper. */
+    className?: string;
+}
+type RepeaterSortingProps = {
+    /** Enable drag-to-reorder. */
+    sortable: true;
+    /** Called when a row is dragged to a new position. */
+    onMove: (fromIndex: number, toIndex: number) => void;
+} | {
+    /** Disable drag-to-reorder. Default `false`. */
+    sortable?: false;
+    /** Optional callback retained for shared prop builders; ignored while sorting is disabled. */
+    onMove?: (fromIndex: number, toIndex: number) => void;
+};
+/**
+ * Extensible consumer shape for callers that derive their own repeater
+ * props. The component itself accepts `RepeaterComponentProps`, whose
+ * discriminated sorting contract requires `onMove` when `sortable` is true.
+ */
+export interface RepeaterProps<T extends RepeaterItem> extends RepeaterBaseProps<T> {
+    sortable?: boolean;
+    onMove?: (fromIndex: number, toIndex: number) => void;
+}
+export type RepeaterComponentProps<T extends RepeaterItem> = Omit<RepeaterProps<T>, 'sortable' | 'onMove'> & RepeaterSortingProps;
+/** Framework-neutral controlled list chrome with optional sortable rows. */
+export declare function Repeater<T extends RepeaterItem>({ items, renderRow, onAdd, onRemove, onMove, sortable, rowVariant, removeVariant, hideRemove, hideAdd, disabled, strings: stringsProp, className, }: RepeaterComponentProps<T>): import("react").JSX.Element;
+export declare namespace Repeater {
+    var displayName: string;
+}
+export {};

package/dist/components/base/repeaters/repeaters.strings.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Shared default strings for repeater-style form fields
+ * (`<StringRepeater>`, `<ObjectRepeater>`,
+ * `<LocalizedStringRepeater>`, …).
+ *
+ * Each repeater has its own concrete `Strings` interface — the shared
+ * defaults below cover the keys they all share. Per-field strings files
+ * spread these defaults into their own constant so consumers can override
+ * any subset uniformly.
+ */
+export interface RepeaterSharedStrings {
+    emptyState: string;
+    addItem: string;
+    removeAriaLabel: string;
+}
+export declare const defaultRepeaterStrings: RepeaterSharedStrings;

package/dist/components/base/repeaters/string-repeater.d.ts

@@ -0,0 +1,65 @@
+/**
+ * StringRepeater — React Hook Form adapter for a controlled `string[]`.
+ *
+ * React Hook Form's `useFieldArray` only supports arrays of objects. This
+ * adapter therefore controls the whole scalar array with `useController` and
+ * gives each visual row a stable opaque id for React and drag-and-drop. The
+ * `renderField` seam lets textarea and localized variants reuse the same state
+ * engine without duplicating flat-array behavior.
+ */
+import { type ReactNode, type RefCallback } from 'react';
+import { type StringsProp } from '../../../lib/strings';
+export interface StringRepeaterStrings {
+    /** Placeholder shown by the default input renderer. */
+    placeholder: string;
+    /** Label for the add-row action. */
+    addButton: string;
+    /** Copy shown when the array is empty. */
+    emptyState: string;
+    /** Accessible label for each remove action. */
+    removeAriaLabel: string;
+    /** Accessible label for each drag handle. */
+    dragHandleAriaLabel: string;
+}
+export declare const defaultStringRepeaterStrings: StringRepeaterStrings;
+export interface StringRepeaterFieldRenderContext {
+    /** Stable opaque id for this visual row. */
+    id: string;
+    /** Current row position. */
+    index: number;
+    /** Native-style field name for the row. */
+    name: string;
+    /** Current scalar value. */
+    value: string;
+    /** Whether the field should render invalid styling. */
+    invalid: boolean;
+    /** Whether editing and row actions are disabled. */
+    disabled: boolean;
+    /** Update only this scalar value. */
+    onValueChange: (value: string) => void;
+    /** Forward blur to React Hook Form. */
+    onBlur: () => void;
+    /** React Hook Form's array-level focus ref, provided on the first row only. */
+    ref?: RefCallback<HTMLInputElement | HTMLTextAreaElement>;
+}
+export interface StringRepeaterProps {
+    /** React Hook Form field path pointing to a `string[]`. */
+    name: string;
+    /** Force invalid styling in addition to React Hook Form field state. */
+    invalid?: boolean;
+    /** Disable editing, addition, removal, and sorting. */
+    disabled?: boolean;
+    /** Enable drag-to-reorder. Default `false`. */
+    sortable?: boolean;
+    /** Replace the default Input while retaining the canonical array engine. */
+    renderField?: (context: StringRepeaterFieldRenderContext) => ReactNode;
+    /** Override default strings. */
+    strings?: StringsProp<StringRepeaterStrings>;
+    /** Class applied to the public repeater root. */
+    className?: string;
+}
+/** React Hook Form adapter for a scalar `string[]` using the canonical Repeater chrome. */
+export declare function StringRepeater({ name, invalid, disabled, sortable, renderField, strings: stringsProp, className, }: StringRepeaterProps): import("react").JSX.Element;
+export declare namespace StringRepeater {
+    var displayName: string;
+}

package/dist/components/base/repeaters/string-repeater.utils.d.ts

@@ -0,0 +1,2 @@
+/** Reorders a scalar-array value without changing its item shape. */
+export declare function moveStringRepeaterItem<T>(items: ReadonlyArray<T>, fromIndex: number, toIndex: number): T[];

package/dist/components/base/sheet/index.d.ts

@@ -0,0 +1 @@
+export { Sheet, SheetTrigger, SheetClose, SheetContent, SheetHeader, SheetBody, SheetFooter, SheetTitle, SheetDescription, } from './sheet';

package/dist/components/base/sheet/sheet.d.ts

@@ -0,0 +1,35 @@
+import type { TextGap } from '../structure';
+/**
+ * Sheet — design-system wrapper around the shadcn compound primitive.
+ *
+ * The root and trigger behavior stay primitive-compatible. The package layer
+ * adds a deliberate header / scrollable body / footer structure, calm admin
+ * spacing, and stable BEM hooks without narrowing primitive props.
+ */
+import * as React from 'react';
+import { Sheet as SheetPrimitive } from '../../ui/sheet';
+export declare const Sheet: typeof SheetPrimitive;
+export declare const SheetTrigger: React.ForwardRefExoticComponent<Omit<import("@base-ui/react").DialogTrigger.Props<unknown> & {
+    asChild?: boolean;
+}, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+export declare const SheetClose: React.ForwardRefExoticComponent<Omit<import("@base-ui/react").AlertDialogCloseProps & {
+    asChild?: boolean;
+}, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+export declare const SheetContent: React.ForwardRefExoticComponent<Omit<import("@base-ui/react").AlertDialogPopupProps & {
+    side?: "top" | "right" | "bottom" | "left";
+    showCloseButton?: boolean;
+} & {
+    container?: import("../../../lib/theme-scope").ThemePortalContainer;
+}, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export declare const SheetHeader: React.ForwardRefExoticComponent<Omit<React.ClassAttributes<HTMLDivElement> & React.HTMLAttributes<HTMLDivElement>, "ref"> & {
+    textGap?: TextGap;
+} & React.RefAttributes<HTMLDivElement>>;
+/** Scroll-owning content region between the fixed sheet header and footer. */
+export declare const SheetBody: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+export declare const SheetFooter: React.ForwardRefExoticComponent<Omit<React.ClassAttributes<HTMLDivElement> & React.HTMLAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export declare const SheetTitle: React.ForwardRefExoticComponent<Omit<import("@base-ui/react").AlertDialogTitleProps & {
+    asChild?: boolean;
+}, "ref"> & React.RefAttributes<HTMLHeadingElement>>;
+export declare const SheetDescription: React.ForwardRefExoticComponent<Omit<import("@base-ui/react").AlertDialogDescriptionProps & {
+    asChild?: boolean;
+}, "ref"> & React.RefAttributes<HTMLParagraphElement>>;

package/dist/components/base/sidebar/index.d.ts

@@ -0,0 +1,6 @@
+export { Sidebar, SidebarContent, SidebarFooter, SidebarGroup, SidebarGroupAction, SidebarGroupContent, SidebarGroupLabel, SidebarHeader, SidebarInput, SidebarInset, SidebarMenu, SidebarMenuAction, SidebarMenuBadge, SidebarMenuButton, SidebarMenuItem, SidebarMenuSkeleton, SidebarMenuSub, SidebarMenuSubButton, SidebarMenuSubItem, SidebarProvider, SidebarRail, SidebarSeparator, SidebarTrigger, defaultSidebarStrings, type SidebarProps, type SidebarInputProps, type SidebarMenuBadgeProps, type SidebarMenuButtonProps, type SidebarMenuDensity, type SidebarMenuProps, type SidebarMenuSkeletonProps, type SidebarMenuSubButtonProps, type SidebarProviderProps, type SidebarStrings, } from './sidebar';
+/**
+ * @deprecated Use `useLayoutSidebar` from `themelia-react-ui/layout/sidebar`.
+ * This vendored compatibility re-export remains available through 1.x.
+ */
+export { useSidebar } from '../../ui/sidebar';

package/dist/components/base/sidebar/sidebar.d.ts

@@ -0,0 +1,135 @@
+/**
+ * base/sidebar — tokenized wrapper around the shadcn `Sidebar` compound component.
+ *
+ * The shadcn source stays untouched. This layer applies the package shell,
+ * density, spacing, typography, focus, and stable DOM-hook contracts while
+ * preserving every compound part and polymorphic `render` seam.
+ */
+import * as React from 'react';
+import { SidebarContent as SidebarContentPrimitive, SidebarFooter as SidebarFooterPrimitive, SidebarGroup as SidebarGroupPrimitive, SidebarGroupAction as SidebarGroupActionPrimitive, SidebarGroupContent as SidebarGroupContentPrimitive, SidebarGroupLabel as SidebarGroupLabelPrimitive, SidebarHeader as SidebarHeaderPrimitive, SidebarInput as SidebarInputPrimitive, SidebarInset as SidebarInsetPrimitive, SidebarMenu as SidebarMenuPrimitive, SidebarMenuAction as SidebarMenuActionPrimitive, SidebarMenuBadge as SidebarMenuBadgePrimitive, SidebarMenuButton as SidebarMenuButtonPrimitive, SidebarMenuItem as SidebarMenuItemPrimitive, SidebarMenuSub as SidebarMenuSubPrimitive, SidebarMenuSubButton as SidebarMenuSubButtonPrimitive, SidebarMenuSubItem as SidebarMenuSubItemPrimitive, SidebarRail as SidebarRailPrimitive, SidebarSeparator as SidebarSeparatorPrimitive, SidebarTrigger as SidebarTriggerPrimitive, useSidebar as useSidebarPrimitive } from '../../ui/sidebar';
+import type { ComponentScale } from '../../../lib/component-vocabulary';
+import { type StringsProp } from '../../../lib/strings';
+export interface SidebarStrings {
+    mobileTitle: string;
+    mobileDescription: string;
+}
+export declare const defaultSidebarStrings: SidebarStrings;
+export interface SidebarProps extends React.ComponentProps<'div'> {
+    /** Edge where the desktop rail and mobile sheet are anchored. */
+    side?: 'left' | 'right';
+    /** Surface treatment and inset behavior for the desktop shell. */
+    variant?: 'sidebar' | 'floating' | 'inset';
+    /** Desktop collapse mode. `none` renders a permanently expanded panel. */
+    collapsible?: 'offcanvas' | 'icon' | 'none';
+    /** Keeps the desktop sidebar in its parent layout instead of fixing it to the viewport. */
+    contained?: boolean;
+    /** Classes for the visible sidebar surface, separate from the positioning container. */
+    surfaceClassName?: string;
+    /** Classes for the responsive positioning root. */
+    rootClassName?: string;
+    /** Copy for the visually hidden mobile sheet title and description. */
+    strings?: StringsProp<SidebarStrings>;
+}
+type SidebarContentProps = React.ComponentProps<typeof SidebarContentPrimitive>;
+type SidebarFooterProps = React.ComponentProps<typeof SidebarFooterPrimitive>;
+type SidebarGroupProps = React.ComponentProps<typeof SidebarGroupPrimitive>;
+type SidebarGroupActionProps = React.ComponentProps<typeof SidebarGroupActionPrimitive>;
+type SidebarGroupContentProps = React.ComponentProps<typeof SidebarGroupContentPrimitive>;
+type SidebarGroupLabelProps = React.ComponentProps<typeof SidebarGroupLabelPrimitive>;
+type SidebarHeaderProps = React.ComponentProps<typeof SidebarHeaderPrimitive>;
+export interface SidebarInputProps extends React.ComponentProps<typeof SidebarInputPrimitive> {
+    /** Accessible name when no visible label is associated with the navigation search. */
+    'aria-label'?: string;
+    /** Search or filter hint. */
+    placeholder?: string;
+    /** Controlled input value. */
+    value?: React.InputHTMLAttributes<HTMLInputElement>['value'];
+    /** Disables the navigation input. */
+    disabled?: boolean;
+    /** Native input change callback. */
+    onChange?: React.ChangeEventHandler<HTMLInputElement>;
+    /** Additional classes merged with the tokenized control defaults. */
+    className?: string;
+}
+type SidebarInsetProps = React.ComponentProps<typeof SidebarInsetPrimitive>;
+export type SidebarMenuDensity = 'compact' | 'default' | 'comfortable';
+export interface SidebarMenuProps extends React.ComponentProps<typeof SidebarMenuPrimitive> {
+    /** Row and child-list rhythm. Inherits the nearest sidebar menu/provider. */
+    menuDensity?: SidebarMenuDensity;
+}
+type SidebarMenuActionProps = React.ComponentProps<typeof SidebarMenuActionPrimitive>;
+export interface SidebarMenuBadgeProps extends React.ComponentProps<typeof SidebarMenuBadgePrimitive> {
+    /** Render in normal flow, for example inside a nested menu button. */
+    inline?: boolean;
+    /** Count-bubble size. @default "md" */
+    size?: ComponentScale;
+}
+export interface SidebarMenuButtonProps extends Omit<React.ComponentProps<typeof SidebarMenuButtonPrimitive>, 'size' | 'isActive'> {
+    /** Explicit row scale. Otherwise follows menuDensity, or md in an unconfigured base menu. */
+    size?: ComponentScale;
+    /** Marks the navigation item as current. */
+    active?: boolean;
+}
+type SidebarMenuItemProps = React.ComponentProps<typeof SidebarMenuItemPrimitive>;
+export interface SidebarMenuSkeletonProps extends React.ComponentProps<'div'> {
+    /** Show the leading icon placeholder. */
+    showIcon?: boolean;
+    /** Deterministic text-bar width. @default "72%" */
+    width?: string;
+}
+type SidebarMenuSubProps = React.ComponentProps<typeof SidebarMenuSubPrimitive>;
+export interface SidebarMenuSubButtonProps extends Omit<React.ComponentProps<typeof SidebarMenuSubButtonPrimitive>, 'isActive'> {
+    /** Marks the nested navigation item as current. */
+    active?: boolean;
+}
+type SidebarMenuSubItemProps = React.ComponentProps<typeof SidebarMenuSubItemPrimitive>;
+export interface SidebarProviderProps extends React.ComponentProps<'div'> {
+    /** Use the provider width for drawers in embedded workspaces; viewport remains the default. */
+    adaptTo?: 'viewport' | 'container';
+    /** Initial expanded state for uncontrolled sidebars. @default true */
+    defaultOpen?: boolean;
+    /** Controlled expanded state. */
+    open?: boolean;
+    /** Controlled state callback. */
+    onOpenChange?: (open: boolean) => void;
+    /** Default menu rhythm; individual menus may override it. */
+    menuDensity?: SidebarMenuDensity;
+    /** Sidebar shell contents. */
+    children?: React.ReactNode;
+    /** Scoped shell token overrides and other root styles. */
+    style?: React.CSSProperties;
+    /** Additional classes merged with the provider root. */
+    className?: string;
+}
+type SidebarRailProps = React.ComponentProps<typeof SidebarRailPrimitive>;
+type SidebarSeparatorProps = React.ComponentProps<typeof SidebarSeparatorPrimitive>;
+type SidebarTriggerProps = React.ComponentProps<typeof SidebarTriggerPrimitive>;
+declare function SidebarProvider({ className, style, menuDensity, ...props }: SidebarProviderProps): React.JSX.Element;
+/** Tokenized responsive sidebar shell with contained and viewport-fixed modes. */
+declare function Sidebar({ side, variant, collapsible, contained, className, surfaceClassName, rootClassName, children, dir, strings: stringsProp, ...props }: SidebarProps): React.JSX.Element;
+declare function SidebarHeader({ className, ...props }: SidebarHeaderProps): React.JSX.Element;
+declare function SidebarFooter({ className, ...props }: SidebarFooterProps): React.JSX.Element;
+declare function SidebarContent({ className, ...props }: SidebarContentProps): React.JSX.Element;
+declare function SidebarGroup({ className, ...props }: SidebarGroupProps): React.JSX.Element;
+declare function SidebarGroupContent({ className, ...props }: SidebarGroupContentProps): React.JSX.Element;
+declare function SidebarGroupAction({ className, ...props }: SidebarGroupActionProps): React.JSX.Element;
+declare function SidebarInput({ className, ...props }: SidebarInputProps): React.JSX.Element;
+declare function SidebarSeparator({ className, ...props }: SidebarSeparatorProps): React.JSX.Element;
+declare function SidebarMenu({ className, menuDensity, ...props }: SidebarMenuProps): React.JSX.Element;
+declare function SidebarMenuItem({ className, ...props }: SidebarMenuItemProps): React.JSX.Element;
+declare function SidebarMenuAction({ className, ...props }: SidebarMenuActionProps): React.JSX.Element;
+declare function SidebarMenuBadge({ className, inline, size, children, ...props }: SidebarMenuBadgeProps): React.JSX.Element;
+declare function SidebarMenuSkeleton({ className, showIcon, style, width, ...props }: SidebarMenuSkeletonProps): React.JSX.Element;
+declare function SidebarMenuSub({ className, ...props }: SidebarMenuSubProps): React.JSX.Element;
+declare function SidebarMenuSubItem({ className, ...props }: SidebarMenuSubItemProps): React.JSX.Element;
+declare function SidebarInset({ className, ...props }: SidebarInsetProps): React.JSX.Element;
+declare function SidebarRail({ className, ...props }: SidebarRailProps): React.JSX.Element;
+declare function SidebarTrigger({ className, ...props }: SidebarTriggerProps): React.JSX.Element;
+declare function SidebarMenuButton({ className, render, size, tooltip, children, active, ...props }: SidebarMenuButtonProps): React.JSX.Element;
+declare function SidebarMenuSubButton({ className, children, active, ...props }: SidebarMenuSubButtonProps): React.JSX.Element;
+declare function SidebarGroupLabel({ className, children, ...props }: SidebarGroupLabelProps): React.JSX.Element;
+export { Sidebar, SidebarContent, SidebarFooter, SidebarGroup, SidebarGroupAction, SidebarGroupContent, SidebarGroupLabel, SidebarHeader, SidebarInput, SidebarInset, SidebarMenu, SidebarMenuAction, SidebarMenuBadge, SidebarMenuButton, SidebarMenuItem, SidebarMenuSkeleton, SidebarMenuSub, SidebarMenuSubButton, SidebarMenuSubItem, SidebarProvider, SidebarRail, SidebarSeparator, SidebarTrigger, };
+/** Internal bridge for the layout layer; not part of the base package entrypoint. */
+export declare const useBaseSidebarContext: typeof useSidebarPrimitive;
+/** Internal density bridge for composed navigation; not a base entrypoint export. */
+export declare function useBaseSidebarMenuDensity(): SidebarMenuDensity | undefined;

package/dist/components/base/signature-pad/index.d.ts

@@ -0,0 +1,4 @@
+export { SignaturePad, SignaturePadPreview } from './signature-pad';
+export { signaturePadToSVG, isSignatureEmpty } from './signature-pad.utils';
+export { defaultSignaturePadStrings } from './signature-pad.types';
+export type { SignaturePadPoint, SignaturePadStroke, SignaturePadValue, SignaturePadFormat, SignaturePadExportOptions, SignaturePadHandle, SignaturePadStrings, SignaturePadProps, SignaturePadPreviewProps } from './signature-pad.types';

package/dist/components/base/signature-pad/signature-pad.d.ts

@@ -0,0 +1,4 @@
+import { type SignaturePadHandle, type SignaturePadProps, type SignaturePadPreviewProps } from './signature-pad.types';
+export declare const SignaturePad: import("react").ForwardRefExoticComponent<SignaturePadProps & import("react").RefAttributes<SignaturePadHandle>>;
+/** Server-renderable preview; normalized geometry follows the semantic foreground. */
+export declare const SignaturePadPreview: import("react").ForwardRefExoticComponent<SignaturePadPreviewProps & import("react").RefAttributes<SVGSVGElement>>;

package/dist/components/base/signature-pad/signature-pad.types.d.ts

@@ -0,0 +1,66 @@
+import type { ComponentPropsWithoutRef } from 'react';
+import type { StringsProp } from '../../../lib/strings';
+/** Coordinates are fractions of the drawing area, so signatures survive resize. */
+export interface SignaturePadPoint {
+    x: number;
+    y: number;
+    pressure: number;
+}
+export interface SignaturePadStroke {
+    points: readonly SignaturePadPoint[];
+}
+export interface SignaturePadValue {
+    strokes: readonly SignaturePadStroke[];
+    /** Accessible alternative to drawing; included in exports and native form data. */
+    typedName?: string;
+}
+export type SignaturePadFormat = 'png' | 'svg' | 'json';
+export interface SignaturePadExportOptions {
+    width?: number;
+    height?: number;
+    scale?: number;
+}
+export interface SignaturePadHandle {
+    focus: () => void;
+    clear: () => void;
+    undo: () => void;
+    redo: () => void;
+    /** PNG is a data URL, SVG is markup, JSON is the structured value. */
+    serialize: (format?: SignaturePadFormat, options?: SignaturePadExportOptions) => string;
+}
+export interface SignaturePadStrings {
+    label: string;
+    instructions: string;
+    drawingInstructions: string;
+    placeholder: string;
+    typedName: string;
+    undo: string;
+    redo: string;
+    clear: string;
+    empty: string;
+    signed: string;
+}
+export declare const defaultSignaturePadStrings: SignaturePadStrings;
+export interface SignaturePadProps extends Omit<ComponentPropsWithoutRef<'div'>, 'children' | 'defaultValue' | 'onChange'> {
+    /** Controlled structured signature. */
+    value?: SignaturePadValue;
+    /** Initial structured signature for uncontrolled use. */
+    defaultValue?: SignaturePadValue;
+    onValueChange?: (value: SignaturePadValue) => void;
+    disabled?: boolean;
+    readOnly?: boolean;
+    invalid?: boolean;
+    /** Native field serializes JSON; an empty signature fails required validation. */
+    name?: string;
+    form?: string;
+    required?: boolean;
+    /** Shows the keyboard-accessible typed signature alternative. @default true */
+    allowTypedSignature?: boolean;
+    /** Ink diameter in CSS drawing pixels; pen pressure varies it. @default 2 */
+    strokeWidth?: number;
+    strings?: StringsProp<SignaturePadStrings>;
+}
+export interface SignaturePadPreviewProps extends ComponentPropsWithoutRef<'svg'> {
+    value: SignaturePadValue;
+    strokeWidth?: number;
+}

package/dist/components/base/signature-pad/signature-pad.utils.d.ts

@@ -0,0 +1,8 @@
+import type { SignaturePadValue } from './signature-pad.types';
+export declare const emptySignature: SignaturePadValue;
+export declare function isSignatureEmpty(value: SignaturePadValue): boolean;
+export declare function normalizeSignature(value: SignaturePadValue): SignaturePadValue;
+/** Drawing geometry, separate from structural UI spacing and theme tokens. */
+export declare function drawSignature(context: CanvasRenderingContext2D, value: SignaturePadValue, width: number, height: number, strokeWidth: number): void;
+/** Semantic currentColor is preserved unless a resolved export ink is supplied. */
+export declare function signaturePadToSVG(value: SignaturePadValue, width?: number, height?: number, strokeWidth?: number, ink?: string): string;

package/dist/components/base/skeleton/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Shape-preserving loading placeholders.
+ *
+ * `Skeleton` is the bare shimmering block. The four recipes above it —
+ * `ContentSkeleton`, `PageSkeleton`, `TwoColumnPageSkeleton` and
+ * `TableSkeleton` — pre-arrange those blocks into the geometry of a content
+ * row, a page, a two-column detail view, and a table, so the layout does not
+ * jump when the real content arrives.
+ *
+ * Reach for a skeleton when the pending region has a known shape. When it does
+ * not, use `Spinner` from `themelia-react-ui/base/spinner`, or `LoadingState`
+ * from `themelia-react-ui/base/feedback` for the standard loading message.
+ */
+export * from './skeleton';

package/dist/components/base/skeleton/skeleton.d.ts

@@ -0,0 +1,54 @@
+import * as React from 'react';
+import { Skeleton as PrimitiveSkeleton } from '../../ui/skeleton';
+type DivProps = React.ComponentPropsWithoutRef<'div'>;
+export interface SkeletonProps extends React.ComponentPropsWithoutRef<typeof PrimitiveSkeleton> {
+}
+export declare function Skeleton({ className, ...props }: SkeletonProps): React.JSX.Element;
+export declare namespace Skeleton {
+    var displayName: string;
+}
+export interface ContentSkeletonProps extends DivProps {
+    /** Number of text rows rendered in the content stack. */
+    lines?: number;
+    /** Render an avatar/media placeholder before the text stack. */
+    avatar?: boolean;
+    /** Render a small action placeholder aligned to the trailing edge. */
+    action?: boolean;
+    /** Optional per-line width classes. Keep these as Tailwind width utilities. */
+    lineWidths?: readonly string[];
+}
+export declare const ContentSkeleton: React.ForwardRefExoticComponent<ContentSkeletonProps & React.RefAttributes<HTMLDivElement>>;
+export interface PageSkeletonProps extends DivProps {
+    /** Number of compact KPI cards below the page header. */
+    stats?: number;
+    /** Number of content cards below the optional stats row. */
+    sections?: number;
+    /** Number of skeleton lines in each content card. */
+    sectionLines?: number;
+    /** Render tab/filter placeholders between the header and content. */
+    tabs?: boolean;
+    /** Number of action button placeholders in the page header. */
+    actions?: number;
+}
+export declare const PageSkeleton: React.ForwardRefExoticComponent<PageSkeletonProps & React.RefAttributes<HTMLDivElement>>;
+export interface TwoColumnPageSkeletonProps extends DivProps {
+    /** Number of primary column cards. */
+    mainSections?: number;
+    /** Number of secondary column cards. */
+    sidebarSections?: number;
+    /** Lines per primary column card. */
+    mainLines?: number;
+    /** Lines per secondary column card. */
+    sidebarLines?: number;
+}
+export declare const TwoColumnPageSkeleton: React.ForwardRefExoticComponent<TwoColumnPageSkeletonProps & React.RefAttributes<HTMLDivElement>>;
+export interface TableSkeletonProps extends DivProps {
+    rows?: number;
+    /** How many columns the grid uses. */
+    columns?: number;
+    toolbar?: boolean;
+    /** Content below the body. */
+    footer?: boolean;
+}
+export declare const TableSkeleton: React.ForwardRefExoticComponent<TableSkeletonProps & React.RefAttributes<HTMLDivElement>>;
+export {};

package/dist/components/base/spinner/index.d.ts

@@ -0,0 +1 @@
+export { Spinner, defaultSpinnerStrings, type SpinnerProps, type SpinnerStrings, type SpinnerVariant, } from './spinner';

package/dist/components/base/spinner/spinner.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Spinner — three-variant loading indicator with optional label.
+ *
+ * Variants:
+ *  - `default` — circular SVG spinner
+ *  - `shimmer` — round shimmer bar
+ *  - `progress` — slim animated progress strip
+ *
+ * `variant` resolves via `useSpinnerConfig().defaultVariant ?? 'default'`,
+ * so a consumer can set the library-wide spinner style at the
+ * `<UIProvider>` root and override per-mount as needed. Forwards a ref to
+ * the outer wrapper so consumers can position/measure the spinner.
+ */
+import { type CSSProperties } from 'react';
+import { type StringsProp } from '../../../lib/strings';
+export type SpinnerVariant = 'default' | 'shimmer' | 'progress';
+export interface SpinnerStrings {
+    /** Accessible fallback when an indeterminate progress bar has no visible label. */
+    loading: string;
+}
+export declare const defaultSpinnerStrings: SpinnerStrings;
+export interface SpinnerProps {
+    /** Display label. */
+    label?: string;
+    className?: string;
+    /** Semantic tone. */
+    variant?: SpinnerVariant;
+    /** Localizes the fallback progress-bar name. */
+    strings?: StringsProp<SpinnerStrings>;
+    style?: CSSProperties;
+}
+export declare const Spinner: import("react").ForwardRefExoticComponent<SpinnerProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist/components/base/structure/adaptive-grid.d.ts

@@ -0,0 +1,3 @@
+import type { AdaptiveGridProps } from './structure.types';
+/** AdaptiveGrid — equal peer columns driven by the available inline size. */
+export declare const AdaptiveGrid: import("react").ForwardRefExoticComponent<Omit<AdaptiveGridProps, "ref"> & import("react").RefAttributes<HTMLDivElement>>;

package/dist/components/base/structure/grid-cell.d.ts

@@ -0,0 +1,3 @@
+import type { GridCellProps } from './structure.types';
+/** GridCell — a Grid child that occupies more than one column, clamped to the columns that exist. */
+export declare const GridCell: import("react").ForwardRefExoticComponent<Omit<GridCellProps, "ref"> & import("react").RefAttributes<HTMLDivElement>>;

package/dist/components/base/structure/grid.d.ts

@@ -0,0 +1,3 @@
+import type { GridProps } from './structure.types';
+/** Grid — responsive card/tile composition with a one-to-two-column default. */
+export declare const Grid: import("react").ForwardRefExoticComponent<Omit<GridProps, "ref"> & import("react").RefAttributes<HTMLDivElement>>;

package/dist/components/base/structure/index.d.ts

@@ -0,0 +1,5 @@
+export { AdaptiveGrid } from './adaptive-grid';
+export { Grid } from './grid';
+export { GridCell } from './grid-cell';
+export { Stack } from './stack';
+export type { AdaptiveGridMinimum, AdaptiveGridProps, GridCellProps, GridProps, ResponsiveValue, StackProps, StructureAlign, StructureBreakpoint, StructureGap, TextGap, StructureJustify, } from './structure.types';

package/dist/components/base/structure/stack.d.ts

@@ -0,0 +1,3 @@
+import type { StackProps } from './structure.types';
+/** Stack — one-dimensional composition with vertical, token-spaced defaults. */
+export declare const Stack: import("react").ForwardRefExoticComponent<Omit<StackProps, "ref"> & import("react").RefAttributes<HTMLDivElement>>;

package/dist/components/base/structure/structure.context.d.ts

@@ -0,0 +1,6 @@
+/**
+ * The nearest Grid publishes its resolved column ladder so a GridCell can clamp
+ * a numeric span to the tracks that exist at each breakpoint. Undefined means
+ * the cell is not inside a Grid.
+ */
+export declare const GridColumnsContext: import("react").Context<Partial<Record<import("./structure.types").StructureBreakpoint, 3 | 1 | 2 | 4>> | undefined>;

package/dist/components/base/structure/structure.recipes.d.ts

@@ -0,0 +1,27 @@
+import type { AdaptiveGridMinimum, GridColumnLadder, ResponsiveValue, StructureAlign, StructureGap, StructureJustify } from './structure.types';
+export declare function stackRecipe({ direction, gap, align, justify, wrap, }: {
+    direction?: ResponsiveValue<'vertical' | 'horizontal'>;
+    gap?: ResponsiveValue<StructureGap>;
+    align?: ResponsiveValue<StructureAlign>;
+    justify?: ResponsiveValue<StructureJustify>;
+    wrap?: ResponsiveValue<boolean>;
+}): string[];
+export declare function resolveGridColumns(columns?: ResponsiveValue<1 | 2 | 3 | 4>): GridColumnLadder;
+export declare function gridRecipe({ columns, gap, rowGap, columnGap, align, }: {
+    columns?: ResponsiveValue<1 | 2 | 3 | 4>;
+    gap?: ResponsiveValue<StructureGap>;
+    rowGap?: ResponsiveValue<StructureGap>;
+    columnGap?: ResponsiveValue<StructureGap>;
+    align?: ResponsiveValue<StructureAlign>;
+}): string[];
+export declare function adaptiveGridRecipe({ minColumnWidth, gap, rowGap, columnGap, align, }: {
+    minColumnWidth?: AdaptiveGridMinimum;
+    gap?: ResponsiveValue<StructureGap>;
+    rowGap?: ResponsiveValue<StructureGap>;
+    columnGap?: ResponsiveValue<StructureGap>;
+    align?: ResponsiveValue<StructureAlign>;
+}): string[];
+export declare function spanRecipe({ span, columns, }: {
+    span?: ResponsiveValue<1 | 2 | 3 | 4 | 'full'>;
+    columns?: GridColumnLadder;
+}): string[];

package/dist/components/base/structure/structure.responsive.d.ts

@@ -0,0 +1,5 @@
+import type { ResponsiveValue, StructureBreakpoint } from './structure.types';
+export declare const STRUCTURE_BREAKPOINTS: readonly StructureBreakpoint[];
+export declare function resolveResponsiveEntries<T>(value: ResponsiveValue<T> | undefined, fallback: T): Partial<Record<StructureBreakpoint, T>>;
+export declare function resolveOptionalResponsiveEntries<T>(value: ResponsiveValue<T> | undefined): Partial<Record<StructureBreakpoint, T>>;
+export declare function compileResponsiveClasses<T extends string | number>(entries: Partial<Record<StructureBreakpoint, T>>, classMap: Record<StructureBreakpoint, Record<T, string>>): string[];