@ledgerhq/lumen-ui-react 0.1.35 → 0.1.37

package/dist/node_modules/@base-ui/react/esm/floating-ui-react/hooks/useFocus.js

@@ -0,0 +1,97 @@
+import * as s from "react";
+import { getWindow as D, isElement as R, isHTMLElement as k } from "../../../../../@floating-ui/utils/dist/floating-ui.utils.dom.js";
+import { isMac as x, isSafari as O } from "../../../../utils/esm/detectBrowser.js";
+import { useTimeout as S } from "../../../../utils/esm/useTimeout.js";
+import { ownerDocument as A } from "../../../../utils/esm/owner.js";
+import { createChangeEventDetails as T } from "../../utils/createBaseUIEventDetails.js";
+import { createAttribute as C } from "../utils/createAttribute.js";
+import { activeElement as F, contains as L, isTargetInsideEnabledTrigger as h, getTarget as B, isTypeableElement as K, matchesFocusVisible as P } from "../utils/element.js";
+import { triggerFocus as b, triggerPress as V, escapeKey as G } from "../../utils/reason-parts.js";
+const y = x && O;
+function Q(d, M = {}) {
+  const t = "rootStore" in d ? d.rootStore : d, {
+    events: g,
+    dataRef: w
+  } = t.context, {
+    enabled: i = !0,
+    delay: l
+  } = M, u = s.useRef(!1), a = s.useRef(null), E = S(), p = s.useRef(!0);
+  s.useEffect(() => {
+    const r = t.select("domReferenceElement");
+    if (!i)
+      return;
+    const e = D(r);
+    function n() {
+      const o = t.select("domReferenceElement");
+      !t.select("open") && k(o) && o === F(A(o)) && (u.current = !0);
+    }
+    function f() {
+      p.current = !0;
+    }
+    function c() {
+      p.current = !1;
+    }
+    return e.addEventListener("blur", n), y && (e.addEventListener("keydown", f, !0), e.addEventListener("pointerdown", c, !0)), () => {
+      e.removeEventListener("blur", n), y && (e.removeEventListener("keydown", f, !0), e.removeEventListener("pointerdown", c, !0));
+    };
+  }, [t, i]), s.useEffect(() => {
+    if (!i)
+      return;
+    function r(e) {
+      if (e.reason === V || e.reason === G) {
+        const n = t.select("domReferenceElement");
+        R(n) && (a.current = n, u.current = !0);
+      }
+    }
+    return g.on("openchange", r), () => {
+      g.off("openchange", r);
+    };
+  }, [g, i, t]);
+  const v = s.useMemo(() => ({
+    onMouseLeave() {
+      u.current = !1, a.current = null;
+    },
+    onFocus(r) {
+      const e = r.currentTarget;
+      if (u.current) {
+        if (a.current === e)
+          return;
+        u.current = !1, a.current = null;
+      }
+      const n = B(r.nativeEvent);
+      if (R(n)) {
+        if (y && !r.relatedTarget) {
+          if (!p.current && !K(n))
+            return;
+        } else if (!P(n))
+          return;
+      }
+      const f = h(r.relatedTarget, t.context.triggerElements), {
+        nativeEvent: c,
+        currentTarget: o
+      } = r, m = typeof l == "function" ? l() : l;
+      if (t.select("open") && f || m === 0 || m === void 0) {
+        t.setOpen(!0, T(b, c, o));
+        return;
+      }
+      E.start(m, () => {
+        u.current || t.setOpen(!0, T(b, c, o));
+      });
+    },
+    onBlur(r) {
+      u.current = !1, a.current = null;
+      const e = r.relatedTarget, n = r.nativeEvent, f = R(e) && e.hasAttribute(C("focus-guard")) && e.getAttribute("data-type") === "outside";
+      E.start(0, () => {
+        const c = t.select("domReferenceElement"), o = F(c ? c.ownerDocument : document);
+        !e && o === c || L(w.current.floatingContext?.refs.floating.current, o) || L(c, o) || f || h(e ?? o, t.context.triggerElements) || t.setOpen(!1, T(b, n));
+      });
+    }
+  }), [w, t, E, l]);
+  return s.useMemo(() => i ? {
+    reference: v,
+    trigger: v
+  } : {}, [i, v]);
+}
+export {
+  Q as useFocus
+};

package/dist/node_modules/@base-ui/react/esm/floating-ui-react/hooks/useHoverFloatingInteraction.js

