haze-ui 1.32.0 → 1.34.0

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';

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

@@ -1,4 +1,2 @@
-export { ResizableGroup, ResizablePanel, ResizableHandle } from './Resizable';
-export type { ResizableGroupProps, ResizablePanelProps, ResizableHandleProps, } from './Resizable';
-export { ResizableGroup as SplitterGroup, ResizablePanel as SplitterPanel, ResizableHandle as SplitterHandle, } from './Resizable';
-export type { ResizableGroupProps as SplitterGroupProps, ResizablePanelProps as SplitterPanelProps, ResizableHandleProps as SplitterHandleProps, } from './Resizable';
+export { ResizableGroup, ResizablePanel, ResizableHandle } from './Resizable.js';
+export type { ResizableGroupProps, ResizablePanelProps, ResizableHandleProps, } from './Resizable.js';

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

@@ -1,2 +1,2 @@
-export { default as Result } from './Result';
-export type { ResultProps, ResultStatus } from './Result';
+export { default as Result } from './Result.js';
+export type { ResultProps, ResultStatus } from './Result.js';

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

@@ -0,0 +1,56 @@
+import type { AnyExtension, Editor } from '@tiptap/core';
+import type { ComponentPropsWithoutRef, ReactNode, Ref } from 'react';
+import type { ControlOrValue } from 'react-use-control';
+/**
+ * Imperative surface for power users — everything the editor can do is
+ * reachable through the Tiptap instance (`chain()`, `can()`, schema,
+ * storage, …). Null before the editor mounts (SSR-safe first paint,
+ * `immediatelyRender: false`) and after unmount.
+ */
+type RichTextEditorHandle = {
+    /** The live Tiptap `Editor` instance, or null when not mounted. */
+    getEditor: () => Editor | null;
+};
+type RichTextEditorProps = {
+    /**
+     * HTML content (`editor.getHTML()` shape). Controlled and uncontrolled
+     * modes share the one prop: external changes are pushed into the editor
+     * only when they differ from the current document, so an equal value
+     * never rebuilds the doc or drops the caret; internal edits publish back
+     * through the control.
+     */
+    value?: ControlOrValue<string>;
+    /** Hint shown while the document is empty (extension-placeholder). */
+    placeholder?: string;
+    /** Whether the document can be edited. Defaults to true. */
+    editable?: ControlOrValue<boolean>;
+    /**
+     * Replaces the built-in formatting toolbar; `false` renders none.
+     * Custom toolbars get the same chrome (padding + divider) and can grab
+     * the editor through the `ref` handle or `useEditorState`.
+     */
+    toolbar?: ReactNode | false;
+    /**
+     * Extra Tiptap extensions appended after the default set
+     * (starter-kit + link + placeholder) — tables, task lists, mentions…
+     */
+    extensions?: AnyExtension[];
+    /**
+     * Remount escape hatch: changing this destroys and recreates the
+     * editor (fresh history, re-read `extensions`/`placeholder`/`value`).
+     */
+    editorKey?: string;
+    /**
+     * Form field name: bridges the HTML value into native form submits
+     * (`new FormData(form)`, server actions) through a hidden input.
+     */
+    name?: string;
+    /**
+     * Imperative handle exposing the Tiptap instance (see
+     * RichTextEditorHandle). `aria-label`/`aria-labelledby` props are
+     * forwarded to the contenteditable textbox itself, not the root.
+     */
+    ref?: Ref<RichTextEditorHandle>;
+} & Omit<ComponentPropsWithoutRef<'div'>, 'value' | 'placeholder' | 'contentEditable' | 'suppressContentEditableWarning' | 'children'>;
+export default function RichTextEditor({ value: valueControl, placeholder, editable: editableControl, toolbar, extensions, editorKey, name, className, 'aria-label': ariaLabel, 'aria-labelledby': ariaLabelledBy, ref, ...rest }: RichTextEditorProps): import("react").JSX.Element;
+export type { RichTextEditorProps, RichTextEditorHandle };

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

