@ledgerhq/lumen-ui-react 0.1.34 → 0.1.36

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

@@ -0,0 +1,271 @@
+import * as r from "react";
+import { useTimeout as Q } from "../../../../utils/esm/useTimeout.js";
+import { useStableCallback as ke } from "../../../../utils/esm/useStableCallback.js";
+import { useId as we } from "../../../../utils/esm/useId.js";
+import { useIsoLayoutEffect as W } from "../../../../utils/esm/useIsoLayoutEffect.js";
+import { useOnFirstRender as Fe } from "../../../../utils/esm/useOnFirstRender.js";
+import { useScrollLock as Ae } from "../../../../utils/esm/useScrollLock.js";
+import { EMPTY_ARRAY as He } from "../../../../utils/esm/empty.js";
+import { fastComponent as Ue } from "../../../../utils/esm/fastHooks.js";
+import { useMenuRootContext as Ke, MenuRootContext as _e } from "./MenuRootContext.js";
+import { useMenubarContext as Le } from "../../menubar/MenubarContext.js";
+import { TYPEAHEAD_RESET_MS as Ve } from "../../utils/constants.js";
+import { useDirection as De } from "../../direction-provider/DirectionContext.js";
+import { useOpenInteractionType as Ye } from "../../utils/useOpenInteractionType.js";
+import { createChangeEventDetails as je } from "../../utils/createBaseUIEventDetails.js";
+import { useContextMenuRootContext as qe } from "../../context-menu/root/ContextMenuRootContext.js";
+import { MenuStore as Be } from "../store/MenuStore.js";
+import { useMenuSubmenuRootContext as $e } from "../submenu-root/MenuSubmenuRootContext.js";
+import { jsx as X } from "react/jsx-runtime";
+import { useFloatingNodeId as ze, useFloatingParentNodeId as Ge, FloatingTree as Je } from "../../floating-ui-react/components/FloatingTree.js";
+import { useImplicitActiveTrigger as Qe, useOpenStateTransitions as We } from "../../utils/popups/popupStoreUtils.js";
+import { useSyncedFloatingRootContext as Xe } from "../../floating-ui-react/hooks/useSyncedFloatingRootContext.js";
+import { useDismiss as Ze } from "../../floating-ui-react/hooks/useDismiss.js";
+import { useRole as et } from "../../floating-ui-react/hooks/useRole.js";
+import { useListNavigation as tt } from "../../floating-ui-react/hooks/useListNavigation.js";
+import { useTypeahead as ot } from "../../floating-ui-react/hooks/useTypeahead.js";
+import { useInteractions as nt } from "../../floating-ui-react/hooks/useInteractions.js";
+import { triggerHover as Z, triggerFocus as ee, focusOut as rt, listNavigation as st, siblingOpen as it, triggerPress as at, itemPress as ut, escapeKey as ct, imperativeAction as lt } from "../../utils/reason-parts.js";
+import { mergeProps as te } from "../../merge-props/mergeProps.js";
+const pt = Ue(function(oe) {
+  const {
+    children: v,
+    open: C,
+    onOpenChange: ne,
+    onOpenChangeComplete: re,
+    defaultOpen: N = !1,
+    disabled: se = !1,
+    modal: k,
+    loopFocus: ie = !0,
+    orientation: ae = "vertical",
+    actionsRef: ue,
+    closeParentOnEsc: ce = !1,
+    handle: le,
+    triggerId: w,
+    defaultTriggerId: F = null,
+    highlightItemOnHover: pe = !0
+  } = oe, u = qe(!0), a = Ke(!0), I = Le(), A = $e(), T = r.useMemo(() => A && a ? {
+    type: "menu",
+    store: a.store
+  } : I ? {
+    type: "menubar",
+    context: I
+  } : u && !a ? {
+    type: "context-menu",
+    context: u
+  } : {
+    type: void 0
+  }, [u, a, I, A]), e = Be.useStore(le?.store, {
+    open: N,
+    openProp: C,
+    activeTriggerId: F,
+    triggerIdProp: w,
+    parent: T
+  });
+  Fe(() => {
+    C === void 0 && e.state.open === !1 && N === !0 && e.update({
+      open: !0,
+      activeTriggerId: F
+    });
+  }), e.useControlledProp("openProp", C), e.useControlledProp("triggerIdProp", w), e.useContextCallback("onOpenChangeComplete", re);
+  const m = e.useState("floatingTreeRoot"), x = ze(m), P = Ge();
+  W(() => {
+    u && !a ? e.update({
+      parent: {
+        type: "context-menu",
+        context: u
+      },
+      floatingNodeId: x,
+      floatingParentNodeId: P
+    }) : a && e.update({
+      floatingNodeId: x,
+      floatingParentNodeId: P
+    });
+  }, [u, a, x, P, e]);
+  const i = e.useState("open"), H = e.useState("activeTriggerElement"), b = e.useState("positionerElement"), U = e.useState("hoverEnabled"), de = e.useState("modal"), K = e.useState("disabled"), _ = e.useState("lastOpenChangeReason"), n = e.useState("parent"), l = e.useState("activeIndex"), me = e.useState("payload"), fe = e.useState("floatingParentNodeId"), E = r.useRef(null), R = fe != null;
+  let p;
+  process.env.NODE_ENV !== "production" && n.type !== void 0 && k !== void 0 && console.warn("Base UI: The `modal` prop is not supported on nested menus. It will be ignored."), e.useSyncedValues({
+    disabled: se,
+    modal: n.type === void 0 ? k : void 0,
+    rootId: we()
+  });
+  const {
+    openMethod: ge,
+    triggerProps: f
+  } = Ye(i);
+  Qe(e);
+  const {
+    forceUnmount: L
+  } = We(i, e, () => {
+    e.update({
+      allowMouseEnter: !1,
+      stickIfOpen: !0
+    });
+  }), h = r.useRef(n.type !== "context-menu"), M = Q();
+  r.useEffect(() => {
+    if (i || (E.current = null), n.type === "context-menu") {
+      if (!i) {
+        M.clear(), h.current = !1;
+        return;
+      }
+      M.start(500, () => {
+        h.current = !0;
+      });
+    }
+  }, [M, i, n.type]), Ae(i && de && _ !== Z && ge !== "touch", b), W(() => {
+    !i && !U && e.set("hoverEnabled", !0);
+  }, [i, U, e]);
+  const g = r.useRef(!0), V = Q(), d = ke((t, o) => {
+    const s = o.reason;
+    if (i === t && o.trigger === H && _ === s || (o.preventUnmountOnClose = () => {
+      e.set("preventUnmountingOnClose", !0);
+    }, !t && o.trigger == null && (o.trigger = H ?? void 0), ne?.(t, o), o.isCanceled))
+      return;
+    const Se = {
+      open: t,
+      nativeEvent: o.event,
+      reason: o.reason,
+      nested: R
+    };
+    p?.emit("openchange", Se);
+    const y = o.event;
+    if (t === !1 && y?.type === "click" && y.pointerType === "touch" && !g.current)
+      return;
+    if (!t && l !== null) {
+      const Ne = e.context.itemDomElements.current[l];
+      queueMicrotask(() => {
+        Ne?.setAttribute("tabindex", "-1");
+      });
+    }
+    t && s === ee ? (g.current = !1, V.start(300, () => {
+      g.current = !0;
+    })) : (g.current = !0, V.clear());
+    const G = (s === at || s === ut) && y.detail === 0 && y?.isTrusted, Oe = !t && (s === ct || s == null), O = {
+      open: t,
+      openChangeReason: s
+    };
+    E.current = o.event ?? null;
+    const J = o.trigger?.id ?? null;
+    (J || t) && (O.activeTriggerId = J, O.activeTriggerElement = o.trigger ?? null), e.update(O), n.type === "menubar" && (s === ee || s === rt || s === Z || s === st || s === it) ? e.set("instantType", "group") : G || Oe ? e.set("instantType", G ? "click" : "dismiss") : e.set("instantType", void 0);
+  }), D = r.useCallback((t) => {
+    const o = je(t);
+    return o.preventUnmountOnClose = () => {
+      e.set("preventUnmountingOnClose", !0);
+    }, o;
+  }, [e]), Y = r.useCallback(() => {
+    e.setOpen(!1, D(lt));
+  }, [e, D]);
+  r.useImperativeHandle(ue, () => ({
+    unmount: L,
+    close: Y
+  }), [L, Y]);
+  let S;
+  n.type === "context-menu" && (S = n.context), r.useImperativeHandle(S?.positionerRef, () => b, [b]), r.useImperativeHandle(S?.actionsRef, () => ({
+    setOpen: d
+  }), [d]);
+  const c = Xe({
+    popupStore: e,
+    onOpenChange: d
+  });
+  p = c.context.events, r.useEffect(() => {
+    const t = ({
+      open: o,
+      eventDetails: s
+    }) => d(o, s);
+    return p.on("setOpen", t), () => {
+      p?.off("setOpen", t);
+    };
+  }, [p, d]);
+  const ye = Ze(c, {
+    enabled: !K,
+    bubbles: {
+      escapeKey: ce && n.type === "menu"
+    },
+    outsidePress() {
+      return n.type !== "context-menu" || E.current?.type === "contextmenu" ? !0 : h.current;
+    },
+    externalTree: R ? m : void 0
+  }), ve = et(c, {
+    role: "menu"
+  }), Ce = De(), Ie = r.useCallback((t) => {
+    e.select("activeIndex") !== t && e.set("activeIndex", t);
+  }, [e]), Te = tt(c, {
+    enabled: !K,
+    listRef: e.context.itemDomElements,
+    activeIndex: l,
+    nested: n.type !== void 0,
+    loopFocus: ie,
+    orientation: ae,
+    parentOrientation: n.type === "menubar" ? n.context.orientation : void 0,
+    rtl: Ce === "rtl",
+    disabledIndices: He,
+    onNavigate: Ie,
+    openOnArrowKeyDown: n.type !== "context-menu",
+    externalTree: R ? m : void 0,
+    focusItemOnHover: pe
+  }), xe = r.useCallback((t) => {
+    e.context.typingRef.current = t;
+  }, [e]), Pe = ot(c, {
+    listRef: e.context.itemLabels,
+    elementsRef: e.context.itemDomElements,
+    activeIndex: l,
+    resetMs: Ve,
+    onMatch: (t) => {
+      i && t !== l && e.set("activeIndex", t);
+    },
+    onTypingChange: xe
+  }), {
+    getReferenceProps: j,
+    getFloatingProps: q,
+    getItemProps: B,
+    getTriggerProps: $
+  } = nt([ye, ve, Te, Pe]), be = r.useMemo(() => {
+    const t = te(j(), {
+      onMouseMove() {
+        e.set("allowMouseEnter", !0);
+      }
+    }, f);
+    return delete t.role, t;
+  }, [j, e, f]), Ee = r.useMemo(() => {
+    const t = $();
+    if (!t)
+      return t;
+    const o = te(t, f);
+    return delete o.role, delete o["aria-controls"], o;
+  }, [$, f]), Re = r.useMemo(() => q({
+    onMouseMove() {
+      e.set("allowMouseEnter", !0), n.type === "menu" && e.set("hoverEnabled", !1);
+    },
+    onClick() {
+      e.select("hoverEnabled") && e.set("hoverEnabled", !1);
+    },
+    onKeyDown(t) {
+      const o = e.select("keyboardEventRelay");
+      o && !t.isPropagationStopped() && o(t);
+    }
+  }), [q, n.type, e]), he = r.useMemo(() => B(), [B]);
+  e.useSyncedValues({
+    floatingRootContext: c,
+    activeTriggerProps: be,
+    inactiveTriggerProps: Ee,
+    popupProps: Re,
+    itemProps: he
+  });
+  const Me = r.useMemo(() => ({
+    store: e,
+    parent: T
+  }), [e, T]), z = /* @__PURE__ */ X(_e.Provider, {
+    value: Me,
+    children: typeof v == "function" ? v({
+      payload: me
+    }) : v
+  });
+  return n.type === void 0 || n.type === "context-menu" ? /* @__PURE__ */ X(Je, {
+    externalTree: m,
+    children: z
+  }) : z;
+});
+process.env.NODE_ENV !== "production" && (pt.displayName = "MenuRoot");
+export {
+  pt as MenuRoot
+};

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

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

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

