haze-ui 1.33.0 → 1.34.0

package/dist/types/components/NavigationMenu/NavigationMenuContext.d.ts

@@ -0,0 +1,77 @@
+import type { Dispatch, RefObject, SetStateAction } from 'react';
+import type { FloatingBehavior } from '../../utils/floating.js';
+/**
+ * Semantic slot classes (AntD v6 `classNames` shape) for the
+ * NavigationMenu family: declared once on the `<NavigationMenu>` root
+ * and distributed to every part through context — the sub-components
+ * stay prop-light while one record themes the whole bar. Consumer
+ * classes are appended at the end of each part's class list (able to
+ * override component defaults); per-part `className` props remain for
+ * one-off tweaks and still land after the slot class.
+ */
+export type NavigationMenuClassNames = {
+    /** The wrapper `<nav data-slot='navigation-menu'>` root. */
+    root?: string;
+    /** Every `<NavigationMenuList>` strip (`role='list'` ul). */
+    list?: string;
+    /** Every `<NavigationMenuItem>` row (`li`). */
+    item?: string;
+    /** Every `<NavigationMenuTrigger>` button. */
+    trigger?: string;
+    /** Every `<NavigationMenuContent>` floating panel. */
+    content?: string;
+};
+type NavigationMenuContextValue = {
+    /** Value of the item whose panel is open; null when all are closed. */
+    activeValue: string | null;
+    /** State write behind `activeValue` (Control-compatible). */
+    setActiveValue: Dispatch<SetStateAction<string | null>>;
+    /**
+     * Pointer/focus entered a trigger: opens it after the intent dwell
+     * when nothing is open yet, instantly when a sibling panel is already
+     * open (menu-traversal must not pay the delay twice). Any pending
+     * timers are dropped first.
+     */
+    hoverTrigger: (value: string) => void;
+    /**
+     * Arm the grace-period close: leaving a trigger or panel starts the
+     * countdown; any re-enter cancels it (see `cancelHoverTimers`).
+     */
+    scheduleClose: () => void;
+    /** Drop both pending timers (intent + grace). */
+    cancelHoverTimers: () => void;
+    /** Stable id of an item's content panel (aria-controls target). */
+    contentId: (value: string) => string;
+    /** Stable id of an item's trigger (aria-labelledby source). */
+    triggerId: (value: string) => string;
+    classNames: NavigationMenuClassNames | undefined;
+    /** Stretch each panel to its trigger's inline size (see NavigationMenu). */
+    stretchToTrigger: boolean;
+};
+export declare const NavigationMenuProvider: import("react").Provider<NavigationMenuContextValue | undefined>;
+export declare function useNavigationMenuContext(): NavigationMenuContextValue;
+type NavigationMenuItemContextValue = {
+    /** This item's `value`. */
+    value: string;
+    /** Whether this item's panel is the open one. */
+    open: boolean;
+    /** This item's floating pair (trigger anchor + panel), per item. */
+    floating: FloatingBehavior;
+    /**
+     * The item's own refs at their narrow element types — the same
+     * objects `floating.triggerRef`/`panelRef` carry (widened to
+     * HTMLElement by the engine), re-exposed so the parts attach them to
+     * typed DOM elements.
+     */
+    triggerRef: RefObject<HTMLButtonElement | null>;
+    panelRef: RefObject<HTMLDivElement | null>;
+    /**
+     * Whether the item carries a `<NavigationMenuContent>` child — drives
+     * the trigger's disclosure wiring (aria-expanded/aria-controls ride
+     * only on items that actually open a panel).
+     */
+    hasContent: boolean;
+};
+export declare const NavigationMenuItemProvider: import("react").Provider<NavigationMenuItemContextValue | undefined>;
+export declare function useNavigationMenuItemContext(): NavigationMenuItemContextValue;
+export {};

package/dist/types/components/NavigationMenu/NavigationMenuItem.d.ts

