@octanejs/base-ui 0.1.31 → 0.1.32

package/dist/cjs/utils/floating/FloatingFocusManager.cjs

@@ -0,0 +1,685 @@
+"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 FloatingFocusManager_exports = {};
+__export(FloatingFocusManager_exports, {
+  FloatingFocusManager: () => FloatingFocusManager
+});
+module.exports = __toCommonJS(FloatingFocusManager_exports);
+var import_octane = require("octane");
+var import_dom = require("@floating-ui/utils/dom");
+var import_internal = require("../../internal.cjs");
+var import_addEventListener = require("../addEventListener.cjs");
+var import_mergeCleanups = require("../mergeCleanups.cjs");
+var import_composeRefs = require("../composeRefs.cjs");
+var import_useValueAsRef = require("../useValueAsRef.cjs");
+var import_useStableCallback = require("../useStableCallback.cjs");
+var import_useTimeout = require("../useTimeout.cjs");
+var import_useAnimationFrame = require("../useAnimationFrame.cjs");
+var import_platform = require("../platform.cjs");
+var import_owner = require("../owner.cjs");
+var import_resolveRef = require("../resolveRef.cjs");
+var import_FocusGuard = require("./FocusGuard.cjs");
+var import_element = require("./element.cjs");
+var import_event = require("./event.cjs");
+var import_list_utils = require("../composite/list-utils.cjs");
+var import_tabbable = require("./tabbable.cjs");
+var import_nodes = require("./nodes.cjs");
+var import_composite = require("./composite.cjs");
+var import_createChangeEventDetails = require("../createChangeEventDetails.cjs");
+var import_createAttribute = require("./createAttribute.cjs");
+var import_constants = require("./constants.cjs");
+var import_enqueueFocus = require("./enqueueFocus.cjs");
+var import_markOthers = require("./markOthers.cjs");
+var import_FloatingPortal = require("./FloatingPortal.cjs");
+var import_FloatingTree = require("./FloatingTree.cjs");
+function getEventType(event, lastInteractionType) {
+  const win = (0, import_owner.ownerWindow)((0, import_element.getTarget)(event));
+  if (event instanceof win.KeyboardEvent) {
+    return "keyboard";
+  }
+  if (event instanceof win.FocusEvent) {
+    return lastInteractionType || "keyboard";
+  }
+  if ("pointerType" in event) {
+    return event.pointerType || "keyboard";
+  }
+  if ("touches" in event) {
+    return "touch";
+  }
+  if (event instanceof win.MouseEvent) {
+    return lastInteractionType || (event.detail === 0 ? "keyboard" : "mouse");
+  }
+  return "";
+}
+const LIST_LIMIT = 20;
+let previouslyFocusedElements = [];
+function clearDisconnectedPreviouslyFocusedElements() {
+  previouslyFocusedElements = previouslyFocusedElements.filter(
+    (entry) => entry.deref()?.isConnected
+  );
+}
+function addPreviouslyFocusedElement(element) {
+  clearDisconnectedPreviouslyFocusedElements();
+  if (element && (0, import_dom.getNodeName)(element) !== "body") {
+    previouslyFocusedElements.push(new WeakRef(element));
+    if (previouslyFocusedElements.length > LIST_LIMIT) {
+      previouslyFocusedElements = previouslyFocusedElements.slice(-LIST_LIMIT);
+    }
+  }
+}
+function getPreviouslyFocusedElement() {
+  clearDisconnectedPreviouslyFocusedElements();
+  return previouslyFocusedElements[previouslyFocusedElements.length - 1]?.deref();
+}
+function getFirstTabbableElement(container) {
+  if (!container) {
+    return null;
+  }
+  if ((0, import_tabbable.isTabbable)(container)) {
+    return container;
+  }
+  return (0, import_tabbable.tabbable)(container)[0] || container;
+}
+function handleTabIndex(floatingFocusElement) {
+  if (floatingFocusElement.hasAttribute("tabindex") && !floatingFocusElement.hasAttribute("data-tabindex")) {
+    return;
+  }
+  if (!floatingFocusElement.getAttribute("role")?.includes("dialog")) {
+    return;
+  }
+  const focusableElements = (0, import_tabbable.focusable)(floatingFocusElement);
+  const tabbableContent = focusableElements.filter((element) => {
+    const dataTabIndex = element.getAttribute("data-tabindex") || "";
+    return (0, import_tabbable.isTabbable)(element) || element.hasAttribute("data-tabindex") && !dataTabIndex.startsWith("-");
+  });
+  const tabIndex = floatingFocusElement.getAttribute("tabindex");
+  if (tabbableContent.length === 0) {
+    if (tabIndex !== "0") {
+      floatingFocusElement.setAttribute("tabindex", "0");
+      floatingFocusElement.setAttribute("data-tabindex", "0");
+    }
+  } else if (tabIndex !== "-1" || floatingFocusElement.hasAttribute("data-tabindex") && floatingFocusElement.getAttribute("data-tabindex") !== "-1") {
+    floatingFocusElement.setAttribute("tabindex", "-1");
+    floatingFocusElement.setAttribute("data-tabindex", "-1");
+  }
+}
+function FloatingFocusManager(props) {
+  const slot = (0, import_internal.S)("FloatingFocusManager");
+  const {
+    context,
+    children,
+    disabled = false,
+    initialFocus = true,
+    returnFocus = true,
+    restoreFocus = false,
+    modal = true,
+    closeOnFocusOut = true,
+    openInteractionType = "",
+    nextFocusableElement,
+    previousFocusableElement,
+    beforeContentFocusGuardRef,
+    externalTree,
+    getInsideElements
+  } = props;
+  const store = context && "rootStore" in context ? context.rootStore : context;
+  const open = store.useState("open", (0, import_internal.subSlot)(slot, "open"));
+  const domReference = store.useState("domReferenceElement", (0, import_internal.subSlot)(slot, "dom"));
+  const floating = store.useState("floatingElement", (0, import_internal.subSlot)(slot, "fel"));
+  const { events, dataRef } = store.context;
+  const getNodeId = (0, import_useStableCallback.useStableCallback)(
+    () => dataRef.current.floatingContext?.nodeId,
+    (0, import_internal.subSlot)(slot, "getNodeId")
+  );
+  const ignoreInitialFocus = initialFocus === false;
+  const isUntrappedTypeableCombobox = (0, import_element.isTypeableCombobox)(domReference) && ignoreInitialFocus;
+  const initialFocusRef = (0, import_useValueAsRef.useValueAsRef)(initialFocus, (0, import_internal.subSlot)(slot, "ifr"));
+  const returnFocusRef = (0, import_useValueAsRef.useValueAsRef)(returnFocus, (0, import_internal.subSlot)(slot, "rfr"));
+  const openInteractionTypeRef = (0, import_useValueAsRef.useValueAsRef)(openInteractionType, (0, import_internal.subSlot)(slot, "oitr"));
+  const openRef = (0, import_useValueAsRef.useValueAsRef)(open, (0, import_internal.subSlot)(slot, "openRef"));
+  const tree = (0, import_FloatingTree.useFloatingTree)(externalTree);
+  const portalContext = (0, import_FloatingPortal.usePortalContext)();
+  const preventReturnFocusRef = (0, import_octane.useRef)(false, (0, import_internal.subSlot)(slot, "prf"));
+  const isPointerDownRef = (0, import_octane.useRef)(false, (0, import_internal.subSlot)(slot, "ipd"));
+  const pointerDownOutsideRef = (0, import_octane.useRef)(false, (0, import_internal.subSlot)(slot, "pdo"));
+  const lastFocusedTabbableRef = (0, import_octane.useRef)(null, (0, import_internal.subSlot)(slot, "lft"));
+  const closeTypeRef = (0, import_octane.useRef)("", (0, import_internal.subSlot)(slot, "ct"));
+  const lastInteractionTypeRef = (0, import_octane.useRef)("", (0, import_internal.subSlot)(slot, "lit"));
+  const beforeGuardRef = (0, import_octane.useRef)(null, (0, import_internal.subSlot)(slot, "bg"));
+  const afterGuardRef = (0, import_octane.useRef)(null, (0, import_internal.subSlot)(slot, "ag"));
+  const mergedBeforeGuardRef = (0, import_composeRefs.useComposedRefs)(
+    beforeGuardRef,
+    beforeContentFocusGuardRef,
+    portalContext?.beforeInsideRef,
+    (0, import_internal.subSlot)(slot, "mbg")
+  );
+  const mergedAfterGuardRef = (0, import_composeRefs.useComposedRefs)(
+    afterGuardRef,
+    portalContext?.afterInsideRef,
+    (0, import_internal.subSlot)(slot, "mag")
+  );
+  const blurTimeout = (0, import_useTimeout.useTimeout)((0, import_internal.subSlot)(slot, "bt"));
+  const pointerDownTimeout = (0, import_useTimeout.useTimeout)((0, import_internal.subSlot)(slot, "pdt"));
+  const restoreFocusFrame = (0, import_useAnimationFrame.useAnimationFrame)((0, import_internal.subSlot)(slot, "rff"));
+  const isInsidePortal = portalContext != null;
+  const floatingFocusElement = (0, import_element.getFloatingFocusElement)(floating);
+  const getTabbableContent = (0, import_useStableCallback.useStableCallback)(
+    (container = floatingFocusElement) => {
+      return container ? (0, import_tabbable.tabbable)(container) : [];
+    },
+    (0, import_internal.subSlot)(slot, "gtc")
+  );
+  const getResolvedInsideElements = (0, import_useStableCallback.useStableCallback)(
+    () => getInsideElements?.().filter((element) => element != null) ?? [],
+    (0, import_internal.subSlot)(slot, "grie")
+  );
+  (0, import_octane.useEffect)(
+    () => {
+      if (disabled || !modal) {
+        return void 0;
+      }
+      function onKeyDown(event) {
+        if (event.key === "Tab") {
+          if ((0, import_element.contains)(floatingFocusElement, (0, import_element.activeElement)((0, import_owner.ownerDocument)(floatingFocusElement))) && getTabbableContent().length === 0 && !isUntrappedTypeableCombobox) {
+            (0, import_list_utils.stopEvent)(event);
+          }
+        }
+      }
+      const doc = (0, import_owner.ownerDocument)(floatingFocusElement);
+      return (0, import_addEventListener.addEventListener)(doc, "keydown", onKeyDown);
+    },
+    [disabled, floatingFocusElement, modal, isUntrappedTypeableCombobox, getTabbableContent],
+    (0, import_internal.subSlot)(slot, "e:tab")
+  );
+  (0, import_octane.useEffect)(
+    () => {
+      if (disabled || !open) {
+        return void 0;
+      }
+      const doc = (0, import_owner.ownerDocument)(floatingFocusElement);
+      function clearPointerDownOutside() {
+        pointerDownOutsideRef.current = false;
+      }
+      function onPointerDown(event) {
+        const target = (0, import_element.getTarget)(event);
+        const insideElements = getResolvedInsideElements();
+        const pointerTargetInside = (0, import_element.contains)(floating, target) || (0, import_element.contains)(domReference, target) || (0, import_element.contains)(portalContext?.portalNode, target) || insideElements.some(
+          (element) => element === target || (0, import_element.contains)(element, target)
+        );
+        pointerDownOutsideRef.current = !pointerTargetInside;
+        lastInteractionTypeRef.current = event.pointerType || "keyboard";
+        if (target?.closest(`[${import_constants.CLICK_TRIGGER_IDENTIFIER}]`)) {
+          isPointerDownRef.current = true;
+          pointerDownTimeout.start(0, () => {
+            isPointerDownRef.current = false;
+          });
+        }
+      }
+      function onKeyDown() {
+        lastInteractionTypeRef.current = "keyboard";
+      }
+      return (0, import_mergeCleanups.mergeCleanups)(
+        (0, import_addEventListener.addEventListener)(doc, "pointerdown", onPointerDown, true),
+        (0, import_addEventListener.addEventListener)(doc, "pointerup", clearPointerDownOutside, true),
+        (0, import_addEventListener.addEventListener)(doc, "pointercancel", clearPointerDownOutside, true),
+        (0, import_addEventListener.addEventListener)(doc, "keydown", onKeyDown, true),
+        clearPointerDownOutside
+      );
+    },
+    [
+      disabled,
+      floating,
+      domReference,
+      floatingFocusElement,
+      open,
+      portalContext,
+      pointerDownTimeout,
+      getResolvedInsideElements
+    ],
+    (0, import_internal.subSlot)(slot, "e:track")
+  );
+  (0, import_octane.useEffect)(
+    () => {
+      if (disabled || !closeOnFocusOut) {
+        return void 0;
+      }
+      const doc = (0, import_owner.ownerDocument)(floatingFocusElement);
+      function handlePointerDown() {
+        isPointerDownRef.current = true;
+        pointerDownTimeout.start(0, () => {
+          isPointerDownRef.current = false;
+        });
+      }
+      function handleFocusIn(event) {
+        const target = (0, import_element.getTarget)(event);
+        if ((0, import_tabbable.isTabbable)(target)) {
+          lastFocusedTabbableRef.current = target;
+        }
+      }
+      function handleFocusOutside(event) {
+        const relatedTarget = event.relatedTarget;
+        const currentTarget = event.currentTarget;
+        const target = (0, import_element.getTarget)(event);
+        if (modal && relatedTarget == null && target != null && (0, import_element.contains)(floating, target)) {
+          addPreviouslyFocusedElement(target);
+        }
+        queueMicrotask(() => {
+          const nodeId = getNodeId();
+          const triggers = store.context.triggerElements;
+          const insideElements = getResolvedInsideElements();
+          const isRelatedFocusGuard = relatedTarget?.hasAttribute((0, import_createAttribute.createAttribute)("focus-guard")) && [
+            beforeGuardRef.current,
+            afterGuardRef.current,
+            portalContext?.beforeInsideRef.current,
+            portalContext?.afterInsideRef.current,
+            portalContext?.beforeOutsideRef.current,
+            portalContext?.afterOutsideRef.current,
+            (0, import_resolveRef.resolveRef)(previousFocusableElement),
+            (0, import_resolveRef.resolveRef)(nextFocusableElement)
+          ].includes(relatedTarget);
+          const movedToUnrelatedNode = !((0, import_element.contains)(domReference, relatedTarget) || (0, import_element.contains)(floating, relatedTarget) || (0, import_element.contains)(relatedTarget, floating) || (0, import_element.contains)(portalContext?.portalNode, relatedTarget) || insideElements.some(
+            (element) => element === relatedTarget || (0, import_element.contains)(element, relatedTarget)
+          ) || relatedTarget != null && triggers.hasElement(relatedTarget) || triggers.hasMatchingElement((trigger) => (0, import_element.contains)(trigger, relatedTarget)) || isRelatedFocusGuard || tree && ((0, import_nodes.getNodeChildren)(tree.nodesRef.current, nodeId).find(
+            (node) => (0, import_element.contains)(node.context?.elements.floating, relatedTarget) || (0, import_element.contains)(node.context?.elements.domReference, relatedTarget)
+          ) || (0, import_nodes.getNodeAncestors)(tree.nodesRef.current, nodeId).find(
+            (node) => [
+              node.context?.elements.floating,
+              (0, import_element.getFloatingFocusElement)(node.context?.elements.floating)
+            ].includes(relatedTarget) || node.context?.elements.domReference === relatedTarget
+          )));
+          if (currentTarget === domReference && floatingFocusElement) {
+            handleTabIndex(floatingFocusElement);
+          }
+          if (restoreFocus && currentTarget !== domReference && !(0, import_composite.isElementVisible)(target) && (0, import_element.activeElement)(doc) === doc.body) {
+            if ((0, import_dom.isHTMLElement)(floatingFocusElement)) {
+              floatingFocusElement.focus();
+              if (restoreFocus === "popup") {
+                restoreFocusFrame.request(() => {
+                  floatingFocusElement.focus();
+                });
+                return;
+              }
+            }
+            const tabbableContent = getTabbableContent();
+            const prevTabbable = lastFocusedTabbableRef.current;
+            const nodeToFocus = (prevTabbable && tabbableContent.includes(prevTabbable) ? prevTabbable : null) || tabbableContent[tabbableContent.length - 1] || floatingFocusElement;
+            if ((0, import_dom.isHTMLElement)(nodeToFocus)) {
+              nodeToFocus.focus();
+            }
+          }
+          if (dataRef.current.insideReactTree) {
+            dataRef.current.insideReactTree = false;
+            return;
+          }
+          if ((isUntrappedTypeableCombobox ? true : !modal) && relatedTarget && movedToUnrelatedNode && !isPointerDownRef.current && (isUntrappedTypeableCombobox || relatedTarget !== getPreviouslyFocusedElement())) {
+            preventReturnFocusRef.current = true;
+            store.setOpen(false, (0, import_createChangeEventDetails.createChangeEventDetails)(import_createChangeEventDetails.REASONS.focusOut, event));
+          }
+        });
+      }
+      function markInsideReactTree() {
+        if (pointerDownOutsideRef.current) {
+          return;
+        }
+        dataRef.current.insideReactTree = true;
+        blurTimeout.start(0, () => {
+          dataRef.current.insideReactTree = false;
+        });
+      }
+      const domReferenceElement = (0, import_dom.isHTMLElement)(domReference) ? domReference : null;
+      if (!floating && !domReferenceElement) {
+        return void 0;
+      }
+      return (0, import_mergeCleanups.mergeCleanups)(
+        domReferenceElement && (0, import_addEventListener.addEventListener)(domReferenceElement, "focusout", handleFocusOutside),
+        domReferenceElement && (0, import_addEventListener.addEventListener)(domReferenceElement, "pointerdown", handlePointerDown),
+        floating && (0, import_addEventListener.addEventListener)(floating, "focusin", handleFocusIn),
+        floating && (0, import_addEventListener.addEventListener)(floating, "focusout", handleFocusOutside),
+        floating && portalContext && (0, import_addEventListener.addEventListener)(floating, "focusout", markInsideReactTree, true)
+      );
+    },
+    [
+      disabled,
+      domReference,
+      floating,
+      floatingFocusElement,
+      modal,
+      tree,
+      portalContext,
+      store,
+      closeOnFocusOut,
+      restoreFocus,
+      getTabbableContent,
+      isUntrappedTypeableCombobox,
+      getNodeId,
+      dataRef,
+      blurTimeout,
+      pointerDownTimeout,
+      restoreFocusFrame,
+      nextFocusableElement,
+      previousFocusableElement,
+      getResolvedInsideElements
+    ],
+    (0, import_internal.subSlot)(slot, "e:focusout")
+  );
+  (0, import_octane.useEffect)(
+    () => {
+      if (disabled || !floating || !open) {
+        return void 0;
+      }
+      const portalNodes = Array.from(
+        portalContext?.portalNode?.querySelectorAll(`[${(0, import_createAttribute.createAttribute)("portal")}]`) || []
+      );
+      const ancestors = tree ? (0, import_nodes.getNodeAncestors)(tree.nodesRef.current, getNodeId()) : [];
+      const rootAncestorComboboxDomReference = ancestors.find(
+        (node) => (0, import_element.isTypeableCombobox)(node.context?.elements.domReference || null)
+      )?.context?.elements.domReference;
+      const controlInsideElements = [
+        floating,
+        ...portalNodes,
+        beforeGuardRef.current,
+        afterGuardRef.current,
+        portalContext?.beforeOutsideRef.current,
+        portalContext?.afterOutsideRef.current,
+        ...getResolvedInsideElements()
+      ];
+      const insideElements = [
+        ...controlInsideElements,
+        rootAncestorComboboxDomReference,
+        (0, import_resolveRef.resolveRef)(previousFocusableElement),
+        (0, import_resolveRef.resolveRef)(nextFocusableElement),
+        isUntrappedTypeableCombobox ? domReference : null
+      ].filter((x) => x != null);
+      const ariaHiddenCleanup = (0, import_markOthers.markOthers)(insideElements, {
+        ariaHidden: modal || isUntrappedTypeableCombobox,
+        mark: false
+      });
+      const markerInsideElements = [floating, ...portalNodes].filter(
+        (x) => x != null
+      );
+      const markerCleanup = (0, import_markOthers.markOthers)(markerInsideElements);
+      return () => {
+        markerCleanup();
+        ariaHiddenCleanup();
+      };
+    },
+    [
+      open,
+      disabled,
+      domReference,
+      floating,
+      modal,
+      portalContext,
+      isUntrappedTypeableCombobox,
+      tree,
+      getNodeId,
+      nextFocusableElement,
+      previousFocusableElement,
+      getResolvedInsideElements
+    ],
+    (0, import_internal.subSlot)(slot, "e:hide")
+  );
+  (0, import_octane.useLayoutEffect)(
+    () => {
+      if (!open || disabled || !(0, import_dom.isHTMLElement)(floatingFocusElement)) {
+        return;
+      }
+      const doc = (0, import_owner.ownerDocument)(floatingFocusElement);
+      const previouslyFocused = (0, import_element.activeElement)(doc);
+      queueMicrotask(() => {
+        const initialFocusValueOrFn = initialFocusRef.current;
+        const resolvedInitialFocus = typeof initialFocusValueOrFn === "function" ? initialFocusValueOrFn(openInteractionTypeRef.current || "") : initialFocusValueOrFn;
+        if (resolvedInitialFocus === void 0 || resolvedInitialFocus === false) {
+          return;
+        }
+        const focusAlreadyInsideFloatingEl = (0, import_element.contains)(floatingFocusElement, previouslyFocused);
+        if (focusAlreadyInsideFloatingEl) {
+          return;
+        }
+        let focusableElements = null;
+        const getDefaultFocusElement = () => {
+          if (focusableElements == null) {
+            focusableElements = getTabbableContent(floatingFocusElement);
+          }
+          return focusableElements[0] || floatingFocusElement;
+        };
+        let elToFocus;
+        if (resolvedInitialFocus === true || resolvedInitialFocus === null) {
+          elToFocus = getDefaultFocusElement();
+        } else {
+          elToFocus = (0, import_resolveRef.resolveRef)(resolvedInitialFocus);
+        }
+        elToFocus = elToFocus || getDefaultFocusElement();
+        const hadFocusInside = (0, import_element.contains)(floatingFocusElement, (0, import_element.activeElement)(doc));
+        (0, import_enqueueFocus.enqueueFocus)(elToFocus, {
+          preventScroll: elToFocus === floatingFocusElement,
+          shouldFocus() {
+            if (!openRef.current) {
+              return false;
+            }
+            if (hadFocusInside) {
+              return true;
+            }
+            const currentActiveElement = (0, import_element.activeElement)(doc);
+            const focusMovedInside = currentActiveElement !== elToFocus && (0, import_element.contains)(floatingFocusElement, currentActiveElement);
+            return !focusMovedInside;
+          }
+        });
+      });
+    },
+    [
+      disabled,
+      open,
+      floatingFocusElement,
+      getTabbableContent,
+      initialFocusRef,
+      openInteractionTypeRef,
+      openRef
+    ],
+    (0, import_internal.subSlot)(slot, "e:initfocus")
+  );
+  (0, import_octane.useLayoutEffect)(
+    () => {
+      if (disabled || !floatingFocusElement) {
+        return void 0;
+      }
+      const doc = (0, import_owner.ownerDocument)(floatingFocusElement);
+      const elementFocusedBeforeOpen = (0, import_element.activeElement)(doc);
+      const preferPreviousFocus = openInteractionTypeRef.current == null;
+      addPreviouslyFocusedElement(elementFocusedBeforeOpen);
+      function onOpenChangeLocal(details) {
+        if (!details.open) {
+          closeTypeRef.current = getEventType(details.nativeEvent, lastInteractionTypeRef.current);
+        }
+        if (details.reason === import_createChangeEventDetails.REASONS.triggerHover && details.nativeEvent.type === "mouseleave") {
+          preventReturnFocusRef.current = true;
+        }
+        if (details.reason !== import_createChangeEventDetails.REASONS.outsidePress) {
+          return;
+        }
+        if (details.nested) {
+          preventReturnFocusRef.current = false;
+        } else if ((0, import_event.isVirtualClick)(details.nativeEvent) || (0, import_event.isVirtualPointerEvent)(details.nativeEvent)) {
+          preventReturnFocusRef.current = false;
+        } else {
+          let isPreventScrollSupported = false;
+          (0, import_owner.ownerDocument)(floatingFocusElement).createElement("div").focus({
+            get preventScroll() {
+              isPreventScrollSupported = true;
+              return false;
+            }
+          });
+          if (isPreventScrollSupported) {
+            preventReturnFocusRef.current = false;
+          } else {
+            preventReturnFocusRef.current = true;
+          }
+        }
+      }
+      events.on("openchange", onOpenChangeLocal);
+      function getReturnElement() {
+        const returnFocusValueOrFn = returnFocusRef.current;
+        let resolvedReturnFocusValue = typeof returnFocusValueOrFn === "function" ? returnFocusValueOrFn(closeTypeRef.current) : returnFocusValueOrFn;
+        if (resolvedReturnFocusValue === void 0 || resolvedReturnFocusValue === false) {
+          return null;
+        }
+        if (resolvedReturnFocusValue === null) {
+          resolvedReturnFocusValue = true;
+        }
+        const referenceReturnElement = domReference?.isConnected ? domReference : null;
+        const previousReturnElement = elementFocusedBeforeOpen?.isConnected && (0, import_dom.getNodeName)(elementFocusedBeforeOpen) !== "body" ? elementFocusedBeforeOpen : null;
+        let defaultReturnElement = preferPreviousFocus ? previousReturnElement || referenceReturnElement : referenceReturnElement || previousReturnElement;
+        if (!defaultReturnElement) {
+          defaultReturnElement = getPreviouslyFocusedElement() || null;
+        }
+        if (typeof resolvedReturnFocusValue === "boolean") {
+          return defaultReturnElement;
+        }
+        return (0, import_resolveRef.resolveRef)(resolvedReturnFocusValue) || defaultReturnElement || null;
+      }
+      return () => {
+        events.off("openchange", onOpenChangeLocal);
+        const activeEl = (0, import_element.activeElement)(doc);
+        const insideElements = getResolvedInsideElements();
+        const isFocusInsideFloatingTree = (0, import_element.contains)(floating, activeEl) || insideElements.some(
+          (element) => element === activeEl || (0, import_element.contains)(element, activeEl)
+        ) || tree && (0, import_nodes.getNodeChildren)(tree.nodesRef.current, getNodeId(), false).some(
+          (node) => (0, import_element.contains)(node.context?.elements.floating, activeEl)
+        );
+        const returnFocusValueOrFn = returnFocusRef.current;
+        const returnElement = getReturnElement();
+        queueMicrotask(() => {
+          const tabbableReturnElement = getFirstTabbableElement(returnElement);
+          const hasExplicitReturnFocus = typeof returnFocusValueOrFn !== "boolean";
+          if (returnFocusValueOrFn && !preventReturnFocusRef.current && (0, import_dom.isHTMLElement)(tabbableReturnElement) && (!hasExplicitReturnFocus && tabbableReturnElement !== activeEl && activeEl !== doc.body ? isFocusInsideFloatingTree : true)) {
+            tabbableReturnElement.focus({ preventScroll: true });
+          }
+          preventReturnFocusRef.current = false;
+        });
+      };
+    },
+    [
+      disabled,
+      floating,
+      floatingFocusElement,
+      returnFocusRef,
+      openInteractionTypeRef,
+      events,
+      tree,
+      domReference,
+      getNodeId,
+      getResolvedInsideElements
+    ],
+    (0, import_internal.subSlot)(slot, "e:returnfocus")
+  );
+  (0, import_octane.useLayoutEffect)(
+    () => {
+      if (!import_platform.platform.engine.webkit || open || !floating) {
+        return;
+      }
+      const activeEl = (0, import_element.activeElement)((0, import_owner.ownerDocument)(floating));
+      if (!(0, import_dom.isHTMLElement)(activeEl) || !(0, import_element.isTypeableElement)(activeEl)) {
+        return;
+      }
+      if ((0, import_element.contains)(floating, activeEl)) {
+        activeEl.blur();
+      }
+    },
+    [open, floating],
+    (0, import_internal.subSlot)(slot, "e:webkit")
+  );
+  (0, import_octane.useLayoutEffect)(
+    () => {
+      if (disabled || !portalContext) {
+        return void 0;
+      }
+      portalContext.setFocusManagerState({
+        modal,
+        closeOnFocusOut,
+        open,
+        onOpenChange: store.setOpen,
+        domReference
+      });
+      return () => {
+        portalContext.setFocusManagerState(null);
+      };
+    },
+    [disabled, portalContext, modal, open, store, closeOnFocusOut, domReference],
+    (0, import_internal.subSlot)(slot, "e:portalsync")
+  );
+  (0, import_octane.useLayoutEffect)(
+    () => {
+      if (disabled || !floatingFocusElement) {
+        return void 0;
+      }
+      handleTabIndex(floatingFocusElement);
+      return () => {
+        queueMicrotask(clearDisconnectedPreviouslyFocusedElements);
+      };
+    },
+    [disabled, floatingFocusElement],
+    (0, import_internal.subSlot)(slot, "e:tabindex")
+  );
+  const shouldRenderGuards = !disabled && (modal ? !isUntrappedTypeableCombobox : true) && (isInsidePortal || modal);
+  return [
+    shouldRenderGuards ? (0, import_octane.createElement)(import_FocusGuard.FocusGuard, {
+      key: "guard-inside-before",
+      "data-type": "inside",
+      ref: mergedBeforeGuardRef,
+      onFocus(event) {
+        if (modal) {
+          const els = getTabbableContent();
+          (0, import_enqueueFocus.enqueueFocus)(els[els.length - 1]);
+        } else if (portalContext?.portalNode) {
+          preventReturnFocusRef.current = false;
+          if ((0, import_tabbable.isOutsideEvent)(event, portalContext.portalNode)) {
+            const nextTabbable = (0, import_tabbable.getNextTabbable)(domReference);
+            nextTabbable?.focus();
+          } else {
+            (0, import_resolveRef.resolveRef)(previousFocusableElement ?? portalContext.beforeOutsideRef)?.focus();
+          }
+        }
+      }
+    }) : null,
+    (0, import_octane.createElement)(import_octane.Fragment, { key: "children", children }),
+    shouldRenderGuards ? (0, import_octane.createElement)(import_FocusGuard.FocusGuard, {
+      key: "guard-inside-after",
+      "data-type": "inside",
+      ref: mergedAfterGuardRef,
+      onFocus(event) {
+        if (modal) {
+          (0, import_enqueueFocus.enqueueFocus)(getTabbableContent()[0]);
+        } else if (portalContext?.portalNode) {
+          if (closeOnFocusOut) {
+            preventReturnFocusRef.current = true;
+          }
+          if ((0, import_tabbable.isOutsideEvent)(event, portalContext.portalNode)) {
+            const prevTabbable = (0, import_tabbable.getPreviousTabbable)(domReference);
+            prevTabbable?.focus();
+          } else {
+            (0, import_resolveRef.resolveRef)(nextFocusableElement ?? portalContext.afterOutsideRef)?.focus();
+          }
+        }
+      }
+    }) : null
+  ];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FloatingFocusManager
+});