@neynar/ui 0.4.0 → 1.0.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"MenuSubmenuRootContext.js","sources":["../../../../../../../node_modules/@base-ui/react/esm/menu/submenu-root/MenuSubmenuRootContext.js"],"sourcesContent":["import * as React from 'react';\nexport const MenuSubmenuRootContext = /*#__PURE__*/React.createContext(undefined);\nif (process.env.NODE_ENV !== \"production\") MenuSubmenuRootContext.displayName = \"MenuSubmenuRootContext\";\nexport function useMenuSubmenuRootContext() {\n  return React.useContext(MenuSubmenuRootContext);\n}"],"names":[],"mappings":";AACY,MAAC,yBAAsC,sBAAM,cAAc,MAAS;AAChF,IAAI,QAAQ,IAAI,aAAa,aAAc,wBAAuB,cAAc;AACzE,SAAS,4BAA4B;AAC1C,SAAO,MAAM,WAAW,sBAAsB;AAChD;","x_google_ignoreList":[0]}

package/dist/node_modules/@base-ui/react/esm/menu/submenu-trigger/MenuSubmenuTrigger.js

@@ -0,0 +1,134 @@
+"use client";
+import formatErrorMessage from "../../../../utils/esm/formatErrorMessage.js";
+import * as React from "react";
+import { useMenuRootContext } from "../root/MenuRootContext.js";
+import { useBaseUiId } from "../../utils/useBaseUiId.js";
+import { triggerOpenStateMapping } from "../../utils/popupStateMapping.js";
+import { useCompositeListItem } from "../../composite/list/useCompositeListItem.js";
+import { useMenuItem } from "../item/useMenuItem.js";
+import { useRenderElement } from "../../utils/useRenderElement.js";
+import { useMenuPositionerContext } from "../positioner/MenuPositionerContext.js";
+import { useMenuSubmenuRootContext } from "../submenu-root/MenuSubmenuRootContext.js";
+import { useTriggerRegistration } from "../../utils/popups/popupStoreUtils.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";
+const MenuSubmenuTrigger = /* @__PURE__ */ React.forwardRef(function SubmenuTriggerComponent(componentProps, forwardedRef) {
+  const {
+    render,
+    className,
+    label,
+    id: idProp,
+    nativeButton = false,
+    openOnHover = true,
+    delay = 100,
+    closeDelay = 0,
+    disabled: disabledProp = false,
+    ...elementProps
+  } = componentProps;
+  const listItem = useCompositeListItem();
+  const menuPositionerContext = useMenuPositionerContext();
+  const {
+    store
+  } = useMenuRootContext();
+  const thisTriggerId = useBaseUiId(idProp);
+  const open = store.useState("open");
+  const floatingRootContext = store.useState("floatingRootContext");
+  const floatingTreeRoot = store.useState("floatingTreeRoot");
+  const baseRegisterTrigger = useTriggerRegistration(thisTriggerId, store);
+  const registerTrigger = React.useCallback((element2) => {
+    const cleanup = baseRegisterTrigger(element2);
+    if (element2 !== null && store.select("open") && store.select("activeTriggerId") == null) {
+      store.update({
+        activeTriggerId: thisTriggerId,
+        activeTriggerElement: element2,
+        closeDelay
+      });
+    }
+    return cleanup;
+  }, [baseRegisterTrigger, closeDelay, store, thisTriggerId]);
+  const triggerElementRef = React.useRef(null);
+  const handleTriggerElementRef = React.useCallback((el) => {
+    triggerElementRef.current = el;
+    store.set("activeTriggerElement", el);
+  }, [store]);
+  const submenuRootContext = useMenuSubmenuRootContext();
+  if (!submenuRootContext?.parentMenu) {
+    throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: <Menu.SubmenuTrigger> must be placed in <Menu.SubmenuRoot>." : formatErrorMessage(37));
+  }
+  store.useSyncedValue("closeDelay", closeDelay);
+  const parentMenuStore = submenuRootContext.parentMenu;
+  const itemProps = parentMenuStore.useState("itemProps");
+  const highlighted = parentMenuStore.useState("isActive", listItem.index);
+  const itemMetadata = React.useMemo(() => ({
+    type: "submenu-trigger",
+    setActive: () => parentMenuStore.set("activeIndex", listItem.index)
+  }), [parentMenuStore, listItem.index]);
+  const rootDisabled = store.useState("disabled");
+  const disabled = disabledProp || rootDisabled;
+  const {
+    getItemProps,
+    itemRef
+  } = useMenuItem({
+    closeOnClick: false,
+    disabled,
+    highlighted,
+    id: thisTriggerId,
+    store,
+    nativeButton,
+    itemMetadata,
+    nodeId: menuPositionerContext?.nodeId
+  });
+  const hoverEnabled = store.useState("hoverEnabled");
+  const allowMouseEnter = store.useState("allowMouseEnter");
+  const hoverProps = useHoverReferenceInteraction(floatingRootContext, {
+    enabled: hoverEnabled && openOnHover && !disabled && allowMouseEnter,
+    handleClose: safePolygon({
+      blockPointerEvents: true
+    }),
+    mouseOnly: true,
+    move: true,
+    restMs: delay,
+    delay: {
+      open: delay,
+      close: closeDelay
+    },
+    triggerElementRef,
+    externalTree: floatingTreeRoot
+  });
+  const click = useClick(floatingRootContext, {
+    enabled: !disabled,
+    event: "mousedown",
+    toggle: !openOnHover,
+    ignoreMouse: openOnHover,
+    stickIfOpen: false
+  });
+  const localInteractionProps = useInteractions([click]);
+  const rootTriggerProps = store.useState("triggerProps", true);
+  delete rootTriggerProps.id;
+  const state = React.useMemo(() => ({
+    disabled,
+    highlighted,
+    open
+  }), [disabled, highlighted, open]);
+  const element = useRenderElement("div", componentProps, {
+    state,
+    stateAttributesMapping: triggerOpenStateMapping,
+    props: [localInteractionProps.getReferenceProps(), hoverProps, rootTriggerProps, itemProps, {
+      tabIndex: open || highlighted ? 0 : -1,
+      onBlur() {
+        if (highlighted) {
+          parentMenuStore.set("activeIndex", null);
+        }
+      }
+    }, elementProps, getItemProps],
+    ref: [forwardedRef, listItem.ref, itemRef, registerTrigger, handleTriggerElementRef]
+  });
+  return element;
+});
+if (process.env.NODE_ENV !== "production") MenuSubmenuTrigger.displayName = "MenuSubmenuTrigger";
+export {
+  MenuSubmenuTrigger
+};
+//# sourceMappingURL=MenuSubmenuTrigger.js.map