@@ -0,0 +1,13 @@
+import type { ComponentPropsWithoutRef, ReactNode } from 'react';
+type NavigationMenuItemProps = {
+    /**
+     * Identifies this item: the value `activeValue` carries while its
+     * panel is open. Unique within the menu.
+     */
+    value: string;
+    className?: string;
+    /** A `<NavigationMenuTrigger>` plus (optionally) its `<NavigationMenuContent>`. */
+    children?: ReactNode;
+} & Omit<ComponentPropsWithoutRef<'li'>, 'className' | 'children'>;
+export default function NavigationMenuItem({ value, className, children, ...rest }: NavigationMenuItemProps): import("react").JSX.Element;
+export type { NavigationMenuItemProps };

package/dist/types/components/NavigationMenu/NavigationMenuList.d.ts

@@ -0,0 +1,15 @@
+import type { ComponentPropsWithoutRef, ReactNode } from 'react';
+type NavigationMenuListProps = {
+    className?: string;
+    /** `<NavigationMenuItem>`s. */
+    children?: ReactNode;
+} & Omit<ComponentPropsWithoutRef<'ul'>, 'className' | 'children'>;
+/**
+ * The horizontal trigger strip. Keyboard model per the WAI-ARIA
+ * disclosure-navigation pattern: every trigger is its own natural Tab
+ * stop (no roving tabindex — panels are disclosures, not tab panels),
+ * with ←/→ moving focus between triggers and Home/End jumping to the
+ * ends as the optional bar-traversal enhancement.
+ */
+export default function NavigationMenuList({ className, onKeyDown, children, ...rest }: NavigationMenuListProps): import("react").JSX.Element;
+export type { NavigationMenuListProps };

package/dist/types/components/NavigationMenu/NavigationMenuTrigger.d.ts

@@ -0,0 +1,15 @@
+import type { ComponentPropsWithoutRef, ReactNode } from 'react';
+type NavigationMenuTriggerProps = {
+    className?: string;
+    children?: ReactNode;
+} & Omit<ComponentPropsWithoutRef<'button'>, 'className' | 'children'>;
+/**
+ * The disclosure button of one menu item. Hover opens after the menu's
+ * intent dwell (instantly while a sibling panel is open), focus follows
+ * the same path, click toggles immediately, Escape closes. Items
+ * without a `NavigationMenuContent` sibling render as plain buttons —
+ * no disclosure attributes and no toggle for a button that opens
+ * nothing (the consumer's own `onClick` rides through untouched).
+ */
+export default function NavigationMenuTrigger({ className, onClick, onMouseEnter, onMouseLeave, onFocus, onBlur, onKeyDown, children, ...rest }: NavigationMenuTriggerProps): import("react").JSX.Element;
+export type { NavigationMenuTriggerProps };

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

@@ -0,0 +1,11 @@
+export { default as NavigationMenu } from './NavigationMenu.js';
+export type { NavigationMenuProps } from './NavigationMenu.js';
+export type { NavigationMenuClassNames } from './NavigationMenuContext.js';
+export { default as NavigationMenuList } from './NavigationMenuList.js';
+export type { NavigationMenuListProps } from './NavigationMenuList.js';
+export { default as NavigationMenuItem } from './NavigationMenuItem.js';
+export type { NavigationMenuItemProps } from './NavigationMenuItem.js';
+export { default as NavigationMenuTrigger } from './NavigationMenuTrigger.js';
+export type { NavigationMenuTriggerProps } from './NavigationMenuTrigger.js';
+export { default as NavigationMenuContent } from './NavigationMenuContent.js';
+export type { NavigationMenuContentProps } from './NavigationMenuContent.js';

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

@@ -1,2 +1,2 @@
-export { default as NumberFormatter } from './NumberFormatter';
-export type { NumberFormatterProps } from './NumberFormatter';
+export { default as NumberFormatter } from './NumberFormatter.js';
+export type { NumberFormatterProps } from './NumberFormatter.js';

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

