@neynar/ui 0.4.0 → 1.0.0

package/dist/node_modules/@base-ui/react/esm/floating-ui-react/components/FloatingFocusManager.js

@@ -0,0 +1,545 @@
+"use client";
+import * as React from "react";
+import { tabbable, isTabbable, focusable } from "../../../../../tabbable/dist/index.esm.js";
+import { isHTMLElement, getNodeName, getWindow, getComputedStyle } from "../../../../../@floating-ui/utils/dist/floating-ui.utils.dom.js";
+import { useMergedRefs } from "../../../../utils/esm/useMergedRefs.js";
+import { useValueAsRef } from "../../../../utils/esm/useValueAsRef.js";
+import { useStableCallback } from "../../../../utils/esm/useStableCallback.js";
+import { useIsoLayoutEffect } from "../../../../utils/esm/useIsoLayoutEffect.js";
+import { visuallyHidden } from "../../../../utils/esm/visuallyHidden.js";
+import { useTimeout } from "../../../../utils/esm/useTimeout.js";
+import { useAnimationFrame } from "../../../../utils/esm/useAnimationFrame.js";
+import { FocusGuard } from "../../utils/FocusGuard.js";
+import { createChangeEventDetails } from "../../utils/createBaseUIEventDetails.js";
+import { createAttribute } from "../utils/createAttribute.js";
+import { enqueueFocus } from "../utils/enqueueFocus.js";
+import { markOthers } from "../utils/markOthers.js";
+import { usePortalContext } from "./FloatingPortal.js";
+import { useFloatingTree } from "./FloatingTree.js";
+import { CLICK_TRIGGER_IDENTIFIER } from "../../utils/constants.js";
+import { resolveRef } from "../../utils/resolveRef.js";
+import { jsxs, jsx } from "react/jsx-runtime";
+import { isTypeableCombobox, getFloatingFocusElement, getDocument, activeElement, contains, getTarget } from "../utils/element.js";
+import { getTabbableOptions, isOutsideEvent, getNextTabbable, getPreviousTabbable } from "../utils/tabbable.js";
+import { getNodeAncestors, getNodeChildren } from "../utils/nodes.js";
+import { isVirtualClick, isVirtualPointerEvent, stopEvent } from "../utils/event.js";
+import { triggerHover, outsidePress, focusOut } from "../../utils/reason-parts.js";
+function getEventType(event, lastInteractionType) {
+  const win = getWindow(event.target);
+  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((el) => el.isConnected);
+}
+function addPreviouslyFocusedElement(element) {
+  clearDisconnectedPreviouslyFocusedElements();
+  if (element && getNodeName(element) !== "body") {
+    previouslyFocusedElements.push(element);
+    if (previouslyFocusedElements.length > LIST_LIMIT) {
+      previouslyFocusedElements = previouslyFocusedElements.slice(-LIST_LIMIT);
+    }
+  }
+}
+function getPreviouslyFocusedElement() {
+  clearDisconnectedPreviouslyFocusedElements();
+  return previouslyFocusedElements[previouslyFocusedElements.length - 1];
+}
+function getFirstTabbableElement(container) {
+  if (!container) {
+    return null;
+  }
+  const tabbableOptions = getTabbableOptions();
+  if (isTabbable(container, tabbableOptions)) {
+    return container;
+  }
+  return tabbable(container, tabbableOptions)[0] || container;
+}
+function isFocusable(element) {
+  if (!element || !element.isConnected) {
+    return false;
+  }
+  if (typeof element.checkVisibility === "function") {
+    return element.checkVisibility();
+  }
+  return getComputedStyle(element).display !== "none";
+}
+function handleTabIndex(floatingFocusElement, orderRef) {
+  if (!orderRef.current.includes("floating") && !floatingFocusElement.getAttribute("role")?.includes("dialog")) {
+    return;
+  }
+  const options = getTabbableOptions();
+  const focusableElements = focusable(floatingFocusElement, options);
+  const tabbableContent = focusableElements.filter((element) => {
+    const dataTabIndex = element.getAttribute("data-tabindex") || "";
+    return isTabbable(element, options) || element.hasAttribute("data-tabindex") && !dataTabIndex.startsWith("-");
+  });
+  const tabIndex = floatingFocusElement.getAttribute("tabindex");
+  if (orderRef.current.includes("floating") || tabbableContent.length === 0) {
+    if (tabIndex !== "0") {
+      floatingFocusElement.setAttribute("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 {
+    context,
+    children,
+    disabled = false,
+    order = ["content"],
+    initialFocus = true,
+    returnFocus = true,
+    restoreFocus = false,
+    modal = true,
+    closeOnFocusOut = true,
+    openInteractionType = "",
+    getInsideElements: getInsideElementsProp = () => [],
+    nextFocusableElement,
+    previousFocusableElement,
+    beforeContentFocusGuardRef,
+    externalTree
+  } = props;
+  const store = "rootStore" in context ? context.rootStore : context;
+  const open = store.useState("open");
+  const domReference = store.useState("domReferenceElement");
+  const floating = store.useState("floatingElement");
+  const {
+    events,
+    dataRef
+  } = store.context;
+  const getNodeId = useStableCallback(() => dataRef.current.floatingContext?.nodeId);
+  const getInsideElements = useStableCallback(getInsideElementsProp);
+  const ignoreInitialFocus = initialFocus === false;
+  const isUntrappedTypeableCombobox = isTypeableCombobox(domReference) && ignoreInitialFocus;
+  const orderRef = useValueAsRef(order);
+  const initialFocusRef = useValueAsRef(initialFocus);
+  const returnFocusRef = useValueAsRef(returnFocus);
+  const openInteractionTypeRef = useValueAsRef(openInteractionType);
+  const tree = useFloatingTree(externalTree);
+  const portalContext = usePortalContext();
+  const startDismissButtonRef = React.useRef(null);
+  const endDismissButtonRef = React.useRef(null);
+  const preventReturnFocusRef = React.useRef(false);
+  const isPointerDownRef = React.useRef(false);
+  const pointerDownOutsideRef = React.useRef(false);
+  const tabbableIndexRef = React.useRef(-1);
+  const closeTypeRef = React.useRef("");
+  const lastInteractionTypeRef = React.useRef("");
+  const blurTimeout = useTimeout();
+  const pointerDownTimeout = useTimeout();
+  const restoreFocusFrame = useAnimationFrame();
+  const isInsidePortal = portalContext != null;
+  const floatingFocusElement = getFloatingFocusElement(floating);
+  const getTabbableContent = useStableCallback((container = floatingFocusElement) => {
+    return container ? tabbable(container, getTabbableOptions()) : [];
+  });
+  const getTabbableElements = useStableCallback((container) => {
+    const content = getTabbableContent(container);
+    return orderRef.current.map(() => content).filter(Boolean).flat();
+  });
+  React.useEffect(() => {
+    if (disabled) {
+      return void 0;
+    }
+    if (!modal) {
+      return void 0;
+    }
+    function onKeyDown(event) {
+      if (event.key === "Tab") {
+        if (contains(floatingFocusElement, activeElement(getDocument(floatingFocusElement))) && getTabbableContent().length === 0 && !isUntrappedTypeableCombobox) {
+          stopEvent(event);
+        }
+      }
+    }
+    const doc = getDocument(floatingFocusElement);
+    doc.addEventListener("keydown", onKeyDown);
+    return () => {
+      doc.removeEventListener("keydown", onKeyDown);
+    };
+  }, [disabled, domReference, floatingFocusElement, modal, orderRef, isUntrappedTypeableCombobox, getTabbableContent, getTabbableElements]);
+  React.useEffect(() => {
+    if (disabled) {
+      return void 0;
+    }
+    if (!floating) {
+      return void 0;
+    }
+    function handleFocusIn(event) {
+      const target = getTarget(event);
+      const tabbableContent = getTabbableContent();
+      const tabbableIndex = tabbableContent.indexOf(target);
+      if (tabbableIndex !== -1) {
+        tabbableIndexRef.current = tabbableIndex;
+      }
+    }
+    floating.addEventListener("focusin", handleFocusIn);
+    return () => {
+      floating.removeEventListener("focusin", handleFocusIn);
+    };
+  }, [disabled, floating, getTabbableContent]);
+  React.useEffect(() => {
+    if (disabled || !open) {
+      return void 0;
+    }
+    const doc = getDocument(floatingFocusElement);
+    function clearPointerDownOutside() {
+      pointerDownOutsideRef.current = false;
+    }
+    function onPointerDown(event) {
+      const target = getTarget(event);
+      const pointerTargetInside = contains(floating, target) || contains(domReference, target) || contains(portalContext?.portalNode, target);
+      pointerDownOutsideRef.current = !pointerTargetInside;
+      lastInteractionTypeRef.current = event.pointerType || "keyboard";
+    }
+    function onKeyDown() {
+      lastInteractionTypeRef.current = "keyboard";
+    }
+    doc.addEventListener("pointerdown", onPointerDown, true);
+    doc.addEventListener("pointerup", clearPointerDownOutside, true);
+    doc.addEventListener("pointercancel", clearPointerDownOutside, true);
+    doc.addEventListener("keydown", onKeyDown, true);
+    return () => {
+      doc.removeEventListener("pointerdown", onPointerDown, true);
+      doc.removeEventListener("pointerup", clearPointerDownOutside, true);
+      doc.removeEventListener("pointercancel", clearPointerDownOutside, true);
+      doc.removeEventListener("keydown", onKeyDown, true);
+    };
+  }, [disabled, floating, domReference, floatingFocusElement, open, portalContext]);
+  React.useEffect(() => {
+    if (disabled) {
+      return void 0;
+    }
+    if (!closeOnFocusOut) {
+      return void 0;
+    }
+    function handlePointerDown() {
+      isPointerDownRef.current = true;
+      pointerDownTimeout.start(0, () => {
+        isPointerDownRef.current = false;
+      });
+    }
+    function handleFocusOutside(event) {
+      const relatedTarget = event.relatedTarget;
+      const currentTarget = event.currentTarget;
+      const target = getTarget(event);
+      queueMicrotask(() => {
+        const nodeId = getNodeId();
+        const triggers = store.context.triggerElements;
+        const movedToUnrelatedNode = !(contains(domReference, relatedTarget) || contains(floating, relatedTarget) || contains(relatedTarget, floating) || contains(portalContext?.portalNode, relatedTarget) || relatedTarget != null && triggers.hasElement(relatedTarget) || triggers.hasMatchingElement((trigger) => contains(trigger, relatedTarget)) || relatedTarget?.hasAttribute(createAttribute("focus-guard")) || tree && (getNodeChildren(tree.nodesRef.current, nodeId).find((node) => contains(node.context?.elements.floating, relatedTarget) || contains(node.context?.elements.domReference, relatedTarget)) || getNodeAncestors(tree.nodesRef.current, nodeId).find((node) => [node.context?.elements.floating, getFloatingFocusElement(node.context?.elements.floating)].includes(relatedTarget) || node.context?.elements.domReference === relatedTarget)));
+        if (currentTarget === domReference && floatingFocusElement) {
+          handleTabIndex(floatingFocusElement, orderRef);
+        }
+        if (restoreFocus && currentTarget !== domReference && !isFocusable(target) && activeElement(getDocument(floatingFocusElement)) === getDocument(floatingFocusElement).body) {
+          if (isHTMLElement(floatingFocusElement)) {
+            floatingFocusElement.focus();
+            if (restoreFocus === "popup") {
+              restoreFocusFrame.request(() => {
+                floatingFocusElement.focus();
+              });
+              return;
+            }
+          }
+          const prevTabbableIndex = tabbableIndexRef.current;
+          const tabbableContent = getTabbableContent();
+          const nodeToFocus = tabbableContent[prevTabbableIndex] || tabbableContent[tabbableContent.length - 1] || floatingFocusElement;
+          if (isHTMLElement(nodeToFocus)) {
+            nodeToFocus.focus();
+          }
+        }
+        if (dataRef.current.insideReactTree) {
+          dataRef.current.insideReactTree = false;
+          return;
+        }
+        if ((isUntrappedTypeableCombobox ? true : !modal) && relatedTarget && movedToUnrelatedNode && !isPointerDownRef.current && // Fix React 18 Strict Mode returnFocus due to double rendering.
+        // For an "untrapped" typeable combobox (input role=combobox with
+        // initialFocus=false), re-opening the popup and tabbing out should still close it even
+        // when the previously focused element (e.g. the next tabbable outside the popup) is
+        // focused again. Otherwise, the popup remains open on the second Tab sequence:
+        // click input -> Tab (closes) -> click input -> Tab.
+        // Allow closing when `isUntrappedTypeableCombobox` regardless of the previously focused element.
+        (isUntrappedTypeableCombobox || relatedTarget !== getPreviouslyFocusedElement())) {
+          preventReturnFocusRef.current = true;
+          store.setOpen(false, createChangeEventDetails(focusOut, event));
+        }
+      });
+    }
+    function markInsideReactTree() {
+      if (pointerDownOutsideRef.current) {
+        return;
+      }
+      dataRef.current.insideReactTree = true;
+      blurTimeout.start(0, () => {
+        dataRef.current.insideReactTree = false;
+      });
+    }
+    const domReferenceElement = isHTMLElement(domReference) ? domReference : null;
+    const cleanups = [];
+    if (!floating && !domReferenceElement) {
+      return void 0;
+    }
+    if (domReferenceElement) {
+      domReferenceElement.addEventListener("focusout", handleFocusOutside);
+      domReferenceElement.addEventListener("pointerdown", handlePointerDown);
+      cleanups.push(() => {
+        domReferenceElement.removeEventListener("focusout", handleFocusOutside);
+        domReferenceElement.removeEventListener("pointerdown", handlePointerDown);
+      });
+    }
+    if (floating) {
+      floating.addEventListener("focusout", handleFocusOutside);
+      if (portalContext) {
+        floating.addEventListener("focusout", markInsideReactTree, true);
+        cleanups.push(() => {
+          floating.removeEventListener("focusout", markInsideReactTree, true);
+        });
+      }
+      cleanups.push(() => {
+        floating.removeEventListener("focusout", handleFocusOutside);
+      });
+    }
+    return () => {
+      cleanups.forEach((cleanup) => {
+        cleanup();
+      });
+    };
+  }, [disabled, domReference, floating, floatingFocusElement, modal, tree, portalContext, store, closeOnFocusOut, restoreFocus, getTabbableContent, isUntrappedTypeableCombobox, getNodeId, orderRef, dataRef, blurTimeout, pointerDownTimeout, restoreFocusFrame]);
+  const beforeGuardRef = React.useRef(null);
+  const afterGuardRef = React.useRef(null);
+  const mergedBeforeGuardRef = useMergedRefs(beforeGuardRef, beforeContentFocusGuardRef, portalContext?.beforeInsideRef);
+  const mergedAfterGuardRef = useMergedRefs(afterGuardRef, portalContext?.afterInsideRef);
+  React.useEffect(() => {
+    if (disabled || !floating || !open) {
+      return void 0;
+    }
+    const portalNodes = Array.from(portalContext?.portalNode?.querySelectorAll(`[${createAttribute("portal")}]`) || []);
+    const ancestors = tree ? getNodeAncestors(tree.nodesRef.current, getNodeId()) : [];
+    const rootAncestorComboboxDomReference = ancestors.find((node) => isTypeableCombobox(node.context?.elements.domReference || null))?.context?.elements.domReference;
+    const insideElements = [floating, rootAncestorComboboxDomReference, ...portalNodes, ...getInsideElements(), startDismissButtonRef.current, endDismissButtonRef.current, beforeGuardRef.current, afterGuardRef.current, portalContext?.beforeOutsideRef.current, portalContext?.afterOutsideRef.current, resolveRef(previousFocusableElement), resolveRef(nextFocusableElement), isUntrappedTypeableCombobox ? domReference : null].filter((x) => x != null);
+    const cleanup = markOthers(insideElements, modal || isUntrappedTypeableCombobox);
+    return () => {
+      cleanup();
+    };
+  }, [open, disabled, domReference, floating, modal, orderRef, portalContext, isUntrappedTypeableCombobox, tree, getNodeId, getInsideElements, nextFocusableElement, previousFocusableElement]);
+  useIsoLayoutEffect(() => {
+    if (!open || disabled || !isHTMLElement(floatingFocusElement)) {
+      return;
+    }
+    const doc = getDocument(floatingFocusElement);
+    const previouslyFocusedElement = activeElement(doc);
+    queueMicrotask(() => {
+      const focusableElements = getTabbableElements(floatingFocusElement);
+      const initialFocusValueOrFn = initialFocusRef.current;
+      const resolvedInitialFocus = typeof initialFocusValueOrFn === "function" ? initialFocusValueOrFn(openInteractionTypeRef.current || "") : initialFocusValueOrFn;
+      if (resolvedInitialFocus === void 0 || resolvedInitialFocus === false) {
+        return;
+      }
+      let elToFocus;
+      if (resolvedInitialFocus === true || resolvedInitialFocus === null) {
+        elToFocus = focusableElements[0] || floatingFocusElement;
+      } else {
+        elToFocus = resolveRef(resolvedInitialFocus);
+      }
+      elToFocus = elToFocus || focusableElements[0] || floatingFocusElement;
+      const focusAlreadyInsideFloatingEl = contains(floatingFocusElement, previouslyFocusedElement);
+      if (focusAlreadyInsideFloatingEl) {
+        return;
+      }
+      enqueueFocus(elToFocus, {
+        preventScroll: elToFocus === floatingFocusElement
+      });
+    });
+  }, [disabled, open, floatingFocusElement, ignoreInitialFocus, getTabbableElements, initialFocusRef, openInteractionTypeRef]);
+  useIsoLayoutEffect(() => {
+    if (disabled || !floatingFocusElement) {
+      return void 0;
+    }
+    const doc = getDocument(floatingFocusElement);
+    const previouslyFocusedElement = activeElement(doc);
+    addPreviouslyFocusedElement(previouslyFocusedElement);
+    function onOpenChangeLocal(details) {
+      if (!details.open) {
+        closeTypeRef.current = getEventType(details.nativeEvent, lastInteractionTypeRef.current);
+      }
+      if (details.reason === triggerHover && details.nativeEvent.type === "mouseleave") {
+        preventReturnFocusRef.current = true;
+      }
+      if (details.reason !== outsidePress) {
+        return;
+      }
+      if (details.nested) {
+        preventReturnFocusRef.current = false;
+      } else if (isVirtualClick(details.nativeEvent) || isVirtualPointerEvent(details.nativeEvent)) {
+        preventReturnFocusRef.current = false;
+      } else {
+        let isPreventScrollSupported = false;
+        document.createElement("div").focus({
+          get preventScroll() {
+            isPreventScrollSupported = true;
+            return false;
+          }
+        });
+        if (isPreventScrollSupported) {
+          preventReturnFocusRef.current = false;
+        } else {
+          preventReturnFocusRef.current = true;
+        }
+      }
+    }
+    events.on("openchange", onOpenChangeLocal);
+    const fallbackEl = doc.createElement("span");
+    fallbackEl.setAttribute("tabindex", "-1");
+    fallbackEl.setAttribute("aria-hidden", "true");
+    Object.assign(fallbackEl.style, visuallyHidden);
+    if (isInsidePortal && domReference) {
+      domReference.insertAdjacentElement("afterend", fallbackEl);
+    }
+    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;
+      }
+      if (typeof resolvedReturnFocusValue === "boolean") {
+        const el = domReference || getPreviouslyFocusedElement();
+        return el && el.isConnected ? el : fallbackEl;
+      }
+      const fallback = domReference || getPreviouslyFocusedElement() || fallbackEl;
+      return resolveRef(resolvedReturnFocusValue) || fallback;
+    }
+    return () => {
+      events.off("openchange", onOpenChangeLocal);
+      const activeEl = activeElement(doc);
+      const isFocusInsideFloatingTree = contains(floating, activeEl) || tree && getNodeChildren(tree.nodesRef.current, getNodeId(), false).some((node) => contains(node.context?.elements.floating, activeEl));
+      const returnElement = getReturnElement();
+      queueMicrotask(() => {
+        const tabbableReturnElement = getFirstTabbableElement(returnElement);
+        const hasExplicitReturnFocus = typeof returnFocusRef.current !== "boolean";
+        if (
+          // eslint-disable-next-line react-hooks/exhaustive-deps
+          returnFocusRef.current && !preventReturnFocusRef.current && isHTMLElement(tabbableReturnElement) && // If the focus moved somewhere else after mount, avoid returning focus
+          // since it likely entered a different element which should be
+          // respected: https://github.com/floating-ui/floating-ui/issues/2607
+          (!hasExplicitReturnFocus && tabbableReturnElement !== activeEl && activeEl !== doc.body ? isFocusInsideFloatingTree : true)
+        ) {
+          tabbableReturnElement.focus({
+            preventScroll: true
+          });
+        }
+        fallbackEl.remove();
+      });
+    };
+  }, [disabled, floating, floatingFocusElement, returnFocusRef, dataRef, events, tree, isInsidePortal, domReference, getNodeId]);
+  React.useEffect(() => {
+    queueMicrotask(() => {
+      preventReturnFocusRef.current = false;
+    });
+  }, [disabled]);
+  React.useEffect(() => {
+    if (disabled || !open) {
+      return void 0;
+    }
+    function handlePointerDown(event) {
+      const target = getTarget(event);
+      if (target?.closest(`[${CLICK_TRIGGER_IDENTIFIER}]`)) {
+        isPointerDownRef.current = true;
+      }
+    }
+    const doc = getDocument(floatingFocusElement);
+    doc.addEventListener("pointerdown", handlePointerDown, true);
+    return () => {
+      doc.removeEventListener("pointerdown", handlePointerDown, true);
+    };
+  }, [disabled, open, floatingFocusElement]);
+  useIsoLayoutEffect(() => {
+    if (disabled) {
+      return void 0;
+    }
+    if (!portalContext) {
+      return void 0;
+    }
+    portalContext.setFocusManagerState({
+      modal,
+      closeOnFocusOut,
+      open,
+      onOpenChange: store.setOpen,
+      domReference
+    });
+    return () => {
+      portalContext.setFocusManagerState(null);
+    };
+  }, [disabled, portalContext, modal, open, store, closeOnFocusOut, domReference]);
+  useIsoLayoutEffect(() => {
+    if (disabled || !floatingFocusElement) {
+      return void 0;
+    }
+    handleTabIndex(floatingFocusElement, orderRef);
+    return () => {
+      queueMicrotask(clearDisconnectedPreviouslyFocusedElements);
+    };
+  }, [disabled, floatingFocusElement, orderRef]);
+  const shouldRenderGuards = !disabled && (modal ? !isUntrappedTypeableCombobox : true) && (isInsidePortal || modal);
+  return /* @__PURE__ */ jsxs(React.Fragment, {
+    children: [shouldRenderGuards && /* @__PURE__ */ jsx(FocusGuard, {
+      "data-type": "inside",
+      ref: mergedBeforeGuardRef,
+      onFocus: (event) => {
+        if (modal) {
+          const els = getTabbableElements();
+          enqueueFocus(els[els.length - 1]);
+        } else if (portalContext?.portalNode) {
+          preventReturnFocusRef.current = false;
+          if (isOutsideEvent(event, portalContext.portalNode)) {
+            const nextTabbable = getNextTabbable(domReference);
+            nextTabbable?.focus();
+          } else {
+            resolveRef(previousFocusableElement ?? portalContext.beforeOutsideRef)?.focus();
+          }
+        }
+      }
+    }), children, shouldRenderGuards && /* @__PURE__ */ jsx(FocusGuard, {
+      "data-type": "inside",
+      ref: mergedAfterGuardRef,
+      onFocus: (event) => {
+        if (modal) {
+          enqueueFocus(getTabbableElements()[0]);
+        } else if (portalContext?.portalNode) {
+          if (closeOnFocusOut) {
+            preventReturnFocusRef.current = true;
+          }
+          if (isOutsideEvent(event, portalContext.portalNode)) {
+            const prevTabbable = getPreviousTabbable(domReference);
+            prevTabbable?.focus();
+          } else {
+            resolveRef(nextFocusableElement ?? portalContext.afterOutsideRef)?.focus();
+          }
+        }
+      }
+    })]
+  });
+}
+export {
+  FloatingFocusManager
+};
+//# sourceMappingURL=FloatingFocusManager.js.map

