react-stately 3.45.0 → 3.46.0

package/dist/types/src/toast/useToastState.d.ts

@@ -0,0 +1,82 @@
+type ToastAction = 'add' | 'remove' | 'clear';
+export interface ToastStateProps {
+    /** The maximum number of toasts to display at a time. */
+    maxVisibleToasts?: number;
+    /** Function to wrap updates in (i.e. document.startViewTransition()). */
+    wrapUpdate?: (fn: () => void, action: ToastAction) => void;
+}
+export interface ToastOptions {
+    /** Handler that is called when the toast is closed, either by the user or after a timeout. */
+    onClose?: () => void;
+    /** A timeout to automatically close the toast after, in milliseconds. */
+    timeout?: number;
+}
+export interface QueuedToast<T> extends ToastOptions {
+    /** The content of the toast. */
+    content: T;
+    /** A unique key for the toast. */
+    key: string;
+    /** A timer for the toast, if a timeout was set. */
+    timer?: Timer;
+}
+export interface ToastState<T> {
+    /** Adds a new toast to the queue. */
+    add(content: T, options?: ToastOptions): string;
+    /**
+     * Closes a toast.
+     */
+    close(key: string): void;
+    /** Pauses the timers for all visible toasts. */
+    pauseAll(): void;
+    /** Resumes the timers for all visible toasts. */
+    resumeAll(): void;
+    /** The visible toasts. */
+    visibleToasts: QueuedToast<T>[];
+}
+/**
+ * Provides state management for a toast queue. Toasts display brief, temporary notifications
+ * of actions, errors, or other events in an application.
+ */
+export declare function useToastState<T>(props?: ToastStateProps): ToastState<T>;
+/**
+ * Subscribes to a provided toast queue and provides methods to update it.
+ */
+export declare function useToastQueue<T>(queue: ToastQueue<T>): ToastState<T>;
+/**
+ * A ToastQueue manages the order of toasts.
+ */
+export declare class ToastQueue<T> {
+    private queue;
+    private subscriptions;
+    private maxVisibleToasts;
+    private wrapUpdate?;
+    /** The currently visible toasts. */
+    visibleToasts: QueuedToast<T>[];
+    constructor(options?: ToastStateProps);
+    private runWithWrapUpdate;
+    /** Subscribes to updates to the visible toasts. */
+    subscribe(fn: () => void): () => void;
+    /** Adds a new toast to the queue. */
+    add(content: T, options?: ToastOptions): string;
+    /**
+     * Closes a toast.
+     */
+    close(key: string): void;
+    private updateVisibleToasts;
+    /** Pauses the timers for all visible toasts. */
+    pauseAll(): void;
+    /** Resumes the timers for all visible toasts. */
+    resumeAll(): void;
+    clear(): void;
+}
+declare class Timer {
+    private timerId;
+    private startTime;
+    private remaining;
+    private callback;
+    constructor(callback: () => void, delay: number);
+    reset(delay: number): void;
+    pause(): void;
+    resume(): void;
+}
+export {};

package/dist/types/src/toggle/useToggleGroupState.d.ts

@@ -0,0 +1,37 @@
+import { Key } from '@react-types/shared';
+export interface ToggleGroupProps {
+    /**
+     * Whether single or multiple selection is enabled.
+     * @default 'single'
+     */
+    selectionMode?: 'single' | 'multiple';
+    /** Whether the collection allows empty selection. */
+    disallowEmptySelection?: boolean;
+    /** The currently selected keys in the collection (controlled). */
+    selectedKeys?: Iterable<Key>;
+    /** The initial selected keys in the collection (uncontrolled). */
+    defaultSelectedKeys?: Iterable<Key>;
+    /** Handler that is called when the selection changes. */
+    onSelectionChange?: (keys: Set<Key>) => void;
+    /** Whether all items are disabled. */
+    isDisabled?: boolean;
+}
+export interface ToggleGroupState {
+    /** Whether single or multiple selection is enabled. */
+    readonly selectionMode: 'single' | 'multiple';
+    /** Whether all items are disabled. */
+    readonly isDisabled: boolean;
+    /** A set of keys for items that are selected. */
+    readonly selectedKeys: Set<Key>;
+    /** Toggles the selected state for an item by its key. */
+    toggleKey(key: Key): void;
+    /** Sets whether the given key is selected. */
+    setSelected(key: Key, isSelected: boolean): void;
+    /** Replaces the set of selected keys. */
+    setSelectedKeys(keys: Set<Key>): void;
+}
+/**
+ * Manages state for a group of toggles.
+ * It supports both single and multiple selected items.
+ */
+export declare function useToggleGroupState(props: ToggleGroupProps): ToggleGroupState;

