@react-aria/selection 3.17.5 → 3.18.0

package/dist/useSelectableCollection.mjs

@@ -0,0 +1,299 @@
+import {isCtrlKeyPressed as $feb5ffebff200149$export$16792effe837dba3, isNonContiguousSelectionModifier as $feb5ffebff200149$export$d3e3bd3e26688c04} from "./utils.mjs";
+import {useTypeSelect as $fb3050f43d946246$export$e32c88dfddc6e1d8} from "./useTypeSelect.mjs";
+import {flushSync as $3H3GQ$flushSync} from "react-dom";
+import {useRef as $3H3GQ$useRef, useEffect as $3H3GQ$useEffect} from "react";
+import {getFocusableTreeWalker as $3H3GQ$getFocusableTreeWalker, focusSafely as $3H3GQ$focusSafely} from "@react-aria/focus";
+import {useRouter as $3H3GQ$useRouter, focusWithoutScrolling as $3H3GQ$focusWithoutScrolling, useEvent as $3H3GQ$useEvent, scrollIntoViewport as $3H3GQ$scrollIntoViewport, scrollIntoView as $3H3GQ$scrollIntoView, mergeProps as $3H3GQ$mergeProps} from "@react-aria/utils";
+import {getInteractionModality as $3H3GQ$getInteractionModality} from "@react-aria/interactions";
+import {useLocale as $3H3GQ$useLocale} from "@react-aria/i18n";
+
+/*
+ * 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 $ae20dd8cbca75726$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, $3H3GQ$useLocale)();
+    let router = (0, $3H3GQ$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, $feb5ffebff200149$export$d3e3bd3e26688c04)(e)) {
+                    // Set focused key and re-render synchronously to bring item into view if needed.
+                    (0, $3H3GQ$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, $feb5ffebff200149$export$d3e3bd3e26688c04)(e)) manager.replaceSelection(key);
+            }
+        };
+        switch(e.key){
+            case "ArrowDown":
+                if (delegate.getKeyBelow) {
+                    var _delegate_getFirstKey, _delegate_getFirstKey1;
+                    e.preventDefault();
+                    let nextKey = manager.focusedKey != null ? delegate.getKeyBelow(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);
+                    navigateToKey(nextKey);
+                }
+                break;
+            case "ArrowUp":
+                if (delegate.getKeyAbove) {
+                    var _delegate_getLastKey, _delegate_getLastKey1;
+                    e.preventDefault();
+                    let nextKey = manager.focusedKey != null ? delegate.getKeyAbove(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);
+                    navigateToKey(nextKey);
+                }
+                break;
+            case "ArrowLeft":
+                if (delegate.getKeyLeftOf) {
+                    var _delegate_getFirstKey2, _delegate_getLastKey2;
+                    e.preventDefault();
+                    let nextKey = delegate.getKeyLeftOf(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);
+                    navigateToKey(nextKey, direction === "rtl" ? "first" : "last");
+                }
+                break;
+            case "ArrowRight":
+                if (delegate.getKeyRightOf) {
+                    var _delegate_getLastKey3, _delegate_getFirstKey3;
+                    e.preventDefault();
+                    let nextKey = delegate.getKeyRightOf(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);
+                    navigateToKey(nextKey, direction === "rtl" ? "last" : "first");
+                }
+                break;
+            case "Home":
+                if (delegate.getFirstKey) {
+                    e.preventDefault();
+                    let firstKey = delegate.getFirstKey(manager.focusedKey, (0, $feb5ffebff200149$export$16792effe837dba3)(e));
+                    manager.setFocusedKey(firstKey);
+                    if ((0, $feb5ffebff200149$export$16792effe837dba3)(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, $feb5ffebff200149$export$16792effe837dba3)(e));
+                    manager.setFocusedKey(lastKey);
+                    if ((0, $feb5ffebff200149$export$16792effe837dba3)(e) && e.shiftKey && manager.selectionMode === "multiple") manager.extendSelection(lastKey);
+                    else if (selectOnFocus) manager.replaceSelection(lastKey);
+                }
+                break;
+            case "PageDown":
+                if (delegate.getKeyPageBelow) {
+                    e.preventDefault();
+                    let nextKey = delegate.getKeyPageBelow(manager.focusedKey);
+                    navigateToKey(nextKey);
+                }
+                break;
+            case "PageUp":
+                if (delegate.getKeyPageAbove) {
+                    e.preventDefault();
+                    let nextKey = delegate.getKeyPageAbove(manager.focusedKey);
+                    navigateToKey(nextKey);
+                }
+                break;
+            case "a":
+                if ((0, $feb5ffebff200149$export$16792effe837dba3)(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, $3H3GQ$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, $3H3GQ$focusWithoutScrolling)(next);
+                    }
+                    break;
+                }
+        }
+    };
+    // Store the scroll position so we can restore it later.
+    let scrollPos = (0, $3H3GQ$useRef)({
+        top: 0,
+        left: 0
+    });
+    (0, $3H3GQ$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 (!isVirtualized && 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, $3H3GQ$focusWithoutScrolling)(element);
+                let modality = (0, $3H3GQ$getInteractionModality)();
+                if (modality === "keyboard") (0, $3H3GQ$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, $3H3GQ$useRef)(autoFocus);
+    (0, $3H3GQ$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, $3H3GQ$focusSafely)(ref.current);
+        }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, []);
+    // If not virtualized, scroll the focused element into view when the focusedKey changes.
+    // When virtualized, Virtualizer handles this internally.
+    let lastFocusedKey = (0, $3H3GQ$useRef)(manager.focusedKey);
+    (0, $3H3GQ$useEffect)(()=>{
+        let modality = (0, $3H3GQ$getInteractionModality)();
+        if (manager.isFocused && manager.focusedKey != null && (scrollRef === null || scrollRef === void 0 ? void 0 : scrollRef.current)) {
+            let element = scrollRef.current.querySelector(`[data-key="${CSS.escape(manager.focusedKey.toString())}"]`);
+            if (element && (modality === "keyboard" || autoFocusRef.current)) {
+                if (!isVirtualized) (0, $3H3GQ$scrollIntoView)(scrollRef.current, element);
+                // Avoid scroll in iOS VO, since it may cause overlay to close (i.e. RAC submenu)
+                if (modality !== "virtual") (0, $3H3GQ$scrollIntoViewport)(element, {
+                    containingElement: ref.current
+                });
+            }
+        }
+        // If the focused key becomes null (e.g. the last item is deleted), focus the whole collection.
+        if (manager.isFocused && manager.focusedKey == null && lastFocusedKey.current != null) (0, $3H3GQ$focusSafely)(ref.current);
+        lastFocusedKey.current = manager.focusedKey;
+        autoFocusRef.current = false;
+    }, [
+        isVirtualized,
+        scrollRef,
+        manager.focusedKey,
+        manager.isFocused,
+        ref
+    ]);
+    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, $fb3050f43d946246$export$e32c88dfddc6e1d8)({
+        keyboardDelegate: delegate,
+        selectionManager: manager
+    });
+    if (!disallowTypeAhead) handlers = (0, $3H3GQ$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
+        }
+    };
+}
+
+
+export {$ae20dd8cbca75726$export$d6daf82dcd84e87c as useSelectableCollection};
+//# sourceMappingURL=useSelectableCollection.mjs.map

package/dist/useSelectableCollection.module.js

@@ -0,0 +1,299 @@
+import {isCtrlKeyPressed as $feb5ffebff200149$export$16792effe837dba3, isNonContiguousSelectionModifier as $feb5ffebff200149$export$d3e3bd3e26688c04} from "./utils.module.js";
+import {useTypeSelect as $fb3050f43d946246$export$e32c88dfddc6e1d8} from "./useTypeSelect.module.js";
+import {flushSync as $3H3GQ$flushSync} from "react-dom";
+import {useRef as $3H3GQ$useRef, useEffect as $3H3GQ$useEffect} from "react";
+import {getFocusableTreeWalker as $3H3GQ$getFocusableTreeWalker, focusSafely as $3H3GQ$focusSafely} from "@react-aria/focus";
+import {useRouter as $3H3GQ$useRouter, focusWithoutScrolling as $3H3GQ$focusWithoutScrolling, useEvent as $3H3GQ$useEvent, scrollIntoViewport as $3H3GQ$scrollIntoViewport, scrollIntoView as $3H3GQ$scrollIntoView, mergeProps as $3H3GQ$mergeProps} from "@react-aria/utils";
+import {getInteractionModality as $3H3GQ$getInteractionModality} from "@react-aria/interactions";
+import {useLocale as $3H3GQ$useLocale} from "@react-aria/i18n";
+
+/*
+ * 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 $ae20dd8cbca75726$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, $3H3GQ$useLocale)();
+    let router = (0, $3H3GQ$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, $feb5ffebff200149$export$d3e3bd3e26688c04)(e)) {
+                    // Set focused key and re-render synchronously to bring item into view if needed.
+                    (0, $3H3GQ$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, $feb5ffebff200149$export$d3e3bd3e26688c04)(e)) manager.replaceSelection(key);
+            }
+        };
+        switch(e.key){
+            case "ArrowDown":
+                if (delegate.getKeyBelow) {
+                    var _delegate_getFirstKey, _delegate_getFirstKey1;
+                    e.preventDefault();
+                    let nextKey = manager.focusedKey != null ? delegate.getKeyBelow(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);
+                    navigateToKey(nextKey);
+                }
+                break;
+            case "ArrowUp":
+                if (delegate.getKeyAbove) {
+                    var _delegate_getLastKey, _delegate_getLastKey1;
+                    e.preventDefault();
+                    let nextKey = manager.focusedKey != null ? delegate.getKeyAbove(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);
+                    navigateToKey(nextKey);
+                }
+                break;
+            case "ArrowLeft":
+                if (delegate.getKeyLeftOf) {
+                    var _delegate_getFirstKey2, _delegate_getLastKey2;
+                    e.preventDefault();
+                    let nextKey = delegate.getKeyLeftOf(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);
+                    navigateToKey(nextKey, direction === "rtl" ? "first" : "last");
+                }
+                break;
+            case "ArrowRight":
+                if (delegate.getKeyRightOf) {
+                    var _delegate_getLastKey3, _delegate_getFirstKey3;
+                    e.preventDefault();
+                    let nextKey = delegate.getKeyRightOf(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);
+                    navigateToKey(nextKey, direction === "rtl" ? "last" : "first");
+                }
+                break;
+            case "Home":
+                if (delegate.getFirstKey) {
+                    e.preventDefault();
+                    let firstKey = delegate.getFirstKey(manager.focusedKey, (0, $feb5ffebff200149$export$16792effe837dba3)(e));
+                    manager.setFocusedKey(firstKey);
+                    if ((0, $feb5ffebff200149$export$16792effe837dba3)(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, $feb5ffebff200149$export$16792effe837dba3)(e));
+                    manager.setFocusedKey(lastKey);
+                    if ((0, $feb5ffebff200149$export$16792effe837dba3)(e) && e.shiftKey && manager.selectionMode === "multiple") manager.extendSelection(lastKey);
+                    else if (selectOnFocus) manager.replaceSelection(lastKey);
+                }
+                break;
+            case "PageDown":
+                if (delegate.getKeyPageBelow) {
+                    e.preventDefault();
+                    let nextKey = delegate.getKeyPageBelow(manager.focusedKey);
+                    navigateToKey(nextKey);
+                }
+                break;
+            case "PageUp":
+                if (delegate.getKeyPageAbove) {
+                    e.preventDefault();
+                    let nextKey = delegate.getKeyPageAbove(manager.focusedKey);
+                    navigateToKey(nextKey);
+                }
+                break;
+            case "a":
+                if ((0, $feb5ffebff200149$export$16792effe837dba3)(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, $3H3GQ$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, $3H3GQ$focusWithoutScrolling)(next);
+                    }
+                    break;
+                }
+        }
+    };
+    // Store the scroll position so we can restore it later.
+    let scrollPos = (0, $3H3GQ$useRef)({
+        top: 0,
+        left: 0
+    });
+    (0, $3H3GQ$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 (!isVirtualized && 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, $3H3GQ$focusWithoutScrolling)(element);
+                let modality = (0, $3H3GQ$getInteractionModality)();
+                if (modality === "keyboard") (0, $3H3GQ$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, $3H3GQ$useRef)(autoFocus);
+    (0, $3H3GQ$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, $3H3GQ$focusSafely)(ref.current);
+        }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, []);
+    // If not virtualized, scroll the focused element into view when the focusedKey changes.
+    // When virtualized, Virtualizer handles this internally.
+    let lastFocusedKey = (0, $3H3GQ$useRef)(manager.focusedKey);
+    (0, $3H3GQ$useEffect)(()=>{
+        let modality = (0, $3H3GQ$getInteractionModality)();
+        if (manager.isFocused && manager.focusedKey != null && (scrollRef === null || scrollRef === void 0 ? void 0 : scrollRef.current)) {
+            let element = scrollRef.current.querySelector(`[data-key="${CSS.escape(manager.focusedKey.toString())}"]`);
+            if (element && (modality === "keyboard" || autoFocusRef.current)) {
+                if (!isVirtualized) (0, $3H3GQ$scrollIntoView)(scrollRef.current, element);
+                // Avoid scroll in iOS VO, since it may cause overlay to close (i.e. RAC submenu)
+                if (modality !== "virtual") (0, $3H3GQ$scrollIntoViewport)(element, {
+                    containingElement: ref.current
+                });
+            }
+        }
+        // If the focused key becomes null (e.g. the last item is deleted), focus the whole collection.
+        if (manager.isFocused && manager.focusedKey == null && lastFocusedKey.current != null) (0, $3H3GQ$focusSafely)(ref.current);
+        lastFocusedKey.current = manager.focusedKey;
+        autoFocusRef.current = false;
+    }, [
+        isVirtualized,
+        scrollRef,
+        manager.focusedKey,
+        manager.isFocused,
+        ref
+    ]);
+    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, $fb3050f43d946246$export$e32c88dfddc6e1d8)({
+        keyboardDelegate: delegate,
+        selectionManager: manager
+    });
+    if (!disallowTypeAhead) handlers = (0, $3H3GQ$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
+        }
+    };
+}
+
+
+export {$ae20dd8cbca75726$export$d6daf82dcd84e87c as useSelectableCollection};
+//# sourceMappingURL=useSelectableCollection.module.js.map