@react-types/shared 3.0.0-nightly.1786 → 3.0.0-nightly.1802

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@react-types/shared",
-  "version": "3.0.0-nightly.1786+892d41e82",
+  "version": "3.0.0-nightly.1802+1d21d12cc",
   "description": "Spectrum UI components in React",
   "license": "Apache-2.0",
   "types": "src/index.d.ts",
@@ -14,5 +14,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "892d41e82dc781fb4651455d0e29c324376659ed"
+  "gitHead": "1d21d12cc7d2f8f36dc38a67d6cd8ea579cdc182"
 }

package/src/dnd.d.ts

@@ -13,8 +13,9 @@
 import {Key, RefObject} from 'react';
 
 export interface DragDropEvent {
-  // Relative to the target element's position
+  /** The x coordinate of the event, relative to the target element. */
   x: number,
+  /** The y coordinate of the event, relative to the target element. */
   y: number
 }
 
@@ -25,120 +26,167 @@ export interface DragItem {
 }
 
 export interface DragStartEvent extends DragDropEvent {
+  /** The event type. */
   type: 'dragstart'
 }
 
 export interface DragMoveEvent extends DragDropEvent {
+  /** The event type. */
   type: 'dragmove'
 }
 
 export interface DragEndEvent extends DragDropEvent {
+  /** The event type. */
   type: 'dragend',
+  /** The drop operation that occurred. */
   dropOperation: DropOperation
 }
 
 export interface DropEnterEvent extends DragDropEvent {
+  /** The event type. */
   type: 'dropenter'
 }
 
 export interface DropMoveEvent extends DragDropEvent {
+  /** The event type. */
   type: 'dropmove'
 }
 
 export interface DropActivateEvent extends DragDropEvent {
+  /** The event type. */
   type: 'dropactivate'
 }
 
 export interface DropExitEvent extends DragDropEvent {
+  /** The event type. */
   type: 'dropexit'
 }
 
 export interface TextItem {
+  /** The item kind. */
   kind: 'text',
+  /**
+   * The drag types available for this item.
+   * These are often mime types, but may be custom app-specific types.
+   */
   types: Set<string>,
+  /** Returns the data for the given type as a string. */
   getText(type: string): Promise<string>
 }
 
 export interface FileItem {
+  /** The item kind. */
   kind: 'file',
+  /** The file type (usually a mime type). */
   type: string,
+  /** The file name. */
   name: string,
+  /** Returns the contents of the file as a blob. */
   getFile(): Promise<File>,
+  /** Returns the contents of the file as a string. */
   getText(): Promise<string>
 }
 
 export interface DirectoryItem {
+  /** The item kind. */
   kind: 'directory',
+  /** The directory name. */
   name: string,
+  /** Returns the entries contained within the directory. */
   getEntries(): AsyncIterable<FileItem | DirectoryItem>
 }
 
 export type DropItem = TextItem | FileItem | DirectoryItem;
 
 export interface DropEvent extends DragDropEvent {
+  /** The event type. */
   type: 'drop',
+  /** The drop operation that should occur. */
   dropOperation: DropOperation,
+  /** The dropped items. */
   items: DropItem[]
 }
 
 export type DropPosition = 'on' | 'before' | 'after';