@@ -0,0 +1,2 @@
+export { default as RichTextEditor } from './RichTextEditor.js';
+export type { RichTextEditorProps, RichTextEditorHandle } from './RichTextEditor.js';

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

@@ -0,0 +1,113 @@
+import type { ComponentPropsWithoutRef, ReactNode, Ref } from 'react';
+import type { ControlOrValue } from 'react-use-control';
+type ScheduleView = 'day' | 'week' | 'month';
+type ScheduleEventColor = 'primary' | 'success' | 'danger' | 'warning' | 'info' | 'neutral';
+type ScheduleEvent = {
+    id: string;
+    start: Date | string;
+    end: Date | string;
+    title: ReactNode;
+    color?: ScheduleEventColor;
+    allDay?: boolean;
+};
+type ScheduleEventChange = {
+    id: string;
+    start: Date;
+    end: Date;
+};
+type ScheduleBusinessHours = {
+    start: number;
+    end: number;
+};
+type ScheduleViewLabels = Partial<Record<ScheduleView, string>>;
+/**
+ * Semantic slot classes (AntD v6 `classNames` shape) for Schedule: one
+ * record themes the toolbar and both grid kinds plus every event chip.
+ * Consumer classes are appended at the end of each part's class list
+ * (able to override component defaults).
+ */
+type ScheduleClassNames = {
+    /** The root container (`data-slot='schedule'`). */
+    root?: string;
+    /** The toolbar strip — nav buttons, title and the view switcher
+     *  (`data-slot='toolbar'`). */
+    toolbar?: string;
+    /** The day/week time grid (`data-slot='time-grid'`), header and
+     *  all-day rows included. */
+    timeGrid?: string;
+    /** The month grid (`data-slot='month-grid'`). */
+    monthGrid?: string;
+    /** Every event chip across all views (`data-slot='event'`), the
+     *  "+N" overflow chips excepted (`data-slot='overflow-chip'`). */
+    event?: string;
+};
+type ScheduleProps = {
+    /** Events to lay out. The component never mutates them — drag and
+     * keyboard rescheduling surface through `onEventChange` and the
+     * consumer owns the data. */
+    events: ScheduleEvent[];
+    /** Active view. Uncontrolled (`'week'`) or controlled. */
+    view?: ControlOrValue<ScheduleView>;
+    onViewChange?: (view: ScheduleView) => void;
+    /** Anchor date the grid is centered on (defaults to today). */
+    date?: ControlOrValue<Date>;
+    onDateChange?: (date: Date) => void;
+    /** Snap granularity in minutes for the day/week time grid (default 60). */
+    slotMinutes?: number;
+    /** Hour numbers (0–23); rows outside the window render muted. */
+    businessHours?: ScheduleBusinessHours;
+    /** Current-time line in day/week views (default true). */
+    nowIndicator?: boolean;
+    onEventClick?: (event: ScheduleEvent) => void;
+    /** Fired when an event is moved by drag or arrow keys: duration is
+     * preserved, start/end snapped to `slotMinutes`. */
+    onEventChange?: (change: ScheduleEventChange) => void;
+    /** Fired when a month-view day cell (or its "+N" overflow chip) is
+     * activated. Cells stay inert unless this is provided. */
+    onDayClick?: (date: Date) => void;
+    todayLabel?: string;
+    prevLabel?: string;
+    nextLabel?: string;
+    viewLabels?: ScheduleViewLabels;
+    /** BCP 47 locale for weekday/month/time formatting; falls back to the
+     * LocaleProvider chain, then the browser default. */
+    locale?: string;
+    /**
+     * Semantic slot classes (AntD v6 `classNames` shape), keyed by the
+     * structural parts (see {@link ScheduleClassNames}). Slot classes are
+     * appended at the end of each part's class list; per-part `className`
+     * stays on the root and still lands after the `root` slot. Not
+     * passing it renders identical output.
+     */
+    classNames?: ScheduleClassNames;
+    className?: string;
+    /** Forwarded to the root container `<div>` (`data-slot='schedule'`). */
+    ref?: Ref<HTMLDivElement>;
+} & ComponentPropsWithoutRef<'div'>;
+type DropPosition = {
+    dayIndex: number;
+    minutes: number;
+};
+type DropContext = {
+    /** Start-of-day for every visible column, in reading order. */
+    days: Date[];
+    eventStart: Date;
+    eventEnd: Date;
+    /** Column index / minute-of-day the pointer grabbed the event at. */
+    grabDayIndex: number;
+    grabMinutes: number;
+    slotMinutes: number;
+};
+/**
+ * Drop-position → rescheduled range, pure so the snap/day-shift/duration
+ * math can be unit-tested without a DOM. The day index is clamped into
+ * the visible columns, the raw pointer delta (drop − grab) shifts the
+ * event civilly, the start snaps to the nearest `slotMinutes` boundary
+ * of its day, and the original duration is re-attached.
+ */
+export declare function computeDropTime(position: DropPosition, context: DropContext): {
+    start: Date;
+    end: Date;
+};
+export default function Schedule({ events, view: viewControl, onViewChange, date: dateControl, onDateChange, slotMinutes, businessHours, nowIndicator, onEventClick, onEventChange, onDayClick, todayLabel, prevLabel, nextLabel, viewLabels, locale, classNames, className, ref, ...rest }: ScheduleProps): import("react").JSX.Element;
+export type { ScheduleProps, ScheduleClassNames, ScheduleEvent, ScheduleView, ScheduleEventChange, ScheduleEventColor, ScheduleBusinessHours, ScheduleViewLabels, };

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

