sonahang-ui 1.0.4 → 1.0.6

package/README.md

@@ -82,12 +82,14 @@ Actions: `Button`, `Dropdown`, `SegmentedControl`
 
 Forms: `Input`, `InputOtp`, `Textarea`, `Select`, `Checkbox`, `Radio`, `Switch`, `RangeSlider`, `MinMaxSlider`, `FileDrop`
 
-Feedback: `Alert`, `Spinner`, `ProgressBar`, `Tooltip`, `Dialog`, `Drawer`
+Feedback: `Alert`, `Toast`, `Spinner`, `ProgressBar`, `Tooltip`, `Dialog`, `Drawer`
 
-Navigation: `Tabs`, `Breadcrumb`, `Pagination`, `Stepper`, `Accordion`
+Navigation: `Tabs`, `Breadcrumb`, `Pagination`, `Stepper`, `Accordion`, `Collapsible`
 
 Data display: `Avatar`, `Tag`, `Chip`, `Carousel`
 
+Media: `AudioPlayer`, `AudioPlaylist`
+
 Every component, every prop, and every state is documented with live controls
 in [Storybook](https://github.com/sonangrai/sonahang-ui) — that's the real
 reference, this file is the summary.

package/dist/components/AudioPlayer/AudioPlayer.d.ts

@@ -0,0 +1,48 @@
+import type { AudioHTMLAttributes, ReactNode, Ref } from "react";
+import "./AudioPlayer.css";
+export type AudioPlayerLabels = {
+    play?: string;
+    pause?: string;
+    previous?: string;
+    next?: string;
+    seek?: string;
+    mute?: string;
+    unmute?: string;
+    volume?: string;
+    /** Shown in place of the controls when the source fails to load. */
+    error?: string;
+};
+export type AudioPlayerProps = {
+    /** URL of the audio file. */
+    src: string;
+    /** Track name, shown above the controls. Also names the player region. */
+    title?: ReactNode;
+    /** Secondary line under the title — an artist, show, or episode. */
+    subtitle?: ReactNode;
+    /** Hides the volume controls, e.g. where the OS volume is all that matters. */
+    hideVolume?: boolean;
+    /** Initial volume, 0–1. Defaults to 1. */
+    defaultVolume?: number;
+    /** Accessible names for the controls — override to localise. */
+    labels?: AudioPlayerLabels;
+    /** Renders a Previous button beside Play. Omit for a single track. */
+    onPrevious?: () => void;
+    /** Renders a Next button beside Play. Omit for a single track. */
+    onNext?: () => void;
+    /** Extra controls, placed in the control row before the volume. */
+    actions?: ReactNode;
+    /** Class for the wrapper element. */
+    className?: string;
+    /** Ref to the underlying `<audio>` element, for imperative control. */
+    ref?: Ref<HTMLAudioElement>;
+} & Omit<AudioHTMLAttributes<HTMLAudioElement>, "src" | "title" | "className" | "controls">;
+/**
+ * Custom controls over a native `<audio>` element.
+ *
+ * The element stays the source of truth: playing, position, and volume are
+ * read back from its media events rather than tracked alongside it, so the UI
+ * can't drift from what's actually playing — even when something else drives
+ * the element through `ref`. The seek and volume bars are `RangeSlider`s, so
+ * arrow keys, Home/End, and screen-reader announcements come from the platform.
+ */
+export declare function AudioPlayer({ src, title, subtitle, hideVolume, defaultVolume, labels, onPrevious, onNext, actions, className, ref, onPlay, onPause, onEnded, onTimeUpdate, onLoadedMetadata, onDurationChange, onVolumeChange, onError, ...props }: AudioPlayerProps): import("react").JSX.Element;

package/dist/components/AudioPlayer/AudioPlaylist.d.ts

@@ -0,0 +1,59 @@
+import type { ReactNode, Ref } from "react";
+import type { AudioPlayerLabels } from "./AudioPlayer";
+import type { PlayMode } from "./playlistOrder";
+import "./AudioPlaylist.css";
+export type AudioTrack = {
+    src: string;
+    title: ReactNode;
+    subtitle?: ReactNode;
+    /**
+     * Length in seconds, shown in the track list. Optional — the player learns
+     * it once a track loads, but the list can't without loading every file.
+     */
+    duration?: number;
+    /** Stable key. Falls back to the index and `src`. */
+    id?: string;
+};
+export type AudioPlaylistLabels = AudioPlayerLabels & {
+    /** Prefix for the play-mode button's name, e.g. "Play mode: Shuffle". */
+    playMode?: string;
+    /** Names of the individual modes. */
+    modes?: Partial<Record<PlayMode, string>>;
+    /** Name of the track list. */
+    tracks?: string;
+};
+export type AudioPlaylistProps = {
+    tracks: readonly AudioTrack[];
+    /** Names the playlist as a whole. Defaults to "Playlist". */
+    label?: string;
+    /** Current track — makes the playlist's position controlled. */
+    trackIndex?: number;
+    /** Initial track when uncontrolled. Defaults to the first. */
+    defaultTrackIndex?: number;
+    /** Fired with the index of the track being moved to. */
+    onTrackChange?: (index: number) => void;
+    /** Current play mode — makes it controlled. */
+    playMode?: PlayMode;
+    /** Initial play mode when uncontrolled. Defaults to `sequential`. */
+    defaultPlayMode?: PlayMode;
+    /** Fired with the next mode when the play-mode button is pressed. */
+    onPlayModeChange?: (mode: PlayMode) => void;
+    /** Hides the track list, leaving the player and its skip buttons. */
+    hideTrackList?: boolean;
+    hideVolume?: boolean;
+    /** Initial volume, 0–1. Carries across tracks. */
+    defaultVolume?: number;
+    labels?: AudioPlaylistLabels;
+    className?: string;
+    /** Ref to the underlying `<audio>` element. */
+    ref?: Ref<HTMLAudioElement>;
+};
+/**
+ * An `AudioPlayer` that works through a list of tracks, with Previous/Next,
+ * a play-mode button cycling through in order, repeat all, repeat one and
+ * shuffle, and a track list to jump around in.
+ *
+ * Volume and mute carry from track to track — it's one `<audio>` element
+ * whose source changes, not a player per track.
+ */
+export declare function AudioPlaylist({ tracks, label, trackIndex, defaultTrackIndex, onTrackChange, playMode, defaultPlayMode, onPlayModeChange, hideTrackList, hideVolume, defaultVolume, labels, className, ref, }: AudioPlaylistProps): import("react").JSX.Element | null;

package/dist/components/AudioPlayer/formatAudioTime.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Formats a playback position as `m:ss`, or `h:mm:ss` once it passes an hour.
+ *
+ * Anything that isn't a finite, non-negative number comes back as `--:--`.
+ * That covers the `NaN` a media element reports before its metadata loads and
+ * the `Infinity` it reports for a live stream — neither has a length to show.
+ */
+export declare function formatAudioTime(seconds: number): string;

package/dist/components/AudioPlayer/index.d.ts

@@ -0,0 +1,7 @@
+export { AudioPlayer } from "./AudioPlayer";
+export type { AudioPlayerProps, AudioPlayerLabels } from "./AudioPlayer";
+export { AudioPlaylist } from "./AudioPlaylist";
+export type { AudioPlaylistProps, AudioPlaylistLabels, AudioTrack } from "./AudioPlaylist";
+export { formatAudioTime } from "./formatAudioTime";
+export { playModes, getNextTrack, getPreviousTrack, createShuffleOrder, } from "./playlistOrder";
+export type { PlayMode, PlaylistAdvance, PlaylistPosition, PlaylistStep, } from "./playlistOrder";

package/dist/components/AudioPlayer/playlistOrder.d.ts

@@ -0,0 +1,45 @@
+export declare const playModes: readonly ["sequential", "repeat-all", "repeat-one", "shuffle"];
+export type PlayMode = (typeof playModes)[number];
+/** What moved the playlist on: the track finishing, or the Next button. */
+export type PlaylistAdvance = "ended" | "next";
+export type PlaylistPosition = {
+    /** Index of the current track. */
+    index: number;
+    /** Number of tracks in the playlist. */
+    count: number;
+    mode: PlayMode;
+    /**
+     * Shuffled play order, as track indices. Only read in `shuffle` mode; an
+     * order that no longer fits the playlist is replaced.
+     */
+    order?: readonly number[];
+    /** Source of randomness, for deterministic tests. Defaults to `Math.random`. */
+    random?: () => number;
+};
+export type PlaylistStep = {
+    /** Track to move to, or `null` to stop where we are. */
+    index: number | null;
+    /** The shuffle order to keep for the next step. */
+    order: number[];
+};
+/**
+ * A random permutation of `0..count-1` that starts with `first`, so turning
+ * shuffle on never jumps away from the track that's playing.
+ */
+export declare function createShuffleOrder(count: number, first: number, random?: () => number): number[];
+/**
+ * Where the playlist goes after the current track.
+ *
+ * - `sequential` stops after the last track when it ends; Next wraps.
+ * - `repeat-all` wraps either way.
+ * - `repeat-one` replays the track when it ends; Next still moves on, since
+ *   pressing it is asking for a different track.
+ * - `shuffle` walks a shuffled order and reshuffles once every track has
+ *   played, never starting the new round on the track that just finished.
+ */
+export declare function getNextTrack(position: PlaylistPosition, advance: PlaylistAdvance): PlaylistStep;
+/**
+ * Where Previous goes. In `shuffle` it retraces the shuffled order and stays
+ * on the first track of the round; otherwise it steps back and wraps.
+ */
+export declare function getPreviousTrack(position: PlaylistPosition): PlaylistStep;

package/dist/components/Collapsible/Collapsible.d.ts

@@ -0,0 +1,36 @@
+import type { HTMLAttributes, ReactNode } from "react";
+import "./Collapsible.css";
+export type CollapsibleProps = {
+    /** `CollapsibleItem`s — which may themselves contain `CollapsibleItem`s. */
+    children?: ReactNode;
+    /**
+     * Values of the open items, at any level — makes the component controlled.
+     * Values must therefore be unique across the whole tree.
+     */
+    value?: string[];
+    /** Initially open items when uncontrolled. */
+    defaultValue?: string[];
+    /** Fired with the full list of open items. */
+    onChange?: (value: string[]) => void;
+    /**
+     * Replaces the default chevron on open items. Applies to every level;
+     * an item's own `expandedIcon` wins over this.
+     */
+    expandedIcon?: ReactNode;
+    /**
+     * Replaces the default chevron on closed items. Applies to every level;
+     * an item's own `collapsedIcon` wins over this.
+     */
+    collapsedIcon?: ReactNode;
+    className?: string;
+} & Omit<HTMLAttributes<HTMLDivElement>, "className" | "onChange">;
+/**
+ * Multi-level set of collapsible sections — nav trees, file trees, nested
+ * settings.
+ *
+ * Nest `CollapsibleItem`s inside each other to add levels; depth and
+ * indentation are worked out from the nesting. Every item opens and closes
+ * independently, and closing a parent keeps its children's state, so they
+ * reappear as they were.
+ */
+export declare function Collapsible({ children, value, defaultValue, onChange, expandedIcon, collapsedIcon, className, ...props }: CollapsibleProps): import("react").JSX.Element;

package/dist/components/Collapsible/CollapsibleItem.d.ts

@@ -0,0 +1,24 @@
+import type { HTMLAttributes, ReactNode } from "react";
+import "./Collapsible.css";
+export type CollapsibleItemProps = {
+    /** Identifies this item in the open list. Unique across the whole tree. */
+    value: string;
+    /** Content of the row. */
+    title: ReactNode;
+    /** Leading icon, shown between the chevron and the title. Any level. */
+    icon?: ReactNode;
+    /**
+     * Revealed when open — nested `CollapsibleItem`s for another level, or any
+     * other content. With no children the item is a plain, non-toggling row.
+     */
+    children?: ReactNode;
+    /** Replaces the chevron on this item while open. */
+    expandedIcon?: ReactNode;
+    /** Replaces the chevron on this item while closed. */
+    collapsedIcon?: ReactNode;
+    /** Prevents the item being opened or closed. */
+    disabled?: boolean;
+    className?: string;
+} & Omit<HTMLAttributes<HTMLDivElement>, "className" | "title">;
+/** One row of a `Collapsible`, optionally containing a further level. */
+export declare function CollapsibleItem({ value, title, icon, children, expandedIcon, collapsedIcon, disabled, className, style, ...props }: CollapsibleItemProps): import("react").JSX.Element;

package/dist/components/Collapsible/collapsible.context.d.ts

@@ -0,0 +1,23 @@
+import type { ReactNode } from "react";
+export type CollapsibleContextValue = {
+    /** Values of every open item, across all levels. */
+    value: string[];
+    /** Opens or closes one item. */
+    toggle: (value: string) => void;
+    baseId: string;
+    /** Indicator shown on open items, when overridden. */
+    expandedIcon?: ReactNode;
+    /** Indicator shown on closed items, when overridden. */
+    collapsedIcon?: ReactNode;
+};
+export declare const CollapsibleContext: import("react").Context<CollapsibleContextValue | undefined>;
+/**
+ * Nesting depth of the items currently rendering. Each open panel provides
+ * `depth + 1` to whatever it contains, so items don't need a `level` prop.
+ */
+export declare const CollapsibleDepthContext: import("react").Context<number>;
+/** Reads the surrounding `Collapsible`, failing loudly rather than silently. */
+export declare function useCollapsibleContext(component: string): CollapsibleContextValue;
+/** Ids are derived rather than registered, so trigger and panel always agree. */
+export declare const triggerId: (baseId: string, value: string) => string;
+export declare const panelId: (baseId: string, value: string) => string;

package/dist/components/Collapsible/index.d.ts

@@ -0,0 +1,4 @@
+export { Collapsible } from "./Collapsible";
+export type { CollapsibleProps } from "./Collapsible";
+export { CollapsibleItem } from "./CollapsibleItem";
+export type { CollapsibleItemProps } from "./CollapsibleItem";

package/dist/components/Toast/Toast.d.ts

@@ -0,0 +1,32 @@
+import type { HTMLAttributes, ReactNode } from "react";
+import type { ToastAction } from "./toast.store";
+import type { ToastVariant } from "./toast.tokens";
+import "./Toast.css";
+export type ToastProps = {
+    /** Defaults to `default`, which has no icon. `loading` shows a spinner. */
+    variant?: ToastVariant;
+    title: ReactNode;
+    /** Secondary line under the title. */
+    description?: ReactNode;
+    /** Replaces the variant's icon, or hides it with `false`. */
+    icon?: ReactNode | false;
+    /** A single button, e.g. "Undo". */
+    action?: ToastAction;
+    /** Renders a close button and is called when it's activated. */
+    onDismiss?: () => void;
+    /** Accessible name for the close button. Defaults to "Dismiss". */
+    dismissLabel?: string;
+    /**
+     * Overrides how assistive tech announces this. Defaults to `alert` for
+     * warning/error and `status` otherwise.
+     */
+    role?: "alert" | "status" | "none";
+} & Omit<HTMLAttributes<HTMLDivElement>, "title" | "role">;
+/**
+ * A single notification card.
+ *
+ * Usually you won't render this yourself — call `toast()` and let
+ * `<Toaster />` handle stacking, timing and dismissal. It's exported for
+ * custom layouts and for documentation.
+ */
+export declare function Toast({ variant, title, description, icon, action, onDismiss, dismissLabel, role, className, ...props }: ToastProps): import("react").JSX.Element;

package/dist/components/Toast/Toaster.d.ts

@@ -0,0 +1,42 @@
+import type { ToastPosition } from "./toast.tokens";
+import "./Toast.css";
+export type ToasterProps = {
+    /** Corner or edge the stack sits in. Defaults to `bottom-right`. */
+    position?: ToastPosition;
+    /** Default time on screen in ms, when a toast doesn't set its own. Defaults to 5000. */
+    duration?: number;
+    /**
+     * Most toasts shown at once. When another arrives, the oldest closes to
+     * make room. Defaults to 3.
+     */
+    max?: number;
+    /** Default for whether toasts show a close button. Defaults to true. */
+    closeButton?: boolean;
+    /** Accessible name of the notification region. Defaults to "Notifications". */
+    label?: string;
+    /** Accessible name of each close button. Defaults to "Dismiss". */
+    dismissLabel?: string;
+    /**
+     * Where to render. `true` (default) portals to `document.body`, an element
+     * portals there, `false` renders in place.
+     *
+     * While a modal `Dialog` or `Drawer` is open, toasts move inside it
+     * regardless — everything outside a modal is inert, so they'd otherwise be
+     * unclickable.
+     */
+    portal?: boolean | HTMLElement;
+    className?: string;
+};
+/**
+ * Renders the toasts raised with `toast()`. Mount one, once, near the root
+ * of the app — no provider needed.
+ *
+ * Timers pause while the pointer is over the stack, while focus is inside
+ * it, and while the tab is hidden, so nothing disappears mid-read.
+ * Escape closes the focused toast.
+ *
+ * Toasts stay on top of, and usable over, an open modal `Dialog` or `Drawer`:
+ * the stack is a popover, so it's in the top layer, and it moves into the
+ * topmost modal while one is open, so it isn't made inert.
+ */
+export declare function Toaster({ position, duration, max, closeButton, label, dismissLabel, portal, className, }: ToasterProps): import("react").ReactNode;

package/dist/components/Toast/index.d.ts

@@ -0,0 +1,8 @@
+export { Toast } from "./Toast";
+export type { ToastProps } from "./Toast";
+export { Toaster } from "./Toaster";
+export type { ToasterProps } from "./Toaster";
+export { toast } from "./toast.store";
+export type { ToastAction, ToastFunction, ToastOptions, ToastPromiseContent, ToastPromiseMessages, } from "./toast.store";
+export { toastVariants, toastPositions } from "./toast.tokens";
+export type { ToastVariant, ToastPosition } from "./toast.tokens";

package/dist/components/Toast/toast.store.d.ts

@@ -0,0 +1,94 @@
+import type { MouseEvent, ReactNode } from "react";
+import type { ToastVariant } from "./toast.tokens";
+export type ToastAction = {
+    label: ReactNode;
+    /** Called on click. The toast closes afterwards unless you call `event.preventDefault()`. */
+    onClick: (event: MouseEvent<HTMLButtonElement>) => void;
+};
+export type ToastOptions = {
+    /**
+     * Reuse an id to replace a toast in place — e.g. turn "Uploading…" into
+     * "Uploaded" — instead of stacking a second one. Its timer restarts.
+     */
+    id?: string;
+    variant?: ToastVariant;
+    /** Secondary line under the title. */
+    description?: ReactNode;
+    /**
+     * Milliseconds before it closes on its own. `Infinity` keeps it until
+     * dismissed. Defaults to the `Toaster`'s `duration`.
+     */
+    duration?: number;
+    /** A single button, e.g. "Undo". */
+    action?: ToastAction;
+    /** Replaces the variant's icon, or hides it with `false`. */
+    icon?: ReactNode | false;
+    /** Whether to show the close button. Defaults to the `Toaster`'s `closeButton`. */
+    dismissible?: boolean;
+    /** Called once the toast has closed, however that happened. */
+    onDismiss?: () => void;
+};
+export type ToastRecord = Omit<ToastOptions, "id"> & {
+    id: string;
+    title: ReactNode;
+    variant: ToastVariant;
+    /** Bumped on every update so the toast's timer knows to restart. */
+    version: number;
+    /** Playing its exit animation; removed from the store shortly after. */
+    closing: boolean;
+};
+/** Long enough for the exit animation in Toast.css to finish. */
+export declare const EXIT_DURATION_MS = 200;
+type Listener = () => void;
+export declare const toastStore: {
+    subscribe(listener: Listener): () => void;
+    getSnapshot: () => ToastRecord[];
+    /** Nothing is queued on the server, and this must be a stable reference. */
+    getServerSnapshot: () => ToastRecord[];
+};
+type VariantShortcut = (title: ReactNode, options?: Omit<ToastOptions, "variant">) => string;
+/** A result message: just a title, or a title with any other toast options. */
+export type ToastPromiseContent = ReactNode | ({
+    title: ReactNode;
+} & Omit<ToastOptions, "id" | "variant">);
+export type ToastPromiseMessages<T> = {
+    /** Shown while pending. Stays up until the promise settles. */
+    loading: ReactNode;
+    /** Shown on resolve. A function receives the resolved value. */
+    success: ToastPromiseContent | ((value: T) => ToastPromiseContent);
+    /**
+     * Shown on reject. A function receives the rejection reason. Leave it out
+     * and the loading toast just closes.
+     */
+    error?: ToastPromiseContent | ((reason: unknown) => ToastPromiseContent);
+};
+export type ToastFunction = {
+    /** Shows a toast and returns its id. */
+    (title: ReactNode, options?: ToastOptions): string;
+    success: VariantShortcut;
+    info: VariantShortcut;
+    warning: VariantShortcut;
+    error: VariantShortcut;
+    /**
+     * Shows a loading toast that turns into success or error when `promise`
+     * settles. Returns the same promise, so it can be awaited or chained —
+     * pass `options.id` to address the toast afterwards.
+     */
+    promise: <T>(promise: Promise<T> | (() => Promise<T>), messages: ToastPromiseMessages<T>, options?: Omit<ToastOptions, "variant">) => Promise<T>;
+    /** Closes one toast, or every toast when called without an id. */
+    dismiss: (id?: string) => void;
+};
+/**
+ * Shows a toast in whichever `<Toaster />` is mounted.
+ *
+ * ```ts
+ * toast("Draft saved");
+ * toast.success("Uploaded", { description: "report.pdf" });
+ * const id = toast("Uploading…", { duration: Infinity });
+ * toast.success("Uploaded", { id });
+ * ```
+ */
+export declare const toast: ToastFunction;
+/** Clears everything immediately. For tests — not exported from the package. */
+export declare function resetToastStore(): void;
+export {};

package/dist/components/Toast/toast.tokens.d.ts

@@ -0,0 +1,4 @@
+export declare const toastVariants: readonly ["default", "success", "info", "warning", "error", "loading"];
+export type ToastVariant = (typeof toastVariants)[number];
+export declare const toastPositions: readonly ["top-left", "top-center", "top-right", "bottom-left", "bottom-center", "bottom-right"];
+export type ToastPosition = (typeof toastPositions)[number];

package/dist/index.d.ts

@@ -48,6 +48,8 @@ export { Pagination, getPaginationRange } from './components/Pagination';
 export type { PaginationProps, PaginationItem, PaginationRangeOptions, } from './components/Pagination';
 export { Accordion, AccordionItem } from './components/Accordion';
 export type { AccordionProps, AccordionItemProps, AccordionType, AccordionHeadingLevel, } from './components/Accordion';
+export { Collapsible, CollapsibleItem } from './components/Collapsible';
+export type { CollapsibleProps, CollapsibleItemProps } from './components/Collapsible';
 export { Stepper, Step } from './components/Stepper';
 export type { StepperProps, StepProps, StepperOrientation, StepStatus } from './components/Stepper';
 export { Breadcrumb, BreadcrumbItem } from './components/Breadcrumb';
@@ -64,6 +66,8 @@ export { ProgressBar, progressBarSizes } from './components/ProgressBar';
 export type { ProgressBarProps, ProgressBarSize } from './components/ProgressBar';
 export { Alert, alertVariants } from './components/Alert';
 export type { AlertProps, AlertVariant } from './components/Alert';
+export { Toast, Toaster, toast, toastVariants, toastPositions } from './components/Toast';
+export type { ToastProps, ToasterProps, ToastAction, ToastFunction, ToastOptions, ToastPromiseContent, ToastPromiseMessages, ToastVariant, ToastPosition, } from './components/Toast';
 export { FileDrop, isFileAccepted, formatFileSize } from './components/FileDrop';
 export type { FileDropProps } from './components/FileDrop';
 export { RangeSlider } from './components/RangeSlider';
@@ -74,6 +78,8 @@ export { Switch, SwitchGroup } from './components/Switch';
 export type { SwitchProps, SwitchGroupProps } from './components/Switch';
 export { SegmentedControl } from './components/SegmentedControl';
 export type { SegmentedControlProps, SegmentedControlOption, } from './components/SegmentedControl';
+export { AudioPlayer, AudioPlaylist, formatAudioTime, playModes, getNextTrack, getPreviousTrack, createShuffleOrder, } from './components/AudioPlayer';
+export type { AudioPlayerProps, AudioPlayerLabels, AudioPlaylistProps, AudioPlaylistLabels, AudioTrack, PlayMode, PlaylistAdvance, PlaylistPosition, PlaylistStep, } from './components/AudioPlayer';
 /**
  * Design tokens. The stylesheet already defines every color as a CSS var
  * (`--color-accent-600`, `--color-bg-surface`, …) — these are the same

package/dist/internal/statusIcons.d.ts

@@ -0,0 +1,10 @@
+import type { ReactNode } from "react";
+/**
+ * Status icons and the dismiss glyph shared by Alert and Toast, so the two
+ * always tell variants apart the same way.
+ *
+ * Not part of the public API.
+ */
+export type StatusVariant = "success" | "info" | "warning" | "error";
+export declare const statusIcons: Record<StatusVariant, ReactNode>;
+export declare const closeIcon: import("react").JSX.Element;

package/dist/internal/useTopModalDialog.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The topmost open modal `<dialog>`, or null.
+ *
+ * Anything outside a modal dialog is inert while it's open — not just
+ * covered, but unclickable and unfocusable — so UI that must stay usable on
+ * top of one (toasts) has to render inside it. Watching the DOM, rather than
+ * asking Dialog and Drawer to report in, also catches modals that aren't ours.
+ *
+ * Not part of the public API.
+ */
+export declare function useTopModalDialog(): HTMLDialogElement | null;