react-stately 3.45.0 → 3.46.0

package/dist/types/src/disclosure/useDisclosureGroupState.d.ts

@@ -0,0 +1,30 @@
+import { Key } from '@react-types/shared';
+export interface DisclosureGroupProps {
+    /** Whether multiple items can be expanded at the same time. */
+    allowsMultipleExpanded?: boolean;
+    /** Whether all items are disabled. */
+    isDisabled?: boolean;
+    /** The currently expanded keys in the group (controlled). */
+    expandedKeys?: Iterable<Key>;
+    /** The initial expanded keys in the group (uncontrolled). */
+    defaultExpandedKeys?: Iterable<Key>;
+    /** Handler that is called when items are expanded or collapsed. */
+    onExpandedChange?: (keys: Set<Key>) => any;
+}
+export interface DisclosureGroupState {
+    /** Whether multiple items can be expanded at the same time. */
+    readonly allowsMultipleExpanded: boolean;
+    /** Whether all items are disabled. */
+    readonly isDisabled: boolean;
+    /** 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;
+}
+/**
+ * Manages state for a group of disclosures, e.g. an accordion.
+ * It supports both single and multiple expanded items.
+ */
+export declare function useDisclosureGroupState(props: DisclosureGroupProps): DisclosureGroupState;

package/dist/types/src/disclosure/useDisclosureState.d.ts

@@ -0,0 +1,25 @@
+export interface DisclosureProps {
+    /** Whether the disclosure is expanded (controlled). */
+    isExpanded?: boolean;
+    /** Whether the disclosure is expanded by default (uncontrolled). */
+    defaultExpanded?: boolean;
+    /** Handler that is called when the disclosure expanded state changes. */
+    onExpandedChange?: (isExpanded: boolean) => void;
+}
+export interface DisclosureState {
+    /** Whether the disclosure is currently expanded. */
+    readonly isExpanded: boolean;
+    /** Sets whether the disclosure is expanded. */
+    setExpanded(isExpanded: boolean): void;
+    /** Expand the disclosure. */
+    expand(): void;
+    /** Collapse the disclosure. */
+    collapse(): void;
+    /** Toggles the disclosure's visibility. */
+    toggle(): void;
+}
+/**
+ * Manages state for a disclosure widget. Tracks whether the disclosure is expanded, and provides
+ * methods to toggle this state.
+ */
+export declare function useDisclosureState(props: DisclosureProps): DisclosureState;

package/dist/types/src/dnd/useDraggableCollectionState.d.ts

@@ -0,0 +1,42 @@
+import { Collection, DraggableCollectionEndEvent, DraggableCollectionProps, DragItem, DragMoveEvent, DragPreviewRenderer, DragStartEvent, DropOperation, Key, Node, RefObject } from '@react-types/shared';
+import { MultipleSelectionManager } from '../selection/types';
+export interface DraggableCollectionStateOptions<T = object> extends DraggableCollectionProps<T> {
+    /** A collection of items. */
+    collection: Collection<Node<unknown>>;
+    /** An interface for reading and updating multiple selection state. */
+    selectionManager: MultipleSelectionManager;
+    /** Whether the drag events should be disabled. */
+    isDisabled?: boolean;
+}
+export interface DraggableCollectionState {
+    /** A collection of items. */
+    collection: Collection<Node<unknown>>;
+    /** An interface for reading and updating multiple selection state. */
+    selectionManager: MultipleSelectionManager;
+    /** The key of the item that initiated a drag. */
+    draggedKey: Key | null;
+    /** The keys of the items that are currently being dragged. */
+    draggingKeys: Set<Key>;
+    /** Whether drag events are disabled. */
+    isDisabled?: boolean;
+    /** Returns whether the given key is currently being dragged. */
+    isDragging(key: Key): boolean;
+    /** Returns the keys of the items that will be dragged with the given key (e.g. selected items). */
+    getKeysForDrag(key: Key): Set<Key>;
+    /** Returns the items to drag for the given key. */
+    getItems(key: Key): DragItem[];
+    /** The ref of the element that will be rendered as the drag preview while dragging. */
+    preview?: RefObject<DragPreviewRenderer | null>;
+    /** Function that returns the drop operations that are allowed for the dragged items. If not provided, all drop operations are allowed. */
+    getAllowedDropOperations?: () => DropOperation[];
+    /** Begins a drag for the given key. This triggers the onDragStart event. */
+    startDrag(key: Key, event: DragStartEvent): void;
+    /** Triggers an onDragMove event. */
+    moveDrag(event: DragMoveEvent): void;
+    /** Ends the current drag, and emits an onDragEnd event. */
+    endDrag(event: DraggableCollectionEndEvent): void;
+}
+/**
+ * Manages state for a draggable collection.
+ */
+export declare function useDraggableCollectionState<T = object>(props: DraggableCollectionStateOptions<T>): DraggableCollectionState;

package/dist/types/src/dnd/useDroppableCollectionState.d.ts

@@ -0,0 +1,38 @@
+import { Collection, DragTypes, DropOperation, DroppableCollectionProps, DropTarget, Key, Node } from '@react-types/shared';
+import { MultipleSelectionManager } from '../selection/types';
+interface DropOperationEvent {
+    target: DropTarget;
+    types: DragTypes;
+    allowedOperations: DropOperation[];
+    isInternal: boolean;
+    draggingKeys: Set<Key>;
+}
+export interface DroppableCollectionStateOptions extends Omit<DroppableCollectionProps, 'onDropMove' | 'onDropActivate'> {
+    /** A collection of items. */
+    collection: Collection<Node<unknown>>;
+    /** An interface for reading and updating multiple selection state. */
+    selectionManager: MultipleSelectionManager;
+    /** Whether the drop events should be disabled. */
+    isDisabled?: boolean;
+}
+export interface DroppableCollectionState {
+    /** A collection of items. */
+    collection: Collection<Node<unknown>>;
+    /** An interface for reading and updating multiple selection state. */
+    selectionManager: MultipleSelectionManager;
+    /** The current drop target. */
+    target: DropTarget | null;
+    /** Whether drop events are disabled. */
+    isDisabled?: boolean;
+    /** Sets the current drop target. */
+    setTarget(target: DropTarget | null): void;
+    /** Returns whether the given target is equivalent to the current drop target. */
+    isDropTarget(target: DropTarget | null): boolean;
+    /** Returns the drop operation for the given parameters. */
+    getDropOperation(e: DropOperationEvent): DropOperation;
+}
+/**
+ * Manages state for a droppable collection.
+ */
+export declare function useDroppableCollectionState(props: DroppableCollectionStateOptions): DroppableCollectionState;
+export {};

package/dist/types/src/flags/flags.d.ts

@@ -0,0 +1,4 @@
+export declare function enableTableNestedRows(): void;
+export declare function tableNestedRows(): boolean;
+export declare function enableShadowDOM(): void;
+export declare function shadowDOM(): boolean;

package/dist/types/src/form/useFormValidationState.d.ts

@@ -0,0 +1,26 @@
+import { Context } from 'react';
+import { Validation, ValidationErrors, ValidationResult } from '@react-types/shared';
+export declare const VALID_VALIDITY_STATE: ValidityState;
+export declare const DEFAULT_VALIDATION_RESULT: ValidationResult;
+export declare const FormValidationContext: Context<ValidationErrors>;
+export declare const privateValidationStateProp: string;
+interface FormValidationProps<T> extends Validation<T> {
+    builtinValidation?: ValidationResult;
+    name?: string | string[];
+    value: T | null;
+}
+export interface FormValidationState {
+    /** Realtime validation results, updated as the user edits the value. */
+    realtimeValidation: ValidationResult;
+    /** Currently displayed validation results, updated when the user commits their changes. */
+    displayValidation: ValidationResult;
+    /** Updates the current validation result. Not displayed to the user until `commitValidation` is called. */
+    updateValidation(result: ValidationResult): void;
+    /** Resets the displayed validation state to valid when the user resets the form. */
+    resetValidation(): void;
+    /** Commits the realtime validation so it is displayed to the user. */
+    commitValidation(): void;
+}
+export declare function useFormValidationState<T>(props: FormValidationProps<T>): FormValidationState;
+export declare function mergeValidation(...results: ValidationResult[]): ValidationResult;
+export {};

package/dist/types/src/grid/GridCollection.d.ts

@@ -0,0 +1,48 @@
+import { Collection, Key, Node } from '@react-types/shared';
+export interface IGridCollection<T> extends Collection<GridNode<T>> {
+    /** The number of columns in the grid. */
+    columnCount: number;
+    /** A list of rows in the grid. */
+    rows: GridNode<T>[];
+}
+export interface GridRow<T> extends Partial<GridNode<T>> {
+    key?: Key;
+    type: string;
+    childNodes: Iterable<Node<T>>;
+}
+export interface GridNode<T> extends Node<T> {
+    column?: GridNode<T>;
+    /**
+     * The number of columns spanned by this cell. Use `colSpan` instead.
+     * @deprecated
+     */
+    colspan?: number;
+    /** The number of columns spanned by this cell.  */
+    colSpan?: number | null;
+    /** The column index of this cell, accounting for any colSpans. */
+    colIndex?: number | null;
+    /** The index of this node within its parent, ignoring sibling nodes that aren't of the same type. */
+    indexOfType?: number;
+}
+interface GridCollectionOptions<T> {
+    columnCount: number;
+    items: GridRow<T>[];
+    visitNode?: (cell: GridNode<T>) => GridNode<T>;
+}
+export declare class GridCollection<T> implements IGridCollection<T> {
+    keyMap: Map<Key, GridNode<T>>;
+    columnCount: number;
+    rows: GridNode<T>[];
+    constructor(opts: GridCollectionOptions<T>);
+    [Symbol.iterator](): IterableIterator<GridNode<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): GridNode<T> | null;
+    at(idx: number): GridNode<T> | null;
+    getChildren(key: Key): Iterable<GridNode<T>>;
+}
+export {};

