dune-react 0.0.1 → 0.0.3

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/menu/group-label/MenuGroupLabel.js

@@ -0,0 +1,35 @@
+import * as React from "react";
+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 { useRenderElement } from "../../utils/useRenderElement.js";
+import { useBaseUiId } from "../../utils/useBaseUiId.js";
+import { useMenuGroupRootContext } from "../group/MenuGroupContext.js";
+const MenuGroupLabel = /* @__PURE__ */ React.forwardRef(function MenuGroupLabelComponent(componentProps, forwardedRef) {
+  const {
+    className,
+    render,
+    id: idProp,
+    ...elementProps
+  } = componentProps;
+  const id = useBaseUiId(idProp);
+  const {
+    setLabelId
+  } = useMenuGroupRootContext();
+  useIsoLayoutEffect(() => {
+    setLabelId(id);
+    return () => {
+      setLabelId(void 0);
+    };
+  }, [setLabelId, id]);
+  return useRenderElement("div", componentProps, {
+    ref: forwardedRef,
+    props: {
+      id,
+      role: "presentation",
+      ...elementProps
+    }
+  });
+});
+if (process.env.NODE_ENV !== "production") MenuGroupLabel.displayName = "MenuGroupLabel";
+export {
+  MenuGroupLabel
+};

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/menu/item/MenuItem.js

@@ -0,0 +1,55 @@
+import * as React from "react";
+import { useMenuItem, REGULAR_ITEM } from "./useMenuItem.js";
+import { useMenuRootContext } from "../root/MenuRootContext.js";
+import { useRenderElement } from "../../utils/useRenderElement.js";
+import { useBaseUiId } from "../../utils/useBaseUiId.js";
+import { useCompositeListItem } from "../../composite/list/useCompositeListItem.js";
+import { useMenuPositionerContext } from "../positioner/MenuPositionerContext.js";
+const MenuItem = /* @__PURE__ */ React.forwardRef(function MenuItem2(componentProps, forwardedRef) {
+  const {
+    render,
+    className,
+    id: idProp,
+    label,
+    nativeButton = false,
+    disabled = false,
+    closeOnClick = true,
+    ...elementProps
+  } = componentProps;
+  const listItem = useCompositeListItem({
+    label
+  });
+  const menuPositionerContext = useMenuPositionerContext(true);
+  const id = useBaseUiId(idProp);
+  const {
+    store
+  } = useMenuRootContext();
+  const highlighted = store.useState("isActive", listItem.index);
+  const itemProps = store.useState("itemProps");
+  const {
+    getItemProps,
+    itemRef
+  } = useMenuItem({
+    closeOnClick,
+    disabled,
+    highlighted,
+    id,
+    store,
+    nativeButton,
+    nodeId: menuPositionerContext == null ? void 0 : menuPositionerContext.nodeId,
+    itemMetadata: REGULAR_ITEM
+  });
+  const state = {
+    disabled,
+    highlighted
+  };
+  return useRenderElement("div", componentProps, {
+    state,
+    props: [itemProps, elementProps, getItemProps],
+    ref: [itemRef, forwardedRef, listItem.ref]
+  });
+});
+if (process.env.NODE_ENV !== "production") MenuItem.displayName = "MenuItem";
+export {
+  MenuItem
+};

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/menu/item/useMenuItem.js

