@jfrader/ui 0.0.0-stage → 0.1.0

package/dist/types/components/breadcrumbs/breadcrumbs.d.ts

@@ -0,0 +1,15 @@
+import { type HTMLAttributes, type LiHTMLAttributes, type ReactNode } from 'react';
+export interface BreadcrumbsProps extends HTMLAttributes<HTMLElement> {
+    /** Accessible name of the navigation landmark. */
+    label?: string;
+    /** Rendered (aria-hidden) between items. */
+    separator?: ReactNode;
+}
+export interface BreadcrumbsItemProps extends LiHTMLAttributes<HTMLLIElement> {
+    href?: string;
+    /** Marks the current page. Defaults to the last item when no item sets it. */
+    current?: boolean;
+}
+export declare const Breadcrumbs: import("react").ForwardRefExoticComponent<BreadcrumbsProps & import("react").RefAttributes<HTMLElement>> & {
+    Item: import("react").ForwardRefExoticComponent<BreadcrumbsItemProps & import("react").RefAttributes<HTMLLIElement>>;
+};

package/dist/types/components/breadcrumbs/index.d.ts

@@ -0,0 +1,2 @@
+export { Breadcrumbs } from './breadcrumbs';
+export type { BreadcrumbsItemProps, BreadcrumbsProps } from './breadcrumbs';

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

@@ -0,0 +1,34 @@
+import { type ButtonHTMLAttributes, type ReactNode, type RefCallback } from 'react';
+import { type Interpolation, type Theme } from '../../styling/css';
+export type ButtonVariant = 'solid' | 'soft' | 'outline' | 'ghost';
+export type ButtonTone = 'neutral' | 'accent' | 'danger';
+export type ButtonSize = 'sm' | 'md' | 'lg';
+/** Props a `render` callback spreads onto the element it returns. */
+export interface ButtonRenderProps extends Omit<ButtonHTMLAttributes<HTMLElement>, 'color' | 'disabled'> {
+    ref: RefCallback<HTMLElement> | null;
+    css: Interpolation<Theme>;
+    'data-ui': string;
+}
+export interface ButtonProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'color'> {
+    variant?: ButtonVariant;
+    tone?: ButtonTone;
+    size?: ButtonSize;
+    loading?: boolean;
+    startIcon?: ReactNode;
+    endIcon?: ReactNode;
+    /** Consumer style overrides, merged after the component's own styles. */
+    css?: Interpolation<Theme>;
+    /**
+     * Replaces the native button. Spread ALL supplied props onto the operative element and attach
+     * the supplied ref. Both that ref and the forwarded ref refer to the rendered element, which
+     * need not be a button; the public forwarded-ref type remains HTMLButtonElement for compatibility.
+     * Overridden handlers, className and style win; compose behavior manually to retain both:
+     * `onClick={(e) => { p.onClick?.(e); mine(e); }}`.
+     * Only this render path joins data-ui markers into a token list; library selectors should use
+     * `[data-ui~="button"]`. The default button always has data-ui="button".
+     * Disabled anchors receive aria-disabled and remain focusable. Primary click/Enter activation
+     * is blocked by the supplied handler; auxiliary/middle-click navigation is NOT covered.
+     */
+    render?: (props: ButtonRenderProps) => ReactNode;
+}
+export declare const Button: import("react").ForwardRefExoticComponent<ButtonProps & import("react").RefAttributes<HTMLButtonElement>>;

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

@@ -0,0 +1,2 @@
+export { Button } from './button';
+export type { ButtonProps, ButtonRenderProps, ButtonSize, ButtonTone, ButtonVariant } from './button';

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