package/dist/types/src/grid/useGridState.d.ts

@@ -0,0 +1,25 @@
+import { IGridCollection } from './GridCollection';
+import { Key } from '@react-types/shared';
+import { MultipleSelectionState } from '../selection/types';
+import { MultipleSelectionStateProps } from '../selection/useMultipleSelectionState';
+import { SelectionManager } from '../selection/SelectionManager';
+export interface GridState<T, C extends IGridCollection<T>> {
+    collection: C;
+    /** A set of keys for rows that are disabled. */
+    disabledKeys: Set<Key>;
+    /** A selection manager to read and update row selection state. */
+    selectionManager: SelectionManager;
+    /** Whether keyboard navigation is disabled, such as when the arrow keys should be handled by a component within a cell. */
+    isKeyboardNavigationDisabled: boolean;
+}
+export interface GridStateOptions<T, C extends IGridCollection<T>> extends MultipleSelectionStateProps {
+    collection: C;
+    disabledKeys?: Iterable<Key>;
+    focusMode?: 'row' | 'cell';
+    /** @private - do not use unless you know what you're doing. */
+    UNSAFE_selectionState?: MultipleSelectionState;
+}
+/**
+ * Provides state management for a grid component. Handles row selection and focusing a grid cell's focusable child if applicable.
+ */
+export declare function useGridState<T extends object, C extends IGridCollection<T>>(props: GridStateOptions<T, C>): GridState<T, C>;

