@ahrowe/ui 0.36.0 → 0.38.0

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

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

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

@@ -0,0 +1,42 @@
+import { CSSProperties } from 'react';
+import { MenuEntry } from '../menu/menu.types.js';
+import { Presentation } from '../configProvider/presentation.types.js';
+import { SlotClassNames, SlotStyles, HtmlProps } from '../types/slots.types.js';
+export type CommandPaletteSlots = 'root' | 'search' | 'input' | 'list' | 'item' | 'itemIcon' | 'itemLabel' | 'itemShortcut' | 'heading' | 'separator' | 'empty';
+export interface CommandPaletteLabels {
+    /** Accessible name of the dialog and the search field. Default: "Search commands". */
+    label?: string;
+    /** Placeholder in the search field. Default: "Type a command or search…". */
+    placeholder?: string;
+    /** Shown when nothing matches. Default: "No results". */
+    empty?: string;
+    /** Shown while `isLoading` and nothing matches yet. Default: "Searching…". */
+    loading?: string;
+    /** Announced to screen readers as the matches change. */
+    results?: (count: number) => string;
+}
+export interface CommandPaletteProps extends HtmlProps<HTMLDivElement> {
+    /** The commands, in the same shape `Menu` takes. Headings group them; separators split groups. */
+    items: MenuEntry[];
+    isOpen: boolean;
+    onClose: () => void;
+    /** Called with the id of the command that was run, after its own `onClick`. */
+    onAction?: (id: string) => void;
+    /** Called on every keystroke, and with `''` each time the palette opens. */
+    onQueryChange?: (query: string) => void;
+    /**
+     * Filter `items` by the query. Default `true`. Set `false` when `items` are already the results,
+     * e.g. fetched from a server in `onQueryChange`.
+     */
+    filter?: boolean;
+    /** Shows the `loading` label instead of `empty` while nothing matches. */
+    isLoading?: boolean;
+    /** Centred dialog, bottom sheet, or a sheet only on a small touch screen. */
+    presentation?: Presentation;
+    /** Text this component renders of its own. */
+    labels?: CommandPaletteLabels;
+    className?: string;
+    style?: CSSProperties;
+    classNames?: SlotClassNames<CommandPaletteSlots>;
+    styles?: SlotStyles<CommandPaletteSlots>;
+}

package/dist/types/common/commandPalette/filterCommands.d.ts

@@ -0,0 +1,15 @@
+import { ReactNode } from 'react';
+import { MenuAction, MenuEntry } from '../menu/menu.types.js';
+export interface CommandGroup {
+    heading?: ReactNode;
+    /** Whether a separator started this group, so the divider can be drawn above it. */
+    separated: boolean;
+    actions: MenuAction[];
+}
+/** Splits entries into groups at each heading and separator, keeping their order. */
+export declare function groupCommands(items: MenuEntry[]): CommandGroup[];
+/**
+ * The groups with only the actions matching `query`, best matches first within each group, and
+ * the group holding the best match first. A heading moves with its group, never away from it.
+ */
+export declare function filterCommands(groups: CommandGroup[], query: string): CommandGroup[];

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

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

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

@@ -15,6 +15,9 @@ import { SearchInputLabels } from '../searchInput/searchInput.types.js';
 import { TooltipLabels } from '../tooltip/tooltip.types.js';
 import { VirtualListLabels } from '../virtualList/virtualList.types.js';
 import { ButtonProps } from '../button/button.types.js';
+import { CopyButtonProps } from '../copyButton/copyButton.types.js';
+import { CommandPaletteProps } from '../commandPalette/commandPalette.types.js';
+import { WeatherIconProps } from '../weatherIcon/weatherIcon.types.js';
 import { ActionButtonsProps } from '../actionButtons/actionButtons.types.js';
 import { ConfirmModalProps } from '../confirmModal/confirmModal.types.js';
 import { BadgeProps } from '../badge/badge.types.js';