@@ -0,0 +1,28 @@
+import { type HTMLAttributes } from 'react';
+/** Day of the week as counted by `Date#getUTCDay`: 0 is Sunday, 6 is Saturday. */
+export type CalendarWeekday = 0 | 1 | 2 | 3 | 4 | 5 | 6;
+export interface CalendarProps extends Omit<HTMLAttributes<HTMLDivElement>, 'defaultValue' | 'onChange'> {
+    /** Selected date, 'YYYY-MM-DD'. */
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    /** Displayed month, 'YYYY-MM'. Defaults to the month of the value, else the current month. */
+    visibleMonth?: string;
+    defaultVisibleMonth?: string;
+    onVisibleMonthChange?: (month: string) => void;
+    /** Earliest selectable date, 'YYYY-MM-DD'. */
+    min?: string;
+    /** Latest selectable date, 'YYYY-MM-DD'. */
+    max?: string;
+    /** BCP 47 tag. Defaults to `navigator.language`. */
+    locale?: string;
+    /** Defaults to the locale's week start. */
+    firstDayOfWeek?: CalendarWeekday;
+}
+/** The header renders its own month buttons and label. */
+export type CalendarHeaderProps = Omit<HTMLAttributes<HTMLDivElement>, 'children'>;
+export type CalendarGridProps = HTMLAttributes<HTMLTableElement>;
+export declare const Calendar: import("react").ForwardRefExoticComponent<CalendarProps & import("react").RefAttributes<HTMLDivElement>> & {
+    Header: import("react").ForwardRefExoticComponent<CalendarHeaderProps & import("react").RefAttributes<HTMLDivElement>>;
+    Grid: import("react").ForwardRefExoticComponent<CalendarGridProps & import("react").RefAttributes<HTMLTableElement>>;
+};

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

@@ -0,0 +1,9 @@
+export declare const rootStyle: import("@emotion/react").SerializedStyles;
+export declare const headerStyle: import("@emotion/react").SerializedStyles;
+export declare const labelStyle: import("@emotion/react").SerializedStyles;
+export declare const navButtonStyle: import("@emotion/react").SerializedStyles;
+export declare const glyphStyle: import("@emotion/react").SerializedStyles;
+export declare const gridStyle: import("@emotion/react").SerializedStyles;
+export declare const weekdayStyle: import("@emotion/react").SerializedStyles;
+export declare const cellStyle: import("@emotion/react").SerializedStyles;
+export declare const dayStyle: import("@emotion/react").SerializedStyles;

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

@@ -0,0 +1,37 @@
+import type { CalendarWeekday } from './calendar';
+export declare const DAYS_PER_WEEK = 7;
+export declare const REFERENCE_SUNDAY = "2026-01-04";
+export declare function dateFromParts(year: number, monthIndex: number, day: number): Date;
+export declare function dateFromIso(iso: string): Date;
+export declare const isoFromDate: (date: Date) => string;
+export declare const isIsoDate: (value: string | undefined) => value is string;
+export declare const isIsoMonth: (value: string | undefined) => value is string;
+export declare const monthOf: (iso: string) => string;
+export declare const firstOfMonth: (month: string) => string;
+export declare function shiftDays(iso: string, days: number): string;
+export declare const shiftMonth: (month: string, months: number) => string;
+export declare const lastOfMonth: (month: string) => string;
+export declare const isWithin: (iso: string, min: string | undefined, max: string | undefined) => boolean;
+export declare function clampDate(iso: string, min: string | undefined, max: string | undefined): string;
+export declare const weekColumn: (iso: string, firstDayOfWeek: CalendarWeekday) => number;
+export interface Formatters {
+    month: Intl.DateTimeFormat;
+    day: Intl.DateTimeFormat;
+    date: Intl.DateTimeFormat;
+    weekdayShort: Intl.DateTimeFormat;
+    weekdayLong: Intl.DateTimeFormat;
+}
+export declare function localeFirstDayOfWeek(locale: string): CalendarWeekday;
+export declare const CIVIL_DATE_FORMAT_OPTIONS: {
+    calendar: string;
+    timeZone: string;
+};
+export declare function createFormatters(locale: string): Formatters;
+export declare const defaultLocale: () => string | undefined;
+interface MoveContext {
+    firstDayOfWeek: CalendarWeekday;
+    shiftKey: boolean;
+}
+type Move = (from: string, context: MoveContext) => string;
+export declare const KEY_MOVES: Record<'ltr' | 'rtl', Partial<Record<string, Move>>>;
+export {};

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

@@ -0,0 +1,2 @@
+export { Calendar } from './calendar';
+export type { CalendarGridProps, CalendarHeaderProps, CalendarProps, CalendarWeekday } from './calendar';

package/dist/types/components/card/card.d.ts