-interface RootDropTarget {
+export interface RootDropTarget {
+  /** The event type. */
   type: 'root'
 }
 
 export interface ItemDropTarget {
+  /** The drop target type. */
   type: 'item',
+  /** The item key. */
   key: Key,
+  /** The drop position relative to the item. */
   dropPosition: DropPosition
 }
 
 export type DropTarget = RootDropTarget | ItemDropTarget;
 
-interface DroppableCollectionEnterEvent extends DropEnterEvent {
+export interface DroppableCollectionEnterEvent extends DropEnterEvent {
+  /** The drop target. */
   target: DropTarget
 }
 
-interface DroppableCollectionMoveEvent extends DropMoveEvent {
+export interface DroppableCollectionMoveEvent extends DropMoveEvent {
+  /** The drop target. */
   target: DropTarget
 }
 
-interface DroppableCollectionActivateEvent extends DropActivateEvent {
+export interface DroppableCollectionActivateEvent extends DropActivateEvent {
+  /** The drop target. */
   target: DropTarget
 }
 
-interface DroppableCollectionExitEvent extends DropExitEvent {
+export interface DroppableCollectionExitEvent extends DropExitEvent {
+  /** The drop target. */
   target: DropTarget
 }
 
-interface DroppableCollectionDropEvent extends DropEvent {
+export interface DroppableCollectionDropEvent extends DropEvent {
+  /** The drop target. */
   target: DropTarget
 }
 
 interface DroppableCollectionInsertDropEvent {
+  /** The dropped items. */
   items: DropItem[],
+  /** The drop operation that should occur. */
   dropOperation: DropOperation,
+   /** The drop target. */
   target: ItemDropTarget
 }
 
 interface DroppableCollectionRootDropEvent {
+  /** The dropped items. */
   items: DropItem[],
+  /** The drop operation that should occur. */
   dropOperation: DropOperation
 }
 
 interface DroppableCollectionOnItemDropEvent {
+  /** The dropped items. */
   items: DropItem[],
+  /** The drop operation that should occur. */
   dropOperation: DropOperation,
+  /** Whether the drag originated within the same collection as the drop. */
   isInternal: boolean,
+  /** The drop target. */
   target: ItemDropTarget
 }
 
 interface DroppableCollectionReorderEvent {
+  /** The keys of the items that were reordered. */
   keys: Set<Key>,
+  /** The drop operation that should occur. */
   dropOperation: DropOperation,
+  /** The drop target. */
   target: ItemDropTarget
 }
 
 export interface DragTypes {
+  /** Returns whether the drag contains data of the given type. */
   has(type: string | symbol): boolean
 }
 
@@ -153,57 +201,62 @@ export interface DropTargetDelegate {
 
 export interface DroppableCollectionProps {
   /**
-   * A function returning the drop operation to be performed when items matching the given types are dropped
-   * on the drop target.
+   * The drag types that the droppable collection accepts. If the collection accepts directories, include `DIRECTORY_DRAG_TYPE` in your array of allowed types.
+   * @default 'all'
    */
-  getDropOperation?: (target: DropTarget, types: DragTypes, allowedOperations: DropOperation[]) => DropOperation,
-  /** Handler that is called when a valid drag enters the drop target. */
-  onDropEnter?: (e: DroppableCollectionEnterEvent) => void,
-  /** Handler that is called when a valid drag is moved within the drop target. */
-  onDropMove?: (e: DroppableCollectionMoveEvent) => void,
-  /** Handler that is called after a valid drag is held over the drop target for a period of time. */
-  onDropActivate?: (e: DroppableCollectionActivateEvent) => void,
-  /** Handler that is called when a valid drag exits the drop target. */
-  onDropExit?: (e: DroppableCollectionExitEvent) => void,
-  /** Handler that is called when a valid drag is dropped on the drop target. */
-  onDrop?: (e: DroppableCollectionDropEvent) => void,
+  acceptedDragTypes?: 'all' | Array<string | symbol>,
   /**
-   * Handler called when external items are dropped "between" the droppable collection's items.
+   * Handler that is called when external items are dropped "between" items.
    */
   onInsert?: (e: DroppableCollectionInsertDropEvent) => void,
   /**
-   * Handler called when external items are dropped on the droppable collection's root.
+   * Handler that is called when external items are dropped on the droppable collection's root.
    */
   onRootDrop?: (e: DroppableCollectionRootDropEvent) => void,
   /**
-   * Handler called when items are dropped "on" a droppable collection's item.
+   * Handler that is called when items are dropped "on" an item.
    */
   onItemDrop?: (e: DroppableCollectionOnItemDropEvent) => void,
   /**
-   * Handler called when items are reordered via drag in the source collection.
+   * Handler that is called when items are reordered via drag in the source collection.
    */
   onReorder?: (e: DroppableCollectionReorderEvent) => void,
+  /** Handler that is called when a valid drag enters a drop target. */
+  onDropEnter?: (e: DroppableCollectionEnterEvent) => void,
+  /** Handler that is called after a valid drag is held over a drop target for a period of time. */
+  onDropActivate?: (e: DroppableCollectionActivateEvent) => void,
+  /** Handler that is called when a valid drag exits a drop target. */
+  onDropExit?: (e: DroppableCollectionExitEvent) => void,
   /**
-   * The drag types that the droppable collection accepts. If directories are accepted, include the DIRECTORY_DRAG_TYPE from @react-aria/dnd in the array of allowed types.
-   * @default 'all'
+   * Handler that is called when a valid drag is dropped on a drop target. When defined, this overrides other
+   * drop handlers such as `onInsert`, and `onItemDrop`.
    */
-  acceptedDragTypes?: 'all' | Array<string | symbol>,
+  onDrop?: (e: DroppableCollectionDropEvent) => void,
   /**
    * A function returning whether a given target in the droppable collection is a valid "on" drop target for the current drag types.
    */
-  shouldAcceptItemDrop?: (target: ItemDropTarget, types: DragTypes) => boolean
+  shouldAcceptItemDrop?: (target: ItemDropTarget, types: DragTypes) => boolean,
+  /**
+   * A function returning the drop operation to be performed when items matching the given types are dropped
+   * on the drop target.
+   */
+  getDropOperation?: (target: DropTarget, types: DragTypes, allowedOperations: DropOperation[]) => DropOperation
 }
 
 interface DraggableCollectionStartEvent extends DragStartEvent {
+  /** The keys of the items that were dragged. */
   keys: Set<Key>
 }
 
 interface DraggableCollectionMoveEvent extends DragMoveEvent {
+  /** The keys of the items that were dragged. */
   keys: Set<Key>
 }
 
 interface DraggableCollectionEndEvent extends DragEndEvent {
+  /** The keys of the items that were dragged. */
   keys: Set<Key>,
+  /** Whether the drop ended within the same collection as it originated. */
   isInternal: boolean
 }
 
@@ -212,7 +265,7 @@ export type DragPreviewRenderer = (items: DragItem[], callback: (node: HTMLEleme
 export interface DraggableCollectionProps {
   /** Handler that is called when a drag operation is started. */
   onDragStart?: (e: DraggableCollectionStartEvent) => void,
-  /** Handler that is called when the dragged element is moved. */
+  /** Handler that is called when the drag is moved. */
   onDragMove?: (e: DraggableCollectionMoveEvent) => void,
   /** Handler that is called when the drag operation is ended, either as a result of a drop or a cancellation. */
   onDragEnd?: (e: DraggableCollectionEndEvent) => void,