react-aria-components 1.15.1 → 1.17.0

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

@@ -0,0 +1,16 @@
+import { ClassNameOrFunction, ContextValue, StyleRenderProps } from './utils';
+import { HoverEvents } from '@react-types/shared';
+import { InputRenderProps } from './Input';
+import React, { TextareaHTMLAttributes } from 'react';
+export interface TextAreaProps extends Omit<TextareaHTMLAttributes<HTMLTextAreaElement>, 'className' | 'style'>, HoverEvents, StyleRenderProps<InputRenderProps, 'textarea'> {
+    /**
+     * The CSS [className](https://developer.mozilla.org/en-US/docs/Web/API/Element/className) for the element. A function may be provided to compute the class based on component state.
+     * @default 'react-aria-TextArea'
+     */
+    className?: ClassNameOrFunction<InputRenderProps>;
+}
+export declare const TextAreaContext: React.Context<ContextValue<TextAreaProps, HTMLTextAreaElement>>;
+/**
+ * A textarea allows a user to input mult-line text.
+ */
+export declare const TextArea: React.ForwardRefExoticComponent<TextAreaProps & React.RefAttributes<HTMLTextAreaElement>>;

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

@@ -0,0 +1,40 @@
+import { AriaTextFieldProps } from 'react-aria/useTextField';
+import { ClassNameOrFunction, ContextValue, DOMProps, RACValidation, RenderProps, SlotProps } from './utils';
+import { GlobalDOMAttributes } from '@react-types/shared';
+import React from 'react';
+export interface TextFieldRenderProps {
+    /**
+     * Whether the text field is disabled.
+     * @selector [data-disabled]
+     */
+    isDisabled: boolean;
+    /**
+     * Whether the value is invalid.
+     * @selector [data-invalid]
+     */
+    isInvalid: boolean;
+    /**
+     * Whether the text field is read only.
+     * @selector [data-readonly]
+     */
+    isReadOnly: boolean;
+    /**
+     * Whether the text field is required.
+     * @selector [data-required]
+     */
+    isRequired: boolean;
+}
+export interface TextFieldProps extends Omit<AriaTextFieldProps, 'label' | 'placeholder' | 'description' | 'errorMessage' | 'validationState' | 'validationBehavior'>, RACValidation, Omit<DOMProps, 'style' | 'className' | 'render' | 'children'>, SlotProps, RenderProps<TextFieldRenderProps>, GlobalDOMAttributes<HTMLDivElement> {
+    /**
+     * The CSS [className](https://developer.mozilla.org/en-US/docs/Web/API/Element/className) for the element. A function may be provided to compute the class based on component state.
+     * @default 'react-aria-TextField'
+     */
+    className?: ClassNameOrFunction<TextFieldRenderProps>;
+    /** Whether the value is invalid. */
+    isInvalid?: boolean;
+}
+export declare const TextFieldContext: React.Context<ContextValue<TextFieldProps, HTMLDivElement>>;
+/**
+ * A text field allows a user to enter a plain text value with a keyboard.
+ */
+export declare const TextField: (props: TextFieldProps & React.RefAttributes<HTMLDivElement>) => React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | null;

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