package/dist/node_modules/@base-ui/react/esm/menu/submenu-trigger/MenuSubmenuTrigger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MenuSubmenuTrigger.js","sources":["../../../../../../../node_modules/@base-ui/react/esm/menu/submenu-trigger/MenuSubmenuTrigger.js"],"sourcesContent":["'use client';\n\nimport _formatErrorMessage from \"@base-ui/utils/formatErrorMessage\";\nimport * as React from 'react';\nimport { safePolygon, useClick, useHoverReferenceInteraction, useInteractions } from \"../../floating-ui-react/index.js\";\nimport { useMenuRootContext } from \"../root/MenuRootContext.js\";\nimport { useBaseUiId } from \"../../utils/useBaseUiId.js\";\nimport { triggerOpenStateMapping } from \"../../utils/popupStateMapping.js\";\nimport { useCompositeListItem } from \"../../composite/list/useCompositeListItem.js\";\nimport { useMenuItem } from \"../item/useMenuItem.js\";\nimport { useRenderElement } from \"../../utils/useRenderElement.js\";\nimport { useMenuPositionerContext } from \"../positioner/MenuPositionerContext.js\";\nimport { useTriggerRegistration } from \"../../utils/popups/index.js\";\nimport { useMenuSubmenuRootContext } from \"../submenu-root/MenuSubmenuRootContext.js\";\n\n/**\n * A menu item that opens a submenu.\n * Renders a `<div>` element.\n *\n * Documentation: [Base UI Menu](https://base-ui.com/react/components/menu)\n */\nexport const MenuSubmenuTrigger = /*#__PURE__*/React.forwardRef(function SubmenuTriggerComponent(componentProps, forwardedRef) {\n  const {\n    render,\n    className,\n    label,\n    id: idProp,\n    nativeButton = false,\n    openOnHover = true,\n    delay = 100,\n    closeDelay = 0,\n    disabled: disabledProp = false,\n    ...elementProps\n  } = componentProps;\n  const listItem = useCompositeListItem();\n  const menuPositionerContext = useMenuPositionerContext();\n  const {\n    store\n  } = useMenuRootContext();\n  const thisTriggerId = useBaseUiId(idProp);\n  const open = store.useState('open');\n  const floatingRootContext = store.useState('floatingRootContext');\n  const floatingTreeRoot = store.useState('floatingTreeRoot');\n  const baseRegisterTrigger = useTriggerRegistration(thisTriggerId, store);\n  const registerTrigger = React.useCallback(element => {\n    const cleanup = baseRegisterTrigger(element);\n    if (element !== null && store.select('open') && store.select('activeTriggerId') == null) {\n      store.update({\n        activeTriggerId: thisTriggerId,\n        activeTriggerElement: element,\n        closeDelay\n      });\n    }\n    return cleanup;\n  }, [baseRegisterTrigger, closeDelay, store, thisTriggerId]);\n  const triggerElementRef = React.useRef(null);\n  const handleTriggerElementRef = React.useCallback(el => {\n    triggerElementRef.current = el;\n    store.set('activeTriggerElement', el);\n  }, [store]);\n  const submenuRootContext = useMenuSubmenuRootContext();\n  if (!submenuRootContext?.parentMenu) {\n    throw new Error(process.env.NODE_ENV !== \"production\" ? 'Base UI: <Menu.SubmenuTrigger> must be placed in <Menu.SubmenuRoot>.' : _formatErrorMessage(37));\n  }\n  store.useSyncedValue('closeDelay', closeDelay);\n  const parentMenuStore = submenuRootContext.parentMenu;\n  const itemProps = parentMenuStore.useState('itemProps');\n  const highlighted = parentMenuStore.useState('isActive', listItem.index);\n  const itemMetadata = React.useMemo(() => ({\n    type: 'submenu-trigger',\n    setActive: () => parentMenuStore.set('activeIndex', listItem.index)\n  }), [parentMenuStore, listItem.index]);\n  const rootDisabled = store.useState('disabled');\n  const disabled = disabledProp || rootDisabled;\n  const {\n    getItemProps,\n    itemRef\n  } = useMenuItem({\n    closeOnClick: false,\n    disabled,\n    highlighted,\n    id: thisTriggerId,\n    store,\n    nativeButton,\n    itemMetadata,\n    nodeId: menuPositionerContext?.nodeId\n  });\n  const hoverEnabled = store.useState('hoverEnabled');\n  const allowMouseEnter = store.useState('allowMouseEnter');\n  const hoverProps = useHoverReferenceInteraction(floatingRootContext, {\n    enabled: hoverEnabled && openOnHover && !disabled && allowMouseEnter,\n    handleClose: safePolygon({\n      blockPointerEvents: true\n    }),\n    mouseOnly: true,\n    move: true,\n    restMs: delay,\n    delay: {\n      open: delay,\n      close: closeDelay\n    },\n    triggerElementRef,\n    externalTree: floatingTreeRoot\n  });\n  const click = useClick(floatingRootContext, {\n    enabled: !disabled,\n    event: 'mousedown',\n    toggle: !openOnHover,\n    ignoreMouse: openOnHover,\n    stickIfOpen: false\n  });\n  const localInteractionProps = useInteractions([click]);\n  const rootTriggerProps = store.useState('triggerProps', true);\n  delete rootTriggerProps.id;\n  const state = React.useMemo(() => ({\n    disabled,\n    highlighted,\n    open\n  }), [disabled, highlighted, open]);\n  const element = useRenderElement('div', componentProps, {\n    state,\n    stateAttributesMapping: triggerOpenStateMapping,\n    props: [localInteractionProps.getReferenceProps(), hoverProps, rootTriggerProps, itemProps, {\n      tabIndex: open || highlighted ? 0 : -1,\n      onBlur() {\n        if (highlighted) {\n          parentMenuStore.set('activeIndex', null);\n        }\n      }\n    }, elementProps, getItemProps],\n    ref: [forwardedRef, listItem.ref, itemRef, registerTrigger, handleTriggerElementRef]\n  });\n  return element;\n});\nif (process.env.NODE_ENV !== \"production\") MenuSubmenuTrigger.displayName = \"MenuSubmenuTrigger\";"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAqBY;AACV;AAAM;AACJ;AACA;AACA;AACI;AACW;AACD;AACN;AACK;AACY;AACtB;AAEL;AACA;AACA;AAAM;AACJ;AAEF;AACA;AACA;AACA;AACA;AACA;AACE;AACA;AACE;AAAa;AACM;AACK;AACtB;AACD;AAEH;AAAO;AAET;AACA;AACE;AACA;AAAoC;AAEtC;AACA;AACE;AAAwJ;AAE1J;AACA;AACA;AACA;AACA;AAA0C;AAClC;AAC4D;AAEpE;AACA;AACA;AAAM;AACJ;AACA;AACc;AACA;AACd;AACA;AACI;AACJ;AACA;AACA;AAC+B;AAEjC;AACA;AACA;AAAqE;AACd;AAC5B;AACH;AACrB;AACU;AACL;AACE;AACD;AACC;AACC;AACb;AACI;AACc;AAEhB;AAA4C;AAChC;AACH;AACE;AACI;AACA;AAEf;AACA;AACA;AACA;AAAmC;AACjC;AACA;AACA;AAEF;AAAwD;AACtD;AACwB;AACoE;AACtD;AAElC;AACE;AAAuC;AACzC;AACF;AAC2B;AACsD;AAErF;AACF;AACA;;;;","x_google_ignoreList":[0]}

package/dist/node_modules/@base-ui/react/esm/menu/trigger/MenuTrigger.js