@@ -0,0 +1,34 @@
+import { type HTMLAttributes } from 'react';
+import { type Interpolation, type Theme } from '../../styling/css';
+export type CardVariant = 'flat' | 'raised';
+export type CardHeadingLevel = 1 | 2 | 3 | 4 | 5 | 6;
+export interface CardPartProps {
+    className?: string;
+    css?: Interpolation<Theme>;
+}
+export interface CardSlotProps {
+    root?: CardPartProps;
+    header?: CardPartProps;
+    title?: CardPartProps;
+    description?: CardPartProps;
+    content?: CardPartProps;
+    footer?: CardPartProps;
+}
+export interface CardProps extends HTMLAttributes<HTMLDivElement> {
+    variant?: CardVariant;
+    slotProps?: CardSlotProps;
+}
+export type CardHeaderProps = HTMLAttributes<HTMLDivElement>;
+export interface CardTitleProps extends HTMLAttributes<HTMLHeadingElement> {
+    level?: CardHeadingLevel;
+}
+export type CardDescriptionProps = HTMLAttributes<HTMLParagraphElement>;
+export type CardContentProps = HTMLAttributes<HTMLDivElement>;
+export type CardFooterProps = HTMLAttributes<HTMLDivElement>;
+export declare const Card: import("react").ForwardRefExoticComponent<CardProps & import("react").RefAttributes<HTMLDivElement>> & {
+    Header: import("react").ForwardRefExoticComponent<CardHeaderProps & import("react").RefAttributes<HTMLDivElement>>;
+    Title: import("react").ForwardRefExoticComponent<CardTitleProps & import("react").RefAttributes<HTMLHeadingElement>>;
+    Description: import("react").ForwardRefExoticComponent<CardDescriptionProps & import("react").RefAttributes<HTMLParagraphElement>>;
+    Content: import("react").ForwardRefExoticComponent<CardContentProps & import("react").RefAttributes<HTMLDivElement>>;
+    Footer: import("react").ForwardRefExoticComponent<CardFooterProps & import("react").RefAttributes<HTMLDivElement>>;
+};

package/dist/types/components/card/index.d.ts

@@ -0,0 +1,2 @@
+export { Card } from './card';
+export type { CardContentProps, CardDescriptionProps, CardFooterProps, CardHeaderProps, CardHeadingLevel, CardPartProps, CardProps, CardSlotProps, CardTitleProps, CardVariant, } from './card';

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

@@ -0,0 +1,21 @@
+import { type InputHTMLAttributes, type ReactNode } from 'react';
+import { type Interpolation, type Theme } from '../../styling/css';
+export type CheckboxSize = 'sm' | 'md';
+export interface CheckboxPartProps {
+    className?: string;
+    css?: Interpolation<Theme>;
+}
+export interface CheckboxProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'size' | 'type'> {
+    label?: ReactNode;
+    description?: ReactNode;
+    indeterminate?: boolean;
+    size?: CheckboxSize;
+    onCheckedChange?: (checked: boolean) => void;
+    slotProps?: {
+        root?: CheckboxPartProps;
+        label?: CheckboxPartProps;
+        control?: CheckboxPartProps;
+        description?: CheckboxPartProps;
+    };
+}
+export declare const Checkbox: import("react").ForwardRefExoticComponent<CheckboxProps & import("react").RefAttributes<HTMLInputElement>>;

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

@@ -0,0 +1,2 @@
+export { Checkbox } from './checkbox';
+export type { CheckboxProps, CheckboxPartProps, CheckboxSize } from './checkbox';

package/dist/types/components/combobox/combobox.d.ts