@@ -0,0 +1,109 @@
+import * as i from "react";
+import { EMPTY_OBJECT as c } from "../../../../utils/esm/empty.js";
+import { useRefWithInit as p } from "../../../../utils/esm/useRefWithInit.js";
+import { FloatingTreeStore as R } from "../../floating-ui-react/components/FloatingTreeStore.js";
+import { popupStoreSelectors as g, createInitialPopupStoreState as y } from "../../utils/popups/store.js";
+import { ReactStore as m } from "../../../../utils/esm/store/ReactStore.js";
+import { PopupTriggerMap as b } from "../../utils/popups/popupTriggerMap.js";
+import { createSelector as t } from "../../../../utils/esm/store/createSelector.js";
+const I = {
+  ...g,
+  disabled: t((e) => e.parent.type === "menubar" && e.parent.context.disabled || e.disabled),
+  modal: t((e) => (e.parent.type === void 0 || e.parent.type === "context-menu") && (e.modal ?? !0)),
+  allowMouseEnter: t((e) => e.allowMouseEnter),
+  stickIfOpen: t((e) => e.stickIfOpen),
+  parent: t((e) => e.parent),
+  rootId: t((e) => e.parent.type === "menu" ? e.parent.store.select("rootId") : e.parent.type !== void 0 ? e.parent.context.rootId : e.rootId),
+  activeIndex: t((e) => e.activeIndex),
+  isActive: t((e, r) => e.activeIndex === r),
+  hoverEnabled: t((e) => e.hoverEnabled),
+  instantType: t((e) => e.instantType),
+  lastOpenChangeReason: t((e) => e.openChangeReason),
+  floatingTreeRoot: t((e) => e.parent.type === "menu" ? e.parent.store.select("floatingTreeRoot") : e.floatingTreeRoot),
+  floatingNodeId: t((e) => e.floatingNodeId),
+  floatingParentNodeId: t((e) => e.floatingParentNodeId),
+  itemProps: t((e) => e.itemProps),
+  closeDelay: t((e) => e.closeDelay),
+  hasViewport: t((e) => e.hasViewport),
+  keyboardEventRelay: t((e) => {
+    if (e.keyboardEventRelay)
+      return e.keyboardEventRelay;
+    if (e.parent.type === "menu")
+      return e.parent.store.select("keyboardEventRelay");
+  })
+};
+class f extends m {
+  constructor(r) {
+    super({
+      ...T(),
+      ...r
+    }, {
+      positionerRef: /* @__PURE__ */ i.createRef(),
+      popupRef: /* @__PURE__ */ i.createRef(),
+      typingRef: {
+        current: !1
+      },
+      itemDomElements: {
+        current: []
+      },
+      itemLabels: {
+        current: []
+      },
+      allowMouseUpTriggerRef: {
+        current: !1
+      },
+      triggerFocusTargetRef: /* @__PURE__ */ i.createRef(),
+      beforeContentFocusGuardRef: /* @__PURE__ */ i.createRef(),
+      onOpenChangeComplete: void 0,
+      triggerElements: new b()
+    }, I), this.unsubscribeParentListener = this.observe("parent", (o) => {
+      if (this.unsubscribeParentListener?.(), o.type === "menu") {
+        let n = o.store.select("rootId"), a = o.store.select("floatingTreeRoot"), l = o.store.select("keyboardEventRelay");
+        this.unsubscribeParentListener = o.store.subscribe(() => {
+          const s = o.store.select("rootId"), u = o.store.select("floatingTreeRoot"), d = o.store.select("keyboardEventRelay");
+          n === s && a === u && l === d || (n = s, a = u, l = d, this.notifyAll());
+        }), this.context.allowMouseUpTriggerRef = o.store.context.allowMouseUpTriggerRef;
+        return;
+      }
+      o.type !== void 0 && (this.context.allowMouseUpTriggerRef = o.context.allowMouseUpTriggerRef), this.unsubscribeParentListener = null;
+    });
+  }
+  setOpen(r, o) {
+    this.state.floatingRootContext.context.events.emit("setOpen", {
+      open: r,
+      eventDetails: o
+    });
+  }
+  static useStore(r, o) {
+    const n = p(() => new f(o)).current;
+    return r ?? n;
+  }
+  unsubscribeParentListener = null;
+}
+function T() {
+  return {
+    ...y(),
+    disabled: !1,
+    modal: !0,
+    allowMouseEnter: !1,
+    stickIfOpen: !0,
+    parent: {
+      type: void 0
+    },
+    rootId: void 0,
+    activeIndex: null,
+    hoverEnabled: !0,
+    instantType: void 0,
+    openChangeReason: null,
+    floatingTreeRoot: new R(),
+    floatingNodeId: void 0,
+    floatingParentNodeId: null,
+    itemProps: c,
+    keyboardEventRelay: void 0,
+    closeDelay: 0,
+    hasViewport: !1
+  };
+}
+export {
+  f as MenuStore
+};

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