package/dist/types/src/toggle/useToggleState.d.ts

@@ -0,0 +1,40 @@
+import { FocusableProps, InputBase, Validation } from '@react-types/shared';
+import { ReactNode } from 'react';
+export interface ToggleStateOptions extends InputBase {
+    /**
+     * Whether the element should be selected (uncontrolled).
+     */
+    defaultSelected?: boolean;
+    /**
+     * Whether the element should be selected (controlled).
+     */
+    isSelected?: boolean;
+    /**
+     * Handler that is called when the element's selection state changes.
+     */
+    onChange?: (isSelected: boolean) => void;
+}
+export interface ToggleProps extends ToggleStateOptions, Validation<boolean>, FocusableProps {
+    /**
+     * The label for the element.
+     */
+    children?: ReactNode;
+    /**
+     * The value of the input element, used when submitting an HTML form. See [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#htmlattrdefvalue).
+     */
+    value?: string;
+}
+export interface ToggleState {
+    /** Whether the toggle is selected. */
+    readonly isSelected: boolean;
+    /** Whether the toggle is selected by default. */
+    readonly defaultSelected: boolean;
+    /** Updates selection state. */
+    setSelected(isSelected: boolean): void;
+    /** Toggle the selection state. */
+    toggle(): void;
+}
+/**
+ * Provides state management for toggle components like checkboxes and switches.
+ */
+export declare function useToggleState(props?: ToggleStateOptions): ToggleState;

package/dist/types/src/tooltip/useTooltipTriggerState.d.ts

@@ -0,0 +1,45 @@
+import { OverlayTriggerProps } from '../overlays/useOverlayTriggerState';
+export interface TooltipTriggerProps extends OverlayTriggerProps {
+    /**
+     * Whether the tooltip should be disabled, independent from the trigger.
+     */
+    isDisabled?: boolean;
+    /**
+     * The delay time for the tooltip to show up. [See guidelines](https://spectrum.adobe.com/page/tooltip/#Immediate-or-delayed-appearance).
+     * @default 1500
+     */
+    delay?: number;
+    /**
+     * The delay time for the tooltip to close. [See guidelines](https://spectrum.adobe.com/page/tooltip/#Warmup-and-cooldown).
+     * @default 500
+     */
+    closeDelay?: number;
+    /**
+     * By default, opens for both focus and hover. Can be made to open only for focus.
+     * @default 'hover'
+     */
+    trigger?: 'hover' | 'focus';
+    /**
+     * Whether the tooltip should close when the trigger is pressed.
+     * @default true
+     */
+    shouldCloseOnPress?: boolean;
+}
+export interface TooltipTriggerState {
+    /** Whether the tooltip is currently showing. */
+    isOpen: boolean;
+    /**
+     * Shows the tooltip. By default, the tooltip becomes visible after a delay
+     * depending on a global warmup timer. The `immediate` option shows the
+     * tooltip immediately instead.
+     */
+    open(immediate?: boolean): void;
+    /** Hides the tooltip. */
+    close(immediate?: boolean): void;
+}
+/**
+ * Manages state for a tooltip trigger. Tracks whether the tooltip is open, and provides
+ * methods to toggle this state. Ensures only one tooltip is open at a time and controls
+ * the delay for showing a tooltip.
+ */
+export declare function useTooltipTriggerState(props?: TooltipTriggerProps): TooltipTriggerState;

package/dist/types/src/tree/TreeCollection.d.ts

@@ -0,0 +1,19 @@
+import { Collection, Key, Node } from '@react-types/shared';
+export declare class TreeCollection<T> implements Collection<Node<T>> {
+    private keyMap;
+    private iterable;
+    private firstKey;
+    private lastKey;
+    constructor(nodes: Iterable<Node<T>>, { expandedKeys }?: {
+        expandedKeys?: Set<Key>;
+    });
+    [Symbol.iterator](): IterableIterator<Node<T>>;
+    get size(): number;
+    getKeys(): IterableIterator<Key>;
+    getKeyBefore(key: Key): Key | null;
+    getKeyAfter(key: Key): Key | null;
+    getFirstKey(): Key | null;
+    getLastKey(): Key | null;
+    getItem(key: Key): Node<T> | null;
+    at(idx: number): Node<T> | null;
+}

