react-aria 3.49.0 → 3.51.0

package/dist/private/selection/useSelectableCollection.js

@@ -7,10 +7,12 @@ import {getFocusableTreeWalker as $903814aeb7d53b38$export$2d6ec8fc375ceafa} fro
 import {getInteractionModality as $b50b1cc8a843ace7$export$630ff653c5ada6a9} from "../interactions/useFocusVisible.js";
 import {getItemElement as $8f207f199487227b$export$c3d8340acf92597f, isNonContiguousSelectionModifier as $8f207f199487227b$export$d3e3bd3e26688c04, useCollectionId as $8f207f199487227b$export$881eb0d9f3605d9d} from "./utils.js";
 import {isCtrlKeyPressed as $2224c9ee07fd529d$export$16792effe837dba3} from "../utils/keyboard.js";
+import {isMac as $d5a2be505488529f$export$9ac100e40613ea10} from "../utils/platform.js";
 import {isTabbable as $ee5e22534121197a$export$bebd5a1431fec25d} from "../utils/isFocusable.js";
 import {mergeProps as $64c36edd757dfa16$export$9d1611c77c2fe928} from "../utils/mergeProps.js";
 import {scrollIntoView as $6507765bd7f5ad94$export$53a0910f038337bd, scrollIntoViewport as $6507765bd7f5ad94$export$c826860796309d1b} from "../utils/scrollIntoView.js";
 import {useEvent as $c3cab330536504ec$export$90fc3a17d93f704c} from "../utils/useEvent.js";
+import {useKeyboard as $bf74df7506f65576$export$8f71654801c2f7cd} from "../interactions/useKeyboard.js";
 import {useLocale as $4defb058003b3e05$export$43bb16f9c6d9e3f7} from "../i18n/I18nProvider.js";
 import {useRouter as $044d3c97ce5d6621$export$9a302a45f65d0572} from "../utils/openLink.js";
 import {useTypeSelect as $d6feb9780eea1a71$export$e32c88dfddc6e1d8} from "./useTypeSelect.js";
@@ -47,165 +49,219 @@ import {useRef as $ld26Q$useRef, useEffect as $ld26Q$useEffect} from "react";
 
 
 
+
+
 function $80c8b4b5cf8e1f86$export$d6daf82dcd84e87c(options) {
+    var _delegate_getFirstKey;
     let { selectionManager: manager, keyboardDelegate: delegate, ref: ref, autoFocus: autoFocus = false, shouldFocusWrap: shouldFocusWrap = false, disallowEmptySelection: disallowEmptySelection = false, disallowSelectAll: disallowSelectAll = false, escapeKeyBehavior: escapeKeyBehavior = 'clearSelection', selectOnFocus: selectOnFocus = manager.selectionBehavior === 'replace', disallowTypeAhead: disallowTypeAhead = false, shouldUseVirtualFocus: shouldUseVirtualFocus, allowsTabNavigation: allowsTabNavigation = false, scrollRef: // If no scrollRef is provided, assume the collection ref is the scrollable region
-    scrollRef = ref, linkBehavior: linkBehavior = 'action' } = options;
+    scrollRef = ref, linkBehavior: linkBehavior = 'action', UNSTABLE_focusOnEntry: UNSTABLE_focusOnEntry } = options;
     let { direction: direction } = (0, $4defb058003b3e05$export$43bb16f9c6d9e3f7)();
     let router = (0, $044d3c97ce5d6621$export$9a302a45f65d0572)();
