@neynar/ui 0.3.1 → 0.5.0

package/dist/node_modules/@base-ui/react/esm/menu/root/MenuRoot.js

@@ -0,0 +1,402 @@
+"use client";
+import * as React from "react";
+import * as ReactDOM from "react-dom";
+import { useTimeout } from "../../../../utils/esm/useTimeout.js";
+import { useStableCallback } from "../../../../utils/esm/useStableCallback.js";
+import { useId } from "../../../../utils/esm/useId.js";
+import { useIsoLayoutEffect } from "../../../../utils/esm/useIsoLayoutEffect.js";
+import { useAnimationFrame } from "../../../../utils/esm/useAnimationFrame.js";
+import { useScrollLock } from "../../../../utils/esm/useScrollLock.js";
+import { EMPTY_ARRAY } from "../../../../utils/esm/empty.js";
+import { useMenuRootContext, MenuRootContext } from "./MenuRootContext.js";
+import { useMenubarContext } from "../../menubar/MenubarContext.js";
+import { TYPEAHEAD_RESET_MS } from "../../utils/constants.js";
+import { useDirection } from "../../direction-provider/DirectionContext.js";
+import { useOpenInteractionType } from "../../utils/useOpenInteractionType.js";
+import { createChangeEventDetails } from "../../utils/createBaseUIEventDetails.js";
+import { useContextMenuRootContext } from "../../context-menu/root/ContextMenuRootContext.js";
+import { MenuStore } from "../store/MenuStore.js";
+import { useMenuSubmenuRootContext } from "../submenu-root/MenuSubmenuRootContext.js";
+import { jsx } from "react/jsx-runtime";
+import { useFloatingNodeId, useFloatingParentNodeId, FloatingTree } from "../../floating-ui-react/components/FloatingTree.js";
+import { useSyncedFloatingRootContext } from "../../floating-ui-react/hooks/useSyncedFloatingRootContext.js";
+import { useDismiss } from "../../floating-ui-react/hooks/useDismiss.js";
+import { useRole } from "../../floating-ui-react/hooks/useRole.js";
+import { useListNavigation } from "../../floating-ui-react/hooks/useListNavigation.js";
+import { useTypeahead } from "../../floating-ui-react/hooks/useTypeahead.js";
+import { useInteractions } from "../../floating-ui-react/hooks/useInteractions.js";
+import { useImplicitActiveTrigger, useOpenStateTransitions } from "../../utils/popups/popupStoreUtils.js";
+import { triggerFocus, triggerPress, itemPress, triggerHover, focusOut, listNavigation, siblingOpen, escapeKey, imperativeAction } from "../../utils/reason-parts.js";
+import { mergeProps } from "../../merge-props/mergeProps.js";
+function MenuRoot(props) {
+  const {
+    children,
+    open: openProp,
+    onOpenChange,
+    onOpenChangeComplete,
+    defaultOpen = false,
+    disabled: disabledProp = false,
+    modal: modalProp,
+    loopFocus = true,
+    orientation = "vertical",
+    actionsRef,
+    closeParentOnEsc = false,
+    handle,
+    triggerId: triggerIdProp,
+    defaultTriggerId: defaultTriggerIdProp = null,
+    highlightItemOnHover = true
+  } = props;
+  const contextMenuContext = useContextMenuRootContext(true);
+  const parentMenuRootContext = useMenuRootContext(true);
+  const menubarContext = useMenubarContext(true);
+  const isSubmenu = useMenuSubmenuRootContext();
+  const parentFromContext = React.useMemo(() => {
+    if (isSubmenu && parentMenuRootContext) {
+      return {
+        type: "menu",
+        store: parentMenuRootContext.store
+      };
+    }
+    if (menubarContext) {
+      return {
+        type: "menubar",
+        context: menubarContext
+      };
+    }
+    if (contextMenuContext && !parentMenuRootContext) {
+      return {
+        type: "context-menu",
+        context: contextMenuContext
+      };
+    }
+    return {
+      type: void 0
+    };
+  }, [contextMenuContext, parentMenuRootContext, menubarContext, isSubmenu]);
+  const store = MenuStore.useStore(handle?.store, {
+    parent: parentFromContext
+  });
+  const floatingTreeRoot = store.useState("floatingTreeRoot");
+  const floatingNodeIdFromContext = useFloatingNodeId(floatingTreeRoot);
+  const floatingParentNodeIdFromContext = useFloatingParentNodeId();
+  useIsoLayoutEffect(() => {
+    if (contextMenuContext && !parentMenuRootContext) {
+      store.update({
+        parent: {
+          type: "context-menu",
+          context: contextMenuContext
+        },
+        floatingNodeId: floatingNodeIdFromContext,
+        floatingParentNodeId: floatingParentNodeIdFromContext
+      });
+    } else if (parentMenuRootContext) {
+      store.update({
+        floatingNodeId: floatingNodeIdFromContext,
+        floatingParentNodeId: floatingParentNodeIdFromContext
+      });
+    }
+  }, [contextMenuContext, parentMenuRootContext, floatingNodeIdFromContext, floatingParentNodeIdFromContext, store]);
+  store.useControlledProp("open", openProp, defaultOpen);
+  store.useControlledProp("activeTriggerId", triggerIdProp, defaultTriggerIdProp);
+  store.useContextCallback("onOpenChangeComplete", onOpenChangeComplete);
+  const open = store.useState("open");
+  const activeTriggerElement = store.useState("activeTriggerElement");
+  const positionerElement = store.useState("positionerElement");
+  const hoverEnabled = store.useState("hoverEnabled");
+  const modal = store.useState("modal");
+  const disabled = store.useState("disabled");
+  const lastOpenChangeReason = store.useState("lastOpenChangeReason");
+  const parent = store.useState("parent");
+  const activeIndex = store.useState("activeIndex");
+  const payload = store.useState("payload");
+  const floatingParentNodeId = store.useState("floatingParentNodeId");
+  const openEventRef = React.useRef(null);
+  const nested = floatingParentNodeId != null;
+  let floatingEvents;
+  if (process.env.NODE_ENV !== "production") {
+    if (parent.type !== void 0 && modalProp !== void 0) {
+      console.warn("Base UI: The `modal` prop is not supported on nested menus. It will be ignored.");
+    }
+  }
+  store.useSyncedValues({
+    disabled: disabledProp,
+    modal: parent.type === void 0 ? modalProp : void 0,
+    rootId: useId()
+  });
+  const {
+    openMethod,
+    triggerProps: interactionTypeProps,
+    reset: resetOpenInteractionType
+  } = useOpenInteractionType(open);
+  useImplicitActiveTrigger(store);
+  const {
+    forceUnmount
+  } = useOpenStateTransitions(open, store, () => {
+    store.update({
+      allowMouseEnter: false,
+      stickIfOpen: true
+    });
+    resetOpenInteractionType();
+  });
+  const allowOutsidePressDismissalRef = React.useRef(parent.type !== "context-menu");
+  const allowOutsidePressDismissalTimeout = useTimeout();
+  React.useEffect(() => {
+    if (!open) {
+      openEventRef.current = null;
+    }
+    if (parent.type !== "context-menu") {
+      return;
+    }
+    if (!open) {
+      allowOutsidePressDismissalTimeout.clear();
+      allowOutsidePressDismissalRef.current = false;
+      return;
+    }
+    allowOutsidePressDismissalTimeout.start(500, () => {
+      allowOutsidePressDismissalRef.current = true;
+    });
+  }, [allowOutsidePressDismissalTimeout, open, parent.type]);
+  useScrollLock(open && modal && lastOpenChangeReason !== triggerHover && openMethod !== "touch", positionerElement);
+  useIsoLayoutEffect(() => {
+    if (!open && !hoverEnabled) {
+      store.set("hoverEnabled", true);
+    }
+  }, [open, hoverEnabled, store]);
+  const allowTouchToCloseRef = React.useRef(true);
+  const allowTouchToCloseTimeout = useTimeout();
+  const setOpen = useStableCallback((nextOpen, eventDetails) => {
+    const reason = eventDetails.reason;
+    if (open === nextOpen && eventDetails.trigger === activeTriggerElement) {
+      return;
+    }
+    eventDetails.preventUnmountOnClose = () => {
+      store.set("preventUnmountingOnClose", true);
+    };
+    if (!nextOpen && eventDetails.trigger == null) {
+      eventDetails.trigger = activeTriggerElement ?? void 0;
+    }
+    onOpenChange?.(nextOpen, eventDetails);
+    if (eventDetails.isCanceled) {
+      return;
+    }
+    const details = {
+      open: nextOpen,
+      nativeEvent: eventDetails.event,
+      reason: eventDetails.reason,
+      nested
+    };
+    floatingEvents?.emit("openchange", details);
+    const nativeEvent = eventDetails.event;
+    if (nextOpen === false && nativeEvent?.type === "click" && nativeEvent.pointerType === "touch" && !allowTouchToCloseRef.current) {
+      return;
+    }
+    if (!nextOpen && activeIndex !== null) {
+      const activeOption = store.context.itemDomElements.current[activeIndex];
+      queueMicrotask(() => {
+        activeOption?.setAttribute("tabindex", "-1");
+      });
+    }
+    if (nextOpen && reason === triggerFocus) {
+      allowTouchToCloseRef.current = false;
+      allowTouchToCloseTimeout.start(300, () => {
+        allowTouchToCloseRef.current = true;
+      });
+    } else {
+      allowTouchToCloseRef.current = true;
+      allowTouchToCloseTimeout.clear();
+    }
+    const isKeyboardClick = (reason === triggerPress || reason === itemPress) && nativeEvent.detail === 0 && nativeEvent?.isTrusted;
+    const isDismissClose = !nextOpen && (reason === escapeKey || reason == null);
+    function changeState() {
+      const updatedState = {
+        open: nextOpen,
+        openChangeReason: reason
+      };
+      openEventRef.current = eventDetails.event ?? null;
+      const newTriggerId = eventDetails.trigger?.id ?? null;
+      if (newTriggerId || nextOpen) {
+        updatedState.activeTriggerId = newTriggerId;
+        updatedState.activeTriggerElement = eventDetails.trigger ?? null;
+      }
+      store.update(updatedState);
+    }
+    if (reason === triggerHover) {
+      ReactDOM.flushSync(changeState);
+    } else {
+      changeState();
+    }
+    if (parent.type === "menubar" && (reason === triggerFocus || reason === focusOut || reason === triggerHover || reason === listNavigation || reason === siblingOpen)) {
+      store.set("instantType", "group");
+    } else if (isKeyboardClick || isDismissClose) {
+      store.set("instantType", isKeyboardClick ? "click" : "dismiss");
+    } else {
+      store.set("instantType", void 0);
+    }
+  });
+  const createMenuEventDetails = React.useCallback((reason) => {
+    const details = createChangeEventDetails(reason);
+    details.preventUnmountOnClose = () => {
+      store.set("preventUnmountingOnClose", true);
+    };
+    return details;
+  }, [store]);
+  const handleImperativeClose = React.useCallback(() => {
+    store.setOpen(false, createMenuEventDetails(imperativeAction));
+  }, [store, createMenuEventDetails]);
+  React.useImperativeHandle(actionsRef, () => ({
+    unmount: forceUnmount,
+    close: handleImperativeClose
+  }), [forceUnmount, handleImperativeClose]);
+  let ctx;
+  if (parent.type === "context-menu") {
+    ctx = parent.context;
+  }
+  React.useImperativeHandle(ctx?.positionerRef, () => positionerElement, [positionerElement]);
+  React.useImperativeHandle(ctx?.actionsRef, () => ({
+    setOpen
+  }), [setOpen]);
+  const floatingRootContext = useSyncedFloatingRootContext({
+    popupStore: store,
+    onOpenChange: setOpen
+  });
+  floatingEvents = floatingRootContext.context.events;
+  React.useEffect(() => {
+    const handleSetOpenEvent = ({
+      open: nextOpen,
+      eventDetails
+    }) => setOpen(nextOpen, eventDetails);
+    floatingEvents.on("setOpen", handleSetOpenEvent);
+    return () => {
+      floatingEvents?.off("setOpen", handleSetOpenEvent);
+    };
+  }, [floatingEvents, setOpen]);
+  const dismiss = useDismiss(floatingRootContext, {
+    enabled: !disabled,
+    bubbles: closeParentOnEsc && parent.type === "menu",
+    outsidePress() {
+      if (parent.type !== "context-menu" || openEventRef.current?.type === "contextmenu") {
+        return true;
+      }
+      return allowOutsidePressDismissalRef.current;
+    },
+    externalTree: nested ? floatingTreeRoot : void 0
+  });
+  const role = useRole(floatingRootContext, {
+    role: "menu"
+  });
+  const direction = useDirection();
+  const setActiveIndex = React.useCallback((index) => {
+    if (store.select("activeIndex") === index) {
+      return;
+    }
+    store.set("activeIndex", index);
+  }, [store]);
+  const listNavigation$1 = useListNavigation(floatingRootContext, {
+    enabled: !disabled,
+    listRef: store.context.itemDomElements,
+    activeIndex,
+    nested: parent.type !== void 0,
+    loopFocus,
+    orientation,
+    parentOrientation: parent.type === "menubar" ? parent.context.orientation : void 0,
+    rtl: direction === "rtl",
+    disabledIndices: EMPTY_ARRAY,
+    onNavigate: setActiveIndex,
+    openOnArrowKeyDown: parent.type !== "context-menu",
+    externalTree: nested ? floatingTreeRoot : void 0,
+    focusItemOnHover: highlightItemOnHover
+  });
+  const onTypingChange = React.useCallback((nextTyping) => {
+    store.context.typingRef.current = nextTyping;
+  }, [store]);
+  const typeahead = useTypeahead(floatingRootContext, {
+    listRef: store.context.itemLabels,
+    activeIndex,
+    resetMs: TYPEAHEAD_RESET_MS,
+    onMatch: (index) => {
+      if (open && index !== activeIndex) {
+        store.set("activeIndex", index);
+      }
+    },
+    onTypingChange
+  });
+  const {
+    getReferenceProps,
+    getFloatingProps,
+    getItemProps,
+    getTriggerProps
+  } = useInteractions([dismiss, role, listNavigation$1, typeahead]);
+  const activeTriggerProps = React.useMemo(() => {
+    const mergedProps = mergeProps(getReferenceProps(), {
+      onMouseEnter() {
+        store.set("hoverEnabled", true);
+      },
+      onMouseMove() {
+        store.set("allowMouseEnter", true);
+      }
+    }, interactionTypeProps);
+    delete mergedProps.role;
+    return mergedProps;
+  }, [getReferenceProps, store, interactionTypeProps]);
+  const inactiveTriggerProps = React.useMemo(() => {
+    const triggerProps = getTriggerProps();
+    if (!triggerProps) {
+      return triggerProps;
+    }
+    const mergedProps = mergeProps(triggerProps, interactionTypeProps);
+    delete mergedProps.role;
+    delete mergedProps["aria-controls"];
+    return mergedProps;
+  }, [getTriggerProps, interactionTypeProps]);
+  const disableHoverTimeout = useAnimationFrame();
+  const popupProps = React.useMemo(() => getFloatingProps({
+    onMouseEnter() {
+      if (parent.type === "menu") {
+        disableHoverTimeout.request(() => store.set("hoverEnabled", false));
+      }
+    },
+    onMouseMove() {
+      store.set("allowMouseEnter", true);
+    },
+    onClick() {
+      if (store.select("hoverEnabled")) {
+        store.set("hoverEnabled", false);
+      }
+    },
+    onKeyDown(event) {
+      const relay = store.select("keyboardEventRelay");
+      if (relay && !event.isPropagationStopped()) {
+        relay(event);
+      }
+    }
+  }), [getFloatingProps, parent.type, disableHoverTimeout, store]);
+  const itemProps = React.useMemo(() => getItemProps(), [getItemProps]);
+  store.useSyncedValues({
+    floatingRootContext,
+    activeTriggerProps,
+    inactiveTriggerProps,
+    popupProps,
+    itemProps
+  });
+  const context = React.useMemo(() => ({
+    store,
+    parent: parentFromContext
+  }), [store, parentFromContext]);
+  const content = /* @__PURE__ */ jsx(MenuRootContext.Provider, {
+    value: context,
+    children: typeof children === "function" ? children({
+      payload
+    }) : children
+  });
+  if (parent.type === void 0 || parent.type === "context-menu") {
+    return /* @__PURE__ */ jsx(FloatingTree, {
+      externalTree: floatingTreeRoot,
+      children: content
+    });
+  }
+  return content;
+}
+export {
+  MenuRoot
+};
+//# sourceMappingURL=MenuRoot.js.map