@@ -0,0 +1,84 @@
+import { AriaToastProps, AriaToastRegionProps } from 'react-aria/useToast';
+import { ClassNameOrFunction, ContextValue, DOMRenderProps, RenderProps, StyleRenderProps } from './utils';
+import { GlobalDOMAttributes } from '@react-types/shared';
+import { QueuedToast, ToastQueue, ToastState } from 'react-stately/useToastState';
+import React, { HTMLAttributes, ReactElement, ReactNode } from 'react';
+declare const ToastStateContext: React.Context<ToastState<any> | null>;
+export interface ToastRegionRenderProps<T> {
+    /** A list of all currently visible toasts. */
+    visibleToasts: QueuedToast<T>[];
+    /**
+     * Whether the toast region is currently hovered with a mouse.
+     * @selector [data-hovered]
+     */
+    isHovered: boolean;
+    /**
+     * Whether the toast region is currently focused.
+     * @selector [data-focused]
+     */
+    isFocused: boolean;
+    /**
+     * Whether the toast region is keyboard focused.
+     * @selector [data-focus-visible]
+     */
+    isFocusVisible: boolean;
+}
+export interface ToastRegionProps<T> extends AriaToastRegionProps, StyleRenderProps<ToastRegionRenderProps<T>>, GlobalDOMAttributes<HTMLDivElement> {
+    /**
+     * The CSS [className](https://developer.mozilla.org/en-US/docs/Web/API/Element/className) for the element. A function may be provided to compute the class based on component state.
+     * @default 'react-aria-ToastRegion'
+     */
+    className?: ClassNameOrFunction<ToastRegionRenderProps<T>>;
+    /** The queue of toasts to display. */
+    queue: ToastQueue<T>;
+    /** A function to render each toast, or children containing a `<ToastList>`. */
+    children: ReactNode | ((renderProps: {
+        toast: QueuedToast<T>;
+    }) => ReactElement);
+}
+/**
+ * A ToastRegion displays one or more toast notifications.
+ */
+declare const ToastRegion: <T>(props: ToastRegionProps<T> & React.RefAttributes<HTMLDivElement>) => ReactElement<unknown, string | React.JSXElementConstructor<any>> | null;
+export interface ToastListProps<T> extends Omit<ToastRegionProps<T>, 'queue' | 'children' | 'render'>, DOMRenderProps<'ol', ToastRegionRenderProps<T>> {
+    /** A function to render each toast. */
+    children: (renderProps: {
+        toast: QueuedToast<T>;
+    }) => ReactElement;
+}
+declare const ToastList: <T>(props: ToastListProps<T> & React.RefAttributes<HTMLOListElement>) => ReactElement<unknown, string | React.JSXElementConstructor<any>> | null;
+export interface ToastRenderProps<T> {
+    /**
+     * The toast object to display.
+     */
+    toast: QueuedToast<T>;
+    /**
+     * Whether the toast is currently focused.
+     * @selector [data-focused]
+     */
+    isFocused: boolean;
+    /**
+     * Whether the toast is keyboard focused.
+     * @selector [data-focus-visible]
+     */
+    isFocusVisible: boolean;
+}
+export interface ToastProps<T> extends AriaToastProps<T>, RenderProps<ToastRenderProps<T>>, GlobalDOMAttributes<HTMLDivElement> {
+    /**
+     * The CSS [className](https://developer.mozilla.org/en-US/docs/Web/API/Element/className) for the element. A function may be provided to compute the class based on component state.
+     * @default 'react-aria-Toast'
+     */
+    className?: ClassNameOrFunction<ToastRenderProps<T>>;
+}
+/**
+ * A Toast displays a brief, temporary notification of actions, errors, or other events in an application.
+ */
+declare const Toast: <T>(props: ToastProps<T> & React.RefAttributes<HTMLDivElement>) => ReactElement<unknown, string | React.JSXElementConstructor<any>> | null;
+export interface ToastContentProps extends HTMLAttributes<HTMLElement>, DOMRenderProps<'div', undefined> {
+}
+export declare const ToastContentContext: React.Context<ContextValue<HTMLAttributes<HTMLElement>, HTMLDivElement>>;
+/**
+ * ToastContent wraps the main content of a toast notification.
+ */
+export declare const ToastContent: React.ForwardRefExoticComponent<ToastContentProps & React.RefAttributes<HTMLDivElement>>;
+export { Toast as UNSTABLE_Toast, ToastList as UNSTABLE_ToastList, ToastRegion as UNSTABLE_ToastRegion, ToastContent as UNSTABLE_ToastContent, ToastStateContext as UNSTABLE_ToastStateContext };

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