@@ -0,0 +1,44 @@
+import { type HTMLAttributes, type ReactNode } from 'react';
+import { type TextFieldProps } from '../text-field';
+export interface ComboboxProps {
+    /** `null` is the controlled "nothing selected" state. */
+    value?: string | null;
+    defaultValue?: string;
+    /** Fires once per accepted selection with the option's `value`, or `null` when the text is cleared. */
+    onValueChange?: (value: string | null) => void;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    /** Renders a hidden input so the value takes part in native form submission. */
+    name?: string;
+    /** Decides whether an option label matches the typed query. Defaults to a case-insensitive substring match. */
+    filter?: (label: string, query: string) => boolean;
+    /** Fires with the new input text when the user types and when a selection or Escape writes a label. */
+    onInputChange?: (query: string) => void;
+    children?: ReactNode;
+}
+export interface ComboboxInputProps extends Omit<TextFieldProps, 'value' | 'defaultValue' | 'onValueChange'> {
+    /** Root `name` is the canonical form name; an Input `name` submits an extra text entry. */
+    name?: string;
+    /** Controlled input text. */
+    inputValue?: string;
+    /** Initial input text; when set, it filters the options from the first render. */
+    defaultInputValue?: string;
+}
+export interface ComboboxListProps extends HTMLAttributes<HTMLDivElement> {
+}
+export interface ComboboxItemProps extends HTMLAttributes<HTMLDivElement> {
+    /** Unique within the combobox. */
+    value: string;
+    disabled?: boolean;
+}
+export interface ComboboxEmptyProps extends HTMLAttributes<HTMLDivElement> {
+}
+declare function ComboboxRoot({ value: valueProp, defaultValue, onValueChange, open: openProp, defaultOpen, onOpenChange, name, filter, onInputChange, children, }: ComboboxProps): import("@emotion/react/jsx-runtime").JSX.Element;
+export declare const Combobox: typeof ComboboxRoot & {
+    Input: import("react").ForwardRefExoticComponent<ComboboxInputProps & import("react").RefAttributes<HTMLInputElement>>;
+    List: import("react").ForwardRefExoticComponent<ComboboxListProps & import("react").RefAttributes<HTMLDivElement>>;
+    Item: import("react").ForwardRefExoticComponent<ComboboxItemProps & import("react").RefAttributes<HTMLDivElement>>;
+    Empty: import("react").ForwardRefExoticComponent<ComboboxEmptyProps & import("react").RefAttributes<HTMLDivElement>>;
+};
+export {};

package/dist/types/components/combobox/index.d.ts

@@ -0,0 +1,2 @@
+export { Combobox } from './combobox';
+export type { ComboboxEmptyProps, ComboboxInputProps, ComboboxItemProps, ComboboxListProps, ComboboxProps, } from './combobox';

package/dist/types/components/command-palette/command-palette.d.ts

@@ -0,0 +1,47 @@
+import { type ButtonHTMLAttributes, type DialogHTMLAttributes, type HTMLAttributes, type InputHTMLAttributes, type ReactNode } from 'react';
+export interface CommandPaletteProps {
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    /** Accessible name of the dialog, input and listbox. */
+    label?: string;
+    /** Decides whether an item's label (or keywords) matches the query. Case-insensitive substring by default. */
+    filter?: (text: string, query: string) => boolean;
+    /** Rendered by CommandPalette.Empty when nothing matches. */
+    emptyMessage?: ReactNode;
+    /** Live region text announced after the query changes. */
+    formatResultCount?: (count: number) => string;
+    children?: ReactNode;
+}
+export interface CommandPaletteTriggerProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+}
+export interface CommandPaletteContentProps extends Omit<DialogHTMLAttributes<HTMLDialogElement>, 'open'> {
+}
+export interface CommandPaletteInputProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'value' | 'defaultValue' | 'type'> {
+}
+export interface CommandPaletteListProps extends HTMLAttributes<HTMLDivElement> {
+}
+export interface CommandPaletteEmptyProps extends HTMLAttributes<HTMLDivElement> {
+}
+export interface CommandPaletteGroupProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
+    label: ReactNode;
+    children?: ReactNode;
+}
+export interface CommandPaletteItemProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onSelect'> {
+    /** Unique within the palette. */
+    value: string;
+    onSelect?: () => void;
+    /** Extra text the filter matches against (synonyms, aliases). */
+    keywords?: string;
+}
+declare function CommandPaletteRoot({ open: openProp, defaultOpen, onOpenChange, label, filter, emptyMessage, formatResultCount, children, }: CommandPaletteProps): import("@emotion/react/jsx-runtime").JSX.Element;
+export declare const CommandPalette: typeof CommandPaletteRoot & {
+    Trigger: import("react").ForwardRefExoticComponent<CommandPaletteTriggerProps & import("react").RefAttributes<HTMLButtonElement>>;
+    Content: import("react").ForwardRefExoticComponent<CommandPaletteContentProps & import("react").RefAttributes<HTMLDialogElement>>;
+    Input: import("react").ForwardRefExoticComponent<CommandPaletteInputProps & import("react").RefAttributes<HTMLInputElement>>;
+    List: import("react").ForwardRefExoticComponent<CommandPaletteListProps & import("react").RefAttributes<HTMLDivElement>>;
+    Empty: import("react").ForwardRefExoticComponent<CommandPaletteEmptyProps & import("react").RefAttributes<HTMLDivElement>>;
+    Group: import("react").ForwardRefExoticComponent<CommandPaletteGroupProps & import("react").RefAttributes<HTMLDivElement>>;
+    Item: import("react").ForwardRefExoticComponent<CommandPaletteItemProps & import("react").RefAttributes<HTMLDivElement>>;
+};
+export {};