@@ -0,0 +1,21 @@
+import * as r from "react";
+import { MenuRoot as u } from "../root/MenuRoot.js";
+import { useMenuRootContext as m } from "../root/MenuRootContext.js";
+import { MenuSubmenuRootContext as i } from "./MenuSubmenuRootContext.js";
+import { useMenuSubmenuRootContext as a } from "./MenuSubmenuRootContext.js";
+import { jsx as e } from "react/jsx-runtime";
+function M(t) {
+  const o = m().store, n = r.useMemo(() => ({
+    parentMenu: o
+  }), [o]);
+  return /* @__PURE__ */ e(i.Provider, {
+    value: n,
+    children: /* @__PURE__ */ e(u, {
+      ...t
+    })
+  });
+}
+export {
+  M as MenuSubmenuRoot,
+  a as useMenuSubmenuRootContext
+};

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

@@ -0,0 +1,10 @@
+import * as e from "react";
+const t = /* @__PURE__ */ e.createContext(void 0);
+process.env.NODE_ENV !== "production" && (t.displayName = "MenuSubmenuRootContext");
+function n() {
+  return e.useContext(t);
+}
+export {
+  t as MenuSubmenuRootContext,
+  n as useMenuSubmenuRootContext
+};

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

@@ -0,0 +1,101 @@
+import U from "../../../../utils/esm/formatErrorMessage.js";
+import * as r from "react";
+import { useMenuRootContext as _ } from "../root/MenuRootContext.js";
+import { useBaseUiId as L } from "../../utils/useBaseUiId.js";
+import { triggerOpenStateMapping as j } from "../../utils/popupStateMapping.js";
+import { useCompositeListItem as q } from "../../composite/list/useCompositeListItem.js";
+import { useMenuItem as z } from "../item/useMenuItem.js";
+import { useRenderElement as F } from "../../utils/useRenderElement.js";
+import { useMenuPositionerContext as G } from "../positioner/MenuPositionerContext.js";
+import { useMenuSubmenuRootContext as J } from "../submenu-root/MenuSubmenuRootContext.js";
+import { useTriggerRegistration as K } from "../../utils/popups/popupStoreUtils.js";
+import { useHoverReferenceInteraction as Q } from "../../floating-ui-react/hooks/useHoverReferenceInteraction.js";
+import { safePolygon as W } from "../../floating-ui-react/safePolygon.js";
+import { useClick as X } from "../../floating-ui-react/hooks/useClick.js";
+import { useInteractions as Y } from "../../floating-ui-react/hooks/useInteractions.js";
+const Z = /* @__PURE__ */ r.forwardRef(function(c, v) {
+  const {
+    render: ee,
+    className: te,
+    label: oe,
+    id: M,
+    nativeButton: I = !1,
+    openOnHover: l = !0,
+    delay: m = 100,
+    closeDelay: n = 0,
+    disabled: S = !1,
+    ...T
+  } = c, s = q(), x = G(), {
+    store: e
+  } = _(), i = L(M), g = e.useState("open"), p = e.useState("floatingRootContext"), E = e.useState("floatingTreeRoot"), d = K(i, e), C = r.useCallback((o) => {
+    const H = d(o);
+    return o !== null && e.select("open") && e.select("activeTriggerId") == null && e.update({
+      activeTriggerId: i,
+      activeTriggerElement: o,
+      closeDelay: n
+    }), H;
+  }, [d, n, e, i]), f = r.useRef(null), P = r.useCallback((o) => {
+    f.current = o, e.set("activeTriggerElement", o);
+  }, [e]), b = J();
+  if (!b?.parentMenu)
+    throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: <Menu.SubmenuTrigger> must be placed in <Menu.SubmenuRoot>." : U(37));
+  e.useSyncedValue("closeDelay", n);
+  const t = b.parentMenu, y = t.useState("itemProps"), a = t.useState("isActive", s.index), h = r.useMemo(() => ({
+    type: "submenu-trigger",
+    setActive() {
+      t.set("activeIndex", s.index);
+    }
+  }), [t, s.index]), k = e.useState("disabled"), u = S || k, {
+    getItemProps: O,
+    itemRef: w
+  } = z({
+    closeOnClick: !1,
+    disabled: u,
+    highlighted: a,
+    id: i,
+    store: e,
+    typingRef: t.context.typingRef,
+    nativeButton: I,
+    itemMetadata: h,
+    nodeId: x?.nodeId
+  }), N = e.useState("hoverEnabled"), D = t.useState("allowMouseEnter"), B = Q(p, {
+    enabled: N && l && !u,
+    handleClose: W({
+      blockPointerEvents: !0
+    }),
+    mouseOnly: !0,
+    move: !0,
+    restMs: m,
+    delay: D ? {
+      open: m,
+      close: n
+    } : 0,
+    triggerElementRef: f,
+    externalTree: E
+  }), A = X(p, {
+    enabled: !u,
+    event: "mousedown",
+    toggle: !l,
+    ignoreMouse: l,
+    stickIfOpen: !1
+  }), V = Y([A]), R = e.useState("triggerProps", !0);
+  return delete R.id, F("div", c, {
+    state: {
+      disabled: u,
+      highlighted: a,
+      open: g
+    },
+    stateAttributesMapping: j,
+    props: [V.getReferenceProps(), B, R, y, {
+      tabIndex: g || a ? 0 : -1,
+      onBlur() {
+        a && t.set("activeIndex", null);
+      }
+    }, T, O],
+    ref: [v, s.ref, w, C, P]
+  });
+});
+process.env.NODE_ENV !== "production" && (Z.displayName = "MenuSubmenuTrigger");
+export {
+  Z as MenuSubmenuTrigger
+};