package/dist/node_modules/@base-ui/react/esm/menu/root/MenuRoot.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MenuRoot.js","sources":["../../../../../../../node_modules/@base-ui/react/esm/menu/root/MenuRoot.js"],"sourcesContent":["'use client';\n\nimport * as React from 'react';\nimport * as ReactDOM from 'react-dom';\nimport { useTimeout } from '@base-ui/utils/useTimeout';\nimport { useStableCallback } from '@base-ui/utils/useStableCallback';\nimport { useId } from '@base-ui/utils/useId';\nimport { useIsoLayoutEffect } from '@base-ui/utils/useIsoLayoutEffect';\nimport { useAnimationFrame } from '@base-ui/utils/useAnimationFrame';\nimport { useScrollLock } from '@base-ui/utils/useScrollLock';\nimport { EMPTY_ARRAY } from '@base-ui/utils/empty';\nimport { FloatingTree, useDismiss, useFloatingNodeId, useFloatingParentNodeId, useInteractions, useListNavigation, useRole, useTypeahead, useSyncedFloatingRootContext } from \"../../floating-ui-react/index.js\";\nimport { MenuRootContext, useMenuRootContext } from \"./MenuRootContext.js\";\nimport { useMenubarContext } from \"../../menubar/MenubarContext.js\";\nimport { TYPEAHEAD_RESET_MS } from \"../../utils/constants.js\";\nimport { useDirection } from \"../../direction-provider/DirectionContext.js\";\nimport { useOpenInteractionType } from \"../../utils/useOpenInteractionType.js\";\nimport { createChangeEventDetails } from \"../../utils/createBaseUIEventDetails.js\";\nimport { REASONS } from \"../../utils/reasons.js\";\nimport { useContextMenuRootContext } from \"../../context-menu/root/ContextMenuRootContext.js\";\nimport { mergeProps } from \"../../merge-props/index.js\";\nimport { MenuStore } from \"../store/MenuStore.js\";\nimport { useImplicitActiveTrigger, useOpenStateTransitions } from \"../../utils/popups/index.js\";\nimport { useMenuSubmenuRootContext } from \"../submenu-root/MenuSubmenuRootContext.js\";\n\n/**\n * Groups all parts of the menu.\n * Doesn’t render its own HTML element.\n *\n * Documentation: [Base UI Menu](https://base-ui.com/react/components/menu)\n */\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nexport function MenuRoot(props) {\n  const {\n    children,\n    open: openProp,\n    onOpenChange,\n    onOpenChangeComplete,\n    defaultOpen = false,\n    disabled: disabledProp = false,\n    modal: modalProp,\n    loopFocus = true,\n    orientation = 'vertical',\n    actionsRef,\n    closeParentOnEsc = false,\n    handle,\n    triggerId: triggerIdProp,\n    defaultTriggerId: defaultTriggerIdProp = null,\n    highlightItemOnHover = true\n  } = props;\n  const contextMenuContext = useContextMenuRootContext(true);\n  const parentMenuRootContext = useMenuRootContext(true);\n  const menubarContext = useMenubarContext(true);\n  const isSubmenu = useMenuSubmenuRootContext();\n  const parentFromContext = React.useMemo(() => {\n    if (isSubmenu && parentMenuRootContext) {\n      return {\n        type: 'menu',\n        store: parentMenuRootContext.store\n      };\n    }\n    if (menubarContext) {\n      return {\n        type: 'menubar',\n        context: menubarContext\n      };\n    }\n\n    // Ensure this is not a Menu nested inside ContextMenu.Trigger.\n    // ContextMenu parentContext is always undefined as ContextMenu.Root is instantiated with\n    // <MenuRootContext.Provider value={undefined}>\n    if (contextMenuContext && !parentMenuRootContext) {\n      return {\n        type: 'context-menu',\n        context: contextMenuContext\n      };\n    }\n    return {\n      type: undefined\n    };\n  }, [contextMenuContext, parentMenuRootContext, menubarContext, isSubmenu]);\n  const store = MenuStore.useStore(handle?.store, {\n    parent: parentFromContext\n  });\n  const floatingTreeRoot = store.useState('floatingTreeRoot');\n  const floatingNodeIdFromContext = useFloatingNodeId(floatingTreeRoot);\n  const floatingParentNodeIdFromContext = useFloatingParentNodeId();\n  useIsoLayoutEffect(() => {\n    if (contextMenuContext && !parentMenuRootContext) {\n      // This is a context menu root.\n      // It doesn't support detached triggers yet, so we have to sync the parent context manually.\n      store.update({\n        parent: {\n          type: 'context-menu',\n          context: contextMenuContext\n        },\n        floatingNodeId: floatingNodeIdFromContext,\n        floatingParentNodeId: floatingParentNodeIdFromContext\n      });\n    } else if (parentMenuRootContext) {\n      store.update({\n        floatingNodeId: floatingNodeIdFromContext,\n        floatingParentNodeId: floatingParentNodeIdFromContext\n      });\n    }\n  }, [contextMenuContext, parentMenuRootContext, floatingNodeIdFromContext, floatingParentNodeIdFromContext, store]);\n  store.useControlledProp('open', openProp, defaultOpen);\n  store.useControlledProp('activeTriggerId', triggerIdProp, defaultTriggerIdProp);\n  store.useContextCallback('onOpenChangeComplete', onOpenChangeComplete);\n  const open = store.useState('open');\n  const activeTriggerElement = store.useState('activeTriggerElement');\n  const positionerElement = store.useState('positionerElement');\n  const hoverEnabled = store.useState('hoverEnabled');\n  const modal = store.useState('modal');\n  const disabled = store.useState('disabled');\n  const lastOpenChangeReason = store.useState('lastOpenChangeReason');\n  const parent = store.useState('parent');\n  const activeIndex = store.useState('activeIndex');\n  const payload = store.useState('payload');\n  const floatingParentNodeId = store.useState('floatingParentNodeId');\n  const openEventRef = React.useRef(null);\n  const nested = floatingParentNodeId != null;\n  let floatingEvents;\n  if (process.env.NODE_ENV !== 'production') {\n    if (parent.type !== undefined && modalProp !== undefined) {\n      console.warn('Base UI: The `modal` prop is not supported on nested menus. It will be ignored.');\n    }\n  }\n  store.useSyncedValues({\n    disabled: disabledProp,\n    modal: parent.type === undefined ? modalProp : undefined,\n    rootId: useId()\n  });\n  const {\n    openMethod,\n    triggerProps: interactionTypeProps,\n    reset: resetOpenInteractionType\n  } = useOpenInteractionType(open);\n  useImplicitActiveTrigger(store);\n  const {\n    forceUnmount\n  } = useOpenStateTransitions(open, store, () => {\n    store.update({\n      allowMouseEnter: false,\n      stickIfOpen: true\n    });\n    resetOpenInteractionType();\n  });\n  const allowOutsidePressDismissalRef = React.useRef(parent.type !== 'context-menu');\n  const allowOutsidePressDismissalTimeout = useTimeout();\n  React.useEffect(() => {\n    if (!open) {\n      openEventRef.current = null;\n    }\n    if (parent.type !== 'context-menu') {\n      return;\n    }\n    if (!open) {\n      allowOutsidePressDismissalTimeout.clear();\n      allowOutsidePressDismissalRef.current = false;\n      return;\n    }\n\n    // With `mousedown` outside press events and long press touch input, there\n    // needs to be a grace period after opening to ensure the dismissal event\n    // doesn't fire immediately after open.\n    allowOutsidePressDismissalTimeout.start(500, () => {\n      allowOutsidePressDismissalRef.current = true;\n    });\n  }, [allowOutsidePressDismissalTimeout, open, parent.type]);\n  useScrollLock(open && modal && lastOpenChangeReason !== REASONS.triggerHover && openMethod !== 'touch', positionerElement);\n  useIsoLayoutEffect(() => {\n    if (!open && !hoverEnabled) {\n      store.set('hoverEnabled', true);\n    }\n  }, [open, hoverEnabled, store]);\n  const allowTouchToCloseRef = React.useRef(true);\n  const allowTouchToCloseTimeout = useTimeout();\n  const setOpen = useStableCallback((nextOpen, eventDetails) => {\n    const reason = eventDetails.reason;\n    if (open === nextOpen && eventDetails.trigger === activeTriggerElement) {\n      return;\n    }\n    eventDetails.preventUnmountOnClose = () => {\n      store.set('preventUnmountingOnClose', true);\n    };\n\n    // Do not immediately reset the activeTriggerId to allow\n    // exit animations to play and focus to be returned correctly.\n    if (!nextOpen && eventDetails.trigger == null) {\n      eventDetails.trigger = activeTriggerElement ?? undefined;\n    }\n    onOpenChange?.(nextOpen, eventDetails);\n    if (eventDetails.isCanceled) {\n      return;\n    }\n    const details = {\n      open: nextOpen,\n      nativeEvent: eventDetails.event,\n      reason: eventDetails.reason,\n      nested\n    };\n    floatingEvents?.emit('openchange', details);\n    const nativeEvent = eventDetails.event;\n    if (nextOpen === false && nativeEvent?.type === 'click' && nativeEvent.pointerType === 'touch' && !allowTouchToCloseRef.current) {\n      return;\n    }\n\n    // Workaround `enableFocusInside` in Floating UI setting `tabindex=0` of a non-highlighted\n    // option upon close when tabbing out due to `keepMounted=true`:\n    // https://github.com/floating-ui/floating-ui/pull/3004/files#diff-962a7439cdeb09ea98d4b622a45d517bce07ad8c3f866e089bda05f4b0bbd875R194-R199\n    // This otherwise causes options to retain `tabindex=0` incorrectly when the popup is closed\n    // when tabbing outside.\n    if (!nextOpen && activeIndex !== null) {\n      const activeOption = store.context.itemDomElements.current[activeIndex];\n      // Wait for Floating UI's focus effect to have fired\n      queueMicrotask(() => {\n        activeOption?.setAttribute('tabindex', '-1');\n      });\n    }\n\n    // Prevent the menu from closing on mobile devices that have a delayed click event.\n    // In some cases the menu, when tapped, will fire the focus event first and then the click event.\n    // Without this guard, the menu will close immediately after opening.\n    if (nextOpen && reason === REASONS.triggerFocus) {\n      allowTouchToCloseRef.current = false;\n      allowTouchToCloseTimeout.start(300, () => {\n        allowTouchToCloseRef.current = true;\n      });\n    } else {\n      allowTouchToCloseRef.current = true;\n      allowTouchToCloseTimeout.clear();\n    }\n    const isKeyboardClick = (reason === REASONS.triggerPress || reason === REASONS.itemPress) && nativeEvent.detail === 0 && nativeEvent?.isTrusted;\n    const isDismissClose = !nextOpen && (reason === REASONS.escapeKey || reason == null);\n    function changeState() {\n      const updatedState = {\n        open: nextOpen,\n        openChangeReason: reason\n      };\n      openEventRef.current = eventDetails.event ?? null;\n\n      // If a popup is closing, the `trigger` may be null.\n      // We want to keep the previous value so that exit animations are played and focus is returned correctly.\n      const newTriggerId = eventDetails.trigger?.id ?? null;\n      if (newTriggerId || nextOpen) {\n        updatedState.activeTriggerId = newTriggerId;\n        updatedState.activeTriggerElement = eventDetails.trigger ?? null;\n      }\n      store.update(updatedState);\n    }\n    if (reason === REASONS.triggerHover) {\n      ReactDOM.flushSync(changeState);\n    } else {\n      changeState();\n    }\n    if (parent.type === 'menubar' && (reason === REASONS.triggerFocus || reason === REASONS.focusOut || reason === REASONS.triggerHover || reason === REASONS.listNavigation || reason === REASONS.siblingOpen)) {\n      store.set('instantType', 'group');\n    } else if (isKeyboardClick || isDismissClose) {\n      store.set('instantType', isKeyboardClick ? 'click' : 'dismiss');\n    } else {\n      store.set('instantType', undefined);\n    }\n  });\n  const createMenuEventDetails = React.useCallback(reason => {\n    const details = createChangeEventDetails(reason);\n    details.preventUnmountOnClose = () => {\n      store.set('preventUnmountingOnClose', true);\n    };\n    return details;\n  }, [store]);\n  const handleImperativeClose = React.useCallback(() => {\n    store.setOpen(false, createMenuEventDetails(REASONS.imperativeAction));\n  }, [store, createMenuEventDetails]);\n  React.useImperativeHandle(actionsRef, () => ({\n    unmount: forceUnmount,\n    close: handleImperativeClose\n  }), [forceUnmount, handleImperativeClose]);\n  let ctx;\n  if (parent.type === 'context-menu') {\n    ctx = parent.context;\n  }\n  React.useImperativeHandle(ctx?.positionerRef, () => positionerElement, [positionerElement]);\n  React.useImperativeHandle(ctx?.actionsRef, () => ({\n    setOpen\n  }), [setOpen]);\n  const floatingRootContext = useSyncedFloatingRootContext({\n    popupStore: store,\n    onOpenChange: setOpen\n  });\n  floatingEvents = floatingRootContext.context.events;\n  React.useEffect(() => {\n    const handleSetOpenEvent = ({\n      open: nextOpen,\n      eventDetails\n    }) => setOpen(nextOpen, eventDetails);\n    floatingEvents.on('setOpen', handleSetOpenEvent);\n    return () => {\n      floatingEvents?.off('setOpen', handleSetOpenEvent);\n    };\n  }, [floatingEvents, setOpen]);\n  const dismiss = useDismiss(floatingRootContext, {\n    enabled: !disabled,\n    bubbles: closeParentOnEsc && parent.type === 'menu',\n    outsidePress() {\n      if (parent.type !== 'context-menu' || openEventRef.current?.type === 'contextmenu') {\n        return true;\n      }\n      return allowOutsidePressDismissalRef.current;\n    },\n    externalTree: nested ? floatingTreeRoot : undefined\n  });\n  const role = useRole(floatingRootContext, {\n    role: 'menu'\n  });\n  const direction = useDirection();\n  const setActiveIndex = React.useCallback(index => {\n    if (store.select('activeIndex') === index) {\n      return;\n    }\n    store.set('activeIndex', index);\n  }, [store]);\n  const listNavigation = useListNavigation(floatingRootContext, {\n    enabled: !disabled,\n    listRef: store.context.itemDomElements,\n    activeIndex,\n    nested: parent.type !== undefined,\n    loopFocus,\n    orientation,\n    parentOrientation: parent.type === 'menubar' ? parent.context.orientation : undefined,\n    rtl: direction === 'rtl',\n    disabledIndices: EMPTY_ARRAY,\n    onNavigate: setActiveIndex,\n    openOnArrowKeyDown: parent.type !== 'context-menu',\n    externalTree: nested ? floatingTreeRoot : undefined,\n    focusItemOnHover: highlightItemOnHover\n  });\n  const onTypingChange = React.useCallback(nextTyping => {\n    store.context.typingRef.current = nextTyping;\n  }, [store]);\n  const typeahead = useTypeahead(floatingRootContext, {\n    listRef: store.context.itemLabels,\n    activeIndex,\n    resetMs: TYPEAHEAD_RESET_MS,\n    onMatch: index => {\n      if (open && index !== activeIndex) {\n        store.set('activeIndex', index);\n      }\n    },\n    onTypingChange\n  });\n  const {\n    getReferenceProps,\n    getFloatingProps,\n    getItemProps,\n    getTriggerProps\n  } = useInteractions([dismiss, role, listNavigation, typeahead]);\n  const activeTriggerProps = React.useMemo(() => {\n    const mergedProps = mergeProps(getReferenceProps(), {\n      onMouseEnter() {\n        store.set('hoverEnabled', true);\n      },\n      onMouseMove() {\n        store.set('allowMouseEnter', true);\n      }\n    }, interactionTypeProps);\n    delete mergedProps.role;\n    return mergedProps;\n  }, [getReferenceProps, store, interactionTypeProps]);\n  const inactiveTriggerProps = React.useMemo(() => {\n    const triggerProps = getTriggerProps();\n    if (!triggerProps) {\n      return triggerProps;\n    }\n    const mergedProps = mergeProps(triggerProps, interactionTypeProps);\n    delete mergedProps.role;\n    delete mergedProps['aria-controls'];\n    return mergedProps;\n  }, [getTriggerProps, interactionTypeProps]);\n  const disableHoverTimeout = useAnimationFrame();\n  const popupProps = React.useMemo(() => getFloatingProps({\n    onMouseEnter() {\n      if (parent.type === 'menu') {\n        disableHoverTimeout.request(() => store.set('hoverEnabled', false));\n      }\n    },\n    onMouseMove() {\n      store.set('allowMouseEnter', true);\n    },\n    onClick() {\n      if (store.select('hoverEnabled')) {\n        store.set('hoverEnabled', false);\n      }\n    },\n    onKeyDown(event) {\n      // The Menubar's CompositeRoot captures keyboard events via\n      // event delegation. This works well when Menu.Root is nested inside Menubar,\n      // but with detached triggers we need to manually forward the event to the CompositeRoot.\n      const relay = store.select('keyboardEventRelay');\n      if (relay && !event.isPropagationStopped()) {\n        relay(event);\n      }\n    }\n  }), [getFloatingProps, parent.type, disableHoverTimeout, store]);\n  const itemProps = React.useMemo(() => getItemProps(), [getItemProps]);\n  store.useSyncedValues({\n    floatingRootContext,\n    activeTriggerProps,\n    inactiveTriggerProps,\n    popupProps,\n    itemProps\n  });\n  const context = React.useMemo(() => ({\n    store,\n    parent: parentFromContext\n  }), [store, parentFromContext]);\n  const content = /*#__PURE__*/_jsx(MenuRootContext.Provider, {\n    value: context,\n    children: typeof children === 'function' ? children({\n      payload\n    }) : children\n  });\n  if (parent.type === undefined || parent.type === 'context-menu') {\n    // set up a FloatingTree to provide the context to nested menus\n    return /*#__PURE__*/_jsx(FloatingTree, {\n      externalTree: floatingTreeRoot,\n      children: content\n    });\n  }\n  return content;\n}"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCO;AACL;AAAM;AACJ;AACM;AACN;AACA;AACc;AACW;AAClB;AACK;AACE;AACd;AACmB;AACnB;AACW;AAC8B;AAClB;AAEzB;AACA;AACA;AACA;AACA;AACE;AACE;AAAO;AACC;AACuB;AACrC;AAEI;AACE;AAAO;AACC;AACG;AACjB;AAMI;AACE;AAAO;AACC;AACG;AACjB;AAEI;AAAO;AACC;AACZ;AAEE;AAAgD;AACtC;AAEV;AACA;AACA;AACA;AACE;AAGE;AAAa;AACH;AACA;AACG;AACnB;AACwB;AACM;AACvB;AAED;AAAa;AACK;AACM;AACvB;AACH;AAEF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACE;AACE;AAA8F;AAChG;AAEF;AAAsB;AACV;AACqC;AAClC;AAEf;AAAM;AACJ;AACc;AACP;AAET;AACA;AAAM;AACJ;AAEA;AAAa;AACM;AACJ;AAEf;AAAwB;AAE1B;AACA;AACA;AACE;AACE;AAAuB;AAEzB;AACE;AAAA;AAEF;AACE;AACA;AACA;AAAA;AAMF;AACE;AAAwC;AACzC;AAEH;AACA;AACE;AACE;AAA8B;AAChC;AAEF;AACA;AACA;AACE;AACA;AACE;AAAA;AAEF;AACE;AAA0C;AAK5C;AACE;AAA+C;AAEjD;AACA;AACE;AAAA;AAEF;AAAgB;AACR;AACoB;AACL;AACrB;AAEF;AACA;AACA;AACE;AAAA;AAQF;AACE;AAEA;AACE;AAA2C;AAC5C;AAMH;AACE;AACA;AACE;AAA+B;AAChC;AAED;AACA;AAA8B;AAEhC;AACA;AACA;AACE;AAAqB;AACb;AACY;AAEpB;AAIA;AACA;AACE;AACA;AAA4D;AAE9D;AAAyB;AAE3B;AACE;AAA8B;AAE9B;AAAW;AAEb;AACE;AAAgC;AAEhC;AAA8D;AAE9D;AAAkC;AACpC;AAEF;AACE;AACA;AACE;AAA0C;AAE5C;AAAO;AAET;AACE;AAAqE;AAEvE;AAA6C;AAClC;AACF;AAET;AACA;AACE;AAAa;AAEf;AACA;AAAkD;AAChD;AAEF;AAAyD;AAC3C;AACE;AAEhB;AACA;AACE;AAA4B;AACpB;AACN;AAEF;AACA;AACE;AAAiD;AACnD;AAEF;AAAgD;AACpC;AACmC;AAE3C;AACE;AAAO;AAET;AAAqC;AACvC;AAC0C;AAE5C;AAA0C;AAClC;AAER;AACA;AACE;AACE;AAAA;AAEF;AAA8B;AAEhC;AAA8D;AAClD;AACa;AACvB;AACwB;AACxB;AACA;AAC4E;AACzD;AACF;AACL;AACwB;AACM;AACxB;AAEpB;AACE;AAAkC;AAEpC;AAAoD;AAC3B;AACvB;AACS;AAEP;AACE;AAA8B;AAChC;AACF;AACA;AAEF;AAAM;AACJ;AACA;AACA;AACA;AAEF;AACE;AAAoD;AAEhD;AAA8B;AAChC;AAEE;AAAiC;AACnC;AAEF;AACA;AAAO;AAET;AACE;AACA;AACE;AAAO;AAET;AACA;AACA;AACA;AAAO;AAET;AACA;AAAwD;AAEpD;AACE;AAAkE;AACpE;AACF;AAEE;AAAiC;AACnC;AAEE;AACE;AAA+B;AACjC;AACF;AAKE;AACA;AACE;AAAW;AACb;AACF;AAEF;AACA;AAAsB;AACpB;AACA;AACA;AACA;AACA;AAEF;AAAqC;AACnC;AACQ;AAEV;AAA4D;AACnD;AAC6C;AAClD;AACG;AAEP;AAEE;AAAuC;AACvB;AACJ;AACX;AAEH;AACF;;;;","x_google_ignoreList":[0]}