package/dist/types/components/command-palette/command-palette.styles.d.ts

@@ -0,0 +1,8 @@
+export declare const dialogStyle: import("@emotion/react").SerializedStyles;
+export declare const panelStyle: import("@emotion/react").SerializedStyles;
+export declare const inputStyle: import("@emotion/react").SerializedStyles;
+export declare const listStyle: import("@emotion/react").SerializedStyles;
+export declare const groupStyle: import("@emotion/react").SerializedStyles;
+export declare const groupHeadingStyle: import("@emotion/react").SerializedStyles;
+export declare const itemStyle: import("@emotion/react").SerializedStyles;
+export declare const emptyStyle: import("@emotion/react").SerializedStyles;

package/dist/types/components/command-palette/index.d.ts

@@ -0,0 +1,2 @@
+export { CommandPalette } from './command-palette';
+export type { CommandPaletteContentProps, CommandPaletteEmptyProps, CommandPaletteGroupProps, CommandPaletteInputProps, CommandPaletteItemProps, CommandPaletteListProps, CommandPaletteProps, CommandPaletteTriggerProps, } from './command-palette';

package/dist/types/components/container/container.d.ts

@@ -0,0 +1,14 @@
+import { type HTMLAttributes } from 'react';
+import { type LayoutSpace } from '../../styling/layout-style';
+export type ContainerSize = 'sm' | 'md' | 'lg' | 'xl';
+export interface ContainerProps extends HTMLAttributes<HTMLDivElement> {
+    size?: ContainerSize;
+    paddingInline?: LayoutSpace;
+}
+export declare const CONTAINER_MAX_INLINE_SIZE: {
+    readonly sm: '640px';
+    readonly md: '768px';
+    readonly lg: '1024px';
+    readonly xl: '1280px';
+};
+export declare const Container: import("react").ForwardRefExoticComponent<ContainerProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist/types/components/container/index.d.ts

@@ -0,0 +1,3 @@
+export { Container } from './container';
+export type { ContainerProps, ContainerSize } from './container';
+export type { LayoutSpace } from '../../styling/layout-style';

package/dist/types/components/date-picker/date-picker.d.ts

@@ -0,0 +1,39 @@
+import { type HTMLAttributes, type ReactNode } from 'react';
+import { type CalendarWeekday } from '../calendar';
+import { type TextFieldProps } from '../text-field';
+export interface DatePickerProps {
+    /** Selected date, 'YYYY-MM-DD'. */
+    value?: string;
+    defaultValue?: string;
+    /** Deduplicated value-change request with the date as 'YYYY-MM-DD'; controlled values may reject it. */
+    onValueChange?: (value: string) => void;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    /** Earliest selectable date, 'YYYY-MM-DD'. */
+    min?: string;
+    /** Latest selectable date, 'YYYY-MM-DD'. */
+    max?: string;
+    /** BCP 47 tag. Defaults to `navigator.language`. */
+    locale?: string;
+    /** Defaults to the locale's week start. */
+    firstDayOfWeek?: CalendarWeekday;
+    /** Closes the popup and blocks all interaction, even with controlled open=true. */
+    disabled?: boolean;
+    /** Renders a hidden input carrying the ISO value so it takes part in native form submission. */
+    name?: string;
+    /** Shown while no date is selected. Defaults to the locale's date field names in display order. */
+    placeholder?: string;
+    children?: ReactNode;
+}
+/** Value, placeholder and form name live on the root; the input is read-only in this version. */
+export interface DatePickerInputProps extends Omit<TextFieldProps, 'value' | 'defaultValue' | 'onValueChange' | 'onChange' | 'readOnly' | 'placeholder' | 'name' | 'type'> {
+}
+/** The popup renders its own calendar. */
+export type DatePickerPopupProps = Omit<HTMLAttributes<HTMLDivElement>, 'children'>;
+declare function DatePickerRoot({ value: valueProp, defaultValue, onValueChange, open: openProp, defaultOpen, onOpenChange, min: minProp, max: maxProp, locale: localeProp, firstDayOfWeek, disabled: disabledProp, name, placeholder: placeholderProp, children, }: DatePickerProps): import("@emotion/react/jsx-runtime").JSX.Element;
+export declare const DatePicker: typeof DatePickerRoot & {
+    Input: import("react").ForwardRefExoticComponent<DatePickerInputProps & import("react").RefAttributes<HTMLInputElement>>;
+    Popup: import("react").ForwardRefExoticComponent<DatePickerPopupProps & import("react").RefAttributes<HTMLDivElement>>;
+};
+export {};

