prime-ui-kit 0.15.0 → 0.17.0

package/dist/internal/listbox.d.ts

@@ -1,12 +1,12 @@
 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"`.
+ * CommandMenu: the item registry, the highlight store, the keyboard and the typeahead. Focus stays
+ * on the field (the search, the listbox); the highlight is a value, and Enter activates the
+ * highlighted item through the registry, never through a synthetic DOM click.
  */
 /** `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;
@@ -20,40 +20,80 @@ export declare function useCreateStore<T>(initial: T): Store<T>;
  * `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;
+/** What an item tells its listbox. */
+type ListboxItem = {
+    /** The visible name: typeahead, the trigger after the list closed, announcements. */
+    label: string;
+    /** The text a query is matched against, in lower case. */
+    haystack: string;
+    /** Shown but skipped by the arrows and never activated. */
+    disabled?: boolean;
+    /** Shown whatever the query, after the matches (create from the query, an action row). */
+    persistent?: boolean;
+    /** What Enter on the highlighted item and a click on it do. */
+    onActivate: () => void;
+};
+/** The items a query leaves on screen. */
+type ListboxView = {
+    /** Shown items: the matches, then the persistent ones. */
+    visible: ReadonlySet<string>;
+    /** Shown, enabled items in their order: what the arrows walk. */
+    navigable: readonly string[];
+    /** Shown items that match the query (persistent ones apart): the empty state. */
+    matchCount: number;
+};
+export type ListboxRegistry = {
+    /** Registers a mounted item (from a layout effect); returns the unregistration. */
+    register: (id: string, item: ListboxItem, node?: () => Element | null) => () => void;
+    /** Runs the item's `onActivate`; `false` when it is unknown, unmounted or disabled. */
+    activate: (id: string) => boolean;
+    /** The item's label, kept after it unmounts (the trigger of a closed list); else the id. */
+    labelOf: (id: string) => string;
+    /** The item's element, to bring the highlight into view. */
+    nodeOf: (id: string) => Element | null;
+    /** The items a query leaves on screen; the same object until an item or the query changes. */
+    view: (query: string, filter: boolean) => ListboxView;
+    subscribe: (listener: () => void) => () => void;
 };
+/** One registry per listbox instance. */
+export declare function useListboxRegistry(): ListboxRegistry;
+/** The items `query` leaves on screen; re-renders when an item (un)registers or changes. */
+export declare function useListboxView(registry: ListboxRegistry, query?: string, filter?: boolean): ListboxView;
 /**
- * Arrows, Home and End move the highlight (wrapping); Enter and Space pick it. Escape is the layer
- * stack's (it closes the panel).
+ * Registers an item while it is mounted. `onActivate` is read when it runs, so a new handler every
+ * render does not re-register the item; `nodeRef` is the element the highlight brings into view.
  */
-export declare function handleListboxKeyDown(event: React.KeyboardEvent<HTMLElement>, { items, highlight, onSelect }: ListboxKeyContext): void;
+export declare function useListboxItem(registry: ListboxRegistry, id: string, item: ListboxItem, nodeRef?: React.RefObject<Element | null>): 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.
+ * A key that belongs to an input method composing text (a Chinese, Japanese or Korean IME, a
+ * dictation): its Enter confirms the composition and its arrows pick a candidate, so a listbox
+ * leaves them alone. Safari reports such keys as `keyCode` 229 without `isComposing`.
  */