@@ -0,0 +1,2 @@
+export { default as Schedule } from './Schedule.js';
+export type { ScheduleProps, ScheduleClassNames, ScheduleEvent, ScheduleView, ScheduleEventChange, ScheduleEventColor, ScheduleBusinessHours, ScheduleViewLabels, } from './Schedule.js';

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

@@ -1,8 +1,32 @@
-import type { ReactNode } from 'react';
+import type { ComponentPropsWithoutRef, ReactNode, Ref } from 'react';
+import type { ScrollbarMode } from './ScrollAreaContext.js';
 type ScrollAreaProps = {
+    /**
+     * Caps the scroll area's height (px when numeric) — the long-standing
+     * sugar sizing knob. Compound usage can size the root via CSS instead.
+     */
     maxHeight?: number | string;
+    /**
+     * Scrollbar visibility mode: `'hover'` (default) shows thumbs while
+     * the pointer is over the scroll area, `'always'` keeps them on,
+     * `'scroll'` flashes them after each scroll.
+     */
+    type?: ScrollbarMode;
+    /**
+     * Accessible name for the scrollable viewport (it becomes focusable
+     * while its content overflows, so keyboard users need a name). An
+     * `aria-label` on `<ScrollViewport>` wins.
+     */
+    label?: string;
     className?: string;
+    /**
+     * Sugar path: plain content is wrapped in an implicit viewport with
+     * overlay scrollbars. Compound path: include `<ScrollViewport>` (or
+     * `<Scrollbar>`/`<ScrollThumb>`) children and they compose as given —
+     * an explicit `<Scrollbar>` suppresses the auto-appended pair.
+     */
     children: ReactNode;
-};
-export default function ScrollArea({ maxHeight, className, children, }: ScrollAreaProps): import("react").JSX.Element;
+    ref?: Ref<HTMLDivElement>;
+} & Omit<ComponentPropsWithoutRef<'div'>, 'children'>;
+export default function ScrollArea({ maxHeight, type, label, className, children, ref, style: consumerStyle, ...rest }: ScrollAreaProps): import("react").JSX.Element;
 export type { ScrollAreaProps };

package/dist/types/components/ScrollArea/ScrollAreaContext.d.ts

