prime-ui-kit 0.9.3 → 0.11.0

package/dist/index.d.ts

@@ -1,5 +1,10 @@
-export * from "./components";
-export * from "./icons";
+export * from "./components/index";
+export * from "./hooks/useTokenValue";
+export * from "./hooks/useUploadQueue";
+export * from "./icons/index";
+export { hueOf } from "./internal/palette";
 export * from "./internal/states";
+export type { TransferDirection, TransferHandler, TransferState } from "./internal/transfer";
 export * from "./motion/celebrate";
 export * from "./theme/applyTheme";
+export * from "./theme/chartColors";

package/dist/index.js

@@ -1,31 +1,41 @@
+"use client";
+
 import {
   Accordion,
   AppHeader,
   AppShell,
-  Avatar,
-  Badge,
   Banner,
   BottomNav,
   Breadcrumb,
   ButtonGroup,
   Card,
+  ChartFrame,
+  Chat,
   CodeBlock,
   ColorPresets,
   CommandMenu,
+  Composer,
+  ConfirmDialog,
   Crossfade,
   DEFAULT_DATEPICKER_PRESETS,
   DataTable,
   Datepicker,
+  DescriptionList,
   DigitInput,
   Dnd,
   Drawer,
   Dropdown,
   ExampleFrame,
+  Fieldset,
   FileUpload,
+  Gallery,
+  Gantt,
   Kanban,
   Kbd,
   LinkButton,
   LoginForm,
+  MediaViewer,
+  Message,
   Modal,
   NativeSelect,
   NotificationCard,
@@ -33,12 +43,11 @@ import {
   PageContent,
   PageToolbar,
   Pagination,
-  Popover,
   ProgressCircle,
   Radio,
   SegmentedControl,
+  Sheet,
   Sidebar,
-  Skeleton,
   Slider,
   SmartFilter,
   Sparkline,
@@ -49,37 +58,52 @@ import {
   TagSelect,
   Textarea,
   Timeline,
-  Tooltip,
   Typography,
+  VideoNote,
+  VoicePlayer,
   YEARLESS_YEAR,
   applyTheme,
   celebrate,
+  chartColors,
   datepickerPresets,
   formatDatepickerValue,
+  formatMessageDate,
+  formatMessageTime,
+  getWaveform,
+  groupMessages,
+  hueOf,
+  isSmartFilterRange,
   matchesSmartFilter,
   moveBefore,
   resolveSmartFilterValues,
   suspendTransitions,
   useNotifications,
-  useSidebar
-} from "./chunks/chunk-OAE4IQX2.js";
+  useSidebar,
+  useTokenValue,
+  useUploadQueue
+} from "./chunks/chunk-CUH6DJ57.js";
 import {
+  Avatar,
+  Badge,
   Button,
   COLOR_PRESETS,
   Checkbox,
   ColorSwatches,
-  ControlSizeProvider,
   Divider,
   EmptyPage,
   Hint,
   Icon,
   Input,
   Label,
+  Popover,
   ProgressBar,
   ScrollContainer,
   Select,
+  Skeleton,
   Spinner,
   Thumbnail,
+  Tooltip,
+  VisuallyHidden,
   controlSizes,
   createIcon,
   dataStates,
@@ -88,9 +112,12 @@ import {
   stepDown,
   textTones,
   tones,
-  useOptionalControlSize,
   variants
-} from "./chunks/chunk-6JTZOA5I.js";
+} from "./chunks/chunk-WDTSHOTD.js";
+import {
+  ControlSizeProvider,
+  useOptionalControlSize
+} from "./chunks/chunk-Q3BFRQHZ.js";
 export {
   Accordion,
   AppHeader,
@@ -104,16 +131,21 @@ export {
   ButtonGroup,
   COLOR_PRESETS,
   Card,
+  ChartFrame,
+  Chat,
   Checkbox,
   CodeBlock,
   ColorPresets,
   ColorSwatches,
   CommandMenu,
+  Composer,
+  ConfirmDialog,
   ControlSizeProvider,
   Crossfade,
   DEFAULT_DATEPICKER_PRESETS,
   DataTable,
   Datepicker,
+  DescriptionList,
   DigitInput,
   Divider,
   Dnd,
@@ -121,7 +153,10 @@ export {
   Dropdown,
   EmptyPage,
   ExampleFrame,
+  Fieldset,
   FileUpload,
+  Gallery,
+  Gantt,
   Hint,
   Icon,
   Input,
@@ -130,6 +165,8 @@ export {
   Label,
   LinkButton,
   LoginForm,
+  MediaViewer,
+  Message,
   Modal,
   NativeSelect,
   NotificationCard,
@@ -144,6 +181,7 @@ export {
   ScrollContainer,
   SegmentedControl,
   Select,
+  Sheet,
   Sidebar,
   Skeleton,
   Slider,
@@ -160,15 +198,25 @@ export {
   Timeline,
   Tooltip,
   Typography,
+  VideoNote,
+  VisuallyHidden,
+  VoicePlayer,
   YEARLESS_YEAR,
   applyTheme,
   celebrate,
+  chartColors,
   controlSizes,
   createIcon,
   dataStates,
   datepickerPresets,
   formatDatepickerValue,
+  formatMessageDate,
+  formatMessageTime,
   getPasswordStrength,
+  getWaveform,
+  groupMessages,
+  hueOf,
+  isSmartFilterRange,
   matchesSmartFilter,
   moveBefore,
   paletteColors,
@@ -180,5 +228,7 @@ export {
   useNotifications,
   useOptionalControlSize,
   useSidebar,
+  useTokenValue,
+  useUploadQueue,
   variants
 };

package/dist/internal/AnchorRectContext.d.ts

@@ -10,3 +10,12 @@ export type AnchorRectResolver = (anchor: HTMLElement, rect: AnchorRect) => Anch
 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;
+/**
+ * The box anchored layers of a region must stay inside (viewport px), or `null` for the viewport:
+ * a scroll region with sticky parts (the Gantt timeline under its sticky header and label column)
+ * keeps its tooltips off those parts. Read by `usePosition` as its collision boundary.
+ */
+export type FloatingBoundaryResolver = (anchor: HTMLElement) => Pick<AnchorRect, "top" | "left" | "right" | "bottom"> | null;
+export declare const FloatingBoundaryProvider: React.Provider<FloatingBoundaryResolver | null>;
+/** The boundary resolver of the nearest region that confines its layers, or `null`. */
+export declare function useFloatingBoundaryResolver(): FloatingBoundaryResolver | null;

package/dist/internal/ChoiceField.d.ts

@@ -1,6 +1,6 @@
 import type * as React from "react";
-import type { FieldIds } from "@/internal/FieldFrame";
-import type { ControlSize, DataState } from "@/internal/states";
+import { type FieldIds } from "./FieldFrame";
+import type { ControlSize, DataState } from "./states";
 /** Class of the visually hidden native input that sits on top of the visual control. */
 export declare const choiceInputClass: string;
 /**

package/dist/internal/ControlSizeContext.d.ts

@@ -1,5 +1,5 @@
 import * as React from "react";
-import type { ControlSize } from "@/internal/states";
+import type { ControlSize } from "./states";
 export type ControlSizeProviderProps = {
     value: ControlSize;
     children: React.ReactNode;

package/dist/internal/Disclosure.d.ts

@@ -0,0 +1,15 @@
+import type * as React from "react";
+export type DisclosureProps = React.HTMLAttributes<HTMLDivElement> & {
+    open: boolean;
+    /** Classes of the clip (a host that lets focus rings reach past it widens it). */
+    clipClassName?: string;
+    ref?: React.Ref<HTMLDivElement>;
+};
+/**
+ * A part that opens and closes in place: its height glides (`0fr ↔ 1fr`) while its content fades
+ * and slides on the same clock — one stroke both ways. Always mounted; closed, the content keeps its
+ * last state and leaves the accessibility tree once the close has played. The host sets the clock
+ * with `--disclosure-duration` / `--disclosure-ease` (see `disclosure.module.css`). An open one on
+ * its first render stands open: nothing plays on mount.
+ */
+export declare function Disclosure({ open, clipClassName, className, children, ...rest }: DisclosureProps): import("react/jsx-runtime").JSX.Element;

package/dist/internal/FieldAction.d.ts

@@ -0,0 +1,38 @@
+import * as React from "react";
+/**
+ * A button segment at a field's edge (Input, Textarea): full field height, the icon centred with the
+ * field padding on both sides, a hover wash over the whole segment, the touch hit area. The field
+ * hosts style it through `data-field-action`.
+ */
+export declare const fieldActionClass: string;
+export type FieldActionButtonProps = Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "aria-label" | "children"> & {
+    /** Accessible name and tooltip («Позвонить», «Открыть профиль»). */
+    label: string;
+    /** Renders the one child (an `<a href>`, a router link) with the segment's look and behaviour. */
+    asChild?: boolean;
+    /** The glyph, or with `asChild` the element that carries it. */
+    children: React.ReactNode;
+    ref?: React.Ref<HTMLButtonElement>;
+};
+/** A named icon action at the field's edge with a tooltip. */
+export declare function FieldActionButton({ label, asChild, className, disabled, type, children, ref, ...rest }: FieldActionButtonProps): import("react/jsx-runtime").JSX.Element;
+export type CopyState = "idle" | "copied" | "error";
+export type FieldCopyLabels = {
+    /** Name and tooltip of the copy button. */
+    copy: string;
+    /** Name, tooltip and announcement once the value is copied. */
+    copied: string;
+    /** Name, tooltip and announcement when the clipboard refuses. */
+    copyError: string;
+};
+export type FieldCopyButtonProps = Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "aria-label" | "children" | "type"> & {
+    /** Reads the text to copy at the moment of the press. */
+    getText: () => string;
+    labels: FieldCopyLabels;
+    ref?: React.Ref<HTMLButtonElement>;
+};
+/**
+ * Copies a field's value: the copy glyph morphs into a check (both stay mounted and cross-fade in
+ * place), the name and tooltip switch to `copied`, a polite live region repeats it.
+ */
+export declare function FieldCopyButton({ getText, labels, onClick, ...rest }: FieldCopyButtonProps): import("react/jsx-runtime").JSX.Element;

package/dist/internal/FieldCommit.d.ts

@@ -0,0 +1,46 @@
+import * as React from "react";
+/**
+ * Saves one field on its own (inline editing of a record card). Returns nothing for a sync save or
+ * a Promise: while it is pending the field shows a spinner and stays editable; a rejection puts the
+ * last committed value back (the owner shows why through `error` or a notification).
+ */
+export type FieldCommitHandler = (value: string) => void | Promise<void>;
+/** `idle` · `pending` (a Promise is running) · `saved` (a brief quiet confirmation). */
+export type FieldCommitState = "idle" | "pending" | "saved";
+type CommitControl = HTMLInputElement | HTMLTextAreaElement;
+/**
+ * Writes a value into a native control the way typing does, so React's `onChange` (and the owner's
+ * `onValueChange`) receive it whether the field is controlled or not.
+ */
+export declare function setControlValue(control: CommitControl, value: string): void;
+export type FieldCommit = {
+    state: FieldCommitState;
+    /** Commits the control's value when it differs from the last committed one. */
+    commit: () => void;
+    /** Puts the last committed value back; `true` when something changed. */
+    revert: () => boolean;
+    /** Takes the control's value as committed (on focus, unless a save is pending). */
+    sync: () => void;
+};
+/**
+ * The commit cycle of a field: the value at focus is the committed one; blur or the commit key
+ * saves a changed value; Escape reverts; a rejected save restores the committed value unless the
+ * person has typed on since. Unchanged values never fire. `onCommit` undefined → inert.
+ */
+export declare function useFieldCommit(controlRef: React.RefObject<CommitControl | null>, onCommit: FieldCommitHandler | undefined): FieldCommit;
+export type FieldCommitLabels = {
+    /** Read while a save is pending. */
+    saving: string;
+    /** Read once a save succeeds. */
+    saved: string;
+};
+/**
+ * The commit status at the field's edge: a spinner while saving, then a check that fades out. A
+ * polite live region says «saving» / «saved»; the glyphs are hidden from assistive tech.
+ */
+export declare function FieldCommitStatus({ state, labels, className, }: {
+    state: FieldCommitState;
+    labels: FieldCommitLabels;
+    className?: string;
+}): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/internal/FieldFrame.d.ts

@@ -1,5 +1,5 @@
 import * as React from "react";
-import type { ControlSize } from "@/internal/states";
+import type { ControlSize } from "./states";
 /** Field props shared by every framed field (the same contract as `Input.Root`). */
 export type FieldFrameProps = {
     label?: React.ReactNode;
@@ -48,6 +48,23 @@ export declare function useFieldFrame(explicitId: string | undefined, { label, h
     error?: React.ReactNode;
     invalid?: boolean;
 }, ariaDescribedBy?: string): FieldIds;
+/**
+ * `data-shake` of a field root: the control shakes once when the field turns invalid or its error
+ * message changes (foundation §7, rule 14) — never for an error it mounts with. The value
+ * alternates between `odd` and `even` so a new error restarts the keyframes.
+ */
+export declare function useErrorShake(invalid: boolean, error: React.ReactNode): "odd" | "even" | undefined;
+/**
+ * The error that has just been fixed, kept on screen while it fades out (`fast`, `exit`) so the
+ * message leaves as smoothly as it arrived; the hint takes the slot after it. `null` when nothing
+ * is leaving. Reduced motion drops it at once.
+ */
+export declare function useLeavingError(showError: boolean, error: React.ReactNode): {
+    node: React.ReactNode;
+    onExitEnd: (event: React.SyntheticEvent<Element>) => void;
+} | null;
+/** Class of the leaving error message (`useLeavingError`), for frames that render their own row. */
+export declare const leavingErrorClass: string;
 type FieldFrameRenderProps = Omit<FieldFrameProps, "focusRing"> & {
     size: ControlSize;
     ids: FieldIds;

package/dist/internal/HighlightMatch.d.ts

@@ -2,12 +2,14 @@ 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.
+ * `text` with its first match of `query` marked in accent (every match with `all`, as in a search
+ * through messages); 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 }: {
+export declare function HighlightMatch({ text, query, all, }: {
     text: string;
     query: string;
+    all?: boolean;
 }): 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/MorphText.d.ts

@@ -3,8 +3,9 @@ export type MorphTextProps = {
     className?: string;
 };
 /**
- * A label that changes in place (foundation §7 rule 8): the old letters leave upward, the new ones
- * come from below one short step apart, and the box glides between the two widths. At rest it is
+ * A label that changes in place (foundation §7 rule 8): the start and end both labels share stay
+ * still; between them the old letters leave upward, the new ones come from below one short step
+ * apart, and the changed part glides between the two widths. At rest it is
  * one plain text span; the letter layers exist only while a change plays. Still on the first
  * render, under reduced motion, and when only digits change (a counter or a percentage in a label
  * updates in place).

package/dist/internal/ProgressLegend.d.ts

@@ -0,0 +1,18 @@
+import { type ProgressSegment } from "./progressSegments";
+import type { ControlSize } from "./states";
+export type ProgressLegendProps = {
+    segments: ProgressSegment[];
+    /** 100% of a share (the resolved scale of the distribution). */
+    scale: number;
+    formatValue: (value: number) => string;
+    size: ControlSize;
+    id?: string;
+    className?: string;
+};
+export declare function ProgressLegend({ segments, scale, formatValue, size, id, className, }: ProgressLegendProps): import("react/jsx-runtime").JSX.Element | null;
+/** The legend while the distribution loads: one text line per expected row. */
+export declare function ProgressLegendSkeleton({ rows, size, className, }: {
+    rows: number;
+    size: ControlSize;
+    className?: string;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/internal/VisuallyHidden.d.ts

@@ -6,6 +6,10 @@ export type VisuallyHiddenProps = React.HTMLAttributes<HTMLSpanElement> & {
 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.
+ * Public as `VisuallyHidden` (docs in `src/components/visually-hidden/`); inside the kit it replaces
+ * the per-component `.srOnly` / `.visuallyHidden` CSS copies.
  */
 export declare function VisuallyHidden({ className, ...rest }: VisuallyHiddenProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace VisuallyHidden {
+    var displayName: string;
+}

package/dist/internal/attachmentTile.d.ts

@@ -0,0 +1,64 @@
+import * as React from "react";
+import type { UploadItem } from "../hooks/useUploadQueue";
+import styles from "./attachmentTile.module.css";
+export { styles as attachmentTileStyles };
+/** What a tile shows: a picture, a video's first frame, or a file placeholder. */
+export type AttachmentTileKind = "image" | "video" | "file";
+export type AttachmentTileProps = Omit<React.HTMLAttributes<HTMLElement>, "children" | "id" | "onKeyDown"> & {
+    /** The id of the item in its `Dnd.Sortable`. */
+    id: string;
+    kind: AttachmentTileKind;
+    /** The picture or the video (a URL or a local object URL); not used for a file. */
+    src?: string;
+    /** The name, at the start of the bottom band (one line, ellipsis). */
+    name?: string;
+    /** The full file name for the tooltip of a trimmed `name` (the format badge shows the extension). */
+    nameTitle?: string;
+    /** The size, at the end of the bottom band; a video without it shows its duration. */
+    meta?: string;
+    /**
+     * The pill at the top start — the format (JPG, PDF) or a word such as «Обложка»; decorative, the
+     * name says it. On a picture or a video it stands on the media shade; a file passes a kit Badge.
+     */
+    badge?: React.ReactNode;
+    /**
+     * The upload of the item: a disk in the middle with the progress ring along its edge
+     * (`TransferOverlay`); the content dims under it until the upload is done.
+     */
+    upload?: UploadItem;
+    /** The upload state in words («Загрузка 45%»): the ring's name and the reason of a failure. */
+    uploadState?: string | null;
+    /** The name of the disk while the upload is in flight: pressing it calls `onRemove`. */
+    cancelLabel?: string;
+    retryLabel?: string;
+    onRetry?: () => void;
+    /**
+     * The delete button (and Delete / Backspace on the tile); without it there is none. While the
+     * upload is in flight the disk in the middle is the delete (a cancel) and the corner one is not drawn.
+     */
+    onRemove?: () => void;
+    removeLabel?: string;
+    /** A change of this tile is being saved: dimmed, its delete button spins, it does not drag. */
+    pending?: boolean;
+    /** Arrived after the first render: it enters (`enterMotion`). */
+    arrived?: boolean;
+    /**
+     * Ids of tiles their delete button took out: such a tile closes up in place (`leaveInPlace`)
+     * when it unmounts. Give it only to a row of tiles (a strip).
+     */
+    leaving?: React.RefObject<Set<string>>;
+    ref?: React.Ref<HTMLElement>;
+};
+/**
+ * One tile of a set of attachments, rendered as a `Dnd.SortableItem` (it drags, Alt + arrows move
+ * it). Every kind has the same slots: the pill at the top start, the remove button at the top end, a
+ * band across the bottom (the name, then the size or a video's duration) and in the middle a
+ * picture, a video's first frame (lazy) with its play mark, or the sheet of a file; the upload disk
+ * with its progress ring stands over the middle. Shared by FileUpload tiles and the Composer tray.
+ */
+export declare function AttachmentTile({ id, kind, src, name, nameTitle, meta, badge, upload, uploadState, cancelLabel, retryLabel, onRetry, onRemove, removeLabel, pending, arrived, leaving, className, ref, ...rest }: AttachmentTileProps): import("react/jsx-runtime").JSX.Element;
+/** A row of tiles scrolls sideways — its hidden edges fade, a scroll rests on a tile, a vertical
+ * wheel moves it — with the bar hidden. */
+export declare function AttachmentStripScroller({ children }: {
+    children: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/internal/attachmentTile.module.css.d.ts

@@ -0,0 +1,2 @@
+declare const styles: Readonly<Record<string, string>>;
+export default styles;

package/dist/internal/disabledContext.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+export declare function DisabledProvider({ disabled, children, }: {
+    disabled: boolean;
+    children: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+/** The control's own `disabled` or a disabled `Fieldset` around it. */
+export declare function useInheritedDisabled(own?: boolean): boolean;

package/dist/internal/edgeAutoScroll.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Edge auto-scroll: the one mechanism behind every gesture that scrolls a ScrollContainer (or the
+ * page) while the pointer is held near its edge — a Dnd drag, a Gantt bar moved or drawn along the
+ * time axis, a drag that paints a selection over DataTable rows or chat messages. Within
+ * `EDGE_ZONE_PX` of an edge the scroller moves toward it, faster the closer the pointer is, up to
+ * `MAX_SPEED_PX_PER_MS` on the edge itself. Speed is per millisecond, so a 120 Hz display scrolls
+ * as fast as a 60 Hz one. A region that cannot scroll (`data-fits`, ScrollContainer `lock`: both
+ * `overflow: hidden`) is never moved.
+ */
+/** Distance from an edge where the scroller starts to move (`--prime-space-16`). */
+export declare const EDGE_ZONE_PX = 64;
+/** Top speed, on the edge itself. */
+export declare const MAX_SPEED_PX_PER_MS = 1.1;
+export type EdgePoint = {
+    x: number;
+    y: number;
+};
+/** Speed toward an edge `distance` px away from the pointer: 0 outside the zone. */
+export declare function edgeSpeed(distance: number, zone?: number): number;
+/** Scrollable boxes between `element` and the root, innermost first: a list that can still scroll wins over the page. */
+export declare function scrollableAncestors(element: Element | null): HTMLElement[];
+/**
+ * One frame of edge auto-scroll: scrolls the innermost of `containers` that wants to move and still
+ * can. `axes` limits the axes a gesture scrolls (a list's drag only up and down). Returns whether
+ * anything moved, so the gesture re-reads what is under the pointer.
+ */
+export declare function autoScrollStep(containers: HTMLElement[], point: EdgePoint, elapsedMs: number, axes?: {
+    x: boolean;
+    y: boolean;
+}): boolean;

package/dist/internal/fileFormat.d.ts

@@ -0,0 +1,5 @@
+import type { PaletteColor } from "./states";
+/** The extension of a file name, lower case; `""` without one. */
+export declare function extensionOf(name: string): string;
+/** The hue of a format badge (FileUpload, `Message.File`); `gray` for anything else. */
+export declare function formatColor(format: string): PaletteColor;

package/dist/internal/fileName.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Splits a file name at its final extension: «отчёт.final.pdf» → `{ base: "отчёт.final", ext: "pdf" }`.
+ * A name without an extension or a dotfile («.env») stays whole, with `ext` `""`. `ext` is lower
+ * case; the one rule behind a format badge and the name trimmed beside it.
+ */
+export declare function splitFileName(name: string): {
+    base: string;
+    ext: string;
+};

package/dist/internal/fileSize.d.ts

@@ -0,0 +1,2 @@
+/** «820 КБ», «1,2 МБ»: Russian digits, one decimal from a megabyte on. */
+export declare function formatFileSize(bytes: number): string;

package/dist/internal/formatClock.d.ts

@@ -0,0 +1,2 @@
+/** A media position or length: `m:ss`, `h:mm:ss` from an hour on. */
+export declare function formatClock(seconds: number): string;

package/dist/internal/glyphSwap.d.ts

@@ -0,0 +1,19 @@
+import * as React from "react";
+/**
+ * What a glyph is: the element type with its `name` prop (an `<Icon name>`) and its key. Text and
+ * numbers are one glyph whose words change in place (a percent ticking up never cross-fades).
+ */
+export declare function glyphKey(node: React.ReactNode): string;
+/**
+ * A glyph that changes cross-fades in place (foundation §7 rule 7): the outgoing one shrinks to 0.6
+ * and fades, the incoming one grows from 0.6 (`fast` · standard) and plays its own gesture once
+ * (`data-play`, `icons/glyphMotion`). Both share one grid cell, so the box keeps the glyph's size.
+ * A change of the same glyph (new words, new props) updates in place. Reduced motion swaps at once
+ * and plays no gesture. Used by `Button.Icon` and the centre of ProgressCircle.
+ */
+export declare function GlyphSwap({ children, className, layerClassName, }: {
+    children?: React.ReactNode;
+    className?: string;
+    /** A class on every glyph layer, for the host to style the glyph inside (`.glyph > svg`). */
+    layerClassName?: string;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/internal/iconBox.module.css.d.ts

@@ -0,0 +1,2 @@
+declare const styles: Readonly<Record<string, string>>;
+export default styles;

package/dist/internal/imageSlot.d.ts

@@ -1,5 +1,5 @@
 import * as React from "react";
-import { type ImageStatus } from "@/hooks/useImageStatus";
+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. */
@@ -24,6 +24,8 @@ export declare function createImageSlot(name: string, classNames: {
     }) => React.ReactElement;
     /** Throws outside the root (for other parts that must sit inside it). */
     useImageSlot: () => ImageStatus;
+    /** The root's status setter, for another media part (a video) that reports its own load. */
+    useReportStatus: () => (status: ImageStatus) => void;
     Image: (props: ImageSlotImageProps) => React.ReactElement;
     Fallback: (props: ImageSlotFallbackProps) => React.ReactElement;
 };

package/dist/internal/leaveInPlace.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The exit of a part the owner removed (a chip, a queue row): React drops the node at once, so a
+ * copy of it stays in the flow at the same spot and closes up — it fades, settles a little smaller
+ * and shrinks to nothing along `axis`, taking its gap with it, so the neighbours glide into the
+ * place instead of jumping. Call it from a layout-effect cleanup, while the node is still drawn;
+ * the copy is placed after the commit, and only if the node really left (Strict Mode replays an
+ * unmount on a node that stays). Inert and hidden from assistive tech; gone when the motion ends.
+ */
+export declare function leaveInPlace(node: HTMLElement, axis: "inline" | "block"): void;