@@ -1,4 +1,5 @@
-export { default as NumberInput } from './NumberInput';
-export type { NumberInputProps } from './NumberInput';
-export { default as NumberInputCore } from './NumberInputCore';
-export type { NumberInputCoreProps } from './NumberInputCore';
+export { default as NumberInput } from './NumberInput.js';
+export type { NumberInputProps } from './NumberInput.js';
+export { default as NumberInputCore } from './NumberInputCore.js';
+export type { NumberInputCoreProps } from './NumberInputCore.js';
+export { inputSizes, btnSizes } from './number-input-styles.js';

package/dist/types/components/NumberInput/number-input-styles.d.ts

@@ -0,0 +1,10 @@
+export declare const inputSizes: {
+    readonly sm: import("@linaria/core").LinariaClassName;
+    readonly md: import("@linaria/core").LinariaClassName;
+    readonly lg: import("@linaria/core").LinariaClassName;
+};
+export declare const btnSizes: {
+    readonly sm: import("@linaria/core").LinariaClassName;
+    readonly md: import("@linaria/core").LinariaClassName;
+    readonly lg: import("@linaria/core").LinariaClassName;
+};

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

@@ -5,9 +5,17 @@ type OTPInputProps = {
     value?: ControlOrValue<string>;
     onChange?: (value: string) => void;
     className?: string;
+    /**
+     * Form field name: renders a hidden input bridge next to the cells so
+     * `<form action={fn}>` / `new FormData(form)` receive the joined code
+     * as one value (the per-cell inputs never carry it — partial codes
+     * would leak cell shards). An empty code submits nothing. react-f0rm
+     * `FormItem` usage never passes it, so both worlds coexist.
+     */
+    name?: string;
     /** Forwarded to the first cell's `<input>` — the element form bridges
      * and `ref.current.focus()` reach. */
     ref?: Ref<HTMLInputElement>;
 };
-export default function OTPInput({ length, value: valueControl, onChange, className, ref, }: OTPInputProps): import("react").JSX.Element;
+export default function OTPInput({ length, value: valueControl, onChange, className, name, ref, }: OTPInputProps): import("react").JSX.Element;
 export type { OTPInputProps };

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

@@ -1,4 +1,4 @@
-export { default as OTPInput } from './OTPInput';
-export type { OTPInputProps } from './OTPInput';
-export { default as OTPInputCore } from './OTPInputCore';
-export type { OTPInputCoreProps } from './OTPInputCore';
+export { default as OTPInput } from './OTPInput.js';
+export type { OTPInputProps } from './OTPInput.js';
+export { default as OTPInputCore } from './OTPInputCore.js';
+export type { OTPInputCoreProps } from './OTPInputCore.js';

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

@@ -1,2 +1,2 @@
-export { default as Pagination } from './Pagination';
-export type { PaginationProps } from './Pagination';
+export { default as Pagination } from './Pagination.js';
+export type { PaginationProps } from './Pagination.js';

package/dist/types/components/Pagination/pagination-styles.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Shared Pagination size skin — the per-size control metrics applied to
+ * the nav (`sizes.sm` / `sizes.lg` tighten or loosen the buttons,
+ * select and jumper input; `md` is the built-in and carries no class).
+ * Sibling styles module per the react-refresh boundary convention
+ * (Input `input-styles` precedent); split-css groups the module with
+ * the Pagination family's css.
+ */
+export declare const sizes: {
+    readonly sm: import("@linaria/core").LinariaClassName;
+    readonly md: import("@linaria/core").LinariaClassName;
+    readonly lg: import("@linaria/core").LinariaClassName;
+};

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

@@ -1,4 +1,4 @@
-export { default as PasswordInput } from './PasswordInput';
-export type { PasswordInputProps } from './PasswordInput';
-export { default as PasswordInputCore } from './PasswordInputCore';
-export type { PasswordInputCoreProps } from './PasswordInputCore';
+export { default as PasswordInput } from './PasswordInput.js';
+export type { PasswordInputProps } from './PasswordInput.js';
+export { default as PasswordInputCore } from './PasswordInputCore.js';
+export type { PasswordInputCoreProps } from './PasswordInputCore.js';

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