@@ -0,0 +1,32 @@
+import { AriaToggleButtonProps } from 'react-aria/useToggleButton';
+import { ButtonRenderProps } from './Button';
+import { ClassNameOrFunction, ContextValue, RenderProps, SlotProps } from './utils';
+import { GlobalDOMAttributes, Key } from '@react-types/shared';
+import { HoverEvents } from '@react-types/shared';
+import React from 'react';
+import { ToggleState } from 'react-stately/useToggleState';
+export interface ToggleButtonRenderProps extends Omit<ButtonRenderProps, 'isPending'> {
+    /**
+     * Whether the button is currently selected.
+     * @selector [data-selected]
+     */
+    isSelected: boolean;
+    /**
+     * State of the toggle button.
+     */
+    state: ToggleState;
+}
+export interface ToggleButtonProps extends Omit<AriaToggleButtonProps, 'children' | 'elementType' | 'id'>, HoverEvents, SlotProps, RenderProps<ToggleButtonRenderProps, 'button'>, Omit<GlobalDOMAttributes<HTMLDivElement>, 'onClick'> {
+    /**
+     * The CSS [className](https://developer.mozilla.org/en-US/docs/Web/API/Element/className) for the element. A function may be provided to compute the class based on component state.
+     * @default 'react-aria-ToggleButton'
+     */
+    className?: ClassNameOrFunction<ToggleButtonRenderProps>;
+    /** When used in a ToggleButtonGroup, an identifier for the item in `selectedKeys`. When used standalone, a DOM id. */
+    id?: Key;
+}
+export declare const ToggleButtonContext: React.Context<ContextValue<ToggleButtonProps, HTMLButtonElement>>;
+/**
+ * A toggle button allows a user to toggle a selection on or off, for example switching between two states or modes.
+ */
+export declare const ToggleButton: (props: ToggleButtonProps & React.RefAttributes<HTMLButtonElement>) => React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | null;

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

@@ -0,0 +1,34 @@
+import { AriaToggleButtonGroupProps } from 'react-aria/useToggleButtonGroup';
+import { ClassNameOrFunction, ContextValue, RenderProps, SlotProps } from './utils';
+import { GlobalDOMAttributes, Orientation } from '@react-types/shared';
+import React from 'react';
+import { ToggleGroupState } from 'react-stately/useToggleGroupState';
+export interface ToggleButtonGroupRenderProps {
+    /**
+     * The orientation of the toggle button group.
+     * @selector [data-orientation="horizontal | vertical"]
+     */
+    orientation: Orientation;
+    /**
+     * Whether the toggle button group is disabled.
+     * @selector [data-disabled]
+     */
+    isDisabled: boolean;
+    /**
+     * State of the toggle button group.
+     */
+    state: ToggleGroupState;
+}
+export interface ToggleButtonGroupProps extends AriaToggleButtonGroupProps, RenderProps<ToggleButtonGroupRenderProps>, SlotProps, GlobalDOMAttributes<HTMLDivElement> {
+    /**
+     * The CSS [className](https://developer.mozilla.org/en-US/docs/Web/API/Element/className) for the element. A function may be provided to compute the class based on component state.
+     * @default 'react-aria-ToggleButtonGroup'
+     */
+    className?: ClassNameOrFunction<ToggleButtonGroupRenderProps>;
+}
+export declare const ToggleButtonGroupContext: React.Context<ContextValue<ToggleButtonGroupProps, HTMLDivElement>>;
+export declare const ToggleGroupStateContext: React.Context<ToggleGroupState | null>;
+/**
+ * A toggle button group allows a user to toggle multiple options, with single or multiple selection.
+ */
+export declare const ToggleButtonGroup: (props: ToggleButtonGroupProps & React.RefAttributes<HTMLDivElement>) => React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | null;

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

