npm - dune-react - Versions diffs - 0.0.1 → 0.0.3 - Mend

dune-react 0.0.1 → 0.0.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1010) hide show

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/menu/radio-group/MenuRadioGroup.js ADDED Viewed

@@ -0,0 +1,55 @@
+import * as React from "react";
+import { useControlled } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/useControlled.js";
+import { useStableCallback } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/useStableCallback.js";
+import { MenuRadioGroupContext } from "./MenuRadioGroupContext.js";
+import { useRenderElement } from "../../utils/useRenderElement.js";
+import { jsx } from "react/jsx-runtime";
+const MenuRadioGroup = /* @__PURE__ */ React.memo(/* @__PURE__ */ React.forwardRef(function MenuRadioGroup2(componentProps, forwardedRef) {
+  const {
+    render,
+    className,
+    value: valueProp,
+    defaultValue,
+    onValueChange: onValueChangeProp,
+    disabled = false,
+    ...elementProps
+  } = componentProps;
+  const [value, setValueUnwrapped] = useControlled({
+    controlled: valueProp,
+    default: defaultValue,
+    name: "MenuRadioGroup"
+  });
+  const onValueChange = useStableCallback(onValueChangeProp);
+  const setValue = useStableCallback((newValue, eventDetails) => {
+    onValueChange == null ? void 0 : onValueChange(newValue, eventDetails);
+    if (eventDetails.isCanceled) {
+      return;
+    }
+    setValueUnwrapped(newValue);
+  });
+  const state = {
+    disabled
+  };
+  const element = useRenderElement("div", componentProps, {
+    state,
+    ref: forwardedRef,
+    props: {
+      role: "group",
+      "aria-disabled": disabled || void 0,
+      ...elementProps
+    }
+  });
+  const context = React.useMemo(() => ({
+    value,
+    setValue,
+    disabled
+  }), [value, setValue, disabled]);
+  return /* @__PURE__ */ jsx(MenuRadioGroupContext.Provider, {
+    value: context,
+    children: element
+  });
+}));
+if (process.env.NODE_ENV !== "production") MenuRadioGroup.displayName = "MenuRadioGroup";
+export {
+  MenuRadioGroup
+};

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/menu/radio-group/MenuRadioGroupContext.js ADDED Viewed

@@ -0,0 +1,15 @@
+import formatErrorMessage from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/formatErrorMessage.js";
+import * as React from "react";
+const MenuRadioGroupContext = /* @__PURE__ */ React.createContext(void 0);
+if (process.env.NODE_ENV !== "production") MenuRadioGroupContext.displayName = "MenuRadioGroupContext";
+function useMenuRadioGroupContext() {
+  const context = React.useContext(MenuRadioGroupContext);
+  if (context === void 0) {
+    throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: MenuRadioGroupContext is missing. MenuRadioGroup parts must be placed within <Menu.RadioGroup>." : formatErrorMessage(34));
+  }
+  return context;
+}
+export {
+  MenuRadioGroupContext,
+  useMenuRadioGroupContext
+};

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/menu/radio-item/MenuRadioItem.js ADDED Viewed

