@wix/site-ui 1.30.0 → 1.31.0

package/dist/5085.js

@@ -0,0 +1,20 @@
+import { NOOP } from "./8272.js";
+import * as __rspack_external_react from "react";
+const FormContext = /*#__PURE__*/ __rspack_external_react.createContext({
+    formRef: {
+        current: {
+            fields: new Map()
+        }
+    },
+    errors: {},
+    clearErrors: NOOP,
+    validationMode: 'onSubmit',
+    submitAttemptedRef: {
+        current: false
+    }
+});
+if ("production" !== process.env.NODE_ENV) FormContext.displayName = "FormContext";
+function useFormContext() {
+    return __rspack_external_react.useContext(FormContext);
+}
+export { FormContext, useFormContext };

package/dist/5299.js

@@ -0,0 +1,597 @@
+import { useTimeout } from "./42.js";
+import { useStableCallback } from "./7541.js";
+import { isListIndexDisabled, getGridCellIndices, findNonDisabledListIndex, getGridNavigatedIndex, createGridCellMap, getMinListIndex, isElementVisible, getGridCellIndexOfCorner, getMaxListIndex, isIndexOutOfListBounds } from "./3319.js";
+import { stopEvent, isVirtualPointerEvent, isVirtualClick } from "./6330.js";
+import { getTarget, contains, activeElement } from "./4549.js";
+import { useIsoLayoutEffect } from "./6499.js";
+import { ARROW_LEFT, ARROW_UP, ARROW_DOWN, ARROW_RIGHT } from "./4745.js";
+import { getFloatingFocusElement, isTypeableCombobox } from "./8758.js";
+import { useValueAsRef } from "./4707.js";
+import { useFloatingParentNodeId, useFloatingTree } from "./285.js";
+import { useAnimationFrame } from "./8996.js";
+import { enqueueFocus } from "./3485.js";
+import { ownerDocument } from "./9829.js";
+import { createChangeEventDetails } from "./4768.js";
+import { listNavigation, focusOut } from "./2418.js";
+import { isHTMLElement } from "./3829.js";
+import * as __rspack_external_react from "react";
+function useTypeahead(context, props) {
+    const { listRef, elementsRef, activeIndex, onMatch: onMatchProp, onTyping, enabled = true, resetMs = 750, selectedIndex = null } = props;
+    const store = 'rootStore' in context ? context.rootStore : context;
+    const open = store.useState('open');
+    const timeout = useTimeout();
+    const stringRef = __rspack_external_react.useRef('');
+    const prevIndexRef = __rspack_external_react.useRef(selectedIndex ?? activeIndex ?? -1);
+    const matchIndexRef = __rspack_external_react.useRef(null);
+    const onKeyDown = useStableCallback((event)=>{
+        function isVisible(index) {
+            const element = elementsRef?.current[index];
+            return !element || isElementVisible(element);
+        }
+        function getMatchingIndex(list, string, startIndex = 0) {
+            if (0 === list.length) return -1;
+            const normalizedStartIndex = (startIndex % list.length + list.length) % list.length;
+            const lowerString = string.toLocaleLowerCase();
+            for(let offset = 0; offset < list.length; offset += 1){
+                const index = (normalizedStartIndex + offset) % list.length;
+                const text = list[index];
+                if (text?.toLocaleLowerCase().startsWith(lowerString) && isVisible(index)) return index;
+            }
+            return -1;
+        }
+        const listContent = listRef.current;
+        if (stringRef.current.length > 0 && ' ' === event.key) {
+            stopEvent(event);
+            onTyping?.(true);
+        }
+        if (stringRef.current.length > 0 && ' ' !== stringRef.current[0]) {
+            if (-1 === getMatchingIndex(listContent, stringRef.current) && ' ' !== event.key) onTyping?.(false);
+        }
+        if (null == listContent || 1 !== event.key.length || event.ctrlKey || event.metaKey || event.altKey) return;
+        if (open && ' ' !== event.key) {
+            stopEvent(event);
+            onTyping?.(true);
+        }
+        const isNewSession = '' === stringRef.current;
+        if (isNewSession) prevIndexRef.current = selectedIndex ?? activeIndex ?? -1;
+        const allowRapidSuccessionOfFirstLetter = listContent.every((text)=>text ? text[0]?.toLocaleLowerCase() !== text[1]?.toLocaleLowerCase() : true);
+        if (allowRapidSuccessionOfFirstLetter && stringRef.current === event.key) {
+            stringRef.current = '';
+            prevIndexRef.current = matchIndexRef.current;
+        }
+        stringRef.current += event.key;
+        timeout.start(resetMs, ()=>{
+            stringRef.current = '';
+            prevIndexRef.current = matchIndexRef.current;
+            onTyping?.(false);
+        });
+        const prevIndex = isNewSession ? selectedIndex ?? activeIndex ?? -1 : prevIndexRef.current;
+        const startIndex = (prevIndex ?? 0) + 1;
+        const index = getMatchingIndex(listContent, stringRef.current, startIndex);
+        if (-1 !== index) {
+            onMatchProp?.(index);
+            matchIndexRef.current = index;
+        } else if (' ' !== event.key) {
+            stringRef.current = '';
+            onTyping?.(false);
+        }
+    });
+    const onBlur = useStableCallback((event)=>{
+        const next = event.relatedTarget;
+        const currentDomReferenceElement = store.select('domReferenceElement');
+        const currentFloatingElement = store.select('floatingElement');
+        const withinComposite = contains(currentDomReferenceElement, next) || contains(currentFloatingElement, next);
+        if (withinComposite) return;
+        timeout.clear();
+        stringRef.current = '';
+        prevIndexRef.current = matchIndexRef.current;
+        onTyping?.(false);
+    });
+    useIsoLayoutEffect(()=>{
+        if (!open && null !== selectedIndex) return;
+        timeout.clear();
+        matchIndexRef.current = null;
+        if ('' !== stringRef.current) stringRef.current = '';
+    }, [
+        open,
+        selectedIndex,
+        timeout
+    ]);
+    useIsoLayoutEffect(()=>{
+        if (open && '' === stringRef.current) prevIndexRef.current = selectedIndex ?? activeIndex ?? -1;
+    }, [
+        open,
+        selectedIndex,
+        activeIndex
+    ]);
+    const sharedProps = __rspack_external_react.useMemo(()=>({
+            onKeyDown,
+            onBlur
+        }), [
+        onKeyDown,
+        onBlur
+    ]);
+    return __rspack_external_react.useMemo(()=>enabled ? {
+            reference: sharedProps,
+            floating: sharedProps
+        } : {}, [
+        enabled,
+        sharedProps
+    ]);
+}
+const ESCAPE = 'Escape';
+function doSwitch(orientation, vertical, horizontal) {
+    switch(orientation){
+        case 'vertical':
+            return vertical;
+        case 'horizontal':
+            return horizontal;
+        default:
+            return vertical || horizontal;
+    }
+}
+function isMainOrientationKey(key, orientation) {
+    const vertical = key === ARROW_UP || key === ARROW_DOWN;
+    const horizontal = key === ARROW_LEFT || key === ARROW_RIGHT;
+    return doSwitch(orientation, vertical, horizontal);
+}
+function isMainOrientationToEndKey(key, orientation, rtl) {
+    const vertical = key === ARROW_DOWN;
+    const horizontal = rtl ? key === ARROW_LEFT : key === ARROW_RIGHT;
+    return doSwitch(orientation, vertical, horizontal) || 'Enter' === key || ' ' === key || '' === key;
+}
+function isCrossOrientationOpenKey(key, orientation, rtl) {
+    const vertical = rtl ? key === ARROW_LEFT : key === ARROW_RIGHT;
+    const horizontal = key === ARROW_DOWN;
+    return doSwitch(orientation, vertical, horizontal);
+}
+function isCrossOrientationCloseKey(key, orientation, rtl, cols) {
+    const vertical = rtl ? key === ARROW_RIGHT : key === ARROW_LEFT;
+    const horizontal = key === ARROW_UP;
+    if ('both' === orientation || 'horizontal' === orientation && cols && cols > 1) return key === ESCAPE;
+    return doSwitch(orientation, vertical, horizontal);
+}
+function useListNavigation(context, props) {
+    const { listRef, activeIndex, onNavigate: onNavigateProp = ()=>{}, enabled = true, selectedIndex = null, allowEscape = false, loopFocus = false, nested = false, rtl = false, virtual = false, focusItemOnOpen = 'auto', focusItemOnHover = true, openOnArrowKeyDown = true, disabledIndices, orientation = 'vertical', parentOrientation, cols = 1, id, resetOnPointerLeave = true, externalTree } = props;
+    if ('production' !== process.env.NODE_ENV) {
+        if (allowEscape) {
+            if (!loopFocus) console.warn('`useListNavigation` looping must be enabled to allow escaping.');
+            if (!virtual) console.warn('`useListNavigation` must be virtual to allow escaping.');
+        }
+        if ('vertical' === orientation && cols > 1) console.warn('In grid list navigation mode (`cols` > 1), the `orientation` should', 'be either "horizontal" or "both".');
+    }
+    const store = 'rootStore' in context ? context.rootStore : context;
+    const open = store.useState('open');
+    const floatingElement = store.useState('floatingElement');
+    const domReferenceElement = store.useState('domReferenceElement');
+    const dataRef = store.context.dataRef;
+    const floatingFocusElement = getFloatingFocusElement(floatingElement);
+    const typeableComboboxReference = isTypeableCombobox(domReferenceElement);
+    const floatingFocusElementRef = useValueAsRef(floatingFocusElement);
+    const parentId = useFloatingParentNodeId();
+    const tree = useFloatingTree(externalTree);
+    const focusItemOnOpenRef = __rspack_external_react.useRef(focusItemOnOpen);
+    const indexRef = __rspack_external_react.useRef(selectedIndex ?? -1);
+    const keyRef = __rspack_external_react.useRef(null);
+    const isPointerModalityRef = __rspack_external_react.useRef(true);
+    const onNavigate = useStableCallback((event)=>{
+        onNavigateProp(-1 === indexRef.current ? null : indexRef.current, event);
+    });
+    const previousOnNavigateRef = __rspack_external_react.useRef(onNavigate);
+    const previousMountedRef = __rspack_external_react.useRef(!!floatingElement);
+    const previousOpenRef = __rspack_external_react.useRef(open);
+    const forceSyncFocusRef = __rspack_external_react.useRef(false);
+    const forceScrollIntoViewRef = __rspack_external_react.useRef(false);
+    const cancelQueuedFocusRef = __rspack_external_react.useRef(null);
+    const disabledIndicesRef = useValueAsRef(disabledIndices);
+    const latestOpenRef = useValueAsRef(open);
+    const selectedIndexRef = useValueAsRef(selectedIndex);
+    const resetOnPointerLeaveRef = useValueAsRef(resetOnPointerLeave);
+    const focusFrame = useAnimationFrame();
+    const waitForListPopulatedFrame = useAnimationFrame();
+    const focusItem = useStableCallback(()=>{
+        function runFocus(item) {
+            if (virtual) tree?.events.emit('virtualfocus', item);
+            else cancelQueuedFocusRef.current = enqueueFocus(item, {
+                sync: forceSyncFocusRef.current,
+                preventScroll: true
+            });
+        }
+        const initialItem = listRef.current[indexRef.current];
+        const forceScrollIntoView = forceScrollIntoViewRef.current;
+        if (initialItem) runFocus(initialItem);
+        const scheduler = forceSyncFocusRef.current ? (callback)=>callback() : (callback)=>focusFrame.request(callback);
+        scheduler(()=>{
+            const waitedItem = listRef.current[indexRef.current] || initialItem;
+            if (!waitedItem) return;
+            if (!initialItem) runFocus(waitedItem);
+            const shouldScrollIntoView = item && (forceScrollIntoView || !isPointerModalityRef.current);
+            if (shouldScrollIntoView) waitedItem.scrollIntoView?.({
+                block: 'nearest',
+                inline: 'nearest'
+            });
+        });
+    });
+    useIsoLayoutEffect(()=>{
+        dataRef.current.orientation = orientation;
+    }, [
+        dataRef,
+        orientation
+    ]);
+    useIsoLayoutEffect(()=>{
+        if (!enabled) return;
+        if (open && floatingElement) {
+            indexRef.current = selectedIndex ?? -1;
+            if (focusItemOnOpenRef.current && null != selectedIndex) {
+                forceScrollIntoViewRef.current = true;
+                onNavigate();
+            }
+        } else if (previousMountedRef.current) {
+            indexRef.current = -1;
+            previousOnNavigateRef.current();
+        }
+    }, [
+        enabled,
+        open,
+        floatingElement,
+        selectedIndex,
+        onNavigate
+    ]);
+    useIsoLayoutEffect(()=>{
+        if (!enabled) return;
+        if (!open) {
+            forceSyncFocusRef.current = false;
+            return;
+        }
+        if (!floatingElement) return;
+        if (null == activeIndex) {
+            forceSyncFocusRef.current = false;
+            if (null != selectedIndexRef.current) return;
+            if (previousMountedRef.current) {
+                indexRef.current = -1;
+                focusItem();
+            }
+            if ((!previousOpenRef.current || !previousMountedRef.current) && focusItemOnOpenRef.current && (null != keyRef.current || true === focusItemOnOpenRef.current && null == keyRef.current)) {
+                let runs = 0;
+                const waitForListPopulated = ()=>{
+                    if (null == listRef.current[0]) {
+                        if (runs < 2) {
+                            const scheduler = runs ? (callback)=>waitForListPopulatedFrame.request(callback) : queueMicrotask;
+                            scheduler(waitForListPopulated);
+                        }
+                        runs += 1;
+                    } else {
+                        indexRef.current = null == keyRef.current || isMainOrientationToEndKey(keyRef.current, orientation, rtl) || nested ? getMinListIndex(listRef) : getMaxListIndex(listRef);
+                        keyRef.current = null;
+                        onNavigate();
+                    }
+                };
+                waitForListPopulated();
+            }
+        } else if (!isIndexOutOfListBounds(listRef.current, activeIndex)) {
+            indexRef.current = activeIndex;
+            focusItem();
+            forceScrollIntoViewRef.current = false;
+        }
+    }, [
+        enabled,
+        open,
+        floatingElement,
+        activeIndex,
+        selectedIndexRef,
+        nested,
+        listRef,
+        orientation,
+        rtl,
+        onNavigate,
+        focusItem,
+        waitForListPopulatedFrame
+    ]);
+    useIsoLayoutEffect(()=>{
+        if (!enabled || floatingElement || !tree || virtual || !previousMountedRef.current) return;
+        const nodes = tree.nodesRef.current;
+        const parent = nodes.find((node)=>node.id === parentId)?.context?.elements.floating;
+        const activeEl = activeElement(ownerDocument(floatingElement));
+        const treeContainsActiveEl = nodes.some((node)=>node.context && contains(node.context.elements.floating, activeEl));
+        if (parent && !treeContainsActiveEl && isPointerModalityRef.current) parent.focus({
+            preventScroll: true
+        });
+    }, [
+        enabled,
+        floatingElement,
+        tree,
+        parentId,
+        virtual
+    ]);
+    useIsoLayoutEffect(()=>{
+        previousOnNavigateRef.current = onNavigate;
+        previousOpenRef.current = open;
+        previousMountedRef.current = !!floatingElement;
+    });
+    useIsoLayoutEffect(()=>{
+        if (!open) {
+            keyRef.current = null;
+            focusItemOnOpenRef.current = focusItemOnOpen;
+        }
+    }, [
+        open,
+        focusItemOnOpen
+    ]);
+    const hasActiveIndex = null != activeIndex;
+    const syncCurrentTarget = useStableCallback((event)=>{
+        if (!latestOpenRef.current) return;
+        const index = listRef.current.indexOf(event.currentTarget);
+        if (-1 !== index && (indexRef.current !== index || activeIndex !== index)) {
+            indexRef.current = index;
+            onNavigate(event);
+        }
+    });
+    const getParentOrientation = useStableCallback(()=>parentOrientation ?? tree?.nodesRef.current.find((node)=>node.id === parentId)?.context?.dataRef?.current.orientation);
+    const getMinEnabledIndex = useStableCallback(()=>getMinListIndex(listRef, disabledIndicesRef.current));
+    const commonOnKeyDown = useStableCallback((event)=>{
+        isPointerModalityRef.current = false;
+        forceSyncFocusRef.current = true;
+        if (229 === event.which) return;
+        if (!latestOpenRef.current && event.currentTarget === floatingFocusElementRef.current) return;
+        if (nested && isCrossOrientationCloseKey(event.key, orientation, rtl, cols)) {
+            if (!isMainOrientationKey(event.key, getParentOrientation())) stopEvent(event);
+            store.setOpen(false, createChangeEventDetails(listNavigation, event.nativeEvent));
+            if (isHTMLElement(domReferenceElement)) if (virtual) tree?.events.emit('virtualfocus', domReferenceElement);
+            else domReferenceElement.focus();
+            return;
+        }
+        const currentIndex = indexRef.current;
+        const minIndex = getMinListIndex(listRef, disabledIndices);
+        const maxIndex = getMaxListIndex(listRef, disabledIndices);
+        if (!typeableComboboxReference) {
+            if ('Home' === event.key) {
+                stopEvent(event);
+                indexRef.current = minIndex;
+                onNavigate(event);
+            }
+            if ('End' === event.key) {
+                stopEvent(event);
+                indexRef.current = maxIndex;
+                onNavigate(event);
+            }
+        }
+        if (cols > 1) {
+            const sizes = Array.from({
+                length: listRef.current.length
+            }, ()=>({
+                    width: 1,
+                    height: 1
+                }));
+            const cellMap = createGridCellMap(sizes, cols, false);
+            const minGridIndex = cellMap.findIndex((index)=>null != index && !isListIndexDisabled(listRef.current, index, disabledIndices));
+            const maxGridIndex = cellMap.reduce((foundIndex, index, cellIndex)=>null == index || isListIndexDisabled(listRef.current, index, disabledIndices) ? foundIndex : cellIndex, -1);
+            const index = cellMap[getGridNavigatedIndex(cellMap.map((itemIndex)=>null != itemIndex ? listRef.current[itemIndex] : null), {
+                event,
+                orientation,
+                loopFocus,
+                rtl,
+                cols,
+                disabledIndices: getGridCellIndices([
+                    ...('function' != typeof disabledIndices ? disabledIndices : null) || listRef.current.map((_, listIndex)=>isListIndexDisabled(listRef.current, listIndex, disabledIndices) ? listIndex : void 0),
+                    void 0
+                ], cellMap),
+                minIndex: minGridIndex,
+                maxIndex: maxGridIndex,
+                prevIndex: getGridCellIndexOfCorner(indexRef.current > maxIndex ? minIndex : indexRef.current, sizes, cellMap, cols, event.key === ARROW_DOWN ? 'bl' : event.key === (rtl ? ARROW_LEFT : ARROW_RIGHT) ? 'tr' : 'tl'),
+                stopEvent: true
+            })];
+            if (null != index) {
+                indexRef.current = index;
+                onNavigate(event);
+            }
+            if ('both' === orientation) return;
+        }
+        if (isMainOrientationKey(event.key, orientation)) {
+            stopEvent(event);
+            if (open && !virtual && activeElement(event.currentTarget.ownerDocument) === event.currentTarget) {
+                indexRef.current = isMainOrientationToEndKey(event.key, orientation, rtl) ? minIndex : maxIndex;
+                onNavigate(event);
+                return;
+            }
+            if (isMainOrientationToEndKey(event.key, orientation, rtl)) if (loopFocus) if (currentIndex >= maxIndex) if (allowEscape && currentIndex !== listRef.current.length) indexRef.current = -1;
+            else {
+                forceSyncFocusRef.current = false;
+                indexRef.current = minIndex;
+            }
+            else indexRef.current = findNonDisabledListIndex(listRef.current, {
+                startingIndex: currentIndex,
+                disabledIndices
+            });
+            else indexRef.current = Math.min(maxIndex, findNonDisabledListIndex(listRef.current, {
+                startingIndex: currentIndex,
+                disabledIndices
+            }));
+            else if (loopFocus) if (currentIndex <= minIndex) if (allowEscape && -1 !== currentIndex) indexRef.current = listRef.current.length;
+            else {
+                forceSyncFocusRef.current = false;
+                indexRef.current = maxIndex;
+            }
+            else indexRef.current = findNonDisabledListIndex(listRef.current, {
+                startingIndex: currentIndex,
+                decrement: true,
+                disabledIndices
+            });
+            else indexRef.current = Math.max(minIndex, findNonDisabledListIndex(listRef.current, {
+                startingIndex: currentIndex,
+                decrement: true,
+                disabledIndices
+            }));
+            if (isIndexOutOfListBounds(listRef.current, indexRef.current)) indexRef.current = -1;
+            onNavigate(event);
+        }
+    });
+    const item = __rspack_external_react.useMemo(()=>{
+        const itemProps = {
+            onFocus (event) {
+                forceSyncFocusRef.current = true;
+                syncCurrentTarget(event);
+            },
+            onClick: ({ currentTarget })=>currentTarget.focus({
+                    preventScroll: true
+                }),
+            onMouseMove (event) {
+                forceSyncFocusRef.current = true;
+                forceScrollIntoViewRef.current = false;
+                if (focusItemOnHover) syncCurrentTarget(event);
+            },
+            onPointerLeave (event) {
+                if (!latestOpenRef.current || !isPointerModalityRef.current || 'touch' === event.pointerType) return;
+                forceSyncFocusRef.current = true;
+                const relatedTarget = event.relatedTarget;
+                if (!focusItemOnHover || listRef.current.includes(relatedTarget)) return;
+                if (!resetOnPointerLeaveRef.current) return;
+                cancelQueuedFocusRef.current?.();
+                cancelQueuedFocusRef.current = null;
+                indexRef.current = -1;
+                onNavigate(event);
+                if (!virtual) {
+                    const floatingFocusEl = floatingFocusElementRef.current;
+                    const activeEl = activeElement(ownerDocument(floatingFocusEl));
+                    if (floatingFocusEl && contains(floatingFocusEl, activeEl)) floatingFocusEl.focus({
+                        preventScroll: true
+                    });
+                }
+            }
+        };
+        return itemProps;
+    }, [
+        syncCurrentTarget,
+        latestOpenRef,
+        floatingFocusElementRef,
+        focusItemOnHover,
+        listRef,
+        onNavigate,
+        resetOnPointerLeaveRef,
+        virtual
+    ]);
+    const ariaActiveDescendantProp = __rspack_external_react.useMemo(()=>virtual && open && hasActiveIndex && {
+            'aria-activedescendant': `${id}-${activeIndex}`
+        }, [
+        virtual,
+        open,
+        hasActiveIndex,
+        id,
+        activeIndex
+    ]);
+    const floating = __rspack_external_react.useMemo(()=>({
+            'aria-orientation': 'both' === orientation ? void 0 : orientation,
+            ...!typeableComboboxReference ? ariaActiveDescendantProp : {},
+            onKeyDown (event) {
+                if ('Tab' === event.key && event.shiftKey && open && !virtual) {
+                    const target = getTarget(event.nativeEvent);
+                    if (target && !contains(floatingFocusElementRef.current, target)) return;
+                    stopEvent(event);
+                    store.setOpen(false, createChangeEventDetails(focusOut, event.nativeEvent));
+                    if (isHTMLElement(domReferenceElement)) domReferenceElement.focus();
+                    return;
+                }
+                commonOnKeyDown(event);
+            },
+            onPointerMove () {
+                isPointerModalityRef.current = true;
+            }
+        }), [
+        ariaActiveDescendantProp,
+        commonOnKeyDown,
+        floatingFocusElementRef,
+        orientation,
+        typeableComboboxReference,
+        store,
+        open,
+        virtual,
+        domReferenceElement
+    ]);
+    const trigger = __rspack_external_react.useMemo(()=>{
+        function openOnNavigationKeyDown(event) {
+            store.setOpen(true, createChangeEventDetails(listNavigation, event.nativeEvent, event.currentTarget));
+        }
+        function checkVirtualMouse(event) {
+            if ('auto' === focusItemOnOpen && isVirtualClick(event.nativeEvent)) focusItemOnOpenRef.current = !virtual;
+        }
+        function checkVirtualPointer(event) {
+            focusItemOnOpenRef.current = focusItemOnOpen;
+            if ('auto' === focusItemOnOpen && isVirtualPointerEvent(event.nativeEvent)) focusItemOnOpenRef.current = true;
+        }
+        return {
+            onKeyDown (event) {
+                const currentOpen = store.select('open');
+                isPointerModalityRef.current = false;
+                const isArrowKey = event.key.startsWith('Arrow');
+                const isParentCrossOpenKey = isCrossOrientationOpenKey(event.key, getParentOrientation(), rtl);
+                const isMainKey = isMainOrientationKey(event.key, orientation);
+                const isNavigationKey = (nested ? isParentCrossOpenKey : isMainKey) || 'Enter' === event.key || '' === event.key.trim();
+                if (virtual && currentOpen) return commonOnKeyDown(event);
+                if (!currentOpen && !openOnArrowKeyDown && isArrowKey) return;
+                if (isNavigationKey) {
+                    const isParentMainKey = isMainOrientationKey(event.key, getParentOrientation());
+                    keyRef.current = nested && isParentMainKey ? null : event.key;
+                }
+                if (nested) {
+                    if (isParentCrossOpenKey) {
+                        stopEvent(event);
+                        if (currentOpen) {
+                            indexRef.current = getMinEnabledIndex();
+                            onNavigate(event);
+                        } else openOnNavigationKeyDown(event);
+                    }
+                    return;
+                }
+                if (isMainKey) {
+                    if (null != selectedIndexRef.current) indexRef.current = selectedIndexRef.current;
+                    stopEvent(event);
+                    if (!currentOpen && openOnArrowKeyDown) openOnNavigationKeyDown(event);
+                    else commonOnKeyDown(event);
+                    if (currentOpen) onNavigate(event);
+                }
+            },
+            onFocus (event) {
+                if (store.select('open') && !virtual) {
+                    indexRef.current = -1;
+                    onNavigate(event);
+                }
+            },
+            onPointerDown: checkVirtualPointer,
+            onPointerEnter: checkVirtualPointer,
+            onMouseDown: checkVirtualMouse,
+            onClick: checkVirtualMouse
+        };
+    }, [
+        commonOnKeyDown,
+        focusItemOnOpen,
+        getMinEnabledIndex,
+        nested,
+        onNavigate,
+        store,
+        openOnArrowKeyDown,
+        orientation,
+        getParentOrientation,
+        rtl,
+        selectedIndexRef,
+        virtual
+    ]);
+    const reference = __rspack_external_react.useMemo(()=>({
+            ...ariaActiveDescendantProp,
+            ...trigger
+        }), [
+        ariaActiveDescendantProp,
+        trigger
+    ]);
+    return __rspack_external_react.useMemo(()=>enabled ? {
+            reference,
+            floating,
+            item,
+            trigger
+        } : {}, [
+        enabled,
+        reference,
+        floating,
+        trigger,
+        item
+    ]);
+}
+export { useListNavigation, useTypeahead };

package/dist/5659.js

@@ -0,0 +1,4 @@
+function areArraysEqual(array1, array2, itemComparer = (a, b)=>a === b) {
+    return array1.length === array2.length && array1.every((value, index)=>itemComparer(value, array2[index]));
+}
+export { areArraysEqual };

package/dist/5778.js

@@ -0,0 +1,10 @@
+function serializeValue(value) {
+    if (null == value) return '';
+    if ('string' == typeof value) return value;
+    try {
+        return JSON.stringify(value);
+    } catch  {
+        return String(value);
+    }
+}
+export { serializeValue };