package/dist/node_modules/@base-ui/react/esm/menu/root/MenuRootContext.js

@@ -0,0 +1,17 @@
+"use client";
+import formatErrorMessage from "../../../../utils/esm/formatErrorMessage.js";
+import * as React from "react";
+const MenuRootContext = /* @__PURE__ */ React.createContext(void 0);
+if (process.env.NODE_ENV !== "production") MenuRootContext.displayName = "MenuRootContext";
+function useMenuRootContext(optional) {
+  const context = React.useContext(MenuRootContext);
+  if (context === void 0 && !optional) {
+    throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: MenuRootContext is missing. Menu parts must be placed within <Menu.Root>." : formatErrorMessage(36));
+  }
+  return context;
+}
+export {
+  MenuRootContext,
+  useMenuRootContext
+};
+//# sourceMappingURL=MenuRootContext.js.map

package/dist/node_modules/@base-ui/react/esm/menu/root/MenuRootContext.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MenuRootContext.js","sources":["../../../../../../../node_modules/@base-ui/react/esm/menu/root/MenuRootContext.js"],"sourcesContent":["'use client';\n\nimport _formatErrorMessage from \"@base-ui/utils/formatErrorMessage\";\nimport * as React from 'react';\nexport const MenuRootContext = /*#__PURE__*/React.createContext(undefined);\nif (process.env.NODE_ENV !== \"production\") MenuRootContext.displayName = \"MenuRootContext\";\nexport function useMenuRootContext(optional) {\n  const context = React.useContext(MenuRootContext);\n  if (context === undefined && !optional) {\n    throw new Error(process.env.NODE_ENV !== \"production\" ? 'Base UI: MenuRootContext is missing. Menu parts must be placed within <Menu.Root>.' : _formatErrorMessage(36));\n  }\n  return context;\n}"],"names":[],"mappings":";;;AAIY;AACZ;AACO;AACL;AACA;AACE;AAAsK;AAExK;AACF;;;;;","x_google_ignoreList":[0]}