package/dist/types/src/tree/useTreeState.d.ts

@@ -0,0 +1,25 @@
+import { Collection, CollectionStateBase, DisabledBehavior, Expandable, Key, MultipleSelection, Node } from '@react-types/shared';
+import { SelectionManager } from '../selection/SelectionManager';
+export interface TreeProps<T> extends CollectionStateBase<T>, Expandable, MultipleSelection {
+    /** Whether `disabledKeys` applies to all interactions, or only selection. */
+    disabledBehavior?: DisabledBehavior;
+}
+export interface TreeState<T> {
+    /** A collection of items in the tree. */
+    readonly collection: Collection<Node<T>>;
+    /** A set of keys for items that are disabled. */
+    readonly disabledKeys: Set<Key>;
+    /** A set of keys for items that are expanded. */
+    readonly expandedKeys: Set<Key>;
+    /** Toggles the expanded state for an item by its key. */
+    toggleKey(key: Key): void;
+    /** Replaces the set of expanded keys. */
+    setExpandedKeys(keys: Set<Key>): void;
+    /** A selection manager to read and update multiple selection state. */
+    readonly selectionManager: SelectionManager;
+}
+/**
+ * Provides state management for tree-like components. Handles building a collection
+ * of items from props, item expanded state, and manages multiple selection state.
+ */
+export declare function useTreeState<T extends object>(props: TreeProps<T>): TreeState<T>;

package/dist/types/src/utils/number.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Takes a value and forces it to the closest min/max if it's outside. Also forces it to the closest valid step.
+ */
+export declare function clamp(value: number, min?: number, max?: number): number;
+export declare function roundToStepPrecision(value: number, step: number): number;
+export declare function snapValueToStep(value: number, min: number | undefined, max: number | undefined, step: number): number;
+export declare function toFixedNumber(value: number, digits: number, base?: number): number;

package/dist/types/src/utils/useControlledState.d.ts

@@ -0,0 +1,3 @@
+import { SetStateAction } from 'react';
+export declare function useControlledState<T, C = T>(value: Exclude<T, undefined>, defaultValue: Exclude<T, undefined> | undefined, onChange?: (v: C, ...args: any[]) => void): [T, (value: SetStateAction<T>, ...args: any[]) => void];
+export declare function useControlledState<T, C = T>(value: Exclude<T, undefined> | undefined, defaultValue: Exclude<T, undefined>, onChange?: (v: C, ...args: any[]) => void): [T, (value: SetStateAction<T>, ...args: any[]) => void];

package/dist/types/src/virtualizer/Layout.d.ts

