@ahrowe/ui 0.35.0 → 0.37.0

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

@@ -0,0 +1,357 @@
+import { CSSProperties, ReactNode, Ref } from 'react';
+import { SlotClassNames, SlotStyles, HtmlProps } from '../types/slots.types.js';
+export type ColumnWidthFixed = {
+    type: 'fixed';
+    px: number;
+};
+export type ColumnWidthFlex = {
+    type: 'flex';
+    weight?: number;
+};
+export type ColumnWidthFit = {
+    type: 'fit';
+};
+export type ColumnWidthSpec = ColumnWidthFixed | ColumnWidthFlex | ColumnWidthFit;
+/** A value the built-in comparator can order. */
+export type SortValue = string | number | boolean | Date | null | undefined;
+export type SortDirection = 'asc' | 'desc';
+/** The column being sorted and the direction. `null` anywhere this appears means unsorted. */
+export interface VirtualListSort {
+    /** `key` of the sorted column. */
+    key: string;
+    direction: SortDirection;
+}
+export interface VirtualListColumn<T> {
+    key: string;
+    label: ReactNode;
+    width: ColumnWidthSpec;
+    renderCell: (item: T, rowIndex: number) => ReactNode;
+    defaultHidden?: boolean;
+    /**
+     * Text shown for this column in the gear toggle menu. Falls back to `label`.
+     * Useful for columns with an empty header (e.g. an actions column) so their
+     * menu entry reads as something meaningful instead of being blank.
+     */
+    toggleLabel?: ReactNode;
+    /**
+     * Prevent this column from being hidden via the toggle menu. It always stays
+     * visible (overriding `defaultHidden` and any controlled/persisted state), and
+     * its menu entry is rendered checked and disabled. Overrides `defaultHidden`.
+     */
+    lockVisible?: boolean;
+    /**
+     * Omit this column from the gear toggle menu entirely — no entry is shown for
+     * it. Unlike `lockVisible` (which shows a checked, disabled entry), the column
+     * simply isn't listed. Its visibility then follows `defaultHidden` /
+     * controlled / persisted state as usual; combine with `lockVisible` to keep it
+     * always visible and out of the menu. The gear button hides automatically if
+     * no column remains toggleable.
+     */
+    hideFromToggle?: boolean;
+    /**
+     * Value this column is ordered by. Its presence makes the column sortable and
+     * lets the list sort `items` itself. `null`/`undefined`/`NaN` sort last, in
+     * both directions.
+     */
+    sortValue?: (item: T) => SortValue;
+    /**
+     * Ascending comparator, for an order `sortValue` can't express. Wins over
+     * `sortValue`, and also makes the column sortable. Descending negates its
+     * result, so it has no equivalent of the empty-values-last rule.
+     */
+    compare?: (a: T, b: T) => number;
+    /**
+     * Floor this column can be dragged to, in px. Default 48.
+     */
+    minWidth?: number;
+    /** Opt this column out of resizing while the list has `resizableColumns`. */
+    resizable?: boolean;
+    /**
+     * Makes the header clickable without the list reordering anything: the sort is
+     * only reported through `onSortChange`. For server-side or paginated sorting,
+     * where sorting the loaded rows would silently sort part of the data. Ignored
+     * when `sortValue` or `compare` is given.
+     */
+    sortable?: boolean;
+}
+/**
+ * What scrolls, when the list is not to scroll itself. `'nearest'` is the first
+ * ancestor set to scroll, the same one `Sticky` pins to; `'window'` is the page;
+ * an element (or a getter for one, for a ref that fills after the first render)
+ * names it outright.
+ */
+export type VirtualListScrollParent = 'nearest' | 'window' | HTMLElement | (() => HTMLElement | null);
+export interface VirtualListScrollOptions {
+    /** Where the target row lands in the viewport. Default: 'start'. */
+    align?: 'start' | 'center' | 'end';
+    /** Native scroll behaviour. Default: 'auto'. */
+    behavior?: ScrollBehavior;
+}
+/** Imperative handle exposed via `ref`. */
+export interface VirtualListHandle {
+    /** Scroll so the row at `index` is visible. */
+    scrollToIndex: (index: number, options?: VirtualListScrollOptions) => void;
+    /** Scroll to the row whose `getItemKey` matches `key` (no-op if not found). */
+    scrollToKey: (key: string | number, options?: VirtualListScrollOptions) => void;
+    /** Scroll back to the top. */
+    scrollToTop: (options?: Pick<VirtualListScrollOptions, 'behavior'>) => void;
+    /**
+     * The element that scrolls: the list itself, or the `scrollParent` it was
+     * given. `null` for `scrollParent='window'`, where the page scrolls.
+     */
+    getScrollElement: () => HTMLElement | null;
+    /**
+     * Re-read where the list sits in its `scrollParent`. Only needed in that mode,
+     * and only when something *above* the list changed height without the list
+     * re-rendering: an element moving fires no event of its own, and the list
+     * would keep rendering the window it had before.
+     */
+    remeasure: () => void;
+    /**
+     * Re-measure `fit` columns on the next layout. Call this after an out-of-band
+     * content change that doesn't flow through a new `items` array or `columns`
+     * set (those reset automatically) — e.g. a cell's content grew in place.
+     */
+    recalculateColumns: () => void;
+    /**
+     * Drops every user-set column width and returns the table to the widths its
+     * columns declare. Also clears them from `persistColumnsKey` storage.
+     */
+    resetColumnWidths: () => void;
+}
+export type VirtualListSlots = 'root' | 'header' | 'headerCell' | 'headerToggle' | 'headerSort' | 'sortIcon' | 'resizeHandle' | 'activeRow' | 'togglePopover' | 'toggleItem' | 'toggleReset' | 'body' | 'row' | 'cell' | 'selectCell' | 'loadingIndicator' | 'dropIndicator' | 'columnChip';
+/** Where a tree-reorder drop lands relative to the row it is over. */
+export type TreeDropPosition = 'before' | 'inside' | 'after';
+/** The resolved drop target reported to `onTreeDrop`. */
+export interface TreeDropTarget {
+    /** `getItemKey` of the row the drop lands on. */
+    key: string | number;
+    /**
+     * `before`/`after` place the dragged node as a sibling of the target (at the
+     * target's depth); `inside` makes it a child of the target (only offered when
+     * `isGroup` returns true for that row).
+     */
+    position: TreeDropPosition;
+}
+/** Text VirtualList renders of its own, for translating it. */
+export interface VirtualListLabels {
+    /** A row's select checkbox, read out by screen readers. */
+    selectRow?: string;
+    /** The header's select-all checkbox, read out by screen readers. */
+    selectAllRows?: string;
+    /** The gear that opens the column menu, read out by screen readers. */
+    toggleColumns?: string;
+    /** The badge on the gear, given how many columns the user has hidden. */
+    columnsHidden?: (count: number) => string;
+    /** The entry in the column menu that undoes the user's column widths. */
+    resetColumnWidths?: ReactNode;
+}
+export interface VirtualListProps<T> extends HtmlProps {
+    items: T[];
+    /** Render function for list mode (no columns). Ignored when `columns` is provided. */
+    renderRow?: (item: T, index: number) => ReactNode;
+    /** Column definitions — presence enables table/header mode. */
+    columns?: VirtualListColumn<T>[];
+    /**
+     * Replaces the roles put on the container and rows (default `list`/`listitem`, or `grid`/`row`
+     * with columns). Pass `'none'` for both when the rows carry their own semantics, as `Tree` does.
+     */
+    ariaRoles?: {
+        container: string;
+        row: string;
+    };
+    /** Height of the scroll viewport. Defaults to '100%' to fill the parent container. Ignored with `scrollParent`. */
+    height?: number | string;
+    /**
+     * Drops the list's own scrollbar: it renders at its full height in the page
+     * flow and virtualizes against whatever is given here, so a long list at the
+     * end of a scrolling page doesn't put a second scrollbar inside the first.
+     * `height` no longer applies. `'nearest'` covers most cases: it walks up to
+     * the first ancestor whose `overflow-y` is set to scroll, whether or not it
+     * currently does, and falls back to the page.
+     *
+     * The header still sticks, now to the top of that scrollport; give the list
+     * `--vl-header-top` to clear a fixed app bar. Rows of uneven height move the
+     * page's own scrollbar as they are measured, so set `estimatedRowHeight` to
+     * the real height where the rows have one.
+     */
+    scrollParent?: VirtualListScrollParent;
+    /** Estimated row height before measurement. Default: 40. */
+    estimatedRowHeight?: number;
+    /** Extra rows to render above/below the visible window. Default: 3. */
+    overscan?: number;
+    /**
+     * Gap between rows. A number is treated as px; a string may be any CSS length
+     * (`'1em'`, `'0.5rem'`, `'1px'`, or a custom property like `'var(--spacing-s)'`).
+     * Non-px units / custom properties are resolved against the list element.
+     * Default: 0.
+     */
+    rowGap?: number | string;
+    /**
+     * Padding applied to every row. A number is treated as px; a string may be any
+     * CSS padding value (`'8px 12px'`, `'1em'`, `'var(--spacing-s)'`). Because each
+     * row's height is measured after layout, the padding is reflected in the
+     * virtualization automatically — no layout math is affected.
+     */
+    rowPadding?: number | string;
+    /** Show a divider line between rows. Default: true. */
+    showDivider?: boolean;
+    /**
+     * Highlight rows on hover. Default: true. Set false when the row content
+     * handles its own hover affordance (e.g. a Card per row), so the list's
+     * background doesn't fight it.
+     */
+    rowHover?: boolean;
+    /** Controlled selected row key. Matched against `getItemKey`. */
+    selectedKey?: string | number | null;
+    /** Returns a stable key per item. Defaults to row index. */
+    getItemKey?: (item: T, index: number) => string | number;
+    /** Called when a row is clicked. */
+    onRowClick?: (item: T, index: number) => void;
+    /**
+     * Arrow-key navigation over the rows, on by default. The list takes one tab
+     * stop, the arrows move an active row, Enter fires `onRowClick` and Space
+     * toggles the selection in `multiSelect`. Keys are ignored while the focus is
+     * inside a cell, so a control in a row keeps its own.
+     *
+     * Turn it off for a list whose rows already handle their own keys, the way
+     * `Tree` does.
+     */
+    keyboardNavigation?: boolean;
+    /**
+     * Lets Tab carry on into the next row instead of leaving the list at the end
+     * of the current one, for a grid of inputs a user fills in field by field.
+     * Shift+Tab walks back the same way, and Tab out of the last row (or back out
+     * of the first) leaves the list as it always did. Default: false, because for
+     * a list that is read rather than filled in, one tab stop and the arrow keys
+     * are the expected behaviour, and 5000 rows of tab stops are a trap.
+     */
+    tabAcrossRows?: boolean;
+    /** Controlled visible column keys. When provided, internal state is ignored. */
+    visibleColumnKeys?: string[];
+    /** Called when the user toggles a column in the popover. */
+    onVisibleColumnsChange?: (keys: string[]) => void;
+    /**
+     * When set, column visibility is saved to `localStorage` under this key and
+     * restored on the next mount of a list with the same key. Only applies in
+     * uncontrolled mode (ignored when `visibleColumnKeys` is provided). Newly
+     * added columns that weren't present when the settings were saved fall back
+     * to their `defaultHidden` value rather than the saved set.
+     */
+    persistColumnsKey?: string;
+    /**
+     * Controlled sort state. `null` is unsorted (source order). When provided,
+     * internal state is ignored.
+     */
+    sort?: VirtualListSort | null;
+    /** Initial sort in uncontrolled mode. Default: `null`. */
+    defaultSort?: VirtualListSort | null;
+    /**
+     * Called on each header click with the next step of the asc → desc → unsorted
+     * cycle. The list reorders `items` itself for columns that define `sortValue`
+     * or `compare`; for a `sortable` column it only reports, and sorting the data
+     * is yours to do.
+     */
+    onSortChange?: (sort: VirtualListSort | null) => void;
+    /**
+     * Lets the user drag a column's right edge to resize it, double-click it to fit
+     * the column to its content, or resize it from the keyboard once the handle has
+     * focus. The first resize pins every visible column to its current pixel width
+     * (nothing moves at that moment), after which the table is an exact pixel
+     * layout that scrolls horizontally rather than redistributing space.
+     */
+    resizableColumns?: boolean;
+    /** Controlled column widths in px, keyed by column key. */
+    columnWidths?: Record<string, number>;
+    /** Overrides the text VirtualList renders of its own. Merged per key. */
+    labels?: VirtualListLabels;
+    /** Called with the full width map whenever the user resizes or auto-fits a column. */
+    onColumnWidthsChange?: (widths: Record<string, number>) => void;
+    /** Show the gear column-toggle button in the header. Default: true when columns present. */
+    showColumnToggle?: boolean;
+    /**
+     * Called when the user scrolls within `loadMoreThreshold` px of the bottom, and
+     * repeatedly while the rows don't fill the viewport — a list too short to scroll
+     * would otherwise never ask for a second batch. Each row count is asked at most
+     * once, so the loop ends as soon as a call appends nothing; pass `undefined`
+     * once the source is exhausted to skip even that final probe.
+     * Must return a Promise that resolves once new items have been appended to `items`.
+     * A spinner is shown at the bottom while the Promise is pending.
+     */
+    onLoadMore?: () => Promise<void>;
+    /** Distance in px from the bottom that triggers `onLoadMore`. Default: 100. */
+    loadMoreThreshold?: number;
+    /** Replaces the list body with a full-height spinner (for initial/filter loads). */
+    isLoading?: boolean;
+    /** Enables multi-row selection with a checkbox column on the far left. */
+    multiSelect?: boolean;
+    /** Controlled set of selected item keys. When provided, internal state is ignored. */
+    selectedKeys?: Set<string | number>;
+    /** Called when the selection changes. */
+    onSelectionChange?: (keys: Set<string | number>) => void;
+    /**
+     * Enables drag-and-drop row reordering (native HTML5 drag — desktop/mouse).
+     * The whole row becomes draggable; pair with `onReorder` to apply the move.
+     * Provide `getItemKey` so reordered rows keep their measured heights.
+     */
+    reorderable?: boolean;
+    /**
+     * Called while the user drags a row over a new position. Fires live (on each
+     * change), so apply it immediately — e.g. `setItems(prev => move(prev, from, to))`.
+     */
+    onReorder?: (fromIndex: number, toIndex: number) => void;
+    /**
+     * Touch only: how long (ms) the user must press-and-hold a row before drag
+     * mode activates, so a normal swipe still scrolls the list. Default: 400.
+     */
+    longPressDelay?: number;
+    /**
+     * Enables tree drag-and-drop: instead of a flat reorder, a dragged row can be
+     * dropped `before`, `after`, or `inside` another row. Mutually exclusive with
+     * `reorderable` (if both are set, `treeReorder` wins). Unlike `reorderable`,
+     * rows are NOT moved live — a drop indicator is shown during the drag and
+     * `onTreeDrop` fires once on release. The list is still a flat array: hold the
+     * real tree in your own state, flatten the expanded nodes into `items` (each
+     * tagged with its depth), and re-flatten after applying the drop.
+     * Provide `getItemKey` so rows keep their measured heights across re-flattens.
+     */
+    treeReorder?: boolean;
+    /**
+     * Depth of each row in the tree (0 = root). Used to align the drop indicator
+     * and to forbid dropping a node onto itself or its own descendants. Defaults
+     * to 0 for every row.
+     */
+    getItemDepth?: (item: T, index: number) => number;
+    /**
+     * Whether a row can receive children — i.e. whether an `inside` drop is
+     * offered when hovering its middle third. Defaults to false (leaf) for every
+     * row, so only `before`/`after` are offered.
+     */
+    isGroup?: (item: T, index: number) => boolean;
+    /**
+     * Called once when a tree-reorder drag is released on a valid target. Apply
+     * the move to your tree state and re-flatten. Not called when the drop target
+     * is the dragged node itself or one of its descendants.
+     */
+    onTreeDrop?: (dragKey: string | number, target: TreeDropTarget) => void;
+    /**
+     * Indent (px per depth level) used to position the `before`/`after` drop
+     * indicator line so it aligns with where the dropped content will start.
+     * Match this to the per-level padding you apply to row content. Default: 24.
+     */
+    treeIndentPx?: number;
+    /**
+     * Restrict drag initiation to elements marked `data-drag-handle` within a row
+     * (rather than the whole row). Essential for rows containing editable inputs
+     * or other interactive controls, so clicking/typing/selecting text in them
+     * doesn't start a drag. Applies to both `reorderable` and `treeReorder`, mouse
+     * and touch. Render a handle in your row, e.g. `<span data-drag-handle>⠿</span>`.
+     */
+    dragHandle?: boolean;
+    /** Imperative handle for scrolling and for recalculating column layout. */
+    ref?: Ref<VirtualListHandle>;
+    className?: string;
+    style?: CSSProperties;
+    classNames?: SlotClassNames<VirtualListSlots>;
+    styles?: SlotStyles<VirtualListSlots>;
+}

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