@@ -0,0 +1,60 @@
+import * as React from "react";
+import { useMergedRefs } 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/useMergedRefs.js";
+import { useMenuItemCommonProps } from "./useMenuItemCommonProps.js";
+import { useButton } from "../../use-button/useButton.js";
+import { mergeProps } from "../../merge-props/mergeProps.js";
+const REGULAR_ITEM = {
+  type: "regular-item"
+};
+function useMenuItem(params) {
+  const {
+    closeOnClick,
+    disabled = false,
+    highlighted,
+    id,
+    store,
+    typingRef = store.context.typingRef,
+    nativeButton,
+    itemMetadata,
+    nodeId
+  } = params;
+  const itemRef = React.useRef(null);
+  const {
+    getButtonProps,
+    buttonRef
+  } = useButton({
+    disabled,
+    focusableWhenDisabled: true,
+    native: nativeButton,
+    composite: true
+  });
+  const commonProps = useMenuItemCommonProps({
+    closeOnClick,
+    highlighted,
+    id,
+    nodeId,
+    store,
+    typingRef,
+    itemRef,
+    itemMetadata
+  });
+  const getItemProps = React.useCallback((externalProps) => {
+    return mergeProps(commonProps, {
+      onMouseEnter() {
+        if (itemMetadata.type !== "submenu-trigger") {
+          return;
+        }
+        itemMetadata.setActive();
+      }
+    }, externalProps, getButtonProps);
+  }, [commonProps, getButtonProps, itemMetadata]);
+  const mergedRef = useMergedRefs(itemRef, buttonRef);
+  return React.useMemo(() => ({
+    getItemProps,
+    itemRef: mergedRef
+  }), [getItemProps, mergedRef]);
+}
+export {
+  REGULAR_ITEM,
+  useMenuItem
+};

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/menu/item/useMenuItemCommonProps.js

@@ -0,0 +1,68 @@
+import * as React from "react";
+import { isMac } 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 { useContextMenuRootContext } from "../../context-menu/root/ContextMenuRootContext.js";
+import { itemPress } from "../../utils/reason-parts.js";
+function useMenuItemCommonProps(params) {
+  const {
+    closeOnClick,
+    highlighted,
+    id,
+    nodeId,
+    store,
+    typingRef,
+    itemRef,
+    itemMetadata
+  } = params;
+  const {
+    events: menuEvents
+  } = store.useState("floatingTreeRoot");
+  const contextMenuContext = useContextMenuRootContext(true);
+  const isContextMenu = contextMenuContext !== void 0;
+  return React.useMemo(() => ({
+    id,
+    role: "menuitem",
+    tabIndex: highlighted ? 0 : -1,
+    onKeyDown(event) {
+      if (event.key === " " && (typingRef == null ? void 0 : typingRef.current)) {
+        event.preventDefault();
+      }
+    },
+    onMouseMove(event) {
+      if (!nodeId) {
+        return;
+      }
+      menuEvents.emit("itemhover", {
+        nodeId,
+        target: event.currentTarget
+      });
+    },
+    onClick(event) {
+      if (closeOnClick) {
+        menuEvents.emit("close", {
+          domEvent: event,
+          reason: itemPress
+        });
+      }
+    },
+    onMouseUp(event) {
+      if (contextMenuContext) {
+        const initialCursorPoint = contextMenuContext.initialCursorPointRef.current;
+        contextMenuContext.initialCursorPointRef.current = null;
+        if (isContextMenu && initialCursorPoint && Math.abs(event.clientX - initialCursorPoint.x) <= 1 && Math.abs(event.clientY - initialCursorPoint.y) <= 1) {
+          return;
+        }
+        if (isContextMenu && !isMac && event.button === 2) {
+          return;
+        }
+      }
+      if (itemRef.current && store.context.allowMouseUpTriggerRef.current && (!isContextMenu || event.button === 2)) {
+        if (!itemMetadata || itemMetadata.type === "regular-item") {
+          itemRef.current.click();
+        }
+      }
+    }
+  }), [closeOnClick, highlighted, id, menuEvents, nodeId, store, typingRef, itemRef, contextMenuContext, isContextMenu, itemMetadata]);
+}
+export {
+  useMenuItemCommonProps
+};

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/menu/popup/MenuPopup.js