package/dist/types/src/layout/GridLayout.d.ts

@@ -0,0 +1,73 @@
+import { DropTarget, DropTargetDelegate, ItemDropTarget, Key, Node } from '@react-types/shared';
+import { InvalidationContext } from '../virtualizer/types';
+import { Layout } from '../virtualizer/Layout';
+import { LayoutInfo } from '../virtualizer/LayoutInfo';
+import { Rect } from '../virtualizer/Rect';
+import { Size } from '../virtualizer/Size';
+export interface GridLayoutOptions {
+    /**
+     * The minimum item size.
+     * @default 200 x 200
+     */
+    minItemSize?: Size;
+    /**
+     * The maximum item size.
+     * @default Infinity
+     */
+    maxItemSize?: Size;
+    /**
+     * Whether to preserve the aspect ratio of the `minItemSize`.
+     * By default, grid rows may have variable heights. When `preserveAspectRatio`
+     * is true, all rows will have equal heights.
+     * @default false
+     */
+    preserveAspectRatio?: boolean;
+    /**
+     * The minimum space required between items.
+     * @default 18 x 18
+     */
+    minSpace?: Size;
+    /**
+     * The maximum allowed horizontal space between items.
+     * @default Infinity
+     */
+    maxHorizontalSpace?: number;
+    /**
+     * The maximum number of columns.
+     * @default Infinity
+     */
+    maxColumns?: number;
+    /**
+     * The thickness of the drop indicator.
+     * @default 2
+     */
+    dropIndicatorThickness?: number;
+    /**
+     * The fixed height of a loader element in px. This loader is specifically for
+     * "load more" elements rendered when loading more rows at the root level or inside nested row/sections.
+     * @default 48
+     */
+    loaderHeight?: number;
+}
+/**
+ * GridLayout is a virtualizer Layout implementation
+ * that arranges its items in a grid.
+ * The items are sized between a minimum and maximum size
+ * depending on the width of the container.
+ */
+export declare class GridLayout<T, O extends GridLayoutOptions = GridLayoutOptions> extends Layout<Node<T>, O> implements DropTargetDelegate {
+    protected gap: Size;
+    protected dropIndicatorThickness: number;
+    protected numColumns: number;
+    private contentSize;
+    private layoutInfos;
+    private margin;
+    shouldInvalidateLayoutOptions(newOptions: O, oldOptions: O): boolean;
+    update(invalidationContext: InvalidationContext<O>): void;
+    getLayoutInfo(key: Key): LayoutInfo | null;
+    getContentSize(): Size;
+    getVisibleLayoutInfos(rect: Rect): LayoutInfo[];
+    updateItemSize(key: Key, size: Size): boolean;
+    getDropTargetFromPoint(x: number, y: number, isValidDropTarget: (target: DropTarget) => boolean): DropTarget;
+    getDropTargetLayoutInfo(target: ItemDropTarget): LayoutInfo;
+}