@@ -0,0 +1,126 @@
+import { ColumnWidthSpec, SortValue, VirtualListColumn, VirtualListSort } from './virtualList.types.js';
+export declare function buildOffsets(keys: (string | number)[], heightsMap: Map<string | number, number>, estimatedRowHeight: number, rowGap?: number): {
+    offsets: number[];
+    totalHeight: number;
+};
+/** Index of the row that sits at `scrollTop` — i.e. the first row whose bottom edge is below it. */
+export declare function findStartIndex(offsets: number[], scrollTop: number, itemCount: number): number;
+export declare function getVisibleRange(offsets: number[], scrollTop: number, containerHeight: number, overscan: number, itemCount: number): {
+    startIndex: number;
+    endIndex: number;
+};
+/**
+ * Decides where a dragged row should move to, applying midpoint hysteresis: a
+ * move only happens once the pointer has crossed the centre of the row it is
+ * over (downwards when moving down, upwards when moving up). Returns the target
+ * index, or null if no move should occur. Pure for easy unit testing.
+ */
+export declare function resolveReorderTarget(fromIndex: number, overIndex: number, pointerY: number, rowTop: number, rowHeight: number): number | null;
+/**
+ * Decides where a tree-reorder drop should land relative to the row under the
+ * pointer. Group rows expose three zones (top third → `before`, middle →
+ * `inside`, bottom third → `after`); leaf rows split in half (`before`/`after`)
+ * since they can't receive children. Pure for easy unit testing.
+ */
+export declare function resolveTreeDropTarget(pointerY: number, rowTop: number, rowHeight: number, isGroup: boolean): 'before' | 'inside' | 'after';
+/**
+ * Index of the last descendant of the node at `index` in a depth-tagged flat
+ * list (a contiguous run of following rows with a greater depth). Returns
+ * `index` itself when the node has no children. A drop is forbidden anywhere in
+ * `[index, lastDescendantIndex]` — that's the node and its own subtree.
+ */
+export declare function lastDescendantIndex(index: number, depths: number[]): number;
+export declare function buildColumnTemplate(columns: {
+    key: string;
+    width: ColumnWidthSpec;
+}[], fitWidths?: Record<string, number>): string;
+/**
+ * What counts as a control inside a row, and so what gets held out of the tab
+ * order while its row is not the one being used.
+ *
+ * `[tabindex="-1"]` is deliberately excluded. The row's own select checkbox sits
+ * there and is reached with Space, and an element the consumer has already taken
+ * out of the tab order stays out.
+ */
+export declare const ROW_FOCUSABLE_SELECTOR = "a[href], button:not([disabled]), input:not([disabled]), select:not([disabled]), textarea:not([disabled]), [tabindex]:not([tabindex=\"-1\"])";
+/** Marks an element parked at `tabindex="-1"` by the list rather than by the consumer. */
+export declare const ROW_PARKED_ATTRIBUTE = "data-vl-parked";
+/**
+ * What `F2` steps into: the controls of a row, including the ones parked out of
+ * the tab order. Without the second half it would find nothing at all in a row
+ * whose controls are custom elements carrying a `tabindex`, because parking them
+ * is exactly what takes them out of the selector above.
+ */
+export declare const ROW_ENTER_SELECTOR = "a[href], button:not([disabled]), input:not([disabled]), select:not([disabled]), textarea:not([disabled]), [tabindex]:not([tabindex=\"-1\"]), [data-vl-parked]";
+/**
+ * The content width of one cell, in px. `scrollWidth` reports the true content
+ * width even when the cell is pinned narrower than its content, which is what
+ * lets a column recover from having been measured while it was still empty.
+ *
+ * Two corrections on top of it, both only resolved when they can apply, so the
+ * hot scroll path stays cheap for a plain in-flow cell:
+ *
+ * - `scrollWidth` includes the left padding but drops the right one once the
+ *   content overflows, so add it back.
+ * - A cell whose only children are FontAwesome icons reports just its padding:
+ *   their boxes overflow via `overflow: visible`, carry no intrinsic width, and
+ *   so never count towards `scrollWidth` (right-aligned, they even overflow
+ *   into negative offsets). Only then walk the descendants for their true span.
+ *   Once a real width pins, the cell is no longer collapsed and this stops.
+ */
+export declare function measureCellWidth(el: HTMLElement): number;
+/** Attribute selector for one column's cells. Column keys are arbitrary strings. */
+export declare function columnCellSelector(key: string): string;
+/** Floor for a user-resized column, unless the column raises it with `minWidth`. */
+export declare const MIN_COLUMN_WIDTH = 48;
+/**
+ * Width given to a column that gains one while the layout is already frozen,
+ * i.e. one revealed from the gear menu after the first resize. Every visible
+ * column has to be an exact px track for the total width (and so the horizontal
+ * scroll range) to be exact, and there is nothing measured to go on yet.
+ */
+export declare const DEFAULT_FROZEN_WIDTH = 160;
+/**
+ * Custom property carrying one column's width. Column keys are arbitrary
+ * strings, so anything a custom property can't contain is folded to `_`; two
+ * keys that differ only in those characters would share a track.
+ */
+export declare function columnWidthVar(key: string): string;
+/** Px width for a column the user hasn't sized, at the moment the layout freezes. */
+export declare function resolveFrozenWidth<T>(col: VirtualListColumn<T>): number;
+/**
+ * Grid template for a frozen layout: every column reads its own custom property,
+ * so a drag can rewrite one width with a single DOM write and have the header
+ * and every row follow in the same layout pass, without React rendering.
+ */
+export declare function buildFrozenTemplate<T>(columns: VirtualListColumn<T>[]): string;
+export declare const COLUMN_STORAGE_PREFIX = "ahroweui:virtuallist:columns:";
+export interface PersistedColumns {
+    visible: string[];
+    known: string[];
+    /** User-resized column widths in px. Absent in entries saved before resizing existed. */
+    widths?: Record<string, number>;
+}
+export declare function loadPersistedColumns(persistKey: string | undefined): PersistedColumns | null;
+/** Whether a column should start visible, honouring saved settings then `defaultHidden`. */
+export declare function isColumnInitiallyVisible<T>(col: VirtualListColumn<T>, persisted: PersistedColumns | null): boolean;
+/** Values with no order of their own, parked at the end of the list either way. */
+export declare function isEmptySortValue(value: SortValue): boolean;
+/**
+ * Ascending comparison of two non-empty `sortValue` results. Dates and booleans
+ * are normalised to numbers; anything with a string on either side goes through
+ * the collator, which is also what makes a mixed-type column produce a stable
+ * (if arbitrary) order rather than a random one.
+ */
+export declare function compareSortValues(a: SortValue, b: SortValue): number;
+/** Whether a header click on this column should do anything at all. */
+export declare function isColumnSortable<T>(col: VirtualListColumn<T>): boolean;
+/** The asc → desc → unsorted cycle a header click steps through. */
+export declare function nextSort(current: VirtualListSort | null, key: string): VirtualListSort | null;
+/**
+ * Returns `items` reordered by `sort`, or the same array reference when nothing
+ * applies: no sort, no such column, or a `sortable` column that only reports
+ * (its data is sorted by the consumer). Callers rely on that identity to tell
+ * "the list sorted this" from "the list left it alone".
+ */
+export declare function sortItems<T>(items: T[], sort: VirtualListSort | null | undefined, columns: VirtualListColumn<T>[] | undefined): T[];

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

