haze-ui 1.12.1 → 1.13.0

package/dist/types/components/Slider/SliderCore.d.ts

@@ -0,0 +1,11 @@
+import type { ComponentPropsWithoutRef } from 'react';
+type SliderCoreProps = {
+    value: number;
+    onChange: (value: number) => void;
+    /** Native change event passthrough — invoked with the DOM event after
+     * `onChange`, so a spread can never override the controlled callback. */
+    onNativeChange?: ComponentPropsWithoutRef<'input'>['onChange'];
+    className?: string;
+} & Omit<ComponentPropsWithoutRef<'input'>, 'type' | 'value' | 'onChange'>;
+export default function SliderCore({ value, onChange, onNativeChange, className, ...rest }: SliderCoreProps): import("react").JSX.Element;
+export type { SliderCoreProps };

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

@@ -1,2 +1,4 @@
 export { default as Slider } from './Slider';
 export type { SliderProps } from './Slider';
+export { default as SliderCore } from './SliderCore';
+export type { SliderCoreProps } from './SliderCore';

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

@@ -3,6 +3,6 @@ import type { Control } from 'react-use-control';
 type SwitchProps = {
     checked?: Control<boolean> | boolean;
     size?: 'sm' | 'md' | 'lg';
-} & Omit<ComponentPropsWithoutRef<'button'>, 'type' | 'checked'>;
+} & Omit<ComponentPropsWithoutRef<'button'>, 'type' | 'checked' | 'onChange'>;
 export default function Switch({ checked: checkedControl, size, className, onClick, ...rest }: SwitchProps): import("react").JSX.Element;
 export type { SwitchProps };

package/dist/types/components/Switch/SwitchCore.d.ts

@@ -0,0 +1,12 @@
+import type { ComponentPropsWithoutRef } from 'react';
+type SwitchCoreProps = {
+    checked: boolean;
+    onChange: (checked: boolean) => void;
+    /** Native click event passthrough — invoked with the DOM event after
+     * `onChange`, so a spread can never override the controlled callback. */
+    onNativeClick?: ComponentPropsWithoutRef<'button'>['onClick'];
+    size?: 'sm' | 'md' | 'lg';
+    className?: string;
+} & Omit<ComponentPropsWithoutRef<'button'>, 'type' | 'checked' | 'onChange'>;
+export default function SwitchCore({ checked, onChange, onNativeClick, size, className, ...rest }: SwitchCoreProps): import("react").JSX.Element;
+export type { SwitchCoreProps };

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

@@ -1,2 +1,4 @@
 export { default as Switch } from './Switch';
 export type { SwitchProps } from './Switch';
+export { default as SwitchCore } from './SwitchCore';
+export type { SwitchCoreProps } from './SwitchCore';

package/dist/types/components/TagInput/TagInputCore.d.ts

@@ -0,0 +1,20 @@
+type TagInputCoreProps = {
+    value: string[];
+    onChange: (value: string[]) => void;
+    placeholder?: string;
+    maxTags?: number;
+    disabled?: boolean;
+    className?: string;
+    /**
+     * 字段 id（FormItem 桥生成）：必须挂到内部可聚焦的 input 上而非根
+     * div，<label htmlFor> 与错误 span 的 aria 链路才能接到焦点元素——
+     * 根 div 不聚焦，挂那里等于断链。
+     */
+    id?: string;
+    /** 由 FormItem 桥传入，随字段错误态变化，透传给内部 input。 */
+    'aria-invalid'?: boolean;
+    /** 指向 FormItem 渲染的错误 span（id={errorId}），透传给内部 input。 */
+    'aria-describedby'?: string;
+};
+export default function TagInputCore({ value: tags, onChange, placeholder, maxTags, disabled, className, id, 'aria-invalid': ariaInvalid, 'aria-describedby': ariaDescribedby, }: TagInputCoreProps): import("react").JSX.Element;
+export type { TagInputCoreProps };

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