@@ -0,0 +1,24 @@
+import type { Dispatch, SetStateAction } from 'react';
+/**
+ * Scrollbar visibility mode, declared once on `<ScrollArea>` and read by
+ * every thumb through context:
+ *
+ * - `'hover'` (default) — thumbs appear while the pointer is over the
+ *   scroll area or while they are being dragged
+ * - `'always'` — thumbs are always shown (when the axis overflows)
+ * - `'scroll'` — thumbs appear for a moment after each scroll
+ */
+export type ScrollbarMode = 'hover' | 'always' | 'scroll';
+type ScrollAreaContextValue = {
+    /** Visibility mode declared on the root. */
+    mode: ScrollbarMode;
+    /** The mounted scrollable viewport (`null` before it attaches). */
+    viewport: HTMLDivElement | null;
+    /** Viewport registration — `<ScrollViewport>` calls it via its ref. */
+    setViewport: Dispatch<SetStateAction<HTMLDivElement | null>>;
+    /** Accessible name declared on the root; the viewport falls back to it. */
+    label: string | undefined;
+};
+export declare const ScrollAreaProvider: import("react").Provider<ScrollAreaContextValue | undefined>;
+export declare function useScrollAreaContext(): ScrollAreaContextValue;
+export {};

package/dist/types/components/ScrollArea/ScrollThumb.d.ts

@@ -0,0 +1,9 @@
+import type { ComponentPropsWithoutRef, Ref } from 'react';
+import type { Orientation } from './scroll-math.js';
+type ScrollThumbProps = {
+    orientation?: Orientation;
+    className?: string;
+    ref?: Ref<HTMLDivElement>;
+} & Omit<ComponentPropsWithoutRef<'div'>, 'children'>;
+export default function ScrollThumb({ orientation, className, ref, ...rest }: ScrollThumbProps): import("react").JSX.Element;
+export type { ScrollThumbProps };

package/dist/types/components/ScrollArea/ScrollViewport.d.ts

@@ -0,0 +1,8 @@
+import type { ComponentPropsWithoutRef, ReactNode, Ref } from 'react';
+type ScrollViewportProps = {
+    className?: string;
+    children: ReactNode;
+    ref?: Ref<HTMLDivElement>;
+} & Omit<ComponentPropsWithoutRef<'div'>, 'children'>;
+export default function ScrollViewport({ className, children, ref, ...restProps }: ScrollViewportProps): import("react").JSX.Element;
+export type { ScrollViewportProps };

package/dist/types/components/ScrollArea/Scrollbar.d.ts

@@ -0,0 +1,19 @@
+import type { ComponentPropsWithoutRef, ReactNode, Ref } from 'react';
+import type { Orientation } from './scroll-math.js';
+type ScrollbarProps = {
+    /**
+     * Axis this track overlays. The track is an absolutely positioned
+     * strip on the corresponding root edge.
+     */
+    orientation?: Orientation;
+    className?: string;
+    /**
+     * Track content — defaults to `<ScrollThumb orientation/>`. Custom
+     * children replace the thumb wholesale (and with it the automatic
+     * `data-scrollable` hit-testing toggle the built-in thumb maintains).
+     */
+    children?: ReactNode;
+    ref?: Ref<HTMLDivElement>;
+} & Omit<ComponentPropsWithoutRef<'div'>, 'children'>;
+export default function Scrollbar({ orientation, className, children, ref, ...rest }: ScrollbarProps): import("react").JSX.Element;
+export type { ScrollbarProps };

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

@@ -1,2 +1,9 @@
-export { default as ScrollArea } from './ScrollArea';
-export type { ScrollAreaProps } from './ScrollArea';
+export { default as ScrollArea } from './ScrollArea.js';
+export type { ScrollAreaProps } from './ScrollArea.js';
+export { default as Scrollbar } from './Scrollbar.js';
+export type { ScrollbarProps } from './Scrollbar.js';
+export { default as ScrollThumb } from './ScrollThumb.js';
+export type { ScrollThumbProps } from './ScrollThumb.js';
+export { default as ScrollViewport } from './ScrollViewport.js';
+export type { ScrollViewportProps } from './ScrollViewport.js';
+export type { ScrollbarMode } from './ScrollAreaContext.js';

