@ahrowe/ui 0.35.0 → 0.36.0

package/dist/cjs-types/common/timer/timer.chime.d.ts

@@ -0,0 +1 @@
+export declare const DEFAULT_CHIME_DATA_URI = "data:audio/wav;base64,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";

package/dist/cjs-types/common/timer/timer.d.ts

@@ -0,0 +1,3 @@
+import { TimerProps } from './timer.types.js';
+declare function Timer(props: TimerProps): import("react").JSX.Element;
+export default Timer;

package/dist/cjs-types/common/timer/timer.types.d.ts

@@ -0,0 +1,110 @@
+import { CSSProperties, ReactNode, Ref } from 'react';
+import { SlotClassNames, SlotStyles, HtmlProps } from '../types/slots.types.js';
+export type TimerSlots = 'root' | 'ringWrapper' | 'ringSvg' | 'ringTrack' | 'ringProgress' | 'ripples' | 'ripple' | 'display' | 'time' | 'label' | 'controls' | 'addButton' | 'removeButton' | 'pauseButton' | 'cancelButton';
+export type TimerStatus = 'idle' | 'running' | 'paused' | 'completed' | 'cancelled';
+export interface TimerHandle {
+    /** Starts (or restarts, if idle/completed/cancelled) the countdown from its current duration. */
+    start: () => void;
+    /** Pauses a running timer. No-op if not running. */
+    pause: () => void;
+    /** Resumes a paused timer from where it left off. No-op if not paused. */
+    resume: () => void;
+    /** Adds seconds to the remaining time. Clamped to `maxSeconds` if set. */
+    addTime: (seconds: number) => void;
+    /** Removes seconds from the remaining time. Clamped to 0, which triggers completion. */
+    removeTime: (seconds: number) => void;
+    /** Stops the timer and resets it back to idle at its original starting duration. Does not fire onComplete. */
+    cancel: () => void;
+    /** Resets to idle at `durationSeconds` without starting. */
+    reset: () => void;
+    /** Current status snapshot. */
+    getStatus: () => TimerStatus;
+    /** Current remaining time in ms, read synchronously. */
+    getRemainingMs: () => number;
+}
+/** Text Timer renders of its own, for translating it. */
+export interface TimerLabels {
+    /** Tooltip on the cancel button. */
+    cancel?: string;
+}
+export interface TimerProps extends HtmlProps {
+    /** Starting duration in seconds. Changing this prop while mounted resets the timer to the new duration. */
+    durationSeconds: number;
+    /** Start ticking automatically on mount (and whenever `durationSeconds` changes). @default true */
+    autoStart?: boolean;
+    /** When `durationSeconds` changes after mount, restart from the new duration immediately (`true`) or only update the idle baseline (`false`). @default true */
+    resetOnDurationChange?: boolean;
+    /** Fires roughly every 200ms with the live remaining ms. */
+    onTick?: (remainingMs: number) => void;
+    /** Fires exactly once when the countdown reaches zero. */
+    onComplete?: () => void;
+    /** Fires when the timer transitions to running (initial start or resume). */
+    onStart?: () => void;
+    /** Fires when paused. */
+    onPause?: () => void;
+    /** Fires when resumed from pause. */
+    onResume?: () => void;
+    /** Fires when cancelled (via button or ref). */
+    onCancel?: () => void;
+    /** Fires whenever time is added, with the seconds added and the new total remaining seconds. */
+    onAddTime?: (secondsAdded: number, newRemainingSeconds: number) => void;
+    /** Fires whenever time is removed. */
+    onRemoveTime?: (secondsRemoved: number, newRemainingSeconds: number) => void;
+    /** Show the built-in control buttons (add/remove/pause-resume/cancel). @default true */
+    showControls?: boolean;
+    /** Individually hide the add-time button while keeping the others. */
+    hideAddButton?: boolean;
+    /** Individually hide the remove-time button while keeping the others. */
+    hideRemoveButton?: boolean;
+    /** Individually hide the pause/resume button while keeping the others. */
+    hidePauseButton?: boolean;
+    /** Individually hide the cancel button while keeping the others. */
+    hideCancelButton?: boolean;
+    /** Seconds added/removed per click of the add/remove buttons. @default 30 */
+    adjustSeconds?: number;
+    /** Optional cap on remaining time when adding. Unset = uncapped. */
+    maxSeconds?: number;
+    /** Label rendered under the time readout, e.g. "Boil pasta". */
+    label?: ReactNode;
+    /** Format the MM:SS (or H:MM:SS) readout. Defaults to a built-in formatter. */
+    formatTime?: (remainingMs: number) => ReactNode;
+    /** Diameter of the ring, any CSS length. Sets `--timer-size`, which defaults to `10em`, 160px at a 16px base. */
+    size?: string;
+    /** Ring stroke width in px. Sets `--timer-stroke-width`. @default 10 */
+    strokeWidth?: number;
+    /** Sweeps the depleting boundary counter-clockwise instead of the default clockwise (matching a clock face). @default false */
+    counterClockwise?: boolean;
+    /** Fraction of total duration (0-1) at which the ring switches to its urgent colour and the pulse (if enabled) kicks in. @default 0.1 */
+    urgentThreshold?: number;
+    /**
+     * Floor, in seconds, for how much time the urgent state gets — whichever of this or
+     * `urgentThreshold` (as a fraction of the total duration) produces the larger window wins.
+     * Without this, a short timer's `urgentThreshold` fraction can resolve to under a second,
+     * making the urgent/critical state barely perceptible. @default 3
+     */
+    urgentMinSeconds?: number;
+    /** Enables the heartbeat/pulse effect once inside `urgentThreshold`. @default true */
+    pulseOnUrgent?: boolean;
+    /** Shows a thin ring pulsing outward from the dial's own edge and fading out while running (a beacon/live-indicator-style halo). @default false */
+    showRunningRipples?: boolean;
+    /** Play a short built-in chime on completion. @default false */
+    playSoundOnComplete?: boolean;
+    /** Overrides the built-in sound with a consumer-supplied audio URL. */
+    soundUrl?: string;
+    /** Volume 0-1 for the completion sound. @default 0.5 */
+    soundVolume?: number;
+    /** Show a browser Notification on completion (permission requested lazily on first `start()`, fails silently if denied/unsupported). @default false */
+    notifyOnComplete?: boolean;
+    /** Notification title when `notifyOnComplete` is set. @default 'Timer done' */
+    notificationTitle?: string;
+    /** Notification body when `notifyOnComplete` is set. Falls back to `label` when it's a string. */
+    notificationBody?: string;
+    /** Imperative handle for starting, pausing and resetting the timer. */
+    ref?: Ref<TimerHandle>;
+    className?: string;
+    style?: CSSProperties;
+    classNames?: SlotClassNames<TimerSlots>;
+    styles?: SlotStyles<TimerSlots>;
+    /** Overrides the text Timer renders of its own. Merged per key. */
+    labels?: TimerLabels;
+}