@@ -0,0 +1,35 @@
+import { default as React } from 'react';
+import { UseColumnsResult } from './useColumns.js';
+import { UseColumnResizeResult } from './useColumnResize.js';
+import { SlotClassNames, SlotStyles } from '../types/slots.types.js';
+import { VirtualListColumn, VirtualListLabels, VirtualListSlots, VirtualListSort } from './virtualList.types.js';
+interface VirtualListHeaderProps<T> {
+    headerRef: React.RefObject<HTMLDivElement | null>;
+    /** Every column, including hidden ones: the toggle menu lists them all. */
+    columns: VirtualListColumn<T>[];
+    cols: UseColumnsResult<T>;
+    resize: UseColumnResizeResult<T>;
+    sort: VirtualListSort | null;
+    onSort: (key: string) => void;
+    multiSelect: boolean;
+    allSelected: boolean;
+    someSelected: boolean;
+    onSelectAll: () => void;
+    labels: Required<VirtualListLabels>;
+    classNames?: SlotClassNames<VirtualListSlots>;
+    styles?: SlotStyles<VirtualListSlots>;
+}
+/**
+ * The table-mode header row: one cell per visible column, each optionally a sort
+ * button and a resize handle, plus the column-visibility menu pinned to the
+ * right. It is a grid with the same template as every row, which is what keeps
+ * the columns aligned across the separate grids.
+ *
+ * The whole header is a single tab stop (see `useHeaderNavigation`). Focus lands
+ * on a header cell rather than on the button inside it, so every key a column
+ * understands is handled in one place: Enter or Space sorts, Alt plus the arrow
+ * keys resizes, Alt+Home and Alt+End take the column to its minimum or to its
+ * content width.
+ */
+declare function VirtualListHeader<T>({ headerRef, columns, cols, resize, sort, onSort, multiSelect, allSelected, someSelected, onSelectAll, labels, classNames, styles: slotStyles, }: VirtualListHeaderProps<T>): React.JSX.Element;
+export default VirtualListHeader;

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