@@ -0,0 +1,88 @@
+import * as React from "react";
+import { useStableCallback } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/useStableCallback.js";
+import { useMenuRootContext } from "../root/MenuRootContext.js";
+import { useRenderElement } from "../../utils/useRenderElement.js";
+import { useBaseUiId } from "../../utils/useBaseUiId.js";
+import { useMenuRadioGroupContext } from "../radio-group/MenuRadioGroupContext.js";
+import { MenuRadioItemContext } from "./MenuRadioItemContext.js";
+import { itemMapping } from "../utils/stateAttributesMapping.js";
+import { useCompositeListItem } from "../../composite/list/useCompositeListItem.js";
+import { useMenuItem, REGULAR_ITEM } from "../item/useMenuItem.js";
+import { useMenuPositionerContext } from "../positioner/MenuPositionerContext.js";
+import { createChangeEventDetails } from "../../utils/createBaseUIEventDetails.js";
+import { jsx } from "react/jsx-runtime";
+import { itemPress } from "../../utils/reason-parts.js";
+const MenuRadioItem = /* @__PURE__ */ React.forwardRef(function MenuRadioItem2(componentProps, forwardedRef) {
+  const {
+    render,
+    className,
+    id: idProp,
+    label,
+    nativeButton = false,
+    disabled: disabledProp = false,
+    closeOnClick = false,
+    value,
+    ...elementProps
+  } = componentProps;
+  const listItem = useCompositeListItem({
+    label
+  });
+  const menuPositionerContext = useMenuPositionerContext(true);
+  const id = useBaseUiId(idProp);
+  const {
+    store
+  } = useMenuRootContext();
+  const highlighted = store.useState("isActive", listItem.index);
+  const itemProps = store.useState("itemProps");
+  const {
+    value: selectedValue,
+    setValue: setSelectedValue,
+    disabled: groupDisabled
+  } = useMenuRadioGroupContext();
+  const disabled = groupDisabled || disabledProp;
+  const checked = selectedValue === value;
+  const {
+    getItemProps,
+    itemRef
+  } = useMenuItem({
+    closeOnClick,
+    disabled,
+    highlighted,
+    id,
+    store,
+    nativeButton,
+    nodeId: menuPositionerContext == null ? void 0 : menuPositionerContext.nodeId,
+    itemMetadata: REGULAR_ITEM
+  });
+  const state = React.useMemo(() => ({
+    disabled,
+    highlighted,
+    checked
+  }), [disabled, highlighted, checked]);
+  const handleClick = useStableCallback((event) => {
+    const details = {
+      ...createChangeEventDetails(itemPress, event.nativeEvent),
+      preventUnmountOnClose: () => {
+      }
+    };
+    setSelectedValue(value, details);
+  });
+  const element = useRenderElement("div", componentProps, {
+    state,
+    stateAttributesMapping: itemMapping,
+    props: [itemProps, {
+      role: "menuitemradio",
+      "aria-checked": checked,
+      onClick: handleClick
+    }, elementProps, getItemProps],
+    ref: [itemRef, forwardedRef, listItem.ref]
+  });
+  return /* @__PURE__ */ jsx(MenuRadioItemContext.Provider, {
+    value: state,
+    children: element
+  });
+});
+if (process.env.NODE_ENV !== "production") MenuRadioItem.displayName = "MenuRadioItem";
+export {
+  MenuRadioItem
+};

@@ -0,0 +1,15 @@
+import formatErrorMessage from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/formatErrorMessage.js";
+import * as React from "react";
+const MenuRadioItemContext = /* @__PURE__ */ React.createContext(void 0);
+if (process.env.NODE_ENV !== "production") MenuRadioItemContext.displayName = "MenuRadioItemContext";
+function useMenuRadioItemContext() {
+  const context = React.useContext(MenuRadioItemContext);
+  if (context === void 0) {
+    throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: MenuRadioItemContext is missing. MenuRadioItem parts must be placed within <Menu.RadioItem>." : formatErrorMessage(35));
+  }
+  return context;
+}
+export {
+  MenuRadioItemContext,
+  useMenuRadioItemContext
+};

@@ -0,0 +1,50 @@
+import * as React from "react";
+import { useMenuRadioItemContext } from "../radio-item/MenuRadioItemContext.js";
+import { useRenderElement } from "../../utils/useRenderElement.js";
+import { itemMapping } from "../utils/stateAttributesMapping.js";
+import { useTransitionStatus } from "../../utils/useTransitionStatus.js";
+import { useOpenChangeComplete } from "../../utils/useOpenChangeComplete.js";
+const MenuRadioItemIndicator = /* @__PURE__ */ React.forwardRef(function MenuRadioItemIndicator2(componentProps, forwardedRef) {
+  const {
+    render,
+    className,
+    keepMounted = false,
+    ...elementProps
+  } = componentProps;
+  const item = useMenuRadioItemContext();
+  const indicatorRef = React.useRef(null);
+  const {
+    transitionStatus,
+    setMounted
+  } = useTransitionStatus(item.checked);
+  useOpenChangeComplete({
+    open: item.checked,
+    ref: indicatorRef,
+    onComplete() {
+      if (!item.checked) {
+        setMounted(false);
+      }
+    }
+  });
+  const state = {
+    checked: item.checked,
+    disabled: item.disabled,
+    highlighted: item.highlighted,
+    transitionStatus
+  };
+  const element = useRenderElement("span", componentProps, {
+    state,
+    stateAttributesMapping: itemMapping,
+    ref: [forwardedRef, indicatorRef],
+    props: {
+      "aria-hidden": true,
+      ...elementProps
+    },
+    enabled: keepMounted || item.checked
+  });
+  return element;
+});
+if (process.env.NODE_ENV !== "production") MenuRadioItemIndicator.displayName = "MenuRadioItemIndicator";
+export {
+  MenuRadioItemIndicator
+};

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/menu/root/MenuRoot.js ADDED Viewed