@@ -1,2 +1,4 @@
 export { default as TagInput } from './TagInput';
 export type { TagInputProps } from './TagInput';
+export { default as TagInputCore } from './TagInputCore';
+export type { TagInputCoreProps } from './TagInputCore';

package/dist/types/components/Textarea/TextareaCore.d.ts

@@ -0,0 +1,12 @@
+import type { ComponentPropsWithoutRef } from 'react';
+type TextareaCoreProps = {
+    value: string;
+    onChange: (value: string) => void;
+    /** Native change event passthrough — invoked with the DOM event after
+     * `onChange`, so a spread can never override the controlled callback. */
+    onNativeChange?: ComponentPropsWithoutRef<'textarea'>['onChange'];
+    size?: 'sm' | 'md' | 'lg';
+    className?: string;
+} & Omit<ComponentPropsWithoutRef<'textarea'>, 'value' | 'onChange' | 'size'>;
+export default function TextareaCore({ value, onChange, onNativeChange, size, className, ...rest }: TextareaCoreProps): import("react").JSX.Element;
+export type { TextareaCoreProps };

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

@@ -1,2 +1,4 @@
 export { default as Textarea } from './Textarea';
 export type { TextareaProps } from './Textarea';
+export { default as TextareaCore } from './TextareaCore';
+export type { TextareaCoreProps } from './TextareaCore';

package/dist/types/components/TimePicker/TimePickerCore.d.ts

@@ -0,0 +1,9 @@
+import type { ComponentPropsWithoutRef } from 'react';
+type TimePickerCoreProps = {
+    value: string;
+    onChange: (value: string) => void;
+    placeholder?: string;
+    className?: string;
+} & Omit<ComponentPropsWithoutRef<'input'>, 'value' | 'onChange' | 'type' | 'placeholder'>;
+export default function TimePickerCore({ value, onChange, placeholder, className, ...rest }: TimePickerCoreProps): import("react").JSX.Element;
+export type { TimePickerCoreProps };

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

@@ -1,2 +1,4 @@
 export { default as TimePicker } from './TimePicker';
 export type { TimePickerProps } from './TimePicker';
+export { default as TimePickerCore } from './TimePickerCore';
+export type { TimePickerCoreProps } from './TimePickerCore';

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

@@ -1,9 +1,13 @@
 import type { ReactNode } from 'react';
+import type { Control } from 'react-use-control';
 type TooltipProps = {
     content: ReactNode;
     position?: 'top' | 'bottom' | 'left' | 'right';
+    /** Milliseconds of hover/focus before the tooltip appears. */
+    delay?: number;
+    open?: Control<boolean> | boolean;
     className?: string;
     children: ReactNode;
 };
-export default function Tooltip({ content, position, className, children, }: TooltipProps): import("react").JSX.Element;
+export default function Tooltip({ content, position, delay, open: openControl, className, children, }: TooltipProps): import("react").JSX.Element;
 export type { TooltipProps };

package/dist/types/form/FormItem.d.ts

@@ -1,20 +1,24 @@
-import type { ReactNode } from 'react';
-import type { FieldError, FieldPath, FieldRules, Name, ValidationMode } from 'react-f0rm';
-import type { Control } from 'react-use-control';
-import type { FormInstance, PathValueOf } from './useFormControl';
+import type { ComponentType, ReactNode } from 'react';
+import type { FieldError, FieldPath, FieldRules, Name, ValidationMode, FormInstance, PathValueOf } from 'react-f0rm';
 /**
  * Field-level validator, structurally compatible with react-f0rm's
  * `Validator`: return an error (string, FieldError, or an array mixing
  * both) or `undefined` when valid; return a Promise for async validation.
  * `meta.signal` aborts as soon as the round is superseded.
+ *
+ * Generic like react-f0rm's own `useField` `validate`: with `form` (a
+ * `FormInstance<TValues>`) and `name` (a `FieldPath<TValues>`) in scope,
+ * the value argument is `PathValueOf<TValues, P>` — the field's actual
+ * type — instead of `any`. The bare defaults keep untyped call sites
+ * exactly as permissive as before.
  */