package/dist/types/src/layout/ListLayout.d.ts

@@ -0,0 +1,144 @@
+import { Collection, DropTarget, DropTargetDelegate, ItemDropTarget, Key, Node, Orientation } from '@react-types/shared';
+import { InvalidationContext } from '../virtualizer/types';
+import { Layout } from '../virtualizer/Layout';
+import { LayoutInfo } from '../virtualizer/LayoutInfo';
+import { Rect } from '../virtualizer/Rect';
+import { Size } from '../virtualizer/Size';
+export interface ListLayoutOptions {
+    /**
+     * The primary orientation of the items. Usually this is the direction that the collection scrolls.
+     * @default 'vertical'
+     */
+    orientation?: Orientation;
+    /**
+     * The fixed size of a row in px with respect to the applied orientation.
+     * @default 48
+     */
+    rowSize?: number;
+    /** The estimated size of a row in px with respect to the applied orientation, when row sizes are variable. */
+    estimatedRowSize?: number;
+    /**
+     * The fixed size of a section header in px with respect to the applied orientation.
+     * @default 48
+     */
+    headingSize?: number;
+    /** The estimated size of a section header in px with respect to the applied orientation, when heading sizes are variable. */
+    estimatedHeadingSize?: number;
+    /**
+     * The fixed size of a loader element in px with respect to the applied orientation. This loader is specifically for
+     * "load more" elements rendered when loading more rows at the root level or inside nested row/sections.
+     * @default 48
+     */
+    loaderSize?: number;
+    /**
+     * The thickness of the drop indicator.
+     * @default 2
+     */
+    dropIndicatorThickness?: number;
+    /**
+     * The gap between items.
+     * @default 0
+     */
+    gap?: number;
+    /**
+     * The padding around the list.
+     * @default 0
+     */
+    padding?: number;
+    /**
+     * The fixed height of a row in px.
+     * @default 48
+     * @deprecated Use `rowSize` instead.
+     */
+    rowHeight?: number;
+    /** The estimated height of a row, when row heights are variable.
+     * @deprecated Use `estimatedRowSize` instead.
+     */
+    estimatedRowHeight?: number;
+    /**
+     * The fixed height of a section header in px.
+     * @default 48
+     * @deprecated Use `headingSize` instead.
+     */
+    headingHeight?: number;
+    /** The estimated height of a section header, when the height is variable.
+     * @deprecated Use `estimatedHeadingSize` instead.
+     */
+    estimatedHeadingHeight?: number;
+    /**
+     * The fixed height of a loader element in px. This loader is specifically for
+     * "load more" elements rendered when loading more rows at the root level or inside nested row/sections.
+     * @default 48
+     * @deprecated Use `loaderSize` instead.
+     */
+    loaderHeight?: number;
+}
+export interface LayoutNode {
+    node?: Node<unknown>;
+    layoutInfo: LayoutInfo;
+    children?: LayoutNode[];
+    validRect: Rect;
+    index?: number;
+}
+/**
+ * ListLayout is a virtualizer Layout implementation
+ * that arranges its items in a stack along its applied orientation.
+ * It supports both fixed and variable size items.
+ */
+export declare class ListLayout<T, O extends ListLayoutOptions = ListLayoutOptions> extends Layout<Node<T>, O> implements DropTargetDelegate {
+    protected rowSize: number | null;
+    protected orientation: Orientation;
+    protected estimatedRowSize: number | null;
+    protected headingSize: number | null;
+    protected estimatedHeadingSize: number | null;
+    protected loaderSize: number | null;
+    protected dropIndicatorThickness: number;
+    protected gap: number;
+    protected padding: number;
+    protected layoutNodes: Map<Key, LayoutNode>;
+    protected contentSize: Size;
+    protected lastCollection: Collection<Node<T>> | null;
+    protected rootNodes: LayoutNode[];
+    private invalidateEverything;
+    /** The rectangle containing currently valid layout infos. */
+    protected validRect: Rect;
+    /** The rectangle of requested layout infos so far. */
+    protected requestedRect: Rect;
+    /**
+     * Creates a new ListLayout with options. See the list of properties below for a description
+     * of the options that can be provided.
+     */
+    constructor(options?: ListLayoutOptions);
+    protected get collection(): Collection<Node<T>>;
+    /** @deprecated Use `rowSize` instead. */
+    protected get rowHeight(): number | null;
+    /** @deprecated Use `estimatedRowSize` instead. */
+    protected get estimatedRowHeight(): number | null;
+    /** @deprecated Use `headingSize` instead. */
+    protected get headingHeight(): number | null;
+    /** @deprecated Use `estimatedHeadingSize` instead. */
+    protected get estimatedHeadingHeight(): number | null;
+    /** @deprecated Use `loaderSize` instead. */
+    protected get loaderHeight(): number | null;
+    getLayoutInfo(key: Key): LayoutInfo | null;
+    getVisibleLayoutInfos(rect: Rect): LayoutInfo[];
+    protected layoutIfNeeded(rect: Rect): void;
+    private ensureLayoutInfo;
+    protected isVisible(node: LayoutNode, rect: Rect): boolean;
+    protected shouldInvalidateEverything(invalidationContext: InvalidationContext<O>): boolean;
+    shouldInvalidateLayoutOptions(newOptions: O, oldOptions: O): boolean;
+    update(invalidationContext: InvalidationContext<O>): void;
+    protected buildCollection(offset?: number): LayoutNode[];
+    protected isValid(node: Node<T>, offset: number): boolean;
+    protected buildChild(node: Node<T>, x: number, y: number, parentKey: Key | null): LayoutNode;
+    protected buildNode(node: Node<T>, x: number, y: number): LayoutNode;
+    protected buildLoader(node: Node<T>, x: number, y: number): LayoutNode;
+    protected buildSection(node: Node<T>, x: number, y: number): LayoutNode;
+    protected buildSectionHeader(node: Node<T>, x: number, y: number): LayoutNode;
+    protected buildItem(node: Node<T>, x: number, y: number): LayoutNode;
+    updateItemSize(key: Key, size: Size): boolean;
+    private updateLayoutNode;
+    getContentSize(): Size;
+    getDropTargetFromPoint(x: number, y: number, isValidDropTarget: (target: DropTarget) => boolean): DropTarget | null;
+    getDropTargetLayoutInfo(target: ItemDropTarget): LayoutInfo;
+}