package/dist/node_modules/@base-ui/react/esm/floating-ui-react/components/FloatingFocusManager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FloatingFocusManager.js","sources":["../../../../../../../node_modules/@base-ui/react/esm/floating-ui-react/components/FloatingFocusManager.js"],"sourcesContent":["'use client';\n\nimport * as React from 'react';\nimport { tabbable, isTabbable, focusable } from 'tabbable';\nimport { getComputedStyle, getNodeName, isHTMLElement } from '@floating-ui/utils/dom';\nimport { useMergedRefs } from '@base-ui/utils/useMergedRefs';\nimport { useValueAsRef } from '@base-ui/utils/useValueAsRef';\nimport { useStableCallback } from '@base-ui/utils/useStableCallback';\nimport { useIsoLayoutEffect } from '@base-ui/utils/useIsoLayoutEffect';\nimport { visuallyHidden } from '@base-ui/utils/visuallyHidden';\nimport { useTimeout } from '@base-ui/utils/useTimeout';\nimport { useAnimationFrame } from '@base-ui/utils/useAnimationFrame';\nimport { ownerWindow } from '@base-ui/utils/owner';\nimport { FocusGuard } from \"../../utils/FocusGuard.js\";\nimport { activeElement, contains, getDocument, getTarget, isTypeableCombobox, isVirtualClick, isVirtualPointerEvent, stopEvent, getNodeAncestors, getNodeChildren, getFloatingFocusElement, getTabbableOptions, isOutsideEvent, getNextTabbable, getPreviousTabbable } from \"../utils.js\";\nimport { createChangeEventDetails } from \"../../utils/createBaseUIEventDetails.js\";\nimport { REASONS } from \"../../utils/reasons.js\";\nimport { createAttribute } from \"../utils/createAttribute.js\";\nimport { enqueueFocus } from \"../utils/enqueueFocus.js\";\nimport { markOthers } from \"../utils/markOthers.js\";\nimport { usePortalContext } from \"./FloatingPortal.js\";\nimport { useFloatingTree } from \"./FloatingTree.js\";\nimport { CLICK_TRIGGER_IDENTIFIER } from \"../../utils/constants.js\";\nimport { resolveRef } from \"../../utils/resolveRef.js\";\nimport { jsx as _jsx, jsxs as _jsxs } from \"react/jsx-runtime\";\nfunction getEventType(event, lastInteractionType) {\n  const win = ownerWindow(event.target);\n  if (event instanceof win.KeyboardEvent) {\n    return 'keyboard';\n  }\n  if (event instanceof win.FocusEvent) {\n    // Focus events can be caused by a preceding pointer interaction (e.g., focusout on outside press).\n    // Prefer the last known pointer type if provided, else treat as keyboard.\n    return lastInteractionType || 'keyboard';\n  }\n  if ('pointerType' in event) {\n    return event.pointerType || 'keyboard';\n  }\n  if ('touches' in event) {\n    return 'touch';\n  }\n  if (event instanceof win.MouseEvent) {\n    // onClick events may not contain pointer events, and will fall through to here\n    return lastInteractionType || (event.detail === 0 ? 'keyboard' : 'mouse');\n  }\n  return '';\n}\nconst LIST_LIMIT = 20;\nlet previouslyFocusedElements = [];\nfunction clearDisconnectedPreviouslyFocusedElements() {\n  previouslyFocusedElements = previouslyFocusedElements.filter(el => el.isConnected);\n}\nfunction addPreviouslyFocusedElement(element) {\n  clearDisconnectedPreviouslyFocusedElements();\n  if (element && getNodeName(element) !== 'body') {\n    previouslyFocusedElements.push(element);\n    if (previouslyFocusedElements.length > LIST_LIMIT) {\n      previouslyFocusedElements = previouslyFocusedElements.slice(-LIST_LIMIT);\n    }\n  }\n}\nfunction getPreviouslyFocusedElement() {\n  clearDisconnectedPreviouslyFocusedElements();\n  return previouslyFocusedElements[previouslyFocusedElements.length - 1];\n}\nfunction getFirstTabbableElement(container) {\n  if (!container) {\n    return null;\n  }\n  const tabbableOptions = getTabbableOptions();\n  if (isTabbable(container, tabbableOptions)) {\n    return container;\n  }\n  return tabbable(container, tabbableOptions)[0] || container;\n}\nfunction isFocusable(element) {\n  if (!element || !element.isConnected) {\n    return false;\n  }\n  if (typeof element.checkVisibility === 'function') {\n    return element.checkVisibility();\n  }\n  return getComputedStyle(element).display !== 'none';\n}\nfunction handleTabIndex(floatingFocusElement, orderRef) {\n  if (!orderRef.current.includes('floating') && !floatingFocusElement.getAttribute('role')?.includes('dialog')) {\n    return;\n  }\n  const options = getTabbableOptions();\n  const focusableElements = focusable(floatingFocusElement, options);\n  const tabbableContent = focusableElements.filter(element => {\n    const dataTabIndex = element.getAttribute('data-tabindex') || '';\n    return isTabbable(element, options) || element.hasAttribute('data-tabindex') && !dataTabIndex.startsWith('-');\n  });\n  const tabIndex = floatingFocusElement.getAttribute('tabindex');\n  if (orderRef.current.includes('floating') || tabbableContent.length === 0) {\n    if (tabIndex !== '0') {\n      floatingFocusElement.setAttribute('tabindex', '0');\n    }\n  } else if (tabIndex !== '-1' || floatingFocusElement.hasAttribute('data-tabindex') && floatingFocusElement.getAttribute('data-tabindex') !== '-1') {\n    floatingFocusElement.setAttribute('tabindex', '-1');\n    floatingFocusElement.setAttribute('data-tabindex', '-1');\n  }\n}\n/**\n * Provides focus management for the floating element.\n * @see https://floating-ui.com/docs/FloatingFocusManager\n * @internal\n */\nexport function FloatingFocusManager(props) {\n  const {\n    context,\n    children,\n    disabled = false,\n    order = ['content'],\n    initialFocus = true,\n    returnFocus = true,\n    restoreFocus = false,\n    modal = true,\n    closeOnFocusOut = true,\n    openInteractionType = '',\n    getInsideElements: getInsideElementsProp = () => [],\n    nextFocusableElement,\n    previousFocusableElement,\n    beforeContentFocusGuardRef,\n    externalTree\n  } = props;\n  const store = 'rootStore' in context ? context.rootStore : context;\n  const open = store.useState('open');\n  const domReference = store.useState('domReferenceElement');\n  const floating = store.useState('floatingElement');\n  const {\n    events,\n    dataRef\n  } = store.context;\n  const getNodeId = useStableCallback(() => dataRef.current.floatingContext?.nodeId);\n  const getInsideElements = useStableCallback(getInsideElementsProp);\n  const ignoreInitialFocus = initialFocus === false;\n  // If the reference is a combobox and is typeable (e.g. input/textarea),\n  // there are different focus semantics. The guards should not be rendered, but\n  // aria-hidden should be applied to all nodes still. Further, the visually\n  // hidden dismiss button should only appear at the end of the list, not the\n  // start.\n  const isUntrappedTypeableCombobox = isTypeableCombobox(domReference) && ignoreInitialFocus;\n  const orderRef = useValueAsRef(order);\n  const initialFocusRef = useValueAsRef(initialFocus);\n  const returnFocusRef = useValueAsRef(returnFocus);\n  const openInteractionTypeRef = useValueAsRef(openInteractionType);\n  const tree = useFloatingTree(externalTree);\n  const portalContext = usePortalContext();\n  const startDismissButtonRef = React.useRef(null);\n  const endDismissButtonRef = React.useRef(null);\n  const preventReturnFocusRef = React.useRef(false);\n  const isPointerDownRef = React.useRef(false);\n  const pointerDownOutsideRef = React.useRef(false);\n  const tabbableIndexRef = React.useRef(-1);\n  const closeTypeRef = React.useRef('');\n  const lastInteractionTypeRef = React.useRef('');\n  const blurTimeout = useTimeout();\n  const pointerDownTimeout = useTimeout();\n  const restoreFocusFrame = useAnimationFrame();\n  const isInsidePortal = portalContext != null;\n  const floatingFocusElement = getFloatingFocusElement(floating);\n  const getTabbableContent = useStableCallback((container = floatingFocusElement) => {\n    return container ? tabbable(container, getTabbableOptions()) : [];\n  });\n  const getTabbableElements = useStableCallback(container => {\n    const content = getTabbableContent(container);\n    return orderRef.current.map(() => content).filter(Boolean).flat();\n  });\n  React.useEffect(() => {\n    if (disabled) {\n      return undefined;\n    }\n    if (!modal) {\n      return undefined;\n    }\n    function onKeyDown(event) {\n      if (event.key === 'Tab') {\n        // The focus guards have nothing to focus, so we need to stop the event.\n        if (contains(floatingFocusElement, activeElement(getDocument(floatingFocusElement))) && getTabbableContent().length === 0 && !isUntrappedTypeableCombobox) {\n          stopEvent(event);\n        }\n      }\n    }\n    const doc = getDocument(floatingFocusElement);\n    doc.addEventListener('keydown', onKeyDown);\n    return () => {\n      doc.removeEventListener('keydown', onKeyDown);\n    };\n  }, [disabled, domReference, floatingFocusElement, modal, orderRef, isUntrappedTypeableCombobox, getTabbableContent, getTabbableElements]);\n  React.useEffect(() => {\n    if (disabled) {\n      return undefined;\n    }\n    if (!floating) {\n      return undefined;\n    }\n    function handleFocusIn(event) {\n      const target = getTarget(event);\n      const tabbableContent = getTabbableContent();\n      const tabbableIndex = tabbableContent.indexOf(target);\n      if (tabbableIndex !== -1) {\n        tabbableIndexRef.current = tabbableIndex;\n      }\n    }\n    floating.addEventListener('focusin', handleFocusIn);\n    return () => {\n      floating.removeEventListener('focusin', handleFocusIn);\n    };\n  }, [disabled, floating, getTabbableContent]);\n\n  // Track the last interaction type at the document level to disambiguate focus events\n  React.useEffect(() => {\n    if (disabled || !open) {\n      return undefined;\n    }\n    const doc = getDocument(floatingFocusElement);\n    function clearPointerDownOutside() {\n      pointerDownOutsideRef.current = false;\n    }\n    function onPointerDown(event) {\n      const target = getTarget(event);\n      const pointerTargetInside = contains(floating, target) || contains(domReference, target) || contains(portalContext?.portalNode, target);\n      pointerDownOutsideRef.current = !pointerTargetInside;\n      lastInteractionTypeRef.current = event.pointerType || 'keyboard';\n    }\n    function onKeyDown() {\n      lastInteractionTypeRef.current = 'keyboard';\n    }\n    doc.addEventListener('pointerdown', onPointerDown, true);\n    doc.addEventListener('pointerup', clearPointerDownOutside, true);\n    doc.addEventListener('pointercancel', clearPointerDownOutside, true);\n    doc.addEventListener('keydown', onKeyDown, true);\n    return () => {\n      doc.removeEventListener('pointerdown', onPointerDown, true);\n      doc.removeEventListener('pointerup', clearPointerDownOutside, true);\n      doc.removeEventListener('pointercancel', clearPointerDownOutside, true);\n      doc.removeEventListener('keydown', onKeyDown, true);\n    };\n  }, [disabled, floating, domReference, floatingFocusElement, open, portalContext]);\n  React.useEffect(() => {\n    if (disabled) {\n      return undefined;\n    }\n    if (!closeOnFocusOut) {\n      return undefined;\n    }\n\n    // In Safari, buttons lose focus when pressing them.\n    function handlePointerDown() {\n      isPointerDownRef.current = true;\n      pointerDownTimeout.start(0, () => {\n        isPointerDownRef.current = false;\n      });\n    }\n    function handleFocusOutside(event) {\n      const relatedTarget = event.relatedTarget;\n      const currentTarget = event.currentTarget;\n      const target = getTarget(event);\n      queueMicrotask(() => {\n        const nodeId = getNodeId();\n        const triggers = store.context.triggerElements;\n        const movedToUnrelatedNode = !(contains(domReference, relatedTarget) || contains(floating, relatedTarget) || contains(relatedTarget, floating) || contains(portalContext?.portalNode, relatedTarget) || relatedTarget != null && triggers.hasElement(relatedTarget) || triggers.hasMatchingElement(trigger => contains(trigger, relatedTarget)) || relatedTarget?.hasAttribute(createAttribute('focus-guard')) || tree && (getNodeChildren(tree.nodesRef.current, nodeId).find(node => contains(node.context?.elements.floating, relatedTarget) || contains(node.context?.elements.domReference, relatedTarget)) || getNodeAncestors(tree.nodesRef.current, nodeId).find(node => [node.context?.elements.floating, getFloatingFocusElement(node.context?.elements.floating)].includes(relatedTarget) || node.context?.elements.domReference === relatedTarget)));\n        if (currentTarget === domReference && floatingFocusElement) {\n          handleTabIndex(floatingFocusElement, orderRef);\n        }\n\n        // Restore focus to the previous tabbable element index to prevent\n        // focus from being lost outside the floating tree.\n        if (restoreFocus && currentTarget !== domReference && !isFocusable(target) && activeElement(getDocument(floatingFocusElement)) === getDocument(floatingFocusElement).body) {\n          // Let `FloatingPortal` effect knows that focus is still inside the\n          // floating tree.\n          if (isHTMLElement(floatingFocusElement)) {\n            floatingFocusElement.focus();\n            // If explicitly requested to restore focus to the popup container, do not search\n            // for the next/previous tabbable element.\n            if (restoreFocus === 'popup') {\n              // If the element is removed on pointerdown, focus tries to move it,\n              // but since it's removed at the same time, focus gets lost as it\n              // happens after the .focus() call above.\n              // In this case, focus needs to be moved asynchronously.\n              restoreFocusFrame.request(() => {\n                floatingFocusElement.focus();\n              });\n              return;\n            }\n          }\n          const prevTabbableIndex = tabbableIndexRef.current;\n          const tabbableContent = getTabbableContent();\n          const nodeToFocus = tabbableContent[prevTabbableIndex] || tabbableContent[tabbableContent.length - 1] || floatingFocusElement;\n          if (isHTMLElement(nodeToFocus)) {\n            nodeToFocus.focus();\n          }\n        }\n\n        // https://github.com/floating-ui/floating-ui/issues/3060\n        if (dataRef.current.insideReactTree) {\n          dataRef.current.insideReactTree = false;\n          return;\n        }\n\n        // Focus did not move inside the floating tree, and there are no tabbable\n        // portal guards to handle closing.\n        if ((isUntrappedTypeableCombobox ? true : !modal) && relatedTarget && movedToUnrelatedNode && !isPointerDownRef.current && (\n        // Fix React 18 Strict Mode returnFocus due to double rendering.\n        // For an \"untrapped\" typeable combobox (input role=combobox with\n        // initialFocus=false), re-opening the popup and tabbing out should still close it even\n        // when the previously focused element (e.g. the next tabbable outside the popup) is\n        // focused again. Otherwise, the popup remains open on the second Tab sequence:\n        // click input -> Tab (closes) -> click input -> Tab.\n        // Allow closing when `isUntrappedTypeableCombobox` regardless of the previously focused element.\n        isUntrappedTypeableCombobox || relatedTarget !== getPreviouslyFocusedElement())) {\n          preventReturnFocusRef.current = true;\n          store.setOpen(false, createChangeEventDetails(REASONS.focusOut, event));\n        }\n      });\n    }\n    function markInsideReactTree() {\n      if (pointerDownOutsideRef.current) {\n        return;\n      }\n      dataRef.current.insideReactTree = true;\n      blurTimeout.start(0, () => {\n        dataRef.current.insideReactTree = false;\n      });\n    }\n    const domReferenceElement = isHTMLElement(domReference) ? domReference : null;\n    const cleanups = [];\n    if (!floating && !domReferenceElement) {\n      return undefined;\n    }\n    if (domReferenceElement) {\n      domReferenceElement.addEventListener('focusout', handleFocusOutside);\n      domReferenceElement.addEventListener('pointerdown', handlePointerDown);\n      cleanups.push(() => {\n        domReferenceElement.removeEventListener('focusout', handleFocusOutside);\n        domReferenceElement.removeEventListener('pointerdown', handlePointerDown);\n      });\n    }\n    if (floating) {\n      floating.addEventListener('focusout', handleFocusOutside);\n      if (portalContext) {\n        floating.addEventListener('focusout', markInsideReactTree, true);\n        cleanups.push(() => {\n          floating.removeEventListener('focusout', markInsideReactTree, true);\n        });\n      }\n      cleanups.push(() => {\n        floating.removeEventListener('focusout', handleFocusOutside);\n      });\n    }\n    return () => {\n      cleanups.forEach(cleanup => {\n        cleanup();\n      });\n    };\n  }, [disabled, domReference, floating, floatingFocusElement, modal, tree, portalContext, store, closeOnFocusOut, restoreFocus, getTabbableContent, isUntrappedTypeableCombobox, getNodeId, orderRef, dataRef, blurTimeout, pointerDownTimeout, restoreFocusFrame]);\n  const beforeGuardRef = React.useRef(null);\n  const afterGuardRef = React.useRef(null);\n  const mergedBeforeGuardRef = useMergedRefs(beforeGuardRef, beforeContentFocusGuardRef, portalContext?.beforeInsideRef);\n  const mergedAfterGuardRef = useMergedRefs(afterGuardRef, portalContext?.afterInsideRef);\n  React.useEffect(() => {\n    if (disabled || !floating || !open) {\n      return undefined;\n    }\n\n    // Don't hide portals nested within the parent portal.\n    const portalNodes = Array.from(portalContext?.portalNode?.querySelectorAll(`[${createAttribute('portal')}]`) || []);\n    const ancestors = tree ? getNodeAncestors(tree.nodesRef.current, getNodeId()) : [];\n    const rootAncestorComboboxDomReference = ancestors.find(node => isTypeableCombobox(node.context?.elements.domReference || null))?.context?.elements.domReference;\n    const insideElements = [floating, rootAncestorComboboxDomReference, ...portalNodes, ...getInsideElements(), startDismissButtonRef.current, endDismissButtonRef.current, beforeGuardRef.current, afterGuardRef.current, portalContext?.beforeOutsideRef.current, portalContext?.afterOutsideRef.current, resolveRef(previousFocusableElement), resolveRef(nextFocusableElement), isUntrappedTypeableCombobox ? domReference : null].filter(x => x != null);\n    const cleanup = markOthers(insideElements, modal || isUntrappedTypeableCombobox);\n    return () => {\n      cleanup();\n    };\n  }, [open, disabled, domReference, floating, modal, orderRef, portalContext, isUntrappedTypeableCombobox, tree, getNodeId, getInsideElements, nextFocusableElement, previousFocusableElement]);\n  useIsoLayoutEffect(() => {\n    if (!open || disabled || !isHTMLElement(floatingFocusElement)) {\n      return;\n    }\n    const doc = getDocument(floatingFocusElement);\n    const previouslyFocusedElement = activeElement(doc);\n\n    // Wait for any layout effect state setters to execute to set `tabIndex`.\n    queueMicrotask(() => {\n      const focusableElements = getTabbableElements(floatingFocusElement);\n      const initialFocusValueOrFn = initialFocusRef.current;\n      const resolvedInitialFocus = typeof initialFocusValueOrFn === 'function' ? initialFocusValueOrFn(openInteractionTypeRef.current || '') : initialFocusValueOrFn;\n\n      // `null` should fallback to default behavior in case of an empty ref.\n      if (resolvedInitialFocus === undefined || resolvedInitialFocus === false) {\n        return;\n      }\n      let elToFocus;\n      if (resolvedInitialFocus === true || resolvedInitialFocus === null) {\n        elToFocus = focusableElements[0] || floatingFocusElement;\n      } else {\n        elToFocus = resolveRef(resolvedInitialFocus);\n      }\n      elToFocus = elToFocus || focusableElements[0] || floatingFocusElement;\n      const focusAlreadyInsideFloatingEl = contains(floatingFocusElement, previouslyFocusedElement);\n      if (focusAlreadyInsideFloatingEl) {\n        return;\n      }\n      enqueueFocus(elToFocus, {\n        preventScroll: elToFocus === floatingFocusElement\n      });\n    });\n  }, [disabled, open, floatingFocusElement, ignoreInitialFocus, getTabbableElements, initialFocusRef, openInteractionTypeRef]);\n  useIsoLayoutEffect(() => {\n    if (disabled || !floatingFocusElement) {\n      return undefined;\n    }\n    const doc = getDocument(floatingFocusElement);\n    const previouslyFocusedElement = activeElement(doc);\n    addPreviouslyFocusedElement(previouslyFocusedElement);\n\n    // Dismissing via outside press should always ignore `returnFocus` to\n    // prevent unwanted scrolling.\n    function onOpenChangeLocal(details) {\n      if (!details.open) {\n        closeTypeRef.current = getEventType(details.nativeEvent, lastInteractionTypeRef.current);\n      }\n      if (details.reason === REASONS.triggerHover && details.nativeEvent.type === 'mouseleave') {\n        preventReturnFocusRef.current = true;\n      }\n      if (details.reason !== REASONS.outsidePress) {\n        return;\n      }\n      if (details.nested) {\n        preventReturnFocusRef.current = false;\n      } else if (isVirtualClick(details.nativeEvent) || isVirtualPointerEvent(details.nativeEvent)) {\n        preventReturnFocusRef.current = false;\n      } else {\n        let isPreventScrollSupported = false;\n        document.createElement('div').focus({\n          get preventScroll() {\n            isPreventScrollSupported = true;\n            return false;\n          }\n        });\n        if (isPreventScrollSupported) {\n          preventReturnFocusRef.current = false;\n        } else {\n          preventReturnFocusRef.current = true;\n        }\n      }\n    }\n    events.on('openchange', onOpenChangeLocal);\n    const fallbackEl = doc.createElement('span');\n    fallbackEl.setAttribute('tabindex', '-1');\n    fallbackEl.setAttribute('aria-hidden', 'true');\n    Object.assign(fallbackEl.style, visuallyHidden);\n    if (isInsidePortal && domReference) {\n      domReference.insertAdjacentElement('afterend', fallbackEl);\n    }\n    function getReturnElement() {\n      const returnFocusValueOrFn = returnFocusRef.current;\n      let resolvedReturnFocusValue = typeof returnFocusValueOrFn === 'function' ? returnFocusValueOrFn(closeTypeRef.current) : returnFocusValueOrFn;\n\n      // `null` should fallback to default behavior in case of an empty ref.\n      if (resolvedReturnFocusValue === undefined || resolvedReturnFocusValue === false) {\n        return null;\n      }\n      if (resolvedReturnFocusValue === null) {\n        resolvedReturnFocusValue = true;\n      }\n      if (typeof resolvedReturnFocusValue === 'boolean') {\n        const el = domReference || getPreviouslyFocusedElement();\n        return el && el.isConnected ? el : fallbackEl;\n      }\n      const fallback = domReference || getPreviouslyFocusedElement() || fallbackEl;\n      return resolveRef(resolvedReturnFocusValue) || fallback;\n    }\n    return () => {\n      events.off('openchange', onOpenChangeLocal);\n      const activeEl = activeElement(doc);\n      const isFocusInsideFloatingTree = contains(floating, activeEl) || tree && getNodeChildren(tree.nodesRef.current, getNodeId(), false).some(node => contains(node.context?.elements.floating, activeEl));\n      const returnElement = getReturnElement();\n      queueMicrotask(() => {\n        // This is `returnElement`, if it's tabbable, or its first tabbable child.\n        const tabbableReturnElement = getFirstTabbableElement(returnElement);\n        const hasExplicitReturnFocus = typeof returnFocusRef.current !== 'boolean';\n        if (\n        // eslint-disable-next-line react-hooks/exhaustive-deps\n        returnFocusRef.current && !preventReturnFocusRef.current && isHTMLElement(tabbableReturnElement) && (\n        // If the focus moved somewhere else after mount, avoid returning focus\n        // since it likely entered a different element which should be\n        // respected: https://github.com/floating-ui/floating-ui/issues/2607\n        !hasExplicitReturnFocus && tabbableReturnElement !== activeEl && activeEl !== doc.body ? isFocusInsideFloatingTree : true)) {\n          tabbableReturnElement.focus({\n            preventScroll: true\n          });\n        }\n        fallbackEl.remove();\n      });\n    };\n  }, [disabled, floating, floatingFocusElement, returnFocusRef, dataRef, events, tree, isInsidePortal, domReference, getNodeId]);\n  React.useEffect(() => {\n    // The `returnFocus` cleanup behavior is inside a microtask; ensure we\n    // wait for it to complete before resetting the flag.\n    queueMicrotask(() => {\n      preventReturnFocusRef.current = false;\n    });\n  }, [disabled]);\n  React.useEffect(() => {\n    if (disabled || !open) {\n      return undefined;\n    }\n    function handlePointerDown(event) {\n      const target = getTarget(event);\n      if (target?.closest(`[${CLICK_TRIGGER_IDENTIFIER}]`)) {\n        isPointerDownRef.current = true;\n      }\n    }\n    const doc = getDocument(floatingFocusElement);\n    doc.addEventListener('pointerdown', handlePointerDown, true);\n    return () => {\n      doc.removeEventListener('pointerdown', handlePointerDown, true);\n    };\n  }, [disabled, open, floatingFocusElement]);\n\n  // Synchronize the `context` & `modal` value to the FloatingPortal context.\n  // It will decide whether or not it needs to render its own guards.\n  useIsoLayoutEffect(() => {\n    if (disabled) {\n      return undefined;\n    }\n    if (!portalContext) {\n      return undefined;\n    }\n    portalContext.setFocusManagerState({\n      modal,\n      closeOnFocusOut,\n      open,\n      onOpenChange: store.setOpen,\n      domReference\n    });\n    return () => {\n      portalContext.setFocusManagerState(null);\n    };\n  }, [disabled, portalContext, modal, open, store, closeOnFocusOut, domReference]);\n  useIsoLayoutEffect(() => {\n    if (disabled || !floatingFocusElement) {\n      return undefined;\n    }\n    handleTabIndex(floatingFocusElement, orderRef);\n    return () => {\n      queueMicrotask(clearDisconnectedPreviouslyFocusedElements);\n    };\n  }, [disabled, floatingFocusElement, orderRef]);\n  const shouldRenderGuards = !disabled && (modal ? !isUntrappedTypeableCombobox : true) && (isInsidePortal || modal);\n  return /*#__PURE__*/_jsxs(React.Fragment, {\n    children: [shouldRenderGuards && /*#__PURE__*/_jsx(FocusGuard, {\n      \"data-type\": \"inside\",\n      ref: mergedBeforeGuardRef,\n      onFocus: event => {\n        if (modal) {\n          const els = getTabbableElements();\n          enqueueFocus(els[els.length - 1]);\n        } else if (portalContext?.portalNode) {\n          preventReturnFocusRef.current = false;\n          if (isOutsideEvent(event, portalContext.portalNode)) {\n            const nextTabbable = getNextTabbable(domReference);\n            nextTabbable?.focus();\n          } else {\n            resolveRef(previousFocusableElement ?? portalContext.beforeOutsideRef)?.focus();\n          }\n        }\n      }\n    }), children, shouldRenderGuards && /*#__PURE__*/_jsx(FocusGuard, {\n      \"data-type\": \"inside\",\n      ref: mergedAfterGuardRef,\n      onFocus: event => {\n        if (modal) {\n          enqueueFocus(getTabbableElements()[0]);\n        } else if (portalContext?.portalNode) {\n          if (closeOnFocusOut) {\n            preventReturnFocusRef.current = true;\n          }\n          if (isOutsideEvent(event, portalContext.portalNode)) {\n            const prevTabbable = getPreviousTabbable(domReference);\n            prevTabbable?.focus();\n          } else {\n            resolveRef(nextFocusableElement ?? portalContext.afterOutsideRef)?.focus();\n          }\n        }\n      }\n    })]\n  });\n}"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAyBA;AACE;AACA;AACE;AAAO;AAET;AAGE;AAA8B;AAEhC;AACE;AAA4B;AAE9B;AACE;AAAO;AAET;AAEE;AAAiE;AAEnE;AACF;AACA;AACA;AACA;AACE;AACF;AACA;AACE;AACA;AACE;AACA;AACE;AAAuE;AACzE;AAEJ;AACA;AACE;AACA;AACF;AACA;AACE;AACE;AAAO;AAET;AACA;AACE;AAAO;AAET;AACF;AACA;AACE;AACE;AAAO;AAET;AACE;AAA8B;AAEhC;AACF;AACA;AACE;AACE;AAAA;AAEF;AACA;AACA;AACE;AACA;AAA4G;AAE9G;AACA;AACE;AACE;AAAiD;AACnD;AAEA;AACA;AAAuD;AAE3D;AAMO;AACL;AAAM;AACJ;AACA;AACW;AACO;AACH;AACD;AACC;AACP;AACU;AACI;AAC2B;AACjD;AACA;AACA;AACA;AAEF;AACA;AACA;AACA;AACA;AAAM;AACJ;AACA;AAEF;AACA;AACA;AAMA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACE;AAA+D;AAEjE;AACE;AACA;AAA+D;AAEjE;AACE;AACE;AAAO;AAET;AACE;AAAO;AAET;AACE;AAEE;AACE;AAAe;AACjB;AACF;AAEF;AACA;AACA;AACE;AAA4C;AAC9C;AAEF;AACE;AACE;AAAO;AAET;AACE;AAAO;AAET;AACE;AACA;AACA;AACA;AACE;AAA2B;AAC7B;AAEF;AACA;AACE;AAAqD;AACvD;AAIF;AACE;AACE;AAAO;AAET;AACA;AACE;AAAgC;AAElC;AACE;AACA;AACA;AACA;AAAsD;AAExD;AACE;AAAiC;AAEnC;AACA;AACA;AACA;AACA;AACE;AACA;AACA;AACA;AAAkD;AACpD;AAEF;AACE;AACE;AAAO;AAET;AACE;AAAO;AAIT;AACE;AACA;AACE;AAA2B;AAC5B;AAEH;AACE;AACA;AACA;AACA;AACE;AACA;AACA;AACA;AACE;AAA6C;AAK/C;AAGE;AACE;AAGA;AAKE;AACE;AAA0B;AAE5B;AAAA;AACF;AAEF;AACA;AACA;AACA;AACE;AAAiB;AACnB;AAIF;AACE;AACA;AAAA;AAKF;AAAgH;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAS9G;AACA;AAAsE;AACxE;AACD;AAEH;AACE;AACE;AAAA;AAEF;AACA;AACE;AAAkC;AACnC;AAEH;AACA;AACA;AACE;AAAO;AAET;AACE;AACA;AACA;AACE;AACA;AAAwE;AACzE;AAEH;AACE;AACA;AACE;AACA;AACE;AAAkE;AACnE;AAEH;AACE;AAA2D;AAC5D;AAEH;AACE;AACE;AAAO;AACR;AACH;AAEF;AACA;AACA;AACA;AACA;AACE;AACE;AAAO;AAIT;AACA;AACA;AACA;AACA;AACA;AACE;AAAO;AACT;AAEF;AACE;AACE;AAAA;AAEF;AACA;AAGA;AACE;AACA;AACA;AAGA;AACE;AAAA;AAEF;AACA;AACE;AAAoC;AAEpC;AAA2C;AAE7C;AACA;AACA;AACE;AAAA;AAEF;AAAwB;AACO;AAC9B;AACF;AAEH;AACE;AACE;AAAO;AAET;AACA;AACA;AAIA;AACE;AACE;AAAuF;AAEzF;AACE;AAAgC;AAElC;AACE;AAAA;AAEF;AACE;AAAgC;AAEhC;AAAgC;AAEhC;AACA;AAAoC;AAEhC;AACA;AAAO;AACT;AAEF;AACE;AAAgC;AAEhC;AAAgC;AAClC;AACF;AAEF;AACA;AACA;AACA;AACA;AACA;AACE;AAAyD;AAE3D;AACE;AACA;AAGA;AACE;AAAO;AAET;AACE;AAA2B;AAE7B;AACE;AACA;AAAmC;AAErC;AACA;AAA+C;AAEjD;AACE;AACA;AACA;AACA;AACA;AAEE;AACA;AACA;AAAA;AAAA;AAE+F;AAAA;AAAA;AAIsB;AACnH;AAA4B;AACX;AAChB;AAEH;AAAiB;AAClB;AACH;AAEF;AAGE;AACE;AAAgC;AACjC;AAEH;AACE;AACE;AAAO;AAET;AACE;AACA;AACE;AAA2B;AAC7B;AAEF;AACA;AACA;AACE;AAA8D;AAChE;AAKF;AACE;AACE;AAAO;AAET;AACE;AAAO;AAET;AAAmC;AACjC;AACA;AACA;AACoB;AACpB;AAEF;AACE;AAAuC;AACzC;AAEF;AACE;AACE;AAAO;AAET;AACA;AACE;AAAyD;AAC3D;AAEF;AACA;AAA0C;AACuB;AAChD;AACR;AAEH;AACE;AACA;AAAgC;AAEhC;AACA;AACE;AACA;AAAmB;AAEnB;AAA6E;AAC/E;AACF;AACF;AACgE;AACnD;AACR;AAEH;AACE;AAAqC;AAErC;AACE;AAAgC;AAElC;AACE;AACA;AAAmB;AAEnB;AAAwE;AAC1E;AACF;AACF;AACA;AAEN;;;;","x_google_ignoreList":[0]}