@@ -0,0 +1,35 @@
+import type { ComponentPropsWithoutRef, Ref } from 'react';
+import type { ControlOrValue } from 'react-use-control';
+import type { CountryCode } from 'libphonenumber-js';
+type PhoneInputProps = {
+    /**
+     * E.164-ish phone value ('+8613800138000' or ''). Typing national
+     * digits commits the value with the selected country's dial-code
+     * prefix; a pasted international number parses on change and
+     * switches the country to its own.
+     */
+    value?: ControlOrValue<string>;
+    /** Selected country (ISO 3166-1 alpha-2); uncontrolled default 'US'. */
+    country?: ControlOrValue<CountryCode>;
+    /** Fires with the next country whenever the Select (or a parsed
+     * international value) changes it. */
+    onCountryChange?: (country: CountryCode) => void;
+    /** Plain-value channel — the E.164 string, the shape `FormItem`'s
+     * `input` binding wires (no native event passthrough: the composite
+     * has no single DOM event to forward). */
+    onChange?: (value: string) => void;
+    size?: 'sm' | 'md' | 'lg';
+    className?: string;
+    /** Forwarded to the number `<input>` — the element form bridges and
+     * `ref.current.focus()` reach. */
+    ref?: Ref<HTMLInputElement>;
+} & Omit<ComponentPropsWithoutRef<'input'>, 'value' | 'onChange' | 'size'>;
+/**
+ * International phone input: a country Select joined seamlessly to a
+ * number field, backed by `libphonenumber-js`. Country names come from
+ * the ambient LocaleProvider locale via `Intl.DisplayNames`; validity
+ * is a derived announcement (`aria-invalid` + a screen-reader hint),
+ * never leaked state — check it in render with `isValidPhone`.
+ */
+export default function PhoneInput({ value: valueControl, country: countryControl, onCountryChange, onChange, size, className, disabled, placeholder, 'aria-describedby': ariaDescribedBy, ref, ...rest }: PhoneInputProps): import("react").JSX.Element;
+export type { PhoneInputProps };

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

@@ -0,0 +1,3 @@
+export { default as PhoneInput } from './PhoneInput.js';
+export type { PhoneInputProps } from './PhoneInput.js';
+export { isValidPhone } from './phone-number.js';

package/dist/types/components/PhoneInput/phone-input-styles.d.ts

@@ -0,0 +1,11 @@
+/**
+ * PhoneInput skin — the joined-field rows composing the country Select
+ * and the number InputCore into one attached control. The merge recipe
+ * is InputGroup's (`& > *` seam and corner rules) inlined on purpose:
+ * PhoneInput owns exactly two cells, so the generic cluster component
+ * would be indirection without a consumer-facing win.
+ */
+export declare const root: import("@linaria/core").LinariaClassName;
+export declare const row: import("@linaria/core").LinariaClassName;
+export declare const countrySelect: import("@linaria/core").LinariaClassName;
+export declare const numberField: import("@linaria/core").LinariaClassName;

package/dist/types/components/PhoneInput/phone-number.d.ts

@@ -0,0 +1,9 @@
+import type { CountryCode } from 'libphonenumber-js';
+/**
+ * Pure validity check for an E.164-ish value: `true` only when
+ * libphonenumber can parse it as a complete, valid number. A country
+ * makes national-format values ('13800138000') resolvable; values that
+ * carry their own '+cc' prefix validate against themselves. Empty is
+ * not valid.
+ */
+export declare function isValidPhone(value: string, country?: CountryCode): boolean;

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

@@ -0,0 +1,26 @@
+import type { ComponentPropsWithoutRef, ReactNode } from 'react';
+type PlanStatus = 'pending' | 'active' | 'done' | 'error' | 'skipped';
+type PlanProps = {
+    /** Heading rendered above the list; no default copy. */
+    title?: ReactNode;
+    /**
+     * Renders the visible progress text from the counted item statuses.
+     * The default is the locale-neutral `2 / 5` count — pass a formatter
+     * for worded copy, the component itself ships no translatable strings.
+     */
+    summary?: (done: number, total: number) => ReactNode;
+    /** `Plan.Item` elements; their statuses feed the progress summary. */
+    children?: ReactNode;
+    className?: string;
+} & Omit<ComponentPropsWithoutRef<'div'>, 'title'>;
+type PlanItemProps = {
+    label: ReactNode;
+    description?: ReactNode;
+    status?: PlanStatus;
+    className?: string;
+} & Omit<ComponentPropsWithoutRef<'li'>, 'children'>;
+declare function PlanItem({ label, description, status, className, ...rest }: PlanItemProps): import("react").JSX.Element;
+declare function Plan({ title, summary, children, className, ...rest }: PlanProps): import("react").JSX.Element;
+export default Plan;
+export { PlanItem };
+export type { PlanProps, PlanItemProps, PlanStatus };

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