@@ -0,0 +1,292 @@
+"use client";
+import formatErrorMessage from "../../../../utils/esm/formatErrorMessage.js";
+import * as React from "react";
+import * as ReactDOM from "react-dom";
+import { useTimeout } from "../../../../utils/esm/useTimeout.js";
+import { ownerDocument } from "../../../../utils/esm/owner.js";
+import { useStableCallback } from "../../../../utils/esm/useStableCallback.js";
+import { useIsoLayoutEffect } from "../../../../utils/esm/useIsoLayoutEffect.js";
+import { EMPTY_OBJECT } from "../../../../utils/esm/empty.js";
+import { FloatingTreeStore } from "../../floating-ui-react/components/FloatingTreeStore.js";
+import { useMenuRootContext } from "../root/MenuRootContext.js";
+import { pressableTriggerOpenStateMapping } from "../../utils/popupStateMapping.js";
+import { useRenderElement } from "../../utils/useRenderElement.js";
+import { useButton } from "../../use-button/useButton.js";
+import { getPseudoElementBounds } from "../../utils/getPseudoElementBounds.js";
+import { CompositeItem } from "../../composite/item/CompositeItem.js";
+import { useCompositeRootContext } from "../../composite/root/CompositeRootContext.js";
+import { findRootOwnerId } from "../utils/findRootOwnerId.js";
+import { useBaseUiId } from "../../utils/useBaseUiId.js";
+import { useMixedToggleClickHandler } from "../../utils/useMixedToggleClickHander.js";
+import { useContextMenuRootContext } from "../../context-menu/root/ContextMenuRootContext.js";
+import { useMenubarContext } from "../../menubar/MenubarContext.js";
+import { PATIENT_CLICK_THRESHOLD } from "../../utils/constants.js";
+import { FocusGuard } from "../../utils/FocusGuard.js";
+import { createChangeEventDetails } from "../../utils/createBaseUIEventDetails.js";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useFloatingTree, useFloatingNodeId, useFloatingParentNodeId } from "../../floating-ui-react/components/FloatingTree.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 { useFocus } from "../../floating-ui-react/hooks/useFocus.js";
+import { useInteractions } from "../../floating-ui-react/hooks/useInteractions.js";
+import { useTriggerDataForwarding } from "../../utils/popups/popupStoreUtils.js";
+import { contains } from "../../floating-ui-react/utils/element.js";
+import { cancelOpen, triggerHover, focusOut } from "../../utils/reason-parts.js";
+import { getTabbableBeforeElement, isOutsideEvent, getTabbableAfterElement, getNextTabbable } from "../../floating-ui-react/utils/tabbable.js";
+const BOUNDARY_OFFSET = 2;
+const MenuTrigger = /* @__PURE__ */ React.forwardRef(function MenuTrigger2(componentProps, forwardedRef) {
+  const {
+    render,
+    className,
+    disabled: disabledProp = false,
+    nativeButton = true,
+    id: idProp,
+    openOnHover: openOnHoverProp,
+    delay = 100,
+    closeDelay = 0,
+    handle,
+    payload,
+    ...elementProps
+  } = componentProps;
+  const rootContext = useMenuRootContext(true);
+  const store = handle?.store ?? rootContext?.store;
+  if (!store) {
+    throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: <Menu.Trigger> must be either used within a <Menu.Root> component or provided with a handle." : formatErrorMessage(85));
+  }
+  const thisTriggerId = useBaseUiId(idProp);
+  const isTriggerActive = store.useState("isTriggerActive", thisTriggerId);
+  const floatingRootContext = store.useState("floatingRootContext");
+  const isOpenedByThisTrigger = store.useState("isOpenedByTrigger", thisTriggerId);
+  const triggerElementRef = React.useRef(null);
+  const parent = useMenuParent();
+  const compositeRootContext = useCompositeRootContext(true);
+  const floatingTreeRootFromContext = useFloatingTree();
+  const floatingTreeRoot = React.useMemo(() => {
+    return floatingTreeRootFromContext ?? new FloatingTreeStore();
+  }, [floatingTreeRootFromContext]);
+  const floatingNodeId = useFloatingNodeId(floatingTreeRoot);
+  const floatingParentNodeId = useFloatingParentNodeId();
+  const {
+    registerTrigger,
+    isMountedByThisTrigger
+  } = useTriggerDataForwarding(thisTriggerId, triggerElementRef, store, {
+    payload,
+    closeDelay,
+    parent,
+    floatingTreeRoot,
+    floatingNodeId,
+    floatingParentNodeId,
+    keyboardEventRelay: compositeRootContext?.relayKeyboardEvent
+  });
+  const rootDisabled = store.useState("disabled");
+  const disabled = disabledProp || rootDisabled || parent.type === "menubar" && parent.context.disabled;
+  const {
+    getButtonProps,
+    buttonRef
+  } = useButton({
+    disabled,
+    native: nativeButton
+  });
+  React.useEffect(() => {
+    if (!isOpenedByThisTrigger && parent.type === void 0) {
+      store.context.allowMouseUpTriggerRef.current = false;
+    }
+  }, [store, isOpenedByThisTrigger, parent.type]);
+  const triggerRef = React.useRef(null);
+  const allowMouseUpTriggerTimeout = useTimeout();
+  const handleDocumentMouseUp = useStableCallback((mouseEvent) => {
+    if (!triggerRef.current) {
+      return;
+    }
+    allowMouseUpTriggerTimeout.clear();
+    store.context.allowMouseUpTriggerRef.current = false;
+    const mouseUpTarget = mouseEvent.target;
+    if (contains(triggerRef.current, mouseUpTarget) || contains(store.select("positionerElement"), mouseUpTarget) || mouseUpTarget === triggerRef.current) {
+      return;
+    }
+    if (mouseUpTarget != null && findRootOwnerId(mouseUpTarget) === store.select("rootId")) {
+      return;
+    }
+    const bounds = getPseudoElementBounds(triggerRef.current);
+    if (mouseEvent.clientX >= bounds.left - BOUNDARY_OFFSET && mouseEvent.clientX <= bounds.right + BOUNDARY_OFFSET && mouseEvent.clientY >= bounds.top - BOUNDARY_OFFSET && mouseEvent.clientY <= bounds.bottom + BOUNDARY_OFFSET) {
+      return;
+    }
+    floatingTreeRoot.events.emit("close", {
+      domEvent: mouseEvent,
+      reason: cancelOpen
+    });
+  });
+  React.useEffect(() => {
+    if (isOpenedByThisTrigger && store.select("lastOpenChangeReason") === triggerHover) {
+      const doc = ownerDocument(triggerRef.current);
+      doc.addEventListener("mouseup", handleDocumentMouseUp, {
+        once: true
+      });
+    }
+  }, [isOpenedByThisTrigger, handleDocumentMouseUp, store]);
+  const parentMenubarHasSubmenuOpen = parent.type === "menubar" && parent.context.hasSubmenuOpen;
+  const openOnHover = openOnHoverProp ?? parentMenubarHasSubmenuOpen ?? false;
+  const hoverProps = useHoverReferenceInteraction(floatingRootContext, {
+    enabled: openOnHover && !disabled && parent.type !== "context-menu" && (parent.type !== "menubar" || parentMenubarHasSubmenuOpen && !isMountedByThisTrigger),
+    handleClose: safePolygon({
+      blockPointerEvents: parent.type !== "menubar"
+    }),
+    mouseOnly: true,
+    move: false,
+    restMs: parent.type === void 0 ? delay : void 0,
+    delay: {
+      close: closeDelay
+    },
+    triggerElementRef,
+    externalTree: floatingTreeRoot,
+    isActiveTrigger: isTriggerActive
+  });
+  const stickIfOpen = useStickIfOpen(isOpenedByThisTrigger, store.select("lastOpenChangeReason"));
+  const click = useClick(floatingRootContext, {
+    enabled: !disabled && parent.type !== "context-menu",
+    event: isOpenedByThisTrigger && parent.type === "menubar" ? "click" : "mousedown",
+    toggle: true,
+    ignoreMouse: false,
+    stickIfOpen: parent.type === void 0 ? stickIfOpen : false
+  });
+  const focus = useFocus(floatingRootContext, {
+    enabled: !disabled && (parent.type !== "menubar" && isOpenedByThisTrigger || parentMenubarHasSubmenuOpen)
+  });
+  const mixedToggleHandlers = useMixedToggleClickHandler({
+    open: isOpenedByThisTrigger,
+    enabled: parent.type === "menubar",
+    mouseDownAction: "open"
+  });
+  const localInteractionProps = useInteractions([click, focus]);
+  const isInMenubar = parent.type === "menubar";
+  const state = React.useMemo(() => ({
+    disabled,
+    open: isOpenedByThisTrigger
+  }), [disabled, isOpenedByThisTrigger]);
+  const rootTriggerProps = store.useState("triggerProps", isMountedByThisTrigger);
+  const ref = [triggerRef, forwardedRef, buttonRef, registerTrigger, triggerElementRef];
+  const props = [localInteractionProps.getReferenceProps(), hoverProps ?? EMPTY_OBJECT, rootTriggerProps, {
+    "aria-haspopup": "menu",
+    id: thisTriggerId,
+    onMouseDown: (event) => {
+      if (store.select("open")) {
+        return;
+      }
+      allowMouseUpTriggerTimeout.start(200, () => {
+        store.context.allowMouseUpTriggerRef.current = true;
+      });
+      const doc = ownerDocument(event.currentTarget);
+      doc.addEventListener("mouseup", handleDocumentMouseUp, {
+        once: true
+      });
+    }
+  }, isInMenubar ? {
+    role: "menuitem"
+  } : {}, mixedToggleHandlers, elementProps, getButtonProps];
+  const preFocusGuardRef = React.useRef(null);
+  const handlePreFocusGuardFocus = useStableCallback((event) => {
+    ReactDOM.flushSync(() => {
+      store.setOpen(false, createChangeEventDetails(focusOut, event.nativeEvent, event.currentTarget));
+    });
+    const previousTabbable = getTabbableBeforeElement(preFocusGuardRef.current);
+    previousTabbable?.focus();
+  });
+  const handleFocusTargetFocus = useStableCallback((event) => {
+    const currentPositionerElement = store.select("positionerElement");
+    if (currentPositionerElement && isOutsideEvent(event, currentPositionerElement)) {
+      store.context.beforeContentFocusGuardRef.current?.focus();
+    } else {
+      ReactDOM.flushSync(() => {
+        store.setOpen(false, createChangeEventDetails(focusOut, event.nativeEvent, event.currentTarget));
+      });
+      let nextTabbable = getTabbableAfterElement(triggerElementRef.current);
+      while (nextTabbable !== null && contains(currentPositionerElement, nextTabbable) || nextTabbable?.hasAttribute("aria-hidden")) {
+        const prevTabbable = nextTabbable;
+        nextTabbable = getNextTabbable(nextTabbable);
+        if (nextTabbable === prevTabbable) {
+          break;
+        }
+      }
+      nextTabbable?.focus();
+    }
+  });
+  const element = useRenderElement("button", componentProps, {
+    enabled: !isInMenubar,
+    stateAttributesMapping: pressableTriggerOpenStateMapping,
+    state,
+    ref,
+    props
+  });
+  if (isInMenubar) {
+    return /* @__PURE__ */ jsx(CompositeItem, {
+      tag: "button",
+      render,
+      className,
+      state,
+      refs: ref,
+      props,
+      stateAttributesMapping: pressableTriggerOpenStateMapping
+    });
+  }
+  if (isOpenedByThisTrigger) {
+    return /* @__PURE__ */ jsxs(React.Fragment, {
+      children: [/* @__PURE__ */ jsx(FocusGuard, {
+        ref: preFocusGuardRef,
+        onFocus: handlePreFocusGuardFocus
+      }, `${thisTriggerId}-pre-focus-guard`), /* @__PURE__ */ jsx(React.Fragment, {
+        children: element
+      }, thisTriggerId), /* @__PURE__ */ jsx(FocusGuard, {
+        ref: store.context.triggerFocusTargetRef,
+        onFocus: handleFocusTargetFocus
+      }, `${thisTriggerId}-post-focus-guard`)]
+    });
+  }
+  return /* @__PURE__ */ jsx(React.Fragment, {
+    children: element
+  }, thisTriggerId);
+});
+if (process.env.NODE_ENV !== "production") MenuTrigger.displayName = "MenuTrigger";
+function useStickIfOpen(open, openReason) {
+  const stickIfOpenTimeout = useTimeout();
+  const [stickIfOpen, setStickIfOpen] = React.useState(false);
+  useIsoLayoutEffect(() => {
+    if (open && openReason === "trigger-hover") {
+      setStickIfOpen(true);
+      stickIfOpenTimeout.start(PATIENT_CLICK_THRESHOLD, () => {
+        setStickIfOpen(false);
+      });
+    } else if (!open) {
+      stickIfOpenTimeout.clear();
+      setStickIfOpen(false);
+    }
+  }, [open, openReason, stickIfOpenTimeout]);
+  return stickIfOpen;
+}
+function useMenuParent() {
+  const contextMenuContext = useContextMenuRootContext(true);
+  const parentContext = useMenuRootContext(true);
+  const menubarContext = useMenubarContext(true);
+  const parent = React.useMemo(() => {
+    if (menubarContext) {
+      return {
+        type: "menubar",
+        context: menubarContext
+      };
+    }
+    if (contextMenuContext && !parentContext) {
+      return {
+        type: "context-menu",
+        context: contextMenuContext
+      };
+    }
+    return {
+      type: void 0
+    };
+  }, [contextMenuContext, parentContext, menubarContext]);
+  return parent;
+}
+export {
+  MenuTrigger
+};
+//# sourceMappingURL=MenuTrigger.js.map