package/dist/node_modules/@base-ui/react/esm/menu/store/MenuStore.js

@@ -0,0 +1,132 @@
+import * as React from "react";
+import { EMPTY_OBJECT } from "../../../../utils/esm/empty.js";
+import { useRefWithInit } from "../../../../utils/esm/useRefWithInit.js";
+import { FloatingTreeStore } from "../../floating-ui-react/components/FloatingTreeStore.js";
+import { ReactStore } from "../../../../utils/esm/store/ReactStore.js";
+import { PopupTriggerMap } from "../../utils/popups/popupTriggerMap.js";
+import { createSelector } from "../../../../utils/esm/store/createSelector.js";
+import { popupStoreSelectors, createInitialPopupStoreState } from "../../utils/popups/store.js";
+const selectors = {
+  ...popupStoreSelectors,
+  disabled: createSelector((state) => state.parent.type === "menubar" ? state.parent.context.disabled || state.disabled : state.disabled),
+  modal: createSelector((state) => (state.parent.type === void 0 || state.parent.type === "context-menu") && (state.modal ?? true)),
+  allowMouseEnter: createSelector((state) => state.parent.type === "menu" ? state.parent.store.select("allowMouseEnter") : state.allowMouseEnter),
+  stickIfOpen: createSelector((state) => state.stickIfOpen),
+  parent: createSelector((state) => state.parent),
+  rootId: createSelector((state) => {
+    if (state.parent.type === "menu") {
+      return state.parent.store.select("rootId");
+    }
+    return state.parent.type !== void 0 ? state.parent.context.rootId : state.rootId;
+  }),
+  activeIndex: createSelector((state) => state.activeIndex),
+  isActive: createSelector((state, itemIndex) => state.activeIndex === itemIndex),
+  hoverEnabled: createSelector((state) => state.hoverEnabled),
+  instantType: createSelector((state) => state.instantType),
+  lastOpenChangeReason: createSelector((state) => state.openChangeReason),
+  floatingTreeRoot: createSelector((state) => {
+    if (state.parent.type === "menu") {
+      return state.parent.store.select("floatingTreeRoot");
+    }
+    return state.floatingTreeRoot;
+  }),
+  floatingNodeId: createSelector((state) => state.floatingNodeId),
+  floatingParentNodeId: createSelector((state) => state.floatingParentNodeId),
+  itemProps: createSelector((state) => state.itemProps),
+  closeDelay: createSelector((state) => state.closeDelay),
+  keyboardEventRelay: createSelector((state) => {
+    if (state.keyboardEventRelay) {
+      return state.keyboardEventRelay;
+    }
+    if (state.parent.type === "menu") {
+      return state.parent.store.select("keyboardEventRelay");
+    }
+    return void 0;
+  })
+};
+class MenuStore extends ReactStore {
+  constructor(initialState) {
+    super({
+      ...createInitialState(),
+      ...initialState
+    }, {
+      positionerRef: /* @__PURE__ */ React.createRef(),
+      popupRef: /* @__PURE__ */ React.createRef(),
+      typingRef: {
+        current: false
+      },
+      itemDomElements: {
+        current: []
+      },
+      itemLabels: {
+        current: []
+      },
+      allowMouseUpTriggerRef: {
+        current: false
+      },
+      triggerFocusTargetRef: /* @__PURE__ */ React.createRef(),
+      beforeContentFocusGuardRef: /* @__PURE__ */ React.createRef(),
+      onOpenChangeComplete: void 0,
+      triggerElements: new PopupTriggerMap()
+    }, selectors);
+    this.observe(createSelector((state) => state.allowMouseEnter), (allowMouseEnter, oldValue) => {
+      if (this.state.parent.type === "menu" && allowMouseEnter !== oldValue) {
+        this.state.parent.store.set("allowMouseEnter", allowMouseEnter);
+      }
+    });
+    this.unsubscribeParentListener = this.observe("parent", (parent) => {
+      this.unsubscribeParentListener?.();
+      if (parent.type === "menu") {
+        this.unsubscribeParentListener = parent.store.subscribe(() => {
+          this.notifyAll();
+        });
+        this.context.allowMouseUpTriggerRef = parent.store.context.allowMouseUpTriggerRef;
+        return;
+      }
+      if (parent.type !== void 0) {
+        this.context.allowMouseUpTriggerRef = parent.context.allowMouseUpTriggerRef;
+      }
+      this.unsubscribeParentListener = null;
+    });
+  }
+  setOpen(open, eventDetails) {
+    this.state.floatingRootContext.context.events.emit("setOpen", {
+      open,
+      eventDetails
+    });
+  }
+  static useStore(externalStore, initialState) {
+    const store = useRefWithInit(() => {
+      return externalStore ?? new MenuStore(initialState);
+    }).current;
+    return store;
+  }
+  unsubscribeParentListener = null;
+}
+function createInitialState() {
+  return {
+    ...createInitialPopupStoreState(),
+    disabled: false,
+    modal: true,
+    allowMouseEnter: true,
+    stickIfOpen: true,
+    parent: {
+      type: void 0
+    },
+    rootId: void 0,
+    activeIndex: null,
+    hoverEnabled: true,
+    instantType: void 0,
+    openChangeReason: null,
+    floatingTreeRoot: new FloatingTreeStore(),
+    floatingNodeId: void 0,
+    floatingParentNodeId: null,
+    itemProps: EMPTY_OBJECT,
+    keyboardEventRelay: void 0,
+    closeDelay: 0
+  };
+}
+export {
+  MenuStore
+};
+//# sourceMappingURL=MenuStore.js.map