-    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 || !(0, $d8ac7ed472840322$export$4282f70798064fe0)(ref.current, (0, $d8ac7ed472840322$export$e58f029f0fbfdb29)(e))) return;
-        const navigateToKey = (key, childFocus)=>{
-            if (key != null) {
-                if (manager.isLink(key) && linkBehavior === 'selection' && selectOnFocus && !(0, $8f207f199487227b$export$d3e3bd3e26688c04)(e)) {
-                    // Set focused key and re-render synchronously to bring item into view if needed.
-                    (0, $ld26Q$flushSync)(()=>{
-                        manager.setFocusedKey(key, childFocus);
-                    });
-                    let item = (0, $8f207f199487227b$export$c3d8340acf92597f)(ref, key);
-                    let itemProps = manager.getItemProps(key);
-                    if (item) router.open(item, e, itemProps.href, itemProps.routerOptions);
+    const navigateToKey = (e, key, childFocus)=>{
+        if (key != null) {
+            if (manager.isLink(key) && linkBehavior === 'selection' && selectOnFocus && !(0, $8f207f199487227b$export$d3e3bd3e26688c04)(e)) {
+                // Set focused key and re-render synchronously to bring item into view if needed.
+                (0, $ld26Q$flushSync)(()=>{
+                    manager.setFocusedKey(key, childFocus);
+                });
+                let item = (0, $8f207f199487227b$export$c3d8340acf92597f)(ref, key);
+                let itemProps = manager.getItemProps(key);
+                if (item) {
+                    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, $8f207f199487227b$export$d3e3bd3e26688c04)(e)) manager.replaceSelection(key);
+                return false;
             }
-        };
-        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_getFirstKey3, _delegate_getLastKey2;
-                    let nextKey = manager.focusedKey != null ? (_delegate_getKeyLeftOf = delegate.getKeyLeftOf) === null || _delegate_getKeyLeftOf === void 0 ? void 0 : _delegate_getKeyLeftOf.call(delegate, manager.focusedKey) : (_delegate_getFirstKey2 = delegate.getFirstKey) === null || _delegate_getFirstKey2 === void 0 ? void 0 : _delegate_getFirstKey2.call(delegate);
-                    if (nextKey == null && shouldFocusWrap) nextKey = direction === 'rtl' ? (_delegate_getFirstKey3 = delegate.getFirstKey) === null || _delegate_getFirstKey3 === void 0 ? void 0 : _delegate_getFirstKey3.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_getFirstKey4, _delegate_getLastKey3, _delegate_getFirstKey5;
-                    let nextKey = manager.focusedKey != null ? (_delegate_getKeyRightOf = delegate.getKeyRightOf) === null || _delegate_getKeyRightOf === void 0 ? void 0 : _delegate_getKeyRightOf.call(delegate, manager.focusedKey) : (_delegate_getFirstKey4 = delegate.getFirstKey) === null || _delegate_getFirstKey4 === void 0 ? void 0 : _delegate_getFirstKey4.call(delegate);
-                    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_getFirstKey5 = delegate.getFirstKey) === null || _delegate_getFirstKey5 === void 0 ? void 0 : _delegate_getFirstKey5.call(delegate, manager.focusedKey);
-                    if (nextKey != null) {
-                        e.preventDefault();
-                        navigateToKey(nextKey, direction === 'rtl' ? 'last' : 'first');
-                    }
-                }
-                break;
-            case 'Home':
-                if (delegate.getFirstKey) {
-                    if (manager.focusedKey === null && e.shiftKey) return;
-                    e.preventDefault();
-                    let firstKey = delegate.getFirstKey(manager.focusedKey, (0, $2224c9ee07fd529d$export$16792effe837dba3)(e));
-                    manager.setFocusedKey(firstKey);
-                    if (firstKey != null) {
-                        if ((0, $2224c9ee07fd529d$export$16792effe837dba3)(e) && e.shiftKey && manager.selectionMode === 'multiple') manager.extendSelection(firstKey);
-                        else if (selectOnFocus) manager.replaceSelection(firstKey);
-                    }
-                }
-                break;
-            case 'End':
-                if (delegate.getLastKey) {
-                    if (manager.focusedKey === null && e.shiftKey) return;
-                    e.preventDefault();
-                    let lastKey = delegate.getLastKey(manager.focusedKey, (0, $2224c9ee07fd529d$export$16792effe837dba3)(e));
-                    manager.setFocusedKey(lastKey);
-                    if (lastKey != null) {
-                        if ((0, $2224c9ee07fd529d$export$16792effe837dba3)(e) && e.shiftKey && manager.selectionMode === 'multiple') manager.extendSelection(lastKey);
-                        else if (selectOnFocus) manager.replaceSelection(lastKey);
-                    }
-                }
-                break;
-            case 'PageDown':
-                if (delegate.getKeyPageBelow && manager.focusedKey != null) {
-                    let nextKey = delegate.getKeyPageBelow(manager.focusedKey);
-                    if (nextKey != null) {
-                        e.preventDefault();
-                        navigateToKey(nextKey);
-                    }
-                }
-                break;
-            case 'PageUp':
-                if (delegate.getKeyPageAbove && manager.focusedKey != null) {
-                    let nextKey = delegate.getKeyPageAbove(manager.focusedKey);
-                    if (nextKey != null) {
-                        e.preventDefault();
-                        navigateToKey(nextKey);
-                    }
-                }
-                break;
-            case 'a':
-                if ((0, $2224c9ee07fd529d$export$16792effe837dba3)(e) && manager.selectionMode === 'multiple' && disallowSelectAll !== true) {
-                    e.preventDefault();
-                    manager.selectAll();
-                }
-                break;
-            case 'Escape':
-                if (escapeKeyBehavior === 'clearSelection' && !disallowEmptySelection && manager.selectedKeys.size !== 0) {
-                    e.stopPropagation();
-                    e.preventDefault();
-                    manager.clearSelection();
+            manager.setFocusedKey(key, childFocus);
+            if (manager.isLink(key) && linkBehavior === 'override') return false;
+            if (e.shiftKey && manager.selectionMode === 'multiple') {
+                manager.extendSelection(key);
+                return;
+            } else if (selectOnFocus && !(0, $8f207f199487227b$export$d3e3bd3e26688c04)(e)) {
+                manager.replaceSelection(key);
+                return;
+            }
+        }
+        return false;
+    };
+    let arrowDown = (e)=>{
+        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) {
+                navigateToKey(e, nextKey);
+                return;
+            }
+        }
+        return false;
+    };
+    let arrowUp = (e)=>{
+        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) {
+                navigateToKey(e, nextKey);
+                return;
+            }
+        }
+        return false;
+    };
+    let home = (e)=>{
+        if (delegate.getFirstKey) {
+            if (manager.focusedKey === null && e.shiftKey) return false;
+            // TODO: should Home and End also be reversed in column reverse aka Home goes to top? Or should Home always to to the "first" (bottom)
+            let firstKey = delegate.getFirstKey(manager.focusedKey, (0, $2224c9ee07fd529d$export$16792effe837dba3)(e));
+            manager.setFocusedKey(firstKey);
+            if (firstKey != null) {
+                if ((0, $2224c9ee07fd529d$export$16792effe837dba3)(e) && e.shiftKey && manager.selectionMode === 'multiple') {
+                    manager.extendSelection(firstKey);
+                    return;
+                } else if (selectOnFocus) {
+                    manager.replaceSelection(firstKey);
+                    return;
                 }
-                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, $903814aeb7d53b38$export$2d6ec8fc375ceafa)(ref.current, {
-                            tabbable: true
-                        });
-                        let next = undefined;
-                        let last;
-                        do {
-                            last = walker.lastChild();
-                            // oxlint-disable-next-line max-depth
-                            if (last) next = last;
-                        }while (last);
-                        // If the active element is NOT tabbable but is contained by an element that IS tabbable (aka the cell), the browser will actually move focus to
-                        // the containing element. We need to special case this so that tab will move focus out of the grid instead of looping between
-                        // focusing the containing cell and back to the non-tabbable child element
-                        let activeElement = (0, $d8ac7ed472840322$export$cd4e5573fbe2b576)();
-                        if (next && (!(0, $d8ac7ed472840322$export$b4f377a2b6254582)(next) || activeElement && !(0, $ee5e22534121197a$export$bebd5a1431fec25d)(activeElement))) (0, $d559d872031c749f$export$de79e2c695e052f3)(next);
-                    }
-                    break;
+            }
+        }
+        return false;
+    };
+    let arrowLeft = (e)=>{
+        if (delegate.getKeyLeftOf) {
+            var _delegate_getKeyLeftOf, _delegate_getFirstKey, _delegate_getFirstKey1, _delegate_getLastKey;
+            let nextKey = manager.focusedKey != null ? (_delegate_getKeyLeftOf = delegate.getKeyLeftOf) === null || _delegate_getKeyLeftOf === void 0 ? void 0 : _delegate_getKeyLeftOf.call(delegate, manager.focusedKey) : (_delegate_getFirstKey = delegate.getFirstKey) === null || _delegate_getFirstKey === void 0 ? void 0 : _delegate_getFirstKey.call(delegate);
+            if (nextKey == null && shouldFocusWrap) nextKey = direction === 'rtl' ? (_delegate_getFirstKey1 = delegate.getFirstKey) === null || _delegate_getFirstKey1 === void 0 ? void 0 : _delegate_getFirstKey1.call(delegate, manager.focusedKey) : (_delegate_getLastKey = delegate.getLastKey) === null || _delegate_getLastKey === void 0 ? void 0 : _delegate_getLastKey.call(delegate, manager.focusedKey);
+            if (nextKey != null) {
+                navigateToKey(e, nextKey, direction === 'rtl' ? 'first' : 'last');
+                return;
+            }
+        }
+        return false;
+    };
+    let arrowRight = (e)=>{
+        if (delegate.getKeyRightOf) {
+            var _delegate_getKeyRightOf, _delegate_getFirstKey, _delegate_getLastKey, _delegate_getFirstKey1;
+            let nextKey = manager.focusedKey != null ? (_delegate_getKeyRightOf = delegate.getKeyRightOf) === null || _delegate_getKeyRightOf === void 0 ? void 0 : _delegate_getKeyRightOf.call(delegate, manager.focusedKey) : (_delegate_getFirstKey = delegate.getFirstKey) === null || _delegate_getFirstKey === void 0 ? void 0 : _delegate_getFirstKey.call(delegate);
+            if (nextKey == null && shouldFocusWrap) nextKey = direction === 'rtl' ? (_delegate_getLastKey = delegate.getLastKey) === null || _delegate_getLastKey === void 0 ? void 0 : _delegate_getLastKey.call(delegate, manager.focusedKey) : (_delegate_getFirstKey1 = delegate.getFirstKey) === null || _delegate_getFirstKey1 === void 0 ? void 0 : _delegate_getFirstKey1.call(delegate, manager.focusedKey);
+            if (nextKey != null) {
+                navigateToKey(e, nextKey, direction === 'rtl' ? 'last' : 'first');
+                return;
+            }
+        }
+        return false;
+    };
+    let end = (e)=>{
+        if (delegate.getLastKey) {
+            if (manager.focusedKey === null && e.shiftKey) return false;
+            let lastKey = delegate.getLastKey(manager.focusedKey, (0, $2224c9ee07fd529d$export$16792effe837dba3)(e));
+            manager.setFocusedKey(lastKey);
+            if (lastKey != null) {
+                if ((0, $2224c9ee07fd529d$export$16792effe837dba3)(e) && e.shiftKey && manager.selectionMode === 'multiple') {
+                    manager.extendSelection(lastKey);
+                    return;
+                } else if (selectOnFocus) {
+                    manager.replaceSelection(lastKey);
+                    return;
                 }
+            }
+        }
+        return false;
+    };
+    let pageDown = (e)=>{
+        if (delegate.getKeyPageBelow && manager.focusedKey != null) {
+            let nextKey = delegate.getKeyPageBelow(manager.focusedKey);
+            if (nextKey != null) return navigateToKey(e, nextKey);
+        }
+        return false;
+    };
+    let pageUp = (e)=>{
+        if (delegate.getKeyPageAbove && manager.focusedKey != null) {
+            let nextKey = delegate.getKeyPageAbove(manager.focusedKey);
+            if (nextKey != null) return navigateToKey(e, nextKey);
+        }
+        return false;
+    };
+    let aHandler = ()=>{
+        if (manager.selectionMode === 'multiple' && disallowSelectAll !== true) {
+            manager.selectAll();
+            return;
         }
+        return false;
     };