@@ -0,0 +1,2 @@
+export { default as Plan, PlanItem } from './Plan.js';
+export type { PlanProps, PlanItemProps, PlanStatus } from './Plan.js';

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

@@ -0,0 +1,57 @@
+import type { ComponentPropsWithoutRef, ReactNode, Ref } from 'react';
+import type { ControlOrValue } from 'react-use-control';
+import type { FloatingPlacement } from '../../utils/floating.js';
+/**
+ * Imperative handle exposed through the React 19 `ref` prop (the
+ * floating-overlay family contract — Popover, DropdownMenu, Dialog,
+ * Drawer, BottomSheet). `open`/`close` are state writes going through
+ * the same `useFloating` path as the trigger's own clicks; `open`
+ * respects `disabled` exactly like the trigger.
+ */
+type PopconfirmHandle = {
+    /** Show the confirmation panel (a no-op while `disabled`). */
+    open: () => void;
+    /** Close the panel through the animated exit path. */
+    close: () => void;
+    /** Focus the trigger element. */
+    focusTrigger: () => void;
+};
+/** Logical placements the panel supports (the floating engine's set minus `point`, which is ContextMenu's pointer mode). */
+type PopconfirmPlacement = Exclude<FloatingPlacement, 'point'>;
+type PopconfirmProps = {
+    /** Panel heading — the confirmation question itself. */
+    title?: ReactNode;
+    /** Secondary explanation under the title. */
+    description?: ReactNode;
+    /** OK button label; defaults to the `confirmDialog.confirm` locale key. */
+    okText?: string;
+    /** Cancel button label; defaults to the `confirmDialog.cancel` locale key. */
+    cancelText?: string;
+    /** OK button tone. `danger` remaps the solid Button skin onto the danger token family. */
+    okVariant?: 'primary' | 'danger';
+    /** Decorative glyph rendered beside the title. */
+    icon?: ReactNode;
+    /**
+     * Sent when the action is confirmed. A returned promise puts the OK
+     * button into its busy phase (Button `loading`); the panel closes
+     * once the promise resolves and stays open (busy lifted) if it
+     * rejects — the antd contract: only a resolved async handler closes.
+     */
+    onConfirm?: () => void | Promise<unknown>;
+    /** Sent when the action is cancelled; the same async contract as `onConfirm`, busy on the cancel button. */
+    onCancel?: () => void | Promise<unknown>;
+    /** Panel placement relative to the trigger (logical, inline-relative). */
+    placement?: PopconfirmPlacement;
+    /** Whether the panel is open (controlled or uncontrolled). */
+    open?: ControlOrValue<boolean>;
+    /** Inert trigger: no pointer or keyboard open while set. */
+    disabled?: boolean;
+    /** Consumer class for the floating panel. */
+    className?: string;
+    /** The trigger content. */
+    children: ReactNode;
+    /** Imperative handle (`open`/`close`/`focusTrigger`) — the overlay family's React 19 command-object ref. */
+    ref?: Ref<PopconfirmHandle>;
+} & Omit<ComponentPropsWithoutRef<'div'>, 'children' | 'title' | 'className'>;
+export default function Popconfirm({ title, description, okText, cancelText, okVariant, icon, onConfirm, onCancel, placement, open: openControl, disabled, className, children, ref, ...rest }: PopconfirmProps): import("react").JSX.Element;
+export type { PopconfirmProps, PopconfirmHandle, PopconfirmPlacement };

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

