prime-ui-kit 0.9.0 → 0.9.1

package/dist/internal/AnchorRectContext.d.ts

@@ -0,0 +1,12 @@
+import * as React from "react";
+/** The box a floating layer is placed against (viewport px). */
+export type AnchorRect = Pick<DOMRectReadOnly, "top" | "left" | "right" | "bottom" | "width" | "height">;
+/**
+ * Maps an anchor's border box to the part of it that is actually visible. A layout whose rows are
+ * wider than what it shows (the compact Sidebar rail keeps full-width rows and clips them to the
+ * icon box) provides one, so tooltips, flyouts and menus of those rows anchor to what the user sees.
+ */
+export type AnchorRectResolver = (anchor: HTMLElement, rect: AnchorRect) => AnchorRect;
+export declare const AnchorRectProvider: React.Provider<AnchorRectResolver | null>;
+/** The resolver of the nearest layout that narrows its anchors, or `null`. Read by `usePosition`. */
+export declare function useAnchorRectResolver(): AnchorRectResolver | null;

package/dist/internal/ChoiceField.d.ts

@@ -0,0 +1,34 @@
+import type * as React from "react";
+import type { FieldIds } from "@/internal/FieldFrame";
+import type { ControlSize, DataState } from "@/internal/states";
+/** Class of the visually hidden native input that sits on top of the visual control. */
+export declare const choiceInputClass: string;
+/**
+ * Class of the visual control (box, circle, track): fill, hover, press, checked, focus ring,
+ * invalid and disabled come from the field state. A host tunes the fills with `--choice-bg*`.
+ * Outside a field (`Checkbox.Indicator`) the element's own `data-state` / `data-disabled` drive it.
+ */
+export declare const choiceVisualClass: string;
+/** `--prime-choice-size` / gap / text of the tier in `data-size` on the same element. */
+export declare const choiceTierClass: string;
+type ChoiceFieldProps = {
+    ids: FieldIds;
+    size: ControlSize;
+    state: Extract<DataState, "checked" | "unchecked" | "indeterminate">;
+    disabled: boolean;
+    /** The state is shown but does not change: no hover or press. */
+    readOnly?: boolean;
+    hint?: React.ReactNode;
+    error?: React.ReactNode;
+    /** The native input (with `choiceInputClass`) followed by its aria-hidden visual. */
+    control: React.ReactNode;
+    className?: string;
+    children?: React.ReactNode;
+};
+export declare function ChoiceField({ ids, size, state, disabled, readOnly, hint, error, control, className, children, }: ChoiceFieldProps): import("react/jsx-runtime").JSX.Element;
+export type ChoiceLabelProps = React.HTMLAttributes<HTMLSpanElement> & {
+    ref?: React.Ref<HTMLSpanElement>;
+};
+/** The visible text of a choice; it sits in the text column of the label row. */
+export declare function ChoiceLabel({ className, ...rest }: ChoiceLabelProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/internal/ControlSizeContext.d.ts

@@ -8,6 +8,10 @@ export declare function ControlSizeProvider({ value, children }: ControlSizeProv
 export declare namespace ControlSizeProvider {
     var displayName: string;
 }
-/** Для `Icon`: если `size` не передан явно, берётся из ближайшего контрола. */
+/** The tier of the nearest control, for parts and leaves whose `size` is not set explicitly. */
 export declare function useOptionalControlSize(): ControlSize | undefined;
-//# sourceMappingURL=ControlSizeContext.d.ts.map
+/**
+ * Tier of a field or control: its own `size`, else the tier of its host (a form, a panel, a
+ * popover, a table), else `m`.
+ */
+export declare function useControlSize(sizeProp: ControlSize | undefined): ControlSize;

package/dist/internal/FieldFrame.d.ts

@@ -1,6 +1,6 @@
 import * as React from "react";
 import type { ControlSize } from "@/internal/states";
-/** Field props shared by Select, TagSelect and Datepicker (the same contract as `Input.Root`). */
+/** Field props shared by every framed field (the same contract as `Input.Root`). */
 export type FieldFrameProps = {
     label?: React.ReactNode;
     /** Red `*` after the label; the control gets native `required` / `aria-required`. */
@@ -17,7 +17,16 @@ export type FieldFrameProps = {
      */
     focusRing?: boolean;
 };
-export declare function hasFieldError(error: React.ReactNode): boolean;
+/**
+ * Native attributes and `ref` of a framed field's root. One rule for every field root:
+ * `className`, `ref` and the rest land on the frame `<div>`, `id` on the control (the value props
+ * belong to the field). Leaf fields whose root wraps a native control and has no `Field` part
+ * (Textarea, Checkbox, Switch, Radio) keep `className` on the frame and send `ref` and the native
+ * attributes to that control instead.
+ */
+export type FieldRootDomProps = Omit<React.HTMLAttributes<HTMLDivElement>, "id" | "children" | "defaultValue" | "defaultChecked" | "onChange"> & {
+    ref?: React.Ref<HTMLDivElement>;
+};
 export type FieldIds = {
     controlId: string;
     /** Id of the label element (rendered only when `label` is set). */
@@ -26,23 +35,53 @@ export type FieldIds = {
     errorId: string;
     /** `aria-describedby` of the control: caller ids + hint or error. */
     describedBy: string | undefined;
+    /** `aria-labelledby` for a group control: the label id when a label renders, else `undefined`. */
+    labelledBy: string | undefined;
+    showHint: boolean;
+    showError: boolean;
     invalid: boolean;
 };
-/** Ids and validation state of a framed field. */
-export declare function useFieldFrame(explicitId: string | undefined, { hint, error, invalid }: {
+/** Ids, visible slots and validation state of a framed field. */
+export declare function useFieldFrame(explicitId: string | undefined, { label, hint, error, invalid, }: {
+    label?: React.ReactNode;
     hint?: React.ReactNode;
     error?: React.ReactNode;
     invalid?: boolean;
 }, ariaDescribedBy?: string): FieldIds;
-type FieldFrameRenderProps = FieldFrameProps & {
+type FieldFrameRenderProps = Omit<FieldFrameProps, "focusRing"> & {
     size: ControlSize;
     ids: FieldIds;
     disabled?: boolean;
     optionalLabel: string;
+    /**
+     * The control is a group (radiogroup, fieldset), not a labelable element: the label gets no
+     * `htmlFor`; the group names itself with `aria-labelledby={ids.labelId}`.
+     */
+    group?: boolean;
+    /** Right side of the label row (Slider's current value); the row renders even without a label. */
+    labelEnd?: React.ReactNode;
+    /** Right side of the support row (a character counter, `FieldCounter`). */
+    counter?: React.ReactNode;
+    /** Always render the support row so an appearing error does not shift the layout. */
+    reserveSupportRow?: boolean;
     className?: string;
     children: React.ReactNode;
+    /** The outer `<div>`: the host part's ref and native attributes land here. */
+    ref?: React.Ref<HTMLDivElement>;
+} & Omit<React.HTMLAttributes<HTMLDivElement>, "children" | "className">;
+/**
+ * Label row · control · support row (hint | error on the left, an optional counter on the right),
+ * spaced by the tier's `label-gap` / `hint-gap`.
+ */
+export declare function FieldFrame({ size, ids, label, required, optional, hint, error, disabled, optionalLabel, group, labelEnd, counter, reserveSupportRow, className, children, ...rest }: FieldFrameRenderProps): import("react/jsx-runtime").JSX.Element;
+type FieldCounterProps = Omit<React.HTMLAttributes<HTMLSpanElement>, "children"> & {
+    current: number;
+    max: number;
+    size: ControlSize;
+    /** Spoken text, a `{current}` / `{max}` template. */
+    label: string;
+    ref?: React.Ref<HTMLSpanElement>;
 };
-/** Label row · control · support row (hint or error), spaced by the tier's `label-gap` / `hint-gap`. */
-export declare function FieldFrame({ size, ids, label, required, optional, hint, error, disabled, optionalLabel, className, children, }: FieldFrameRenderProps): import("react/jsx-runtime").JSX.Element;
+/** `14/40` for the eye, `labels.counter` for screen readers; danger when `current > max`. */
+export declare function FieldCounter({ current, max, size, label, className, ...rest }: FieldCounterProps): import("react/jsx-runtime").JSX.Element;
 export {};
-//# sourceMappingURL=FieldFrame.d.ts.map

package/dist/internal/HighlightMatch.d.ts

@@ -0,0 +1,13 @@
+import * as React from "react";
+/** Index of the first case-insensitive occurrence of `query` in `text`; -1 for an empty query. */
+export declare function matchIndex(text: string, query: string): number;
+/**
+ * `text` with its first match of `query` marked in accent; plain text when nothing matches.
+ * The pieces share one span, so a flex row with a `gap` (a menu item) keeps the word whole.
+ */
+export declare function HighlightMatch({ text, query }: {
+    text: string;
+    query: string;
+}): import("react/jsx-runtime").JSX.Element;
+/** Marks the match in every string / number child; elements pass through untouched. */
+export declare function highlightChildren(children: React.ReactNode, query: string): React.ReactNode;

package/dist/internal/MenuGroup.d.ts

@@ -0,0 +1,8 @@
+import * as React from "react";
+export type MenuGroupProps = Omit<React.HTMLAttributes<HTMLDivElement>, "role"> & {
+    /** Visible heading of the group; names it for screen readers. */
+    label?: React.ReactNode;
+    ref?: React.Ref<HTMLDivElement>;
+};
+/** A labelled `role="group"` of rows: Dropdown, Select and CommandMenu groups. */
+export declare function MenuGroup({ label, className, children, ...rest }: MenuGroupProps): import("react/jsx-runtime").JSX.Element;

package/dist/internal/Portal.d.ts

@@ -5,4 +5,3 @@ type PortalProps = {
 };
 export declare function Portal({ children, container }: PortalProps): React.ReactPortal | null;
 export {};
-//# sourceMappingURL=Portal.d.ts.map

package/dist/internal/VisuallyHidden.d.ts

@@ -0,0 +1,11 @@
+import type * as React from "react";
+export type VisuallyHiddenProps = React.HTMLAttributes<HTMLSpanElement> & {
+    ref?: React.Ref<HTMLSpanElement>;
+};
+/** The sr-only recipe as a class, for an element that must stay itself (a focusable file input). */
+export declare const visuallyHiddenClass: string;
+/**
+ * Text for screen readers only: spoken counters, live-region messages, names of icon-only parts.
+ * Replaces the per-component `.srOnly` / `.visuallyHidden` CSS copies.
+ */
+export declare function VisuallyHidden({ className, ...rest }: VisuallyHiddenProps): import("react/jsx-runtime").JSX.Element;

package/dist/internal/context.d.ts

@@ -8,4 +8,3 @@ import * as React from "react";
  * const [InputProvider, useInputContext] = createComponentContext<InputContextValue>("Input");
  */
 export declare function createComponentContext<T>(displayName: string): readonly [React.Provider<T | null>, () => T];
-//# sourceMappingURL=context.d.ts.map

package/dist/internal/cx.d.ts

@@ -1,2 +1 @@
 export declare function cx(...classNames: Array<string | false | null | undefined>): string;
-//# sourceMappingURL=cx.d.ts.map

package/dist/internal/data-attributes.d.ts

@@ -3,4 +3,3 @@ type DataAttributesInput = Record<string, DataPrimitive>;
 type DataAttributesOutput = Record<string, string | undefined>;
 export declare function toDataAttributes(input: DataAttributesInput): DataAttributesOutput;
 export {};
-//# sourceMappingURL=data-attributes.d.ts.map

package/dist/internal/fieldClasses.d.ts

@@ -0,0 +1,9 @@
+/** Fill, hover, focus fill + ring, invalid and disabled of a field box (`fieldSurface.module.css`). */
+export declare const fieldSurfaceClass: string;
+/** `--field-*` tier variables, resolved from `data-size` on the same element (`fieldTier.module.css`). */
+export declare const fieldTierClass: string;
+/**
+ * Tier + surface + trigger layout of a button-shaped field (`fieldTrigger.module.css`). Classes are
+ * joined here, in TSX, never by a cross-file CSS `composes` (the bundler cannot order those).
+ */
+export declare const fieldTriggerClass: string;

package/dist/internal/formatLabel.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Fills a `{token}` label template (`"{current} из {max} символов"`): every `{name}` takes its
+ * value from `values`, every occurrence; a missing or `undefined` value becomes empty and the
+ * result is trimmed (`"Выбрать строку {label}"` without a label reads "Выбрать строку").
+ */
+export declare function formatLabel(template: string, values: Readonly<Record<string, string | number | undefined>>): string;

package/dist/internal/highlightTsxHtml.d.ts

@@ -1,3 +1,2 @@
-/** Примитивная подсветка TS/TSX для плейграунда: комментарии, строки, числа, ключевые слова, JSX-теги. */
+/** Minimal TS/TSX highlighting for the playground: comments, strings, numbers, keywords, JSX tags. */
 export declare function highlightTsxHtml(source: string): string;
-//# sourceMappingURL=highlightTsxHtml.d.ts.map

package/dist/internal/iconBox.d.ts

@@ -0,0 +1,9 @@
+import styles from "./iconBox.module.css";
+import type { ControlSize } from "./states";
+/**
+ * Class names of the shared icon box (Icon, Spinner). An explicit `size` takes the global icon
+ * scale; without it the box follows the host's `--prime-icon-size`, else `tier` (the nearest
+ * `ControlSizeProvider`), else `m`.
+ */
+export declare function iconBoxClass(size: ControlSize | undefined, tier: ControlSize | undefined): string;
+export { styles as iconBoxStyles };

package/dist/internal/iconLayout.d.ts

@@ -0,0 +1,15 @@
+import * as React from "react";
+export type IconLayout = {
+    /** Only icons: a square control without side padding. */
+    iconOnly: boolean;
+    /** An icon first, then text: the start side takes the optical padding. */
+    leadingIcon: boolean;
+    /** Text, then an icon last: the end side takes the optical padding. */
+    trailingIcon: boolean;
+};
+/**
+ * Where the icons sit among the direct children of a button-like control (Button,
+ * ButtonGroup.Item): drives optical padding (icon side = padX − 4px), the square icon-only shape
+ * and where a loading spinner goes. `iconType` is the control's own Icon part.
+ */
+export declare function iconLayout(children: React.ReactNode, iconType: React.ElementType): IconLayout;

package/dist/internal/imageSlot.d.ts

@@ -0,0 +1,29 @@
+import * as React from "react";
+import { type ImageStatus } from "@/hooks/useImageStatus";
+export type ImageSlotImageProps = Omit<React.ImgHTMLAttributes<HTMLImageElement>, "src" | "alt"> & {
+    src: string;
+    /** Empty (default) when the text next to it already names the subject. */
+    alt?: string;
+    ref?: React.Ref<HTMLImageElement>;
+};
+export type ImageSlotFallbackProps = React.HTMLAttributes<HTMLSpanElement> & {
+    ref?: React.Ref<HTMLSpanElement>;
+};
+/**
+ * Image-with-fallback mechanics shared by Avatar and Thumbnail: the root provides the load status,
+ * `Image` reports it (`data-status`: loading → loaded | error), `Fallback` shows through while the
+ * image loads or after it fails and is hidden from assistive tech once the image has loaded.
+ */
+export declare function createImageSlot(name: string, classNames: {
+    image: string;
+    fallback: string;
+}): {
+    /** Wraps the root's children; holds the status. */
+    ImageSlotProvider: (props: {
+        children: React.ReactNode;
+    }) => React.ReactElement;
+    /** Throws outside the root (for other parts that must sit inside it). */
+    useImageSlot: () => ImageStatus;
+    Image: (props: ImageSlotImageProps) => React.ReactElement;
+    Fallback: (props: ImageSlotFallbackProps) => React.ReactElement;
+};

package/dist/internal/layoutPxFromPrimitives.d.ts

@@ -1,7 +1,6 @@
 /**
- * Текущий вычисленный `font-size` корня (`html`) в px — для перевода rem из примитивов
- * в пиксели floating UI / SVG без жёсткой привязки к 16.
+ * The computed root (`html`) `font-size` in px: converts rem primitives to pixels for floating UI
+ * and SVG without assuming 16.
  */
 export declare function getRootFontSizePx(): number;
 export declare function remToPx(rem: string, rootPx?: number): number;
-//# sourceMappingURL=layoutPxFromPrimitives.d.ts.map

package/dist/internal/listbox.d.ts

@@ -0,0 +1,40 @@
+import * as React from "react";
+/**
+ * Listboxes with a virtual highlight (`aria-activedescendant`), shared by Select, TagSelect and
+ * CommandMenu. Options carry `data-value` and `data-label`; disabled ones `data-disabled="true"`.
+ */
+/** `id` of an option for `aria-activedescendant` (no spaces: a valid id). */
+export declare const optionDomId: (listboxId: string, value: string) => string;
+/** Enabled options of a listbox, in DOM order. */
+export declare function enabledOptions(container: HTMLElement | null): HTMLElement[];
+export type Store<T> = {
+    get: () => T;
+    set: (next: T) => void;
+    subscribe: (listener: () => void) => () => void;
+};
+export declare function createStore<T>(initial: T): Store<T>;
+/** One store per component instance. */
+export declare function useCreateStore<T>(initial: T): Store<T>;
+/**
+ * Reads a slice of a store; re-renders only when the slice changes. An option subscribes to
+ * `highlighted === value`, so moving the highlight re-renders two options, not the whole list.
+ */
+export declare function useStoreSlice<T, S>(store: Store<T>, select: (value: T) => S): S;
+export type ListboxKeyContext = {
+    items: HTMLElement[];
+    highlight: Store<string | undefined>;
+    onSelect: (value: string, label: string) => void;
+};
+/**
+ * Arrows, Home and End move the highlight (wrapping); Enter and Space pick it. Escape is the layer
+ * stack's (it closes the panel).
+ */
+export declare function handleListboxKeyDown(event: React.KeyboardEvent<HTMLElement>, { items, highlight, onSelect }: ListboxKeyContext): void;
+/**
+ * Typeahead by option label: the typed prefix finds the next match; the same letter repeated
+ * cycles through the options that start with it. Returns the match to highlight.
+ */
+export declare function useTypeahead(): {
+    find: (key: string, items: HTMLElement[], highlighted: string | undefined) => HTMLElement | undefined;
+    isTyping: () => boolean;
+};

package/dist/internal/mergeRefs.d.ts

@@ -1,4 +1,6 @@
 import type * as React from "react";
-/** Composes multiple refs (callback or object) into one callback — same idea as Radix `composeRefs`. */
+/**
+ * Composes refs (callback or object) into one callback. Internal helper of `useMergedRefs` and
+ * `Slot`; components call `useMergedRefs`, which keeps the callback stable between renders.
+ */
 export declare function mergeRefs<T>(...refs: Array<React.Ref<T> | undefined>): React.RefCallback<T>;
-//# sourceMappingURL=mergeRefs.d.ts.map

package/dist/internal/overlay/FloatingPanel.d.ts

@@ -0,0 +1,34 @@
+import type * as React from "react";
+import type { ControlSize } from "@/internal/states";
+import type { FloatingLayer } from "./useFloatingLayer";
+export type FloatingPanelProps = Omit<React.HTMLAttributes<HTMLElement>, "onAnimationEnd"> & {
+    floating: FloatingLayer;
+    /** Tier of the panel (`data-size`) and of the controls inside. */
+    size: ControlSize;
+    /** The panel scrolls (a ScrollContainer) instead of a plain `<div>`. */
+    scroll?: boolean;
+    /** The raised floating surface (radius, shadow, fill). Default `true`. */
+    surface?: boolean;
+    ref?: React.Ref<HTMLElement>;
+};
+/**
+ * The panel of a floating layer: portaled to `<body>` when it opens (so it stacks above every
+ * layer opened before it, on the one overlay z-index), positioned, animated from `data-state` /
+ * `data-side` (foundation §8), a size context for the controls inside, and a layer context so
+ * layers opened inside stack above it in the layer stack. Renders nothing while closed.
+ */
+export declare function FloatingPanel({ floating, size, scroll, surface, className, onKeyDown, children, ref, ...rest }: FloatingPanelProps): import("react/jsx-runtime").JSX.Element | null;
+export type FloatingTriggerProps = {
+    /** Props of the layer for its trigger: `ref`, ARIA, handlers, `data-state`. */
+    triggerProps: Record<string, unknown> & {
+        ref?: React.Ref<HTMLElement>;
+    };
+    children: React.ReactElement;
+} & Record<string, unknown>;
+/**
+ * The trigger of a floating layer: merges the layer's `triggerProps` onto the single child, and
+ * forwards every other prop it receives (handlers, ARIA, `ref`) the same way, so a trigger wrapped
+ * by another trigger (`Tooltip.Trigger` around `Dropdown.Trigger`) keeps both. Handlers chain,
+ * `aria-describedby` ids join, the child's own props win.
+ */
+export declare function FloatingTrigger({ triggerProps, children, ...forwarded }: FloatingTriggerProps): import("react/jsx-runtime").JSX.Element;

package/dist/internal/overlay/focus.d.ts

@@ -0,0 +1,14 @@
+/** Tab stops inside `container`, in DOM order (hidden and `aria-hidden` ones skipped). */
+export declare function getFocusable(container: HTMLElement): HTMLElement[];
+/**
+ * Moves focus into a layer that just opened, unless focus is already inside (a child `autoFocus`):
+ * `[data-autofocus]`, else the first tab stop, else the container itself.
+ */
+export declare function focusInto(container: HTMLElement): void;
+/** Focuses `el` when it is still in the document. */
+export declare function focusBack(el: HTMLElement | null | undefined): void;
+/**
+ * The element focused right now — read while rendering the open transition, before a child
+ * `autoFocus` moves focus into the new layer, so it is the opener to return to on close.
+ */
+export declare function activeElement(): HTMLElement | null;

package/dist/internal/overlay/layerStack.d.ts

@@ -0,0 +1,41 @@
+import * as React from "react";
+/**
+ * The one stack of open overlay layers (foundation §8 "Overlay contract"): Modal, Drawer, the
+ * off-canvas Sidebar, CommandMenu, Popover, Dropdown, Select, TagSelect, Tooltip. One set of
+ * document listeners serves every layer and only the topmost layer reacts, so one Escape or one
+ * press outside closes one layer, and a press inside a nested (portaled) child layer never reaches
+ * its parent. The owner gets the reason and decides about focus.
+ */
+/** Why the stack asks a layer to close. */
+export type DismissReason = "escape" | "outside" | "scrim";
+/**
+ * How a press outside the layer dismisses it.
+ * - `pointerdown` — floating panels: as soon as the press starts outside (reason `outside`).
+ * - `click` — scrim layers: the press must start and end outside, so a drag from inside the dialog
+ *   onto the scrim never closes it (reason `scrim`).
+ * - `none` — the layer takes no part in presses or Tab (Tooltip); it still gets Escape first.
+ *
+ * A layer that opts out of outside dismissal (`closeOnOutsideClick={false}`) keeps `pointerdown` /
+ * `click` and ignores the reason, so it still blocks the layers below it.
+ */
+export type OutsideDismiss = "pointerdown" | "click" | "none";
+export type LayerEntry = {
+    /** The layer that rendered this one (context): it stays below its descendants. */
+    parent: LayerEntry | null;
+    /** The panel first (the trap container), then other parts that are not "outside" (the trigger). */
+    refs: ReadonlyArray<React.RefObject<HTMLElement | null>>;
+    dismiss: OutsideDismiss;
+    /** Tab cycles inside the panel while focus is in it, and is pulled back in from outside. */
+    trap: boolean;
+    onDismiss: (reason: DismissReason) => void;
+};
+/** Wrap a layer's content: layers opened inside it register as its descendants. */
+export declare const LayerProvider: React.Provider<LayerEntry | null>;
+export type UseLayerOptions = Omit<LayerEntry, "parent" | "trap"> & {
+    trap?: boolean;
+};
+/**
+ * Registers a layer in the stack while `open`. The entry keeps the latest options (no
+ * re-registration on a new callback). Wrap the layer's content in `<LayerProvider value={layer}>`.
+ */
+export declare function useLayer(open: boolean, options: UseLayerOptions): LayerEntry;

package/dist/internal/overlay/useFloatingLayer.d.ts

@@ -0,0 +1,60 @@
+import * as React from "react";
+import { type PositionOptions, type PositionSide } from "@/hooks/usePosition";
+import { type MotionDurationToken, type Presence } from "@/hooks/usePresence";
+import { type LayerEntry } from "./layerStack";
+export type UseFloatingLayerOptions = PositionOptions & {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    /** The anchor: positions the panel, is not "outside", and gets focus back on close. */
+    triggerRef: React.RefObject<HTMLElement | null>;
+    /** Escape closes the panel. Default `true`. */
+    closeOnEscape?: boolean;
+    /** A press outside the panel and its trigger closes it. Default `true`. */
+    closeOnOutsideClick?: boolean;
+    /**
+     * `pointerdown` (default) — a regular floating panel. `none` — a passive layer (Tooltip): no
+     * part in presses or Tab, no focus restore; Escape still closes it first.
+     */
+    dismiss?: "pointerdown" | "none";
+    /** Focus moves into the panel on open (`[data-autofocus]` → first tab stop → the panel). */
+    focusOnOpen?: boolean;
+    /** Tab cycles inside the panel. */
+    trap?: boolean;
+    /**
+     * Without `trap`, how Tab leaves the panel (focus goes to the trigger and the panel closes):
+     * `always` — any Tab (menus, listboxes); `edges` — Tab past the last / Shift+Tab before the first
+     * tab stop (dialog-like panels); `none` — focus never sits in the panel.
+     */
+    tabExit?: "always" | "edges" | "none";
+    /** Exit animation token. Default `fast`. */
+    exitDuration?: MotionDurationToken;
+    /** Unmount at once on close, skipping the exit animation (a Tooltip replaced by its neighbour). */
+    skipExit?: boolean;
+};
+export type FloatingLayer = {
+    open: boolean;
+    presence: Presence;
+    /** Render the panel while true. */
+    mounted: boolean;
+    /** The side after flipping. */
+    side: PositionSide;
+    /** Attach to the panel element (merged with a consumer ref). */
+    panelRef: React.RefCallback<HTMLElement>;
+    /** The panel element while mounted. */
+    contentRef: React.RefObject<HTMLElement | null>;
+    layer: LayerEntry;
+    /**
+     * Closes the panel and returns focus to the trigger when it was in the panel (Escape, a pick,
+     * Tab, a close button, code).
+     */
+    close: () => void;
+    /** Tab leaving the panel; part of the panel's `onKeyDown`. */
+    onKeyDown: (event: React.KeyboardEvent<HTMLElement>) => void;
+};
+/**
+ * The one floating-layer primitive: Popover, Dropdown, Tooltip, Select and TagSelect. Presence
+ * (exit animation), positioning against the trigger, a place in the layer stack and one focus
+ * policy (foundation §8): focus returns to the trigger after Escape, a pick, Tab or a close — not
+ * after a press outside, where focus follows the pointer. Render the panel with `FloatingPanel`.
+ */
+export declare function useFloatingLayer({ open, onOpenChange, triggerRef, closeOnEscape, closeOnOutsideClick, dismiss, focusOnOpen, trap, tabExit, exitDuration, skipExit, ...positionOptions }: UseFloatingLayerOptions): FloatingLayer;

package/dist/internal/polymorphic.d.ts

@@ -0,0 +1,9 @@
+import type * as React from "react";
+type UnionToIntersection<U> = (U extends unknown ? (arg: U) => void : never) extends (arg: infer I) => void ? I : never;
+/**
+ * The ref a polymorphic `<Tag>` accepts when `Tag` is a union of tag names (an `as` prop): JSX
+ * checks it against every element of the union at once. Parts keep `ref?: Ref<HTMLElement>` in
+ * their props and pass `ref as TagRef<TheirAs>` to the tag.
+ */
+export type TagRef<Tag extends keyof HTMLElementTagNameMap> = React.Ref<UnionToIntersection<HTMLElementTagNameMap[Tag]>>;
+export {};

package/dist/internal/progressSegments.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Shared props, math and accessible text of the progress indicators (ProgressBar, ProgressCircle):
+ * one `value`, or `segments` that split a whole.
+ */
+import type { Tone } from "./states";
+/** The two modes of a progress indicator; the component adds its own common props. */
+export type ProgressModeProps = {
+    /** Current value; clamped to `0…max`. */
+    value: number;
+    /** Top of the scale. Default `100`. */
+    max?: number;
+    /** Fill color. Default `accent`. */
+    tone?: Tone;
+    segments?: never;
+    segmentGap?: never;
+    labels?: never;
+} | {
+    /** Parts in order (left to right, clockwise from the top); each one's size is its share of `max`. */
+    segments: ProgressSegment[];
+    /** Total capacity. Default: the sum of the segments (they fill the whole indicator). */
+    max?: number;
+    /** `hairline` draws every part on its own with a gap. Default `none`. */
+    segmentGap?: "none" | "hairline";
+    /** Built-in accessible strings for empty distributions. */
+    labels?: Partial<ProgressSegmentsLabels>;
+    value?: never;
+    tone?: never;
+};
+/** `value` mode: `max` defaults to 100 (or when not positive) and `value` is clamped to `0…max`. */
+export declare function resolveValue(value: number, max: number | undefined): {
+    value: number;
+    max: number;
+    ratio: number;
+    percent: number;
+};
+export type ProgressSegment = {
+    /** Non-negative weight; negative or non-finite values count as 0. */
+    value: number;
+    label?: string;
+    /** Segment fill. Default `accent`. */
+    tone?: Tone;
+};
+export type ProgressSegmentsLabels = {
+    /** Accessible description when `segments` is empty. */
+    empty: string;
+    /** Accessible description when every segment weighs zero. */
+    allEmpty: string;
+};
+export declare const DEFAULT_PROGRESS_SEGMENTS_LABELS: ProgressSegmentsLabels;
+export type ResolvedSegments = {
+    segments: ProgressSegment[];
+    /** Sum of the segment weights. */
+    total: number;
+    /** Full scale: `max` when it exceeds the sum, otherwise the sum. */
+    scale: number;
+    /** Free capacity: `scale - total`. */
+    rest: number;
+    /** Rounded filled share, 0–100. */
+    percent: number;
+    /** "Видео: 38%, Документы: 21%" or the empty texts. */
+    text: string;
+};
+export declare function resolveSegments(input: ProgressSegment[], max: number | undefined, labels: ProgressSegmentsLabels): ResolvedSegments;

package/dist/internal/rovingFocus.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Keyboard → index math for roving focus, shared by single-row groups (tablist, radiogroup of
+ * segments) and grids (swatches). Pure functions: the caller owns the items, focus and selection.
+ */
+/** Which arrow keys move along a single row. `both` accepts all four (a vertical list shown as a row). */
+export type RovingOrientation = "horizontal" | "vertical" | "both";
+/**
+ * Next index in a wrapping row of `count` items, or `null` when `key` does not navigate.
+ * Arrows wrap around the ends; Home / End jump to the first / last item. A current index of `-1`
+ * (nothing focused yet) moves to the first item on "next" and to the last on "previous".
+ */
+export declare function rovingIndex(key: string, index: number, count: number, orientation?: RovingOrientation): number | null;
+/**
+ * Next index in a grid of `count` items laid out in rows of `columns`, or `null` when `key` does
+ * not navigate. Left / Right step through the reading order and stop at the ends; Up / Down move
+ * one row and stay put when there is no row; Home / End jump to the first / last item.
+ */
+export declare function gridIndex(key: string, index: number, count: number, columns: number): number | null;

package/dist/internal/scrollAncestors.d.ts

@@ -1,3 +1,2 @@
-/** window, прокручиваемые предки якоря и visualViewport — для пересчёта fixed при scroll. */
+/** `window` and the scrolling ancestors of the anchor: where a fixed layer listens for scroll. */
 export declare function getScrollContainers(node: Element | null): Array<Element | Window | VisualViewport>;
-//# sourceMappingURL=scrollAncestors.d.ts.map