package/dist/node_modules/@base-ui/react/esm/menu/store/MenuStore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MenuStore.js","sources":["../../../../../../../node_modules/@base-ui/react/esm/menu/store/MenuStore.js"],"sourcesContent":["import * as React from 'react';\nimport { createSelector, ReactStore } from '@base-ui/utils/store';\nimport { EMPTY_OBJECT } from '@base-ui/utils/empty';\nimport { useRefWithInit } from '@base-ui/utils/useRefWithInit';\nimport { FloatingTreeStore } from \"../../floating-ui-react/components/FloatingTreeStore.js\";\nimport { createInitialPopupStoreState, popupStoreSelectors, PopupTriggerMap } from \"../../utils/popups/index.js\";\nconst selectors = {\n  ...popupStoreSelectors,\n  disabled: createSelector(state => state.parent.type === 'menubar' ? state.parent.context.disabled || state.disabled : state.disabled),\n  modal: createSelector(state => (state.parent.type === undefined || state.parent.type === 'context-menu') && (state.modal ?? true)),\n  allowMouseEnter: createSelector(state => state.parent.type === 'menu' ? state.parent.store.select('allowMouseEnter') : state.allowMouseEnter),\n  stickIfOpen: createSelector(state => state.stickIfOpen),\n  parent: createSelector(state => state.parent),\n  rootId: createSelector(state => {\n    if (state.parent.type === 'menu') {\n      return state.parent.store.select('rootId');\n    }\n    return state.parent.type !== undefined ? state.parent.context.rootId : state.rootId;\n  }),\n  activeIndex: createSelector(state => state.activeIndex),\n  isActive: createSelector((state, itemIndex) => state.activeIndex === itemIndex),\n  hoverEnabled: createSelector(state => state.hoverEnabled),\n  instantType: createSelector(state => state.instantType),\n  lastOpenChangeReason: createSelector(state => state.openChangeReason),\n  floatingTreeRoot: createSelector(state => {\n    if (state.parent.type === 'menu') {\n      return state.parent.store.select('floatingTreeRoot');\n    }\n    return state.floatingTreeRoot;\n  }),\n  floatingNodeId: createSelector(state => state.floatingNodeId),\n  floatingParentNodeId: createSelector(state => state.floatingParentNodeId),\n  itemProps: createSelector(state => state.itemProps),\n  closeDelay: createSelector(state => state.closeDelay),\n  keyboardEventRelay: createSelector(state => {\n    if (state.keyboardEventRelay) {\n      return state.keyboardEventRelay;\n    }\n    if (state.parent.type === 'menu') {\n      return state.parent.store.select('keyboardEventRelay');\n    }\n    return undefined;\n  })\n};\nexport class MenuStore extends ReactStore {\n  constructor(initialState) {\n    super({\n      ...createInitialState(),\n      ...initialState\n    }, {\n      positionerRef: /*#__PURE__*/React.createRef(),\n      popupRef: /*#__PURE__*/React.createRef(),\n      typingRef: {\n        current: false\n      },\n      itemDomElements: {\n        current: []\n      },\n      itemLabels: {\n        current: []\n      },\n      allowMouseUpTriggerRef: {\n        current: false\n      },\n      triggerFocusTargetRef: /*#__PURE__*/React.createRef(),\n      beforeContentFocusGuardRef: /*#__PURE__*/React.createRef(),\n      onOpenChangeComplete: undefined,\n      triggerElements: new PopupTriggerMap()\n    }, selectors);\n\n    // Sync `allowMouseEnter` with parent menu if applicable.\n    this.observe(createSelector(state => state.allowMouseEnter), (allowMouseEnter, oldValue) => {\n      // The allowMouseEnter !== oldValue check prevent calling parent store's set\n      // on intialization. Without it, React might complain about updating one component during rendering another.\n      if (this.state.parent.type === 'menu' && allowMouseEnter !== oldValue) {\n        this.state.parent.store.set('allowMouseEnter', allowMouseEnter);\n      }\n    });\n\n    // Set up propagation of state from parent menu if applicable.\n    this.unsubscribeParentListener = this.observe('parent', parent => {\n      this.unsubscribeParentListener?.();\n      if (parent.type === 'menu') {\n        this.unsubscribeParentListener = parent.store.subscribe(() => {\n          this.notifyAll();\n        });\n        this.context.allowMouseUpTriggerRef = parent.store.context.allowMouseUpTriggerRef;\n        return;\n      }\n      if (parent.type !== undefined) {\n        this.context.allowMouseUpTriggerRef = parent.context.allowMouseUpTriggerRef;\n      }\n      this.unsubscribeParentListener = null;\n    });\n  }\n  setOpen(open, eventDetails) {\n    this.state.floatingRootContext.context.events.emit('setOpen', {\n      open,\n      eventDetails\n    });\n  }\n  static useStore(externalStore, initialState) {\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    const store = useRefWithInit(() => {\n      return externalStore ?? new MenuStore(initialState);\n    }).current;\n    return store;\n  }\n  unsubscribeParentListener = null;\n}\nfunction createInitialState() {\n  return {\n    ...createInitialPopupStoreState(),\n    disabled: false,\n    modal: true,\n    allowMouseEnter: true,\n    stickIfOpen: true,\n    parent: {\n      type: undefined\n    },\n    rootId: undefined,\n    activeIndex: null,\n    hoverEnabled: true,\n    instantType: undefined,\n    openChangeReason: null,\n    floatingTreeRoot: new FloatingTreeStore(),\n    floatingNodeId: undefined,\n    floatingParentNodeId: null,\n    itemProps: EMPTY_OBJECT,\n    keyboardEventRelay: undefined,\n    closeDelay: 0\n  };\n}"],"names":[],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/@base-ui/react/esm/menu/submenu-root/MenuSubmenuRoot.js