@@ -0,0 +1,2 @@
+export { default as Popconfirm } from './Popconfirm.js';
+export type { PopconfirmProps, PopconfirmHandle, PopconfirmPlacement } from './Popconfirm.js';

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

@@ -1,6 +1,6 @@
 import type { ReactNode, Ref } from 'react';
 import type { ControlOrValue } from 'react-use-control';
-import type { CollisionPadding } from '../../utils/collision';
+import type { CollisionPadding } from '../../utils/collision.js';
 /**
  * Imperative handle exposed through the React 19 `ref` prop (same API
  * choice as VirtualList). `open`/`close` are state writes going through

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

@@ -1,2 +1,2 @@
-export { default as Popover } from './Popover';
-export type { PopoverProps, PopoverHandle, PopoverClassNames } from './Popover';
+export { default as Popover } from './Popover.js';
+export type { PopoverProps, PopoverHandle, PopoverClassNames } from './Popover.js';

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

@@ -1,9 +1,13 @@
+import type { ComponentPropsWithoutRef, Ref } from 'react';
 type ProgressProps = {
     value?: number;
     variant?: 'bar' | 'circle';
     size?: 'sm' | 'md' | 'lg';
-    color?: 'primary' | 'success' | 'warning' | 'danger';
+    /** Semantic fill color. */
+    color?: 'default' | 'primary' | 'success' | 'warning' | 'danger' | 'info';
     className?: string;
-};
-export default function Progress({ value, variant, size, color, className, }: ProgressProps): import("react").JSX.Element;
+    /** Forwarded to the root element (data-slot='progress'). */
+    ref?: Ref<HTMLDivElement>;
+} & Omit<ComponentPropsWithoutRef<'div'>, 'children' | 'className' | 'color'>;
+export default function Progress({ value, variant, size, color, 'aria-label': ariaLabel, className, ref, ...rest }: ProgressProps): import("react").JSX.Element;
 export type { ProgressProps };

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

@@ -1,2 +1,3 @@
-export { default as Progress } from './Progress';
-export type { ProgressProps } from './Progress';
+export { default as Progress } from './Progress.js';
+export type { ProgressProps } from './Progress.js';
+export { barSizes, circleSizes } from './progress-styles.js';

package/dist/types/components/Progress/progress-styles.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Shared Progress skin — the bar and circle chrome (base, per-size and
+ * per-color classes) the `Progress` component wears. Living in their
+ * own module keeps the component file free of style internals
+ * (react-refresh boundary) and lets the size maps ship as public
+ * constants (`barSizes` / `circleSizes`, the shadcn `buttonVariants`
+ * precedent) for consumers composing custom elements with the same
+ * skin; split-css groups the emitted CSS into `haze-ui/css/progress.css`
+ * with them.
+ */
+export declare const barBase: import("@linaria/core").LinariaClassName;
+export declare const barSizes: {
+    readonly sm: import("@linaria/core").LinariaClassName;
+    readonly md: import("@linaria/core").LinariaClassName;
+    readonly lg: import("@linaria/core").LinariaClassName;
+};
+export declare const barFill: import("@linaria/core").LinariaClassName;
+export declare const colorMap: {
+    readonly default: import("@linaria/core").LinariaClassName;
+    readonly primary: import("@linaria/core").LinariaClassName;
+    readonly success: import("@linaria/core").LinariaClassName;
+    readonly warning: import("@linaria/core").LinariaClassName;
+    readonly danger: import("@linaria/core").LinariaClassName;
+    readonly info: import("@linaria/core").LinariaClassName;
+};
+export declare const circleBase: import("@linaria/core").LinariaClassName;
+export declare const circleSizes: {
+    readonly sm: import("@linaria/core").LinariaClassName;
+    readonly md: import("@linaria/core").LinariaClassName;
+    readonly lg: import("@linaria/core").LinariaClassName;
+};
+export declare const circleBg: import("@linaria/core").LinariaClassName;
+export declare const circleFill: import("@linaria/core").LinariaClassName;
+export declare const circleColorMap: {
+    readonly default: import("@linaria/core").LinariaClassName;
+    readonly primary: import("@linaria/core").LinariaClassName;
+    readonly success: import("@linaria/core").LinariaClassName;
+    readonly warning: import("@linaria/core").LinariaClassName;
+    readonly danger: import("@linaria/core").LinariaClassName;
+    readonly info: import("@linaria/core").LinariaClassName;
+};

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