@@ -6,30 +6,30 @@ import { useTimeout as w } from "../../../../utils/esm/useTimeout.js";
 import { ownerDocument as H } from "../../../../utils/esm/owner.js";
 import { createChangeEventDetails as b } from "../../utils/createBaseUIEventDetails.js";
 import { useFloatingTree as M, useFloatingParentNodeId as N } from "../components/FloatingTree.js";
-import { useHoverInteractionSharedState as x, clearSafePolygonPointerEventsMutation as W, isInteractiveElement as $, applySafePolygonPointerEventsMutation as j } from "./useHoverInteractionSharedState.js";
-import { isClickLikeOpenEvent as q, getDelay as z } from "./useHoverShared.js";
-import { isTargetInsideEnabledTrigger as A, getTarget as B } from "../utils/element.js";
+import { useHoverInteractionSharedState as x, applySafePolygonPointerEventsMutation as W, clearSafePolygonPointerEventsMutation as $, isInteractiveElement as j } from "./useHoverInteractionSharedState.js";
+import { getDelay as q, isClickLikeOpenEvent as z } from "./useHoverShared.js";
 import { triggerHover as R } from "../../utils/reason-parts.js";
 import { getNodeChildren as k } from "../utils/nodes.js";
+import { getTarget as A, isTargetInsideEnabledTrigger as B } from "../utils/element.js";
 function ne(p, D = {}) {
   const r = "rootStore" in p ? p.rootStore : p, u = r.useState("open"), f = r.useState("floatingElement"), g = r.useState("domReferenceElement"), {
     dataRef: E
   } = r.context, {
     enabled: m = !0,
     closeDelay: T = 0
-  } = D, e = x(r), n = M(), c = N(), I = d(() => q(E.current.openEvent?.type, e.interactedInside)), C = d(() => {
+  } = D, e = x(r), n = M(), c = N(), I = d(() => z(E.current.openEvent?.type, e.interactedInside)), C = d(() => {
     const t = E.current.openEvent?.type;
     return t?.includes("mouse") && t !== "mousedown";
-  }), S = d((t) => A(t, r.context.triggerElements)), L = y.useCallback((t) => {
-    const s = z(T, "close", e.pointerType), a = () => {
+  }), S = d((t) => B(t, r.context.triggerElements)), L = y.useCallback((t) => {
+    const s = q(T, "close", e.pointerType), a = () => {
       r.setOpen(!1, b(R, t)), n?.events.emit("floating.closed", t);
     };
     s ? e.openChangeTimeout.start(s, a) : (e.openChangeTimeout.clear(), a());
   }, [T, r, e, n]), i = d(() => {
-    W(e);
+    $(e);
   }), v = d((t) => {
-    const s = B(t);
-    if (!$(s)) {
+    const s = A(t);
+    if (!j(s)) {
       e.interactedInside = !1;
       return;
     }
@@ -42,7 +42,7 @@ function ne(p, D = {}) {
       const t = g, s = f, a = H(f), o = n?.nodesRef.current.find((O) => O.id === c)?.context?.elements.floating;
       o && (o.style.pointerEvents = "");
       const l = e.handleCloseOptions?.getScope?.() ?? e.pointerEventsScopeElement ?? o ?? t.closest("[data-rootownerid]") ?? a.body;
-      return j(e, {
+      return W(e, {
         scopeElement: l,
         referenceElement: t,
         floatingElement: s

package/dist/node_modules/@base-ui/react/esm/floating-ui-react/hooks/useHoverReferenceInteraction.js

@@ -7,10 +7,10 @@ import { ownerDocument as B } from "../../../../utils/esm/owner.js";
 import { createChangeEventDetails as d } from "../../utils/createBaseUIEventDetails.js";
 import { useFloatingTree as K } from "../components/FloatingTree.js";
 import { useHoverInteractionSharedState as Q, clearSafePolygonPointerEventsMutation as U } from "./useHoverInteractionSharedState.js";
-import { getDelay as Y, getRestMs as N, isClickLikeOpenEvent as Z } from "./useHoverShared.js";
+import { isClickLikeOpenEvent as Z, getDelay as Y, getRestMs as N } from "./useHoverShared.js";
+import { isTargetInsideEnabledTrigger as ee, contains as P } from "../utils/element.js";
 import { isMouseLikePointerType as W } from "../utils/event.js";
 import { triggerHover as g } from "../../utils/reason-parts.js";
-import { contains as P, isTargetInsideEnabledTrigger as ee } from "../utils/element.js";
 const te = {
   current: null
 };

package/dist/node_modules/@base-ui/react/esm/floating-ui-react/utils/element.js

@@ -1,12 +1,13 @@
 import { isShadowRoot as i, isHTMLElement as u, isElement as s } from "../../../../../@floating-ui/utils/dist/floating-ui.utils.dom.js";
-import { TYPEABLE_SELECTOR as a, FOCUSABLE_ATTRIBUTE as o } from "./constants.js";
+import { isJSDOM as a } from "../../../../utils/esm/detectBrowser.js";
+import { FOCUSABLE_ATTRIBUTE as o, TYPEABLE_SELECTOR as c } from "./constants.js";
 function d(t) {
   let e = t.activeElement;
   for (; e?.shadowRoot?.activeElement != null; )
     e = e.shadowRoot.activeElement;
   return e;
 }
-function c(t, e) {
+function f(t, e) {
   if (!t || !e)
     return !1;
   const r = e.getRootNode?.();
@@ -22,21 +23,21 @@ function c(t, e) {
   }
   return !1;
 }
-function h(t, e) {
+function g(t, e) {
   if (!s(t))
     return !1;
   const r = t;
   if (e.hasElement(r))
     return !r.hasAttribute("data-trigger-disabled");
   for (const [, n] of e.entries())
-    if (c(n, r))
+    if (f(n, r))
       return !n.hasAttribute("data-trigger-disabled");
   return !1;
 }
-function b(t) {
+function E(t) {
   return "composedPath" in t ? t.composedPath()[0] : t.target;
 }
-function g(t, e) {
+function T(t, e) {
   if (e == null)
     return !1;
   if ("composedPath" in t)
@@ -44,26 +45,36 @@ function g(t, e) {
   const r = t;
   return r.target != null && e.contains(r.target);
 }
-function E(t) {
+function p(t) {
   return t.matches("html,body");
 }
-function f(t) {
-  return u(t) && t.matches(a);
+function l(t) {
+  return u(t) && t.matches(c);
 }
-function T(t) {
-  return t ? t.getAttribute("role") === "combobox" && f(t) : !1;
+function A(t) {
+  return t ? t.getAttribute("role") === "combobox" && l(t) : !1;
 }
-function p(t) {
+function R(t) {
+  if (!t || a)
+    return !0;
+  try {
+    return t.matches(":focus-visible");
+  } catch {
+    return !0;
+  }
+}
+function w(t) {
   return t ? t.hasAttribute(o) ? t : t.querySelector(`[${o}]`) || t : null;
 }
 export {
   d as activeElement,
-  c as contains,
-  p as getFloatingFocusElement,
-  b as getTarget,
-  g as isEventTargetWithin,
-  E as isRootElement,
-  h as isTargetInsideEnabledTrigger,
-  T as isTypeableCombobox,
-  f as isTypeableElement
+  f as contains,
+  w as getFloatingFocusElement,
+  E as getTarget,
+  T as isEventTargetWithin,
+  p as isRootElement,
+  g as isTargetInsideEnabledTrigger,
+  A as isTypeableCombobox,
+  l as isTypeableElement,
+  R as matchesFocusVisible
 };

package/dist/node_modules/@base-ui/react/esm/menu/checkbox-item/MenuCheckboxItem.js

@@ -0,0 +1,78 @@
+import * as c from "react";
+import { useStableCallback as A } from "../../../../utils/esm/useStableCallback.js";
+import { useControlled as O } from "../../../../utils/esm/useControlled.js";
+import { MenuCheckboxItemContext as S } from "./MenuCheckboxItemContext.js";
+import { useMenuItem as U, REGULAR_ITEM as B } from "../item/useMenuItem.js";
+import { useCompositeListItem as D } from "../../composite/list/useCompositeListItem.js";
+import { useMenuRootContext as L } from "../root/MenuRootContext.js";
+import { useRenderElement as _ } from "../../utils/useRenderElement.js";
+import { useBaseUiId as j } from "../../utils/useBaseUiId.js";
+import { itemMapping as w } from "../utils/stateAttributesMapping.js";
+import { useMenuPositionerContext as y } from "../positioner/MenuPositionerContext.js";
+import { createChangeEventDetails as G } from "../../utils/createBaseUIEventDetails.js";
+import { jsx as T } from "react/jsx-runtime";
+import { itemPress as V } from "../../utils/reason-parts.js";
+const q = /* @__PURE__ */ c.forwardRef(function(r, a) {
+  const {
+    render: F,
+    className: H,
+    id: d,
+    label: l,
+    nativeButton: u = !1,
+    disabled: t = !1,
+    closeOnClick: p = !1,
+    checked: f,
+    defaultChecked: C,
+    onCheckedChange: h,
+    ...k
+  } = r, s = D({
+    label: l
+  }), x = y(!0), I = j(d), {
+    store: o
+  } = L(), n = o.useState("isActive", s.index), M = o.useState("itemProps"), [e, b] = O({
+    controlled: f,
+    default: C ?? !1,
+    name: "MenuCheckboxItem",
+    state: "checked"
+  }), {
+    getItemProps: v,
+    itemRef: P
+  } = U({
+    closeOnClick: p,
+    disabled: t,
+    highlighted: n,
+    id: I,
+    store: o,
+    nativeButton: u,
+    nodeId: x?.nodeId,
+    itemMetadata: B
+  }), i = c.useMemo(() => ({
+    disabled: t,
+    highlighted: n,
+    checked: e
+  }), [t, n, e]), g = A((R) => {
+    const m = {
+      ...G(V, R.nativeEvent),
+      preventUnmountOnClose: () => {
+      }
+    };
+    h?.(!e, m), !m.isCanceled && b((N) => !N);
+  }), E = _("div", r, {
+    state: i,
+    stateAttributesMapping: w,
+    props: [M, {
+      role: "menuitemcheckbox",
+      "aria-checked": e,
+      onClick: g
+    }, k, v],
+    ref: [P, a, s.ref]
+  });
+  return /* @__PURE__ */ T(S.Provider, {
+    value: i,
+    children: E
+  });
+});
+process.env.NODE_ENV !== "production" && (q.displayName = "MenuCheckboxItem");
+export {
+  q as MenuCheckboxItem
+};

package/dist/node_modules/@base-ui/react/esm/menu/checkbox-item/MenuCheckboxItemContext.js

@@ -0,0 +1,14 @@
+import n from "../../../../utils/esm/formatErrorMessage.js";
+import * as t from "react";
+const o = /* @__PURE__ */ t.createContext(void 0);
+process.env.NODE_ENV !== "production" && (o.displayName = "MenuCheckboxItemContext");
+function s() {
+  const e = t.useContext(o);
+  if (e === void 0)
+    throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: MenuCheckboxItemContext is missing. MenuCheckboxItem parts must be placed within <Menu.CheckboxItem>." : n(30));
+  return e;
+}
+export {
+  o as MenuCheckboxItemContext,
+  s as useMenuCheckboxItemContext
+};

package/dist/node_modules/@base-ui/react/esm/menu/checkbox-item/MenuCheckboxItemDataAttributes.js

@@ -0,0 +1,6 @@
+let h = /* @__PURE__ */ (function(d) {
+  return d.checked = "data-checked", d.unchecked = "data-unchecked", d.disabled = "data-disabled", d.highlighted = "data-highlighted", d;
+})({});
+export {
+  h as MenuCheckboxItemDataAttributes
+};

package/dist/node_modules/@base-ui/react/esm/menu/checkbox-item-indicator/MenuCheckboxItemIndicator.js

@@ -0,0 +1,44 @@
+import * as o from "react";
+import { useMenuCheckboxItemContext as m } from "../checkbox-item/MenuCheckboxItemContext.js";
+import { useRenderElement as p } from "../../utils/useRenderElement.js";
+import { itemMapping as u } from "../utils/stateAttributesMapping.js";
+import { useTransitionStatus as h } from "../../utils/useTransitionStatus.js";
+import { useOpenChangeComplete as f } from "../../utils/useOpenChangeComplete.js";
+const l = /* @__PURE__ */ o.forwardRef(function(t, r) {
+  const {
+    render: b,
+    className: C,
+    keepMounted: i = !1,
+    ...s
+  } = t, e = m(), n = o.useRef(null), {
+    transitionStatus: c,
+    setMounted: a
+  } = h(e.checked);
+  f({
+    open: e.checked,
+    ref: n,
+    onComplete() {
+      e.checked || a(!1);
+    }
+  });
+  const d = {
+    checked: e.checked,
+    disabled: e.disabled,
+    highlighted: e.highlighted,
+    transitionStatus: c
+  };
+  return p("span", t, {
+    state: d,
+    ref: [r, n],
+    stateAttributesMapping: u,
+    props: {
+      "aria-hidden": !0,
+      ...s
+    },
+    enabled: i || e.checked
+  });
+});
+process.env.NODE_ENV !== "production" && (l.displayName = "MenuCheckboxItemIndicator");
+export {
+  l as MenuCheckboxItemIndicator
+};

package/dist/node_modules/@base-ui/react/esm/menu/group/MenuGroup.js

@@ -0,0 +1,28 @@
+import * as e from "react";
+import { useRenderElement as l } from "../../utils/useRenderElement.js";
+import { MenuGroupContext as p } from "./MenuGroupContext.js";
+import { jsx as d } from "react/jsx-runtime";
+const i = /* @__PURE__ */ e.forwardRef(function(r, t) {
+  const {
+    render: c,
+    className: f,
+    ...n
+  } = r, [s, o] = e.useState(void 0), u = e.useMemo(() => ({
+    setLabelId: o
+  }), [o]), a = l("div", r, {
+    ref: t,
+    props: {
+      role: "group",
+      "aria-labelledby": s,
+      ...n
+    }
+  });
+  return /* @__PURE__ */ d(p.Provider, {
+    value: u,
+    children: a
+  });
+});
+process.env.NODE_ENV !== "production" && (i.displayName = "MenuGroup");
+export {
+  i as MenuGroup
+};

package/dist/node_modules/@base-ui/react/esm/menu/group/MenuGroupContext.js

@@ -0,0 +1,14 @@
+import n from "../../../../utils/esm/formatErrorMessage.js";
+import * as o from "react";
+const t = /* @__PURE__ */ o.createContext(void 0);
+process.env.NODE_ENV !== "production" && (t.displayName = "MenuGroupContext");
+function u() {
+  const e = o.useContext(t);
+  if (e === void 0)
+    throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: MenuGroupRootContext is missing. Menu group parts must be used within <Menu.Group>." : n(31));
+  return e;
+}
+export {
+  t as MenuGroupContext,
+  u as useMenuGroupRootContext
+};

package/dist/node_modules/@base-ui/react/esm/menu/group-label/MenuGroupLabel.js

@@ -0,0 +1,29 @@
+import * as u from "react";
+import { useIsoLayoutEffect as p } from "../../../../utils/esm/useIsoLayoutEffect.js";
+import { useRenderElement as i } from "../../utils/useRenderElement.js";
+import { useBaseUiId as a } from "../../utils/useBaseUiId.js";
+import { useMenuGroupRootContext as m } from "../group/MenuGroupContext.js";
+const d = /* @__PURE__ */ u.forwardRef(function(r, t) {
+  const {
+    className: c,
+    render: l,
+    id: n,
+    ...s
+  } = r, e = a(n), {
+    setLabelId: o
+  } = m();
+  return p(() => (o(e), () => {
+    o(void 0);
+  }), [o, e]), i("div", r, {
+    ref: t,
+    props: {
+      id: e,
+      role: "presentation",
+      ...s
+    }
+  });
+});
+process.env.NODE_ENV !== "production" && (d.displayName = "MenuGroupLabel");
+export {
+  d as MenuGroupLabel
+};

package/dist/node_modules/@base-ui/react/esm/menu/item/MenuItem.js

@@ -0,0 +1,47 @@
+import * as M from "react";
+import { useMenuItem as R, REGULAR_ITEM as P } from "./useMenuItem.js";
+import { useMenuRootContext as x } from "../root/MenuRootContext.js";
+import { useRenderElement as C } from "../../utils/useRenderElement.js";
+import { useBaseUiId as E } from "../../utils/useBaseUiId.js";
+import { useCompositeListItem as v } from "../../composite/list/useCompositeListItem.js";
+import { useMenuPositionerContext as N } from "../positioner/MenuPositionerContext.js";
+const g = /* @__PURE__ */ M.forwardRef(function(t, i) {
+  const {
+    render: b,
+    className: A,
+    id: n,
+    label: m,
+    nativeButton: u = !1,
+    disabled: o = !1,
+    closeOnClick: a = !0,
+    ...d
+  } = t, s = v({
+    label: m
+  }), c = N(!0), p = E(n), {
+    store: e
+  } = x(), r = e.useState("isActive", s.index), f = e.useState("itemProps"), {
+    getItemProps: l,
+    itemRef: I
+  } = R({
+    closeOnClick: a,
+    disabled: o,
+    highlighted: r,
+    id: p,
+    store: e,
+    nativeButton: u,
+    nodeId: c?.nodeId,
+    itemMetadata: P
+  });
+  return C("div", t, {
+    state: {
+      disabled: o,
+      highlighted: r
+    },
+    props: [f, d, l],
+    ref: [I, i, s.ref]
+  });
+});
+process.env.NODE_ENV !== "production" && (g.displayName = "MenuItem");
+export {
+  g as MenuItem
+};

package/dist/node_modules/@base-ui/react/esm/menu/item/useMenuItem.js

@@ -0,0 +1,50 @@
+import * as t from "react";
+import { useMergedRefs as b } from "../../../../utils/esm/useMergedRefs.js";
+import { useMenuItemCommonProps as I } from "./useMenuItemCommonProps.js";
+import { useButton as P } from "../../use-button/useButton.js";
+import { mergeProps as h } from "../../merge-props/mergeProps.js";
+const E = {
+  type: "regular-item"
+};
+function k(i) {
+  const {
+    closeOnClick: c,
+    disabled: f = !1,
+    highlighted: p,
+    id: a,
+    store: o,
+    typingRef: g = o.context.typingRef,
+    nativeButton: l,
+    itemMetadata: e,
+    nodeId: R
+  } = i, r = t.useRef(null), {
+    getButtonProps: n,
+    buttonRef: d
+  } = P({
+    disabled: f,
+    focusableWhenDisabled: !0,
+    native: l,
+    composite: !0
+  }), s = I({
+    closeOnClick: c,
+    highlighted: p,
+    id: a,
+    nodeId: R,
+    store: o,
+    typingRef: g,
+    itemRef: r,
+    itemMetadata: e
+  }), m = t.useCallback((M) => h(s, {
+    onMouseEnter() {
+      e.type === "submenu-trigger" && e.setActive();
+    }
+  }, M, n), [s, n, e]), u = b(r, d);
+  return t.useMemo(() => ({
+    getItemProps: m,
+    itemRef: u
+  }), [m, u]);
+}
+export {
+  E as REGULAR_ITEM,
+  k as useMenuItem
+};

package/dist/node_modules/@base-ui/react/esm/menu/item/useMenuItemCommonProps.js

@@ -0,0 +1,49 @@
+import * as p from "react";
+import { isMac as C } from "../../../../utils/esm/detectBrowser.js";
+import { useContextMenuRootContext as d } from "../../context-menu/root/ContextMenuRootContext.js";
+import { itemPress as g } from "../../utils/reason-parts.js";
+function b(M) {
+  const {
+    closeOnClick: m,
+    highlighted: a,
+    id: f,
+    nodeId: n,
+    store: r,
+    typingRef: l,
+    itemRef: i,
+    itemMetadata: u
+  } = M, {
+    events: s
+  } = r.useState("floatingTreeRoot"), e = d(!0), o = e !== void 0;
+  return p.useMemo(() => ({
+    id: f,
+    role: "menuitem",
+    tabIndex: a ? 0 : -1,
+    onKeyDown(t) {
+      t.key === " " && l?.current && t.preventDefault();
+    },
+    onMouseMove(t) {
+      n && s.emit("itemhover", {
+        nodeId: n,
+        target: t.currentTarget
+      });
+    },
+    onClick(t) {
+      m && s.emit("close", {
+        domEvent: t,
+        reason: g
+      });
+    },
+    onMouseUp(t) {
+      if (e) {
+        const c = e.initialCursorPointRef.current;
+        if (e.initialCursorPointRef.current = null, o && c && Math.abs(t.clientX - c.x) <= 1 && Math.abs(t.clientY - c.y) <= 1 || o && !C && t.button === 2)
+          return;
+      }
+      i.current && r.context.allowMouseUpTriggerRef.current && (!o || t.button === 2) && (!u || u.type === "regular-item") && i.current.click();
+    }
+  }), [m, a, f, s, n, r, l, i, e, o, u]);
+}
+export {
+  b as useMenuItemCommonProps
+};