@octanejs/base-ui 0.1.30 → 0.1.32

package/dist/cjs/utils/floating/useListNavigation.cjs

@@ -0,0 +1,665 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var useListNavigation_exports = {};
+__export(useListNavigation_exports, {
+  ESCAPE: () => ESCAPE,
+  useListNavigation: () => useListNavigation
+});
+module.exports = __toCommonJS(useListNavigation_exports);
+var import_octane = require("octane");
+var import_internal = require("../../internal.cjs");
+var import_dom = require("../dom.cjs");
+var import_owner = require("../owner.cjs");
+var import_useAnimationFrame = require("../useAnimationFrame.cjs");
+var import_useStableCallback = require("../useStableCallback.cjs");
+var import_useValueAsRef = require("../useValueAsRef.cjs");
+var import_createChangeEventDetails = require("../createChangeEventDetails.cjs");
+var import_keys = require("../composite/keys.cjs");
+var import_list_utils = require("../composite/list-utils.cjs");
+var import_FloatingTree = require("./FloatingTree.cjs");
+var import_element = require("./element.cjs");
+var import_enqueueFocus = require("./enqueueFocus.cjs");
+var import_event = require("./event.cjs");
+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 === import_keys.ARROW_UP || key === import_keys.ARROW_DOWN;
+  const horizontal = key === import_keys.ARROW_LEFT || key === import_keys.ARROW_RIGHT;
+  return doSwitch(orientation, vertical, horizontal);
+}
+function isMainOrientationToEndKey(key, orientation, rtl) {
+  const vertical = key === import_keys.ARROW_DOWN;
+  const horizontal = rtl ? key === import_keys.ARROW_LEFT : key === import_keys.ARROW_RIGHT;
+  return doSwitch(orientation, vertical, horizontal) || key === "Enter" || key === " " || key === "";
+}
+function isCrossOrientationOpenKey(key, orientation, rtl) {
+  const vertical = rtl ? key === import_keys.ARROW_LEFT : key === import_keys.ARROW_RIGHT;
+  const horizontal = key === import_keys.ARROW_DOWN;
+  return doSwitch(orientation, vertical, horizontal);
+}
+function isCrossOrientationCloseKey(key, orientation, rtl, grid) {
+  const vertical = rtl ? key === import_keys.ARROW_RIGHT : key === import_keys.ARROW_LEFT;
+  const horizontal = key === import_keys.ARROW_UP;
+  if (orientation === "both" || orientation === "horizontal" && grid) {
+    return key === ESCAPE;
+  }
+  return doSwitch(orientation, vertical, horizontal);
+}
+function useListNavigation(context, props, slot) {
+  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 = void 0,
+    orientation = "vertical",
+    parentOrientation,
+    id,
+    resetOnPointerLeave = true,
+    externalTree,
+    grid: navigateGrid
+  } = props;
+  const isGrid = navigateGrid != null;
+  const store = context && "rootStore" in context ? context.rootStore : context;
+  const open = store.useState("open", (0, import_internal.subSlot)(slot, "open"));
+  const floatingElement = store.useState("floatingElement", (0, import_internal.subSlot)(slot, "fel"));
+  const domReferenceElement = store.useState("domReferenceElement", (0, import_internal.subSlot)(slot, "drel"));
+  const dataRef = store.context.dataRef;
+  const floatingFocusElement = (0, import_element.getFloatingFocusElement)(floatingElement);
+  const typeableComboboxReference = (0, import_element.isTypeableCombobox)(domReferenceElement);
+  const floatingFocusElementRef = (0, import_useValueAsRef.useValueAsRef)(
+    floatingFocusElement,
+    (0, import_internal.subSlot)(slot, "ffe")
+  );
+  const parentId = (0, import_FloatingTree.useFloatingParentNodeId)();
+  const tree = (0, import_FloatingTree.useFloatingTree)(externalTree);
+  const focusItemOnOpenRef = (0, import_octane.useRef)(focusItemOnOpen, (0, import_internal.subSlot)(slot, "fioo"));
+  const indexRef = (0, import_octane.useRef)(selectedIndex ?? -1, (0, import_internal.subSlot)(slot, "index"));
+  const keyRef = (0, import_octane.useRef)(null, (0, import_internal.subSlot)(slot, "key"));
+  const isPointerModalityRef = (0, import_octane.useRef)(true, (0, import_internal.subSlot)(slot, "ipm"));
+  const onNavigate = (0, import_useStableCallback.useStableCallback)(
+    (event) => {
+      onNavigateProp?.(indexRef.current === -1 ? null : indexRef.current, event);
+    },
+    (0, import_internal.subSlot)(slot, "on")
+  );
+  const previousMountedRef = (0, import_octane.useRef)(!!floatingElement, (0, import_internal.subSlot)(slot, "pm"));
+  const previousOpenRef = (0, import_octane.useRef)(open, (0, import_internal.subSlot)(slot, "po"));
+  const forceSyncFocusRef = (0, import_octane.useRef)(false, (0, import_internal.subSlot)(slot, "fsf"));
+  const forceScrollIntoViewRef = (0, import_octane.useRef)(false, (0, import_internal.subSlot)(slot, "fsiv"));
+  const cancelQueuedFocusRef = (0, import_octane.useRef)(null, (0, import_internal.subSlot)(slot, "cqf"));
+  const disabledIndicesRef = (0, import_useValueAsRef.useValueAsRef)(
+    disabledIndices,
+    (0, import_internal.subSlot)(slot, "dir")
+  );
+  const latestOpenRef = (0, import_useValueAsRef.useValueAsRef)(open, (0, import_internal.subSlot)(slot, "lo"));
+  const selectedIndexRef = (0, import_useValueAsRef.useValueAsRef)(selectedIndex, (0, import_internal.subSlot)(slot, "si"));
+  const resetOnPointerLeaveRef = (0, import_useValueAsRef.useValueAsRef)(resetOnPointerLeave, (0, import_internal.subSlot)(slot, "ropl"));
+  const focusFrame = (0, import_useAnimationFrame.useAnimationFrame)((0, import_internal.subSlot)(slot, "ff"));
+  const waitForListPopulatedFrame = (0, import_useAnimationFrame.useAnimationFrame)((0, import_internal.subSlot)(slot, "wflp"));
+  const focusItem = (0, import_useStableCallback.useStableCallback)(
+    () => {
+      function runFocus(itemElement) {
+        if (virtual) {
+          tree?.events.emit("virtualfocus", itemElement);
+        } else {
+          cancelQueuedFocusRef.current = (0, import_enqueueFocus.enqueueFocus)(itemElement, {
+            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 = (
+          // eslint-disable-next-line @typescript-eslint/no-use-before-define
+          item && (forceScrollIntoView || !isPointerModalityRef.current)
+        );
+        if (shouldScrollIntoView) {
+          waitedItem.scrollIntoView?.({ block: "nearest", inline: "nearest" });
+        }
+      });
+    },
+    (0, import_internal.subSlot)(slot, "fi")
+  );
+  (0, import_octane.useLayoutEffect)(
+    () => {
+      dataRef.current.orientation = orientation;
+    },
+    [dataRef, orientation],
+    (0, import_internal.subSlot)(slot, "e:orientation")
+  );
+  (0, import_octane.useLayoutEffect)(
+    () => {
+      if (!enabled) {
+        return;
+      }
+      if (open && floatingElement) {
+        indexRef.current = selectedIndex ?? -1;
+        if (focusItemOnOpenRef.current && selectedIndex != null) {
+          forceScrollIntoViewRef.current = true;
+          onNavigate();
+        }
+      } else if (previousMountedRef.current) {
+        indexRef.current = -1;
+        onNavigate();
+      }
+    },
+    [enabled, open, floatingElement, selectedIndex, onNavigate],
+    (0, import_internal.subSlot)(slot, "e:syncSelected")
+  );
+  (0, import_octane.useLayoutEffect)(
+    () => {
+      if (!enabled) {
+        return;
+      }
+      if (!open) {
+        forceSyncFocusRef.current = false;
+        return;
+      }
+      if (!floatingElement) {
+        return;
+      }
+      if (activeIndex == null) {
+        forceSyncFocusRef.current = false;
+        if (selectedIndexRef.current != null) {
+          return;
+        }
+        if (previousMountedRef.current) {
+          indexRef.current = -1;
+          focusItem();
+        }
+        if ((!previousOpenRef.current || !previousMountedRef.current) && focusItemOnOpenRef.current && (keyRef.current != null || focusItemOnOpenRef.current === true && keyRef.current == null)) {
+          let runs = 0;
+          const waitForListPopulated = () => {
+            if (listRef.current[0] == null) {
+              if (runs < 2) {
+                const scheduler = runs ? (callback) => waitForListPopulatedFrame.request(callback) : queueMicrotask;
+                scheduler(waitForListPopulated);
+              }
+              runs += 1;
+            } else {
+              indexRef.current = keyRef.current == null || isMainOrientationToEndKey(keyRef.current, orientation, rtl) || nested ? (0, import_list_utils.getMinListIndex)(listRef) : (0, import_list_utils.getMaxListIndex)(listRef);
+              keyRef.current = null;
+              onNavigate();
+            }
+          };
+          waitForListPopulated();
+        }
+      } else if (!(0, import_list_utils.isIndexOutOfListBounds)(listRef.current, activeIndex)) {
+        indexRef.current = activeIndex;
+        focusItem();
+        forceScrollIntoViewRef.current = false;
+      }
+    },
+    [
+      enabled,
+      open,
+      floatingElement,
+      activeIndex,
+      selectedIndexRef,
+      nested,
+      listRef,
+      orientation,
+      rtl,
+      onNavigate,
+      focusItem,
+      waitForListPopulatedFrame
+    ],
+    (0, import_internal.subSlot)(slot, "e:syncActive")
+  );
+  (0, import_octane.useLayoutEffect)(
+    () => {
+      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 = (0, import_element.activeElement)((0, import_owner.ownerDocument)(domReferenceElement ?? parent ?? null));
+      const treeContainsActiveEl = nodes.some(
+        (node) => node.context && (0, import_element.contains)(node.context.elements.floating, activeEl)
+      );
+      if (parent && !treeContainsActiveEl && isPointerModalityRef.current) {
+        parent.focus({ preventScroll: true });
+      }
+    },
+    [enabled, floatingElement, domReferenceElement, tree, parentId, virtual],
+    (0, import_internal.subSlot)(slot, "e:parentFocus")
+  );
+  (0, import_octane.useLayoutEffect)(
+    () => {
+      previousOpenRef.current = open;
+      previousMountedRef.current = !!floatingElement;
+    },
+    void 0,
+    (0, import_internal.subSlot)(slot, "e:previous")
+  );
+  (0, import_octane.useLayoutEffect)(
+    () => {
+      if (!open) {
+        keyRef.current = null;
+        focusItemOnOpenRef.current = focusItemOnOpen;
+      }
+    },
+    [open, focusItemOnOpen],
+    (0, import_internal.subSlot)(slot, "e:resetKey")
+  );
+  const hasActiveIndex = activeIndex != null;
+  const syncCurrentTarget = (0, import_useStableCallback.useStableCallback)(
+    (event) => {
+      if (!latestOpenRef.current) {
+        return;
+      }
+      const index = listRef.current.indexOf(event.currentTarget);
+      if (index !== -1 && (indexRef.current !== index || activeIndex !== index)) {
+        indexRef.current = index;
+        onNavigate(event);
+      }
+    },
+    (0, import_internal.subSlot)(slot, "sct")
+  );
+  const getParentOrientation = (0, import_useStableCallback.useStableCallback)(
+    () => {
+      return parentOrientation ?? tree?.nodesRef.current.find((node) => node.id === parentId)?.context?.dataRef?.current.orientation;
+    },
+    (0, import_internal.subSlot)(slot, "gpo")
+  );
+  const getMinEnabledIndex = (0, import_useStableCallback.useStableCallback)(
+    () => {
+      return (0, import_list_utils.getMinListIndex)(listRef, disabledIndicesRef.current);
+    },
+    (0, import_internal.subSlot)(slot, "gmei")
+  );
+  const commonOnKeyDown = (0, import_useStableCallback.useStableCallback)(
+    (event) => {
+      isPointerModalityRef.current = false;
+      forceSyncFocusRef.current = true;
+      if (event.which === 229) {
+        return;
+      }
+      if (!latestOpenRef.current && event.currentTarget === floatingFocusElementRef.current) {
+        return;
+      }
+      if (nested && isCrossOrientationCloseKey(event.key, orientation, rtl, isGrid)) {
+        if (!isMainOrientationKey(event.key, getParentOrientation())) {
+          (0, import_list_utils.stopEvent)(event);
+        }
+        store.setOpen(false, (0, import_createChangeEventDetails.createChangeEventDetails)(import_createChangeEventDetails.REASONS.listNavigation, event));
+        if ((0, import_dom.isHTMLElement)(domReferenceElement)) {
+          if (virtual) {
+            tree?.events.emit("virtualfocus", domReferenceElement);
+          } else {
+            domReferenceElement.focus();
+          }
+        }
+        return;
+      }
+      const currentIndex = indexRef.current;
+      const minIndex = (0, import_list_utils.getMinListIndex)(listRef, disabledIndices);
+      const maxIndex = (0, import_list_utils.getMaxListIndex)(listRef, disabledIndices);
+      if (!typeableComboboxReference) {
+        if (event.key === "Home") {
+          (0, import_list_utils.stopEvent)(event);
+          indexRef.current = minIndex;
+          onNavigate(event);
+        }
+        if (event.key === "End") {
+          (0, import_list_utils.stopEvent)(event);
+          indexRef.current = maxIndex;
+          onNavigate(event);
+        }
+      }
+      if (navigateGrid != null) {
+        const index = navigateGrid(
+          event,
+          indexRef.current,
+          listRef,
+          orientation,
+          loopFocus,
+          rtl,
+          disabledIndices,
+          minIndex,
+          maxIndex
+        );
+        if (index != null) {
+          indexRef.current = index;
+          onNavigate(event);
+        }
+        if (orientation === "both") {
+          return;
+        }
+      }
+      if (isMainOrientationKey(event.key, orientation)) {
+        (0, import_list_utils.stopEvent)(event);
+        if (open && !virtual && (0, import_element.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 = (0, import_list_utils.findNonDisabledListIndex)(listRef.current, {
+                startingIndex: currentIndex,
+                disabledIndices
+              });
+            }
+          } else {
+            indexRef.current = Math.min(
+              maxIndex,
+              (0, import_list_utils.findNonDisabledListIndex)(listRef.current, {
+                startingIndex: currentIndex,
+                disabledIndices
+              })
+            );
+          }
+        } else if (loopFocus) {
+          if (currentIndex <= minIndex) {
+            if (allowEscape && currentIndex !== -1) {
+              indexRef.current = listRef.current.length;
+            } else {
+              forceSyncFocusRef.current = false;
+              indexRef.current = maxIndex;
+            }
+          } else {
+            indexRef.current = (0, import_list_utils.findNonDisabledListIndex)(listRef.current, {
+              startingIndex: currentIndex,
+              decrement: true,
+              disabledIndices
+            });
+          }
+        } else {
+          indexRef.current = Math.max(
+            minIndex,
+            (0, import_list_utils.findNonDisabledListIndex)(listRef.current, {
+              startingIndex: currentIndex,
+              decrement: true,
+              disabledIndices
+            })
+          );
+        }
+        if ((0, import_list_utils.isIndexOutOfListBounds)(listRef.current, indexRef.current)) {
+          indexRef.current = -1;
+        }
+        onNavigate(event);
+      }
+    },
+    (0, import_internal.subSlot)(slot, "cokd")
+  );
+  const item = (0, import_octane.useMemo)(
+    () => {
+      const itemProps = {
+        onFocus(event) {
+          forceSyncFocusRef.current = true;
+          syncCurrentTarget(event);
+        },
+        onClick: ({ currentTarget }) => currentTarget.focus({ preventScroll: true }),
+        // Safari
+        onMouseMove(event) {
+          forceSyncFocusRef.current = true;
+          forceScrollIntoViewRef.current = false;
+          if (focusItemOnHover) {
+            syncCurrentTarget(event);
+          }
+        },
+        onPointerLeave(event) {
+          if (!latestOpenRef.current || !isPointerModalityRef.current || event.pointerType === "touch") {
+            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 = (0, import_element.activeElement)((0, import_owner.ownerDocument)(floatingFocusEl));
+            if (floatingFocusEl && (0, import_element.contains)(floatingFocusEl, activeEl)) {
+              floatingFocusEl.focus({ preventScroll: true });
+            }
+          }
+        }
+      };
+      return itemProps;
+    },
+    [
+      syncCurrentTarget,
+      latestOpenRef,
+      floatingFocusElementRef,
+      focusItemOnHover,
+      listRef,
+      onNavigate,
+      resetOnPointerLeaveRef,
+      virtual
+    ],
+    (0, import_internal.subSlot)(slot, "item")
+  );
+  const ariaActiveDescendantProp = (0, import_octane.useMemo)(
+    () => {
+      return virtual && open && hasActiveIndex && {
+        "aria-activedescendant": `${id}-${activeIndex}`
+      };
+    },
+    [virtual, open, hasActiveIndex, id, activeIndex],
+    (0, import_internal.subSlot)(slot, "aad")
+  );
+  const floating = (0, import_octane.useMemo)(
+    () => {
+      return {
+        "aria-orientation": orientation === "both" ? void 0 : orientation,
+        ...!typeableComboboxReference ? ariaActiveDescendantProp : {},
+        onKeyDown(event) {
+          if (event.key === "Tab" && event.shiftKey && open && !virtual) {
+            const target = (0, import_element.getTarget)(event);
+            if (target && !(0, import_element.contains)(floatingFocusElementRef.current, target)) {
+              return;
+            }
+            (0, import_list_utils.stopEvent)(event);
+            store.setOpen(false, (0, import_createChangeEventDetails.createChangeEventDetails)(import_createChangeEventDetails.REASONS.focusOut, event));
+            if ((0, import_dom.isHTMLElement)(domReferenceElement)) {
+              domReferenceElement.focus();
+            }
+            return;
+          }
+          commonOnKeyDown(event);
+        },
+        onPointerMove() {
+          isPointerModalityRef.current = true;
+        }
+      };
+    },
+    [
+      ariaActiveDescendantProp,
+      commonOnKeyDown,
+      floatingFocusElementRef,
+      orientation,
+      typeableComboboxReference,
+      store,
+      open,
+      virtual,
+      domReferenceElement
+    ],
+    (0, import_internal.subSlot)(slot, "floating")
+  );
+  const trigger = (0, import_octane.useMemo)(
+    () => {
+      function openOnNavigationKeyDown(event) {
+        store.setOpen(
+          true,
+          (0, import_createChangeEventDetails.createChangeEventDetails)(
+            import_createChangeEventDetails.REASONS.listNavigation,
+            event,
+            event.currentTarget
+          )
+        );
+      }
+      function checkVirtualMouse(event) {
+        if (focusItemOnOpen === "auto" && (0, import_event.isVirtualClick)(event)) {
+          focusItemOnOpenRef.current = !virtual;
+        }
+      }
+      function checkVirtualPointer(event) {
+        focusItemOnOpenRef.current = focusItemOnOpen;
+        if (focusItemOnOpen === "auto" && (0, import_event.isVirtualPointerEvent)(event)) {
+          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) || event.key === "Enter" || event.key.trim() === "";
+          if (virtual && currentOpen) {
+            return commonOnKeyDown(event);
+          }
+          if (!currentOpen && !openOnArrowKeyDown && isArrowKey) {
+            return void 0;
+          }
+          if (isNavigationKey) {
+            const isParentMainKey = isMainOrientationKey(event.key, getParentOrientation());
+            keyRef.current = nested && isParentMainKey ? null : event.key;
+          }
+          if (nested) {
+            if (isParentCrossOpenKey) {
+              (0, import_list_utils.stopEvent)(event);
+              if (currentOpen) {
+                indexRef.current = getMinEnabledIndex();
+                onNavigate(event);
+              } else {
+                openOnNavigationKeyDown(event);
+              }
+            }
+            return void 0;
+          }
+          if (isMainKey) {
+            if (selectedIndexRef.current != null) {
+              indexRef.current = selectedIndexRef.current;
+            }
+            (0, import_list_utils.stopEvent)(event);
+            if (!currentOpen && openOnArrowKeyDown) {
+              openOnNavigationKeyDown(event);
+            } else {
+              commonOnKeyDown(event);
+            }
+            if (currentOpen) {
+              onNavigate(event);
+            }
+          }
+          return void 0;
+        },
+        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
+    ],
+    (0, import_internal.subSlot)(slot, "trigger")
+  );
+  const reference = (0, import_octane.useMemo)(
+    () => {
+      return {
+        ...ariaActiveDescendantProp,
+        ...trigger
+      };
+    },
+    [ariaActiveDescendantProp, trigger],
+    (0, import_internal.subSlot)(slot, "ref")
+  );
+  return (0, import_octane.useMemo)(
+    () => enabled ? { reference, floating, item, trigger } : {},
+    [enabled, reference, floating, trigger, item],
+    (0, import_internal.subSlot)(slot, "out")
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ESCAPE,
+  useListNavigation
+});