prime-ui-kit 0.15.0 → 0.16.0

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

@@ -0,0 +1,59 @@
+import type * as React from "react";
+import { type ControlSize } from "../states";
+import { type DialogLabels, type DialogRootOptions } from "./DialogParts";
+export type ModalLabels = DialogLabels;
+export type ModalRootProps = Omit<DialogRootOptions, "labels" | "confirmOnEnter"> & {
+    /**
+     * Escape closes the dialog.
+     */
+    closeOnEscape?: boolean;
+    /**
+     * A click on the scrim (and a swipe down, which draws the grab handle) closes the dialog. A destructive action is confirmed in a ConfirmDialog; unsaved changes are held by `Guard`.
+     */
+    closeOnOutsideClick?: boolean;
+    /**
+     * Enter inside the dialog clicks the element wrapped in `Modal.Confirm`; Enter on a button, link, `textarea`, `select`, checkbox or in the header keeps its own meaning.
+     */
+    confirmOnEnter?: boolean;
+    /**
+     * Replaces the default Enter confirm (the `Modal.Confirm` click).
+     */
+    onEnterConfirm?: (event: KeyboardEvent) => void;
+    /**
+     * Built-in strings, see Labels.
+     */
+    labels?: Partial<ModalLabels>;
+    /**
+     * Trigger and Content.
+     */
+    children?: React.ReactNode;
+};
+export declare function ModalRoot({ confirmOnEnter, children, ...options }: ModalRootProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace ModalRoot {
+    var displayName: string;
+}
+/** Where the dialog stands: centred, or near the top (a palette whose list grows downward). */
+export type ModalPlacement = "center" | "top";
+export type ModalContentProps = React.HTMLAttributes<HTMLDivElement> & {
+    /**
+     * Width: 360 · 440 · 560 · 720 · 960.
+     */
+    size?: ControlSize;
+    /**
+     * `center`: in the middle; on a phone a bottom sheet that swipes down (`closeOnOutsideClick`). `top`: near the top edge at every width, growing downward — a search palette above the on-screen keyboard.
+     */
+    placement?: ModalPlacement;
+    /**
+     * Portal target.
+     */
+    container?: HTMLElement | null;
+    /**
+     * Class on the scrim.
+     */
+    overlayClassName?: string;
+    ref?: React.Ref<HTMLDivElement>;
+};
+export declare function ModalContent({ size, placement, ...props }: ModalContentProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace ModalContent {
+    var displayName: string;
+}

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

@@ -7,25 +7,49 @@ export declare function getFocusable(container: HTMLElement): HTMLElement[];
 export declare function hasNativeTabStop(el: HTMLElement): boolean;
 /**
  * Moves focus into a layer that just opened, unless focus is already inside (a child `autoFocus`):
+ * the first match of `first` (a menu's first enabled item, which is no tab stop of its own), else
  * `[data-autofocus]`, else the first tab stop, else the container itself.
  */
-export declare function focusInto(container: HTMLElement): void;
+export declare function focusInto(container: HTMLElement, first?: string): void;
 /**
  * Focuses `el` when it is still in the document. `quiet` — the layer was opened with a pointer:
  * focus returns without the focus ring, also when a key (Escape) closed the layer; the next key
- * brings the ring back.
+ * brings the ring back. When `el` is gone (the row that opened a menu was deleted), focus goes to
+ * the first tab stop of the page instead, so it is never lost and the next Tab starts from a known
+ * place.
  */
 export declare function focusBack(el: HTMLElement | null | undefined, quiet?: boolean): void;
-/** Who opened a layer, to return focus to on close, and whether a pointer did it. */
+/**
+ * Hands focus from a part that is about to leave to the part that takes its place (a region that
+ * swaps state, a dismissed message, an item moved to another place): only when `leaving` holds
+ * focus, or held it and is already gone with focus lost to the body. `next` is focused itself when
+ * it is a tab stop; a container gets focus on its `[data-autofocus]`, else its first tab stop,
+ * else itself (made programmatically focusable, `tabindex="-1"`). Without a `next` in the document,
+ * focus goes to the first tab stop of the page. Returns whether focus moved.
+ */
+export declare function handoffFocus(leaving: Element | null | undefined, next: HTMLElement | null | undefined): boolean;
+/**
+ * The tab stop that takes the place of `el` when it leaves the page (a dismissed banner, a closed
+ * toast): the first one after it in document order, else the last one before it. Tab stops inside
+ * `el` do not count.
+ */
+export declare function tabStopBeside(el: Element): HTMLElement | null;
+/**
+ * Who opened a layer, to return focus to on close: `element` — the control (or the focused
+ * element); `target` — the exact element a press landed on (a picture inside a link, for a layer
+ * that grows out of it), `null` after a key; `byPointer` — a pointer did it.
+ */
 export type Opener = {
     element: HTMLElement | null;
+    target: Element | null;
     byPointer: boolean;
 };
 /**
  * The opener of a layer, read while rendering the open transition (before a child `autoFocus`
  * moves focus in). After a press: the control pressed — a click leaves focus elsewhere in Safari
- * (the body, or a `tabindex="-1"` region around the button) — and `byPointer`, so focus goes
- * back without a focus ring. After a key: the focused element, and the ring shows.
+ * (the body, or a `tabindex="-1"` region around the button) — the element pressed, and
+ * `byPointer`, so focus goes back without a focus ring. After a key: the focused element, and the
+ * ring shows.
  */
 export declare function captureOpener(): Opener;
 /**

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

@@ -1,7 +1,9 @@
 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
+ * The one stack of open overlay layers (foundation §8 "Overlay contract"): Modal, ConfirmDialog,
+ * Drawer, Sheet, CommandMenu, MediaViewer, the off-canvas Sidebar (through `useModalLayer`),
+ * Popover, Dropdown, Tooltip, the Select, TagSelect, Datepicker and ColorPresets panels, the
+ * reaction bar of a Message and the chart tooltip (through `useFloatingLayer`). 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.
@@ -16,9 +18,9 @@ export type DismissReason = "escape" | "outside" | "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.
+ * `click`; its hook drops the reason, so it still blocks the layers below it.
  */
-export type OutsideDismiss = "pointerdown" | "click" | "none";
+type OutsideDismiss = "pointerdown" | "click" | "none";
 export type LayerEntry = {
     /** The layer that rendered this one (context): it stays below its descendants. */
     parent: LayerEntry | null;
@@ -31,7 +33,7 @@ export type LayerEntry = {
 };
 /** 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"> & {
+type UseLayerOptions = Omit<LayerEntry, "parent" | "trap"> & {
     trap?: boolean;
 };
 /**
@@ -39,3 +41,4 @@ export type UseLayerOptions = Omit<LayerEntry, "parent" | "trap"> & {
  * re-registration on a new callback). Wrap the layer's content in `<LayerProvider value={layer}>`.
  */
 export declare function useLayer(open: boolean, options: UseLayerOptions): LayerEntry;
+export {};

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

@@ -0,0 +1,14 @@
+import * as React from "react";
+type AnchorName = {
+    "aria-labelledby"?: string;
+    "aria-label"?: string;
+};
+/**
+ * The accessible name of a floating panel without a heading of its own (a menu, a popover with no
+ * Title): the control it opened from — the trigger, or the control inside an anchor (the menu
+ * button under `Popover.Anchor`, a row under `Dropdown.Anchor`) — by its id when it has one, else
+ * by its `aria-label`, else by its text. Read from the DOM while open, never guessed: a child's own id wins over the
+ * one the trigger was given. `named` — the panel has a heading that names it: nothing is read.
+ */
+export declare function useAnchorName(open: boolean, named: boolean, anchorRef: React.RefObject<HTMLElement | null>): AnchorName;
+export {};

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

@@ -0,0 +1,7 @@
+/**
+ * The wheel over an open anchored panel does not scroll the page under it; scrolling areas inside
+ * it (a list, the panel itself when it overflows) work as usual. `overscroll-behavior: contain` is
+ * not enough: it only holds while the panel overflows, and a panel that fits chains the wheel to
+ * the page. `panel` is the boundary; `null` turns it off.
+ */
+export declare function useContainScroll(panel: HTMLElement | null): void;

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

@@ -1,23 +1,28 @@
 import * as React from "react";
 import { type PositionOptions, type PositionSide } from "../../hooks/usePosition";
-import { type MotionDurationToken, type Presence } from "../../hooks/usePresence";
+import { type Presence } from "../../hooks/usePresence";
+import { type SwipeDismiss } from "../../hooks/useSwipeDismiss";
+import type { MotionDurationToken } from "../motionTiming";
 import { type LayerEntry } from "./layerStack";
-export type UseFloatingLayerOptions = PositionOptions & {
+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;
+    /** Escape closes the panel (a passive layer passes `true`: Escape always hides it). */
+    closeOnEscape: boolean;
+    /** A press outside the panel and its trigger, or a swipe down on its sheet, closes it. */
+    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;
+    /**
+     * Focus moves into the panel on open: `true` — `[data-autofocus]` → first tab stop → the panel;
+     * a selector — its first match first (a menu's first enabled item, which is no tab stop).
+     */
+    focusOnOpen?: boolean | string;
     /** Tab cycles inside the panel. */
     trap?: boolean;
     /**
@@ -46,8 +51,8 @@ export type FloatingLayer = {
     side: PositionSide;
     /** Rendered as a bottom sheet (`sheet` on a narrow viewport). */
     sheet: boolean;
-    /** Swipe-to-close of the sheet; part of the sheet's `onPointerDown`. */
-    onSheetPointerDown: (event: React.PointerEvent<HTMLElement>) => void;
+    /** Swipe-to-close of the sheet: its handle shows while `enabled`; part of the sheet's props. */
+    swipe: SwipeDismiss;
     /** Attach to the panel element (merged with a consumer ref). */
     panelRef: React.RefCallback<HTMLElement>;
     /** The panel element while mounted. */
@@ -62,9 +67,33 @@ export type FloatingLayer = {
     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`.
+ * The one floating-layer primitive: Popover, Dropdown, Tooltip, Select, TagSelect, the reaction
+ * bar of a Message and the chart tooltip. Presence (exit animation), positioning against the
+ * trigger, a place in the layer stack with the dismiss options applied inside, the wheel kept off
+ * the page under the panel, 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, sheet: sheetOption, ...positionOptions }: UseFloatingLayerOptions): FloatingLayer;
+type FloatingTriggerStateOptions = {
+    open: boolean;
+    setOpen: (open: boolean) => void;
+    /**
+     * ArrowDown and ArrowUp on the trigger open a closed layer, as on a menu button or a picker
+     * (WAI-ARIA); Enter and Space open it as the trigger's click.
+     */
+    openOnArrow?: boolean;
+};
+/**
+ * The props of a floating layer's trigger that follow its open state: `aria-expanded`,
+ * `data-state`, the click that toggles the layer, and with `openOnArrow` the arrow keys that open
+ * it. Merged onto the consumer's element by `FloatingTrigger` (the element's own handlers run
+ * first; `preventDefault()` in them skips these).
+ */
+export declare function floatingTriggerProps({ open, setOpen, openOnArrow, }: FloatingTriggerStateOptions): {
+    onKeyDown?: ((event: React.KeyboardEvent<HTMLElement>) => void) | undefined;
+    "aria-expanded": boolean;
+    "data-state": string;
+    onClick: () => void;
+};
+export {};

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

@@ -0,0 +1,22 @@
+type UseOpenStateOptions = {
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    /**
+     * The owner is out of action (a disabled field): the layer is closed whatever `open` /
+     * `defaultOpen` say, and nothing opens it; it opens again by itself once enabled, when its open
+     * state still says so.
+     */
+    disabled?: boolean;
+};
+type OpenState = readonly [
+    open: boolean,
+    setOpen: (next: boolean | ((open: boolean) => boolean)) => void
+];
+/**
+ * The open triad of an overlay (`open` / `defaultOpen` / `onOpenChange`), controlled or not, with
+ * the disabled gate every overlay owner shares: a disabled owner renders closed and ignores a
+ * request to open; a request to close always goes through.
+ */
+export declare function useOpenState({ open, defaultOpen, onOpenChange, disabled, }: UseOpenStateOptions): OpenState;
+export {};

package/dist/internal/partPresence.d.ts

@@ -0,0 +1,31 @@
+import * as React from "react";
+type PartPresenceOptions = {
+    /**
+     * Whether the host shows the part now. It enters when this turns on after the host's first
+     * render; on the first render it is just there.
+     */
+    present?: boolean;
+    /** The axis the part closes up along when it leaves (`leaveInPlace`). */
+    axis: "inline" | "block";
+};
+type PartPresence<E extends HTMLElement> = {
+    /** The part's ref: on unmount, whatever caused it, the part closes up in place. */
+    ref: React.RefCallback<E>;
+    /** The part's enter class (`enterMotion.enter`) while it is a part that arrived. */
+    className: string | undefined;
+};
+/**
+ * Presence of an optional part that comes and goes while its host stays (a clear button, a chip
+ * row, a remove segment, a change badge): it rises in when it appears (`enterMotion`; the host
+ * tunes it with `--enter-*`) and closes up in place when it goes (`leaveInPlace`), so the parts
+ * around it glide instead of jumping. Called by the host that owns the condition; spread the
+ * result on the part:
+ *
+ *   const clear = usePartPresence<HTMLButtonElement>({ present: hasValue, axis: "inline" });
+ *   {hasValue ? <button ref={clear.ref} className={cx(styles.clear, clear.className)} /> : null}
+ *
+ * A part that unmounts itself (a chip removed from a list) passes no `present`: only its exit
+ * plays. Reduced motion: the part appears with the fade only and leaves at once.
+ */
+export declare function usePartPresence<E extends HTMLElement>({ present, axis, }: PartPresenceOptions): PartPresence<E>;
+export {};

package/dist/internal/parts.d.ts

@@ -0,0 +1,39 @@
+import * as React from "react";
+/**
+ * Whether a child is an element of the given part (element types are compared, never
+ * `displayName`).
+ */
+export declare function isPart<P = unknown>(node: React.ReactNode, type: React.ElementType): node is React.ReactElement<P>;
+/**
+ * The children as a flat list: fragments opened (their keys prefixed, so they stay unique),
+ * `null`, `undefined` and booleans dropped.
+ */
+export declare function flattenChildren(nodes: React.ReactNode, prefix?: string): React.ReactNode[];
+/**
+ * Splits the direct children into the elements of the given part types and the rest, each in the
+ * written order (`PageToolbar.Chips` under the bar, `Badge.Action` at the end of the badge).
+ */
+export declare function splitParts<P = unknown>(children: React.ReactNode, ...types: React.ElementType[]): {
+    parts: React.ReactElement<P>[];
+    rest: React.ReactNode[];
+};
+/** Plain text children become `Label` elements, so every item title is its labelling part. */
+export declare function labelPlainText(children: React.ReactNode, Label: React.ComponentType<{
+    children: React.ReactNode;
+}>): React.ReactNode;
+/** A text part of an item: its title, a count after it, the second line. */
+type TextPart = "label" | "count" | "description";
+/**
+ * The text parts of a two-line item (a tab, a segment): its `Label`, `Count` and `Description`
+ * register their ids (`useTextPartId`), and the item takes its name from the label and the count
+ * and its description from the second line — by ids that are in the document, never guessed. A
+ * one-line item (no description) is named by its content and gets neither attribute.
+ */
+export declare function useTextParts(): {
+    provide: (children: React.ReactNode) => React.ReactElement;
+    labelledBy: string | undefined;
+    describedBy: string | undefined;
+};
+/** The id of a text part inside an item (`useTextParts`); `undefined` outside one. */
+export declare function useTextPartId(part: TextPart): string | undefined;
+export {};

package/dist/internal/progressSegments.d.ts

@@ -5,31 +5,70 @@
 import type { PaletteColor, 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 mode: the current value, clamped to `0…max`.
+     */
     value: number;
-    /** Top of the scale. Default `100`. */
+    /**
+     * Value mode: top of the scale. Segments mode: total capacity; a `max` above the sum of the parts leaves the rest as track.
+     */
     max?: number;
-    /** Fill color. Default `accent`. */
+    /**
+     * Value mode: fill color, telling the outcome.
+     */
     tone?: Tone;
+    /**
+     * Segments mode: parts in order, `{ value, label?, tone? | color? }`: `tone` names a meaning (default `accent`), `color` a category, as in its charts. Each part's width is its share of `max`.
+     */
     segments?: never;
+    /**
+     * Segments mode: `none` — one continuous pill; `hairline` — every part and the rest are separate pills. `bar` layout.
+     */
     segmentGap?: never;
+    /**
+     * Segments mode: built-in strings, see Labels.
+     */
     labels?: never;
+    /**
+     * Segments mode: a legend under the bar, one row per part: color · name · value · share; it becomes the group's description. `bar` layout.
+     */
     legend?: never;
+    /**
+     * Segments mode: display of a part's value in the legend and the rows («1 840 000 ₽»).
+     */
     formatValue?: never;
 } | {
-    /** Parts in order (left to right, clockwise from the top); each one's size is its share of `max`. */
+    /**
+     * Segments mode: parts in order, `{ value, label?, tone? | color? }`: `tone` names a meaning (default `accent`), `color` a category — its step of the chart palette. Each part's length is its share of `max`.
+     */
     segments: ProgressSegment[];
-    /** Total capacity. Default: the sum of the segments (they fill the whole indicator). */
+    /**
+     * Value mode: top of the scale. Segments mode: total capacity; the sum of the parts closes the ring, a larger `max` leaves the rest as track.
+     */
     max?: number;
-    /** `hairline` draws every part on its own with a gap. Default `none`. */
+    /**
+     * Segments mode: `none` — one continuous ring; `hairline` — every part and the rest are separate round arcs.
+     */
     segmentGap?: "none" | "hairline";
-    /** Built-in accessible strings for empty distributions. */
+    /**
+     * Segments mode: built-in strings, see Labels.
+     */
     labels?: Partial<ProgressSegmentsLabels>;
-    /** A legend of the parts: color · name · value · share. Default `false`. */
+    /**
+     * Segments mode: a legend beside the ring (below it when narrow), one row per part: color · name · value · share; with `aria-label` it becomes the group's description. The root turns into the row of ring and legend.
+     */
     legend?: boolean;
-    /** Display of a value in the legend (and in ProgressBar rows). Default: Russian digit groups. */
+    /**
+     * Segments mode: display of a part's value in the legend («38 ГБ»).
+     */
     formatValue?: (value: number) => string;
+    /**
+     * Value mode: the current value, clamped to `0…max`; it glides to a new value (`base`). `null` — under way, the share unknown: a quarter arc that always turns, no `aria-valuenow`.
+     */
     value?: never;
+    /**
+     * Value mode: arc color, telling the outcome. `inherit` — the arc in the host's text color over a 32% track of it, for a ring on a colored host or over media.
+     */
     tone?: never;
 };
 /** `value` mode: `max` defaults to 100 (or when not positive) and `value` is clamped to `0…max`. */
@@ -63,7 +102,7 @@ export declare function segmentFill(segment: ProgressSegment): {
 };
 /** What 100% of a row is in the `rows` layout. */
 export type ProgressScale = "sum" | "max" | "first";
-export type ResolvedRow = {
+type ResolvedRow = {
     segment: ProgressSegment;
     /** Bar length, 0–1. */
     ratio: number;
@@ -83,8 +122,8 @@ export type ProgressSegmentsLabels = {
     /** Accessible description when every segment weighs zero. */
     allEmpty: string;
 };
-export declare const DEFAULT_PROGRESS_SEGMENTS_LABELS: ProgressSegmentsLabels;
-export type ResolvedSegments = {
+export declare const PROGRESS_SEGMENTS_LABELS: ProgressSegmentsLabels;
+type ResolvedSegments = {
     segments: ProgressSegment[];
     /** Sum of the segment weights. */
     total: number;
@@ -98,3 +137,4 @@ export type ResolvedSegments = {
     text: string;
 };
 export declare function resolveSegments(input: ProgressSegment[], max: number | undefined, labels: ProgressSegmentsLabels): ResolvedSegments;
+export {};

package/dist/internal/richText.d.ts

@@ -1,45 +1,17 @@
 import * as React from "react";
-export type RichInline = {
-    type: "text";
-    text: string;
-} | {
-    type: "bold" | "italic" | "strike" | "spoiler";
-    children: RichInline[];
-} | {
-    type: "code";
-    text: string;
-} | {
-    type: "link";
-    href: string;
-    children: RichInline[];
-};
-export type RichBlock = {
-    type: "text";
-    children: RichInline[];
-} | {
-    type: "quote";
-    children: RichInline[];
-} | {
-    type: "code";
-    text: string;
-};
-/** The address when it is a safe link, else `null`. */
-export declare function safeHref(raw: string): string | null;
-/** Inline markup of one run of text. */
-export declare function parseInline(source: string): RichInline[];
-/** Blocks of a message: runs of text, quotes (`> ` lines) and fenced code. */
-export declare function parseRichText(source: string): RichBlock[];
-export type RichTextLabels = {
+type RichTextLabels = {
     /** Accessible name of a masked spoiler: its text is not read until it is revealed. */
     spoiler: string;
 };
-export type RichTextProps = {
+type RichTextProps = {
     source: string;
     /** Rendered at the very end of the last line (a chat bubble's meta reserve). */
     end?: React.ReactNode;
     /** Marks every case-insensitive match of this text (a search through a chat). */
     highlight?: string;
-    labels?: Partial<RichTextLabels>;
+    /** The host's strings (`Message.Text` passes its `spoiler`). */
+    labels: RichTextLabels;
 };
 /** A message text with its Markdown subset rendered safely; `end` closes the last text line. */
-export declare function RichText({ source, end, highlight, labels: labelsProp }: RichTextProps): import("react/jsx-runtime").JSX.Element;
+export declare function RichText({ source, end, highlight, labels }: RichTextProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/internal/ring.d.ts

@@ -16,9 +16,12 @@ export declare const RING_DATA_STROKE: number;
  * - `line` — a ring inside a control (Spinner, the ring of a circle Button, a transfer disk): the
  *   kit's line weight, two border widths — the weight of an icon's stroke at the control's tier,
  *   at every diameter.
+ * - `band` — a band of one spacing step over the edge of a round video (the playback ring of
+ *   VideoNote, the recording ring of the Composer).
  */
-export type RingWeight = "data" | "line";
-export type RingProps = Omit<React.SVGAttributes<SVGSVGElement>, "children"> & {
+type RingWeight = "data" | "line" | "band";
+type RingTrack = "line" | "faint" | "surface" | "none";
+type RingProps = Omit<React.SVGAttributes<SVGSVGElement>, "children"> & {
     /**
      * The share drawn, `0…1`; `null` — under way, the share unknown: a quarter arc that always
      * turns. Ignored with `live`.
@@ -26,8 +29,13 @@ export type RingProps = Omit<React.SVGAttributes<SVGSVGElement>, "children"> & {
     value: number | null;
     /** The ring turns at any share (one turn = 3 × `--prime-motion-loop`); the arc never under 8%. */
     spin?: boolean;
-    /** A faint full circle under the arc. Default `true`. */
-    track?: boolean;
+    /**
+     * The full circle under the arc: `line` — `currentColor` at the line tint, for a ring on a
+     * colored host or over media (default); `faint` — at the hover tint, for a ring that is only a
+     * loading cue (Spinner); `surface` — `fill-strong`, the track of a line on a surface (as
+     * ProgressBar's); `none` — no track.
+     */
+    track?: RingTrack;
     /** Default `line`. */
     weight?: RingWeight;
     /**
@@ -56,9 +64,11 @@ export declare function RingCap({ position, className, style, ...rest }: React.S
  * it. An SVG without a viewBox: the circle is placed in CSS (`r`, the stroke from `weight`), so
  * the stroke is exact at every diameter; lengths are percent of the circle (`RING_PATH`). The arc
  * starts at 12 o'clock and runs clockwise with round ends; its share is one variable
- * (`--ring-value`) and glides by itself (`base`, on the paint of the arc), while the turn is a
- * transform of the whole svg (compositor) — so a share grows while the ring turns. Colors:
- * `--ring-fill` (default `currentColor`) and `--ring-track` (default `currentColor` at 32%).
- * Decorative (`aria-hidden`) unless the host gives it a role.
+ * (`--ring-value`) and glides by itself (`base`, on the paint of the arc), while the turn is the
+ * `rotate` of its inner group (compositor) — so a share grows while the ring turns, and a host's
+ * own animation of the svg (a region swap) runs beside it. The fill is `--ring-fill` (default
+ * `currentColor`); the track is `currentColor` at the line tint. Decorative (`aria-hidden`)
+ * unless the host gives it a role.
  */
 export declare function Ring({ value, spin, track, weight, live, className, style, children, role, ...rest }: RingProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/internal/rovingFocus.d.ts

@@ -3,16 +3,21 @@
  * 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";
+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".
+ * Next index in a row of `count` items, or `null` when `key` does not navigate. Arrows move one
+ * step and wrap around the ends (a tablist, a menu, a palette); with `wrap: false` they stop at the
+ * first and the last item (a long list whose ends are its edges: messages, conversations). 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;
+export declare function rovingIndex(key: string, index: number, count: number, orientation?: RovingOrientation, { wrap }?: {
+    wrap?: boolean;
+}): 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;
+export {};

package/dist/{components/data-table/rowEvents.d.ts → internal/rowLink.d.ts}

@@ -1,9 +1,4 @@
 import type * as React from "react";
-/**
- * Elements inside a row that are controls of their own: a click on them never opens the row, and
- * on a link row they sit above the row's hit area. `data-row-click-ignore` marks a custom widget.
- */
-export declare const ROW_CONTROLS: string;
 /**
  * Whether a click on a row should open it: it started inside the row's own DOM (React events
  * bubble out of portals — a ⋯ menu item in a cell — and those never count), not on a control

package/dist/internal/scrollAncestors.d.ts

@@ -1,2 +1,16 @@
+/**
+ * The boxes a person can scroll around an element: the one walk behind a layer that follows its
+ * anchor through scrolling (`usePosition`) and a gesture that scrolls the box under the pointer
+ * (`edgeAutoScroll`). `hidden` and `clip` are not scrolling: a locked region or one whose content
+ * fits never counts.
+ */
+export type ScrollAxes = {
+    x: boolean;
+    y: boolean;
+};
+/** The axes a person can scroll `element` along. */
+export declare function scrollAxes(element: Element): ScrollAxes;
+/** Scrollable boxes from `element` itself up to the root, innermost first. */
+export declare function scrollableAncestors(element: Element | null): HTMLElement[];
 /** `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>;