package/dist/types/components/ScrollArea/scroll-math.d.ts

@@ -0,0 +1,121 @@
+/**
+ * Pure scroll/thumb geometry for the ScrollArea family.
+ *
+ * jsdom has no layout engine (every extent reads 0), so the math is
+ * extracted here as pure functions over plain numbers: unit tests cover
+ * the math directly, component tests cover the DOM wiring with mocked
+ * extents.
+ *
+ * Axis vocabulary (vertical examples):
+ * - `viewportSize` — `clientHeight`, the visible extent
+ * - `scrollSize`   — `scrollHeight`, the content extent
+ * - `trackSize`    — the scrollbar track's extent
+ * - `scrollOffset` — `scrollTop`, distance from the scroll *start*
+ *   (logical units, see RTL below)
+ * - `thumbOffset`  — the thumb's displacement from the track's
+ *   *physical* start (top for vertical, left for horizontal)
+ *
+ * RTL: horizontal offsets stay *logical* (0 = inline start = the
+ * physical right edge), normalized against the spec-aligned `scrollLeft`
+ * scale that reads 0 at the start and goes negative toward the end —
+ * the same convention VirtualList normalizes. The thumb's physical
+ * position mirrors: logical progress 0 parks it at the right edge.
+ */
+/** Axis a scrollbar/thumb operates on. */
+export type Orientation = 'vertical' | 'horizontal';
+/**
+ * Smallest rendered thumb (px) — keeps the grab target reachable when
+ * the content is huge (WCAG 2.5.8 target-size spirit). Layout geometry,
+ * not a visual token: it feeds the same math that consumes px extents.
+ */
+export declare const MIN_THUMB_SIZE = 24;
+/**
+ * Minimal element surface the readers/writers need — test literals and
+ * jsdom elements (real or mocked) both plug in.
+ */
+type ScrollElementLike = {
+    clientHeight: number;
+    scrollHeight: number;
+    scrollTop: number;
+    clientWidth: number;
+    scrollWidth: number;
+    scrollLeft: number;
+};
+export declare function clamp(value: number, min: number, max: number): number;
+export type AxisGeometryInput = {
+    viewportSize: number;
+    scrollSize: number;
+    trackSize: number;
+    /** Distance from the scroll start (logical units). */
+    scrollOffset: number;
+    /** Floor for the thumb extent; defaults to {@link MIN_THUMB_SIZE}. */
+    minThumbSize?: number;
+    /** Mirror the thumb along the track (horizontal RTL). */
+    rtl?: boolean;
+};
+export type AxisGeometry = {
+    /** Whether the axis has overflow at all. */
+    scrollable: boolean;
+    /** Fraction [0,1] of the content the viewport shows. */
+    ratio: number;
+    /** Thumb extent in px; 0 when not scrollable. */
+    thumbSize: number;
+    /** Thumb displacement from the track's physical start in px. */
+    thumbOffset: number;
+    /** Largest scroll offset (px). */
+    maxScroll: number;
+    /** Largest thumb displacement (px). */
+    maxThumbOffset: number;
+};
+/** Thumb size and position for one axis from its extents. */
+export declare function axisGeometry(input: AxisGeometryInput): AxisGeometry;
+export type ThumbDragInput = {
+    /** Thumb displacement from the track start at grab time (physical px). */
+    thumbStart: number;
+    /** Pointer travel since grab (px, positive = toward the track's physical end). */
+    pointerDelta: number;
+    viewportSize: number;
+    scrollSize: number;
+    trackSize: number;
+    minThumbSize?: number;
+    rtl?: boolean;
+};
+/**
+ * Scroll offset a thumb drag must produce: travel the thumb by the
+ * pointer delta (mirrored in RTL), then invert the offset mapping.
+ */
+export declare function thumbDragToScroll(input: ThumbDragInput): number;
+export type TrackPageInput = {
+    /** Pointer displacement from the track's physical start (px). */
+    trackPos: number;
+    /** Live thumb placement on that track. */
+    thumbOffset: number;
+    thumbSize: number;
+    scrollOffset: number;
+    viewportSize: number;
+    scrollSize: number;
+};
+/**
+ * Track-press paging, Chrome/Windows-scrollbar semantics: jump one
+ * viewport toward the press (past/before the thumb's center), clamped
+ * to the scroll range.
+ */
+export declare function trackPageToScroll(input: TrackPageInput): number;
+/** One axis of a scroll element in logical units (RTL horizontal normalized). */
+export type ViewportAxis = {
+    viewportSize: number;
+    scrollSize: number;
+    scrollOffset: number;
+};
+/**
+ * Read one axis off a scroll element. Horizontal RTL `scrollLeft` reads
+ * 0 at the inline start (physical right) and goes negative toward the
+ * end — negate it into logical units.
+ */
+export declare function readViewportAxis(el: ScrollElementLike, orientation: Orientation, rtl: boolean): ViewportAxis;
+/** Write a logical scroll offset back to the element (RTL de-normalized). */
+export declare function writeViewportAxis(el: {
+    scrollTop: number;
+    scrollLeft: number;
+}, orientation: Orientation, rtl: boolean, value: number): void;
+export {};

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