@@ -0,0 +1,68 @@
+import { InvalidationContext } from './types';
+import { ItemDropTarget, Key, LayoutDelegate, Node } from '@react-types/shared';
+import { LayoutInfo } from './LayoutInfo';
+import { Rect } from './Rect';
+import { Size } from './Size';
+import { Virtualizer } from './Virtualizer';
+/**
+ * Virtualizer supports arbitrary layout objects, which compute what items are visible, and how
+ * to position and style them. However, layouts do not render items directly. Instead,
+ * layouts produce lightweight LayoutInfo objects which describe various properties of an item,
+ * such as its position and size. The Virtualizer is then responsible for creating the actual
+ * views as needed, based on this layout information.
+ *
+ * Every layout extends from the Layout abstract base class. Layouts must implement the `getVisibleLayoutInfos`,
+ * `getLayoutInfo`, and `getContentSize` methods. All other methods can be optionally overridden to implement custom behavior.
+ */
+export declare abstract class Layout<T extends object = Node<any>, O = any> implements LayoutDelegate {
+    /** The Virtualizer the layout is currently attached to. */
+    virtualizer: Virtualizer<T, any> | null;
+    /**
+     * Returns an array of `LayoutInfo` objects which are inside the given rectangle.
+     * Should be implemented by subclasses.
+     * @param rect The rectangle that should contain the returned LayoutInfo objects.
+     */
+    abstract getVisibleLayoutInfos(rect: Rect): LayoutInfo[];
+    /**
+     * Returns a `LayoutInfo` for the given key.
+     * Should be implemented by subclasses.
+     * @param key The key of the LayoutInfo to retrieve.
+     */
+    abstract getLayoutInfo(key: Key): LayoutInfo | null;
+    /**
+     * Returns size of the content. By default, it returns virtualizer's size.
+     */
+    abstract getContentSize(): Size;
+    /**
+     * Returns whether the layout should invalidate in response to
+     * visible rectangle changes. By default, it only invalidates
+     * when the virtualizer's size changes. Return true always
+     * to make the layout invalidate while scrolling (e.g. sticky headers).
+     */
+    shouldInvalidate(newRect: Rect, oldRect: Rect): boolean;
+    /**
+     * Returns whether the layout should invalidate when the layout options change.
+     * By default it invalidates when the object identity changes. Override this
+     * method to optimize layout updates based on specific option changes.
+     */
+    shouldInvalidateLayoutOptions(newOptions: O, oldOptions: O): boolean;
+    /**
+     * This method allows the layout to perform any pre-computation
+     * it needs to in order to prepare LayoutInfos for retrieval.
+     * Called by the virtualizer before `getVisibleLayoutInfos`
+     * or `getLayoutInfo` are called.
+     */
+    update(invalidationContext: InvalidationContext<O>): void;
+    /**
+     * Updates the size of the given item.
+     */
+    updateItemSize?(key: Key, size: Size): boolean;
+    /**
+     * Returns a `LayoutInfo` for the given drop target.
+     */
+    getDropTargetLayoutInfo?(target: ItemDropTarget): LayoutInfo;
+    /** @private */
+    getItemRect(key: Key): Rect | null;
+    /** @private */
+    getVisibleRect(): Rect;
+}

package/dist/types/src/virtualizer/LayoutInfo.d.ts

@@ -0,0 +1,70 @@
+import { Key } from '@react-types/shared';
+import { Rect } from './Rect';
+/**
+ * Instances of this lightweight class are created by `Layout` subclasses
+ * to represent each item in the `Virtualizer`. LayoutInfo objects describe
+ * various properties of an item, such as its position and size, and style information.
+ * The virtualizer uses this information when creating actual DOM elements to display.
+ */
+export declare class LayoutInfo {
+    /**
+     * The type of element represented by this LayoutInfo. Should match the `type` of the corresponding collection node.
+     */
+    type: string;
+    /**
+     * A unique key for this LayoutInfo. Should match the `key` of the corresponding collection node.
+     */
+    key: Key;
+    /**
+     * The key for a parent LayoutInfo, if any.
+     */
+    parentKey: Key | null;
+    /**
+     * Content for this item if it was generated by the layout rather than coming from the Collection.
+     */
+    content: any | null;
+    /**
+     * The rectangle describing the size and position of this element.
+     */
+    rect: Rect;
+    /**
+     * Whether the size is estimated. `false` by default.
+     * Items with estimated sizes will be measured the first time they are added to the DOM.
+     * The estimated size is used to calculate the size and position of the scrollbar.
+     * @default false
+     */
+    estimatedSize: boolean;
+    /**
+     * Whether the layout info sticks to the viewport when scrolling.
+     * @default false
+     */
+    isSticky: boolean;
+    /**
+     * The element's opacity.
+     * @default 1
+     */
+    opacity: number;
+    /**
+     * A CSS transform string to apply to the element. `null` by default.
+     */
+    transform: string | null;
+    /**
+     * The z-index of the element. 0 by default.
+     */
+    zIndex: number;
+    /**
+     * Whether the element allows its contents to overflow its container.
+     * @default false
+     */
+    allowOverflow: boolean;
+    /**
+     * @param type The type of element represented by this LayoutInfo. Should match the `type` of the corresponding collection node.
+     * @param key A unique key for this LayoutInfo. Should match the `key` of the corresponding collection node.
+     * @param rect The rectangle describing the size and position of this element.
+     */
+    constructor(type: string, key: Key, rect: Rect);
+    /**
+     * Returns a copy of the LayoutInfo.
+     */
+    copy(): LayoutInfo;
+}

package/dist/types/src/virtualizer/OverscanManager.d.ts

@@ -0,0 +1,8 @@
+import { Rect } from './Rect';
+export declare class OverscanManager {
+    private startTime;
+    private velocity;
+    private visibleRect;
+    setVisibleRect(rect: Rect): void;
+    getOverscannedRect(): Rect;
+}