@@ -0,0 +1,120 @@
+import * as React from "react";
+import { useMenuRootContext } from "../root/MenuRootContext.js";
+import { useMenuPositionerContext } from "../positioner/MenuPositionerContext.js";
+import { useRenderElement } from "../../utils/useRenderElement.js";
+import { popupStateMapping } from "../../utils/popupStateMapping.js";
+import { transitionStatusMapping } from "../../utils/stateAttributesMapping.js";
+import { useOpenChangeComplete } from "../../utils/useOpenChangeComplete.js";
+import { createChangeEventDetails } from "../../utils/createBaseUIEventDetails.js";
+import { useToolbarRootContext } from "../../toolbar/root/ToolbarRootContext.js";
+import { COMPOSITE_KEYS } from "../../composite/composite.js";
+import { getDisabledMountTransitionStyles } from "../../utils/getDisabledMountTransitionStyles.js";
+import { jsx } from "react/jsx-runtime";
+import { useHoverFloatingInteraction } from "../../floating-ui-react/hooks/useHoverFloatingInteraction.js";
+import { FloatingFocusManager } from "../../floating-ui-react/components/FloatingFocusManager.js";
+import { outsidePress } from "../../utils/reason-parts.js";
+const stateAttributesMapping = {
+  ...popupStateMapping,
+  ...transitionStatusMapping
+};
+const MenuPopup = /* @__PURE__ */ React.forwardRef(function MenuPopup2(componentProps, forwardedRef) {
+  const {
+    render,
+    className,
+    finalFocus,
+    ...elementProps
+  } = componentProps;
+  const {
+    store
+  } = useMenuRootContext();
+  const {
+    side,
+    align
+  } = useMenuPositionerContext();
+  const insideToolbar = useToolbarRootContext() != null;
+  const open = store.useState("open");
+  const transitionStatus = store.useState("transitionStatus");
+  const popupProps = store.useState("popupProps");
+  const mounted = store.useState("mounted");
+  const instantType = store.useState("instantType");
+  const triggerElement = store.useState("activeTriggerElement");
+  const parent = store.useState("parent");
+  const lastOpenChangeReason = store.useState("lastOpenChangeReason");
+  const rootId = store.useState("rootId");
+  const floatingContext = store.useState("floatingRootContext");
+  const floatingTreeRoot = store.useState("floatingTreeRoot");
+  const closeDelay = store.useState("closeDelay");
+  const activeTriggerElement = store.useState("activeTriggerElement");
+  const isContextMenu = parent.type === "context-menu";
+  useOpenChangeComplete({
+    open,
+    ref: store.context.popupRef,
+    onComplete() {
+      var _a, _b;
+      if (open) {
+        (_b = (_a = store.context).onOpenChangeComplete) == null ? void 0 : _b.call(_a, true);
+      }
+    }
+  });
+  React.useEffect(() => {
+    function handleClose(event) {
+      store.setOpen(false, createChangeEventDetails(event.reason, event.domEvent));
+    }
+    floatingTreeRoot.events.on("close", handleClose);
+    return () => {
+      floatingTreeRoot.events.off("close", handleClose);
+    };
+  }, [floatingTreeRoot.events, store]);
+  const hoverEnabled = store.useState("hoverEnabled");
+  const disabled = store.useState("disabled");
+  useHoverFloatingInteraction(floatingContext, {
+    enabled: hoverEnabled && !disabled && !isContextMenu && parent.type !== "menubar",
+    closeDelay
+  });
+  const state = {
+    transitionStatus,
+    side,
+    align,
+    open,
+    nested: parent.type === "menu",
+    instant: instantType
+  };
+  const setPopupElement = React.useCallback((element2) => {
+    store.set("popupElement", element2);
+  }, [store]);
+  const element = useRenderElement("div", componentProps, {
+    state,
+    ref: [forwardedRef, store.context.popupRef, setPopupElement],
+    stateAttributesMapping,
+    props: [popupProps, {
+      onKeyDown(event) {
+        if (insideToolbar && COMPOSITE_KEYS.has(event.key)) {
+          event.stopPropagation();
+        }
+      }
+    }, getDisabledMountTransitionStyles(transitionStatus), elementProps, {
+      "data-rootownerid": rootId
+    }]
+  });
+  let returnFocus = parent.type === void 0 || isContextMenu;
+  if (triggerElement || parent.type === "menubar" && lastOpenChangeReason !== outsidePress) {
+    returnFocus = true;
+  }
+  return /* @__PURE__ */ jsx(FloatingFocusManager, {
+    context: floatingContext,
+    modal: isContextMenu,
+    disabled: !mounted,
+    returnFocus: finalFocus === void 0 ? returnFocus : finalFocus,
+    initialFocus: parent.type !== "menu",
+    restoreFocus: true,
+    externalTree: parent.type !== "menubar" ? floatingTreeRoot : void 0,
+    previousFocusableElement: activeTriggerElement,
+    nextFocusableElement: parent.type === void 0 ? store.context.triggerFocusTargetRef : void 0,
+    beforeContentFocusGuardRef: parent.type === void 0 ? store.context.beforeContentFocusGuardRef : void 0,
+    children: element
+  });
+});
+if (process.env.NODE_ENV !== "production") MenuPopup.displayName = "MenuPopup";
+export {
+  MenuPopup
+};

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/menu/portal/MenuPortal.js

