@depup/react-aria-components 1.16.0-depup.0

package/src/TreeDropTargetDelegate.ts

@@ -0,0 +1,308 @@
+import {Direction, DropTarget, DropTargetDelegate, ItemDropTarget, Key, Node, RootDropTarget} 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>
+}
+
+interface PointerTracking {
+  lastY: number,
+  lastX: number,
+  yDirection: 'up' | 'down' | null,
+  xDirection: 'left' | 'right' | null,
+  boundaryContext: {
+    parentKey: Key,
+    lastSwitchY: number,
+    lastSwitchX: number,
+    preferredTargetIndex?: number
+  } | null
+}
+
+const X_SWITCH_THRESHOLD = 10;
+const Y_SWITCH_THRESHOLD = 5;
+export class TreeDropTargetDelegate<T> {
+  private delegate: DropTargetDelegate | null = null;
+  private state: TreeState<T> | null = null;
+  private direction: Direction = 'ltr';
+  private pointerTracking: PointerTracking = {
+    lastY: 0,
+    lastX: 0,
+    yDirection: null,
+    xDirection: null,
+    boundaryContext: null
+  };
+
+  setup(delegate: DropTargetDelegate, state: TreeState<T>, direction: Direction): void {
+    this.delegate = delegate;
+    this.state = state;
+    this.direction = direction;
+  }
+
+  getDropTargetFromPoint(x: number, y: number, isValidDropTarget: (target: DropTarget) => boolean): DropTarget | null {
+    let baseTarget = this.delegate!.getDropTargetFromPoint(x, y, isValidDropTarget);
+    if (!baseTarget || baseTarget.type === 'root') {
+      return baseTarget;
+    }
+
+    return this.resolveDropTarget(baseTarget, x, y, isValidDropTarget);
+  }
+
+  private resolveDropTarget(
+    target: ItemDropTarget,
+    x: number,
+    y: number,
+    isValidDropTarget: (target: DropTarget) => boolean
+  ): RootDropTarget | ItemDropTarget | null {
+    let tracking = this.pointerTracking;
+
+    // Calculate movement directions
+    let deltaY = y - tracking.lastY;
+    let deltaX = x - tracking.lastX;
+    let currentYMovement: 'up' | 'down' | null = tracking.yDirection;
+    let currentXMovement: 'left' | 'right' | null = tracking.xDirection;
+
+    if (Math.abs(deltaY) > Y_SWITCH_THRESHOLD) {
+      currentYMovement = deltaY > 0 ? 'down' : 'up';
+      tracking.yDirection = currentYMovement;
+      tracking.lastY = y;
+    }
+
+    if (Math.abs(deltaX) > X_SWITCH_THRESHOLD) {
+      currentXMovement = deltaX > 0 ? 'right' : 'left';
+      tracking.xDirection = currentXMovement;
+      tracking.lastX = x;
+    }
+
+    // Normalize to 'after'
+    if (target.dropPosition === 'before') {
+      let keyBefore = this.state!.collection.getKeyBefore(target.key);
+      if (keyBefore != null) {
+        let convertedTarget = {
+          type: 'item',
+          key: keyBefore,
+          dropPosition: 'after'
+        } as const;
+
+        if (isValidDropTarget(convertedTarget)) {
+          target = convertedTarget;
+        }
+      }
+    }
+
+    let potentialTargets = this.getPotentialTargets(target, isValidDropTarget);
+
+    if (potentialTargets.length === 0) {
+      return {type: 'root'};
+    }
+
+    let resolvedItemTarget: ItemDropTarget;
+    if (potentialTargets.length > 1) {
+      resolvedItemTarget = this.selectTarget(potentialTargets, target, x, y, currentYMovement, currentXMovement);
+    } else {
+      resolvedItemTarget = potentialTargets[0];
+      // Reset boundary context since we're not in a boundary case
+      tracking.boundaryContext = null;
+    }
+
+    return resolvedItemTarget;
+  }
+
+  // Returns potential targets for an ambiguous drop position (e.g. after the last child of a parent, or after the parent itself)
+  // Ordered by level, from innermost to outermost.
+  private getPotentialTargets(originalTarget: ItemDropTarget, isValidDropTarget: (target: DropTarget) => boolean): ItemDropTarget[] {
+    if (originalTarget.dropPosition === 'on') {
+      return [originalTarget];
+    }
+
+    let target = originalTarget;
+    let collection = this.state!.collection;
+
+    let currentItem = collection.getItem(target.key);
+    while (currentItem && currentItem?.type !== 'item' && currentItem.nextKey != null) {
+      target.key = currentItem.nextKey;
+      currentItem = collection.getItem(currentItem.nextKey);
+    }
+
+    let potentialTargets = [target];
+
+    // If target has children and is expanded, use "before first child"
+    if (currentItem && currentItem.hasChildNodes && this.state!.expandedKeys.has(currentItem.key) && collection.getChildren && target.dropPosition === 'after') {
+      let firstChildItemNode: Node<T> | null = null;
+      for (let child of collection.getChildren(currentItem.key)) {
+        if (child.type === 'item') {
+          firstChildItemNode = child;
+          break;
+        }
+      }
+
+      if (firstChildItemNode) {
+        const beforeFirstChildTarget = {
+          type: 'item',
+          key: firstChildItemNode.key,
+          dropPosition: 'before'
+        } as const;
+
+        if (isValidDropTarget(beforeFirstChildTarget)) {
+          return [beforeFirstChildTarget];
+        } else {
+          return [];
+        }
+      }
+    }
+
+    if (currentItem?.nextKey != null) {
+      return [originalTarget];
+    }
+
+    // Walk up the parent chain to find ancestors that are the last child at their level
+    let parentKey = currentItem?.parentKey;
+    let ancestorTargets: ItemDropTarget[] = [];
+
+    while (parentKey) {
+      let parentItem = collection.getItem(parentKey);
+      let nextItem = parentItem?.nextKey ? collection.getItem(parentItem.nextKey) : null;
+      let isLastChildAtLevel = !nextItem || nextItem.parentKey !== parentKey;
+
+      if (isLastChildAtLevel) {
+        let afterParentTarget = {
+          type: 'item',
+          key: parentKey,
+          dropPosition: 'after'
+        } as const;
+
+        if (isValidDropTarget(afterParentTarget)) {
+          ancestorTargets.push(afterParentTarget);
+        }
+        if (nextItem) {
+          break;
+        }
+      }
+
+      parentKey = parentItem?.parentKey;
+    }
+
+    if (ancestorTargets.length > 0) {
+      potentialTargets.push(...ancestorTargets);
+    }
+
+    // Handle converting "after" to "before next" for non-ambiguous cases
+    if (potentialTargets.length === 1) {
+      let nextKey = collection.getKeyAfter(target.key);
+      let nextNode = nextKey ? collection.getItem(nextKey) : null;
+      if (nextKey != null && nextNode && currentItem && nextNode.level != null && currentItem.level != null && nextNode.level > currentItem.level) {
+        let beforeTarget = {
+          type: 'item',
+          key: nextKey,
+          dropPosition: 'before'
+        } as const;
+        if (isValidDropTarget(beforeTarget)) {
+          return [beforeTarget];
+        }
+      }
+    }
+
+    return potentialTargets.filter(isValidDropTarget);
+  }
+
+  private selectTarget(
+    potentialTargets: ItemDropTarget[],
+    originalTarget: ItemDropTarget,
+    x: number,
+    y: number,
+    currentYMovement: 'up' | 'down' | null,
+    currentXMovement: 'left' | 'right' | null
+  ): ItemDropTarget {
+    if (potentialTargets.length < 2) {
+      return potentialTargets[0];
+    }
+
+    let tracking = this.pointerTracking;
+    let currentItem = this.state!.collection.getItem(originalTarget.key);
+    let parentKey = currentItem?.parentKey;
+
+    if (!parentKey) {
+      return potentialTargets[0];
+    }
+
+    // More than 1 potential target - use Y for initial target, then X for switching levels
+    // Initialize boundary context if needed
+    if (!tracking.boundaryContext || tracking.boundaryContext.parentKey !== parentKey) {
+      // If entering from below, start with outer-most
+      let initialTargetIndex = tracking.yDirection === 'up' ? potentialTargets.length - 1 : 0;
+      tracking.boundaryContext = {
+        parentKey,
+        preferredTargetIndex: initialTargetIndex,
+        lastSwitchY: y,
+        lastSwitchX: x
+      };
+    }
+
+    let boundaryContext = tracking.boundaryContext;
+    let distanceFromLastXSwitch = Math.abs(x - boundaryContext.lastSwitchX);
+    let distanceFromLastYSwitch = Math.abs(y - boundaryContext.lastSwitchY);
+
+    // Switch between targets based on Y movement
+    if (distanceFromLastYSwitch > Y_SWITCH_THRESHOLD && currentYMovement) {
+      let currentIndex = boundaryContext.preferredTargetIndex || 0;
+
+      if (currentYMovement === 'down' && currentIndex === 0) {
+        // Moving down from inner-most, switch to outer-most
+        boundaryContext.preferredTargetIndex = potentialTargets.length - 1;
+      } else if (currentYMovement === 'up' && currentIndex === potentialTargets.length - 1) {
+        // Moving up from outer-most, switch to inner-most
+        boundaryContext.preferredTargetIndex = 0;
+      }
+
+      // Reset x tracking so that moving diagonally doesn't cause flickering.
+      tracking.xDirection = null;
+    }
+
+    // X movement controls level selection
+    if (distanceFromLastXSwitch > X_SWITCH_THRESHOLD && currentXMovement) {
+      let currentTargetIndex = boundaryContext.preferredTargetIndex || 0;
+
+      if (currentXMovement === 'left') {
+        if (this.direction === 'ltr') {
+          // LTR: left = move to higher level in tree (increase index)
+          if (currentTargetIndex < potentialTargets.length - 1) {
+            boundaryContext.preferredTargetIndex = currentTargetIndex + 1;
+            boundaryContext.lastSwitchX = x;
+          }
+        } else {
+          // RTL: left = move to lower level in tree (decrease index)
+          if (currentTargetIndex > 0) {
+            boundaryContext.preferredTargetIndex = currentTargetIndex - 1;
+            boundaryContext.lastSwitchX = x;
+          }
+        }
+      } else if (currentXMovement === 'right') {
+        if (this.direction === 'ltr') {
+          // LTR: right = move to lower level in tree (decrease index)
+          if (currentTargetIndex > 0) {
+            boundaryContext.preferredTargetIndex = currentTargetIndex - 1;
+            boundaryContext.lastSwitchX = x;
+          }
+        } else {
+          // RTL: right = move to higher level in tree (increase index)
+          if (currentTargetIndex < potentialTargets.length - 1) {
+            boundaryContext.preferredTargetIndex = currentTargetIndex + 1;
+            boundaryContext.lastSwitchX = x;
+          }
+        }
+      }
+
+      // Reset y tracking so that moving diagonally doesn't cause flickering.
+      tracking.yDirection = null;
+    }
+
+    let targetIndex = Math.max(0, Math.min(boundaryContext.preferredTargetIndex || 0, potentialTargets.length - 1));
+    return potentialTargets[targetIndex];
+  }
+}