-export declare function useTypeahead(): {
-    find: (key: string, items: HTMLElement[], highlighted: string | undefined) => HTMLElement | undefined;
-    isTyping: () => boolean;
-};
-export type LoadMoreOptions = {
-    /** More can be requested now: `hasMore`, a handler, nothing loading, no load error. */
-    enabled: boolean;
-    onLoadMore: (() => void | Promise<void>) | undefined;
-    /** The list's own scroller: the observer root. */
-    scrollRef: React.RefObject<HTMLElement | null>;
-    /** Changes when the list changes (a batch arrived): re-arms the request. */
-    rearm: unknown;
+export declare function isComposingKey(event: React.KeyboardEvent): boolean;
+/**
+ * Brings the highlighted option into view inside the list's own scroller after a keyboard move
+ * (`block: "nearest"`); a highlight that follows the pointer never scrolls.
+ */
+export declare function revealHighlighted(element: Element | null | undefined): void;
+type ListboxKeyContext = {
+    /** The navigable items, in order. */
+    ids: readonly string[];
+    highlight: Store<string | undefined>;
+    /** Enter and Space on the highlighted item (the registry's `activate`). */
+    activate: (id: string) => void;
 };
 /**
- * Load more at the end of a list (Select, CommandMenu): a sentinel after the last option asks once
- * per round when it scrolls into the list's own scroller; `request` asks the same way from the
- * keyboard (the highlight reached the last option). Without `IntersectionObserver` (jsdom, old
- * engines) only `request` asks.
+ * Arrows, Home and End move the highlight (wrapping); Enter and Space activate it. Escape is the
+ * layer stack's (it closes the panel); a key of a composing input method is left alone. Returns
+ * the item the highlight moved to, for the host to reveal (`revealHighlighted`), or `null`.
  */
-export declare function useLoadMore({ enabled, onLoadMore, scrollRef, rearm }: LoadMoreOptions): {
-    sentinelRef: React.RefObject<HTMLDivElement | null>;
-    request: () => void;
+export declare function handleListboxKeyDown(event: React.KeyboardEvent<HTMLElement>, { ids, highlight, activate }: ListboxKeyContext): string | null;
+/**
+ * Typeahead by item label: the typed prefix finds the next match; the same letter repeated cycles
+ * through the items that start with it. Returns the match to highlight.
+ */
+export declare function useTypeahead(): {
+    find: (key: string, ids: readonly string[], highlighted: string | undefined, labelOf: (id: string) => string) => string | undefined;
+    isTyping: () => boolean;
 };
+export {};

package/dist/internal/longPress.d.ts

@@ -0,0 +1,42 @@
+import * as React from "react";
+/**
+ * A finger held this long picks up what it rests on to carry it: shorter than a long press, so a
+ * grab never feels like waiting, longer than the slow start of a scroll.
+ */
+export declare const DRAG_HOLD_MS = 280;
+/** A finger that moves further than this (px) before its hold ends is scrolling, not pressing. */
+export declare const PRESS_SLOP_PX = 8;
+/** Pointer travel (px) that turns a mouse or pen press into a drag: past the tremor of a click. */
+export declare const DRAG_THRESHOLD_PX = 4;
+type LongPressPoint = {
+    x: number;
+    y: number;
+};
+type LongPressOptions = {
+    /** Off: a press does nothing. */
+    enabled?: boolean;
+    /** The hold ended without the finger moving: the point it rests on, in client coordinates. */
+    onLongPress: (point: LongPressPoint) => void;
+    /** How long the finger rests. */
+    delay?: number;
+};
+type LongPressHandlers = {
+    onPointerDown: (event: React.PointerEvent) => void;
+    onPointerMove: (event: React.PointerEvent) => void;
+    onPointerUp: () => void;
+    onPointerCancel: () => void;
+};
+/**
+ * A long press of a finger on an element (a mouse has its right click): the hold starts on a touch
+ * press, ends in `onLongPress` when the finger rests for `delay`, and is given up when the finger
+ * moves past `PRESS_SLOP_PX` (it scrolls), lifts or is cancelled. `takeFired()` answers once
+ * whether the last press ended as a long press, so the click that follows the lift does not also
+ * activate the element. Spread `handlers` on the element; a host that has its own pointer
+ * handlers calls them from its own.
+ */
+export declare function useLongPress({ enabled, onLongPress, delay, }: LongPressOptions): {
+    handlers: LongPressHandlers;
+    cancel: () => void;
+    takeFired: () => boolean;
+};
+export {};

package/dist/internal/mediaDisk.d.ts

@@ -1,14 +1,17 @@
 /**
  * The still disk over media: the look of `Button shape="circle" variant="shade"` (`l`) for a disk
- * that is not a control. A host positions it; it may shrink it to a small frame (the glyph follows
- * at half the diameter).
+ * that is not a control. Join it with `data-size="l"` (the control tier it takes its diameter
+ * from). A host positions it; it may shrink it to a small frame (the glyph follows at half the
+ * diameter).
  */
 export declare const mediaDiskClass: string;
 /**
  * The play mark of a video frame: the still media disk with the play glyph — the same size, ground
  * and glyph as the play and transfer disks over media. Decorative: the tile around it is the
- * button and says what it opens.
+ * button and says what it opens. Always mounted: `shown={false}` fades and shrinks it away (the
+ * frame plays, a transfer takes the middle) and it comes back the same way.
  */
-export declare function MediaPlayMark({ className }: {
+export declare function MediaPlayMark({ shown, className, }: {
+    shown?: boolean;
     className?: string;
 }): import("react/jsx-runtime").JSX.Element;

package/dist/internal/mediaPlayer.d.ts

@@ -8,26 +8,40 @@ import { type TransferDiskProps } from "./transferDisk";
  * sound at a time on the page (`internal/mediaSession`), the keyboard seek, the transcript
  * (`internal/transcript`) and the transfer (`internal/transfer`, drawn by `internal/transferDisk`).
  * A player adds only what its media really has of its own (the voice waveform and rate, the
- * circle's poster) and keeps its own media logic.
+ * circle's poster); the playback itself is `useMediaPlayer`. Each prop is described in
+ * `mediaPlayer.api.ts`.
  */
 export type MediaPlayerProps = TranscriptProps & TransferProps & {
-    /** The media file; loaded with `preload="metadata"`. */
+    /**
+     * Audio URL, loaded with `preload="metadata"`: nothing plays before a press.
+     */
     src: string;
-    /** Length in seconds, shown until the media reports its own. */
+    /**
+     * Length in seconds, shown until the media reports its own.
+     */
     duration?: number;
-    /** Nobody has played it yet: an accent dot after the time. Clear it on `onPlayingChange(true)`. */
+    /**
+     * Nobody has played it yet: an accent dot after the time and `labels.unplayed` for screen readers. Clear it when `onPlayingChange(true)` comes; the dot fades out and the row closes up in place.
+     */
     unplayed?: boolean;
-    /** Playing with sound (controlled). One sound plays at a time on the page. */
+    /**
+     * Playing with sound (controlled): `true` plays it (from the start or on from a pause), `false` pauses it. One sound plays on the page at a time.
+     */
     playing?: boolean;
-    /** Initial playing state (uncontrolled). Default `false`. */
+    /**
+     * Initial playing state (uncontrolled).
+     */
     defaultPlaying?: boolean;
-    /** Playback with sound started or stopped: a press, another sound taking over, the end. */
+    /**
+     * Playback with sound started or stopped: the play disk, Enter / Space, another sound taking over, the end (then `onEnded` too); a drag on the waveform that pauses for the seek does not count.
+     */
     onPlayingChange?: (playing: boolean) => void;
-    /** Playback reached the end; the player is back at the start. */
+    /**
+     * Playback reached the end; the player is back at the start, paused.
+     */
     onEnded?: () => void;
     /**
-     * Nothing can be played: the play control, the seek, the transcript button and the transfer
-     * actions are off. A disabled `Fieldset` around the player disables it too.
+     * Nothing can be played: the play disk, the waveform slider and the rate chip, the transcript button and the transfer actions are off (native `disabled`). A disabled `Fieldset` around it disables it too.
      */
     disabled?: boolean;
 };
@@ -70,20 +84,38 @@ export declare const MEDIA_PLAYER_LABELS: {
 };
 /** Where a player's playback is: at the start, playing, or stopped past the start. */
 export type PlaybackState = "idle" | "playing" | "paused";
-/**
- * The keyboard seek of every player (on the voice waveform, on the circle): ArrowRight / ArrowUp
- * 5 s forward, ArrowLeft / ArrowDown 5 s back (mirrored in RTL), PageUp / PageDown a tenth, Home
- * / End the edges. The next position in seconds, or `null` for any other key.
- */
-export declare function seekByKey(event: React.KeyboardEvent<HTMLElement>, current: number, total: number): number | null;
 /** Splits a player's props: the shared player ones, and the rest (its own and the DOM's). */
 export declare function splitMediaPlayerProps<P extends MediaPlayerProps>(props: P): [MediaPlayerProps, Omit<P, keyof MediaPlayerProps>];
 /** The transfer disk's props a player hands on (it adds its own `look` and `className`). */
-export type PlayerTransferDisk = Pick<TransferDiskProps, "state" | "progress" | "labels" | "onCancel" | "onRetry" | "onDownload" | "disabled">;
-export type MediaPlayer = {
-    /** The triad: what the owner (or the player's last act) wants — it may lead the media. */
-    wanted: boolean;
-    setWanted: (playing: boolean) => void;
+type PlayerTransferDisk = Pick<TransferDiskProps, "state" | "progress" | "labels" | "onCancel" | "onRetry" | "onDownload" | "disabled">;
+type MediaPlayerOptions = {
+    /** Playback speed of the media. Default `1`. */
+    rate?: number;
+    /**
+     * The element whose `progressProperty` carries the played share (0…1): written every frame while
+     * playing and on every seek, never through a render.
+     */
+    progressRef?: React.RefObject<HTMLElement | SVGSVGElement | null>;
+    /** The custom property the share is written to. Default `--ring-value` (a live `Ring`). */
+    progressProperty?: string;
+};
+/** The media element's events the player listens to: spread them on the `<audio>` / `<video>`. */
+type MediaEvents = {
+    onPlay: () => void;
+    onPause: () => void;
+    onEnded: () => void;
+    onLoadedMetadata: () => void;
+    onDurationChange: () => void;
+};
+type MediaPlayer = {
+    /** Where the playback is: `idle` at the start, `playing`, `paused` past the start. */
+    state: PlaybackState;
+    /** The position in seconds: exact at rest, the whole second while playing. */
+    position: number;
+    /** The length the player knows (the media's own, else `duration`), `null` while unknown. */
+    duration: number | null;
+    /** A drag of the seek holds the playback (`scrub`). */
+    seeking: boolean;
     transcript: Transcript | null;
     /** Its own `disabled` or a disabled `Fieldset` around it. */
     disabled: boolean;
@@ -93,13 +125,43 @@ export type MediaPlayer = {
     inactive: boolean;
     /** The transfer disk to draw, or `null` without a transfer. */
     transferDisk: PlayerTransferDisk | null;
+    /** Plays (from the start out of `idle`, on from a pause) or pauses — inside the press. */
+    toggle: () => void;
+    /** Moves the position to `seconds` (clamped); out of `idle` it leaves the player paused there. */
+    seek: (seconds: number) => void;
+    /** The keyboard seek (`seekByKey`) on the element that has it; `true` when the key moved it. */
+    seekWithKey: (event: React.KeyboardEvent<HTMLElement>) => boolean;
+    /** A drag of the seek starts (`true`: a playing media holds) or ends (`false`: it resumes). */
+    scrub: (active: boolean) => void;
+    mediaEvents: MediaEvents;
 };
 /**
- * The shared half of a chat player: registers `mediaRef` with the one-sound session, holds the
- * `playing` triad, the transcript and the transfer. The player drives its media from `wanted`
- * and reports what the media does through `setWanted`.
+ * The one playback engine of the chat players. It registers `mediaRef` with the one-sound
+ * session, holds the `playing` triad and syncs the media to it, keeps the playback state
+ * (`idle` → `playing` ⇄ `paused` → the end rewinds to `idle`), starts with a rewind when the media
+ * stands elsewhere, applies the rate, follows the position with one animation-frame loop that
+ * writes the played share to `progressRef` (a render only when the second changes), and holds a
+ * playing media through a drag of the seek. The transcript and the transfer come with it. A player
+ * draws its media from this and spreads `mediaEvents` on the element.
+ */
+export declare function useMediaPlayer(mediaRef: React.RefObject<HTMLMediaElement | null>, props: MediaPlayerProps, labels: MediaPlayerLabels, { rate, progressRef, progressProperty }?: MediaPlayerOptions): MediaPlayer;
+/**
+ * The root of every player: a `role="group"` named by `labels.player`, with the player's state on
+ * it (`data-playing`, `data-seeking`, `data-disabled`, `data-transfer`).
+ */
+export declare function MediaPlayerRoot({ label, player, className, children, ...rest }: Omit<MediaPlayerRootProps, "children"> & {
+    label: string;
+    player: MediaPlayer;
+    children: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+/**
+ * The accent dot of a player nobody has played yet (after the voice message's time, in the video
+ * circle's duration pill): it rises in when `unplayed` turns on and closes up in place when it
+ * clears. Decorative; the player reads `labels.unplayed` itself.
  */
-export declare function useMediaPlayer(mediaRef: React.RefObject<HTMLMediaElement | null>, props: MediaPlayerProps, labels: MediaPlayerLabels): MediaPlayer;
+export declare function UnplayedDot({ shown }: {
+    shown: boolean;
+}): import("react/jsx-runtime").JSX.Element | null;
 /**
  * The play disk of every player: one `Button shape="circle"` (control `l`) for every state — play
  * ⇄ pause, and while the media is on its way, failed or not fetched, the transfer's ×, retry or
@@ -125,11 +187,13 @@ export declare function PlayDisk({ look, state, labels, disabled, covered, trans
 }): import("react/jsx-runtime").JSX.Element;
 /**
  * The transcript button of every player, so a voice message and a circle never drift: a soft `xs`
- * icon Button with the transcript mark («→A») that cross-fades into a chevron up while the text is
- * open, spinning (`loading`) while it is asked for. The player places it at its top end.
+ * icon Button with the transcript mark («→A») that cross-fades (`Button.Icon`) into a chevron up
+ * while the text is open, spinning (`loading`) while it is asked for. The player places it at its
+ * top end.
  */
 export declare function TranscriptButton({ transcript, disabled, className, }: {
     transcript: Transcript;
     disabled?: boolean;
     className?: string;
 }): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/internal/mediaSession.d.ts

@@ -1,10 +1,4 @@
 import * as React from "react";
-/** `media` started playing (or got its sound back while playing): it takes the session. */
-export declare function claimPlayback(media: HTMLMediaElement): void;
-/** `media` paused, ended or went away: the session is free. */
-export declare function releasePlayback(media: HTMLMediaElement): void;
-/** The media element now holding the session (tests and diagnostics). */
-export declare function activePlayback(): HTMLMediaElement | null;
 /**
  * Registers a media element with the session: playing it with sound pauses whatever else plays.
  * Listens to the element itself, so native controls, `play()` from code and the kit's own buttons

package/dist/internal/messageList.d.ts

@@ -19,7 +19,7 @@ export type Selection = readonly string[] | null;
  * The selection of a list, outside React state: each message subscribes to its own state in it
  * (`useMessageSelection`), so a toggle re-renders the messages whose state changed, not the list.
  */
-export type SelectionStore = {
+type SelectionStore = {
     get: () => Selection;
     /** `0` — not selecting, `1` — selecting, not selected, `2` — selected. */
     stateOf: (value: string) => 0 | 1 | 2;
@@ -84,7 +84,7 @@ export declare function useMessageSelection(value: string): {
 /** The whole selection of the list. */
 export declare function useListSelection(): Selection;
 /** What a message row says about itself from its props alone, before it renders. */
-export type MessageRowDescription = {
+type MessageRowDescription = {
     value: string | undefined;
     direction: MessageDirection;
     /** The row's height before it is measured (px). */
@@ -98,7 +98,7 @@ export type MessageRowDescription = {
  * typing, the selection bar). A `message` row describes itself; a `sticky` row is a date that
  * sticks while its day scrolls.
  */
-export type RowKind = {
+type RowKind = {
     tail?: boolean;
     sticky?: boolean;
     message?: (props: Record<string, unknown>) => MessageRowDescription;
@@ -119,3 +119,4 @@ export type MessageRowInfo = {
 /** The list wraps every row in it. */
 export declare const MessageRowProvider: React.Provider<MessageRowInfo | null>;
 export declare function useMessageRow(): MessageRowInfo | null;
+export {};

package/dist/internal/motionTiming.d.ts

@@ -0,0 +1,34 @@
+import { TOKEN_DEFAULTS } from "./tokenDefaults";
+/**
+ * Motion timing for code: the motion tokens read from the document, so theme, app overrides and
+ * reduced motion (which zeroes the movement clocks, foundation §7) apply to JS motion as they do
+ * to CSS. WAAPI and timers cannot take `var()`; everything that times a motion in JS reads here.
+ */
+export type MotionDurationToken = "xfast" | "fast" | "base" | "slow";
+type MotionCurve = "standard" | "enter" | "exit" | "emphasized";
+/** A custom property of the document root as written (`""` when the CSS cannot be read). */
+export declare function motionToken(name: `--prime-motion-${string}`): string;
+/**
+ * A duration token in ms, read from the document (respects theme and reduced-motion overrides);
+ * its token default when the CSS cannot be read.
+ */
+export declare function readCssDurationMs(name: keyof typeof TOKEN_DEFAULTS): number;
+/**
+ * A duration custom property in ms as it applies to `element` (a component clock such as
+ * `--prime-message-morph-duration`, which a theme or reduced motion may set); 0 when unset.
+ */
+export declare function readElementDurationMs(element: Element, name: `--${string}`): number;
+/** `--prime-motion-duration-<token>` in ms. */
+export declare function motionDurationMs(token: MotionDurationToken): number;
+/** When a motion of `ms` has surely ended: the timeout of a fallback that cleans up after it. */
+export declare function afterMotionMs(ms: number): number;
+/** Timeout fallback for an exit of `token` length: the token duration plus slack. */
+export declare function exitTimeoutMs(token: MotionDurationToken): number;
+/**
+ * WAAPI timing from the motion tokens (`--prime-motion-duration-<token>`,
+ * `--prime-motion-easing-<curve>`), read at animation time. Read once per frame: a computed style
+ * read of the root forces a style pass, and each list of a board would otherwise force its own
+ * after the previous list's glides.
+ */
+export declare function motionTiming(duration: MotionDurationToken, curve?: MotionCurve): KeyframeAnimationOptions;
+export {};

package/dist/internal/namedRole.d.ts

@@ -0,0 +1,13 @@
+import type * as React from "react";
+type NamedProps = {
+    role?: React.AriaRole;
+    "aria-label"?: string;
+    "aria-labelledby"?: string;
+};
+/**
+ * The role of a generic element (`<div>`, `<span>`) that the consumer may name: a name on an
+ * element without a role is ignored by assistive tech, so a named element takes `role` (`group`
+ * for a panel, `img` for a mark). An explicit `role` wins; an unnamed element keeps none.
+ */
+export declare function namedRole(props: NamedProps, role: React.AriaRole): React.AriaRole | undefined;
+export {};

package/dist/internal/nodeText.d.ts

@@ -0,0 +1,6 @@
+import * as React from "react";
+/**
+ * The plain text of a node tree: a label made of nodes (an icon and a word, a highlighted match)
+ * still has a name to search, announce or show in a trigger. Booleans and empty nodes add nothing.
+ */
+export declare function nodeText(node: React.ReactNode): string;

package/dist/{components/modal → internal/overlay}/DialogGuard.d.ts

@@ -1,17 +1,15 @@
 export type DialogGuardProps = {
     /**
-     * A request runs: Escape, a press outside, a swipe, the close button and `Close` do nothing; the
-     * close button and the `Close` child stay in place, disabled.
+     * A request runs: Escape, a press outside, a swipe, the close button and `Close` do nothing; the close button and the `Close` child stay in place, disabled. The grab handle stays and takes no drag.
      */
     busy?: boolean;
     /**
-     * Unsaved changes: any of those dismisses first asks «Не сохранять изменения?» (a ConfirmDialog
-     * with the Root's `labels.discard*`); confirming closes the dialog.
+     * Unsaved changes: any of those dismisses (a swipe glides back first) asks «Не сохранять изменения?» (a ConfirmDialog with `labels.discard*`); confirming closes the dialog.
      */
     dirty?: boolean;
 };
 /**
- * Holds a Modal or Drawer from inside its content, where the form state lives: put it anywhere in
+ * Holds a Modal, Drawer or Sheet from inside its content, where the form state lives: put it anywhere in
  * `Content`. Renders nothing but the «discard changes?» confirm when it is asked. Closing from code
  * (`open={false}`) is never held.
  */