dune-react 0.0.1 → 0.0.2

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/navigation-menu/trigger/NavigationMenuTrigger.js

@@ -0,0 +1,633 @@
+import * as React from "react";
+import * as ReactDOM from "react-dom";
+import { getWindow, isHTMLElement } from "../../../../../../../@floating-ui_utils@0.2.11/node_modules/@floating-ui/utils/dist/floating-ui.utils.dom.js";
+import { isTabbable } from "../../../../../../../tabbable@6.4.0/node_modules/tabbable/dist/index.esm.js";
+import { useIsoLayoutEffect } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/useIsoLayoutEffect.js";
+import { useStableCallback } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/useStableCallback.js";
+import { useTimeout } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/useTimeout.js";
+import { useAnimationFrame } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/useAnimationFrame.js";
+import { useValueAsRef } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/useValueAsRef.js";
+import { isWebKit } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/detectBrowser.js";
+import { useHoverInteractionSharedState, clearSafePolygonPointerEventsMutation, applySafePolygonPointerEventsMutation } from "../../floating-ui-react/hooks/useHoverInteractionSharedState.js";
+import { useNavigationMenuItemContext } from "../item/NavigationMenuItemContext.js";
+import { useNavigationMenuRootContext, useNavigationMenuTreeContext } from "../root/NavigationMenuRootContext.js";
+import { createChangeEventDetails } from "../../utils/createBaseUIEventDetails.js";
+import { ownerVisuallyHidden, PATIENT_CLICK_THRESHOLD } from "../../utils/constants.js";
+import { FocusGuard } from "../../utils/FocusGuard.js";
+import { pressableTriggerOpenStateMapping } from "../../utils/popupStateMapping.js";
+import { TransitionStatusDataAttributes } from "../../utils/stateAttributesMapping.js";
+import { isOutsideMenuEvent } from "../utils/isOutsideMenuEvent.js";
+import { CompositeItem } from "../../composite/item/CompositeItem.js";
+import { useAnimationsFinished } from "../../utils/useAnimationsFinished.js";
+import { getCssDimensions } from "../../utils/getCssDimensions.js";
+import { NAVIGATION_MENU_TRIGGER_IDENTIFIER } from "../utils/constants.js";
+import { useNavigationMenuDismissContext } from "../list/NavigationMenuDismissContext.js";
+import { NavigationMenuPopupCssVars } from "../popup/NavigationMenuPopupCssVars.js";
+import { NavigationMenuPositionerCssVars } from "../positioner/NavigationMenuPositionerCssVars.js";
+import { jsxs, jsx } from "react/jsx-runtime";
+import { useFloatingTree } from "../../floating-ui-react/components/FloatingTree.js";
+import { useFloatingRootContext } from "../../floating-ui-react/hooks/useFloatingRootContext.js";
+import { useHoverReferenceInteraction } from "../../floating-ui-react/hooks/useHoverReferenceInteraction.js";
+import { safePolygon } from "../../floating-ui-react/safePolygon.js";
+import { useClick } from "../../floating-ui-react/hooks/useClick.js";
+import { useInteractions } from "../../floating-ui-react/hooks/useInteractions.js";
+import { useButton } from "../../use-button/useButton.js";
+import { EMPTY_ARRAY } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/empty.js";
+import { isOutsideEvent, getPreviousTabbable, getNextTabbable, getTabbableAfterElement } from "../../floating-ui-react/utils/tabbable.js";
+import { contains } from "../../floating-ui-react/utils/element.js";
+import { focusOut, triggerHover, triggerPress, listNavigation } from "../../utils/reason-parts.js";
+import { stopEvent } from "../../floating-ui-react/utils/event.js";
+const DEFAULT_SIZE = {
+  width: 0,
+  height: 0
+};
+const NavigationMenuTrigger = /* @__PURE__ */ React.forwardRef(function NavigationMenuTrigger2(componentProps, forwardedRef) {
+  const {
+    className,
+    render,
+    nativeButton = true,
+    disabled,
+    ...elementProps
+  } = componentProps;
+  const {
+    value,
+    setValue,
+    mounted,
+    open,
+    positionerElement,
+    setActivationDirection,
+    setFloatingRootContext,
+    popupElement,
+    viewportElement,
+    transitionStatus,
+    rootRef,
+    beforeOutsideRef,
+    afterOutsideRef,
+    afterInsideRef,
+    beforeInsideRef,
+    prevTriggerElementRef,
+    currentContentRef,
+    delay,
+    closeDelay,
+    orientation,
+    setViewportInert,
+    nested
+  } = useNavigationMenuRootContext();
+  const {
+    value: itemValue
+  } = useNavigationMenuItemContext();
+  const nodeId = useNavigationMenuTreeContext();
+  const tree = useFloatingTree();
+  const dismissProps = useNavigationMenuDismissContext();
+  const stickIfOpenTimeout = useTimeout();
+  const focusFrame = useAnimationFrame();
+  const mutationFrame = useAnimationFrame();
+  const resizeFrame = useAnimationFrame();
+  const sizeFrame = useAnimationFrame();
+  const [triggerElement, setTriggerElement] = React.useState(null);
+  const [stickIfOpen, setStickIfOpen] = React.useState(true);
+  const [pointerType, setPointerType] = React.useState("");
+  const triggerElementRef = React.useRef(null);
+  const allowFocusRef = React.useRef(false);
+  const prevSizeRef = React.useRef(DEFAULT_SIZE);
+  const animationAbortControllerRef = React.useRef(null);
+  const skipAutoSizeSyncRef = React.useRef(false);
+  const isActiveItem = open && value === itemValue;
+  const isActiveItemRef = useValueAsRef(isActiveItem);
+  const interactionsEnabled = positionerElement ? true : !value;
+  const hoverFloatingElement = positionerElement || viewportElement;
+  const hoverInteractionsEnabled = hoverFloatingElement ? true : !value;
+  const runOnceAnimationsFinish = useAnimationsFinished(popupElement, false, false);
+  const handleTriggerElement = React.useCallback((element) => {
+    triggerElementRef.current = element;
+    setTriggerElement(element);
+  }, []);
+  React.useEffect(() => {
+    var _a;
+    (_a = animationAbortControllerRef.current) == null ? void 0 : _a.abort();
+  }, [isActiveItem]);
+  function setAutoSizes() {
+    if (!popupElement) {
+      return;
+    }
+    popupElement.style.setProperty(NavigationMenuPopupCssVars.popupWidth, "auto");
+    popupElement.style.setProperty(NavigationMenuPopupCssVars.popupHeight, "auto");
+  }
+  function clearFixedSizes() {
+    if (!popupElement || !positionerElement) {
+      return;
+    }
+    popupElement.style.removeProperty(NavigationMenuPopupCssVars.popupWidth);
+    popupElement.style.removeProperty(NavigationMenuPopupCssVars.popupHeight);
+    positionerElement.style.removeProperty(NavigationMenuPositionerCssVars.positionerWidth);
+    positionerElement.style.removeProperty(NavigationMenuPositionerCssVars.positionerHeight);
+  }
+  function setSharedFixedSizes(width, height) {
+    if (!popupElement || !positionerElement) {
+      return;
+    }
+    popupElement.style.setProperty(NavigationMenuPopupCssVars.popupWidth, `${width}px`);
+    popupElement.style.setProperty(NavigationMenuPopupCssVars.popupHeight, `${height}px`);
+    positionerElement.style.setProperty(NavigationMenuPositionerCssVars.positionerWidth, `${width}px`);
+    positionerElement.style.setProperty(NavigationMenuPositionerCssVars.positionerHeight, `${height}px`);
+  }
+  function scheduleAutoSizeReset() {
+    animationAbortControllerRef.current = new AbortController();
+    runOnceAnimationsFinish(setAutoSizes, animationAbortControllerRef.current.signal);
+  }
+  const handleValueChange = useStableCallback((currentWidth, currentHeight, options = {}) => {
+    if (!popupElement || !positionerElement) {
+      return;
+    }
+    const {
+      syncPositioner = false
+    } = options;
+    clearFixedSizes();
+    const {
+      width,
+      height
+    } = getCssDimensions(popupElement);
+    const measuredWidth = width || prevSizeRef.current.width;
+    const measuredHeight = height || prevSizeRef.current.height;
+    if (currentHeight === 0 || currentWidth === 0) {
+      currentWidth = measuredWidth;
+      currentHeight = measuredHeight;
+    }
+    popupElement.style.setProperty(NavigationMenuPopupCssVars.popupWidth, `${currentWidth}px`);
+    popupElement.style.setProperty(NavigationMenuPopupCssVars.popupHeight, `${currentHeight}px`);
+    positionerElement.style.setProperty(NavigationMenuPositionerCssVars.positionerWidth, `${syncPositioner ? currentWidth : measuredWidth}px`);
+    positionerElement.style.setProperty(NavigationMenuPositionerCssVars.positionerHeight, `${syncPositioner ? currentHeight : measuredHeight}px`);
+    sizeFrame.request(() => {
+      popupElement.style.setProperty(NavigationMenuPopupCssVars.popupWidth, `${measuredWidth}px`);
+      popupElement.style.setProperty(NavigationMenuPopupCssVars.popupHeight, `${measuredHeight}px`);
+      if (syncPositioner) {
+        positionerElement.style.setProperty(NavigationMenuPositionerCssVars.positionerWidth, `${measuredWidth}px`);
+        positionerElement.style.setProperty(NavigationMenuPositionerCssVars.positionerHeight, `${measuredHeight}px`);
+      }
+      scheduleAutoSizeReset();
+    });
+  });
+  const handleInterruptedMutationResize = useStableCallback((currentWidth, currentHeight) => {
+    var _a;
+    if (!popupElement || !positionerElement) {
+      return;
+    }
+    sizeFrame.cancel();
+    mutationFrame.cancel();
+    (_a = animationAbortControllerRef.current) == null ? void 0 : _a.abort();
+    animationAbortControllerRef.current = null;
+    if (currentWidth === 0 || currentHeight === 0) {
+      return;
+    }
+    setSharedFixedSizes(currentWidth, currentHeight);
+    mutationFrame.request(() => {
+      mutationFrame.request(() => {
+        clearFixedSizes();
+        const {
+          width,
+          height
+        } = getCssDimensions(popupElement);
+        const measuredWidth = width || currentWidth || prevSizeRef.current.width;
+        const measuredHeight = height || currentHeight || prevSizeRef.current.height;
+        setSharedFixedSizes(currentWidth, currentHeight);
+        sizeFrame.request(() => {
+          setSharedFixedSizes(measuredWidth, measuredHeight);
+          scheduleAutoSizeReset();
+        });
+      });
+    });
+  });
+  const syncCurrentSize = useStableCallback(() => {
+    var _a;
+    if (!popupElement || !positionerElement) {
+      return;
+    }
+    sizeFrame.cancel();
+    (_a = animationAbortControllerRef.current) == null ? void 0 : _a.abort();
+    animationAbortControllerRef.current = null;
+    clearFixedSizes();
+    const {
+      width,
+      height
+    } = getCssDimensions(popupElement);
+    if (width === 0 || height === 0) {
+      return;
+    }
+    prevSizeRef.current = {
+      width,
+      height
+    };
+    setAutoSizes();
+    positionerElement.style.setProperty(NavigationMenuPositionerCssVars.positionerWidth, `${width}px`);
+    positionerElement.style.setProperty(NavigationMenuPositionerCssVars.positionerHeight, `${height}px`);
+  });
+  const getMutationBaseline = useStableCallback(() => {
+    if (!popupElement) {
+      return {
+        size: prevSizeRef.current,
+        syncPositioner: false
+      };
+    }
+    const popupWidth = popupElement.style.getPropertyValue(NavigationMenuPopupCssVars.popupWidth);
+    const popupHeight = popupElement.style.getPropertyValue(NavigationMenuPopupCssVars.popupHeight);
+    const isResizing = popupWidth !== "" && popupWidth !== "auto" && popupHeight !== "" && popupHeight !== "auto";
+    if (!isResizing) {
+      return {
+        size: prevSizeRef.current,
+        syncPositioner: false
+      };
+    }
+    return {
+      size: {
+        width: popupElement.offsetWidth || prevSizeRef.current.width,
+        height: popupElement.offsetHeight || prevSizeRef.current.height
+      },
+      syncPositioner: true
+    };
+  });
+  React.useEffect(() => {
+    var _a;
+    if (!open) {
+      stickIfOpenTimeout.clear();
+      mutationFrame.cancel();
+      resizeFrame.cancel();
+      sizeFrame.cancel();
+      (_a = animationAbortControllerRef.current) == null ? void 0 : _a.abort();
+      animationAbortControllerRef.current = null;
+      skipAutoSizeSyncRef.current = false;
+      setPointerType("");
+    }
+  }, [stickIfOpenTimeout, open, mutationFrame, resizeFrame, sizeFrame]);
+  React.useEffect(() => {
+    if (!mounted) {
+      prevSizeRef.current = DEFAULT_SIZE;
+    }
+  }, [mounted]);
+  React.useEffect(() => {
+    if (!popupElement || typeof ResizeObserver !== "function") {
+      return void 0;
+    }
+    const resizeObserver = new ResizeObserver(() => {
+      prevSizeRef.current = {
+        width: popupElement.offsetWidth,
+        height: popupElement.offsetHeight
+      };
+    });
+    resizeObserver.observe(popupElement);
+    return () => {
+      resizeObserver.disconnect();
+    };
+  }, [popupElement]);
+  React.useEffect(() => {
+    if (!open || !isActiveItem || !popupElement || !positionerElement) {
+      return void 0;
+    }
+    const win = getWindow(positionerElement);
+    function handleResize() {
+      resizeFrame.cancel();
+      resizeFrame.request(syncCurrentSize);
+    }
+    win.addEventListener("resize", handleResize);
+    return () => {
+      resizeFrame.cancel();
+      win.removeEventListener("resize", handleResize);
+    };
+  }, [open, isActiveItem, popupElement, positionerElement, resizeFrame, syncCurrentSize]);
+  React.useEffect(() => {
+    const observedElement = currentContentRef.current;
+    if (!observedElement || !popupElement || !isActiveItem || typeof MutationObserver !== "function") {
+      return void 0;
+    }
+    const mutationObserver = new MutationObserver(() => {
+      if (transitionStatus === "starting" || popupElement.hasAttribute(TransitionStatusDataAttributes.startingStyle)) {
+        syncCurrentSize();
+        return;
+      }
+      const {
+        size,
+        syncPositioner
+      } = getMutationBaseline();
+      if (syncPositioner) {
+        handleInterruptedMutationResize(size.width, size.height);
+        return;
+      }
+      handleValueChange(size.width, size.height);
+    });
+    mutationObserver.observe(observedElement, {
+      childList: true,
+      subtree: true,
+      characterData: true
+    });
+    return () => {
+      mutationObserver.disconnect();
+    };
+  }, [currentContentRef, popupElement, isActiveItem, transitionStatus, getMutationBaseline, handleInterruptedMutationResize, handleValueChange, syncCurrentSize]);
+  React.useEffect(() => {
+    if (isActiveItem && open && popupElement && allowFocusRef.current) {
+      allowFocusRef.current = false;
+      focusFrame.request(() => {
+        var _a;
+        (_a = beforeOutsideRef.current) == null ? void 0 : _a.focus();
+      });
+    }
+    return () => {
+      focusFrame.cancel();
+    };
+  }, [beforeOutsideRef, focusFrame, isActiveItem, open, popupElement]);
+  useIsoLayoutEffect(() => {
+    var _a;
+    if (isActiveItemRef.current && open && popupElement) {
+      if (transitionStatus === "starting") {
+        const hasNestedMenu = ((_a = currentContentRef.current) == null ? void 0 : _a.querySelector("[data-nested]")) != null;
+        if (hasNestedMenu) {
+          sizeFrame.request(syncCurrentSize);
+          return () => {
+            sizeFrame.cancel();
+          };
+        }
+      }
+      if (skipAutoSizeSyncRef.current) {
+        skipAutoSizeSyncRef.current = false;
+        return void 0;
+      }
+      handleValueChange(0, 0);
+    }
+    return void 0;
+  }, [currentContentRef, handleValueChange, isActiveItemRef, open, popupElement, sizeFrame, syncCurrentSize, transitionStatus]);
+  function handleOpenChange(nextOpen, eventDetails) {
+    const isHover = eventDetails.reason === triggerHover;
+    if (!interactionsEnabled) {
+      return;
+    }
+    if (pointerType === "touch" && isHover) {
+      return;
+    }
+    if (!nextOpen && value !== itemValue) {
+      return;
+    }
+    function changeState() {
+      if (isHover) {
+        setStickIfOpen(true);
+        stickIfOpenTimeout.clear();
+        stickIfOpenTimeout.start(PATIENT_CLICK_THRESHOLD, () => {
+          setStickIfOpen(false);
+        });
+      }
+      if (nextOpen) {
+        setValue(itemValue, eventDetails);
+      } else {
+        setValue(null, eventDetails);
+        setPointerType("");
+      }
+    }
+    if (isHover) {
+      ReactDOM.flushSync(changeState);
+    } else {
+      changeState();
+    }
+  }
+  const context = useFloatingRootContext({
+    open,
+    onOpenChange: handleOpenChange,
+    elements: {
+      reference: triggerElement,
+      floating: hoverFloatingElement
+    }
+  });
+  const hoverInteractionState = useHoverInteractionSharedState(context);
+  React.useEffect(() => {
+    if (!open) {
+      context.context.dataRef.current.openEvent = void 0;
+      hoverInteractionState.pointerType = void 0;
+      hoverInteractionState.interactedInside = false;
+      hoverInteractionState.restTimeoutPending = false;
+      hoverInteractionState.openChangeTimeout.clear();
+      hoverInteractionState.restTimeout.clear();
+      clearSafePolygonPointerEventsMutation(hoverInteractionState);
+    }
+  }, [context, hoverInteractionState, open]);
+  const getInlineHandleCloseContext = useStableCallback(() => {
+    if (!nested || positionerElement || !triggerElementRef.current || !hoverFloatingElement) {
+      return null;
+    }
+    return getHandleCloseContext(triggerElementRef.current, hoverFloatingElement, nodeId);
+  });
+  function getScope() {
+    var _a;
+    return ((_a = triggerElementRef.current) == null ? void 0 : _a.closest("ul")) ?? null;
+  }
+  const hoverProps = useHoverReferenceInteraction(context, {
+    enabled: hoverInteractionsEnabled,
+    move: false,
+    handleClose: safePolygon({
+      blockPointerEvents: pointerType !== "touch" && (!isWebKit || nested)
+    }),
+    restMs: mounted && positionerElement ? 0 : delay,
+    delay: {
+      close: closeDelay
+    },
+    triggerElementRef,
+    getHandleCloseContext: getInlineHandleCloseContext
+  });
+  const hover = React.useMemo(() => hoverProps ? {
+    reference: hoverProps
+  } : void 0, [hoverProps]);
+  const click = useClick(context, {
+    enabled: interactionsEnabled,
+    stickIfOpen,
+    toggle: isActiveItem
+  });
+  const {
+    getReferenceProps
+  } = useInteractions([hover, click]);
+  useIsoLayoutEffect(() => {
+    if (isActiveItem) {
+      setFloatingRootContext(context);
+      prevTriggerElementRef.current = triggerElement;
+    }
+  }, [isActiveItem, context, setFloatingRootContext, prevTriggerElementRef, triggerElement]);
+  function handleActivation(event) {
+    ReactDOM.flushSync(() => {
+      var _a;
+      const prevTriggerRect = (_a = prevTriggerElementRef.current) == null ? void 0 : _a.getBoundingClientRect();
+      if (mounted && prevTriggerRect && triggerElement) {
+        const nextTriggerRect = triggerElement.getBoundingClientRect();
+        const isMovingRight = nextTriggerRect.left > prevTriggerRect.left;
+        const isMovingDown = nextTriggerRect.top > prevTriggerRect.top;
+        if (orientation === "horizontal" && nextTriggerRect.left !== prevTriggerRect.left) {
+          setActivationDirection(isMovingRight ? "right" : "left");
+        } else if (orientation === "vertical" && nextTriggerRect.top !== prevTriggerRect.top) {
+          setActivationDirection(isMovingDown ? "down" : "up");
+        }
+      }
+      if (event.type !== "click" && value != null) {
+        context.context.dataRef.current.openEvent = void 0;
+      }
+      if (pointerType === "touch" && event.type !== "click") {
+        return;
+      }
+      if (value != null) {
+        setValue(itemValue, createChangeEventDetails(event.type === "mouseenter" ? triggerHover : triggerPress, event.nativeEvent));
+      }
+      if (event.type === "mouseenter" && nested && !positionerElement && pointerType !== "touch" && hoverFloatingElement && isHTMLElement(event.currentTarget)) {
+        const scopeElement = getScope();
+        if (!scopeElement) {
+          return;
+        }
+        applySafePolygonPointerEventsMutation(hoverInteractionState, {
+          scopeElement,
+          referenceElement: event.currentTarget,
+          floatingElement: hoverFloatingElement
+        });
+      }
+    });
+  }
+  const handleOpenEvent = useStableCallback((event) => {
+    if (!popupElement || !positionerElement) {
+      handleActivation(event);
+      return;
+    }
+    const {
+      width,
+      height
+    } = getCssDimensions(popupElement);
+    const shouldSkipAutoSizeSync = value != null && value !== itemValue && (event.type === "click" || pointerType !== "touch");
+    handleActivation(event);
+    if (shouldSkipAutoSizeSync) {
+      skipAutoSizeSyncRef.current = true;
+    }
+    handleValueChange(width, height);
+  });
+  const state = {
+    open: isActiveItem
+  };
+  function handleSetPointerType(event) {
+    setPointerType(event.pointerType);
+  }
+  const defaultProps = {
+    tabIndex: 0,
+    onMouseEnter: handleOpenEvent,
+    onClick: handleOpenEvent,
+    onPointerEnter: handleSetPointerType,
+    onPointerDown: handleSetPointerType,
+    "aria-expanded": isActiveItem,
+    "aria-controls": isActiveItem ? popupElement == null ? void 0 : popupElement.id : void 0,
+    [NAVIGATION_MENU_TRIGGER_IDENTIFIER]: "",
+    onFocus() {
+      if (!isActiveItem) {
+        return;
+      }
+      setViewportInert(false);
+    },
+    onMouseMove() {
+      allowFocusRef.current = false;
+    },
+    onKeyDown(event) {
+      allowFocusRef.current = true;
+      if (nested) {
+        return;
+      }
+      const openHorizontal = orientation === "horizontal" && event.key === "ArrowDown";
+      const openVertical = orientation === "vertical" && event.key === "ArrowRight";
+      if (openHorizontal || openVertical) {
+        setValue(itemValue, createChangeEventDetails(listNavigation, event.nativeEvent));
+        handleOpenEvent(event);
+        stopEvent(event);
+      }
+    },
+    onBlur(event) {
+      if (positionerElement && popupElement && isOutsideMenuEvent({
+        currentTarget: event.currentTarget,
+        relatedTarget: event.relatedTarget
+      }, {
+        popupElement,
+        rootRef,
+        tree,
+        nodeId
+      })) {
+        setValue(null, createChangeEventDetails(focusOut, event.nativeEvent));
+      }
+    }
+  };
+  const {
+    getButtonProps,
+    buttonRef
+  } = useButton({
+    disabled,
+    focusableWhenDisabled: true,
+    native: nativeButton
+  });
+  const referenceElement = hoverFloatingElement;
+  return /* @__PURE__ */ jsxs(React.Fragment, {
+    children: [/* @__PURE__ */ jsx(CompositeItem, {
+      tag: "button",
+      render,
+      className,
+      state,
+      stateAttributesMapping: pressableTriggerOpenStateMapping,
+      refs: [forwardedRef, handleTriggerElement, buttonRef],
+      props: [getReferenceProps, (dismissProps == null ? void 0 : dismissProps.reference) || EMPTY_ARRAY, defaultProps, elementProps, getButtonProps]
+    }), isActiveItem && /* @__PURE__ */ jsxs(React.Fragment, {
+      children: [/* @__PURE__ */ jsx(FocusGuard, {
+        ref: beforeOutsideRef,
+        onFocus: (event) => {
+          var _a;
+          if (referenceElement && isOutsideEvent(event, referenceElement)) {
+            (_a = beforeInsideRef.current) == null ? void 0 : _a.focus();
+          } else {
+            const prevTabbable = getPreviousTabbable(triggerElement);
+            prevTabbable == null ? void 0 : prevTabbable.focus();
+          }
+        }
+      }), /* @__PURE__ */ jsx("span", {
+        "aria-owns": viewportElement == null ? void 0 : viewportElement.id,
+        style: ownerVisuallyHidden
+      }), /* @__PURE__ */ jsx(FocusGuard, {
+        ref: afterOutsideRef,
+        onFocus: (event) => {
+          if (referenceElement && isOutsideEvent(event, referenceElement)) {
+            const elementToFocus = afterInsideRef.current && isTabbable(afterInsideRef.current) ? afterInsideRef.current : triggerElement;
+            elementToFocus == null ? void 0 : elementToFocus.focus();
+          } else {
+            let nextTabbable = getNextTabbable(triggerElement);
+            if (nested && !positionerElement && referenceElement && nextTabbable && contains(referenceElement, nextTabbable)) {
+              nextTabbable = getTabbableAfterElement(afterInsideRef.current);
+            }
+            nextTabbable == null ? void 0 : nextTabbable.focus();
+            if ((!nested || positionerElement) && !contains(rootRef.current, nextTabbable)) {
+              setValue(null, createChangeEventDetails(focusOut, event.nativeEvent));
+            }
+          }
+        }
+      })]
+    })]
+  });
+});
+if (process.env.NODE_ENV !== "production") NavigationMenuTrigger.displayName = "NavigationMenuTrigger";
+function getPlacementFromElements(domReferenceElement, floatingElement) {
+  const referenceRect = domReferenceElement.getBoundingClientRect();
+  const floatingRect = floatingElement.getBoundingClientRect();
+  const referenceCenterX = referenceRect.left + referenceRect.width / 2;
+  const referenceCenterY = referenceRect.top + referenceRect.height / 2;
+  const floatingCenterX = floatingRect.left + floatingRect.width / 2;
+  const floatingCenterY = floatingRect.top + floatingRect.height / 2;
+  const deltaX = floatingCenterX - referenceCenterX;
+  const deltaY = floatingCenterY - referenceCenterY;
+  if (Math.abs(deltaX) >= Math.abs(deltaY)) {
+    return deltaX >= 0 ? "right" : "left";
+  }
+  return deltaY >= 0 ? "bottom" : "top";
+}
+function getHandleCloseContext(domReferenceElement, floatingElement, nodeId) {
+  return {
+    placement: getPlacementFromElements(domReferenceElement, floatingElement),
+    elements: {
+      domReference: domReferenceElement,
+      floating: floatingElement
+    },
+    nodeId
+  };
+}
+export {
+  NavigationMenuTrigger
+};

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/navigation-menu/utils/constants.js