@@ -1,12 +1,20 @@
 import type { Ref } from 'react';
 import type { ControlOrValue } from 'react-use-control';
-import type { SegmentedOption } from './SegmentedCore';
+import type { SegmentedOption } from './SegmentedCore.js';
 type SegmentedProps = {
     options: SegmentedOption[];
     value?: ControlOrValue<string>;
     onChange?: (value: string) => void;
     size?: 'sm' | 'md' | 'lg';
     className?: string;
+    /**
+     * Form field name: renders a hidden input bridge next to the button
+     * group so `<form action={fn}>` / `new FormData(form)` receive the
+     * selected option's value. The `''` no-selection sentinel submits
+     * nothing. react-f0rm `FormItem` usage never passes it, so both
+     * worlds coexist.
+     */
+    name?: string;
     /**
      * Forwarded to the group's focus target — the selected option's
      * `<button>` (falling back to the first) — so form bridges and
@@ -14,5 +22,5 @@ type SegmentedProps = {
      */
     ref?: Ref<HTMLButtonElement>;
 };
-export default function Segmented({ options, value: valueControl, onChange, size, className, ref, }: SegmentedProps): import("react").JSX.Element;
+export default function Segmented({ options, value: valueControl, onChange, size, className, name, ref, }: SegmentedProps): import("react").JSX.Element;
 export type { SegmentedProps, SegmentedOption };

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

@@ -1,4 +1,4 @@
-export { default as Segmented } from './Segmented';
-export type { SegmentedProps, SegmentedOption } from './Segmented';
-export { default as SegmentedCore } from './SegmentedCore';
-export type { SegmentedCoreProps, SegmentedOption as SegmentedCoreOption } from './SegmentedCore';
+export { default as Segmented } from './Segmented.js';
+export type { SegmentedProps, SegmentedOption } from './Segmented.js';
+export { default as SegmentedCore } from './SegmentedCore.js';
+export type { SegmentedCoreProps, SegmentedOption as SegmentedCoreOption } from './SegmentedCore.js';

package/dist/types/components/Select/Option.d.ts

@@ -1,6 +1,9 @@
 import type { ComponentPropsWithoutRef, ReactNode } from 'react';
 type OptionProps = {
-    value: string;
+    /** Raw option value — `string | number`; the owning Select's value
+     * type param governs what is meaningful here (the DOM stringifies
+     * the rendered attribute; the floating paths compare raw values). */
+    value: string | number;
     children: ReactNode;
 } & Omit<ComponentPropsWithoutRef<'option'>, 'value'>;
 export default function Option({ value, children, ...rest }: OptionProps): import("react").JSX.Element;