package/src/Virtualizer.tsx

@@ -0,0 +1,174 @@
+/*
+ * Copyright 2024 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+import {CollectionBranchProps, CollectionRenderer, CollectionRendererContext, CollectionRootProps, renderAfterDropIndicators} from './Collection';
+import {DropTargetDelegate, ItemDropTarget, Node} from '@react-types/shared';
+import {Layout, ReusableView, useVirtualizerState, VirtualizerState} from '@react-stately/virtualizer';
+import React, {createContext, JSX, ReactNode, useContext, useMemo} from 'react';
+import {useScrollView, VirtualizerItem} from '@react-aria/virtualizer';
+
+type View = ReusableView<Node<unknown>, ReactNode>;
+
+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
+}
+
+interface LayoutContextValue {
+  layout: ILayout<any>,
+  layoutOptions?: any
+}
+
+const VirtualizerContext = createContext<VirtualizerState<any, any> | null>(null);
+const LayoutContext = createContext<LayoutContextValue | null>(null);
+
+/**
+ * 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 function Virtualizer<O>(props: VirtualizerProps<O>): JSX.Element {
+  let {children, layout: layoutProp, layoutOptions} = props;
+  let layout = useMemo(() => typeof layoutProp === 'function' ? new layoutProp() : layoutProp, [layoutProp]);
+  let renderer: CollectionRenderer = useMemo(() => ({
+    isVirtualized: true,
+    layoutDelegate: layout,
+    dropTargetDelegate: layout.getDropTargetFromPoint ? layout as DropTargetDelegate : undefined,
+    CollectionRoot,
+    CollectionBranch
+  }), [layout]);
+
+  return (
+    <CollectionRendererContext.Provider value={renderer}>
+      <LayoutContext.Provider value={{layout, layoutOptions}}>
+        {children}
+      </LayoutContext.Provider>
+    </CollectionRendererContext.Provider>
+  );
+}
+
+function CollectionRoot({collection, persistedKeys, scrollRef, renderDropIndicator}: CollectionRootProps) {
+  let {layout, layoutOptions} = useContext(LayoutContext)!;
+  let layoutOptions2 = layout.useLayoutOptions?.();
+  let state = useVirtualizerState({
+    layout,
+    collection,
+    renderView: (type, item) => {
+      return item?.render?.(item);
+    },
+    onVisibleRectChange(rect) {
+      let element = scrollRef?.current;
+      if (element) {
+        element.scrollLeft = rect.x;
+        element.scrollTop = rect.y;
+      }
+    },
+    persistedKeys,
+    layoutOptions: useMemo(() => {
+      if (layoutOptions && layoutOptions2) {
+        return {...layoutOptions, ...layoutOptions2};
+      }
+      return layoutOptions || layoutOptions2;
+    }, [layoutOptions, layoutOptions2])
+  });
+
+  let {contentProps} = useScrollView({
+    onVisibleRectChange: state.setVisibleRect,
+    contentSize: state.contentSize,
+    onScrollStart: state.startScrolling,
+    onScrollEnd: state.endScrolling
+  }, scrollRef!);
+
+  return (
+    <div {...contentProps}>
+      <VirtualizerContext.Provider value={state}>
+        {renderChildren(null, state.visibleViews, renderDropIndicator)}
+      </VirtualizerContext.Provider>
+    </div>
+  );
+}
+
+function CollectionBranch({parent, renderDropIndicator}: CollectionBranchProps) {
+  let virtualizer = useContext(VirtualizerContext);
+  let parentView = virtualizer!.virtualizer.getVisibleView(parent.key)!;
+  return renderChildren(parentView, Array.from(parentView.children), renderDropIndicator);
+}
+
+function renderChildren(parent: View | null, children: View[], renderDropIndicator?: (target: ItemDropTarget) => ReactNode) {
+  return children.map(view => renderWrapper(parent, view, renderDropIndicator));
+}
+
+function renderWrapper(
+  parent: View | null,
+  reusableView: View,
+  renderDropIndicator?: (target: ItemDropTarget) => ReactNode
+): ReactNode {
+  let rendered = (
+    <VirtualizerItem
+      key={reusableView.key}
+      layoutInfo={reusableView.layoutInfo!}
+      virtualizer={reusableView.virtualizer}
+      parent={parent?.layoutInfo}>
+      {reusableView.rendered}
+    </VirtualizerItem>
+  );
+
+  let {collection, layout} = reusableView.virtualizer;
+  let node = reusableView.content;
+  if (node?.type === 'item' && renderDropIndicator && layout.getDropTargetLayoutInfo) {
+    rendered = (
+      <React.Fragment key={reusableView.key}>
+        {renderDropIndicatorWrapper(parent, reusableView, {type: 'item', key: reusableView.content!.key, dropPosition: 'before'}, renderDropIndicator)}
+        {rendered}
+        {renderAfterDropIndicators(collection, node, target => renderDropIndicatorWrapper(parent, reusableView, target, renderDropIndicator))}
+      </React.Fragment>
+    );
+  }
+
+  return rendered;
+}
+
+function renderDropIndicatorWrapper(
+  parent: View | null,
+  reusableView: View,
+  target: ItemDropTarget,
+  renderDropIndicator: (target: ItemDropTarget) => ReactNode
+) {
+  let indicator = renderDropIndicator(target);
+  if (indicator) {
+    let layoutInfo = reusableView.virtualizer.layout.getDropTargetLayoutInfo!(target);
+    indicator = (
+      <VirtualizerItem
+        layoutInfo={layoutInfo}
+        virtualizer={reusableView.virtualizer}
+        parent={parent?.layoutInfo}>
+        {indicator}
+      </VirtualizerItem>
+    );
+  }
+
+  return indicator;
+}

package/src/index.ts

@@ -0,0 +1,160 @@
+/*
+ * Copyright 2022 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+// Mark as a client only package. This will cause a build time error if you try
+// to import it from a React Server Component in a framework like Next.js.
+import 'client-only';
+
+export {CheckboxContext, ColorAreaContext, ColorFieldContext, ColorSliderContext, ColorWheelContext, HeadingContext, SelectableCollectionContext, FieldInputContext} from './RSPContexts';
+
+export {Autocomplete, AutocompleteContext, AutocompleteStateContext} from './Autocomplete';
+export {Breadcrumbs, BreadcrumbsContext, Breadcrumb} from './Breadcrumbs';
+export {Button, ButtonContext} from './Button';
+export {Calendar, CalendarGrid, CalendarGridHeader, CalendarGridBody, CalendarHeaderCell, CalendarCell, RangeCalendar, CalendarContext, RangeCalendarContext, CalendarStateContext, RangeCalendarStateContext} from './Calendar';
+export {Checkbox, CheckboxGroup, CheckboxGroupContext, CheckboxGroupStateContext} from './Checkbox';
+export {ColorArea, ColorAreaStateContext} from './ColorArea';
+export {ColorField, ColorFieldStateContext} from './ColorField';
+export {ColorPicker, ColorPickerContext, ColorPickerStateContext} from './ColorPicker';
+export {ColorSlider, ColorSliderStateContext} from './ColorSlider';
+export {ColorSwatch, ColorSwatchContext} from './ColorSwatch';
+export {ColorSwatchPicker, ColorSwatchPickerItem, ColorSwatchPickerContext} from './ColorSwatchPicker';
+export {ColorThumb} from './ColorThumb';
+export {ColorWheel, ColorWheelTrack, ColorWheelTrackContext, ColorWheelStateContext} from './ColorWheel';
+export {ComboBox, ComboBoxValue, ComboBoxContext, ComboBoxStateContext, ComboBoxValueContext} from './ComboBox';
+export {composeRenderProps, DEFAULT_SLOT, Provider, useContextProps, useRenderProps, useSlottedContext} from './utils';
+export {DateField, DateInput, DateSegment, TimeField, DateFieldContext, TimeFieldContext, DateFieldStateContext, TimeFieldStateContext} from './DateField';
+export {DatePicker, DateRangePicker, DatePickerContext, DateRangePickerContext, DatePickerStateContext, DateRangePickerStateContext} from './DatePicker';
+export {DialogTrigger, Dialog, DialogContext, OverlayTriggerStateContext} from './Dialog';
+export {Disclosure, DisclosureGroup, DisclosureGroupStateContext, DisclosurePanel, DisclosureStateContext, DisclosureContext} from './Disclosure';
+export {DropZone, DropZoneContext} from './DropZone';
+export {FieldError, FieldErrorContext} from './FieldError';
+export {FileTrigger} from './FileTrigger';
+export {Form, FormContext} from './Form';
+export {GridListLoadMoreItem, GridList, GridListItem, GridListContext, GridListHeader, GridListHeaderContext, GridListSection} from './GridList';
+export {Group, GroupContext} from './Group';
+export {Header, HeaderContext} from './Header';
+export {Heading} from './Heading';
+export {Input, InputContext} from './Input';
+export {Section, CollectionRendererContext, DefaultCollectionRenderer} from './Collection';
+export {Collection, createLeafComponent, createBranchComponent, CollectionBuilder} from '@react-aria/collections';
+export {Keyboard, KeyboardContext} from './Keyboard';
+export {Label, LabelContext} from './Label';
+export {Link, LinkContext} from './Link';
+export {ListBoxLoadMoreItem, ListBox, ListBoxItem, ListBoxSection, ListBoxContext, ListStateContext} from './ListBox';
+export {Menu, MenuItem, MenuTrigger, MenuSection, MenuContext, MenuStateContext, RootMenuTriggerStateContext, SubmenuTrigger} from './Menu';
+export {Meter, MeterContext} from './Meter';
+export {Modal, ModalOverlay, ModalContext} from './Modal';
+export {NumberField, NumberFieldContext, NumberFieldStateContext} from './NumberField';
+export {OverlayArrow} from './OverlayArrow';
+export {Popover, PopoverContext} from './Popover';
+export {ProgressBar, ProgressBarContext} from './ProgressBar';
+export {RadioGroup, Radio, RadioGroupContext, RadioContext, RadioGroupStateContext} from './RadioGroup';
+export {SearchField, SearchFieldContext} from './SearchField';
+export {Select, SelectValue, SelectContext, SelectValueContext, SelectStateContext} from './Select';
+export {SelectionIndicator, SelectionIndicatorContext} from './SelectionIndicator';
+export {Separator, SeparatorContext} from './Separator';
+export {SharedElementTransition, SharedElement} from './SharedElementTransition';
+export {Slider, SliderOutput, SliderTrack, SliderThumb, SliderContext, SliderOutputContext, SliderTrackContext, SliderStateContext} from './Slider';
+export {Switch, SwitchContext} from './Switch';
+export {TableLoadMoreItem, Table, Row, Cell, Column, ColumnResizer, TableHeader, TableBody, TableContext, ResizableTableContainer, useTableOptions, TableStateContext, TableColumnResizeStateContext} from './Table';
+export {TableLayout} from './TableLayout';
+export {Tabs, TabList, TabPanels, TabPanel, Tab, TabsContext, TabListStateContext} from './Tabs';
+export {TagGroup, TagGroupContext, TagList, TagListContext, Tag} from './TagGroup';
+export {Text, TextContext} from './Text';
+export {TextArea, TextAreaContext} from './TextArea';
+export {TextField, TextFieldContext} from './TextField';
+export {Toast as UNSTABLE_Toast, ToastList as UNSTABLE_ToastList, ToastRegion as UNSTABLE_ToastRegion, ToastContent as UNSTABLE_ToastContent, ToastStateContext as UNSTABLE_ToastStateContext} from './Toast';
+export {ToggleButton, ToggleButtonContext} from './ToggleButton';
+export {ToggleButtonGroup, ToggleButtonGroupContext, ToggleGroupStateContext} from './ToggleButtonGroup';
+export {Toolbar, ToolbarContext} from './Toolbar';
+export {TooltipTrigger, Tooltip, TooltipTriggerStateContext, TooltipContext} from './Tooltip';
+export {TreeLoadMoreItem, Tree, TreeItem, TreeContext, TreeItemContent, TreeHeader, TreeSection, TreeStateContext} from './Tree';
+export {useDrag, useDrop} from '@react-aria/dnd';
+export {useDragAndDrop} from './useDragAndDrop';
+export {DropIndicator, DropIndicatorContext, DragAndDropContext} from './DragAndDrop';
+export {Virtualizer} from './Virtualizer';
+export {DIRECTORY_DRAG_TYPE, isDirectoryDropItem, isFileDropItem, isTextDropItem, SSRProvider, RouterProvider, I18nProvider, isRTL, useLocale, useFilter, Pressable, Focusable, VisuallyHidden} from 'react-aria';
+export {FormValidationContext, parseColor, getColorChannels, ToastQueue as UNSTABLE_ToastQueue, useListData, useTreeData, useAsyncList} from 'react-stately';
+export {ListLayout, GridLayout, WaterfallLayout} from '@react-stately/layout';
+export {Layout, LayoutInfo, Size, Rect, Point} from '@react-stately/virtualizer';
+
+export type {AutocompleteProps} from './Autocomplete';
+export type {BreadcrumbsProps, BreadcrumbProps, BreadcrumbRenderProps} from './Breadcrumbs';
+export type {ButtonProps, ButtonRenderProps} from './Button';
+export type {CalendarCellProps, CalendarProps, CalendarRenderProps, CalendarGridProps, CalendarGridHeaderProps, CalendarGridBodyProps, CalendarHeaderCellProps, CalendarCellRenderProps, RangeCalendarProps, RangeCalendarRenderProps} from './Calendar';
+export type {CheckboxGroupProps, CheckboxGroupRenderProps, CheckboxRenderProps, CheckboxProps} from './Checkbox';
+export type {ColorAreaProps, ColorAreaRenderProps} from './ColorArea';
+export type {ColorFieldProps, ColorFieldRenderProps} from './ColorField';
+export type {ColorSliderProps, ColorSliderRenderProps} from './ColorSlider';
+export type {ColorSwatchProps, ColorSwatchRenderProps} from './ColorSwatch';
+export type {ColorSwatchPickerProps, ColorSwatchPickerRenderProps, ColorSwatchPickerItemProps, ColorSwatchPickerItemRenderProps} from './ColorSwatchPicker';
+export type {ColorThumbProps, ColorThumbRenderProps} from './ColorThumb';
+export type {ColorPickerProps, ColorPickerRenderProps} from './ColorPicker';
+export type {ColorWheelProps, ColorWheelRenderProps, ColorWheelTrackProps, ColorWheelTrackRenderProps} from './ColorWheel';
+export type {ComboBoxProps, ComboBoxRenderProps, ComboBoxValueProps, ComboBoxValueRenderProps} from './ComboBox';
+export type {DateFieldProps, DateFieldRenderProps, DateInputProps, DateInputRenderProps, DateSegmentProps, DateSegmentRenderProps, TimeFieldProps} from './DateField';
+export type {DatePickerProps, DatePickerRenderProps, DateRangePickerProps, DateRangePickerRenderProps} from './DatePicker';
+export type {DialogProps, DialogTriggerProps, DialogRenderProps} from './Dialog';
+export type {DisclosureProps, DisclosureRenderProps, DisclosurePanelProps, DisclosurePanelRenderProps, DisclosureGroupProps, DisclosureGroupRenderProps} from './Disclosure';
+export type {DropZoneProps, DropZoneRenderProps} from './DropZone';
+export type {FieldErrorProps, FieldErrorRenderProps} from './FieldError';
+export type {FileTriggerProps} from './FileTrigger';
+export type {FormProps} from './Form';
+export type {GridListProps, GridListRenderProps, GridListItemProps, GridListItemRenderProps, GridListLoadMoreItemProps, GridListSectionProps} from './GridList';
+export type {GroupProps, GroupRenderProps} from './Group';
+export type {HeaderProps} from './Header';
+export type {HeadingProps} from './Heading';
+export type {InputProps, InputRenderProps} from './Input';
+export type {SectionProps, CollectionRenderer} from './Collection';
+export type {LabelProps} from './Label';
+export type {LinkProps, LinkRenderProps} from './Link';
+export type {ListBoxProps, ListBoxRenderProps, ListBoxItemProps, ListBoxItemRenderProps, ListBoxSectionProps, ListBoxLoadMoreItemProps} from './ListBox';
+export type {MenuProps, MenuItemProps, MenuItemRenderProps, MenuTriggerProps, SubmenuTriggerProps, MenuSectionProps} from './Menu';
+export type {MeterProps, MeterRenderProps} from './Meter';
+export type {ModalOverlayProps, ModalRenderProps} from './Modal';
+export type {NumberFieldProps, NumberFieldRenderProps} from './NumberField';
+export type {OverlayArrowProps, OverlayArrowRenderProps} from './OverlayArrow';
+export type {PopoverProps, PopoverRenderProps} from './Popover';
+export type {ProgressBarProps, ProgressBarRenderProps} from './ProgressBar';
+export type {RadioGroupProps, RadioGroupRenderProps, RadioProps, RadioRenderProps} from './RadioGroup';
+export type {SearchFieldProps, SearchFieldRenderProps} from './SearchField';
+export type {SelectProps, SelectValueProps, SelectValueRenderProps, SelectRenderProps} from './Select';
+export type {SelectionIndicatorProps} from './SelectionIndicator';
+export type {SharedElementTransitionProps, SharedElementProps, SharedElementRenderProps} from './SharedElementTransition';
+export type {SeparatorProps} from './Separator';
+export type {SliderOutputProps, SliderProps, SliderRenderProps, SliderThumbProps, SliderTrackProps, SliderTrackRenderProps, SliderThumbRenderProps} from './Slider';
+export type {SwitchProps, SwitchRenderProps} from './Switch';
+export type {TableProps, TableRenderProps, TableHeaderProps, TableBodyProps, TableBodyRenderProps, ResizableTableContainerProps, ColumnProps, ColumnRenderProps, ColumnResizerProps, ColumnResizerRenderProps, RowProps, RowRenderProps, CellProps, CellRenderProps, TableLoadMoreItemProps} from './Table';
+export type {TabListProps, TabListRenderProps, TabPanelsProps, TabPanelProps, TabPanelRenderProps, TabProps, TabsProps, TabRenderProps, TabsRenderProps} from './Tabs';
+export type {TagGroupProps, TagListProps, TagListRenderProps, TagProps, TagRenderProps} from './TagGroup';
+export type {TextAreaProps} from './TextArea';
+export type {TextFieldProps, TextFieldRenderProps} from './TextField';
+export type {TextProps} from './Text';
+export type {ToastRegionProps, ToastListProps, ToastRegionRenderProps, ToastProps, ToastRenderProps} from './Toast';
+export type {ToggleButtonProps, ToggleButtonRenderProps} from './ToggleButton';
+export type {ToggleButtonGroupProps, ToggleButtonGroupRenderProps} from './ToggleButtonGroup';
+export type {ToolbarProps, ToolbarRenderProps} from './Toolbar';
+export type {TooltipProps, TooltipRenderProps, TooltipTriggerComponentProps} from './Tooltip';
+export type {TreeProps, TreeRenderProps, TreeItemProps, TreeItemRenderProps, TreeItemContentProps, TreeItemContentRenderProps, TreeLoadMoreItemProps, TreeLoadMoreItemRenderProps} from './Tree';
+export type {DragOptions, DragResult} from '@react-aria/dnd';
+export type {DragAndDropHooks, DragAndDropOptions} from './useDragAndDrop';
+export type {DropIndicatorProps, DropIndicatorRenderProps} from './DragAndDrop';
+export type {ContextValue, RenderProps, SlotProps, StyleRenderProps} from './utils';
+export type {VirtualizerProps} from './Virtualizer';
+
+export type {DateValue, DateRange, TimeValue} from 'react-aria';
+export type {DirectoryDropItem, DraggableCollectionEndEvent, DraggableCollectionMoveEvent, DraggableCollectionStartEvent, DragPreviewRenderer, DragTypes, DropItem, DropOperation, DroppableCollectionDropEvent, DroppableCollectionEnterEvent, DroppableCollectionExitEvent, DroppableCollectionInsertDropEvent, DroppableCollectionMoveEvent, DroppableCollectionOnItemDropEvent, DroppableCollectionReorderEvent, DroppableCollectionRootDropEvent, DropPosition, DropTarget, FileDropItem, ItemDropTarget, RootDropTarget, TextDropItem, PressEvent} from 'react-aria';
+export type {CalendarState, CheckboxGroupState, Color, ColorAreaState, ColorFieldState, ColorFormat, ColorPickerState, ColorSliderState, ColorSpace, ColorWheelState, ComboBoxState, DateFieldState, DatePickerState, DateRangePickerState, DisclosureState, DisclosureGroupState, Key, ListState, NumberFieldState, OverlayTriggerState, QueuedToast, RadioGroupState, RangeCalendarState, RootMenuTriggerState, SearchFieldState, Selection, SelectState, SliderState, SortDescriptor, SortDirection, SelectionMode, TableState, TabListState, TimeFieldState, ToastOptions, ToastState, ToggleGroupState, ToggleState, TooltipTriggerState, TreeState, ListData, TreeData, AsyncListData} from 'react-stately';
+export type {AutocompleteState} from '@react-stately/autocomplete';
+export type {ListLayoutOptions, GridLayoutOptions, WaterfallLayoutOptions} from '@react-stately/layout';
+export type {RangeValue, ValidationResult, RouterConfig} from '@react-types/shared';
+export type {SelectableCollectionContextValue} from './RSPContexts';