@@ -0,0 +1,4 @@
+const NAVIGATION_MENU_TRIGGER_IDENTIFIER = "data-base-ui-navigation-menu-trigger";
+export {
+  NAVIGATION_MENU_TRIGGER_IDENTIFIER
+};

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/navigation-menu/utils/isOutsideMenuEvent.js

@@ -0,0 +1,26 @@
+import { getNodeChildren } from "../../floating-ui-react/utils/nodes.js";
+import { contains } from "../../floating-ui-react/utils/element.js";
+function isOutsideMenuEvent({
+  currentTarget,
+  relatedTarget
+}, params) {
+  const {
+    popupElement,
+    viewportElement,
+    rootRef,
+    tree,
+    nodeId
+  } = params;
+  const nodeChildrenContains = tree ? getNodeChildren(tree.nodesRef.current, nodeId).some((node) => {
+    var _a;
+    return contains((_a = node.context) == null ? void 0 : _a.elements.floating, relatedTarget);
+  }) : [];
+  if (!popupElement) {
+    return !contains(rootRef.current, relatedTarget) && !nodeChildrenContains;
+  }
+  const floatingElement = popupElement || viewportElement;
+  return !contains(floatingElement, currentTarget) && !contains(floatingElement, relatedTarget) && !contains(rootRef.current, relatedTarget) && !nodeChildrenContains && !(contains(floatingElement, relatedTarget) && (relatedTarget == null ? void 0 : relatedTarget.hasAttribute("data-base-ui-focus-guard")));
+}
+export {
+  isOutsideMenuEvent
+};