-export type FieldValidator = (value: any, meta: {
+export type FieldValidator<TValues extends Record<string, any> = any, P extends FieldPath<TValues> | Name = Name> = (value: PathValueOf<TValues, P>, meta: {
     form: FormInstance;
     signal: AbortSignal;
 }) => string | FieldError | (string | FieldError)[] | undefined | Promise<string | FieldError | (string | FieldError)[] | undefined>;
 /** Render binding handed to `FormItem`'s render-prop children. */
 export type FormItemBinding<TValues, P extends FieldPath<TValues> | Name> = {
-    /** id for the field control element (`<Input id={id}>`) */
+    /** id for the field control element (`<InputCore id={id}>`) */
     id: string;
     /** id of the error message element; pass as `aria-describedby` */
     errorId: string;
@@ -23,19 +27,49 @@ export type FormItemBinding<TValues, P extends FieldPath<TValues> | Name> = {
     /** every error registered for the field, in insertion order */
     errors: FieldError[];
     /** react-f0rm blur hook for this field — pass to the control's `onBlur`
-     * (`<Input onBlur={onBlur}/>`) so blur-scheduled validation modes
+     * (`<InputCore onBlur={onBlur}/>`) so blur-scheduled validation modes
      * (`mode='onBlur' | 'onTouched' | 'all'`) fire when the field loses focus. */
     onBlur: () => void;
-    /** Control bound to the field value — pass to a control prop */
-    control: Control<PathValueOf<TValues, P>>;
+    /** Field value subscribed per-field — pass to a controlled core
+     * (`<InputCore value={value} onChange={onChange} />`). */
+    value: PathValueOf<TValues, P>;
+    /** react-f0rm's own field-change writer — pass to the core's `onChange`.
+     * It routes through the same mode-gated, re-validating pipeline as
+     * react-f0rm's built-in Field/Checkbox/Select. */
+    onChange: (next: PathValueOf<TValues, P>) => void;
+};
+/**
+ * Declarative `as` binding for `FormItem` — the same props shape as
+ * react-f0rm `Field`'s `as` (deliberately *not* Radix's `asChild`): pass
+ * any component as the field control and `FormItem` wires the id, aria
+ * attributes, `onBlur` and `onChange` itself.
+ */
+export type FormItemAsProps = {
+    /** Component rendered as the field control. When provided it takes
+     * precedence over the children render-prop. */
+    as?: ComponentType<any>;
+    /** Extra props spread onto the `as` component. They land before the
+     * value props, so `value`/`valueToProps` win conflicts — the same
+     * precedence react-f0rm's `Field` uses. */
+    asProps?: Record<string, any>;
+    /** Converts what the `as` component passes to its `onChange` into the
+     * field value. Defaults to identity — haze cores' `onChange` emits the
+     * next plain value; pass `(e) => e.target.value` when `as` is a raw
+     * DOM-element component. */
+    eventToValue?: (e: any) => any;
+    /** Derives the value props for the `as` component from the field value —
+     * e.g. `(checked) => ({checked})` for `CheckboxCore`. Defaults to
+     * passing `{value}`. */
+    valueToProps?: (value: any) => Record<string, any>;
 };
 export type FormItemProps<TValues extends Record<string, any> = any, P extends FieldPath<TValues> | Name = Name> = {
     form: FormInstance<TValues>;
     name: P;
     label?: ReactNode;
     /** Field-level validator, registered through react-f0rm's own
-     * `useField` channel — validated per the form's `mode` and on submit. */
-    validate?: FieldValidator;
+     * `useField` channel — validated per the form's `mode` and on submit.
+     * With a typed form the value argument is `PathValueOf<TValues, P>`. */
+    validate?: FieldValidator<TValues, P>;
     /** Per-field validation mode override (react-f0rm ≥0.6): when given,
      * this field validates on its own schedule — e.g. `'onBlur'` — instead
      * of the form's `mode`; other fields are unaffected. Omit to keep the
@@ -58,24 +92,57 @@ export type FormItemProps<TValues extends Record<string, any> = any, P extends F
      * `validate` — both sources' errors merge, rules errors ahead. Omit for
      * `validate`-only validation. */
     rules?: FieldRules;
+    /** Custom error renderer: when provided and the field has errors, the
+     * built-in error span renders `renderError(errors[0].message, errorId)`
+     * instead of the bare message. The span itself — id, `role='alert'`,
+     * styling — stays FormItem's, in both the `as` and children modes. */
+    renderError?: (error: string, id: string) => ReactNode;
     className?: string;
+} & FormItemAsProps & ({
+    as: ComponentType<any>;
+    children?: never;
+} | {
+    as?: undefined;
     children: (binding: FormItemBinding<TValues, P>) => ReactNode;
-};
+});
 /**
- * Glue a single field of a react-f0rm form to a haze-ui control:
- * generates accessible ids, subscribes to the field's errors, and hands
- * both plus a `useFormControl` handle to the render-prop children.
+ * Glue a single field of a react-f0rm form to a haze-ui controlled core.
+ * The binding layer is react-f0rm's own headless `useField` hook — the
+ * same channel its built-in Field/Checkbox/Select use — so no adapter or
+ * state-bridge lives here. FormItem contributes only the view: label,
+ * error span and the id/aria convention.
  *
  * ```tsx
  * <FormItem form={form} name='email' label='Email'>
- *   {({id, errorId, invalid, control}) => (
- *     <Input id={id} value={control} aria-describedby={errorId} aria-invalid={invalid} />
+ *   {({id, errorId, invalid, value, onChange}) => (
+ *     <InputCore
+ *       id={id}
+ *       value={value}
+ *       onChange={onChange}
+ *       aria-describedby={errorId}
+ *       aria-invalid={invalid}
+ *     />
  *   )}
  * </FormItem>
  * ```
  *
+ * Or declaratively, react-f0rm `Field`-style (`as` and children are
+ * mutually exclusive — pick one):
+ *
+ * ```tsx
+ * <FormItem form={form} name='email' label='Email' as={InputCore} />
+ * ```
+ *
+ * With `as`, the id/aria/onBlur/onChange wiring happens here: the control
+ * gets `id`, `aria-invalid`/`aria-describedby` while the field errors,
+ * and `onChange={(v) => onChange(toValue(v))}` where `toValue` defaults
+ * to identity (haze cores emit plain values — pass
+ * `eventToValue={(e) => e.target.value}` for a raw DOM element) and the
+ * value lands as `{value}` or, with `valueToProps`, whatever props the
+ * control wants (e.g. `{checked}` for CheckboxCore).
+ *
  * When the field has errors, the first error's message is rendered into a
- * `<span id={errorId} role='alert'>` next to the children; with no errors
+ * `<span id={errorId} role='alert'>` next to the control; with no errors
  * no extra element is rendered.
  */
-export default function FormItem<TValues extends Record<string, any> = any, P extends FieldPath<TValues> | Name = Name>({ form, name, label, validate, mode, validateDebounce, delayError, rules, className, children }: FormItemProps<TValues, P>): import("react").JSX.Element;
+export default function FormItem<TValues extends Record<string, any> = any, P extends FieldPath<TValues> | Name = Name>({ form, name, label, validate, mode, validateDebounce, delayError, rules, className, renderError, as: As, asProps, eventToValue, valueToProps, children }: FormItemProps<TValues, P>): import("react").JSX.Element;

package/dist/types/form/index.d.ts

@@ -1,4 +1,3 @@
-export { useFormControl } from './useFormControl';
-export type { FormInstance, PathValueOf } from './useFormControl';
 export { default as FormItem } from './FormItem';
-export type { FieldValidator, FormItemBinding, FormItemProps } from './FormItem';
+export type { FieldValidator, FormItemAsProps, FormItemBinding, FormItemProps } from './FormItem';
+export type { FormInstance, PathValueOf } from 'react-f0rm';

package/dist/types/index.d.ts

@@ -5,14 +5,14 @@ export { TOKEN_REGISTRY, COMPONENT_TOKENS } from './tokens/registry';
 export type { TokenDef } from './tokens/registry';
 export { Button } from './components/Button';
 export type { ButtonProps } from './components/Button';
-export { Input } from './components/Input';
-export type { InputProps } from './components/Input';
-export { Select, Option } from './components/Select';
-export type { SelectProps, OptionProps } from './components/Select';
-export { Checkbox } from './components/Checkbox';
-export type { CheckboxProps } from './components/Checkbox';
-export { Switch } from './components/Switch';
-export type { SwitchProps } from './components/Switch';
+export { Input, InputCore } from './components/Input';
+export type { InputProps, InputCoreProps } from './components/Input';
+export { Select, Option, SelectCore } from './components/Select';
+export type { SelectProps, OptionProps, SelectCoreProps } from './components/Select';
+export { Checkbox, CheckboxCore } from './components/Checkbox';
+export type { CheckboxProps, CheckboxCoreProps } from './components/Checkbox';
+export { Switch, SwitchCore } from './components/Switch';
+export type { SwitchProps, SwitchCoreProps } from './components/Switch';
 export { Badge } from './components/Badge';
 export type { BadgeProps } from './components/Badge';
 export { Dialog } from './components/Dialog';
@@ -23,12 +23,12 @@ export { Popover } from './components/Popover';
 export type { PopoverProps } from './components/Popover';
 export { Card } from './components/Card';
 export type { CardProps } from './components/Card';
-export { Radio, RadioGroup } from './components/Radio';
-export type { RadioProps, RadioGroupProps } from './components/Radio';
-export { Textarea } from './components/Textarea';
-export type { TextareaProps } from './components/Textarea';
-export { Slider } from './components/Slider';
-export type { SliderProps } from './components/Slider';
+export { Radio, RadioGroup, RadioGroupCore } from './components/Radio';
+export type { RadioProps, RadioGroupProps, RadioGroupCoreProps } from './components/Radio';
+export { Textarea, TextareaCore } from './components/Textarea';
+export type { TextareaProps, TextareaCoreProps } from './components/Textarea';
+export { Slider, SliderCore } from './components/Slider';
+export type { SliderProps, SliderCoreProps } from './components/Slider';
 export { Tabs, TabList, Tab, TabPanel } from './components/Tabs';
 export type { TabsProps, TabListProps, TabProps, TabPanelProps, } from './components/Tabs';
 export { Accordion, AccordionItem } from './components/Accordion';
@@ -53,8 +53,8 @@ export { Disclosure } from './components/Disclosure';
 export type { DisclosureProps } from './components/Disclosure';
 export { Menu, MenuItem, MenuDivider } from './components/Menu';
 export type { MenuProps, MenuItemProps } from './components/Menu';
-export { NumberInput } from './components/NumberInput';
-export type { NumberInputProps } from './components/NumberInput';
+export { NumberInput, NumberInputCore } from './components/NumberInput';
+export type { NumberInputProps, NumberInputCoreProps } from './components/NumberInput';
 export { FileInput } from './components/FileInput';
 export type { FileInputProps } from './components/FileInput';
 export { Toast, ToastContainer, useToast } from './components/Toast';
@@ -67,8 +67,8 @@ export { Table, TableHead, TableBody, TableRow, TableCell, } from './components/
 export type { TableProps, TableHeadProps, TableBodyProps, TableRowProps, TableCellProps, } from './components/Table';
 export { Carousel, CarouselSlide } from './components/Carousel';
 export type { CarouselProps, CarouselSlideProps } from './components/Carousel';
-export { Datepicker } from './components/Datepicker';
-export type { DatepickerProps } from './components/Datepicker';
+export { Datepicker, DatepickerCore } from './components/Datepicker';
+export type { DatepickerProps, DatepickerCoreProps } from './components/Datepicker';
 export { Tree } from './components/Tree';
 export type { TreeProps, TreeNodeData } from './components/Tree';
 export { Divider } from './components/Divider';
@@ -97,32 +97,32 @@ export { Transfer } from './components/Transfer';
 export type { TransferProps, TransferItem } from './components/Transfer';
 export { Upload } from './components/Upload';
 export type { UploadProps } from './components/Upload';
-export { ColorPicker } from './components/ColorPicker';
-export type { ColorPickerProps } from './components/ColorPicker';
-export { Rating } from './components/Rating';
-export type { RatingProps } from './components/Rating';
+export { ColorPicker, ColorPickerCore } from './components/ColorPicker';
+export type { ColorPickerProps, ColorPickerCoreProps } from './components/ColorPicker';
+export { Rating, RatingCore } from './components/Rating';
+export type { RatingProps, RatingCoreProps } from './components/Rating';
 export { Timeline, TimelineItem } from './components/Timeline';
 export type { TimelineProps, TimelineItemProps } from './components/Timeline';
 export { Title, Text, Paragraph } from './components/Typography';
 export type { TitleProps, TextProps, ParagraphProps } from './components/Typography';
 export { Stat, StatGroup } from './components/Stat';
 export type { StatProps, StatGroupProps } from './components/Stat';
-export { Segmented } from './components/Segmented';
-export type { SegmentedProps } from './components/Segmented';
+export { Segmented, SegmentedCore } from './components/Segmented';
+export type { SegmentedProps, SegmentedCoreProps } from './components/Segmented';
 export { Chip } from './components/Chip';
 export type { ChipProps } from './components/Chip';
 export { ScrollArea } from './components/ScrollArea';
 export type { ScrollAreaProps } from './components/ScrollArea';
-export { TimePicker } from './components/TimePicker';
-export type { TimePickerProps } from './components/TimePicker';
-export { DateRangePicker } from './components/DateRangePicker';
-export type { DateRangePickerProps } from './components/DateRangePicker';
-export { OTPInput } from './components/OTPInput';
-export type { OTPInputProps } from './components/OTPInput';
-export { PasswordInput } from './components/PasswordInput';
-export type { PasswordInputProps } from './components/PasswordInput';
-export { TagInput } from './components/TagInput';
-export type { TagInputProps } from './components/TagInput';
+export { TimePicker, TimePickerCore } from './components/TimePicker';
+export type { TimePickerProps, TimePickerCoreProps } from './components/TimePicker';
+export { DateRangePicker, DateRangePickerCore } from './components/DateRangePicker';
+export type { DateRangePickerProps, DateRangePickerCoreProps } from './components/DateRangePicker';
+export { OTPInput, OTPInputCore } from './components/OTPInput';
+export type { OTPInputProps, OTPInputCoreProps } from './components/OTPInput';
+export { PasswordInput, PasswordInputCore } from './components/PasswordInput';
+export type { PasswordInputProps, PasswordInputCoreProps } from './components/PasswordInput';
+export { TagInput, TagInputCore } from './components/TagInput';
+export type { TagInputProps, TagInputCoreProps } from './components/TagInput';
 export { InlineEdit } from './components/InlineEdit';
 export type { InlineEditProps } from './components/InlineEdit';
 export { DropdownMenu, DropdownMenuTrigger, DropdownMenuContent, DropdownMenuItem, DropdownMenuSeparator } from './components/DropdownMenu';
@@ -181,6 +181,6 @@ export { DiffViewer } from './components/DiffViewer';
 export type { DiffViewerProps, DiffLine } from './components/DiffViewer';
 export { LogViewer } from './components/LogViewer';
 export type { LogViewerProps, LogEntry, LogLevel } from './components/LogViewer';
-export { FormItem, useFormControl } from './form';
-export type { FieldValidator, FormItemBinding, FormItemProps, FormInstance, PathValueOf, } from './form';
+export { FormItem } from './form';
+export type { FieldValidator, FormItemAsProps, FormItemBinding, FormItemProps, FormInstance, PathValueOf, } from './form';
 export { useControl } from 'react-use-control';

package/dist/types/utils/floating.d.ts

@@ -0,0 +1,99 @@
+import type { ComponentProps, CSSProperties, Dispatch, ReactNode, RefObject, SetStateAction } from 'react';
+/** Lazy feature detection so tests can flip between native and fallback. */
+export declare function supportsNativePopover(): boolean;
+/**
+ * Anchor positioning requires the popover API first: jsdom's
+ * `CSS.supports` returns true for arbitrary declarations, so it must never
+ * be trusted on its own.
+ */
+export declare function supportsAnchorPositioning(): boolean;
+declare const anchoredPlacements: {
+    readonly bottom: import("@linaria/core").LinariaClassName;
+    readonly 'bottom-span': import("@linaria/core").LinariaClassName;
+    readonly 'bottom-center': import("@linaria/core").LinariaClassName;
+    readonly 'bottom-end': import("@linaria/core").LinariaClassName;
+    readonly top: import("@linaria/core").LinariaClassName;
+    readonly left: import("@linaria/core").LinariaClassName;
+    readonly right: import("@linaria/core").LinariaClassName;
+};
+type AnchorablePlacement = keyof typeof anchoredPlacements;
+/**
+ * Panel placement relative to the trigger. `point` leaves positioning
+ * entirely to the consumer (e.g. ContextMenu at the pointer coordinates).
+ */
+export type FloatingPlacement = AnchorablePlacement | 'point';
+type UseFloatingOptions = {
+    open: boolean;
+    setOpen: Dispatch<SetStateAction<boolean>>;
+    /** Element the panel is anchored to; also the outside-close boundary. */
+    triggerRef: RefObject<HTMLElement | null>;
+    /** The floating panel element. */
+    panelRef: RefObject<HTMLElement | null>;
+};
+export type FloatingBehavior = {
+    open: boolean;
+    native: boolean;
+    anchored: boolean;
+    /**
+     * Whether the panel element is actually shown right now (native path:
+     * mirrored from `toggle` events; fallback path: identical to `open`).
+     * Differs from `open` across the commit→effect gap: `open` flips when
+     * React commits, while the popover only becomes focusable/paintable
+     * after the effect calls showPopover(). Consumers that move focus into
+     * the panel on open must gate on `shown`, or the focus call lands on a
+     * display:none element and is silently dropped (Chromium).
+     */
+    shown: boolean;
+    /** Unique CSS anchor name for this instance (anchored path). */
+    anchorName: string;
+    /** Inline style for the trigger: declares `anchor-name`. */
+    triggerStyle: CSSProperties | undefined;
+    /** Spread on the trigger: records pointerdown for race attribution. */
+    onTriggerPointerDown: () => void;
+    /** Spread as the trigger's click handler: suppression-aware toggle. */
+    onTriggerClick: () => void;
+    /** Spread on the panel: popover attribute + anchor custom property. */
+    panelAttrs: {
+        popover: 'auto' | undefined;
+        style: CSSProperties | undefined;
+    };
+    /** Positioning-skeleton entries for the panel's x-class array. */
+    panelClasses: (string | false)[];
+    triggerRef: RefObject<HTMLElement | null>;
+    panelRef: RefObject<HTMLElement | null>;
+};
+export declare function useFloating({ open, setOpen, triggerRef, panelRef, }: UseFloatingOptions): FloatingBehavior;
+/** x-class entries placing the panel relative to the trigger, per tier. */
+export declare function floatingPlacementClasses(behavior: Pick<FloatingBehavior, 'native' | 'anchored'>, placement: FloatingPlacement): (string | false)[];
+/**
+ * Tier 2 positioning: place the panel under/over/beside the trigger and
+ * re-place on scroll/resize while open. No-op on the anchored and
+ * fallback tiers.
+ */
+export declare function useFloatingPosition({ behavior, placement, }: {
+    behavior: FloatingBehavior;
+    placement: FloatingPlacement;
+}): void;
+type FloatingPanelProps = {
+    /** Behavior record produced by `useFloating` at the floating root. */
+    behavior: FloatingBehavior;
+    /**
+     * Placement relative to the trigger. Omit (or pass 'point') when the
+     * consumer positions the panel itself, e.g. ContextMenu at the pointer.
+     */
+    placement?: FloatingPlacement;
+    /** Consumer visual skin: border, background, shadow, padding. */
+    visualClass?: string;
+    className?: string;
+    children?: ReactNode;
+    /** Merged with the anchor custom property the behavior may set. */
+    style?: CSSProperties;
+} & Omit<ComponentProps<'div'>, 'className' | 'children' | 'style'>;
+/**
+ * The panel element of a floating pair: applies the popover attribute,
+ * the anchor custom property and the tier/placement classes, and runs the
+ * tier-2 position effect. Everything else (id, role, handlers, ref) is
+ * passed through to the underlying div.
+ */
+export declare function FloatingPanel({ behavior, placement, visualClass, className, style, children, ...rest }: FloatingPanelProps): import("react").JSX.Element;
+export {};

package/dist/types/utils/menuKeyboard.d.ts

@@ -0,0 +1,43 @@
+import type { KeyboardEvent as ReactKeyboardEvent, RefObject } from 'react';
+/** Enabled items inside a container, in DOM order. */
+export declare function getEnabledMenuItems(container: HTMLElement | null, selector?: string): HTMLElement[];
+type UseMenuKeyboardOptions = {
+    /** Element containing the item children (`[role=menuitem]` by default). */
+    menuRef: RefObject<HTMLElement | null>;
+    /**
+     * Called when the menu should close via keyboard; the caller returns
+     * focus to the trigger.
+     */
+    onClose: () => void;
+    /**
+     * Item selector for containers that are not a `role="menu"` — e.g. the
+     * `[role=option]` list of a Command palette.
+     */
+    selector?: string;
+};
+/**
+ * Keyboard behavior for a roving-tabindex item container (WAI-ARIA menu
+ * button / listbox pattern): ↑/↓ move focus (wrapping, skipping disabled
+ * items), Home/End jump to the ends, Escape closes (returning focus to
+ * the trigger), Tab closes, and printable characters run typeahead.
+ */
+export declare function useMenuKeyboard({ menuRef, onClose, selector, }: UseMenuKeyboardOptions): (event: ReactKeyboardEvent) => void;
+type UseRovingTabindexOptions = {
+    menuRef: RefObject<HTMLElement | null>;
+    /**
+     * While false the effect is inert — panels that stay mounted when
+     * closed (Menu, Combobox-style listboxes) manage the tab stops only
+     * while open.
+     */
+    active: boolean;
+    selector?: string;
+};
+/**
+ * Roving tabindex for a menu/listbox container: exactly one item is a tab
+ * stop at any time. On activation the current stop is kept (first item
+ * initially); a `focusin` listener moves the stop with focus, and a
+ * MutationObserver re-syncs when the item set changes (e.g. a filtered
+ * Command list).
+ */
+export declare function useRovingTabindex({ menuRef, active, selector, }: UseRovingTabindexOptions): void;
+export {};