package/dist/types/src/layout/TableLayout.d.ts

@@ -0,0 +1,72 @@
+import { DropTarget, ItemDropTarget, Key } from '@react-types/shared';
+import { GridNode } from '../grid/GridCollection';
+import { InvalidationContext } from '../virtualizer/types';
+import { LayoutInfo } from '../virtualizer/LayoutInfo';
+import { LayoutNode, ListLayout, ListLayoutOptions } from './ListLayout';
+import { Rect } from '../virtualizer/Rect';
+import { ITableCollection as TableCollection } from '../table/TableCollection';
+export interface TableLayoutProps extends Omit<ListLayoutOptions, 'orientation' | 'rowSize' | 'estimatedRowSize' | 'headingSize' | 'estimatedHeadingSize' | 'loaderSize'> {
+    /**
+     * The fixed height of a row in px.
+     * @default 48
+     */
+    rowHeight?: number;
+    /** The estimated height of a row, when row heights are variable.
+     */
+    estimatedRowHeight?: number;
+    /**
+     * The fixed height of a section header in px.
+     * @default 48
+     */
+    headingHeight?: number;
+    /** The estimated height of a section header, when the height is variable.
+     */
+    estimatedHeadingHeight?: number;
+    /**
+     * The fixed height of a loader element in px. This loader is specifically for
+     * "load more" elements rendered when loading more rows at the root level or inside nested row/sections.
+     * @default 48
+     */
+    loaderHeight?: number;
+    columnWidths?: Map<Key, number>;
+}
+/**
+ * TableLayout is a virtualizer Layout implementation that arranges
+ * items in rows and columns.
+ */
+export declare class TableLayout<T, O extends TableLayoutProps = TableLayoutProps> extends ListLayout<T, O> {
+    protected lastCollection: TableCollection<T> | null;
+    private columnWidths;
+    private stickyColumnIndices;
+    private lastPersistedKeys;
+    private persistedIndices;
+    constructor(options?: TableLayoutProps);
+    protected get collection(): TableCollection<T>;
+    protected get rowHeight(): number | null;
+    protected get estimatedRowHeight(): number | null;
+    protected get headingHeight(): number | null;
+    protected get estimatedHeadingHeight(): number | null;
+    protected get loaderHeight(): number | null;
+    private columnsChanged;
+    shouldInvalidateLayoutOptions(newOptions: O, oldOptions: O): boolean;
+    update(invalidationContext: InvalidationContext<O>): void;
+    protected buildCollection(): LayoutNode[];
+    protected buildTableHeader(): LayoutNode;
+    protected buildHeaderRow(headerRow: GridNode<T>, x: number, y: number): LayoutNode;
+    private setChildHeights;
+    private getRenderedColumnWidth;
+    private getEstimatedHeight;
+    protected getEstimatedRowHeight(): number;
+    protected buildColumn(node: GridNode<T>, x: number, y: number): LayoutNode;
+    protected isStickyColumn(node: GridNode<T>): boolean;
+    protected buildBody(y: number): LayoutNode;
+    protected buildNode(node: GridNode<T>, x: number, y: number): LayoutNode;
+    protected buildRow(node: GridNode<T>, x: number, y: number): LayoutNode;
+    protected buildCell(node: GridNode<T>, x: number, y: number): LayoutNode;
+    getVisibleLayoutInfos(rect: Rect): LayoutInfo[];
+    private addVisibleLayoutInfos;
+    private binarySearch;
+    private buildPersistedIndices;
+    getDropTargetFromPoint(x: number, y: number, isValidDropTarget: (target: DropTarget) => boolean): DropTarget | null;
+    getDropTargetLayoutInfo(target: ItemDropTarget): LayoutInfo;
+}