package/dist/types/src/virtualizer/Point.d.ts

@@ -0,0 +1,19 @@
+export declare class Point {
+    /** The x-coordinate of the point. */
+    x: number;
+    /** The y-coordinate of the point. */
+    y: number;
+    constructor(x?: number, y?: number);
+    /**
+     * Returns a copy of this point.
+     */
+    copy(): Point;
+    /**
+     * Checks if two points are equal.
+     */
+    equals(point: Point): boolean;
+    /**
+     * Returns true if this point is the origin.
+     */
+    isOrigin(): boolean;
+}

package/dist/types/src/virtualizer/Rect.d.ts

@@ -0,0 +1,82 @@
+import { Point } from './Point';
+import { Size } from './Size';
+export type RectCorner = 'topLeft' | 'topRight' | 'bottomLeft' | 'bottomRight';
+/**
+ * Represents a rectangle.
+ */
+export declare class Rect {
+    /** The x-coordinate of the rectangle. */
+    x: number;
+    /** The y-coordinate of the rectangle. */
+    y: number;
+    /** The width of the rectangle. */
+    width: number;
+    /** The height of the rectangle. */
+    height: number;
+    constructor(x?: number, y?: number, width?: number, height?: number);
+    /**
+     * The maximum x-coordinate in the rectangle.
+     */
+    get maxX(): number;
+    /**
+     * The maximum y-coordinate in the rectangle.
+     */
+    get maxY(): number;
+    /**
+     * The area of the rectangle.
+     */
+    get area(): number;
+    /**
+     * The top left corner of the rectangle.
+     */
+    get topLeft(): Point;
+    /**
+     * The top right corner of the rectangle.
+     */
+    get topRight(): Point;
+    /**
+     * The bottom left corner of the rectangle.
+     */
+    get bottomLeft(): Point;
+    /**
+     * The bottom right corner of the rectangle.
+     */
+    get bottomRight(): Point;
+    /**
+     * Returns whether this rectangle intersects another rectangle.
+     * @param rect - The rectangle to check.
+     */
+    intersects(rect: Rect): boolean;
+    /**
+     * Returns whether this rectangle fully contains another rectangle.
+     * @param rect - The rectangle to check.
+     */
+    containsRect(rect: Rect): boolean;
+    /**
+     * Returns whether the rectangle contains the given point.
+     * @param point - The point to check.
+     */
+    containsPoint(point: Point): boolean;
+    /**
+     * Returns the first corner of this rectangle (from top to bottom, left to right)
+     * that is contained in the given rectangle, or null of the rectangles do not intersect.
+     * @param rect - The rectangle to check.
+     */
+    getCornerInRect(rect: Rect): RectCorner | null;
+    equals(rect: Rect): boolean;
+    pointEquals(point: Point | Rect): boolean;
+    sizeEquals(size: Size | Rect): boolean;
+    /**
+     * Returns the union of this Rect and another.
+     */
+    union(other: Rect): Rect;
+    /**
+     * Returns the intersection of this Rect with another.
+     * If the rectangles do not intersect, an all zero Rect is returned.
+     */
+    intersection(other: Rect): Rect;
+    /**
+     * Returns a copy of this rectangle.
+     */
+    copy(): Rect;
+}

package/dist/types/src/virtualizer/ReusableView.d.ts

@@ -0,0 +1,34 @@
+import { Key } from '@react-types/shared';
+import { LayoutInfo } from './LayoutInfo';
+import { Virtualizer } from './Virtualizer';
+/**
+ * `Virtualizer` creates instances of the `ReusableView` class to
+ * represent views currently being displayed.
+ */
+export declare class ReusableView<T extends object, V> {
+    /** The Virtualizer this view is a part of. */
+    virtualizer: Virtualizer<T, V>;
+    /** The LayoutInfo this view is currently representing. */
+    layoutInfo: LayoutInfo | null;
+    /** The content currently being displayed by this view, set by the virtualizer. */
+    content: T | null;
+    rendered: V | null;
+    viewType: string;
+    key: Key;
+    children: Set<ChildView<T, V>>;
+    reusableViews: Map<string, ChildView<T, V>[]>;
+    constructor(virtualizer: Virtualizer<T, V>, viewType: string);
+    /**
+     * Prepares the view for reuse. Called just before the view is removed from the DOM.
+     */
+    prepareForReuse(): void;
+    getReusableView(reuseType: string): ChildView<T, V>;
+    reuseChild(child: ChildView<T, V>): void;
+}
+export declare class RootView<T extends object, V> extends ReusableView<T, V> {
+    constructor(virtualizer: Virtualizer<T, V>);
+}
+export declare class ChildView<T extends object, V> extends ReusableView<T, V> {
+    parent: ReusableView<T, V>;
+    constructor(virtualizer: Virtualizer<T, V>, parent: ReusableView<T, V>, viewType: string);
+}