package/dist/node_modules/@base-ui/react/esm/menu/trigger/MenuTrigger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MenuTrigger.js","sources":["../../../../../../../node_modules/@base-ui/react/esm/menu/trigger/MenuTrigger.js"],"sourcesContent":["'use client';\n\nimport _formatErrorMessage from \"@base-ui/utils/formatErrorMessage\";\nimport * as React from 'react';\nimport * as ReactDOM from 'react-dom';\nimport { useTimeout } from '@base-ui/utils/useTimeout';\nimport { ownerDocument } from '@base-ui/utils/owner';\nimport { useStableCallback } from '@base-ui/utils/useStableCallback';\nimport { useIsoLayoutEffect } from '@base-ui/utils/useIsoLayoutEffect';\nimport { EMPTY_OBJECT } from '@base-ui/utils/empty';\nimport { safePolygon, useClick, useFloatingTree, useFocus, useHoverReferenceInteraction, useInteractions, useFloatingNodeId, useFloatingParentNodeId } from \"../../floating-ui-react/index.js\";\nimport { FloatingTreeStore } from \"../../floating-ui-react/components/FloatingTreeStore.js\";\nimport { contains, getNextTabbable, getTabbableAfterElement, getTabbableBeforeElement, isOutsideEvent } from \"../../floating-ui-react/utils.js\";\nimport { useMenuRootContext } from \"../root/MenuRootContext.js\";\nimport { pressableTriggerOpenStateMapping } from \"../../utils/popupStateMapping.js\";\nimport { useRenderElement } from \"../../utils/useRenderElement.js\";\nimport { useButton } from \"../../use-button/useButton.js\";\nimport { getPseudoElementBounds } from \"../../utils/getPseudoElementBounds.js\";\nimport { CompositeItem } from \"../../composite/item/CompositeItem.js\";\nimport { useCompositeRootContext } from \"../../composite/root/CompositeRootContext.js\";\nimport { findRootOwnerId } from \"../utils/findRootOwnerId.js\";\nimport { useTriggerDataForwarding } from \"../../utils/popups/index.js\";\nimport { useBaseUiId } from \"../../utils/useBaseUiId.js\";\nimport { REASONS } from \"../../utils/reasons.js\";\nimport { useMixedToggleClickHandler } from \"../../utils/useMixedToggleClickHander.js\";\nimport { useContextMenuRootContext } from \"../../context-menu/root/ContextMenuRootContext.js\";\nimport { useMenubarContext } from \"../../menubar/MenubarContext.js\";\nimport { PATIENT_CLICK_THRESHOLD } from \"../../utils/constants.js\";\nimport { FocusGuard } from \"../../utils/FocusGuard.js\";\nimport { createChangeEventDetails } from \"../../utils/createBaseUIEventDetails.js\";\nimport { jsx as _jsx, jsxs as _jsxs } from \"react/jsx-runtime\";\nconst BOUNDARY_OFFSET = 2;\n\n/**\n * A button that opens the menu.\n * Renders a `<button>` element.\n *\n * Documentation: [Base UI Menu](https://base-ui.com/react/components/menu)\n */\nexport const MenuTrigger = /*#__PURE__*/React.forwardRef(function MenuTrigger(componentProps, forwardedRef) {\n  const {\n    render,\n    className,\n    disabled: disabledProp = false,\n    nativeButton = true,\n    id: idProp,\n    openOnHover: openOnHoverProp,\n    delay = 100,\n    closeDelay = 0,\n    handle,\n    payload,\n    ...elementProps\n  } = componentProps;\n  const rootContext = useMenuRootContext(true);\n  const store = handle?.store ?? rootContext?.store;\n  if (!store) {\n    throw new Error(process.env.NODE_ENV !== \"production\" ? 'Base UI: <Menu.Trigger> must be either used within a <Menu.Root> component or provided with a handle.' : _formatErrorMessage(85));\n  }\n  const thisTriggerId = useBaseUiId(idProp);\n  const isTriggerActive = store.useState('isTriggerActive', thisTriggerId);\n  const floatingRootContext = store.useState('floatingRootContext');\n  const isOpenedByThisTrigger = store.useState('isOpenedByTrigger', thisTriggerId);\n  const triggerElementRef = React.useRef(null);\n  const parent = useMenuParent();\n  const compositeRootContext = useCompositeRootContext(true);\n  const floatingTreeRootFromContext = useFloatingTree();\n  const floatingTreeRoot = React.useMemo(() => {\n    return floatingTreeRootFromContext ?? new FloatingTreeStore();\n  }, [floatingTreeRootFromContext]);\n  const floatingNodeId = useFloatingNodeId(floatingTreeRoot);\n  const floatingParentNodeId = useFloatingParentNodeId();\n  const {\n    registerTrigger,\n    isMountedByThisTrigger\n  } = useTriggerDataForwarding(thisTriggerId, triggerElementRef, store, {\n    payload,\n    closeDelay,\n    parent,\n    floatingTreeRoot,\n    floatingNodeId,\n    floatingParentNodeId,\n    keyboardEventRelay: compositeRootContext?.relayKeyboardEvent\n  });\n  const rootDisabled = store.useState('disabled');\n  const disabled = disabledProp || rootDisabled || parent.type === 'menubar' && parent.context.disabled;\n  const {\n    getButtonProps,\n    buttonRef\n  } = useButton({\n    disabled,\n    native: nativeButton\n  });\n  React.useEffect(() => {\n    if (!isOpenedByThisTrigger && parent.type === undefined) {\n      store.context.allowMouseUpTriggerRef.current = false;\n    }\n  }, [store, isOpenedByThisTrigger, parent.type]);\n  const triggerRef = React.useRef(null);\n  const allowMouseUpTriggerTimeout = useTimeout();\n  const handleDocumentMouseUp = useStableCallback(mouseEvent => {\n    if (!triggerRef.current) {\n      return;\n    }\n    allowMouseUpTriggerTimeout.clear();\n    store.context.allowMouseUpTriggerRef.current = false;\n    const mouseUpTarget = mouseEvent.target;\n    if (contains(triggerRef.current, mouseUpTarget) || contains(store.select('positionerElement'), mouseUpTarget) || mouseUpTarget === triggerRef.current) {\n      return;\n    }\n    if (mouseUpTarget != null && findRootOwnerId(mouseUpTarget) === store.select('rootId')) {\n      return;\n    }\n    const bounds = getPseudoElementBounds(triggerRef.current);\n    if (mouseEvent.clientX >= bounds.left - BOUNDARY_OFFSET && mouseEvent.clientX <= bounds.right + BOUNDARY_OFFSET && mouseEvent.clientY >= bounds.top - BOUNDARY_OFFSET && mouseEvent.clientY <= bounds.bottom + BOUNDARY_OFFSET) {\n      return;\n    }\n    floatingTreeRoot.events.emit('close', {\n      domEvent: mouseEvent,\n      reason: REASONS.cancelOpen\n    });\n  });\n  React.useEffect(() => {\n    if (isOpenedByThisTrigger && store.select('lastOpenChangeReason') === REASONS.triggerHover) {\n      const doc = ownerDocument(triggerRef.current);\n      doc.addEventListener('mouseup', handleDocumentMouseUp, {\n        once: true\n      });\n    }\n  }, [isOpenedByThisTrigger, handleDocumentMouseUp, store]);\n  const parentMenubarHasSubmenuOpen = parent.type === 'menubar' && parent.context.hasSubmenuOpen;\n  const openOnHover = openOnHoverProp ?? parentMenubarHasSubmenuOpen ?? false;\n  const hoverProps = useHoverReferenceInteraction(floatingRootContext, {\n    enabled: openOnHover && !disabled && parent.type !== 'context-menu' && (parent.type !== 'menubar' || parentMenubarHasSubmenuOpen && !isMountedByThisTrigger),\n    handleClose: safePolygon({\n      blockPointerEvents: parent.type !== 'menubar'\n    }),\n    mouseOnly: true,\n    move: false,\n    restMs: parent.type === undefined ? delay : undefined,\n    delay: {\n      close: closeDelay\n    },\n    triggerElementRef,\n    externalTree: floatingTreeRoot,\n    isActiveTrigger: isTriggerActive\n  });\n\n  // Whether to ignore clicks to open the menu.\n  // `lastOpenChangeReason` doesnt't need to be reactive here, as we need to run this\n  // only when `isOpenedByThisTrigger` changes.\n  const stickIfOpen = useStickIfOpen(isOpenedByThisTrigger, store.select('lastOpenChangeReason'));\n  const click = useClick(floatingRootContext, {\n    enabled: !disabled && parent.type !== 'context-menu',\n    event: isOpenedByThisTrigger && parent.type === 'menubar' ? 'click' : 'mousedown',\n    toggle: true,\n    ignoreMouse: false,\n    stickIfOpen: parent.type === undefined ? stickIfOpen : false\n  });\n  const focus = useFocus(floatingRootContext, {\n    enabled: !disabled && (parent.type !== 'menubar' && isOpenedByThisTrigger || parentMenubarHasSubmenuOpen)\n  });\n  const mixedToggleHandlers = useMixedToggleClickHandler({\n    open: isOpenedByThisTrigger,\n    enabled: parent.type === 'menubar',\n    mouseDownAction: 'open'\n  });\n  const localInteractionProps = useInteractions([click, focus]);\n  const isInMenubar = parent.type === 'menubar';\n  const state = React.useMemo(() => ({\n    disabled,\n    open: isOpenedByThisTrigger\n  }), [disabled, isOpenedByThisTrigger]);\n  const rootTriggerProps = store.useState('triggerProps', isMountedByThisTrigger);\n  const ref = [triggerRef, forwardedRef, buttonRef, registerTrigger, triggerElementRef];\n  const props = [localInteractionProps.getReferenceProps(), hoverProps ?? EMPTY_OBJECT, rootTriggerProps, {\n    'aria-haspopup': 'menu',\n    id: thisTriggerId,\n    onMouseDown: event => {\n      if (store.select('open')) {\n        return;\n      }\n\n      // mousedown -> mouseup on menu item should not trigger it within 200ms.\n      allowMouseUpTriggerTimeout.start(200, () => {\n        store.context.allowMouseUpTriggerRef.current = true;\n      });\n      const doc = ownerDocument(event.currentTarget);\n      doc.addEventListener('mouseup', handleDocumentMouseUp, {\n        once: true\n      });\n    }\n  }, isInMenubar ? {\n    role: 'menuitem'\n  } : {}, mixedToggleHandlers, elementProps, getButtonProps];\n  const preFocusGuardRef = React.useRef(null);\n  const handlePreFocusGuardFocus = useStableCallback(event => {\n    ReactDOM.flushSync(() => {\n      store.setOpen(false, createChangeEventDetails(REASONS.focusOut, event.nativeEvent, event.currentTarget));\n    });\n    const previousTabbable = getTabbableBeforeElement(preFocusGuardRef.current);\n    previousTabbable?.focus();\n  });\n  const handleFocusTargetFocus = useStableCallback(event => {\n    const currentPositionerElement = store.select('positionerElement');\n    if (currentPositionerElement && isOutsideEvent(event, currentPositionerElement)) {\n      store.context.beforeContentFocusGuardRef.current?.focus();\n    } else {\n      ReactDOM.flushSync(() => {\n        store.setOpen(false, createChangeEventDetails(REASONS.focusOut, event.nativeEvent, event.currentTarget));\n      });\n      let nextTabbable = getTabbableAfterElement(triggerElementRef.current);\n      while (nextTabbable !== null && contains(currentPositionerElement, nextTabbable) || nextTabbable?.hasAttribute('aria-hidden')) {\n        const prevTabbable = nextTabbable;\n        nextTabbable = getNextTabbable(nextTabbable);\n        if (nextTabbable === prevTabbable) {\n          break;\n        }\n      }\n      nextTabbable?.focus();\n    }\n  });\n  const element = useRenderElement('button', componentProps, {\n    enabled: !isInMenubar,\n    stateAttributesMapping: pressableTriggerOpenStateMapping,\n    state,\n    ref,\n    props\n  });\n  if (isInMenubar) {\n    return /*#__PURE__*/_jsx(CompositeItem, {\n      tag: \"button\",\n      render: render,\n      className: className,\n      state: state,\n      refs: ref,\n      props: props,\n      stateAttributesMapping: pressableTriggerOpenStateMapping\n    });\n  }\n\n  // A fragment with key is required to ensure that the `element` is mounted to the same DOM node\n  // regardless of whether the focus guards are rendered or not.\n\n  if (isOpenedByThisTrigger) {\n    return /*#__PURE__*/_jsxs(React.Fragment, {\n      children: [/*#__PURE__*/_jsx(FocusGuard, {\n        ref: preFocusGuardRef,\n        onFocus: handlePreFocusGuardFocus\n      }, `${thisTriggerId}-pre-focus-guard`), /*#__PURE__*/_jsx(React.Fragment, {\n        children: element\n      }, thisTriggerId), /*#__PURE__*/_jsx(FocusGuard, {\n        ref: store.context.triggerFocusTargetRef,\n        onFocus: handleFocusTargetFocus\n      }, `${thisTriggerId}-post-focus-guard`)]\n    });\n  }\n  return /*#__PURE__*/_jsx(React.Fragment, {\n    children: element\n  }, thisTriggerId);\n});\nif (process.env.NODE_ENV !== \"production\") MenuTrigger.displayName = \"MenuTrigger\";\n/**\n * Determines whether to ignore clicks after a hover-open.\n */\nfunction useStickIfOpen(open, openReason) {\n  const stickIfOpenTimeout = useTimeout();\n  const [stickIfOpen, setStickIfOpen] = React.useState(false);\n  useIsoLayoutEffect(() => {\n    if (open && openReason === 'trigger-hover') {\n      // Only allow \"patient\" clicks to close the menu if it's open.\n      // If they clicked within 500ms of the menu opening, keep it open.\n      setStickIfOpen(true);\n      stickIfOpenTimeout.start(PATIENT_CLICK_THRESHOLD, () => {\n        setStickIfOpen(false);\n      });\n    } else if (!open) {\n      stickIfOpenTimeout.clear();\n      setStickIfOpen(false);\n    }\n  }, [open, openReason, stickIfOpenTimeout]);\n  return stickIfOpen;\n}\nfunction useMenuParent() {\n  const contextMenuContext = useContextMenuRootContext(true);\n  const parentContext = useMenuRootContext(true);\n  const menubarContext = useMenubarContext(true);\n  const parent = React.useMemo(() => {\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 && !parentContext) {\n      return {\n        type: 'context-menu',\n        context: contextMenuContext\n      };\n    }\n    return {\n      type: undefined\n    };\n  }, [contextMenuContext, parentContext, menubarContext]);\n  return parent;\n}"],"names":["REASONS.cancelOpen"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BA;AAQY;AACV;AAAM;AACJ;AACA;AACyB;AACV;AACX;AACS;AACL;AACK;AACb;AACA;AACG;AAEL;AACA;AACA;AACE;AAAyL;AAE3L;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACE;AAA2D;AAE7D;AACA;AACA;AAAM;AACJ;AACA;AACoE;AACpE;AACA;AACA;AACA;AACA;AACA;AAC0C;AAE5C;AACA;AACA;AAAM;AACJ;AACA;AACY;AACZ;AACQ;AAEV;AACE;AACE;AAA+C;AACjD;AAEF;AACA;AACA;AACE;AACE;AAAA;AAEF;AACA;AACA;AACA;AACE;AAAA;AAEF;AACE;AAAA;AAEF;AACA;AACE;AAAA;AAEF;AAAsC;AAC1B;AACFA;AACT;AAEH;AACE;AACE;AACA;AAAuD;AAC/C;AACP;AACH;AAEF;AACA;AACA;AAAqE;AACkE;AAC5G;AACa;AACrC;AACU;AACL;AACsC;AACrC;AACE;AACb;AACI;AACc;AACG;AAMnB;AACA;AAA4C;AACJ;AACgC;AAC9D;AACK;AAC0C;AAEzD;AAA4C;AACmC;AAE/E;AAAuD;AAC/C;AACmB;AACR;AAEnB;AACA;AACA;AAAmC;AACjC;AACM;AAER;AACA;AACA;AAAwG;AACrF;AACb;AAEF;AACE;AAAA;AAIF;AACE;AAA+C;AAEjD;AACA;AAAuD;AAC/C;AACP;AACH;AACe;AACT;AAER;AACA;AACE;AACE;AAAuG;AAEzG;AACA;AAAuB;AAEzB;AACE;AACA;AACE;AAAuD;AAEvD;AACE;AAAuG;AAEzG;AACA;AACE;AACA;AACA;AACE;AAAA;AACF;AAEF;AAAmB;AACrB;AAEF;AAA2D;AAC/C;AACc;AACxB;AACA;AACA;AAEF;AACE;AAAwC;AACjC;AACL;AACA;AACA;AACM;AACN;AACwB;AACzB;AAMH;AACE;AAA0C;AACC;AAClC;AACI;AAC+D;AAC9D;AACqC;AAC5B;AACV;AAC4B;AACxC;AAEH;AAAyC;AAC7B;AAEd;AACA;AAIA;AACE;AACA;AACA;AACE;AAGE;AACA;AACE;AAAoB;AACrB;AAED;AACA;AAAoB;AACtB;AAEF;AACF;AACA;AACE;AACA;AACA;AACA;AACE;AACE;AAAO;AACC;AACG;AACjB;AAMI;AACE;AAAO;AACC;AACG;AACjB;AAEI;AAAO;AACC;AACZ;AAEE;AACF;;;;","x_google_ignoreList":[0]}

package/dist/node_modules/@base-ui/react/esm/menu/utils/findRootOwnerId.js

@@ -0,0 +1,14 @@
+import { isHTMLElement, isLastTraversableNode, getParentNode } from "../../../../../@floating-ui/utils/dist/floating-ui.utils.dom.js";
+function findRootOwnerId(node) {
+  if (isHTMLElement(node) && node.hasAttribute("data-rootownerid")) {
+    return node.getAttribute("data-rootownerid") ?? void 0;
+  }
+  if (isLastTraversableNode(node)) {
+    return void 0;
+  }
+  return findRootOwnerId(getParentNode(node));
+}
+export {
+  findRootOwnerId
+};
+//# sourceMappingURL=findRootOwnerId.js.map

package/dist/node_modules/@base-ui/react/esm/menu/utils/findRootOwnerId.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"findRootOwnerId.js","sources":["../../../../../../../node_modules/@base-ui/react/esm/menu/utils/findRootOwnerId.js"],"sourcesContent":["import { getParentNode, isHTMLElement, isLastTraversableNode } from '@floating-ui/utils/dom';\nexport function findRootOwnerId(node) {\n  if (isHTMLElement(node) && node.hasAttribute('data-rootownerid')) {\n    return node.getAttribute('data-rootownerid') ?? undefined;\n  }\n  if (isLastTraversableNode(node)) {\n    return undefined;\n  }\n  return findRootOwnerId(getParentNode(node));\n}"],"names":[],"mappings":";AACO,SAAS,gBAAgB,MAAM;AACpC,MAAI,cAAc,IAAI,KAAK,KAAK,aAAa,kBAAkB,GAAG;AAChE,WAAO,KAAK,aAAa,kBAAkB,KAAK;AAAA,EAClD;AACA,MAAI,sBAAsB,IAAI,GAAG;AAC/B,WAAO;AAAA,EACT;AACA,SAAO,gBAAgB,cAAc,IAAI,CAAC;AAC5C;","x_google_ignoreList":[0]}