@@ -0,0 +1,30 @@
+import * as React from "react";
+import { useMenuRootContext } from "../root/MenuRootContext.js";
+import { MenuPortalContext } from "./MenuPortalContext.js";
+import { jsx } from "react/jsx-runtime";
+import { FloatingPortal } from "../../floating-ui-react/components/FloatingPortal.js";
+const MenuPortal = /* @__PURE__ */ React.forwardRef(function MenuPortal2(props, forwardedRef) {
+  const {
+    keepMounted = false,
+    ...portalProps
+  } = props;
+  const {
+    store
+  } = useMenuRootContext();
+  const mounted = store.useState("mounted");
+  const shouldRender = mounted || keepMounted;
+  if (!shouldRender) {
+    return null;
+  }
+  return /* @__PURE__ */ jsx(MenuPortalContext.Provider, {
+    value: keepMounted,
+    children: /* @__PURE__ */ jsx(FloatingPortal, {
+      ref: forwardedRef,
+      ...portalProps
+    })
+  });
+});
+if (process.env.NODE_ENV !== "production") MenuPortal.displayName = "MenuPortal";
+export {
+  MenuPortal
+};

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/menu/portal/MenuPortalContext.js

@@ -0,0 +1,15 @@
+import formatErrorMessage 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/formatErrorMessage.js";
+import * as React from "react";
+const MenuPortalContext = /* @__PURE__ */ React.createContext(void 0);
+if (process.env.NODE_ENV !== "production") MenuPortalContext.displayName = "MenuPortalContext";
+function useMenuPortalContext() {
+  const value = React.useContext(MenuPortalContext);
+  if (value === void 0) {
+    throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: <Menu.Portal> is missing." : formatErrorMessage(32));
+  }
+  return value;
+}
+export {
+  MenuPortalContext,
+  useMenuPortalContext
+};

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/menu/positioner/MenuPositioner.js