package/dist/types/src/virtualizer/Size.d.ts

@@ -0,0 +1,17 @@
+export declare class Size {
+    width: number;
+    height: number;
+    constructor(width?: number, height?: number);
+    /**
+     * Returns a copy of this size.
+     */
+    copy(): Size;
+    /**
+     * Returns whether this size is equal to another one.
+     */
+    equals(other: Size): boolean;
+    /**
+     * The total area of the Size.
+     */
+    get area(): number;
+}

package/dist/types/src/virtualizer/Virtualizer.d.ts

@@ -0,0 +1,74 @@
+import { ReusableView } from './ReusableView';
+import { Collection, Key } from '@react-types/shared';
+import { InvalidationContext, VirtualizerDelegate, VirtualizerRenderOptions } from './types';
+import { Layout } from './Layout';
+import { LayoutInfo } from './LayoutInfo';
+import { Point } from './Point';
+import { Rect } from './Rect';
+import { Size } from './Size';
+interface VirtualizerOptions<T extends object, V> {
+    delegate: VirtualizerDelegate<T, V>;
+    collection: Collection<T>;
+    layout: Layout<T>;
+}
+/**
+ * The Virtualizer class renders a scrollable collection of data using customizable layouts.
+ * It supports very large collections by only rendering visible views to the DOM, reusing
+ * them as you scroll. Virtualizer can present any type of view, including non-item views
+ * such as section headers and footers.
+ *
+ * Virtualizer uses `Layout` objects to compute what views should be visible, and how
+ * to position and style them. This means that virtualizer can have its items arranged in
+ * a stack, a grid, a circle, or any other layout you can think of. The layout can be changed
+ * dynamically at runtime as well.
+ *
+ * Layouts produce information on what views should appear in the virtualizer, but do not create
+ * the views themselves directly. It is the responsibility of the `VirtualizerDelegate` object
+ * to render elements for each layout info. The virtualizer manages a set of `ReusableView` objects,
+ * which are reused as the user scrolls by swapping their content with cached elements returned by the delegate.
+ */
+export declare class Virtualizer<T extends object, V> {
+    /**
+     * The virtualizer delegate. The delegate is used by the virtualizer
+     * to create and configure views.
+     */
+    delegate: VirtualizerDelegate<T, V>;
+    /** The current content of the virtualizer. */
+    readonly collection: Collection<T>;
+    /** The layout object that determines the visible views. */
+    readonly layout: Layout<T>;
+    /** The size of the scrollable content. */
+    readonly contentSize: Size;
+    /** The currently visible rectangle. */
+    readonly visibleRect: Rect;
+    /** The size of the virtualizer scroll view. */
+    readonly size: Size;
+    /** The set of persisted keys that are always present in the DOM, even if not currently in view. */
+    readonly persistedKeys: Set<Key>;
+    private _visibleViews;
+    private _renderedContent;
+    private _rootView;
+    private _isScrolling;
+    private _invalidationContext;
+    private _overscanManager;
+    constructor(options: VirtualizerOptions<T, V>);
+    /** Returns whether the given key, or an ancestor, is persisted. */
+    isPersistedKey(key: Key): boolean;
+    private getParentView;
+    private getReusableView;
+    private _renderView;
+    private _renderContent;
+    /**
+     * Returns the key for the item view currently at the given point.
+     */
+    keyAtPoint(point: Point): Key | null;
+    private relayout;
+    getVisibleLayoutInfos(): Map<Key, LayoutInfo>;
+    private updateSubviews;
+    /** Performs layout and updates visible views as needed. */
+    render(opts: VirtualizerRenderOptions<T>): ReusableView<T, V>[];
+    getVisibleView(key: Key): ReusableView<T, V> | undefined;
+    invalidate(context: InvalidationContext): void;
+    updateItemSize(key: Key, size: Size): void;
+}
+export {};