package/dist/cjs-types/common/toast/index.d.ts

@@ -0,0 +1,3 @@
+export { default } from './toastProvider.js';
+export { showToast } from './toastService.js';
+export type { ToastProviderProps, ToastContextConfig, ToastOptions, ToastType, ToastPosition, ToastSlots, } from './toast.types.js';

package/dist/cjs-types/common/toast/toast.d.ts

@@ -0,0 +1,11 @@
+import { default as React } from 'react';
+import { ToastItem, ToastLabels } from './toast.types.js';
+interface ToastProps {
+    item: ToastItem;
+    isBottom: boolean;
+    onDismiss: (id: string) => void;
+    /** Already resolved by the provider: defaults, provider, then this toast's own. */
+    labels: Required<ToastLabels>;
+}
+declare function Toast({ item, isBottom, onDismiss, labels }: ToastProps): React.JSX.Element;
+export default Toast;

package/dist/cjs-types/common/toast/toast.types.d.ts

@@ -0,0 +1,50 @@
+import { ReactNode } from 'react';
+import { SlotClassNames, SlotStyles } from '../types/slots.types.js';
+export type ToastPosition = 'top-left' | 'top-center' | 'top-right' | 'bottom-left' | 'bottom-center' | 'bottom-right';
+export type ToastType = 'default' | 'info' | 'success' | 'error' | 'warn';
+export type ToastSlots = 'root' | 'icon' | 'content' | 'closeButton' | 'progressBar';
+/** Text Toast renders of its own, for translating it. */
+export interface ToastLabels {
+    /** The dismiss button, read out by screen readers. */
+    close?: string;
+}
+export interface ToastContextConfig {
+    position?: ToastPosition;
+    /** Duration in ms. 0 = persistent. */
+    duration?: number;
+    showRemainingTime?: boolean;
+    showCloseButton?: boolean;
+    /** Whether multiple toasts can be visible simultaneously. */
+    allowStacking?: boolean;
+    /** Pause the auto-dismiss timer while the toast is hovered or focused. */
+    pauseOnHover?: boolean;
+    /**
+     * Overrides the text a toast renders of its own. Set on `ToastProvider` for
+     * the whole app, or per toast through `showToast` options.
+     */
+    labels?: ToastLabels;
+}
+export interface ToastOptions extends ToastContextConfig {
+    type?: ToastType;
+    classNames?: SlotClassNames<ToastSlots>;
+    styles?: SlotStyles<ToastSlots>;
+}
+export interface ToastProviderProps extends ToastContextConfig {
+    children: ReactNode;
+}
+export interface ToastItem extends Pick<ToastOptions, 'labels'> {
+    id: string;
+    content: ReactNode;
+    options: ResolvedToastOptions;
+    dismissing: boolean;
+}
+export interface ResolvedToastOptions {
+    position: ToastPosition;
+    duration: number;
+    showRemainingTime: boolean;
+    showCloseButton: boolean;
+    pauseOnHover: boolean;
+    type: ToastType;
+    classNames?: SlotClassNames<ToastSlots>;
+    styles?: SlotStyles<ToastSlots>;
+}