@@ -0,0 +1,24 @@
+import { AriaToolbarProps } from 'react-aria/useToolbar';
+import { ClassNameOrFunction, ContextValue, RenderProps, SlotProps } from './utils';
+import { GlobalDOMAttributes, Orientation } from '@react-types/shared';
+import React from 'react';
+export interface ToolbarRenderProps {
+    /**
+     * The current orientation of the toolbar.
+     * @selector [data-orientation]
+     */
+    orientation: Orientation;
+}
+export interface ToolbarProps extends AriaToolbarProps, SlotProps, RenderProps<ToolbarRenderProps>, GlobalDOMAttributes<HTMLDivElement> {
+    /**
+     * The CSS [className](https://developer.mozilla.org/en-US/docs/Web/API/Element/className) for the element. A function may be provided to compute the class based on component state.
+     * @default 'react-aria-Toolbar'
+     */
+    className?: ClassNameOrFunction<ToolbarRenderProps>;
+}
+export declare const ToolbarContext: React.Context<ContextValue<ToolbarProps, HTMLDivElement>>;
+/**
+ * A toolbar is a container for a set of interactive controls, such as buttons, dropdown menus, or checkboxes,
+ * with arrow key navigation.
+ */
+export declare const Toolbar: (props: ToolbarProps & React.RefAttributes<HTMLDivElement>) => React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | null;

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

@@ -0,0 +1,74 @@
+import { AriaLabelingProps, GlobalDOMAttributes, RefObject } from '@react-types/shared';
+import { AriaPositionProps, Placement, PlacementAxis, PositionProps } from 'react-aria/useOverlayPosition';
+import { ClassNameOrFunction, ContextValue, RenderProps } from './utils';
+import { OverlayTriggerProps } from 'react-stately/useOverlayTriggerState';
+import React, { JSX, ReactNode } from 'react';
+import { TooltipTriggerProps, TooltipTriggerState } from 'react-stately/useTooltipTriggerState';
+export interface TooltipTriggerComponentProps extends TooltipTriggerProps {
+    children: ReactNode;
+}
+export interface TooltipProps extends PositionProps, Pick<AriaPositionProps, 'arrowBoundaryOffset'>, OverlayTriggerProps, AriaLabelingProps, RenderProps<TooltipRenderProps>, GlobalDOMAttributes<HTMLDivElement> {
+    /**
+     * The CSS [className](https://developer.mozilla.org/en-US/docs/Web/API/Element/className) for the element. A function may be provided to compute the class based on component state.
+     * @default 'react-aria-Tooltip'
+     */
+    className?: ClassNameOrFunction<TooltipRenderProps>;
+    /**
+     * The ref for the element which the tooltip positions itself with respect to.
+     *
+     * When used within a TooltipTrigger this is set automatically. It is only required when used standalone.
+     */
+    triggerRef?: RefObject<Element | null>;
+    /**
+     * Whether the tooltip is currently performing an entry animation.
+     */
+    isEntering?: boolean;
+    /**
+     * Whether the tooltip is currently performing an exit animation.
+     */
+    isExiting?: boolean;
+    /**
+     * The container element in which the overlay portal will be placed. This may have unknown behavior depending on where it is portalled to.
+     * @default document.body
+     * @deprecated - Use a parent UNSAFE_PortalProvider to set your portal container instead.
+     */
+    UNSTABLE_portalContainer?: Element;
+    /**
+     * The placement of the tooltip with respect to the trigger.
+     * @default 'top'
+     */
+    placement?: Placement;
+}
+export interface TooltipRenderProps {
+    /**
+     * The placement of the tooltip relative to the trigger.
+     * @selector [data-placement="left | right | top | bottom"]
+     */
+    placement: PlacementAxis | null;
+    /**
+     * Whether the tooltip is currently entering. Use this to apply animations.
+     * @selector [data-entering]
+     */
+    isEntering: boolean;
+    /**
+     * Whether the tooltip is currently exiting. Use this to apply animations.
+     * @selector [data-exiting]
+     */
+    isExiting: boolean;
+    /**
+     * State of the tooltip.
+     */
+    state: TooltipTriggerState;
+}
+export declare const TooltipTriggerStateContext: React.Context<TooltipTriggerState | null>;
+export declare const TooltipContext: React.Context<ContextValue<TooltipProps, HTMLDivElement>>;
+/**
+ * TooltipTrigger wraps around a trigger element and a Tooltip. It handles opening and closing
+ * the Tooltip when the user hovers over or focuses the trigger, and positioning the Tooltip
+ * relative to the trigger.
+ */
+export declare function TooltipTrigger(props: TooltipTriggerComponentProps): JSX.Element;
+/**
+ * A tooltip displays a description of an element on hover or focus.
+ */
+export declare const Tooltip: (props: TooltipProps & React.RefAttributes<HTMLDivElement>) => React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | null;

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