@@ -1,2 +1,2 @@
-export { default as PromptInput } from './PromptInput';
-export type { PromptInputProps } from './PromptInput';
+export { default as PromptInput } from './PromptInput.js';
+export type { PromptInputProps } from './PromptInput.js';

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

@@ -0,0 +1,61 @@
+import type { ReactNode, ComponentPropsWithoutRef, Ref } from 'react';
+/** Gesture state machine: idle → pulling → ready → refreshing → idle. */
+type PullToRefreshPhase = 'idle' | 'pulling' | 'ready' | 'refreshing';
+/** Payload handed to the `indicator` render prop. */
+type PullToRefreshIndicatorInfo = {
+    /** Current phase of the gesture state machine. */
+    phase: PullToRefreshPhase;
+    /**
+     * Pull progress 0..1 — the (damped) pull offset divided by `distance`.
+     * Reaches 1 exactly at the trigger threshold.
+     */
+    progress: number;
+};
+type PullToRefreshProps = {
+    /**
+     * Refresh action. A returned promise gates the refreshing phase: the
+     * spinner stays up until it settles (fulfilled or rejected — rejection
+     * is swallowed after the gesture because error reporting belongs to the
+     * caller's channel, e.g. a toast inside their own handler), then the
+     * head springs back to idle. `void` return settles immediately.
+     */
+    onRefresh: () => Promise<unknown> | void;
+    /** The scrolling content; the gesture starts from anywhere inside it. */
+    children: ReactNode;
+    /**
+     * Pull distance (px) that arms the refresh — the same value sizes the
+     * head, so at the threshold the indicator is fully revealed. Also the
+     * resting offset while refreshing. The default mirrors the
+     * `--haze-space-16` step (64px): the gesture math needs a raw number,
+     * so the token value is mirrored here rather than read back per frame.
+     */
+    distance?: number;
+    /** Disables the gesture entirely (render output is unchanged). */
+    disabled?: boolean;
+    /**
+     * Whether a pull may take over the gesture, evaluated once per pull as
+     * it crosses the slop (not per move). Default: every ancestor between
+     * the touched element and the document root sits at `scrollTop === 0`
+     * — a walk over `parentElement` checking `scrollTop > 0` (the same
+     * scroll-edge rule BottomSheet's swipe-to-dismiss uses). That walk
+     * covers both scrollables rendered as `children` and outer scroll
+     * containers (the page included), because a scroll chain with anything
+     * left to scroll should keep scrolling natively instead of refreshing.
+     */
+    canRefresh?: () => boolean;
+    /**
+     * Renders the head indicator. Default: a down arrow that flips when
+     * armed, a Spinner once refreshing, plus the status text props.
+     */
+    indicator?: (info: PullToRefreshIndicatorInfo) => ReactNode;
+    /** Status text while pulling below the threshold (default indicator). */
+    pullingText?: ReactNode;
+    /** Status text once the pull passes the threshold (default indicator). */
+    readyText?: ReactNode;
+    /** Status text while the refresh promise is pending (default indicator). */
+    refreshingText?: ReactNode;
+    /** Forwarded to the root container (data-slot='container'). */
+    ref?: Ref<HTMLDivElement>;
+} & Omit<ComponentPropsWithoutRef<'div'>, 'children'>;
+export default function PullToRefresh({ onRefresh, children, distance, disabled, canRefresh, indicator, pullingText, readyText, refreshingText, className, ref, ...rest }: PullToRefreshProps): import("react").JSX.Element;
+export type { PullToRefreshProps, PullToRefreshPhase, PullToRefreshIndicatorInfo };

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

