@react-aria/selection 3.0.0-alpha.1 → 3.0.0-nightly-641446f65-240905

package/dist/types.d.ts

@@ -1,65 +1,253 @@
-import { HTMLAttributes, Key, RefObject } from "react";
-import { KeyboardDelegate } from "@react-types/shared";
+import { DOMAttributes, Key, KeyboardDelegate, FocusStrategy, RefObject, FocusableElement, LayoutDelegate, Rect, Size, Collection, Direction, DisabledBehavior, Node, Orientation } from "@react-types/shared";
 import { MultipleSelectionManager } from "@react-stately/selection";
-import { PressProps } from "@react-aria/interactions";
-import { Collection, Node } from "@react-stately/collections";
-import { FocusStrategy } from "@react-types/menu";
-interface TypeSelectOptions {
+export interface AriaTypeSelectOptions {
+    /**
+     * A delegate that returns collection item keys with respect to visual layout.
+     */
     keyboardDelegate: KeyboardDelegate;
+    /**
+     * An interface for reading and updating multiple selection state.
+     */
     selectionManager: MultipleSelectionManager;
+    /**
+     * Called when an item is focused by typing.
+     */
     onTypeSelect?: (key: Key) => void;
 }
-interface TypeSelectAria {
-    typeSelectProps: HTMLAttributes<HTMLElement>;
+export interface TypeSelectAria {
+    /**
+     * Props to be spread on the owner of the options.
+     */
+    typeSelectProps: DOMAttributes;
 }
-export function useTypeSelect(options: TypeSelectOptions): TypeSelectAria;
-type FocusStrategy = 'first' | 'last';
-interface SelectableCollectionOptions {
+/**
+ * Handles typeahead interactions with collections.
+ */
+export function useTypeSelect(options: AriaTypeSelectOptions): TypeSelectAria;
+export interface AriaSelectableCollectionOptions {
+    /**
+     * An interface for reading and updating multiple selection state.
+     */
     selectionManager: MultipleSelectionManager;
+    /**
+     * A delegate object that implements behavior for keyboard focus movement.
+     */
     keyboardDelegate: KeyboardDelegate;
+    /**
+     * The ref attached to the element representing the collection.
+     */
+    ref: RefObject<HTMLElement | null>;
+    /**
+     * Whether the collection or one of its items should be automatically focused upon render.
+     * @default false
+     */
     autoFocus?: boolean | FocusStrategy;
+    /**
+     * Whether focus should wrap around when the end/start is reached.
+     * @default false
+     */
     shouldFocusWrap?: boolean;
+    /**
+     * Whether the collection allows empty selection.
+     * @default false
+     */
     disallowEmptySelection?: boolean;
+    /**
+     * Whether the collection allows the user to select all items via keyboard shortcut.
+     * @default false
+     */
     disallowSelectAll?: boolean;
+    /**
+     * Whether selection should occur automatically on focus.
+     * @default false
+     */
+    selectOnFocus?: boolean;
+    /**
+     * Whether typeahead is disabled.
+     * @default false
+     */
+    disallowTypeAhead?: boolean;
+    /**
+     * Whether the collection items should use virtual focus instead of being focused directly.
+     */
+    shouldUseVirtualFocus?: boolean;
+    /**
+     * Whether navigation through tab key is enabled.
+     */
+    allowsTabNavigation?: boolean;
+    /**
+     * Whether the collection items are contained in a virtual scroller.
+     */
+    isVirtualized?: boolean;
+    /**
+     * The ref attached to the scrollable body. Used to provide automatic scrolling on item focus for non-virtualized collections.
+     * If not provided, defaults to the collection ref.
+     */
+    scrollRef?: RefObject<HTMLElement | null>;
+    /**
+     * The behavior of links in the collection.
+     * - 'action': link behaves like onAction.
+     * - 'selection': link follows selection interactions (e.g. if URL drives selection).
+     * - 'override': links override all other interactions (link items are not selectable).
+     * @default 'action'
+     */
+    linkBehavior?: 'action' | 'selection' | 'override';
 }
-interface SelectableCollectionAria {
-    collectionProps: HTMLAttributes<HTMLElement>;
+export interface SelectableCollectionAria {
+    /** Props for the collection element. */
+    collectionProps: DOMAttributes;
 }
-export function useSelectableCollection(options: SelectableCollectionOptions): SelectableCollectionAria;
-interface SelectableItemOptions {
+/**
+ * Handles interactions with selectable collections.
+ */
+export function useSelectableCollection(options: AriaSelectableCollectionOptions): SelectableCollectionAria;
+export interface SelectableItemOptions {
+    /**
+     * An interface for reading and updating multiple selection state.
+     */
     selectionManager: MultipleSelectionManager;
-    itemKey: Key;
-    itemRef: RefObject<HTMLElement>;
+    /**
+     * A unique key for the item.
+     */
+    key: Key;
+    /**
+     * Ref to the item.
+     */
+    ref: RefObject<FocusableElement | null>;
+    /**
+     * By default, selection occurs on pointer down. This can be strange if selecting an
+     * item causes the UI to disappear immediately (e.g. menus).
+     */
     shouldSelectOnPressUp?: boolean;
+    /**
+     * Whether selection requires the pointer/mouse down and up events to occur on the same target or triggers selection on
+     * the target of the pointer/mouse up event.
+     */
+    allowsDifferentPressOrigin?: boolean;
+    /**
+     * Whether the option is contained in a virtual scroller.
+     */
     isVirtualized?: boolean;
+    /**
+     * Function to focus the item.
+     */
+    focus?: () => void;
+    /**
+     * Whether the option should use virtual focus instead of being focused directly.
+     */
+    shouldUseVirtualFocus?: boolean;
+    /** Whether the item is disabled. */
+    isDisabled?: boolean;
+    /**
+     * Handler that is called when a user performs an action on the item. The exact user event depends on
+     * the collection's `selectionBehavior` prop and the interaction modality.
+     */
+    onAction?: () => void;
+    /**
+     * The behavior of links in the collection.
+     * - 'action': link behaves like onAction.
+     * - 'selection': link follows selection interactions (e.g. if URL drives selection).
+     * - 'override': links override all other interactions (link items are not selectable).
+     * - 'none': links are disabled for both selection and actions (e.g. handled elsewhere).
+     * @default 'action'
+     */
+    linkBehavior?: 'action' | 'selection' | 'override' | 'none';
+}
+export interface SelectableItemStates {
+    /** Whether the item is currently in a pressed state. */
+    isPressed: boolean;
+    /** Whether the item is currently selected. */
+    isSelected: boolean;
+    /** Whether the item is currently focused. */
+    isFocused: boolean;
+    /**
+     * Whether the item is non-interactive, i.e. both selection and actions are disabled and the item may
+     * not be focused. Dependent on `disabledKeys` and `disabledBehavior`.
+     */
+    isDisabled: boolean;
+    /**
+     * Whether the item may be selected, dependent on `selectionMode`, `disabledKeys`, and `disabledBehavior`.
+     */
+    allowsSelection: boolean;
+    /**
+     * Whether the item has an action, dependent on `onAction`, `disabledKeys`,
+     * and `disabledBehavior`. It may also change depending on the current selection state
+     * of the list (e.g. when selection is primary). This can be used to enable or disable hover
+     * styles or other visual indications of interactivity.
+     */
+    hasAction: boolean;
 }
-interface SelectableItemAria {
-    itemProps: HTMLAttributes<HTMLElement> & PressProps;
+export interface SelectableItemAria extends SelectableItemStates {
+    /**
+     * Props to be spread on the item root node.
+     */
+    itemProps: DOMAttributes;
 }
+/**
+ * Handles interactions with an item in a selectable collection.
+ */
 export function useSelectableItem(options: SelectableItemOptions): SelectableItemAria;
+export class DOMLayoutDelegate implements LayoutDelegate {
+    constructor(ref: RefObject<HTMLElement>);
+    getItemRect(key: Key): Rect | null;
+    getContentSize(): Size;
+    getVisibleRect(): Rect;
+}
+interface ListKeyboardDelegateOptions<T> {
+    collection: Collection<Node<T>>;
+    ref: RefObject<HTMLElement | null>;
+    collator?: Intl.Collator;
+    layout?: 'stack' | 'grid';
+    orientation?: Orientation;
+    direction?: Direction;
+    disabledKeys?: Set<Key>;
+    disabledBehavior?: DisabledBehavior;
+    layoutDelegate?: LayoutDelegate;
+}
 export class ListKeyboardDelegate<T> implements KeyboardDelegate {
-    constructor(collection: Collection<Node<T>>, ref: RefObject<HTMLElement>, collator?: Intl.Collator);
+    constructor(collection: Collection<Node<T>>, disabledKeys: Set<Key>, ref: RefObject<HTMLElement | null>, collator?: Intl.Collator);
+    constructor(options: ListKeyboardDelegateOptions<T>);
+    getNextKey(key: Key): Key;
+    getPreviousKey(key: Key): Key;
     getKeyBelow(key: Key): Key;
     getKeyAbove(key: Key): Key;
+    getKeyRightOf(key: Key): Key;
+    getKeyLeftOf(key: Key): Key;
     getFirstKey(): Key;
     getLastKey(): Key;
     getKeyPageAbove(key: Key): Key;
     getKeyPageBelow(key: Key): Key;
     getKeyForSearch(search: string, fromKey?: Key): Key;
 }
-interface SelectableListOptions {
-    selectionManager: MultipleSelectionManager;
+export interface AriaSelectableListOptions extends Omit<AriaSelectableCollectionOptions, 'keyboardDelegate'> {
+    /**
+     * State of the collection.
+     */
     collection: Collection<Node<unknown>>;
-    ref?: RefObject<HTMLElement>;
+    /**
+     * A delegate object that implements behavior for keyboard focus movement.
+     */
     keyboardDelegate?: KeyboardDelegate;
-    autoFocus?: boolean | FocusStrategy;
-    shouldFocusWrap?: boolean;
-    isVirtualized?: boolean;
-    disallowEmptySelection?: boolean;
+    /**
+     * A delegate object that provides layout information for items in the collection.
+     * By default this uses the DOM, but this can be overridden to implement things like
+     * virtualized scrolling.
+     */
+    layoutDelegate?: LayoutDelegate;
+    /**
+     * The item keys that are disabled. These items cannot be selected, focused, or otherwise interacted with.
+     */
+    disabledKeys: Set<Key>;
 }
-interface SelectableListAria {
-    listProps: HTMLAttributes<HTMLElement>;
+export interface SelectableListAria {
+    /**
+     * Props for the option element.
+     */
+    listProps: DOMAttributes;
 }
-export function useSelectableList(props: SelectableListOptions): SelectableListAria;
+/**
+ * Handles interactions with a selectable list.
+ */
+export function useSelectableList(props: AriaSelectableListOptions): SelectableListAria;
 
 //# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/govett/dev/react-spectrum/packages/@react-aria/selection/src/packages/@react-aria/selection/src/useTypeSelect.ts","/Users/govett/dev/react-spectrum/packages/@react-aria/selection/src/packages/@react-aria/selection/src/useSelectableCollection.ts","/Users/govett/dev/react-spectrum/packages/@react-aria/selection/src/packages/@react-aria/selection/src/useSelectableItem.ts","/Users/govett/dev/react-spectrum/packages/@react-aria/selection/src/packages/@react-aria/selection/src/ListKeyboardDelegate.ts","/Users/govett/dev/react-spectrum/packages/@react-aria/selection/src/packages/@react-aria/selection/src/useSelectableList.ts"],"names":[],"mappings":";;;;;;AAgBA;IACE,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,gBAAgB,EAAE,wBAAwB,CAAC;IAC3C,YAAY,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,IAAI,CAAA;CAClC;AAED;IACE,eAAe,EAAE,eAAe,WAAW,CAAC,CAAA;CAC7C;AAED,8BAA8B,OAAO,EAAE,iBAAiB,GAAG,cAAc,CAwCxE;AChDD,qBAAqB,OAAO,GAAG,MAAM,CAAC;AAetC;IACE,gBAAgB,EAAE,wBAAwB,CAAC;IAC3C,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,SAAS,CAAC,EAAE,OAAO,GAAG,aAAa,CAAC;IACpC,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,sBAAsB,CAAC,EAAE,OAAO,CAAC;IACjC,iBAAiB,CAAC,EAAE,OAAO,CAAA;CAC5B;AAED;IACE,eAAe,EAAE,eAAe,WAAW,CAAC,CAAA;CAC7C;AAED,wCAAwC,OAAO,EAAE,2BAA2B,GAAG,wBAAwB,CAsLtG;AClND;IACE,gBAAgB,EAAE,wBAAwB,CAAC;IAC3C,OAAO,EAAE,GAAG,CAAC;IACb,OAAO,EAAE,UAAU,WAAW,CAAC,CAAC;IAChC,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,aAAa,CAAC,EAAE,OAAO,CAAA;CACxB;AAED;IACE,SAAS,EAAE,eAAe,WAAW,CAAC,GAAG,UAAU,CAAA;CACpD;AAED,kCAAkC,OAAO,EAAE,qBAAqB,GAAG,kBAAkB,CAwEpF;ACtFD,kCAAkC,CAAC,CAAE,YAAW,gBAAgB;gBAKlD,UAAU,EAAE,WAAW,KAAK,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,UAAU,WAAW,CAAC,EAAE,QAAQ,CAAC,EAAE,KAAK,QAAQ;IAMlG,WAAW,CAAC,GAAG,EAAE,GAAG;IAYpB,WAAW,CAAC,GAAG,EAAE,GAAG;IAYpB,WAAW;IAYX,UAAU;IAgBV,eAAe,CAAC,GAAG,EAAE,GAAG;IAiBxB,eAAe,CAAC,GAAG,EAAE,GAAG;IAiBxB,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG;CAmB9C;AC/GD;IACE,gBAAgB,EAAE,wBAAwB,CAAC;IAC3C,UAAU,EAAE,WAAW,KAAK,OAAO,CAAC,CAAC,CAAC;IACtC,GAAG,CAAC,EAAE,UAAU,WAAW,CAAC,CAAC;IAC7B,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;IACpC,SAAS,CAAC,EAAE,OAAO,GAAG,aAAa,CAAC;IACpC,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,sBAAsB,CAAC,EAAE,OAAO,CAAA;CACjC;AAED;IACE,SAAS,EAAE,eAAe,WAAW,CAAC,CAAA;CACvC;AAED,kCAAkC,KAAK,EAAE,qBAAqB,GAAG,kBAAkB,CAuClF","file":"types.d.ts.map"}
+{"mappings":"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","sources":["packages/@react-aria/selection/src/packages/@react-aria/selection/src/utils.ts","packages/@react-aria/selection/src/packages/@react-aria/selection/src/useTypeSelect.ts","packages/@react-aria/selection/src/packages/@react-aria/selection/src/useSelectableCollection.ts","packages/@react-aria/selection/src/packages/@react-aria/selection/src/useSelectableItem.ts","packages/@react-aria/selection/src/packages/@react-aria/selection/src/DOMLayoutDelegate.ts","packages/@react-aria/selection/src/packages/@react-aria/selection/src/ListKeyboardDelegate.ts","packages/@react-aria/selection/src/packages/@react-aria/selection/src/useSelectableList.ts","packages/@react-aria/selection/src/packages/@react-aria/selection/src/index.ts","packages/@react-aria/selection/src/index.ts"],"sourcesContent":[null,null,null,null,null,null,null,null,"/*\n * Copyright 2020 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */\n\nexport {useSelectableCollection} from './useSelectableCollection';\nexport {useSelectableItem} from './useSelectableItem';\nexport {useSelectableList} from './useSelectableList';\nexport {ListKeyboardDelegate} from './ListKeyboardDelegate';\nexport {DOMLayoutDelegate} from './DOMLayoutDelegate';\nexport {useTypeSelect} from './useTypeSelect';\n\nexport type {AriaSelectableCollectionOptions, SelectableCollectionAria} from './useSelectableCollection';\nexport type {AriaSelectableListOptions, SelectableListAria} from './useSelectableList';\nexport type {SelectableItemOptions, SelectableItemStates, SelectableItemAria} from './useSelectableItem';\nexport type {AriaTypeSelectOptions, TypeSelectAria} from './useTypeSelect';\n"],"names":[],"version":3,"file":"types.d.ts.map"}

package/dist/useSelectableCollection.main.js

@@ -0,0 +1,318 @@
+var $ee0bdf4faa47f2a8$exports = require("./utils.main.js");
+var $a1189052f36475e8$exports = require("./useTypeSelect.main.js");
+var $bT8Bh$reactdom = require("react-dom");
+var $bT8Bh$react = require("react");
+var $bT8Bh$reactariafocus = require("@react-aria/focus");
+var $bT8Bh$reactariautils = require("@react-aria/utils");
+var $bT8Bh$reactariainteractions = require("@react-aria/interactions");
+var $bT8Bh$reactariai18n = require("@react-aria/i18n");
+
+
+function $parcel$export(e, n, v, s) {
+  Object.defineProperty(e, n, {get: v, set: s, enumerable: true, configurable: true});
+}
+
+$parcel$export(module.exports, "useSelectableCollection", () => $b6837c2f80a3c32f$export$d6daf82dcd84e87c);
+/*
+ * Copyright 2020 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.
+ */ 
+
+
+
+
+
+
+
+function $b6837c2f80a3c32f$export$d6daf82dcd84e87c(options) {
+    let { selectionManager: manager, keyboardDelegate: delegate, ref: ref, autoFocus: autoFocus = false, shouldFocusWrap: shouldFocusWrap = false, disallowEmptySelection: disallowEmptySelection = false, disallowSelectAll: disallowSelectAll = false, selectOnFocus: selectOnFocus = manager.selectionBehavior === 'replace', disallowTypeAhead: disallowTypeAhead = false, shouldUseVirtualFocus: shouldUseVirtualFocus, allowsTabNavigation: allowsTabNavigation = false, isVirtualized: isVirtualized, scrollRef: // If no scrollRef is provided, assume the collection ref is the scrollable region
+    scrollRef = ref, linkBehavior: linkBehavior = 'action' } = options;
+    let { direction: direction } = (0, $bT8Bh$reactariai18n.useLocale)();
+    let router = (0, $bT8Bh$reactariautils.useRouter)();
+    let onKeyDown = (e)=>{
+        // Prevent option + tab from doing anything since it doesn't move focus to the cells, only buttons/checkboxes
+        if (e.altKey && e.key === 'Tab') e.preventDefault();
+        // Keyboard events bubble through portals. Don't handle keyboard events
+        // for elements outside the collection (e.g. menus).
+        if (!ref.current.contains(e.target)) return;
+        const navigateToKey = (key, childFocus)=>{
+            if (key != null) {
+                if (manager.isLink(key) && linkBehavior === 'selection' && selectOnFocus && !(0, $ee0bdf4faa47f2a8$exports.isNonContiguousSelectionModifier)(e)) {
+                    // Set focused key and re-render synchronously to bring item into view if needed.
+                    (0, $bT8Bh$reactdom.flushSync)(()=>{
+                        manager.setFocusedKey(key, childFocus);
+                    });
+                    let item = scrollRef.current.querySelector(`[data-key="${CSS.escape(key.toString())}"]`);
+                    let itemProps = manager.getItemProps(key);
+                    router.open(item, e, itemProps.href, itemProps.routerOptions);
+                    return;
+                }
+                manager.setFocusedKey(key, childFocus);
+                if (manager.isLink(key) && linkBehavior === 'override') return;
+                if (e.shiftKey && manager.selectionMode === 'multiple') manager.extendSelection(key);
+                else if (selectOnFocus && !(0, $ee0bdf4faa47f2a8$exports.isNonContiguousSelectionModifier)(e)) manager.replaceSelection(key);
+            }
+        };
+        switch(e.key){
+            case 'ArrowDown':
+                if (delegate.getKeyBelow) {
+                    var _delegate_getKeyBelow, _delegate_getFirstKey, _delegate_getFirstKey1;
+                    let nextKey = manager.focusedKey != null ? (_delegate_getKeyBelow = delegate.getKeyBelow) === null || _delegate_getKeyBelow === void 0 ? void 0 : _delegate_getKeyBelow.call(delegate, manager.focusedKey) : (_delegate_getFirstKey = delegate.getFirstKey) === null || _delegate_getFirstKey === void 0 ? void 0 : _delegate_getFirstKey.call(delegate);
+                    if (nextKey == null && shouldFocusWrap) nextKey = (_delegate_getFirstKey1 = delegate.getFirstKey) === null || _delegate_getFirstKey1 === void 0 ? void 0 : _delegate_getFirstKey1.call(delegate, manager.focusedKey);
+                    if (nextKey != null) {
+                        e.preventDefault();
+                        navigateToKey(nextKey);
+                    }
+                }
+                break;
+            case 'ArrowUp':
+                if (delegate.getKeyAbove) {
+                    var _delegate_getKeyAbove, _delegate_getLastKey, _delegate_getLastKey1;
+                    let nextKey = manager.focusedKey != null ? (_delegate_getKeyAbove = delegate.getKeyAbove) === null || _delegate_getKeyAbove === void 0 ? void 0 : _delegate_getKeyAbove.call(delegate, manager.focusedKey) : (_delegate_getLastKey = delegate.getLastKey) === null || _delegate_getLastKey === void 0 ? void 0 : _delegate_getLastKey.call(delegate);
+                    if (nextKey == null && shouldFocusWrap) nextKey = (_delegate_getLastKey1 = delegate.getLastKey) === null || _delegate_getLastKey1 === void 0 ? void 0 : _delegate_getLastKey1.call(delegate, manager.focusedKey);
+                    if (nextKey != null) {
+                        e.preventDefault();
+                        navigateToKey(nextKey);
+                    }
+                }
+                break;
+            case 'ArrowLeft':
+                if (delegate.getKeyLeftOf) {
+                    var _delegate_getKeyLeftOf, _delegate_getFirstKey2, _delegate_getLastKey2;
+                    let nextKey = (_delegate_getKeyLeftOf = delegate.getKeyLeftOf) === null || _delegate_getKeyLeftOf === void 0 ? void 0 : _delegate_getKeyLeftOf.call(delegate, manager.focusedKey);
+                    if (nextKey == null && shouldFocusWrap) nextKey = direction === 'rtl' ? (_delegate_getFirstKey2 = delegate.getFirstKey) === null || _delegate_getFirstKey2 === void 0 ? void 0 : _delegate_getFirstKey2.call(delegate, manager.focusedKey) : (_delegate_getLastKey2 = delegate.getLastKey) === null || _delegate_getLastKey2 === void 0 ? void 0 : _delegate_getLastKey2.call(delegate, manager.focusedKey);
+                    if (nextKey != null) {
+                        e.preventDefault();
+                        navigateToKey(nextKey, direction === 'rtl' ? 'first' : 'last');
+                    }
+                }
+                break;
+            case 'ArrowRight':
+                if (delegate.getKeyRightOf) {
+                    var _delegate_getKeyRightOf, _delegate_getLastKey3, _delegate_getFirstKey3;
+                    let nextKey = (_delegate_getKeyRightOf = delegate.getKeyRightOf) === null || _delegate_getKeyRightOf === void 0 ? void 0 : _delegate_getKeyRightOf.call(delegate, manager.focusedKey);
+                    if (nextKey == null && shouldFocusWrap) nextKey = direction === 'rtl' ? (_delegate_getLastKey3 = delegate.getLastKey) === null || _delegate_getLastKey3 === void 0 ? void 0 : _delegate_getLastKey3.call(delegate, manager.focusedKey) : (_delegate_getFirstKey3 = delegate.getFirstKey) === null || _delegate_getFirstKey3 === void 0 ? void 0 : _delegate_getFirstKey3.call(delegate, manager.focusedKey);
+                    if (nextKey != null) {
+                        e.preventDefault();
+                        navigateToKey(nextKey, direction === 'rtl' ? 'last' : 'first');
+                    }
+                }
+                break;
+            case 'Home':
+                if (delegate.getFirstKey) {
+                    e.preventDefault();
+                    let firstKey = delegate.getFirstKey(manager.focusedKey, (0, $ee0bdf4faa47f2a8$exports.isCtrlKeyPressed)(e));
+                    manager.setFocusedKey(firstKey);
+                    if ((0, $ee0bdf4faa47f2a8$exports.isCtrlKeyPressed)(e) && e.shiftKey && manager.selectionMode === 'multiple') manager.extendSelection(firstKey);
+                    else if (selectOnFocus) manager.replaceSelection(firstKey);
+                }
+                break;
+            case 'End':
+                if (delegate.getLastKey) {
+                    e.preventDefault();
+                    let lastKey = delegate.getLastKey(manager.focusedKey, (0, $ee0bdf4faa47f2a8$exports.isCtrlKeyPressed)(e));
+                    manager.setFocusedKey(lastKey);
+                    if ((0, $ee0bdf4faa47f2a8$exports.isCtrlKeyPressed)(e) && e.shiftKey && manager.selectionMode === 'multiple') manager.extendSelection(lastKey);
+                    else if (selectOnFocus) manager.replaceSelection(lastKey);
+                }
+                break;
+            case 'PageDown':
+                if (delegate.getKeyPageBelow) {
+                    let nextKey = delegate.getKeyPageBelow(manager.focusedKey);
+                    if (nextKey != null) {
+                        e.preventDefault();
+                        navigateToKey(nextKey);
+                    }
+                }
+                break;
+            case 'PageUp':
+                if (delegate.getKeyPageAbove) {
+                    let nextKey = delegate.getKeyPageAbove(manager.focusedKey);
+                    if (nextKey != null) {
+                        e.preventDefault();
+                        navigateToKey(nextKey);
+                    }
+                }
+                break;
+            case 'a':
+                if ((0, $ee0bdf4faa47f2a8$exports.isCtrlKeyPressed)(e) && manager.selectionMode === 'multiple' && disallowSelectAll !== true) {
+                    e.preventDefault();
+                    manager.selectAll();
+                }
+                break;
+            case 'Escape':
+                if (!disallowEmptySelection && manager.selectedKeys.size !== 0) {
+                    e.stopPropagation();
+                    e.preventDefault();
+                    manager.clearSelection();
+                }
+                break;
+            case 'Tab':
+                if (!allowsTabNavigation) {
+                    // There may be elements that are "tabbable" inside a collection (e.g. in a grid cell).
+                    // However, collections should be treated as a single tab stop, with arrow key navigation internally.
+                    // We don't control the rendering of these, so we can't override the tabIndex to prevent tabbing.
+                    // Instead, we handle the Tab key, and move focus manually to the first/last tabbable element
+                    // in the collection, so that the browser default behavior will apply starting from that element
+                    // rather than the currently focused one.
+                    if (e.shiftKey) ref.current.focus();
+                    else {
+                        let walker = (0, $bT8Bh$reactariafocus.getFocusableTreeWalker)(ref.current, {
+                            tabbable: true
+                        });
+                        let next;
+                        let last;
+                        do {
+                            last = walker.lastChild();
+                            if (last) next = last;
+                        }while (last);
+                        if (next && !next.contains(document.activeElement)) (0, $bT8Bh$reactariautils.focusWithoutScrolling)(next);
+                    }
+                    break;
+                }
+        }
+    };
+    // Store the scroll position so we can restore it later.
+    /// TODO: should this happen all the time??
+    let scrollPos = (0, $bT8Bh$react.useRef)({
+        top: 0,
+        left: 0
+    });
+    (0, $bT8Bh$reactariautils.useEvent)(scrollRef, 'scroll', isVirtualized ? null : ()=>{
+        scrollPos.current = {
+            top: scrollRef.current.scrollTop,
+            left: scrollRef.current.scrollLeft
+        };
+    });
+    let onFocus = (e)=>{
+        if (manager.isFocused) {
+            // If a focus event bubbled through a portal, reset focus state.
+            if (!e.currentTarget.contains(e.target)) manager.setFocused(false);
+            return;
+        }
+        // Focus events can bubble through portals. Ignore these events.
+        if (!e.currentTarget.contains(e.target)) return;
+        manager.setFocused(true);
+        if (manager.focusedKey == null) {
+            let navigateToFirstKey = (key)=>{
+                if (key != null) {
+                    manager.setFocusedKey(key);
+                    if (selectOnFocus) manager.replaceSelection(key);
+                }
+            };
+            // If the user hasn't yet interacted with the collection, there will be no focusedKey set.
+            // Attempt to detect whether the user is tabbing forward or backward into the collection
+            // and either focus the first or last item accordingly.
+            let relatedTarget = e.relatedTarget;
+            var _manager_lastSelectedKey, _manager_firstSelectedKey;
+            if (relatedTarget && e.currentTarget.compareDocumentPosition(relatedTarget) & Node.DOCUMENT_POSITION_FOLLOWING) navigateToFirstKey((_manager_lastSelectedKey = manager.lastSelectedKey) !== null && _manager_lastSelectedKey !== void 0 ? _manager_lastSelectedKey : delegate.getLastKey());
+            else navigateToFirstKey((_manager_firstSelectedKey = manager.firstSelectedKey) !== null && _manager_firstSelectedKey !== void 0 ? _manager_firstSelectedKey : delegate.getFirstKey());
+        } else if (!isVirtualized) {
+            // Restore the scroll position to what it was before.
+            scrollRef.current.scrollTop = scrollPos.current.top;
+            scrollRef.current.scrollLeft = scrollPos.current.left;
+        }
+        if (manager.focusedKey != null) {
+            // Refocus and scroll the focused item into view if it exists within the scrollable region.
+            let element = scrollRef.current.querySelector(`[data-key="${CSS.escape(manager.focusedKey.toString())}"]`);
+            if (element) {
+                // This prevents a flash of focus on the first/last element in the collection, or the collection itself.
+                if (!element.contains(document.activeElement)) (0, $bT8Bh$reactariautils.focusWithoutScrolling)(element);
+                let modality = (0, $bT8Bh$reactariainteractions.getInteractionModality)();
+                if (modality === 'keyboard') (0, $bT8Bh$reactariautils.scrollIntoViewport)(element, {
+                    containingElement: ref.current
+                });
+            }
+        }
+    };
+    let onBlur = (e)=>{
+        // Don't set blurred and then focused again if moving focus within the collection.
+        if (!e.currentTarget.contains(e.relatedTarget)) manager.setFocused(false);
+    };
+    const autoFocusRef = (0, $bT8Bh$react.useRef)(autoFocus);
+    (0, $bT8Bh$react.useEffect)(()=>{
+        if (autoFocusRef.current) {
+            let focusedKey = null;
+            // Check focus strategy to determine which item to focus
+            if (autoFocus === 'first') focusedKey = delegate.getFirstKey();
+            if (autoFocus === 'last') focusedKey = delegate.getLastKey();
+            // If there are any selected keys, make the first one the new focus target
+            let selectedKeys = manager.selectedKeys;
+            if (selectedKeys.size) {
+                for (let key of selectedKeys)if (manager.canSelectItem(key)) {
+                    focusedKey = key;
+                    break;
+                }
+            }
+            manager.setFocused(true);
+            manager.setFocusedKey(focusedKey);
+            // If no default focus key is selected, focus the collection itself.
+            if (focusedKey == null && !shouldUseVirtualFocus) (0, $bT8Bh$reactariafocus.focusSafely)(ref.current);
+        }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, []);
+    // Scroll the focused element into view when the focusedKey changes.
+    let lastFocusedKey = (0, $bT8Bh$react.useRef)(manager.focusedKey);
+    (0, $bT8Bh$react.useEffect)(()=>{
+        if (manager.isFocused && manager.focusedKey != null && (manager.focusedKey !== lastFocusedKey.current || autoFocusRef.current) && (scrollRef === null || scrollRef === void 0 ? void 0 : scrollRef.current)) {
+            let modality = (0, $bT8Bh$reactariainteractions.getInteractionModality)();
+            let element = ref.current.querySelector(`[data-key="${CSS.escape(manager.focusedKey.toString())}"]`);
+            if (!element) // If item element wasn't found, return early (don't update autoFocusRef and lastFocusedKey).
+            // The collection may initially be empty (e.g. virtualizer), so wait until the element exists.
+            return;
+            if (modality === 'keyboard' || autoFocusRef.current) {
+                (0, $bT8Bh$reactariautils.scrollIntoView)(scrollRef.current, element);
+                // Avoid scroll in iOS VO, since it may cause overlay to close (i.e. RAC submenu)
+                if (modality !== 'virtual') (0, $bT8Bh$reactariautils.scrollIntoViewport)(element, {
+                    containingElement: ref.current
+                });
+            }
+        }
+        // If the focused key becomes null (e.g. the last item is deleted), focus the whole collection.
+        if (!shouldUseVirtualFocus && manager.isFocused && manager.focusedKey == null && lastFocusedKey.current != null) (0, $bT8Bh$reactariafocus.focusSafely)(ref.current);
+        lastFocusedKey.current = manager.focusedKey;
+        autoFocusRef.current = false;
+    });
+    // Intercept FocusScope restoration since virtualized collections can reuse DOM nodes.
+    (0, $bT8Bh$reactariautils.useEvent)(ref, 'react-aria-focus-scope-restore', (e)=>{
+        e.preventDefault();
+        manager.setFocused(true);
+    });
+    let handlers = {
+        onKeyDown: onKeyDown,
+        onFocus: onFocus,
+        onBlur: onBlur,
+        onMouseDown (e) {
+            // Ignore events that bubbled through portals.
+            if (scrollRef.current === e.target) // Prevent focus going to the collection when clicking on the scrollbar.
+            e.preventDefault();
+        }
+    };
+    let { typeSelectProps: typeSelectProps } = (0, $a1189052f36475e8$exports.useTypeSelect)({
+        keyboardDelegate: delegate,
+        selectionManager: manager
+    });
+    if (!disallowTypeAhead) handlers = (0, $bT8Bh$reactariautils.mergeProps)(typeSelectProps, handlers);
+    // If nothing is focused within the collection, make the collection itself tabbable.
+    // This will be marshalled to either the first or last item depending on where focus came from.
+    // If using virtual focus, don't set a tabIndex at all so that VoiceOver on iOS 14 doesn't try
+    // to move real DOM focus to the element anyway.
+    let tabIndex;
+    if (!shouldUseVirtualFocus) tabIndex = manager.focusedKey == null ? 0 : -1;
+    return {
+        collectionProps: {
+            ...handlers,
+            tabIndex: tabIndex
+        }
+    };
+}
+
+
+//# sourceMappingURL=useSelectableCollection.main.js.map