@@ -0,0 +1,164 @@
+import { AriaTreeItemOptions } from 'react-aria/useTree';
+import { AriaTreeProps } from 'react-aria/useTree';
+import { ChildrenOrFunction, ClassNameOrFunction, ContextValue, DOMRenderProps, RenderProps, SlotProps, StyleRenderProps } from './utils';
+import { CollectionProps, ItemRenderProps, SectionProps } from './Collection';
+import { DisabledBehavior, Expandable, GlobalDOMAttributes, HoverEvents, Key, LinkDOMProps, MultipleSelection, PressEvents, SelectionMode } from '@react-types/shared';
+import { DragAndDropHooks } from './useDragAndDrop';
+import { GridListHeaderProps } from './GridList';
+import { LoadMoreSentinelProps } from 'react-aria/private/utils/useLoadMoreSentinel';
+import { SelectionBehavior } from '@react-types/shared';
+import React, { ReactNode } from 'react';
+import { TreeState } from 'react-stately/useTreeState';
+export interface TreeRenderProps {
+    /**
+     * Whether the tree has no items and should display its empty state.
+     * @selector [data-empty]
+     */
+    isEmpty: boolean;
+    /**
+     * Whether the tree is currently focused.
+     * @selector [data-focused]
+     */
+    isFocused: boolean;
+    /**
+     * Whether the tree is currently keyboard focused.
+     * @selector [data-focus-visible]
+     */
+    isFocusVisible: boolean;
+    /**
+     * The type of selection that is allowed in the collection.
+     * @selector [data-selection-mode="single | multiple"]
+     */
+    selectionMode: SelectionMode;
+    /**
+     * Whether the tree allows dragging.
+     * @selector [data-allows-dragging]
+     */
+    allowsDragging: boolean;
+    /**
+     * State of the tree.
+     */
+    state: TreeState<unknown>;
+}
+export interface TreeEmptyStateRenderProps extends Omit<TreeRenderProps, 'isEmpty'> {
+}
+export interface TreeProps<T> extends Omit<AriaTreeProps<T>, 'children'>, MultipleSelection, CollectionProps<T>, StyleRenderProps<TreeRenderProps>, SlotProps, Expandable, GlobalDOMAttributes<HTMLDivElement> {
+    /**
+     * The CSS [className](https://developer.mozilla.org/en-US/docs/Web/API/Element/className) for the element. A function may be provided to compute the class based on component state.
+     * @default 'react-aria-Tree'
+     */
+    className?: ClassNameOrFunction<TreeRenderProps>;
+    /**
+     * How multiple selection should behave in the tree.
+     * @default "toggle"
+     */
+    selectionBehavior?: SelectionBehavior;
+    /** Provides content to display when there are no items in the list. */
+    renderEmptyState?: (props: TreeEmptyStateRenderProps) => ReactNode;
+    /**
+     * Whether `disabledKeys` applies to all interactions, or only selection.
+     * @default 'all'
+     */
+    disabledBehavior?: DisabledBehavior;
+    /** The drag and drop hooks returned by `useDragAndDrop` used to enable drag and drop behavior for the Tree. */
+    dragAndDropHooks?: DragAndDropHooks<NoInfer<T>>;
+}
+export declare const TreeContext: React.Context<ContextValue<TreeProps<any>, HTMLDivElement>>;
+export declare const TreeStateContext: React.Context<TreeState<any> | null>;
+/**
+ * A tree provides users with a way to navigate nested hierarchical information, with support for keyboard navigation
+ * and selection.
+ */
+export declare const Tree: <T extends object>(props: TreeProps<T> & React.RefAttributes<HTMLDivElement>) => React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | null;
+export interface TreeItemRenderProps extends ItemRenderProps {
+    /**
+     * Whether the tree item is expanded.
+     * @selector [data-expanded]
+     */
+    isExpanded: boolean;
+    /**
+     * Whether the tree item has child tree items.
+     * @selector [data-has-child-items]
+     */
+    hasChildItems: boolean;
+    /**
+     * What level the tree item has within the tree.
+     * @selector [data-level="number"]
+     */
+    level: number;
+    /**
+     * Whether the tree item's children have keyboard focus.
+     * @selector [data-focus-visible-within]
+     */
+    isFocusVisibleWithin: boolean;
+    /** The state of the tree. */
+    state: TreeState<unknown>;
+    /** The unique id of the tree row. */
+    id: Key;
+}
+export interface TreeItemContentRenderProps extends TreeItemRenderProps {
+}
+export interface TreeItemContentProps {
+    /** The children of the component. A function may be provided to alter the children based on component state. */
+    children: ChildrenOrFunction<TreeItemContentRenderProps>;
+}
+export declare const TreeItemContent: (props: TreeItemContentProps & React.RefAttributes<Element>) => React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | null;
+export declare const TreeItemContentContext: React.Context<TreeItemContentRenderProps | null>;
+export interface TreeItemProps<T = object> extends StyleRenderProps<TreeItemRenderProps>, LinkDOMProps, HoverEvents, PressEvents, Pick<AriaTreeItemOptions, 'hasChildItems'>, Omit<GlobalDOMAttributes<HTMLDivElement>, 'onClick'> {
+    /**
+     * The CSS [className](https://developer.mozilla.org/en-US/docs/Web/API/Element/className) for the element. A function may be provided to compute the class based on component state.
+     * @default 'react-aria-TreeItem'
+     */
+    className?: ClassNameOrFunction<TreeItemRenderProps>;
+    /** The unique id of the tree row. */
+    id?: Key;
+    /** The object value that this tree item represents. When using dynamic collections, this is set automatically. */
+    value?: T;
+    /** A string representation of the tree item's contents, used for features like typeahead. */
+    textValue: string;
+    /** An accessibility label for this tree item. */
+    'aria-label'?: string;
+    /** The content of the tree item along with any nested children. Supports static nested tree items or use of a Collection to dynamically render nested tree items. */
+    children: ReactNode;
+    /** Whether the item is disabled. */
+    isDisabled?: boolean;
+    /**
+     * Handler that is called when a user performs an action on this tree item. The exact user event depends on
+     * the collection's `selectionBehavior` prop and the interaction modality.
+     */
+    onAction?: () => void;
+}
+/**
+ * A TreeItem represents an individual item in a Tree.
+ */
+export declare const TreeItem: <T extends object>(props: TreeItemProps<T> & React.RefAttributes<HTMLDivElement>) => React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | null;
+export interface TreeLoadMoreItemRenderProps {
+    /**
+     * What level the tree item has within the tree.
+     * @selector [data-level]
+     */
+    level: number;
+}
+export interface TreeLoadMoreItemProps extends Omit<LoadMoreSentinelProps, 'collection'>, RenderProps<TreeLoadMoreItemRenderProps> {
+    /**
+     * The CSS [className](https://developer.mozilla.org/en-US/docs/Web/API/Element/className) for the element. A function may be provided to compute the class based on component state.
+     * @default 'react-aria-TreeLoadMoreItem'
+     */
+    className?: ClassNameOrFunction<TreeLoadMoreItemRenderProps>;
+    /**
+     * The load more spinner to render when loading additional items.
+     */
+    children?: ChildrenOrFunction<TreeLoadMoreItemRenderProps>;
+    /**
+     * Whether or not the loading spinner should be rendered or not.
+     */
+    isLoading?: boolean;
+}
+export declare const TreeLoadMoreItem: <T extends object>(props: TreeLoadMoreItemProps & React.RefAttributes<HTMLDivElement>) => React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | null;
+export interface GridListSectionProps<T> extends SectionProps<T>, DOMRenderProps<'div', undefined> {
+}
+/**
+ * A TreeSection represents a section within a Tree.
+ */
+export declare const TreeSection: <T extends object>(props: GridListSectionProps<T> & React.RefAttributes<HTMLDivElement>) => React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | null;
+export declare const TreeHeader: (props: GridListHeaderProps) => ReactNode;

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