package/dist/types/components/date-picker/index.d.ts

@@ -0,0 +1,2 @@
+export { DatePicker } from './date-picker';
+export type { DatePickerInputProps, DatePickerPopupProps, DatePickerProps } from './date-picker';

package/dist/types/components/dialog/dialog.d.ts

@@ -0,0 +1,61 @@
+import { type ButtonHTMLAttributes, type DialogHTMLAttributes, type HTMLAttributes, type ReactNode, type Ref } from 'react';
+export interface DialogProps {
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    children?: ReactNode;
+}
+/** Props a part's `render` callback spreads onto the element it returns (e.g. a `Button`). */
+export interface DialogPartRenderProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+    ref: Ref<HTMLButtonElement>;
+    'data-ui': string;
+}
+export interface DialogTriggerProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+    /**
+     * Replaces the default button. Spread ALL supplied props onto the operative element and attach
+     * the supplied ref, including when composing through Button. The forwarded and callback refs
+     * refer to the rendered element, which need not be a button; their public types remain
+     * HTMLButtonElement for compatibility.
+     * Overridden handlers, className and style win; compose behavior manually to retain both:
+     * `onClick={(e) => { p.onClick?.(e); mine(e); }}`.
+     * Only the render path joins data-ui markers into a token list; library selectors should use
+     * `[data-ui~="dialog-trigger"]`. The default button always has data-ui="dialog-trigger".
+     * For disabled anchors, compose through Button's render path: aria-disabled keeps them
+     * focusable and its supplied handler blocks primary click/Enter activation, but does NOT
+     * cover auxiliary/middle-click navigation. This part alone supplies native button semantics.
+     */
+    render?: (props: DialogPartRenderProps) => ReactNode;
+}
+export interface DialogContentProps extends Omit<DialogHTMLAttributes<HTMLDialogElement>, 'open'> {
+    /** Set false to keep structured content out of the dialog's accessible description. */
+    withDescription?: boolean;
+}
+export interface DialogTitleProps extends HTMLAttributes<HTMLHeadingElement> {
+}
+export interface DialogDescriptionProps extends HTMLAttributes<HTMLParagraphElement> {
+}
+export interface DialogCloseProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+    /**
+     * Replaces the default button. Spread ALL supplied props onto the operative element and attach
+     * the supplied ref, including when composing through Button. The forwarded and callback refs
+     * refer to the rendered element, which need not be a button; their public types remain
+     * HTMLButtonElement for compatibility.
+     * Overridden handlers, className and style win; compose behavior manually to retain both:
+     * `onClick={(e) => { p.onClick?.(e); mine(e); }}`.
+     * Only the render path joins data-ui markers into a token list; library selectors should use
+     * `[data-ui~="dialog-close"]`. The default button always has data-ui="dialog-close".
+     * For disabled anchors, compose through Button's render path: aria-disabled keeps them
+     * focusable and its supplied handler blocks primary click/Enter activation, but does NOT
+     * cover auxiliary/middle-click navigation. This part alone supplies native button semantics.
+     */
+    render?: (props: DialogPartRenderProps) => ReactNode;
+}
+declare function DialogRoot({ open: openProp, defaultOpen, onOpenChange, children }: DialogProps): import("@emotion/react/jsx-runtime").JSX.Element;
+export declare const Dialog: typeof DialogRoot & {
+    Trigger: import("react").ForwardRefExoticComponent<DialogTriggerProps & import("react").RefAttributes<HTMLButtonElement>>;
+    Content: import("react").ForwardRefExoticComponent<DialogContentProps & import("react").RefAttributes<HTMLDialogElement>>;
+    Title: import("react").ForwardRefExoticComponent<DialogTitleProps & import("react").RefAttributes<HTMLHeadingElement>>;
+    Description: import("react").ForwardRefExoticComponent<DialogDescriptionProps & import("react").RefAttributes<HTMLParagraphElement>>;
+    Close: import("react").ForwardRefExoticComponent<DialogCloseProps & import("react").RefAttributes<HTMLButtonElement>>;
+};
+export {};