package/dist/cjs-types/common/toast/toastProvider.d.ts

@@ -0,0 +1,8 @@
+import { default as React, ReactNode } from 'react';
+import { ToastContextConfig } from './toast.types.js';
+interface ToastProviderProps extends ToastContextConfig {
+    children: ReactNode;
+}
+declare function ToastProvider({ children, position, duration, showRemainingTime, showCloseButton, allowStacking, pauseOnHover, labels, }: ToastProviderProps): React.JSX.Element;
+export default ToastProvider;
+export type { ToastProviderProps };

package/dist/cjs-types/common/toast/toastService.d.ts

@@ -0,0 +1,7 @@
+import { ReactNode } from 'react';
+import { ToastOptions } from './toast.types.js';
+type ShowToastFn = (content: ReactNode, options?: ToastOptions) => void;
+export declare function _registerToastHandler(fn: ShowToastFn): void;
+export declare function _unregisterToastHandler(): void;
+export declare function showToast(content: ReactNode, options?: ToastOptions): void;
+export {};

package/dist/cjs-types/common/tooltip/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './tooltip.js';
+export * from './tooltip.types.js';

package/dist/cjs-types/common/tooltip/tooltip.d.ts

@@ -0,0 +1,3 @@
+import { default as React } from 'react';
+import { TooltipProps } from './tooltip.types.js';
+export default function Tooltip({ variant, message, isVisible, tooltipPosition, onClick, labels, }: TooltipProps): React.JSX.Element | null;

package/dist/cjs-types/common/tooltip/tooltip.types.d.ts

@@ -0,0 +1,17 @@
+import { default as React } from 'react';
+export type TooltipVariant = 'info' | 'details' | 'error';
+/** Text Tooltip renders of its own, for translating it. */
+export interface TooltipLabels {
+    /** Accessible name of the `?` icon the `details` variant renders (default `More information`). */
+    details?: string;
+}
+export interface TooltipProps {
+    variant: TooltipVariant;
+    message?: React.ReactNode;
+    isVisible?: boolean;
+    iconPosition?: string;
+    tooltipPosition?: string;
+    onClick?: () => void;
+    /** Overrides the text Tooltip renders of its own. Merged per key. */
+    labels?: TooltipLabels;
+}

package/dist/cjs-types/common/tree/flattenTree.d.ts

@@ -0,0 +1,3 @@
+import { FlatTreeNode, TreeNode, TreeValue } from './tree.types.js';
+/** The visible nodes in render order. Flat, not nested, deliberately: see docs/Tree.md. */
+export declare function flattenTree(nodes: TreeNode[], expandedKeys: TreeValue[], level?: number, parentKey?: TreeValue | null): FlatTreeNode[];