@@ -0,0 +1,23 @@
+import { Direction, DropTarget, DropTargetDelegate, Key, Node } from '@react-types/shared';
+interface TreeCollection<T> extends Iterable<Node<T>> {
+    getItem(key: Key): Node<T> | null;
+    getChildren?(key: Key): Iterable<Node<T>>;
+    getKeyAfter(key: Key): Key | null;
+    getKeyBefore(key: Key): Key | null;
+}
+interface TreeState<T> {
+    collection: TreeCollection<T>;
+    expandedKeys: Set<Key>;
+}
+export declare class TreeDropTargetDelegate<T> {
+    private delegate;
+    private state;
+    private direction;
+    private pointerTracking;
+    setup(delegate: DropTargetDelegate, state: TreeState<T>, direction: Direction): void;
+    getDropTargetFromPoint(x: number, y: number, isValidDropTarget: (target: DropTarget) => boolean): DropTarget | null;
+    private resolveDropTarget;
+    private getPotentialTargets;
+    private selectTarget;
+}
+export {};

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

@@ -0,0 +1,26 @@
+import { DropTargetDelegate, Node } from '@react-types/shared';
+import { Layout } from 'react-stately/useVirtualizerState';
+import { JSX, ReactNode } from 'react';
+export interface LayoutOptionsDelegate<O> {
+    useLayoutOptions?(): O;
+}
+interface ILayout<O> extends Layout<Node<unknown>, O>, Partial<DropTargetDelegate>, LayoutOptionsDelegate<O> {
+}
+interface LayoutClass<O> {
+    new (): ILayout<O>;
+}
+export interface VirtualizerProps<O> {
+    /** The child collection to virtualize (e.g. ListBox, GridList, or Table). */
+    children: ReactNode;
+    /** The layout object that determines the position and size of the visible elements. */
+    layout: LayoutClass<O> | ILayout<O>;
+    /** Options for the layout. */
+    layoutOptions?: O;
+}
+/**
+ * A Virtualizer renders a scrollable collection of data using customizable layouts.
+ * It supports very large collections by only rendering visible items to the DOM, reusing
+ * them as the user scrolls.
+ */
+export declare function Virtualizer<O>(props: VirtualizerProps<O>): JSX.Element;
+export {};

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