package/dist/node_modules/@base-ui/react/esm/menu/utils/stateAttributesMapping.js

@@ -0,0 +1,19 @@
+import { transitionStatusMapping } from "../../utils/stateAttributesMapping.js";
+import { MenuCheckboxItemDataAttributes } from "../checkbox-item/MenuCheckboxItemDataAttributes.js";
+const itemMapping = {
+  checked(value) {
+    if (value) {
+      return {
+        [MenuCheckboxItemDataAttributes.checked]: ""
+      };
+    }
+    return {
+      [MenuCheckboxItemDataAttributes.unchecked]: ""
+    };
+  },
+  ...transitionStatusMapping
+};
+export {
+  itemMapping
+};
+//# sourceMappingURL=stateAttributesMapping.js.map

package/dist/node_modules/@base-ui/react/esm/menu/utils/stateAttributesMapping.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stateAttributesMapping.js","sources":["../../../../../../../node_modules/@base-ui/react/esm/menu/utils/stateAttributesMapping.js"],"sourcesContent":["import { transitionStatusMapping } from \"../../utils/stateAttributesMapping.js\";\nimport { MenuCheckboxItemDataAttributes } from \"../checkbox-item/MenuCheckboxItemDataAttributes.js\";\nexport const itemMapping = {\n  checked(value) {\n    if (value) {\n      return {\n        [MenuCheckboxItemDataAttributes.checked]: ''\n      };\n    }\n    return {\n      [MenuCheckboxItemDataAttributes.unchecked]: ''\n    };\n  },\n  ...transitionStatusMapping\n};"],"names":[],"mappings":";;AAEY,MAAC,cAAc;AAAA,EACzB,QAAQ,OAAO;AACb,QAAI,OAAO;AACT,aAAO;AAAA,QACL,CAAC,+BAA+B,OAAO,GAAG;AAAA,MAClD;AAAA,IACI;AACA,WAAO;AAAA,MACL,CAAC,+BAA+B,SAAS,GAAG;AAAA,IAClD;AAAA,EACE;AAAA,EACA,GAAG;AACL;","x_google_ignoreList":[0]}