package/dist/cjs-types/common/tree/index.d.ts

@@ -0,0 +1,3 @@
+export { default } from './tree.js';
+export { flattenTree } from './flattenTree.js';
+export * from './tree.types.js';

package/dist/cjs-types/common/tree/tree.d.ts

@@ -0,0 +1,4 @@
+import { ReactElement } from 'react';
+import { TreeProps } from './tree.types.js';
+declare function Tree(props: TreeProps): ReactElement;
+export default Tree;

package/dist/cjs-types/common/tree/tree.types.d.ts

@@ -0,0 +1,67 @@
+import { CSSProperties, ReactNode } from 'react';
+import { IconContent } from '../types/icon.types.js';
+import { SlotClassNames, SlotStyles, HtmlProps } from '../types/slots.types.js';
+export type TreeValue = string | number;
+export interface TreeNode {
+    key: TreeValue;
+    label: ReactNode;
+    /** Icon shown before the label. */
+    icon?: IconContent;
+    /** Child nodes. An empty array still renders a toggle, for a branch whose children load later. */
+    children?: TreeNode[];
+    disabled?: boolean;
+}
+/** One visible row produced by `flattenTree`. */
+export interface FlatTreeNode {
+    node: TreeNode;
+    /** Depth from the roots, 0-based. */
+    level: number;
+    parentKey: TreeValue | null;
+    isBranch: boolean;
+    isExpanded: boolean;
+    /** Number of siblings at this level, for `aria-setsize`. */
+    setSize: number;
+    /** 1-based position among those siblings, for `aria-posinset`. */
+    posInSet: number;
+}
+export type TreeSlots = 'root' | 'node' | 'toggle' | 'icon' | 'label' | 'empty';
+/** Text Tree renders of its own, for translating it. */
+export interface TreeLabels {
+    /** Shown when `nodes` is empty (default `Nothing here`). */
+    empty?: string;
+}
+export interface TreeProps extends Omit<HtmlProps<HTMLDivElement>, 'onSelect'> {
+    nodes: TreeNode[];
+    /** Controlled set of expanded branch keys. Omit for uncontrolled. */
+    expandedKeys?: TreeValue[];
+    /** Branches expanded initially when uncontrolled (default `[]`). */
+    defaultExpandedKeys?: TreeValue[];
+    onExpandedChange?: (keys: TreeValue[]) => void;
+    /** Controlled selected key. Omit for uncontrolled. */
+    selectedKey?: TreeValue | null;
+    /** Key selected initially when uncontrolled. */
+    defaultSelectedKey?: TreeValue;
+    onSelect?: (key: TreeValue, node: TreeNode) => void;
+    /** Clicking a branch's label toggles it as well as selecting it (default `true`). */
+    expandOnSelect?: boolean;
+    /** Indent per level in px (default `20`). */
+    indent?: number;
+    /** Icon for the expand/collapse toggle. Rotates 90° when open (default a right chevron). */
+    toggleIcon?: IconContent;
+    /**
+     * Sets a fixed viewport height and windows the rows through `VirtualList`, so only the visible
+     * ones are in the DOM. Use it past a few hundred visible nodes. Rows must then be uniform
+     * height: set `--tree-node-height` rather than sizing individual rows.
+     */
+    height?: number | string;
+    /** Row height used by the windowed renderer before measurement (default `32`). */
+    estimatedRowHeight?: number;
+    disabled?: boolean;
+    'aria-label'?: string;
+    className?: string;
+    style?: CSSProperties;
+    classNames?: SlotClassNames<TreeSlots>;
+    styles?: SlotStyles<TreeSlots>;
+    /** Overrides the text Tree renders of its own. Merged per key. */
+    labels?: TreeLabels;
+}

package/dist/cjs-types/common/types/actions.types.d.ts

@@ -0,0 +1,7 @@
+import { IconContent } from './icon.types.js';
+/** A single icon-triggered action, rendered as an `ActionIcon` */
+export interface IconAction {
+    title?: string;
+    onClick?: (e: React.MouseEvent<HTMLDivElement>) => void;
+    icon: IconContent;
+}

package/dist/cjs-types/common/types/baseProps.types.d.ts