@@ -0,0 +1,403 @@
+import * as React from "react";
+import { useTimeout } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/useTimeout.js";
+import { useStableCallback } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/useStableCallback.js";
+import { useId } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/useId.js";
+import { useIsoLayoutEffect } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/useIsoLayoutEffect.js";
+import { useOnFirstRender } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/useOnFirstRender.js";
+import { useScrollLock } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/useScrollLock.js";
+import { EMPTY_ARRAY } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/empty.js";
+import { fastComponent } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/fastHooks.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 { triggerHover, triggerFocus, triggerPress, itemPress, escapeKey, focusOut, listNavigation, siblingOpen, imperativeAction } from "../../utils/reason-parts.js";
+import { mergeProps } from "../../merge-props/mergeProps.js";
+const MenuRoot = fastComponent(function MenuRoot2(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 == null ? void 0 : handle.store, {
+    open: defaultOpen,
+    openProp,
+    activeTriggerId: defaultTriggerIdProp,
+    triggerIdProp,
+    parent: parentFromContext
+  });
+  useOnFirstRender(() => {
+    if (openProp === void 0 && store.state.open === false && defaultOpen === true) {
+      store.update({
+        open: true,
+        activeTriggerId: defaultTriggerIdProp
+      });
+    }
+  });
+  store.useControlledProp("openProp", openProp);
+  store.useControlledProp("triggerIdProp", triggerIdProp);
+  store.useContextCallback("onOpenChangeComplete", onOpenChangeComplete);
+  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]);
+  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
+  } = useOpenInteractionType(open);
+  useImplicitActiveTrigger(store);
+  const {
+    forceUnmount
+  } = useOpenStateTransitions(open, store, () => {
+    store.update({
+      allowMouseEnter: false,
+      stickIfOpen: true
+    });
+  });
+  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) => {
+    var _a;
+    const reason = eventDetails.reason;
+    if (open === nextOpen && eventDetails.trigger === activeTriggerElement && lastOpenChangeReason === reason) {
+      return;
+    }
+    eventDetails.preventUnmountOnClose = () => {
+      store.set("preventUnmountingOnClose", true);
+    };
+    if (!nextOpen && eventDetails.trigger == null) {
+      eventDetails.trigger = activeTriggerElement ?? void 0;
+    }
+    onOpenChange == null ? void 0 : onOpenChange(nextOpen, eventDetails);
+    if (eventDetails.isCanceled) {
+      return;
+    }
+    const details = {
+      open: nextOpen,
+      nativeEvent: eventDetails.event,
+      reason: eventDetails.reason,
+      nested
+    };
+    floatingEvents == null ? void 0 : floatingEvents.emit("openchange", details);
+    const nativeEvent = eventDetails.event;
+    if (nextOpen === false && (nativeEvent == null ? void 0 : nativeEvent.type) === "click" && nativeEvent.pointerType === "touch" && !allowTouchToCloseRef.current) {
+      return;
+    }
+    if (!nextOpen && activeIndex !== null) {
+      const activeOption = store.context.itemDomElements.current[activeIndex];
+      queueMicrotask(() => {
+        activeOption == null ? void 0 : 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 == null ? void 0 : nativeEvent.isTrusted);
+    const isDismissClose = !nextOpen && (reason === escapeKey || reason == null);
+    const updatedState = {
+      open: nextOpen,
+      openChangeReason: reason
+    };
+    openEventRef.current = eventDetails.event ?? null;
+    const newTriggerId = ((_a = eventDetails.trigger) == null ? void 0 : _a.id) ?? null;
+    if (newTriggerId || nextOpen) {
+      updatedState.activeTriggerId = newTriggerId;
+      updatedState.activeTriggerElement = eventDetails.trigger ?? null;
+    }
+    store.update(updatedState);
+    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 == null ? void 0 : ctx.positionerRef, () => positionerElement, [positionerElement]);
+  React.useImperativeHandle(ctx == null ? void 0 : 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 == null ? void 0 : floatingEvents.off("setOpen", handleSetOpenEvent);
+    };
+  }, [floatingEvents, setOpen]);
+  const dismiss = useDismiss(floatingRootContext, {
+    enabled: !disabled,
+    bubbles: {
+      escapeKey: closeParentOnEsc && parent.type === "menu"
+    },
+    outsidePress() {
+      var _a;
+      if (parent.type !== "context-menu" || ((_a = openEventRef.current) == null ? void 0 : _a.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,
+    elementsRef: store.context.itemDomElements,
+    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(), {
+      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 popupProps = React.useMemo(() => getFloatingProps({
+    onMouseMove() {
+      store.set("allowMouseEnter", true);
+      if (parent.type === "menu") {
+        store.set("hoverEnabled", false);
+      }
+    },
+    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, 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;
+});
+if (process.env.NODE_ENV !== "production") MenuRoot.displayName = "MenuRoot";
+export {
+  MenuRoot
+};

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/menu/root/MenuRootContext.js ADDED Viewed

@@ -0,0 +1,15 @@
+import formatErrorMessage from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/formatErrorMessage.js";
+import * as React from "react";
+const 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
+};