@@ -0,0 +1,260 @@
+import * as React from "react";
+import { inertValue } 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/inertValue.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 { 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 { MenuPositionerContext } from "./MenuPositionerContext.js";
+import { useMenuRootContext } from "../root/MenuRootContext.js";
+import { useAnchorPositioning } from "../../utils/useAnchorPositioning.js";
+import { useRenderElement } from "../../utils/useRenderElement.js";
+import { popupStateMapping } from "../../utils/popupStateMapping.js";
+import { CompositeList } from "../../composite/list/CompositeList.js";
+import { InternalBackdrop } from "../../utils/InternalBackdrop.js";
+import { useMenuPortalContext } from "../portal/MenuPortalContext.js";
+import { DROPDOWN_COLLISION_AVOIDANCE, POPUP_COLLISION_AVOIDANCE } from "../../utils/constants.js";
+import { getDisabledMountTransitionStyles } from "../../utils/getDisabledMountTransitionStyles.js";
+import { useContextMenuRootContext } from "../../context-menu/root/ContextMenuRootContext.js";
+import { createChangeEventDetails } from "../../utils/createBaseUIEventDetails.js";
+import { adaptiveOrigin } from "../../utils/adaptiveOriginMiddleware.js";
+import { useAnimationsFinished } from "../../utils/useAnimationsFinished.js";
+import { jsxs, jsx } from "react/jsx-runtime";
+import { FloatingNode } from "../../floating-ui-react/components/FloatingTree.js";
+import { triggerHover, siblingOpen } from "../../utils/reason-parts.js";
+const MenuPositioner = /* @__PURE__ */ React.forwardRef(function MenuPositioner2(componentProps, forwardedRef) {
+  var _a;
+  const {
+    anchor: anchorProp,
+    positionMethod: positionMethodProp = "absolute",
+    className,
+    render,
+    side,
+    align: alignProp,
+    sideOffset: sideOffsetProp = 0,
+    alignOffset: alignOffsetProp = 0,
+    collisionBoundary = "clipping-ancestors",
+    collisionPadding = 5,
+    arrowPadding = 5,
+    sticky = false,
+    disableAnchorTracking = false,
+    collisionAvoidance: collisionAvoidanceProp = DROPDOWN_COLLISION_AVOIDANCE,
+    ...elementProps
+  } = componentProps;
+  const {
+    store
+  } = useMenuRootContext();
+  const keepMounted = useMenuPortalContext();
+  const contextMenuContext = useContextMenuRootContext(true);
+  const parent = store.useState("parent");
+  const floatingRootContext = store.useState("floatingRootContext");
+  const floatingTreeRoot = store.useState("floatingTreeRoot");
+  const mounted = store.useState("mounted");
+  const open = store.useState("open");
+  const modal = store.useState("modal");
+  const triggerElement = store.useState("activeTriggerElement");
+  const transitionStatus = store.useState("transitionStatus");
+  const positionerElement = store.useState("positionerElement");
+  const instantType = store.useState("instantType");
+  const hasViewport = store.useState("hasViewport");
+  const lastOpenChangeReason = store.useState("lastOpenChangeReason");
+  const floatingNodeId = store.useState("floatingNodeId");
+  const floatingParentNodeId = store.useState("floatingParentNodeId");
+  const domReference = floatingRootContext.useState("domReferenceElement");
+  const previousTriggerRef = React.useRef(null);
+  const runOnceAnimationsFinish = useAnimationsFinished(positionerElement, false, false);
+  let anchor = anchorProp;
+  let sideOffset = sideOffsetProp;
+  let alignOffset = alignOffsetProp;
+  let align = alignProp;
+  let collisionAvoidance = collisionAvoidanceProp;
+  if (parent.type === "context-menu") {
+    anchor = anchorProp ?? ((_a = parent.context) == null ? void 0 : _a.anchor);
+    align = align ?? "start";
+    if (!side && align !== "center") {
+      alignOffset = componentProps.alignOffset ?? 2;
+      sideOffset = componentProps.sideOffset ?? -5;
+    }
+  }
+  let computedSide = side;
+  let computedAlign = align;
+  if (parent.type === "menu") {
+    computedSide = computedSide ?? "inline-end";
+    computedAlign = computedAlign ?? "start";
+    collisionAvoidance = componentProps.collisionAvoidance ?? POPUP_COLLISION_AVOIDANCE;
+  } else if (parent.type === "menubar") {
+    computedSide = computedSide ?? "bottom";
+    computedAlign = computedAlign ?? "start";
+  }
+  const contextMenu = parent.type === "context-menu";
+  const positioner = useAnchorPositioning({
+    anchor,
+    floatingRootContext,
+    positionMethod: contextMenuContext ? "fixed" : positionMethodProp,
+    mounted,
+    side: computedSide,
+    sideOffset,
+    align: computedAlign,
+    alignOffset,
+    arrowPadding: contextMenu ? 0 : arrowPadding,
+    collisionBoundary,
+    collisionPadding,
+    sticky,
+    nodeId: floatingNodeId,
+    keepMounted,
+    disableAnchorTracking,
+    collisionAvoidance,
+    shiftCrossAxis: contextMenu && !("side" in collisionAvoidance && collisionAvoidance.side === "flip"),
+    externalTree: floatingTreeRoot,
+    adaptiveOrigin: hasViewport ? adaptiveOrigin : void 0
+  });
+  const positionerProps = React.useMemo(() => {
+    const hiddenStyles = {};
+    if (!open) {
+      hiddenStyles.pointerEvents = "none";
+    }
+    return {
+      role: "presentation",
+      hidden: !mounted,
+      style: {
+        ...positioner.positionerStyles,
+        ...hiddenStyles
+      }
+    };
+  }, [open, mounted, positioner.positionerStyles]);
+  React.useEffect(() => {
+    function onMenuOpenChange(details) {
+      if (details.open) {
+        if (details.parentNodeId === floatingNodeId) {
+          store.set("hoverEnabled", false);
+        }
+        if (details.nodeId !== floatingNodeId && details.parentNodeId === store.select("floatingParentNodeId")) {
+          store.setOpen(false, createChangeEventDetails(siblingOpen));
+        }
+      }
+    }
+    floatingTreeRoot.events.on("menuopenchange", onMenuOpenChange);
+    return () => {
+      floatingTreeRoot.events.off("menuopenchange", onMenuOpenChange);
+    };
+  }, [store, floatingTreeRoot.events, floatingNodeId]);
+  React.useEffect(() => {
+    if (store.select("floatingParentNodeId") == null) {
+      return void 0;
+    }
+    function onParentClose(details) {
+      if (details.open || details.nodeId !== store.select("floatingParentNodeId")) {
+        return;
+      }
+      const reason = details.reason ?? siblingOpen;
+      store.setOpen(false, createChangeEventDetails(reason));
+    }
+    floatingTreeRoot.events.on("menuopenchange", onParentClose);
+    return () => {
+      floatingTreeRoot.events.off("menuopenchange", onParentClose);
+    };
+  }, [floatingTreeRoot.events, store]);
+  const closeTimeout = useTimeout();
+  React.useEffect(() => {
+    if (!open) {
+      closeTimeout.clear();
+    }
+  }, [open, closeTimeout]);
+  React.useEffect(() => {
+    function onItemHover(event) {
+      if (!open || event.nodeId !== store.select("floatingParentNodeId")) {
+        return;
+      }
+      if (event.target && triggerElement && triggerElement !== event.target) {
+        const delay = store.select("closeDelay");
+        if (delay > 0) {
+          if (!closeTimeout.isStarted()) {
+            closeTimeout.start(delay, () => {
+              store.setOpen(false, createChangeEventDetails(siblingOpen));
+            });
+          }
+        } else {
+          store.setOpen(false, createChangeEventDetails(siblingOpen));
+        }
+      } else {
+        closeTimeout.clear();
+      }
+    }
+    floatingTreeRoot.events.on("itemhover", onItemHover);
+    return () => {
+      floatingTreeRoot.events.off("itemhover", onItemHover);
+    };
+  }, [floatingTreeRoot.events, open, triggerElement, store, closeTimeout]);
+  React.useEffect(() => {
+    const eventDetails = {
+      open,
+      nodeId: floatingNodeId,
+      parentNodeId: floatingParentNodeId,
+      reason: store.select("lastOpenChangeReason")
+    };
+    floatingTreeRoot.events.emit("menuopenchange", eventDetails);
+  }, [floatingTreeRoot.events, open, store, floatingNodeId, floatingParentNodeId]);
+  useIsoLayoutEffect(() => {
+    const currentTrigger = domReference;
+    const previousTrigger = previousTriggerRef.current;
+    if (currentTrigger) {
+      previousTriggerRef.current = currentTrigger;
+    }
+    if (previousTrigger && currentTrigger && currentTrigger !== previousTrigger) {
+      store.set("instantType", void 0);
+      const abortController = new AbortController();
+      runOnceAnimationsFinish(() => {
+        store.set("instantType", "trigger-change");
+      }, abortController.signal);
+      return () => {
+        abortController.abort();
+      };
+    }
+    return void 0;
+  }, [domReference, runOnceAnimationsFinish, store]);
+  const state = {
+    open,
+    side: positioner.side,
+    align: positioner.align,
+    anchorHidden: positioner.anchorHidden,
+    nested: parent.type === "menu",
+    instant: instantType
+  };
+  const contextValue = React.useMemo(() => ({
+    side: positioner.side,
+    align: positioner.align,
+    arrowRef: positioner.arrowRef,
+    arrowUncentered: positioner.arrowUncentered,
+    arrowStyles: positioner.arrowStyles,
+    nodeId: positioner.context.nodeId
+  }), [positioner.side, positioner.align, positioner.arrowRef, positioner.arrowUncentered, positioner.arrowStyles, positioner.context.nodeId]);
+  const element = useRenderElement("div", componentProps, {
+    state,
+    stateAttributesMapping: popupStateMapping,
+    ref: [forwardedRef, store.useStateSetter("positionerElement")],
+    props: [positionerProps, getDisabledMountTransitionStyles(transitionStatus), elementProps]
+  });
+  const shouldRenderBackdrop = mounted && parent.type !== "menu" && (parent.type !== "menubar" && modal && lastOpenChangeReason !== triggerHover || parent.type === "menubar" && parent.context.modal);
+  let backdropCutout = null;
+  if (parent.type === "menubar") {
+    backdropCutout = parent.context.contentElement;
+  } else if (parent.type === void 0) {
+    backdropCutout = triggerElement;
+  }
+  return /* @__PURE__ */ jsxs(MenuPositionerContext.Provider, {
+    value: contextValue,
+    children: [shouldRenderBackdrop && /* @__PURE__ */ jsx(InternalBackdrop, {
+      ref: parent.type === "context-menu" || parent.type === "nested-context-menu" ? parent.context.internalBackdropRef : null,
+      inert: inertValue(!open),
+      cutout: backdropCutout
+    }), /* @__PURE__ */ jsx(FloatingNode, {
+      id: floatingNodeId,
+      children: /* @__PURE__ */ jsx(CompositeList, {
+        elementsRef: store.context.itemDomElements,
+        labelsRef: store.context.itemLabels,
+        children: element
+      })
+    })]
+  });
+});
+if (process.env.NODE_ENV !== "production") MenuPositioner.displayName = "MenuPositioner";
+export {
+  MenuPositioner
+};

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/menu/positioner/MenuPositionerContext.js

@@ -0,0 +1,15 @@
+import formatErrorMessage 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/formatErrorMessage.js";
+import * as React from "react";
+const MenuPositionerContext = /* @__PURE__ */ React.createContext(void 0);
+if (process.env.NODE_ENV !== "production") MenuPositionerContext.displayName = "MenuPositionerContext";
+function useMenuPositionerContext(optional) {
+  const context = React.useContext(MenuPositionerContext);
+  if (context === void 0 && !optional) {
+    throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: MenuPositionerContext is missing. MenuPositioner parts must be placed within <Menu.Positioner>." : formatErrorMessage(33));
+  }
+  return context;
+}
+export {
+  MenuPositionerContext,
+  useMenuPositionerContext
+};