@@ -0,0 +1,2 @@
+export { default as PullToRefresh } from './PullToRefresh.js';
+export type { PullToRefreshProps, PullToRefreshPhase, PullToRefreshIndicatorInfo } from './PullToRefresh.js';

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

@@ -1,2 +1,2 @@
-export { default as QRCode } from './QRCode';
-export type { QRCodeProps, QRCodeLevel } from './QRCode';
+export { default as QRCode } from './QRCode.js';
+export type { QRCodeProps, QRCodeLevel } from './QRCode.js';

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

@@ -0,0 +1,25 @@
+import type { ComponentPropsWithoutRef, ReactNode } from 'react';
+type QueueStatus = 'queued' | 'sending' | 'failed';
+type QueueProps = {
+    /** `Queue.Item` elements. */
+    children: ReactNode;
+    className?: string;
+} & Omit<ComponentPropsWithoutRef<'ul'>, 'children'>;
+type QueueItemProps = {
+    title: ReactNode;
+    description?: ReactNode;
+    status?: QueueStatus;
+    /** When present a remove button renders and calls this on click. */
+    onRemove?: () => void;
+    /**
+     * Accessible name of the remove button. No builtin copy: pass the
+     * label yourself, otherwise the `×` glyph doubles as the name.
+     */
+    removeLabel?: string;
+    className?: string;
+} & Omit<ComponentPropsWithoutRef<'li'>, 'children' | 'title'>;
+declare function QueueItem({ title, description, status, onRemove, removeLabel, className, ...rest }: QueueItemProps): import("react").JSX.Element;
+declare function Queue({ children, className, ...rest }: QueueProps): import("react").JSX.Element;
+export default Queue;
+export { QueueItem };
+export type { QueueProps, QueueItemProps, QueueStatus };

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

@@ -0,0 +1,2 @@
+export { default as Queue, QueueItem } from './Queue.js';
+export type { QueueProps, QueueItemProps, QueueStatus } from './Queue.js';

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

@@ -1,6 +1,6 @@
-export { default as Radio } from './Radio';
-export type { RadioProps } from './Radio';
-export { default as RadioGroup } from './RadioGroup';
-export type { RadioGroupProps } from './RadioGroup';
-export { default as RadioGroupCore } from './RadioGroupCore';
-export type { RadioGroupCoreProps } from './RadioGroupCore';
+export { default as Radio } from './Radio.js';
+export type { RadioProps } from './Radio.js';
+export { default as RadioGroup } from './RadioGroup.js';
+export type { RadioGroupProps } from './RadioGroup.js';
+export { default as RadioGroupCore } from './RadioGroupCore.js';
+export type { RadioGroupCoreProps } from './RadioGroupCore.js';

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

@@ -6,6 +6,13 @@ type RatingProps = {
     allowHalf?: boolean;
     onChange?: (value: number) => void;
     className?: string;
+    /**
+     * Form field name: renders a hidden input bridge next to the stars so
+     * `<form action={fn}>` / `new FormData(form)` receive `String(value)`.
+     * The `0` no-rating sentinel submits nothing. react-f0rm `FormItem`
+     * usage never passes it, so both worlds coexist.
+     */
+    name?: string;
     /**
      * Forwarded to the group's focus target — the star that is the roving
      * tab stop (the current rating, or the first star) — so form bridges
@@ -13,5 +20,5 @@ type RatingProps = {
      */
     ref?: Ref<HTMLSpanElement>;
 };
-export default function Rating({ value: valueControl, count, allowHalf, onChange, className, ref, }: RatingProps): import("react").JSX.Element;
+export default function Rating({ value: valueControl, count, allowHalf, onChange, className, name, ref, }: RatingProps): import("react").JSX.Element;
 export type { RatingProps };

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

@@ -1,4 +1,4 @@
-export { default as Rating } from './Rating';
-export type { RatingProps } from './Rating';
-export { default as RatingCore } from './RatingCore';
-export type { RatingCoreProps } from './RatingCore';
+export { default as Rating } from './Rating.js';
+export type { RatingProps } from './Rating.js';
+export { default as RatingCore } from './RatingCore.js';
+export type { RatingCoreProps } from './RatingCore.js';