@ahrowe/ui 0.35.0 → 0.37.0

package/dist/types/common/timeline/index.d.ts

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

package/dist/types/common/timeline/timeline.d.ts

@@ -1,3 +1,3 @@
 import { default as React } from 'react';
-import { TimelineProps } from './timeline.types';
+import { TimelineProps } from './timeline.types.js';
 export default function Timeline({ items, alignment, className, style, classNames, styles: slotStyles, ...rest }: TimelineProps): React.JSX.Element;

package/dist/types/common/timeline/timeline.types.d.ts

@@ -1,6 +1,6 @@
 import { default as React } from 'react';
-import { IconContent } from '../types/icon.types';
-import { SlotClassNames, SlotStyles, HtmlProps } from '../types/slots.types';
+import { IconContent } from '../types/icon.types.js';
+import { SlotClassNames, SlotStyles, HtmlProps } from '../types/slots.types.js';
 /** Layout of entries relative to the connecting line. */
 export declare enum TimelineAlignment {
     /** Line and markers on the left, content to the right (the default). */

package/dist/types/common/timer/index.d.ts

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

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

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

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

@@ -1,5 +1,5 @@
 import { CSSProperties, ReactNode, Ref } from 'react';
-import { SlotClassNames, SlotStyles, HtmlProps } from '../types/slots.types';
+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 {
@@ -68,7 +68,7 @@ export interface TimerProps extends HtmlProps {
     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`. @default '160px' */
+    /** 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;

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

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

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

@@ -1,5 +1,5 @@
 import { default as React } from 'react';
-import { ToastItem, ToastLabels } from './toast.types';
+import { ToastItem, ToastLabels } from './toast.types.js';
 interface ToastProps {
     item: ToastItem;
     isBottom: boolean;

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

@@ -1,5 +1,5 @@
 import { ReactNode } from 'react';
-import { SlotClassNames, SlotStyles } from '../types/slots.types';
+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';

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

@@ -1,5 +1,5 @@
 import { default as React, ReactNode } from 'react';
-import { ToastContextConfig } from './toast.types';
+import { ToastContextConfig } from './toast.types.js';
 interface ToastProviderProps extends ToastContextConfig {
     children: ReactNode;
 }

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

@@ -1,5 +1,5 @@
 import { ReactNode } from 'react';
-import { ToastOptions } from './toast.types';
+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;

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

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

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

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

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

@@ -1,3 +1,3 @@
-import { FlatTreeNode, TreeNode, TreeValue } from './tree.types';
+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/types/common/tree/index.d.ts

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

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

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

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

@@ -1,6 +1,6 @@
 import { CSSProperties, ReactNode } from 'react';
-import { IconContent } from '../types/icon.types';
-import { SlotClassNames, SlotStyles, HtmlProps } from '../types/slots.types';
+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;

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

@@ -1,4 +1,4 @@
-import { IconContent } from './icon.types';
+import { IconContent } from './icon.types.js';
 /** A single icon-triggered action, rendered as an `ActionIcon` */
 export interface IconAction {
     title?: string;

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

@@ -1,4 +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';
+export type { HtmlProps, DataProps } from './baseProps.types.js';

package/dist/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/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/types/common/utils/renderIcon.d.ts

@@ -1,6 +1,6 @@
 import { CSSProperties, ReactNode } from 'react';
 import { IconDefinition } from '@fortawesome/fontawesome-svg-core';
-import { IconContent } from '../types/icon.types';
+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;

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

@@ -1,2 +1,12 @@
 export declare function getScrollableAncestors(el: HTMLElement): HTMLElement[];
 export declare function isHiddenByAnyAncestor(rect: DOMRect, ancestors: HTMLElement[]): boolean;
+/**
+ * The ancestor whose scrollbar carries `el`, or null when that is the page.
+ * `Sticky` pins against it and `VirtualList` virtualizes against it, and the two
+ * have to agree or a sticky header and the rows under it come apart.
+ *
+ * Narrower than `getScrollableAncestors` above, which is about who *clips* and so
+ * counts `hidden` too: a `hidden` box never scrolls, so pinning to it would pin
+ * to something that never moves.
+ */
+export declare function getScrollParent(el: HTMLElement | null): HTMLElement | null;

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

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

package/dist/types/common/virtualList/scroller.d.ts

@@ -0,0 +1,33 @@
+import { VirtualListScrollParent } from './virtualList.types.js';
+/**
+ * Whatever carries the list's scroll, and how the list is measured against it.
+ *
+ * Everything here works in *list space*: offset 0 is the top of the first row,
+ * which is the root's `scrollTop` when the list scrolls itself and its distance
+ * above the scrollport's top edge when it doesn't. One coordinate system, so the
+ * windowing, anchoring and jump math never branch.
+ */
+export type Scroller = HTMLElement | Window;
+export declare function isWindowScroller(scroller: Scroller): scroller is Window;
+/** `'nearest'` is resolved by the caller, which caches the ancestor walk. */
+export declare function resolveScroller(scrollParent: Exclude<VirtualListScrollParent, 'nearest'> | undefined): Scroller | null;
+/** In viewport coordinates, which is what the rects below are compared against. */
+export declare function scrollportBounds(scroller: Scroller): {
+    top: number;
+    height: number;
+};
+export interface Viewport {
+    /** List-space scroll position, unclamped: negative while the list starts below
+     *  the scrollport, which is what makes a target reachable from either side. */
+    rel: number;
+    /** The slice of the scrollport the list occupies now. */
+    visibleHeight: number;
+    /** The whole scrollport, which is what a scroll target is aimed within. */
+    viewportHeight: number;
+    /** From the list's last row to the end of the scrollport. The browser clamps
+     *  `scrollTop`, so a list that scrolls itself never reports this negative;
+     *  riding a scrollport, it does, for the whole rest of the page. */
+    distanceToEnd: number;
+    width: number;
+}
+export declare function measureViewport(root: HTMLElement, scroller: Scroller | null): Viewport;

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

@@ -1,5 +1,5 @@
 import { default as React } from 'react';
-import { VirtualListColumn } from './virtualList.types';
+import { VirtualListColumn } from './virtualList.types.js';
 interface UseColumnResizeArgs<T> {
     columns?: VirtualListColumn<T>[];
     /**

package/dist/types/common/virtualList/useColumns.d.ts

@@ -1,5 +1,5 @@
 import { default as React } from 'react';
-import { VirtualListColumn } from './virtualList.types';
+import { VirtualListColumn } from './virtualList.types.js';
 interface UseColumnsArgs<T> {
     columns?: VirtualListColumn<T>[];
     items: T[];

package/dist/types/common/virtualList/useRowDrag.d.ts

@@ -1,5 +1,6 @@
 import { default as React } from 'react';
-import { TreeDropPosition, TreeDropTarget } from './virtualList.types';
+import { TreeDropPosition, TreeDropTarget } from './virtualList.types.js';
+import { ListViewportRect } from './useVirtualWindow.js';
 interface UseRowDragArgs {
     reorderable: boolean;
     treeReorder: boolean;
@@ -15,6 +16,10 @@ interface UseRowDragArgs {
     rootRef: React.RefObject<HTMLDivElement | null>;
     /** Latest keys for async (touch / rAF) consumers — owned by useVirtualWindow. */
     keysRef: React.RefObject<(string | number)[]>;
+    /** Where the list is on screen, which is not its own box once it rides a
+     *  scrollport — owned by useVirtualWindow, as is `scrollBy`. */
+    getVisibleRect: () => ListViewportRect | null;
+    scrollBy: (dy: number) => void;
 }
 /** The drag-related props the parent spreads onto a given row. */
 export interface RowDragProps {
@@ -54,5 +59,5 @@ interface UseRowDragResult {
  * Touch uses a long-press → lifted-clone → pointer-move path with edge
  * auto-scroll. `dragHandle` restricts initiation to `[data-drag-handle]`.
  */
-export declare function useRowDrag({ reorderable, treeReorder, onReorder, onTreeDrop, longPressDelay, dragHandle, treeIndentPx, keys, depths, isGroupAt, rootRef, keysRef, }: UseRowDragArgs): UseRowDragResult;
+export declare function useRowDrag({ reorderable, treeReorder, onReorder, onTreeDrop, longPressDelay, dragHandle, treeIndentPx, keys, depths, isGroupAt, rootRef, keysRef, getVisibleRect, scrollBy, }: UseRowDragArgs): UseRowDragResult;
 export {};

package/dist/types/common/virtualList/useRowNavigation.d.ts

@@ -1,12 +1,18 @@
 import { default as React } from 'react';
-import { VirtualListScrollOptions } from './virtualList.types';
+import { VirtualListScrollOptions } from './virtualList.types.js';
+import { VisibleSlice } from './useVirtualWindow.js';
 interface UseRowNavigationArgs {
     enabled: boolean;
+    tabAcrossRows: boolean;
     rowCount: number;
     /** Row tops, from the windowing engine, used for paging and visibility. */
     offsets: number[];
     rootRef: React.RefObject<HTMLDivElement | null>;
     headerRef: React.RefObject<HTMLDivElement | null>;
+    /** Read live: a held arrow key moves the slice faster than the state commits. */
+    getVisibleSlice: () => VisibleSlice;
+    /** The whole scrollport, which is what one PageDown covers. */
+    viewportHeight: number;
     scrollToIndex: (index: number, options?: VirtualListScrollOptions) => void;
     /** Row index the active row starts on, normally the selected one. */
     initialIndex: number;
@@ -45,6 +51,10 @@ interface UseRowNavigationResult {
  * hold an input, a dropdown or a button, and every one of them wants the arrows,
  * Enter and Space for itself. `F2` steps into such a row and `Escape` steps back
  * out, which is the one pair of keys that does work from inside a cell.
+ *
+ * `tabAcrossRows` adds the second pair, Tab and Shift+Tab, which the browser
+ * cannot carry across a row boundary itself: the next row may not be in the DOM
+ * when it looks for the next stop.
  */
-export declare function useRowNavigation({ enabled, rowCount, offsets, rootRef, headerRef, scrollToIndex, initialIndex, multiSelect, onActivate, onToggleSelect, }: UseRowNavigationArgs): UseRowNavigationResult;
+export declare function useRowNavigation({ enabled, tabAcrossRows, rowCount, offsets, rootRef, headerRef, getVisibleSlice, viewportHeight, scrollToIndex, initialIndex, multiSelect, onActivate, onToggleSelect, }: UseRowNavigationArgs): UseRowNavigationResult;
 export {};

package/dist/types/common/virtualList/useSorting.d.ts

@@ -1,4 +1,4 @@
-import { VirtualListColumn, VirtualListSort } from './virtualList.types';
+import { VirtualListColumn, VirtualListSort } from './virtualList.types.js';
 interface UseSortingArgs<T> {
     items: T[];
     columns?: VirtualListColumn<T>[];

package/dist/types/common/virtualList/useVirtualWindow.d.ts

@@ -1,5 +1,5 @@
 import { default as React } from 'react';
-import { VirtualListHandle } from './virtualList.types';
+import { VirtualListHandle, VirtualListScrollParent } from './virtualList.types.js';
 interface UseVirtualWindowArgs<T> {
     items: T[];
     /** Stable key per row (already derived by the caller). */
@@ -12,6 +12,19 @@ interface UseVirtualWindowArgs<T> {
     loadMoreThreshold: number;
     /** Initial/filter load in progress — the body is replaced by a spinner. */
     isLoading: boolean;
+    scrollParent?: VirtualListScrollParent;
+}
+/** Where the list is on screen, which is not its own box once it rides a scrollport. */
+export interface ListViewportRect {
+    top: number;
+    bottom: number;
+    left: number;
+    right: number;
+}
+/** The list-space slice currently on screen, read live for keyboard navigation. */
+export interface VisibleSlice {
+    top: number;
+    height: number;
 }
 interface UseVirtualWindowResult {
     rootRef: React.RefObject<HTMLDivElement | null>;
@@ -22,15 +35,21 @@ interface UseVirtualWindowResult {
     keysRef: React.RefObject<(string | number)[]>;
     offsets: number[];
     totalHeight: number;
+    /** The list's visible slice, which is what decides which rows are rendered. */
     containerHeight: number;
+    /** The whole scrollport, which is what a scroll target is aimed within. */
+    viewportHeight: number;
     containerWidth: number;
     startIndex: number;
     endIndex: number;
-    handleScroll: (e: React.UIEvent<HTMLDivElement>) => void;
     showLoadMoreSpinner: boolean;
+    isWindowed: boolean;
+    getVisibleSlice: () => VisibleSlice;
+    getVisibleRect: () => ListViewportRect | null;
+    scrollBy: (dy: number) => void;
     /** The scroll-related imperative methods, for the component to compose into
      *  the forwarded handle alongside column controls. */
     scrollApi: Omit<VirtualListHandle, 'recalculateColumns' | 'resetColumnWidths'>;
 }
-export declare function useVirtualWindow<T>({ items, keys, getItemKey, estimatedRowHeight, rowGap, overscan, onLoadMore, loadMoreThreshold, isLoading, }: UseVirtualWindowArgs<T>): UseVirtualWindowResult;
+export declare function useVirtualWindow<T>({ items, keys, getItemKey, estimatedRowHeight, rowGap, overscan, onLoadMore, loadMoreThreshold, isLoading, scrollParent, }: UseVirtualWindowArgs<T>): UseVirtualWindowResult;
 export {};

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

@@ -1,5 +1,5 @@
 import { default as React } from 'react';
-import { VirtualListProps } from './virtualList.types';
-export { buildOffsets, findStartIndex, getVisibleRange, resolveReorderTarget, resolveTreeDropTarget, lastDescendantIndex, buildColumnTemplate, compareSortValues, isColumnSortable, isEmptySortValue, nextSort, sortItems, } from './virtualList.utils';
-declare function VirtualList<T>({ ref, items, renderRow, ariaRoles, columns, height, estimatedRowHeight, overscan, rowGap, rowPadding, selectedKey, getItemKey, onRowClick, keyboardNavigation, visibleColumnKeys, onVisibleColumnsChange, persistColumnsKey, resizableColumns, columnWidths, onColumnWidthsChange, labels, sort, defaultSort, onSortChange, showColumnToggle, onLoadMore, loadMoreThreshold, isLoading, multiSelect, selectedKeys, onSelectionChange, reorderable, onReorder, longPressDelay, treeReorder, getItemDepth, isGroup, onTreeDrop, treeIndentPx, dragHandle, showDivider, rowHover, className, style, classNames, styles: slotStyles, ...rest }: VirtualListProps<T>): React.JSX.Element;
+import { VirtualListProps } from './virtualList.types.js';
+export { buildOffsets, findStartIndex, getVisibleRange, resolveReorderTarget, resolveTreeDropTarget, lastDescendantIndex, buildColumnTemplate, compareSortValues, isColumnSortable, isEmptySortValue, nextSort, sortItems, } from './virtualList.utils.js';
+declare function VirtualList<T>(props: VirtualListProps<T>): React.JSX.Element;
 export default VirtualList;

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

@@ -1,5 +1,5 @@
 import { CSSProperties, ReactNode, Ref } from 'react';
-import { SlotClassNames, SlotStyles, HtmlProps } from '../types/slots.types';
+import { SlotClassNames, SlotStyles, HtmlProps } from '../types/slots.types.js';
 export type ColumnWidthFixed = {
     type: 'fixed';
     px: number;
@@ -74,6 +74,13 @@ export interface VirtualListColumn<T> {
      */
     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';
@@ -88,8 +95,18 @@ export interface VirtualListHandle {
     scrollToKey: (key: string | number, options?: VirtualListScrollOptions) => void;
     /** Scroll back to the top. */
     scrollToTop: (options?: Pick<VirtualListScrollOptions, 'behavior'>) => void;
-    /** The underlying scroll container element, for advanced use. */
-    getScrollElement: () => HTMLDivElement | null;
+    /**
+     * 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`
@@ -143,8 +160,22 @@ export interface VirtualListProps<T> extends HtmlProps {
         container: string;
         row: string;
     };
-    /** Height of the scroll viewport. Defaults to '100%' to fill the parent container. */
+    /** 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. */
@@ -187,6 +218,15 @@ export interface VirtualListProps<T> extends HtmlProps {
      * `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. */

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

@@ -1,4 +1,4 @@
-import { ColumnWidthSpec, SortValue, VirtualListColumn, VirtualListSort } from './virtualList.types';
+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;

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

@@ -1,8 +1,8 @@
 import { default as React } from 'react';
-import { UseColumnsResult } from './useColumns';
-import { UseColumnResizeResult } from './useColumnResize';
-import { SlotClassNames, SlotStyles } from '../types/slots.types';
-import { VirtualListColumn, VirtualListLabels, VirtualListSlots, VirtualListSort } from './virtualList.types';
+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. */

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

@@ -1,5 +1,5 @@
 import { default as React } from 'react';
-import { TreeDropPosition } from './virtualList.types';
+import { TreeDropPosition } from './virtualList.types.js';
 export interface VirtualRowProps {
     index: number;
     /** Referenced by the list's `aria-activedescendant` while this row is active. */

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

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

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

@@ -1,3 +1,3 @@
 import { default as React } from 'react';
-import { WizardProps } from './wizard.types';
+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/types/common/wizard/wizard.types.d.ts

@@ -1,5 +1,5 @@
 import { default as React } from 'react';
-import { SlotClassNames, SlotStyles, HtmlProps } from '../types/slots.types';
+import { SlotClassNames, SlotStyles, HtmlProps } from '../types/slots.types.js';
 export type WizardSlots = 'root' | 'container' | 'step' | 'stepContent';
 export interface WizardProps extends HtmlProps {
     currentStep?: number;