@@ -0,0 +1,24 @@
+"use client";
+import * as React from "react";
+import { MenuRoot } from "../root/MenuRoot.js";
+import { useMenuRootContext } from "../root/MenuRootContext.js";
+import { MenuSubmenuRootContext } from "./MenuSubmenuRootContext.js";
+import { useMenuSubmenuRootContext } from "./MenuSubmenuRootContext.js";
+import { jsx } from "react/jsx-runtime";
+function MenuSubmenuRoot(props) {
+  const parentMenu = useMenuRootContext().store;
+  const contextValue = React.useMemo(() => ({
+    parentMenu
+  }), [parentMenu]);
+  return /* @__PURE__ */ jsx(MenuSubmenuRootContext.Provider, {
+    value: contextValue,
+    children: /* @__PURE__ */ jsx(MenuRoot, {
+      ...props
+    })
+  });
+}
+export {
+  MenuSubmenuRoot,
+  useMenuSubmenuRootContext
+};
+//# sourceMappingURL=MenuSubmenuRoot.js.map

package/dist/node_modules/@base-ui/react/esm/menu/submenu-root/MenuSubmenuRoot.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MenuSubmenuRoot.js","sources":["../../../../../../../node_modules/@base-ui/react/esm/menu/submenu-root/MenuSubmenuRoot.js"],"sourcesContent":["'use client';\n\nimport * as React from 'react';\nimport { MenuRoot } from \"../root/MenuRoot.js\";\nimport { useMenuRootContext } from \"../root/MenuRootContext.js\";\nimport { MenuSubmenuRootContext } from \"./MenuSubmenuRootContext.js\";\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nexport { useMenuSubmenuRootContext } from \"./MenuSubmenuRootContext.js\";\n\n/**\n * Groups all parts of a submenu.\n * Doesn’t render its own HTML element.\n *\n * Documentation: [Base UI Menu](https://base-ui.com/react/components/menu)\n */\nexport function MenuSubmenuRoot(props) {\n  const parentMenu = useMenuRootContext().store;\n  const contextValue = React.useMemo(() => ({\n    parentMenu\n  }), [parentMenu]);\n  return /*#__PURE__*/_jsx(MenuSubmenuRootContext.Provider, {\n    value: contextValue,\n    children: /*#__PURE__*/_jsx(MenuRoot, {\n      ...props\n    })\n  });\n}"],"names":[],"mappings":";;;;;;;AAeO;AACL;AACA;AAA0C;AACxC;AAEF;AAA0D;AACjD;AAC+B;AACjC;AACJ;AAEL;;;;;","x_google_ignoreList":[0]}

package/dist/node_modules/@base-ui/react/esm/menu/submenu-root/MenuSubmenuRootContext.js

@@ -0,0 +1,11 @@
+import * as React from "react";
+const MenuSubmenuRootContext = /* @__PURE__ */ React.createContext(void 0);
+if (process.env.NODE_ENV !== "production") MenuSubmenuRootContext.displayName = "MenuSubmenuRootContext";
+function useMenuSubmenuRootContext() {
+  return React.useContext(MenuSubmenuRootContext);
+}
+export {
+  MenuSubmenuRootContext,
+  useMenuSubmenuRootContext
+};
+//# sourceMappingURL=MenuSubmenuRootContext.js.map