package/dist/types/src/layout/WaterfallLayout.d.ts

@@ -0,0 +1,61 @@
+import { DropTarget, DropTargetDelegate, Key, LayoutDelegate, Node } from '@react-types/shared';
+import { InvalidationContext } from '../virtualizer/types';
+import { Layout } from '../virtualizer/Layout';
+import { LayoutInfo } from '../virtualizer/LayoutInfo';
+import { Rect } from '../virtualizer/Rect';
+import { Size } from '../virtualizer/Size';
+export interface WaterfallLayoutOptions {
+    /**
+     * The minimum item size.
+     * @default 200 x 200
+     */
+    minItemSize?: Size;
+    /**
+     * The maximum item size.
+     * @default Infinity
+     */
+    maxItemSize?: Size;
+    /**
+     * The minimum space required between items.
+     * @default 18 x 18
+     */
+    minSpace?: Size;
+    /**
+     * The maximum allowed horizontal space between items.
+     * @default Infinity
+     */
+    maxHorizontalSpace?: number;
+    /**
+     * The maximum number of columns.
+     * @default Infinity
+     */
+    maxColumns?: number;
+    /**
+     * The thickness of the drop indicator.
+     * @default 2
+     */
+    dropIndicatorThickness?: number;
+    /**
+     * The fixed height of a loader element in px. This loader is specifically for
+     * "load more" elements rendered when loading more rows at the root level or inside nested row/sections.
+     * @default 48
+     */
+    loaderHeight?: number;
+}
+export declare class WaterfallLayout<T extends object, O extends WaterfallLayoutOptions = WaterfallLayoutOptions> extends Layout<Node<T>, O> implements LayoutDelegate, DropTargetDelegate {
+    private contentSize;
+    private layoutInfos;
+    protected numColumns: number;
+    protected dropIndicatorThickness: number;
+    private margin;
+    shouldInvalidateLayoutOptions(newOptions: O, oldOptions: O): boolean;
+    update(invalidationContext: InvalidationContext<O>): void;
+    getLayoutInfo(key: Key): LayoutInfo;
+    getContentSize(): Size;
+    getVisibleLayoutInfos(rect: Rect): LayoutInfo[];
+    updateItemSize(key: Key, size: Size): boolean;
+    getKeyRightOf(key: Key): Key | null;
+    getKeyLeftOf(key: Key): Key | null;
+    getKeyRange(from: Key, to: Key): Key[];
+    getDropTargetFromPoint(x: number, y: number): DropTarget;
+}