package/dist/node_modules/@base-ui/react/esm/menubar/Menubar.js

@@ -0,0 +1,115 @@
+"use client";
+import * as React from "react";
+import { useScrollLock } from "../../../utils/esm/useScrollLock.js";
+import { MenubarContext, useMenubarContext } from "./MenubarContext.js";
+import { useOpenInteractionType } from "../utils/useOpenInteractionType.js";
+import { CompositeRoot } from "../composite/root/CompositeRoot.js";
+import { useBaseUiId } from "../utils/useBaseUiId.js";
+import { jsx } from "react/jsx-runtime";
+import { FloatingTree, useFloatingNodeId, useFloatingTree, FloatingNode } from "../floating-ui-react/components/FloatingTree.js";
+const menubarStateAttributesMapping = {
+  hasSubmenuOpen(value) {
+    return {
+      "data-has-submenu-open": value ? "true" : "false"
+    };
+  }
+};
+const Menubar = /* @__PURE__ */ React.forwardRef(function Menubar2(props, forwardedRef) {
+  const {
+    orientation = "horizontal",
+    loopFocus = true,
+    render,
+    className,
+    modal = true,
+    disabled = false,
+    id: idProp,
+    ...elementProps
+  } = props;
+  const [contentElement, setContentElement] = React.useState(null);
+  const [hasSubmenuOpen, setHasSubmenuOpen] = React.useState(false);
+  const {
+    openMethod,
+    triggerProps: interactionTypeProps,
+    reset: resetOpenInteractionType
+  } = useOpenInteractionType(hasSubmenuOpen);
+  React.useEffect(() => {
+    if (!hasSubmenuOpen) {
+      resetOpenInteractionType();
+    }
+  }, [hasSubmenuOpen, resetOpenInteractionType]);
+  useScrollLock(modal && hasSubmenuOpen && openMethod !== "touch", contentElement);
+  const id = useBaseUiId(idProp);
+  const state = React.useMemo(() => ({
+    orientation,
+    modal,
+    hasSubmenuOpen
+  }), [orientation, modal, hasSubmenuOpen]);
+  const contentRef = React.useRef(null);
+  const allowMouseUpTriggerRef = React.useRef(false);
+  const context = React.useMemo(() => ({
+    contentElement,
+    setContentElement,
+    setHasSubmenuOpen,
+    hasSubmenuOpen,
+    modal,
+    disabled,
+    orientation,
+    allowMouseUpTriggerRef,
+    rootId: id
+  }), [contentElement, hasSubmenuOpen, modal, disabled, orientation, id]);
+  return /* @__PURE__ */ jsx(MenubarContext.Provider, {
+    value: context,
+    children: /* @__PURE__ */ jsx(FloatingTree, {
+      children: /* @__PURE__ */ jsx(MenubarContent, {
+        children: /* @__PURE__ */ jsx(CompositeRoot, {
+          render,
+          className,
+          state,
+          stateAttributesMapping: menubarStateAttributesMapping,
+          refs: [forwardedRef, setContentElement, contentRef],
+          props: [{
+            role: "menubar",
+            id
+          }, interactionTypeProps, elementProps],
+          orientation,
+          loopFocus,
+          highlightItemOnHover: hasSubmenuOpen
+        })
+      })
+    })
+  });
+});
+if (process.env.NODE_ENV !== "production") Menubar.displayName = "Menubar";
+function MenubarContent(props) {
+  const nodeId = useFloatingNodeId();
+  const {
+    events: menuEvents
+  } = useFloatingTree();
+  const rootContext = useMenubarContext();
+  React.useEffect(() => {
+    function onSubmenuOpenChange(details) {
+      if (!details.nodeId || details.parentNodeId !== nodeId) {
+        return;
+      }
+      if (details.open) {
+        if (!rootContext.hasSubmenuOpen) {
+          rootContext.setHasSubmenuOpen(true);
+        }
+      } else if (details.reason !== "sibling-open" && details.reason !== "list-navigation") {
+        rootContext.setHasSubmenuOpen(false);
+      }
+    }
+    menuEvents.on("menuopenchange", onSubmenuOpenChange);
+    return () => {
+      menuEvents.off("menuopenchange", onSubmenuOpenChange);
+    };
+  }, [menuEvents, nodeId, rootContext]);
+  return /* @__PURE__ */ jsx(FloatingNode, {
+    id: nodeId,
+    children: props.children
+  });
+}
+export {
+  Menubar
+};
+//# sourceMappingURL=Menubar.js.map