@@ -0,0 +1,29 @@
+import { default as React } from 'react';
+/**
+ * TypeScript allows hyphenated attributes on *intrinsic* elements only, so a component's props
+ * interface has to declare these itself — no React attribute type provides them.
+ */
+type DataAttributes = {
+    [K in `data-${string}`]?: string;
+};
+/**
+ * HTML pass-through props accepted on the root element of every component: the full native
+ * attribute set for that element, plus `data-*`.
+ *
+ * Pass the root's element type for correctly-typed event handlers (`HtmlProps<HTMLDivElement>`);
+ * the default is the loose `HTMLElement`. Where the root is not a plain container, extend the
+ * matching React type instead and add `DataProps` for the `data-*` half — `Button` does this
+ * with `React.ButtonHTMLAttributes<HTMLButtonElement>`.
+ *
+ * `ref` is deliberately *not* here. `Ref<E>` is invariant, so a shared `Ref<HTMLElement>` is not
+ * assignable to the `<div>` it would be spread onto, and narrowing the default to `HTMLDivElement`
+ * re-types every event handler with it — which breaks `Dropdown` and `SplitButton`, whose `onClick`
+ * is typed for the `<button>` they hand it to. A component that accepts a ref declares it itself,
+ * next to its other props, typed for the element it actually lands on.
+ *
+ * A component prop that collides with a native one of the same name must `Omit` the native one.
+ */
+export type HtmlProps<E extends HTMLElement = HTMLElement> = React.HTMLAttributes<E> & DataAttributes;
+/** The `data-*` half of {@link HtmlProps}, for components that source attributes elsewhere. */
+export type DataProps = DataAttributes;
+export {};

package/dist/cjs-types/common/types/icon.types.d.ts

@@ -0,0 +1,17 @@
+import { IconDefinition } from '@fortawesome/fontawesome-svg-core';
+import { ReactElement } from 'react';
+/**
+ * Anything a component will accept for an `icon` prop: either a FontAwesome
+ * `IconDefinition` (rendered through `FontAwesomeIcon`) or an arbitrary React
+ * element (rendered as-is) — an `<img>`, an inline `<svg>`, another icon
+ * library's component, …
+ *
+ * Deliberately `ReactElement` rather than `ReactNode`: `ReactNode` also covers
+ * strings, numbers and booleans, so a required icon prop would stop catching
+ * `icon="star"` at compile time and silently render the text instead. Matches
+ * what `Input` has always accepted for its own icon prop.
+ *
+ * Render one with `renderIcon` from `components/common/utils/renderIcon`, which
+ * picks the right branch.
+ */
+export type IconContent = IconDefinition | ReactElement;

package/dist/cjs-types/common/types/slots.types.d.ts

@@ -0,0 +1,4 @@
+import { CSSProperties } from 'react';
+export type SlotClassNames<Keys extends string> = Partial<Record<Keys, string>>;
+export type SlotStyles<Keys extends string> = Partial<Record<Keys, CSSProperties>>;
+export type { HtmlProps, DataProps } from './baseProps.types.js';

package/dist/cjs-types/common/utils/activationKey.d.ts

@@ -0,0 +1,9 @@
+import { default as React } from 'react';
+/**
+ * Whether a keydown is a click-equivalent activation of the element the handler sits on.
+ *
+ * The target check is the important half: keydown bubbles, so without it a Space typed into a
+ * nested input activates the container and, once the container calls `preventDefault()`, never
+ * reaches the input at all.
+ */
+export declare function isSelfActivation(event: React.KeyboardEvent): boolean;

package/dist/cjs-types/common/utils/interactiveTarget.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Whether a click landed on a control of its own inside `container`, rather than on the container.
+ *
+ * `container` itself never counts, or one carrying `role="button"` would exclude every click it is
+ * meant to answer. `role="group"` is absent for the same reason: it marks a wrapper, not a control.
+ */
+export declare function isInteractiveTarget(target: EventTarget | null, container: Element | null): boolean;