+    let escape = ()=>{
+        if (escapeKeyBehavior === 'clearSelection' && !disallowEmptySelection && manager.selectedKeys.size !== 0) {
+            manager.clearSelection();
+            return;
+        }
+        return false;
+    };
+    let tab = ()=>{
+        if (!allowsTabNavigation && ref.current) {
+            // 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.
+            let walker = (0, $903814aeb7d53b38$export$2d6ec8fc375ceafa)(ref.current, {
+                tabbable: true
+            });
+            let next = undefined;
+            let last;
+            do {
+                last = walker.lastChild();
+                if (last) next = last;
+            }while (last);
+            // If the active element is NOT tabbable but is contained by an element that IS tabbable (aka the cell), the browser will actually move focus to
+            // the containing element. We need to special case this so that tab will move focus out of the grid instead of looping between
+            // focusing the containing cell and back to the non-tabbable child element
+            let activeElement = (0, $d8ac7ed472840322$export$cd4e5573fbe2b576)();
+            if (next && (!(0, $d8ac7ed472840322$export$b4f377a2b6254582)(next) || activeElement && !(0, $ee5e22534121197a$export$bebd5a1431fec25d)(activeElement))) (0, $d559d872031c749f$export$de79e2c695e052f3)(next);
+        }
+        return {
+            shouldContinuePropagation: true,
+            shouldPreventDefault: false
+        };
+    };
+    let shiftTab = ()=>{
+        if (!allowsTabNavigation && ref.current) ref.current.focus();
+        return {
+            shouldContinuePropagation: true,
+            shouldPreventDefault: false
+        };
+    };
+    let withShiftSel = (key, callback)=>{
+        return {
+            [(0, $d5a2be505488529f$export$9ac100e40613ea10)() ? key + '+Shift+Alt' : key + '+Shift+Control']: callback,
+            [key + '+Shift']: callback,
+            [(0, $d5a2be505488529f$export$9ac100e40613ea10)() ? key + '+Alt' : key + '+Control']: callback,
+            [key]: callback
+        };
+    };
+    // oxlint-disable react/react-compiler
+    let { keyboardProps: repeatKeyboardProps } = (0, $bf74df7506f65576$export$8f71654801c2f7cd)({
+        shortcuts: {
+            ...withShiftSel('ArrowDown', arrowDown),
+            ...withShiftSel('ArrowUp', arrowUp),
+            ...withShiftSel('ArrowLeft', arrowLeft),
+            ...withShiftSel('ArrowRight', arrowRight),
+            ...withShiftSel('PageDown', pageDown),
+            ...withShiftSel('PageUp', pageUp)
+        },
+        allowRepeats: true
+    });
+    // oxlint-disable react/react-compiler
+    let { keyboardProps: keyboardProps } = (0, $bf74df7506f65576$export$8f71654801c2f7cd)({
+        shortcuts: {
+            ...withShiftSel('Home', home),
+            ...withShiftSel('End', end),
+            'Mod+A': aHandler,
+            Escape: escape,
+            Tab: tab,
+            'Tab+Shift': shiftTab
+        }
+    });
+    // oxlint-enable react/react-compiler
     // Store the scroll position so we can restore it later.
     /// TODO: should this happen all the time??
     let scrollPos = (0, $ld26Q$useRef)({
@@ -221,6 +277,7 @@ function $80c8b4b5cf8e1f86$export$d6daf82dcd84e87c(options) {
         };
     });
     let onFocus = (e)=>{
+        var _delegate_getFirstKey, _delegate_getLastKey;
         if (manager.isFocused) {
             // If a focus event bubbled through a portal, reset focus state.
             if (!(0, $d8ac7ed472840322$export$4282f70798064fe0)(e.currentTarget, (0, $d8ac7ed472840322$export$e58f029f0fbfdb29)(e))) manager.setFocused(false);
@@ -228,22 +285,28 @@ function $80c8b4b5cf8e1f86$export$d6daf82dcd84e87c(options) {
         }
         // Focus events can bubble through portals. Ignore these events.
         if (!(0, $d8ac7ed472840322$export$4282f70798064fe0)(e.currentTarget, (0, $d8ac7ed472840322$export$e58f029f0fbfdb29)(e))) return;
+        let modality = (0, $b50b1cc8a843ace7$export$630ff653c5ada6a9)();
         manager.setFocused(true);
-        if (manager.focusedKey == null) {
-            var _delegate_getLastKey, _delegate_getFirstKey;
-            let navigateToKey = (key)=>{
-                if (key != null) {
-                    manager.setFocusedKey(key);
-                    if (selectOnFocus && !manager.isSelected(key)) manager.replaceSelection(key);
-                }
-            };
+        let navigateToKey = (key)=>{
+            if (key != null) {
+                manager.setFocusedKey(key);
+                if (selectOnFocus && !manager.isSelected(key)) manager.replaceSelection(key);
+            }
+        };
+        // we need the "virtual" modality case checks here because shift tabbing from the prompt field's attachment card back into the
+        // thread is a virtual focus event (the tab handler in onKeyDown focuses the ref of the attachmentList aka TagGroup via a focus() call, hence the virtual modality)
+        if (UNSTABLE_focusOnEntry && (modality === 'keyboard' || modality === 'virtual')) // always go to the first item in the Thread when tabbing forwards/backwards into the collection
+        // since it is probably more important to the user to see the new prompt reply rather than go to the last focused key
+        navigateToKey(UNSTABLE_focusOnEntry === 'first' ? (_delegate_getFirstKey = delegate.getFirstKey) === null || _delegate_getFirstKey === void 0 ? void 0 : _delegate_getFirstKey.call(delegate) : (_delegate_getLastKey = delegate.getLastKey) === null || _delegate_getLastKey === void 0 ? void 0 : _delegate_getLastKey.call(delegate));
+        else if (manager.focusedKey == null) {
+            var _delegate_getLastKey1, _delegate_getFirstKey1;
             // 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) navigateToKey((_manager_lastSelectedKey = manager.lastSelectedKey) !== null && _manager_lastSelectedKey !== void 0 ? _manager_lastSelectedKey : (_delegate_getLastKey = delegate.getLastKey) === null || _delegate_getLastKey === void 0 ? void 0 : _delegate_getLastKey.call(delegate));
-            else navigateToKey((_manager_firstSelectedKey = manager.firstSelectedKey) !== null && _manager_firstSelectedKey !== void 0 ? _manager_firstSelectedKey : (_delegate_getFirstKey = delegate.getFirstKey) === null || _delegate_getFirstKey === void 0 ? void 0 : _delegate_getFirstKey.call(delegate));
+            if (relatedTarget && e.currentTarget.compareDocumentPosition(relatedTarget) & Node.DOCUMENT_POSITION_FOLLOWING) navigateToKey((_manager_lastSelectedKey = manager.lastSelectedKey) !== null && _manager_lastSelectedKey !== void 0 ? _manager_lastSelectedKey : (_delegate_getLastKey1 = delegate.getLastKey) === null || _delegate_getLastKey1 === void 0 ? void 0 : _delegate_getLastKey1.call(delegate));
+            else navigateToKey((_manager_firstSelectedKey = manager.firstSelectedKey) !== null && _manager_firstSelectedKey !== void 0 ? _manager_firstSelectedKey : (_delegate_getFirstKey1 = delegate.getFirstKey) === null || _delegate_getFirstKey1 === void 0 ? void 0 : _delegate_getFirstKey1.call(delegate));
         } else if (scrollRef.current) {
             // Restore the scroll position to what it was before.
             scrollRef.current.scrollTop = scrollPos.current.top;
@@ -255,8 +318,7 @@ function $80c8b4b5cf8e1f86$export$d6daf82dcd84e87c(options) {
             if (element instanceof HTMLElement) {
                 // This prevents a flash of focus on the first/last element in the collection, or the collection itself.
                 if (!(0, $d8ac7ed472840322$export$b4f377a2b6254582)(element) && !shouldUseVirtualFocus) (0, $d559d872031c749f$export$de79e2c695e052f3)(element);
-                let modality = (0, $b50b1cc8a843ace7$export$630ff653c5ada6a9)();
-                if (modality === 'keyboard') (0, $6507765bd7f5ad94$export$c826860796309d1b)(element, {
+                if (modality === 'keyboard' || UNSTABLE_focusOnEntry && modality === 'virtual') (0, $6507765bd7f5ad94$export$c826860796309d1b)(element, {
                     containingElement: ref.current
                 });
             }
@@ -280,15 +342,14 @@ function $80c8b4b5cf8e1f86$export$d6daf82dcd84e87c(options) {
         // If the user is typing forwards, autofocus the first option in the list.
         if ((detail === null || detail === void 0 ? void 0 : detail.focusStrategy) === 'first') shouldVirtualFocusFirst.current = true;
     });
+    var _delegate_getFirstKey1;
     // update active descendant
+    let firstKey = (_delegate_getFirstKey1 = (_delegate_getFirstKey = delegate.getFirstKey) === null || _delegate_getFirstKey === void 0 ? void 0 : _delegate_getFirstKey.call(delegate)) !== null && _delegate_getFirstKey1 !== void 0 ? _delegate_getFirstKey1 : null;
     (0, $96d0d4862843d873$export$72ef708ab07251f1)(()=>{
         if (shouldVirtualFocusFirst.current) {
-            var _delegate_getFirstKey;
-            var _delegate_getFirstKey1;
-            let keyToFocus = (_delegate_getFirstKey1 = (_delegate_getFirstKey = delegate.getFirstKey) === null || _delegate_getFirstKey === void 0 ? void 0 : _delegate_getFirstKey.call(delegate)) !== null && _delegate_getFirstKey1 !== void 0 ? _delegate_getFirstKey1 : null;
             // If no focusable items exist in the list, make sure to clear any activedescendant that may still exist and move focus back to
             // the original active element (e.g. the autocomplete input)
-            if (keyToFocus == null) {
+            if (firstKey == null) {
                 let previousActiveElement = (0, $d8ac7ed472840322$export$cd4e5573fbe2b576)();
                 (0, $57a86975180d30a8$export$76e4e37e5339496d)(ref.current);
                 (0, $57a86975180d30a8$export$2b35b76d2e30e129)(previousActiveElement, null);
@@ -296,7 +357,7 @@ function $80c8b4b5cf8e1f86$export$d6daf82dcd84e87c(options) {
                 // Reset shouldVirtualFocusFirst so that we don't erronously autofocus an item when the collection is filtered again.
                 if (manager.collection.size > 0) shouldVirtualFocusFirst.current = false;
             } else {
-                manager.setFocusedKey(keyToFocus);
+                manager.setFocusedKey(firstKey);
                 // Only set shouldVirtualFocusFirst to false if we've successfully set the first key as the focused key
                 // If there wasn't a key to focus, we might be in a temporary loading state so we'll want to still focus the first key
                 // after the collection updates after load
@@ -304,7 +365,8 @@ function $80c8b4b5cf8e1f86$export$d6daf82dcd84e87c(options) {
             }
         }
     }, [
-        manager.collection
+        firstKey,
+        manager.collection.size
     ]);
     // reset focus first flag
     (0, $96d0d4862843d873$export$72ef708ab07251f1)(()=>{
@@ -390,7 +452,7 @@ function $80c8b4b5cf8e1f86$export$d6daf82dcd84e87c(options) {
         manager.setFocused(true);
     });
     let handlers = {
-        onKeyDown: onKeyDown,
+        ...(0, $64c36edd757dfa16$export$9d1611c77c2fe928)(keyboardProps, repeatKeyboardProps),
         onFocus: onFocus,
         onBlur: onBlur,
         onMouseDown (e) {
@@ -403,13 +465,15 @@ function $80c8b4b5cf8e1f86$export$d6daf82dcd84e87c(options) {
         keyboardDelegate: delegate,
         selectionManager: manager
     });
-    if (!disallowTypeAhead) handlers = (0, $64c36edd757dfa16$export$9d1611c77c2fe928)(typeSelectProps, handlers);
+    if (!disallowTypeAhead) // oxlint-disable-next-line react/react-compiler
+    handlers = (0, $64c36edd757dfa16$export$9d1611c77c2fe928)(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.
     let tabIndex = undefined;
     if (!shouldUseVirtualFocus) tabIndex = manager.focusedKey == null ? 0 : -1;
     let collectionId = (0, $8f207f199487227b$export$881eb0d9f3605d9d)(manager.collection);
     return {
+        // oxlint-disable-next-line react/react-compiler
         collectionProps: (0, $64c36edd757dfa16$export$9d1611c77c2fe928)(handlers, {
             tabIndex: tabIndex,
             'data-collection': collectionId