package/dist/node_modules/@base-ui/react/esm/menubar/Menubar.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Menubar.js","sources":["../../../../../../node_modules/@base-ui/react/esm/menubar/Menubar.js"],"sourcesContent":["'use client';\n\nimport * as React from 'react';\nimport { useScrollLock } from '@base-ui/utils/useScrollLock';\nimport { FloatingNode, FloatingTree, useFloatingNodeId, useFloatingTree } from \"../floating-ui-react/index.js\";\nimport { MenubarContext, useMenubarContext } from \"./MenubarContext.js\";\nimport { useOpenInteractionType } from \"../utils/useOpenInteractionType.js\";\nimport { CompositeRoot } from \"../composite/root/CompositeRoot.js\";\nimport { useBaseUiId } from \"../utils/useBaseUiId.js\";\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nconst menubarStateAttributesMapping = {\n  hasSubmenuOpen(value) {\n    return {\n      'data-has-submenu-open': value ? 'true' : 'false'\n    };\n  }\n};\n\n/**\n * The container for menus.\n *\n * Documentation: [Base UI Menubar](https://base-ui.com/react/components/menubar)\n */\nexport const Menubar = /*#__PURE__*/React.forwardRef(function Menubar(props, forwardedRef) {\n  const {\n    orientation = 'horizontal',\n    loopFocus = true,\n    render,\n    className,\n    modal = true,\n    disabled = false,\n    id: idProp,\n    ...elementProps\n  } = props;\n  const [contentElement, setContentElement] = React.useState(null);\n  const [hasSubmenuOpen, setHasSubmenuOpen] = React.useState(false);\n  const {\n    openMethod,\n    triggerProps: interactionTypeProps,\n    reset: resetOpenInteractionType\n  } = useOpenInteractionType(hasSubmenuOpen);\n  React.useEffect(() => {\n    if (!hasSubmenuOpen) {\n      resetOpenInteractionType();\n    }\n  }, [hasSubmenuOpen, resetOpenInteractionType]);\n  useScrollLock(modal && hasSubmenuOpen && openMethod !== 'touch', contentElement);\n  const id = useBaseUiId(idProp);\n  const state = React.useMemo(() => ({\n    orientation,\n    modal,\n    hasSubmenuOpen\n  }), [orientation, modal, hasSubmenuOpen]);\n  const contentRef = React.useRef(null);\n  const allowMouseUpTriggerRef = React.useRef(false);\n  const context = React.useMemo(() => ({\n    contentElement,\n    setContentElement,\n    setHasSubmenuOpen,\n    hasSubmenuOpen,\n    modal,\n    disabled,\n    orientation,\n    allowMouseUpTriggerRef,\n    rootId: id\n  }), [contentElement, hasSubmenuOpen, modal, disabled, orientation, id]);\n  return /*#__PURE__*/_jsx(MenubarContext.Provider, {\n    value: context,\n    children: /*#__PURE__*/_jsx(FloatingTree, {\n      children: /*#__PURE__*/_jsx(MenubarContent, {\n        children: /*#__PURE__*/_jsx(CompositeRoot, {\n          render: render,\n          className: className,\n          state: state,\n          stateAttributesMapping: menubarStateAttributesMapping,\n          refs: [forwardedRef, setContentElement, contentRef],\n          props: [{\n            role: 'menubar',\n            id\n          }, interactionTypeProps, elementProps],\n          orientation: orientation,\n          loopFocus: loopFocus,\n          highlightItemOnHover: hasSubmenuOpen\n        })\n      })\n    })\n  });\n});\nif (process.env.NODE_ENV !== \"production\") Menubar.displayName = \"Menubar\";\nfunction MenubarContent(props) {\n  const nodeId = useFloatingNodeId();\n  const {\n    events: menuEvents\n  } = useFloatingTree();\n  const rootContext = useMenubarContext();\n  React.useEffect(() => {\n    function onSubmenuOpenChange(details) {\n      if (!details.nodeId || details.parentNodeId !== nodeId) {\n        return;\n      }\n      if (details.open) {\n        if (!rootContext.hasSubmenuOpen) {\n          rootContext.setHasSubmenuOpen(true);\n        }\n      } else if (details.reason !== 'sibling-open' && details.reason !== 'list-navigation') {\n        rootContext.setHasSubmenuOpen(false);\n      }\n    }\n    menuEvents.on('menuopenchange', onSubmenuOpenChange);\n    return () => {\n      menuEvents.off('menuopenchange', onSubmenuOpenChange);\n    };\n  }, [menuEvents, nodeId, rootContext]);\n  return /*#__PURE__*/_jsx(FloatingNode, {\n    id: nodeId,\n    children: props.children\n  });\n}"],"names":[],"mappings":";;;;;;;;;AAUA;AAAsC;AAElC;AAAO;AACqC;AAChD;AAEA;AAOY;AACV;AAAM;AACU;AACF;AACZ;AACA;AACQ;AACG;AACP;AACD;AAEL;AACA;AACA;AAAM;AACJ;AACc;AACP;AAET;AACE;AACE;AAAwB;AAC1B;AAEF;AACA;AACA;AAAmC;AACjC;AACA;AACA;AAEF;AACA;AACA;AAAqC;AACnC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACQ;AAEV;AAAkD;AACzC;AACmC;AACI;AACC;AACzC;AACA;AACA;AACwB;AAC0B;AAC1C;AACA;AACN;AACmC;AACrC;AACA;AACsB;AACvB;AACF;AACF;AAEL;AACA;AACA;AACE;AACA;AAAM;AACI;AAEV;AACA;AACE;AACE;AACE;AAAA;AAEF;AACE;AACE;AAAkC;AACpC;AAEA;AAAmC;AACrC;AAEF;AACA;AACE;AAAoD;AACtD;AAEF;AAAuC;AACjC;AACY;AAEpB;;;;","x_google_ignoreList":[0]}