package/dist/cjs-types/common/utils/listNavigation.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Where the highlight goes next in a list the arrow keys move through.
+ *
+ * Shared so the library's listboxes agree on it. They did not: Dropdown wrapped and skipped
+ * disabled options, MultiSelect wrapped but stopped on them, and InputDropdown clamped at both
+ * ends and cleared the highlight when ArrowUp reached the top. Moving between two fields in the
+ * same form behaved differently for no reason a user could see.
+ *
+ * Only the arithmetic is shared. Which key means what, and what selecting does, stays with each
+ * component, because those genuinely differ.
+ */
+/** `null` is "nothing highlighted": the state a freshly opened list starts in. */
+export type ActiveIndex = number | null;
+export interface ListNavigationOptions {
+    /** Options that cannot be highlighted, by index. */
+    isDisabled?: (index: number) => boolean;
+    /**
+     * Whether moving past an end comes back round. `false` stops on the last selectable option,
+     * for a list whose first entry is the text the user is still typing.
+     */
+    wrap?: boolean;
+}
+/**
+ * The next selectable index in `step` direction, or `null` when the list has nothing to
+ * highlight. From `null` a forward step enters at the top and a backward step at the bottom,
+ * which is what both a native `<select>` and the ARIA combobox pattern do.
+ */
+export declare function nextIndex(from: ActiveIndex, step: 1 | -1, length: number, { isDisabled, wrap }?: ListNavigationOptions): ActiveIndex;
+/** The first or last selectable index, for Home and End. */
+export declare function edgeIndex(edge: 'first' | 'last', length: number, options?: ListNavigationOptions): ActiveIndex;
+/**
+ * Scrolls `option` into view inside `list`, moving nothing else on the page.
+ *
+ * The arrow keys move a highlight, not the focus — the focus stays on the combobox, because that
+ * is what `aria-activedescendant` points from. So the browser never scrolls the option into view
+ * by itself, and a list taller than its panel would highlight rows the user cannot see.
+ *
+ * Measured with `getBoundingClientRect` rather than `offsetTop`, which is relative to the nearest
+ * positioned ancestor and so silently wrong whenever that is not the scrolling element itself.
+ * `scrollIntoView` would be shorter but is free to scroll every ancestor, including the page
+ * behind the panel.
+ *
+ * Rectangles are what the screen shows, and `scrollTop` is in layout pixels, so the two disagree
+ * whenever an ancestor carries a scale — which every one of these lists does, because the Popover
+ * panel holding them animates in from a smaller size. Measured mid-animation, a list 260 layout
+ * pixels tall reports a rectangle of 182, and scrolling by the raw difference moved 30% short
+ * every step. `offsetHeight` against the rectangle's height recovers the factor.
+ */
+export declare function scrollOptionIntoView(list: HTMLElement | null | undefined, option: Element | null | undefined): void;

package/dist/cjs-types/common/utils/mergeRefs.d.ts

@@ -0,0 +1,12 @@
+import { Ref } from 'react';
+/**
+ * Fans one element out to several refs, for a component that needs the node itself *and*
+ * hands it to the consumer through a `ref` prop.
+ *
+ * The returned callback is a new function on every render, so React detaches and reattaches
+ * it each time (null, then the node). Every ref here is therefore written twice per render,
+ * which is fine for storing a node and wrong for anything with a side effect. Call it inline
+ * rather than memoising: a memo would have to list the refs it closes over, and a consumer
+ * passing an inline callback ref changes that identity every render anyway.
+ */
+export declare function mergeRefs<T>(...refs: (Ref<T> | undefined)[]): (node: T | null) => void;

package/dist/cjs-types/common/utils/renderIcon.d.ts

@@ -0,0 +1,29 @@
+import { CSSProperties, ReactNode } from 'react';
+import { IconDefinition } from '@fortawesome/fontawesome-svg-core';
+import { IconContent } from '../types/icon.types.js';
+interface RenderIconOptions {
+    /** Class applied to the rendered icon (or to the wrapper span for a custom element). */
+    className?: string;
+    /** Inline style applied to the rendered icon (or to the wrapper span for a custom element). */
+    style?: CSSProperties;
+}
+/**
+ * Narrows an `IconContent` to a FontAwesome `IconDefinition`.
+ *
+ * Both halves of the union are plain objects (a React element is one too), so
+ * they can only be told apart structurally: an icon definition always carries
+ * `prefix`, `iconName` and the `icon` tuple.
+ */
+export declare function isIconDefinition(icon: IconContent | null | undefined): icon is IconDefinition;
+/**
+ * Renders an `icon` prop that may be either a FontAwesome `IconDefinition` or an
+ * arbitrary React element.
+ *
+ * A definition goes through `FontAwesomeIcon`; an element is returned untouched
+ * unless a `className`/`style` was given, in which case it is wrapped in a
+ * `<span>` carrying them so component and consumer slot styling still lands
+ * somewhere. Note that a custom element is not sized by FontAwesome's `1em`
+ * geometry — size it yourself if the surrounding layout expects a square icon.
+ */
+export declare function renderIcon(icon: IconContent | null | undefined, options?: RenderIconOptions): ReactNode;
+export {};