@@ -0,0 +1,62 @@
+import { default as React } from 'react';
+import { TreeDropPosition } from './virtualList.types.js';
+export interface VirtualRowProps {
+    index: number;
+    /** Referenced by the list's `aria-activedescendant` while this row is active. */
+    id?: string;
+    top: number;
+    /** Padding applied to the row (already normalised to a CSS string). */
+    padding?: string;
+    columnTemplate: string | undefined;
+    isSelected: boolean;
+    /** The row the arrow keys are on. Distinct from selection. */
+    isActive?: boolean;
+    /**
+     * Hold this row's own controls out of the tab order unless it is the row being
+     * used. Off when the list leaves the keyboard to its rows.
+     */
+    manageTabStops?: boolean;
+    /** This is the row being used, so its controls are reachable with Tab. */
+    isEntered?: boolean;
+    activeClassName?: string;
+    activeStyle?: React.CSSProperties;
+    showDivider: boolean;
+    hover: boolean;
+    onClick: () => void;
+    observer: ResizeObserver | null;
+    ariaRowIndex?: number;
+    ariaPosInSet?: number;
+    ariaSetSize?: number;
+    rowRole: string;
+    reorderable?: boolean;
+    /**
+     * Native mouse DnD is active for the list. Distinct from `draggable`, which in
+     * `dragHandle` mode is only set on the row the pointer has armed.
+     */
+    mouseDragEnabled?: boolean;
+    draggable?: boolean;
+    isDragging?: boolean;
+    reserveToggleGutter?: boolean;
+    onMouseDown?: (e: React.MouseEvent<HTMLDivElement>) => void;
+    onMouseOver?: (e: React.MouseEvent<HTMLDivElement>) => void;
+    onMouseLeave?: (e: React.MouseEvent<HTMLDivElement>) => void;
+    onDragStart?: (e: React.DragEvent<HTMLDivElement>) => void;
+    onDragOver?: (e: React.DragEvent<HTMLDivElement>) => void;
+    onDragEnd?: () => void;
+    onDrop?: (e: React.DragEvent<HTMLDivElement>) => void;
+    onTouchStart?: (e: React.TouchEvent<HTMLDivElement>) => void;
+    dropPosition?: TreeDropPosition;
+    dropIndentPx?: number;
+    dropIndicatorClassName?: string;
+    dropIndicatorStyle?: React.CSSProperties;
+    rowClassName?: string;
+    rowStyle?: React.CSSProperties;
+    children: React.ReactNode;
+}
+/**
+ * A single virtualized row: absolutely positioned at its `top`, optionally a
+ * grid (table mode), registering itself with the shared ResizeObserver and
+ * carrying all the drag / drop-indicator wiring the parent assigns it.
+ */
+declare function VirtualRow({ index, id, top, padding, columnTemplate, isSelected, isActive, manageTabStops, isEntered, activeClassName, activeStyle, showDivider, hover, onClick, observer, ariaRowIndex, ariaPosInSet, ariaSetSize, rowRole, reorderable, mouseDragEnabled, draggable, isDragging, reserveToggleGutter, onMouseDown, onMouseOver, onMouseLeave, onDragStart, onDragOver, onDragEnd, onDrop, onTouchStart, dropPosition, dropIndentPx, dropIndicatorClassName, dropIndicatorStyle, rowClassName, rowStyle, children, }: VirtualRowProps): React.JSX.Element;
+export default VirtualRow;

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

@@ -0,0 +1 @@
+export { default } from './wizard.js';

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

@@ -0,0 +1,3 @@
+import { default as React } from 'react';
+import { WizardProps } from './wizard.types.js';
+export default function Wizard({ currentStep, stepCount, renderStep, className, style, classNames, styles: slotStyles, ...rest }: WizardProps): React.JSX.Element;

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

@@ -0,0 +1,12 @@
+import { default as React } from 'react';
+import { SlotClassNames, SlotStyles, HtmlProps } from '../types/slots.types.js';
+export type WizardSlots = 'root' | 'container' | 'step' | 'stepContent';
+export interface WizardProps extends HtmlProps {
+    currentStep?: number;
+    stepCount?: number;
+    renderStep?: (index: number) => React.ReactNode;
+    className?: string;
+    style?: React.CSSProperties;
+    classNames?: SlotClassNames<WizardSlots>;
+    styles?: SlotStyles<WizardSlots>;
+}

package/dist/cjs-types/hooks/useWindowSize.d.ts

@@ -0,0 +1,6 @@
+export interface WindowSize {
+    width: number;
+    height: number;
+    isMobileSize: boolean;
+}
+export default function useWindowSize(): WindowSize;