@@ -91,6 +94,7 @@ export interface ComponentDefaults {
     RadioGroup?: Partial<RadioGroupProps>;
     DatePicker?: Partial<DatePickerProps>;
     Button?: Partial<ButtonProps>;
+    CopyButton?: Partial<CopyButtonProps>;
     ActionButtons?: Partial<ActionButtonsProps>;
     ConfirmModal?: Partial<ConfirmModalProps>;
     Badge?: Partial<BadgeProps>;
@@ -118,6 +122,8 @@ export interface ComponentDefaults {
     RoomViewer?: Partial<RoomViewerProps>;
     Popover?: Partial<PopoverProps>;
     Modal?: Partial<ModalProps>;
+    CommandPalette?: Partial<CommandPaletteProps>;
+    WeatherIcon?: Partial<WeatherIconProps>;
 }
 export interface ConfigProviderProps {
     children: React.ReactNode;

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

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

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

@@ -0,0 +1,36 @@
+import { CSSProperties, MouseEvent, Ref } from 'react';
+import { IconContent } from '../types/icon.types.js';
+import { SlotClassNames, SlotStyles, HtmlProps } from '../types/slots.types.js';
+export type CopyButtonSlots = 'root' | 'icon';
+export interface CopyButtonLabels {
+    /** Accessible name and tooltip before copying. Default: "Copy". */
+    copy?: string;
+    /** Accessible name and tooltip after a successful copy, also announced. Default: "Copied". */
+    copied?: string;
+    /** Announced when the copy fails. Default: "Could not copy". */
+    failed?: string;
+}
+export interface CopyButtonProps extends Omit<HtmlProps<HTMLDivElement>, 'onCopy' | 'onError'> {
+    /** Text written to the clipboard on click. */
+    value: string;
+    /** How long the copied state shows, in ms. Default: 2000. */
+    timeout?: number;
+    /** Icon before copying. Default: `faCopy`. */
+    icon?: IconContent;
+    /** Icon while the copied state shows. Default: `faCheck`. */
+    copiedIcon?: IconContent;
+    /** Called after a successful copy. */
+    onCopy?: (value: string) => void;
+    /** Called when the clipboard refuses the write, e.g. outside a secure context. */
+    onError?: () => void;
+    /** Called on every click, before the copy. */
+    onClick?: (event: MouseEvent<HTMLDivElement>) => void;
+    /** Text this component renders of its own. */
+    labels?: CopyButtonLabels;
+    /** Ref to the root element. */
+    ref?: Ref<HTMLDivElement>;
+    className?: string;
+    style?: CSSProperties;
+    classNames?: SlotClassNames<CopyButtonSlots>;
+    styles?: SlotStyles<CopyButtonSlots>;
+}

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

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

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

@@ -2,13 +2,10 @@ import { default as React } from 'react';
 import { ErrorBoundaryProps, ErrorBoundaryState } from './errorBoundary.types.js';
 declare class ErrorBoundary extends React.Component<ErrorBoundaryProps, ErrorBoundaryState> {
     state: ErrorBoundaryState;
-    private copyResetTimeout;
     static getDerivedStateFromError(error: Error): Partial<ErrorBoundaryState>;
     componentDidCatch(error: Error, errorInfo: React.ErrorInfo): void;
     componentDidUpdate(prevProps: ErrorBoundaryProps): void;
-    componentWillUnmount(): void;
     private reset;
-    private copyStackTrace;
     render(): React.ReactNode;
 }
 export default ErrorBoundary;

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

@@ -13,9 +13,9 @@ export interface ErrorBoundaryFallbackProps {
 export interface ErrorBoundaryLabels {
     /** Accordion header for the stack trace section. Default: "Stack trace". */
     stackTrace?: string;
-    /** Copy button label before copying. Default: "Copy". */
+    /** Copy button's tooltip and accessible name before copying. Default: "Copy". */
     copy?: string;
-    /** Copy button label right after a successful copy. Default: "Copied". */
+    /** Copy button's tooltip and accessible name right after a successful copy. Default: "Copied". */
     copied?: string;
     /** Reset button label. Default: "Try again". */
     reset?: string;
@@ -53,5 +53,4 @@ export interface ErrorBoundaryProps extends Omit<HtmlProps, 'title' | 'onError'>
 export interface ErrorBoundaryState {
     error: Error | null;
     errorInfo: ErrorInfo | null;
-    copied: boolean;
 }

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

@@ -0,0 +1,15 @@
+export { useHotkeys, formatHotkey } from './useHotkeys.js';
+export type { HotkeyHandler, HotkeyMap, UseHotkeysOptions } from './useHotkeys.js';
+export { useMediaQuery } from './useMediaQuery.js';
+export { useCoarsePointer } from './useCoarsePointer.js';
+export { useVisualViewportSize } from './useVisualViewportSize.js';
+export type { VisualViewportSize } from './useVisualViewportSize.js';
+export { useScrollEdges } from './useScrollEdges.js';
+export type { ScrollEdges, ScrollEdgesOptions } from './useScrollEdges.js';
+export { useSwipeDismiss } from './useSwipeDismiss.js';
+export type { UseSwipeDismissOptions, UseSwipeDismissResult } from './useSwipeDismiss.js';
+export { useOverlay } from './useOverlay.js';
+export type { UseOverlayArgs } from './useOverlay.js';
+export { tabbablesIn } from './useFocusBoundary.js';
+export { useClipboard } from './useClipboard.js';
+export type { UseClipboardOptions, UseClipboardResult } from './useClipboard.js';

package/dist/types/common/hooks/useClipboard.d.ts

@@ -0,0 +1,16 @@
+export interface UseClipboardOptions {
+    /** How long `copied` stays `true` after a successful copy, in ms. Default: 2000. */
+    timeout?: number;
+}
+export interface UseClipboardResult {
+    /** Writes `text` to the clipboard. Resolves `true` on success, `false` on failure. */
+    copy: (text: string) => Promise<boolean>;
+    /** `true` for `timeout` ms after a successful copy. */
+    copied: boolean;
+    /** Why the last copy failed, until the next attempt. */
+    error: Error | null;
+    /** Clears `copied` and `error` early. */
+    reset: () => void;
+}
+export declare function useClipboard({ timeout }?: UseClipboardOptions): UseClipboardResult;
+export default useClipboard;

package/dist/types/common/hooks/useHotkeys.d.ts

@@ -0,0 +1,45 @@
+import { RefObject } from 'react';
+export type HotkeyHandler = (event: KeyboardEvent) => void;
+/** Combo → handler, e.g. `{ 'mod+k': open, Escape: close }`. */
+export type HotkeyMap = Record<string, HotkeyHandler>;
+export interface UseHotkeysOptions {
+    /** Attach the listener at all. Default `true`; pass `false` to suspend every combo at once. */
+    enabled?: boolean;
+    /** Scope the shortcuts to one element instead of the whole window. */
+    target?: RefObject<HTMLElement | null>;
+    /**
+     * Let plain-key combos fire while a text field or `contenteditable` has focus. Default `false`,
+     * so `'n'` does not fire for every `n` typed into an input. Combos carrying Ctrl, Cmd or Alt
+     * are never suppressed — they cannot be confused with typing.
+     */
+    enableInFields?: boolean;
+    /**
+     * Call `preventDefault()` on a match, so `mod+s` does not also open the browser's save dialog.
+     * Default `true`.
+     */
+    preventDefault?: boolean;
+}
+/**
+ * A combo written for the reader: `'mod+shift+k'` reads `⇧⌘K` on an Apple platform and
+ * `Ctrl+Shift+K` everywhere else.
+ *
+ * So a shortcut is written once, in one spelling, and the hint beside it cannot contradict what
+ * the binding actually listens for. Hand-written `'⌘K'` hints are wrong on every other platform,
+ * silently, because nothing compares the label to the binding.
+ *
+ * Resolved from the platform at call time, so a server-rendered page renders the non-Apple form.
+ */
+export declare function formatHotkey(combo: string): string;
+/**
+ * Keyboard shortcuts, for a whole app or for one element.
+ *
+ * ```tsx
+ * useHotkeys({ 'mod+k': () => setPaletteOpen(true), '?': () => setHelpOpen(true) });
+ * ```
+ *
+ * The map is read through a ref at event time, so an inline object literal is fine and no handler
+ * needs memoising. Shortcuts keep firing while a Modal or Drawer is open — pass `enabled` for the
+ * ones that should not.
+ */
+export declare function useHotkeys(hotkeys: HotkeyMap, options?: UseHotkeysOptions): void;
+export default useHotkeys;

package/dist/types/common/hooks/useSwipeDismiss.d.ts

@@ -19,8 +19,12 @@ export interface UseSwipeDismissOptions {
 }
 export interface UseSwipeDismissResult<T extends HTMLElement> {
     /** Attach to the element that should become draggable. The hook wires up its own pointer
-     * listeners on this node directly (no handlers to spread), so this is the only thing to attach. */
-    ref: React.RefObject<T | null>;
+     * listeners on this node directly (no handlers to spread), so this is the only thing to attach.
+     *
+     * A callback ref rather than an object one, because the hook has to know when the node changes:
+     * an element that is unmounted and rendered again is a *different* node, and a ref object cannot
+     * say so. To keep a ref of your own on the element, call both from one callback. */
+    ref: React.RefCallback<T>;
     /** True for the duration of an active drag — e.g. use it to pause an auto-dismiss timer. */
     isDragging: boolean;
 }

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

@@ -1,7 +1,11 @@
 import { default as React } from 'react';
 import { SlotClassNames, SlotStyles, HtmlProps } from '../types/slots.types.js';
 import { FormValidator } from '../../services/formValidation/index.js';
-export type InputDropdownSlots = 'root' | 'dropdown' | 'item';
+export type InputDropdownSlots = 'root' | 'dropdown' | 'item' | 'empty';
+export interface InputDropdownLabels {
+    /** Shown when nothing matches the typed text and `allowCustomValue` is off (default `No matches`). */
+    empty?: string;
+}
 export interface InputDropdownItem {
     label?: string;
     value: string;
@@ -29,6 +33,8 @@ export interface InputDropdownProps extends Omit<HtmlProps, 'onSelect'> {
     onChange?: (value: unknown) => void;
     placeholder?: string;
     readOnly?: boolean;
+    /** Overrides the text InputDropdown renders of its own. Merged per key. */
+    labels?: InputDropdownLabels;
     className?: string;
     style?: React.CSSProperties;
     classNames?: SlotClassNames<InputDropdownSlots>;

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

@@ -1,2 +1 @@
-export { default as IconLoading } from './iconLoading/index.js';
 export { default as SpinnerLoading } from './spinnerLoading/index.js';

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

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

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

@@ -10,10 +10,18 @@ export interface MenuAction {
     label: ReactNode;
     icon?: IconContent;
     /**
-     * Keyboard hint on the trailing edge, e.g. `⌘K`. Display only: binding the
-     * shortcut is yours, since only you know what else is listening.
+     * A keyboard shortcut for this action, in `useHotkeys` spelling: `'mod+k'`,
+     * `'shift+f2'`, `'delete'`. Shown on the trailing edge written for the
+     * platform: `⌘K` on an Apple one, `Ctrl+K` elsewhere.
+     *
+     * The menu draws it and nothing more. Binding is yours, because only the app
+     * knows what else is listening and whether the shortcut should work at all
+     * times or only while the menu is open. `menuHotkeys` turns these entries
+     * into a `useHotkeys` map, so the one spelling covers both ends.
      */
-    shortcut?: ReactNode;
+    shortcut?: string;
+    /** Extra search terms for `CommandPalette`, which also matches a string `label`. `Menu` ignores them. */
+    keywords?: string[];
     disabled?: boolean;
     /** Renders in the destructive colour. For deleting, discarding, revoking. */
     danger?: boolean;

package/dist/types/common/menu/menuHotkeys.d.ts

@@ -0,0 +1,20 @@
+import { HotkeyMap } from '../hooks/useHotkeys.js';
+import { MenuEntry } from './menu.types.js';
+/**
+ * The bindings for a menu's `shortcut` entries, to hand to `useHotkeys` yourself.
+ *
+ * The menu draws a shortcut but never listens for one, because only the app knows what else is
+ * listening: binding it here as well as in an app's own keymap would run the action twice, and
+ * whether a shortcut should work at all times or only while the menu is open is the app's
+ * question, not the menu's. Calling this keeps the answer in one spelling, so the hint the menu
+ * draws cannot drift from what actually fires.
+ *
+ * ```tsx
+ * useHotkeys(menuHotkeys(items, run));                      // whenever the page is up
+ * useHotkeys(menuHotkeys(items, run), { enabled: isOpen }); // only while the menu is open
+ * ```
+ *
+ * Runs each entry the way clicking it does: its own `onClick`, then `onAction`. A `disabled`
+ * entry, and an entry with no `shortcut`, is left out.
+ */
+export declare function menuHotkeys(items: MenuEntry[], onAction?: (id: string) => void): HotkeyMap;

package/dist/types/common/popover/usePopoverPosition.d.ts

@@ -1,5 +1,6 @@
 import { RefObject } from 'react';
 import { PopoverPlacement, PopoverAlign } from './popover.types.js';
+export declare function supportsAnchoring(): boolean;
 export interface UsePopoverPositionArgs {
     isOpen: boolean;
     placement: PopoverPlacement;

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

@@ -1,3 +1,3 @@
 import { default as React } from 'react';
 import { StickyProps } from './sticky.types.js';
-export default function Sticky({ children, offsetTop, offsetElement, stickToScrollParent, zIndex, disabled, onStuckChange, className, style, classNames, styles: slotStyles, ...rest }: StickyProps): React.JSX.Element;
+export default function Sticky({ children, offsetTop, offsetElement, stickToScrollParent, boundary, boundaryInset, zIndex, disabled, onStuckChange, className, style, classNames, styles: slotStyles, ...rest }: StickyProps): React.JSX.Element;

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

@@ -9,6 +9,21 @@ export interface StickyProps extends HtmlProps {
     offsetElement?: React.RefObject<HTMLElement | null>;
     /** Stick to the top of the nearest scrollable ancestor instead of the browser viewport. Falls back to the viewport if no scrollable ancestor is found. */
     stickToScrollParent?: boolean;
+    /**
+     * Element the content is confined to, normally the one it labels. Once that
+     * element's bottom edge reaches the pinned content, the content is pushed up
+     * with it and scrolls away, instead of staying pinned over whatever follows.
+     * Without it the content pins for as long as the page scrolls.
+     */
+    boundary?: React.RefObject<HTMLElement | null>;
+    /**
+     * How much of the boundary's lower end stays uncovered as the content leaves,
+     * in px. At 0 the content rests on the very bottom edge, which means the last
+     * stretch of the boundary, as tall as the pinned content, spends the whole
+     * exit hidden underneath it. Set it to how much you want to stay in sight:
+     * for a table header, a few rows. Default 0. Ignored without `boundary`.
+     */
+    boundaryInset?: number;
     /** z-index applied to the content while stuck. Default 20. */
     zIndex?: number;
     /** Disable sticking entirely — content stays in normal flow. */

package/dist/types/common/sticky/stickyStack.d.ts

@@ -15,6 +15,11 @@ export interface StickyStackMetrics {
      *  in unrelated scroll panels should never push each other down just because they happen to
      *  share horizontal DOM coordinates. */
     container: HTMLElement | null;
+    /** The element the entry is confined to, or null when nothing confines it.
+     *  Entries sharing one leave together. */
+    boundary: HTMLElement | null;
+    /** Bottom edge of that element (less its inset), in the same coordinate space as `top`. */
+    boundaryBottom: number | null;
 }
 export interface StickyStackEntry {
     node: HTMLElement;

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

@@ -9,6 +9,11 @@ interface State {
     resolvedVariables: Record<string, string>;
     colorFadeActive: boolean;
     currentThemeColor: string | null;
+    /** What `resolvedVariables` was resolved from, to tell a theme change from any other render. */
+    resolvedFrom: {
+        themes: Theme[] | undefined;
+        currentThemeId: string | undefined;
+    };
 }
 declare class ThemeProvider extends Component<Props, State> {
     state: State;
@@ -16,6 +21,7 @@ declare class ThemeProvider extends Component<Props, State> {
     private wrapperRef;
     private themeColorMeta;
     private createdThemeColorMeta;
+    static getDerivedStateFromProps(props: Props, state: State): Partial<State> | null;
     componentDidMount(): void;
     componentDidUpdate(prevProps: Props, prevState: State): void;
     componentWillUnmount(): void;
@@ -26,13 +32,8 @@ declare class ThemeProvider extends Component<Props, State> {
      * (and removes it again on unmount).
      */
     private syncThemeColorMeta;
-    /**
-     * Resolves the full variable set for a given theme ID by walking up the
-     * baseThemeId chain.  Returns variables ordered from deepest ancestor to
-     * the requested theme so callers can merge in order (later entries win).
-     */
-    private resolveChain;
-    private applyTheme;
+    /** `--primary-color` as the browser resolved it, which may be a `var()` of another variable. */
+    private readThemeColor;
     render(): React.JSX.Element;
 }
 export default ThemeProvider;

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/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/useRowDrag.d.ts

@@ -1,5 +1,6 @@
 import { default as React } from 'react';
 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.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/useVirtualWindow.d.ts

@@ -1,5 +1,5 @@
 import { default as React } from 'react';
-import { VirtualListHandle } from './virtualList.types.js';
+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.js';
 export { buildOffsets, findStartIndex, getVisibleRange, resolveReorderTarget, resolveTreeDropTarget, lastDescendantIndex, buildColumnTemplate, compareSortValues, isColumnSortable, isEmptySortValue, nextSort, sortItems, } from './virtualList.utils.js';
-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;
+declare function VirtualList<T>(props: VirtualListProps<T>): React.JSX.Element;
 export default VirtualList;