@@ -0,0 +1,68 @@
+import { DropIndicatorProps as AriaDropIndicatorProps, DropIndicatorAria, DroppableCollectionOptions, DroppableCollectionResult, DroppableItemOptions, DroppableItemResult } from 'react-aria/useDroppableCollection';
+import { DraggableCollectionOptions, DraggableItemProps, DraggableItemResult, DragPreview } from 'react-aria/useDraggableCollection';
+import { DraggableCollectionProps, DroppableCollectionProps, Key, RefObject } from '@react-types/shared';
+import { DraggableCollectionState, DraggableCollectionStateOptions } from 'react-stately/useDraggableCollectionState';
+import { DragItem, DropTarget, DropTargetDelegate } from '@react-types/shared';
+import { DroppableCollectionState, DroppableCollectionStateOptions } from 'react-stately/useDroppableCollectionState';
+import { JSX } from 'react';
+import { ListDropTargetDelegate } from 'react-aria/ListDropTargetDelegate';
+export { DropIndicator, DropIndicatorContext, DragAndDropContext } from './DragAndDrop';
+export type { DropIndicatorProps, DropIndicatorRenderProps } from './DragAndDrop';
+interface DraggableCollectionStateOpts<T = object> extends Omit<DraggableCollectionStateOptions<T>, 'getItems'> {
+}
+interface DragHooks<T = object> {
+    useDraggableCollectionState?: (props: DraggableCollectionStateOpts<T>) => DraggableCollectionState;
+    useDraggableCollection?: (props: DraggableCollectionOptions, state: DraggableCollectionState, ref: RefObject<HTMLElement | null>) => void;
+    useDraggableItem?: (props: DraggableItemProps, state: DraggableCollectionState) => DraggableItemResult;
+    DragPreview?: typeof DragPreview;
+    renderDragPreview?: (items: DragItem[]) => JSX.Element | {
+        element: JSX.Element;
+        x: number;
+        y: number;
+    };
+    isVirtualDragging?: () => boolean;
+}
+interface DropHooks {
+    useDroppableCollectionState?: (props: DroppableCollectionStateOptions) => DroppableCollectionState;
+    useDroppableCollection?: (props: DroppableCollectionOptions, state: DroppableCollectionState, ref: RefObject<HTMLElement | null>) => DroppableCollectionResult;
+    useDroppableItem?: (options: DroppableItemOptions, state: DroppableCollectionState, ref: RefObject<HTMLElement | null>) => DroppableItemResult;
+    useDropIndicator?: (props: AriaDropIndicatorProps, state: DroppableCollectionState, ref: RefObject<HTMLElement | null>) => DropIndicatorAria;
+    renderDropIndicator?: (target: DropTarget) => JSX.Element;
+    dropTargetDelegate?: DropTargetDelegate;
+    ListDropTargetDelegate: typeof ListDropTargetDelegate;
+}
+export type DragAndDropHooks<T = object> = DragHooks<T> & DropHooks;
+export interface DragAndDrop<T = object> {
+    /** Drag and drop hooks for the collection element.  */
+    dragAndDropHooks: DragAndDropHooks<T>;
+}
+export interface DragAndDropOptions<T = object> extends Omit<DraggableCollectionProps, 'preview' | 'getItems'>, DroppableCollectionProps {
+    /**
+     * A function that returns the items being dragged. If not specified, we assume that the collection is not draggable.
+     * @default () => []
+     */
+    getItems?: (keys: Set<Key>, items: T[]) => DragItem[];
+    /**
+     * A function that renders a drag preview, which is shown under the user's cursor while dragging.
+     * By default, a copy of the dragged element is rendered.
+     */
+    renderDragPreview?: (items: DragItem[]) => JSX.Element | {
+        element: JSX.Element;
+        x: number;
+        y: number;
+    };
+    /**
+     * A function that renders a drop indicator element between two items in a collection.
+     * This should render a `<DropIndicator>` element. If this function is not provided, a
+     * default DropIndicator is provided.
+     */
+    renderDropIndicator?: (target: DropTarget) => JSX.Element;
+    /** A custom delegate object that provides drop targets for pointer coordinates within the collection. */
+    dropTargetDelegate?: DropTargetDelegate;
+    /** Whether the drag and drop events should be disabled. */
+    isDisabled?: boolean;
+}
+/**
+ * Provides the hooks required to enable drag and drop behavior for a drag and drop compatible collection component.
+ */
+export declare function useDragAndDrop<T = object>(options: DragAndDropOptions<T>): DragAndDrop<T>;