package/dist/cjs-types/common/utils/scrollAncestors.d.ts

@@ -0,0 +1,2 @@
+export declare function getScrollableAncestors(el: HTMLElement): HTMLElement[];
+export declare function isHiddenByAnyAncestor(rect: DOMRect, ancestors: HTMLElement[]): boolean;

package/dist/cjs-types/common/utils/visualViewport.d.ts

@@ -0,0 +1,7 @@
+export interface VisualViewportRect {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}
+export declare function getVisualViewportRect(): VisualViewportRect;

package/dist/cjs-types/common/virtualList/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './virtualList.js';
+export * from './virtualList.types.js';

package/dist/cjs-types/common/virtualList/useColumnResize.d.ts

@@ -0,0 +1,59 @@
+import { default as React } from 'react';
+import { VirtualListColumn } from './virtualList.types.js';
+interface UseColumnResizeArgs<T> {
+    columns?: VirtualListColumn<T>[];
+    /**
+     * The columns currently rendered, in order. A ref rather than a value because
+     * the visible set is derived one hook later, and only the freeze reads it, at
+     * event time.
+     */
+    visibleColumnsRef: React.RefObject<VirtualListColumn<T>[]>;
+    resizableColumns: boolean;
+    /** Controlled widths. When provided, internal state is ignored. */
+    columnWidths?: Record<string, number>;
+    onColumnWidthsChange?: (widths: Record<string, number>) => void;
+    /** Restores widths saved under this key. Uncontrolled mode only. */
+    persistColumnsKey?: string;
+    rootRef: React.RefObject<HTMLDivElement | null>;
+}
+export interface UseColumnResizeResult<T> {
+    widths: Record<string, number>;
+    /**
+     * True once every visible column has an exact px width. Nothing moves at that
+     * moment, but from then on the layout is pixels rather than `fr`/`fit`.
+     */
+    isFrozen: boolean;
+    isResizing: boolean;
+    /** Drops every user width and hands the layout back to the column definitions. */
+    reset: () => void;
+    /** Whether this column takes a resize at all, by handle or by keyboard. */
+    isResizable: (col: VirtualListColumn<T>) => boolean;
+    /** Widens (or, negative, narrows) one column. The keyboard entry point. */
+    resizeBy: (key: string, delta: number) => void;
+    /** Takes one column down to its minimum. */
+    resizeToMin: (key: string) => void;
+    /** Sizes one column to its widest rendered cell. */
+    autoFit: (key: string) => void;
+    /** Pointer props for one column's handle, or null when that column can't be resized. */
+    getHandleProps: (col: VirtualListColumn<T>) => React.HTMLAttributes<HTMLDivElement> | null;
+}
+/**
+ * User column resizing: the width state, and a drag that doesn't go through
+ * React.
+ *
+ * A pointer move writes the dragged column's custom property straight onto the
+ * list element. The header and every row read that same property, so one DOM
+ * write resizes all of them in a single layout pass. Going through state
+ * instead would re-render the header plus every visible row on every frame, and
+ * the handle would trail the cursor by one frame, which is the whole difference
+ * between this feeling attached to the pointer and feeling cheap. React is told
+ * once, on release.
+ *
+ * The first resize **freezes** every visible column to its measured width. A
+ * `fr` track can't express "this one column is now 240px" without the others
+ * silently absorbing the difference, and once they hit their minimum the dragged
+ * edge stops following the cursor, which is the worst moment for it to happen.
+ * Frozen, the table is exact pixels and simply scrolls horizontally instead.
+ */
+export declare function useColumnResize<T>({ columns, visibleColumnsRef, resizableColumns, columnWidths, onColumnWidthsChange, persistColumnsKey, rootRef, }: UseColumnResizeArgs<T>): UseColumnResizeResult<T>;
+export {};