package/dist/types/src/list/ListCollection.d.ts

@@ -0,0 +1,19 @@
+import { Collection, Key, Node } from '@react-types/shared';
+export declare class ListCollection<T> implements Collection<Node<T>> {
+    private keyMap;
+    private iterable;
+    private firstKey;
+    private lastKey;
+    private _size;
+    constructor(nodes: Iterable<Node<T>>);
+    [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;
+    getChildren(key: Key): Iterable<Node<T>>;
+}

package/dist/types/src/list/useListState.d.ts

@@ -0,0 +1,31 @@
+import { Collection, CollectionStateBase, Key, LayoutDelegate, Node } from '@react-types/shared';
+import { MultipleSelectionStateProps } from '../selection/useMultipleSelectionState';
+import { SelectionManager } from '../selection/SelectionManager';
+export interface ListProps<T> extends CollectionStateBase<T>, MultipleSelectionStateProps {
+    /** Filter function to generate a filtered list of nodes. */
+    filter?: (nodes: Iterable<Node<T>>) => Iterable<Node<T>>;
+    /** @private */
+    suppressTextValueWarning?: boolean;
+    /**
+     * A delegate object that provides layout information for items in the collection.
+     * This can be used to override the behavior of shift selection.
+     */
+    layoutDelegate?: LayoutDelegate;
+}
+export interface ListState<T> {
+    /** A collection of items in the list. */
+    collection: Collection<Node<T>>;
+    /** A set of items that are disabled. */
+    disabledKeys: Set<Key>;
+    /** A selection manager to read and update multiple selection state. */
+    selectionManager: SelectionManager;
+}
+/**
+ * Provides state management for list-like components. Handles building a collection
+ * of items from props, and manages multiple selection state.
+ */
+export declare function useListState<T extends object>(props: ListProps<T>): ListState<T>;
+/**
+ * Filters a collection using the provided filter function and returns a new ListState.
+ */
+export declare function UNSTABLE_useFilteredListState<T extends object>(state: ListState<T>, filterFn: ((nodeValue: string, node: Node<T>) => boolean) | null | undefined): ListState<T>;