package/dist/types/components/dialog/index.d.ts

@@ -0,0 +1,2 @@
+export { Dialog } from './dialog';
+export type { DialogCloseProps, DialogContentProps, DialogDescriptionProps, DialogPartRenderProps, DialogProps, DialogTitleProps, DialogTriggerProps, } from './dialog';

package/dist/types/components/divider/divider.d.ts

@@ -0,0 +1,14 @@
+import { type HTMLAttributes, type ReactNode } from 'react';
+export type DividerOrientation = 'horizontal' | 'vertical';
+type DividerBaseProps = Omit<HTMLAttributes<HTMLElement>, 'children' | 'role' | 'aria-orientation'>;
+export interface DividerHorizontalProps extends DividerBaseProps {
+    orientation?: 'horizontal';
+    label?: ReactNode;
+}
+export interface DividerVerticalProps extends DividerBaseProps {
+    orientation: 'vertical';
+    label?: never;
+}
+export type DividerProps = DividerHorizontalProps | DividerVerticalProps;
+export declare const Divider: import("react").ForwardRefExoticComponent<DividerProps & import("react").RefAttributes<HTMLElement>>;
+export {};

package/dist/types/components/divider/index.d.ts

@@ -0,0 +1,2 @@
+export { Divider } from './divider';
+export type { DividerHorizontalProps, DividerOrientation, DividerProps, DividerVerticalProps } from './divider';

package/dist/types/components/field/field-anatomy.d.ts

@@ -0,0 +1,49 @@
+import { type AriaAttributes, type ReactNode } from 'react';
+import { type Interpolation, type Theme } from '../../styling/css';
+export interface FieldPartProps {
+    className?: string;
+    css?: Interpolation<Theme>;
+}
+export interface FieldSlotProps<Part = FieldPartProps> {
+    root?: Part;
+    label?: Part;
+    control?: Part;
+    description?: Part;
+    error?: Part;
+}
+interface FieldAnatomyOptions {
+    id?: string;
+    description?: ReactNode;
+    error?: ReactNode;
+    'aria-describedby'?: string;
+    'aria-invalid'?: AriaAttributes['aria-invalid'];
+}
+export declare function useFieldAnatomy({ id: idProp, description, error, 'aria-describedby': ariaDescribedByProp, 'aria-invalid': ariaInvalidProp, }: FieldAnatomyOptions): {
+    id: string;
+    descriptionId: string;
+    errorId: string;
+    describedBy: string | undefined;
+    ariaInvalid: "false" | "grammar" | "spelling" | "true" | boolean | undefined;
+};
+interface FieldRootProps {
+    'data-ui': string;
+    className?: string;
+    part?: FieldPartProps;
+    children: ReactNode;
+}
+export declare function FieldRoot({ 'data-ui': dataUi, className, part, children }: FieldRootProps): import("@emotion/react/jsx-runtime").JSX.Element;
+interface FieldLabelProps {
+    htmlFor: string;
+    required?: boolean;
+    part?: FieldPartProps;
+    children: ReactNode;
+}
+export declare function FieldLabel({ htmlFor, required, part, children }: FieldLabelProps): import("@emotion/react/jsx-runtime").JSX.Element | null;
+interface FieldMessageProps {
+    id: string;
+    part?: FieldPartProps;
+    children: ReactNode;
+}
+export declare function FieldDescription({ id, part, children }: FieldMessageProps): import("@emotion/react/jsx-runtime").JSX.Element | null;
+export declare function FieldError({ id, part, children }: FieldMessageProps): import("@emotion/react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/types/components/flex/flex.d.ts

@@ -0,0 +1,4 @@
+import { type HTMLAttributes } from 'react';
+import { type LayoutProps } from '../../styling/layout-style';
+export type FlexProps = HTMLAttributes<HTMLDivElement> & LayoutProps;
+export declare const Flex: import("react").ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & LayoutProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist/types/components/flex/index.d.ts

@@ -0,0 +1,3 @@
+export { Flex } from './flex';
+export type { FlexProps } from './flex';
+export type { FlexAlign, FlexDirection, FlexJustify, LayoutSpace } from '../../styling/layout-style';

package/dist/types/components/kbd/index.d.ts

@@ -0,0 +1,2 @@
+export { Kbd } from './kbd';
+export type { KbdGroupProps, KbdProps } from './kbd';

package/dist/types/components/kbd/kbd.d.ts

@@ -0,0 +1,6 @@
+import { type HTMLAttributes } from 'react';
+export type KbdProps = HTMLAttributes<HTMLElement>;
+export type KbdGroupProps = HTMLAttributes<HTMLSpanElement>;
+export declare const Kbd: import("react").ForwardRefExoticComponent<KbdProps & import("react").RefAttributes<HTMLElement>> & {
+    Group: import("react").ForwardRefExoticComponent<KbdGroupProps & import("react").RefAttributes<HTMLSpanElement>>;
+};

package/dist/types/components/menu/index.d.ts

@@ -0,0 +1,2 @@
+export { Menu } from './menu';
+export type { MenuContentProps, MenuItemProps, MenuProps, MenuSeparatorProps, MenuTriggerProps } from './menu';

package/dist/types/components/menu/menu.d.ts

@@ -0,0 +1,29 @@
+import { type ButtonHTMLAttributes, type HTMLAttributes, type ReactNode } from 'react';
+import { type Placement } from '@floating-ui/react';
+export interface MenuProps {
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    placement?: Placement;
+    children?: ReactNode;
+}
+export interface MenuTriggerProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+}
+export interface MenuContentProps extends HTMLAttributes<HTMLDivElement> {
+}
+export interface MenuItemProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'onSelect'> {
+    /** Called when the item is activated. The menu then closes unless a click handler called
+     * `event.preventDefault()`. */
+    onSelect?: () => void;
+    disabled?: boolean;
+}
+export interface MenuSeparatorProps extends HTMLAttributes<HTMLDivElement> {
+}
+declare function MenuRoot({ open: openProp, defaultOpen, onOpenChange, placement, children, }: MenuProps): import("@emotion/react/jsx-runtime").JSX.Element;
+export declare const Menu: typeof MenuRoot & {
+    Trigger: import("react").ForwardRefExoticComponent<MenuTriggerProps & import("react").RefAttributes<HTMLButtonElement>>;
+    Content: import("react").ForwardRefExoticComponent<MenuContentProps & import("react").RefAttributes<HTMLDivElement>>;
+    Item: import("react").ForwardRefExoticComponent<MenuItemProps & import("react").RefAttributes<HTMLButtonElement>>;
+    Separator: import("react").ForwardRefExoticComponent<MenuSeparatorProps & import("react").RefAttributes<HTMLDivElement>>;
+};
+export {};

package/dist/types/components/navigation/index.d.ts

@@ -0,0 +1,2 @@
+export { Navigation } from './navigation';
+export type { NavigationGroupProps, NavigationItemProps, NavigationProps } from './navigation';

package/dist/types/components/navigation/navigation.d.ts

@@ -0,0 +1,24 @@
+import { type AnchorHTMLAttributes, type HTMLAttributes, type ReactNode } from 'react';
+export interface NavigationProps extends HTMLAttributes<HTMLElement> {
+    /** Accessible name of the navigation landmark. */
+    label?: string;
+}
+export interface NavigationGroupProps extends HTMLAttributes<HTMLElement> {
+    label?: ReactNode;
+    /** Render as a native <details> disclosure; the label becomes its <summary>. */
+    collapsible?: boolean;
+    /** Initial `open` attribute of a collapsible group. The browser owns the state afterwards. */
+    defaultOpen?: boolean;
+}
+export interface NavigationItemProps extends AnchorHTMLAttributes<HTMLElement> {
+    href?: string;
+    /** Marks the current page (aria-current="page"). */
+    active?: boolean;
+    disabled?: boolean;
+    /** Decorative leading icon, hidden from assistive tech. */
+    icon?: ReactNode;
+}
+export declare const Navigation: import("react").ForwardRefExoticComponent<NavigationProps & import("react").RefAttributes<HTMLElement>> & {
+    Group: import("react").ForwardRefExoticComponent<NavigationGroupProps & import("react").RefAttributes<HTMLElement>>;
+    Item: import("react").ForwardRefExoticComponent<NavigationItemProps & import("react").RefAttributes<HTMLElement>>;
+};

package/dist/types/components/pagination/index.d.ts

@@ -0,0 +1,2 @@
+export { Pagination } from './pagination';
+export type { PaginationProps } from './pagination';