@ledgerhq/lumen-ui-react 0.1.14 → 0.1.16

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

@@ -0,0 +1,275 @@
+import * as a from "react";
+import { isWebKit as Xe, isElement as B, isShadowRoot as We, isLastTraversableNode as Z, getParentNode as Ye, isHTMLElement as Ae, getComputedStyle as _e } from "../../../../../@floating-ui/utils/dist/floating-ui.utils.dom.js";
+import { useTimeout as de, Timeout as pe } from "../../../../utils/esm/useTimeout.js";
+import { useStableCallback as y } from "../../../../utils/esm/useStableCallback.js";
+import { ownerDocument as me } from "../../../../utils/esm/owner.js";
+import { useFloatingTree as He } from "../components/FloatingTree.js";
+import { createChangeEventDetails as N } from "../../utils/createBaseUIEventDetails.js";
+import { createAttribute as Be } from "../utils/createAttribute.js";
+import { isReactEvent as Ne } from "../utils/event.js";
+import { getTarget as S, contains as F, isEventTargetWithin as l, isRootElement as Fe } from "../utils/element.js";
+import { getNodeChildren as z } from "../utils/nodes.js";
+import { escapeKey as qe, triggerPress as Ee, outsidePress as $e } from "../../utils/reason-parts.js";
+const Ve = {
+  intentional: "onClick",
+  sloppy: "onPointerDown"
+};
+function Ue() {
+  return !1;
+}
+function je(f) {
+  return {
+    escapeKey: typeof f == "boolean" ? f : f?.escapeKey ?? !1,
+    outsidePress: typeof f == "boolean" ? f : f?.outsidePress ?? !0
+  };
+}
+function it(f, he = {}) {
+  const n = "rootStore" in f ? f.rootStore : f, C = n.useState("open"), ee = n.useState("floatingElement"), {
+    dataRef: p
+  } = n.context, {
+    enabled: m = !0,
+    escapeKey: X = !0,
+    outsidePress: W = !0,
+    outsidePressEvent: ye = "sloppy",
+    referencePress: ge = Ue,
+    referencePressEvent: q = "sloppy",
+    bubbles: Pe,
+    externalTree: ve
+  } = he, g = He(ve), Re = y(typeof W == "function" ? W : () => !1), P = typeof W == "function" ? Re : W, $ = P !== !1, te = y(() => ye), k = a.useRef(!1), Y = a.useRef(!1), T = a.useRef(!1), {
+    escapeKey: A,
+    outsidePress: ne
+  } = je(Pe), i = a.useRef(null), O = de(), re = de(), E = y(() => {
+    re.clear(), p.current.insideReactTree = !1;
+  }), V = a.useRef(!1), U = a.useRef(""), j = y(ge), v = y((s) => {
+    if (!C || !m || !X || s.key !== "Escape" || V.current)
+      return;
+    const h = p.current.floatingContext?.nodeId, D = g ? z(g.nodesRef.current, h) : [];
+    if (!A && D.length > 0) {
+      let M = !0;
+      if (D.forEach((d) => {
+        d.context?.open && !d.context.dataRef.current.__escapeKeyBubbles && (M = !1);
+      }), !M)
+        return;
+    }
+    const _ = Ne(s) ? s.nativeEvent : s, I = N(qe, _);
+    n.setOpen(!1, I), !A && !I.isPropagationAllowed && s.stopPropagation();
+  }), R = y(() => {
+    p.current.insideReactTree = !0, re.start(0, E);
+  });
+  a.useEffect(() => {
+    if (!C || !m)
+      return;
+    p.current.__escapeKeyBubbles = A, p.current.__outsidePressBubbles = ne;
+    const s = new pe(), h = new pe();
+    function D() {
+      s.clear(), V.current = !0;
+    }
+    function _() {
+      s.start(
+        // 0ms or 1ms don't work in Safari. 5ms appears to consistently work.
+        // Only apply to WebKit for the test to remain 0ms.
+        Xe() ? 5 : 0,
+        () => {
+          V.current = !1;
+        }
+      );
+    }
+    function I() {
+      T.current = !0, h.start(0, () => {
+        T.current = !1;
+      });
+    }
+    function M() {
+      k.current = !1, Y.current = !1;
+    }
+    function d() {
+      const e = U.current, t = e === "pen" || !e ? "mouse" : e, o = te(), c = typeof o == "function" ? o() : o;
+      return typeof c == "string" ? c : c[t];
+    }
+    function Te(e) {
+      const t = d();
+      return t === "intentional" && e.type !== "click" || t === "sloppy" && e.type === "click";
+    }
+    function oe(e) {
+      const t = p.current.floatingContext?.nodeId, o = g && z(g.nodesRef.current, t).some((c) => l(e, c.context?.elements.floating));
+      return l(e, n.select("floatingElement")) || l(e, n.select("domReferenceElement")) || o;
+    }
+    function H(e) {
+      if (Te(e)) {
+        E();
+        return;
+      }
+      if (p.current.insideReactTree) {
+        E();
+        return;
+      }
+      const t = S(e), o = `[${Be("inert")}]`;
+      let c = Array.from(me(n.select("floatingElement")).querySelectorAll(o));
+      const K = B(t) ? t.getRootNode() : null;
+      We(K) && (c = c.concat(Array.from(K.querySelectorAll(o))));
+      const ae = n.context.triggerElements;
+      if (t && (ae.hasElement(t) || ae.hasMatchingElement((u) => F(u, t))))
+        return;
+      let x = B(t) ? t : null;
+      for (; x && !Z(x); ) {
+        const u = Ye(x);
+        if (Z(u) || !B(u))
+          break;
+        x = u;
+      }
+      if (c.length && B(t) && !Fe(t) && // Clicked on a direct ancestor (e.g. FloatingOverlay).
+      !F(t, n.select("floatingElement")) && // If the target root element contains none of the markers, then the
+      // element was injected after the floating element rendered.
+      c.every((u) => !F(x, u)))
+        return;
+      if (Ae(t) && !("touches" in e)) {
+        const u = Z(t), w = _e(t), fe = /auto|scroll/, ke = u || fe.test(w.overflowX), Oe = u || fe.test(w.overflowY), De = ke && t.clientWidth > 0 && t.scrollWidth > t.clientWidth, Ie = Oe && t.clientHeight > 0 && t.scrollHeight > t.clientHeight, Me = w.direction === "rtl", Ke = Ie && (Me ? e.offsetX <= t.offsetWidth - t.clientWidth : e.offsetX > t.clientWidth), xe = De && e.offsetY > t.clientHeight;
+        if (Ke || xe)
+          return;
+      }
+      if (oe(e))
+        return;
+      if (d() === "intentional" && T.current) {
+        h.clear(), T.current = !1;
+        return;
+      }
+      if (typeof P == "function" && !P(e))
+        return;
+      const Ce = p.current.floatingContext?.nodeId, le = g ? z(g.nodesRef.current, Ce) : [];
+      if (le.length > 0) {
+        let u = !0;
+        if (le.forEach((w) => {
+          w.context?.open && !w.context.dataRef.current.__outsidePressBubbles && (u = !1);
+        }), !u)
+          return;
+      }
+      n.setOpen(!1, N($e, e)), E();
+    }
+    function be(e) {
+      d() !== "sloppy" || e.pointerType === "touch" || !n.select("open") || !m || l(e, n.select("floatingElement")) || l(e, n.select("domReferenceElement")) || H(e);
+    }
+    function Le(e) {
+      if (d() !== "sloppy" || !n.select("open") || !m || l(e, n.select("floatingElement")) || l(e, n.select("domReferenceElement")))
+        return;
+      const t = e.touches[0];
+      t && (i.current = {
+        startTime: Date.now(),
+        startX: t.clientX,
+        startY: t.clientY,
+        dismissOnTouchEnd: !1,
+        dismissOnMouseDown: !0
+      }, O.start(1e3, () => {
+        i.current && (i.current.dismissOnTouchEnd = !1, i.current.dismissOnMouseDown = !1);
+      }));
+    }
+    function ie(e) {
+      U.current = "touch";
+      const t = S(e);
+      function o() {
+        Le(e), t?.removeEventListener(e.type, o);
+      }
+      t?.addEventListener(e.type, o);
+    }
+    function b(e) {
+      if (O.clear(), e.type === "pointerdown" && (U.current = e.pointerType), e.type === "mousedown" && i.current && !i.current.dismissOnMouseDown)
+        return;
+      const t = S(e);
+      function o() {
+        e.type === "pointerdown" ? be(e) : H(e), t?.removeEventListener(e.type, o);
+      }
+      t?.addEventListener(e.type, o);
+    }
+    function L(e) {
+      if (!k.current)
+        return;
+      const t = Y.current;
+      if (M(), d() === "intentional") {
+        if (e.type === "pointercancel") {
+          t && I();
+          return;
+        }
+        if (!oe(e)) {
+          if (t) {
+            I();
+            return;
+          }
+          typeof P == "function" && !P(e) || (h.clear(), T.current = !0, E());
+        }
+      }
+    }
+    function we(e) {
+      if (d() !== "sloppy" || !i.current || l(e, n.select("floatingElement")) || l(e, n.select("domReferenceElement")))
+        return;
+      const t = e.touches[0];
+      if (!t)
+        return;
+      const o = Math.abs(t.clientX - i.current.startX), c = Math.abs(t.clientY - i.current.startY), K = Math.sqrt(o * o + c * c);
+      K > 5 && (i.current.dismissOnTouchEnd = !0), K > 10 && (H(e), O.clear(), i.current = null);
+    }
+    function ce(e) {
+      const t = S(e);
+      function o() {
+        we(e), t?.removeEventListener(e.type, o);
+      }
+      t?.addEventListener(e.type, o);
+    }
+    function Se(e) {
+      d() !== "sloppy" || !i.current || l(e, n.select("floatingElement")) || l(e, n.select("domReferenceElement")) || (i.current.dismissOnTouchEnd && H(e), O.clear(), i.current = null);
+    }
+    function ue(e) {
+      const t = S(e);
+      function o() {
+        Se(e), t?.removeEventListener(e.type, o);
+      }
+      t?.addEventListener(e.type, o);
+    }
+    const r = me(ee);
+    return X && (r.addEventListener("keydown", v), r.addEventListener("compositionstart", D), r.addEventListener("compositionend", _)), $ && (r.addEventListener("click", b, !0), r.addEventListener("pointerdown", b, !0), r.addEventListener("pointerup", L, !0), r.addEventListener("pointercancel", L, !0), r.addEventListener("mousedown", b, !0), r.addEventListener("mouseup", L, !0), r.addEventListener("touchstart", ie, !0), r.addEventListener("touchmove", ce, !0), r.addEventListener("touchend", ue, !0)), () => {
+      X && (r.removeEventListener("keydown", v), r.removeEventListener("compositionstart", D), r.removeEventListener("compositionend", _)), $ && (r.removeEventListener("click", b, !0), r.removeEventListener("pointerdown", b, !0), r.removeEventListener("pointerup", L, !0), r.removeEventListener("pointercancel", L, !0), r.removeEventListener("mousedown", b, !0), r.removeEventListener("mouseup", L, !0), r.removeEventListener("touchstart", ie, !0), r.removeEventListener("touchmove", ce, !0), r.removeEventListener("touchend", ue, !0)), s.clear(), h.clear(), M(), T.current = !1;
+    };
+  }, [p, ee, X, $, P, C, m, A, ne, v, E, te, g, n, O]), a.useEffect(E, [P, E]);
+  const G = a.useMemo(() => ({
+    onKeyDown: v,
+    [Ve[q]]: (s) => {
+      j() && n.setOpen(!1, N(Ee, s.nativeEvent));
+    },
+    ...q !== "intentional" && {
+      onClick(s) {
+        j() && n.setOpen(!1, N(Ee, s.nativeEvent));
+      }
+    }
+  }), [v, n, q, j]), J = y((s) => {
+    if (!C || !m || s.button !== 0)
+      return;
+    const h = S(s.nativeEvent);
+    F(n.select("floatingElement"), h) && (k.current || (k.current = !0, Y.current = !1));
+  }), Q = y((s) => {
+    !C || !m || (s.defaultPrevented || s.nativeEvent.defaultPrevented) && k.current && (Y.current = !0);
+  }), se = a.useMemo(() => ({
+    onKeyDown: v,
+    // `onMouseDown` may be blocked if `event.preventDefault()` is called in
+    // `onPointerDown`, such as with <NumberField.ScrubArea>.
+    // See https://github.com/mui/base-ui/pull/3379
+    onPointerDown: Q,
+    onMouseDown: Q,
+    onClickCapture: R,
+    onMouseDownCapture(s) {
+      R(), J(s);
+    },
+    onPointerDownCapture(s) {
+      R(), J(s);
+    },
+    onMouseUpCapture: R,
+    onTouchEndCapture: R,
+    onTouchMoveCapture: R
+  }), [v, R, J, Q]);
+  return a.useMemo(() => m ? {
+    reference: G,
+    floating: se,
+    trigger: G
+  } : {}, [m, G, se]);
+}
+export {
+  je as normalizeProp,
+  it as useDismiss
+};

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

@@ -0,0 +1,78 @@
+import * as o from "react";
+import { useFloating as P } from "../../../../../@floating-ui/react-dom/dist/floating-ui.react-dom.js";
+import { isElement as s } from "../../../../../@floating-ui/utils/dist/floating-ui.utils.dom.js";
+import { useIsoLayoutEffect as F } from "../../../../utils/esm/useIsoLayoutEffect.js";
+import { useFloatingTree as V } from "../components/FloatingTree.js";
+import { useFloatingRootContext as v } from "./useFloatingRootContext.js";
+function w(c = {}) {
+  const {
+    nodeId: m,
+    externalTree: y
+  } = c, I = v(c), t = c.rootContext || I, r = {
+    reference: t.useState("referenceElement"),
+    floating: t.useState("floatingElement"),
+    domReference: t.useState("domReferenceElement")
+  }, [g, M] = o.useState(null), i = o.useRef(null), b = V(y);
+  F(() => {
+    r.domReference && (i.current = r.domReference);
+  }, [r.domReference]);
+  const n = P({
+    ...c,
+    elements: {
+      ...r,
+      ...g && {
+        reference: g
+      }
+    }
+  }), d = o.useCallback((e) => {
+    const u = s(e) ? {
+      getBoundingClientRect: () => e.getBoundingClientRect(),
+      getClientRects: () => e.getClientRects(),
+      contextElement: e
+    } : e;
+    M(u), n.refs.setReference(u);
+  }, [n.refs]), [R, S] = o.useState(null), [k, L] = o.useState(null);
+  t.useSyncedValue("referenceElement", R), t.useSyncedValue("domReferenceElement", s(R) ? R : null), t.useSyncedValue("floatingElement", k);
+  const x = o.useCallback((e) => {
+    (s(e) || e === null) && (i.current = e, S(e)), (s(n.refs.reference.current) || n.refs.reference.current === null || // Don't allow setting virtual elements using the old technique back to
+    // `null` to support `positionReference` + an unstable `reference`
+    // callback ref.
+    e !== null && !s(e)) && n.refs.setReference(e);
+  }, [n.refs, S]), C = o.useCallback((e) => {
+    L(e), n.refs.setFloating(e);
+  }, [n.refs]), l = o.useMemo(() => ({
+    ...n.refs,
+    setReference: x,
+    setFloating: C,
+    setPositionReference: d,
+    domReference: i
+  }), [n.refs, x, C, d]), f = o.useMemo(() => ({
+    ...n.elements,
+    domReference: r.domReference
+  }), [n.elements, r.domReference]), E = t.useState("open"), p = t.useState("floatingId"), a = o.useMemo(() => ({
+    ...n,
+    dataRef: t.context.dataRef,
+    open: E,
+    onOpenChange: t.setOpen,
+    events: t.context.events,
+    floatingId: p,
+    refs: l,
+    elements: f,
+    nodeId: m,
+    rootStore: t
+  }), [n, l, f, m, t, E, p]);
+  return F(() => {
+    t.context.dataRef.current.floatingContext = a;
+    const e = b?.nodesRef.current.find((u) => u.id === m);
+    e && (e.context = a);
+  }), o.useMemo(() => ({
+    ...n,
+    context: a,
+    refs: l,
+    elements: f,
+    rootStore: t
+  }), [n, l, f, a, t]);
+}
+export {
+  w as useFloating
+};

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

@@ -0,0 +1,38 @@
+import { isElement as l } from "../../../../../@floating-ui/utils/dist/floating-ui.utils.dom.js";
+import { useId as c } from "../../../../utils/esm/useId.js";
+import { useRefWithInit as m } from "../../../../utils/esm/useRefWithInit.js";
+import { useIsoLayoutEffect as a } from "../../../../utils/esm/useIsoLayoutEffect.js";
+import { useFloatingParentNodeId as u } from "../components/FloatingTree.js";
+import { FloatingRootStore as p } from "../components/FloatingRootStore.js";
+import { PopupTriggerMap as g } from "../../utils/popups/popupTriggerMap.js";
+function O(s) {
+  const {
+    open: o = !1,
+    onOpenChange: f,
+    elements: e = {}
+  } = s, r = c(), i = u() != null;
+  if (process.env.NODE_ENV !== "production") {
+    const n = e.reference;
+    n && !l(n) && console.error("Cannot pass a virtual element to the `elements.reference` option,", "as it must be a real DOM element. Use `context.setPositionReference()`", "instead.");
+  }
+  const t = m(() => new p({
+    open: o,
+    onOpenChange: f,
+    referenceElement: e.reference ?? null,
+    floatingElement: e.floating ?? null,
+    triggerElements: new g(),
+    floatingId: r,
+    nested: i,
+    noEmit: !1
+  })).current;
+  return a(() => {
+    const n = {
+      open: o,
+      floatingId: r
+    };
+    e.reference !== void 0 && (n.referenceElement = e.reference, n.domReferenceElement = l(e.reference) ? e.reference : null), e.floating !== void 0 && (n.floatingElement = e.floating), t.update(n);
+  }, [o, r, e.reference, e.floating, t]), t.context.onOpenChange = f, t.context.nested = i, t.context.noEmit = !1, t;
+}
+export {
+  O as useFloatingRootContext
+};

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

@@ -0,0 +1,87 @@
+import * as y from "react";
+import { isElement as F } from "../../../../../@floating-ui/utils/dist/floating-ui.utils.dom.js";
+import { useStableCallback as d } from "../../../../utils/esm/useStableCallback.js";
+import { useIsoLayoutEffect as P } from "../../../../utils/esm/useIsoLayoutEffect.js";
+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 { triggerHover as R } from "../../utils/reason-parts.js";
+import { getNodeChildren as k } from "../utils/nodes.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(() => {
+    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 = () => {
+      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);
+  }), v = d((t) => {
+    const s = B(t);
+    if (!$(s)) {
+      e.interactedInside = !1;
+      return;
+    }
+    e.interactedInside = s?.closest("[aria-haspopup]") != null;
+  });
+  P(() => {
+    u || (e.pointerType = void 0, e.restTimeoutPending = !1, e.interactedInside = !1, i());
+  }, [u, e, i]), y.useEffect(() => i, [i]), P(() => {
+    if (m && u && e.handleCloseOptions?.blockPointerEvents && C() && F(g) && f) {
+      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, {
+        scopeElement: l,
+        referenceElement: t,
+        floatingElement: s
+      }), () => {
+        i();
+      };
+    }
+  }, [m, u, g, f, e, C, n, c, i]);
+  const h = w();
+  y.useEffect(() => {
+    if (!m)
+      return;
+    function t() {
+      e.openChangeTimeout.clear(), h.clear(), n?.events.off("floating.closed", a), i();
+    }
+    function s(l) {
+      if (n && c && k(n.nodesRef.current, c).length > 0) {
+        n.events.on("floating.closed", a);
+        return;
+      }
+      if (!S(l.relatedTarget)) {
+        if (e.handler) {
+          e.handler(l);
+          return;
+        }
+        i(), I() || L(l);
+      }
+    }
+    function a(l) {
+      !n || !c || k(n.nodesRef.current, c).length > 0 || h.start(0, () => {
+        n.events.off("floating.closed", a), r.setOpen(!1, b(R, l)), n.events.emit("floating.closed", l);
+      });
+    }
+    const o = f;
+    return o && (o.addEventListener("mouseenter", t), o.addEventListener("mouseleave", s), o.addEventListener("pointerdown", v, !0)), () => {
+      o && (o.removeEventListener("mouseenter", t), o.removeEventListener("mouseleave", s), o.removeEventListener("pointerdown", v, !0)), n?.events.off("floating.closed", a);
+    };
+  }, [m, f, r, E, I, S, L, i, v, e, n, c, h]);
+}
+export {
+  ne as useHoverFloatingInteraction
+};

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

@@ -0,0 +1,42 @@
+import { useOnMount as l } from "../../../../utils/esm/useOnMount.js";
+import { useRefWithInit as p } from "../../../../utils/esm/useRefWithInit.js";
+import { Timeout as s } from "../../../../utils/esm/useTimeout.js";
+import { TYPEABLE_SELECTOR as a } from "../utils/constants.js";
+const u = `button,a,[role="button"],select,[tabindex]:not([tabindex="-1"]),${a}`;
+function h(e) {
+  return e ? !!e.closest(u) : !1;
+}
+class o {
+  constructor() {
+    this.pointerType = void 0, this.interactedInside = !1, this.handler = void 0, this.blockMouseMove = !0, this.performedPointerEventsMutation = !1, this.pointerEventsScopeElement = null, this.pointerEventsReferenceElement = null, this.pointerEventsFloatingElement = null, this.restTimeoutPending = !1, this.openChangeTimeout = new s(), this.restTimeout = new s(), this.handleCloseOptions = void 0;
+  }
+  static create() {
+    return new o();
+  }
+  dispose = () => {
+    this.openChangeTimeout.clear(), this.restTimeout.clear();
+  };
+  disposeEffect = () => this.dispose;
+}
+function E(e) {
+  e.performedPointerEventsMutation && (e.pointerEventsScopeElement?.style.removeProperty("pointer-events"), e.pointerEventsReferenceElement?.style.removeProperty("pointer-events"), e.pointerEventsFloatingElement?.style.removeProperty("pointer-events"), e.performedPointerEventsMutation = !1, e.pointerEventsScopeElement = null, e.pointerEventsReferenceElement = null, e.pointerEventsFloatingElement = null);
+}
+function d(e, n) {
+  const {
+    scopeElement: t,
+    referenceElement: r,
+    floatingElement: i
+  } = n;
+  E(e), e.performedPointerEventsMutation = !0, e.pointerEventsScopeElement = t, e.pointerEventsReferenceElement = r, e.pointerEventsFloatingElement = i, t.style.pointerEvents = "none", r.style.pointerEvents = "auto", i.style.pointerEvents = "auto";
+}
+function S(e) {
+  const n = p(o.create).current, t = e.context.dataRef.current;
+  return t.hoverInteractionState || (t.hoverInteractionState = n), l(t.hoverInteractionState.disposeEffect), t.hoverInteractionState;
+}
+export {
+  o as HoverInteraction,
+  d as applySafePolygonPointerEventsMutation,
+  E as clearSafePolygonPointerEventsMutation,
+  h as isInteractiveElement,
+  S as useHoverInteractionSharedState
+};

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

@@ -0,0 +1,145 @@
+import * as v from "react";
+import * as J from "react-dom";
+import { isElement as X } from "../../../../../@floating-ui/utils/dist/floating-ui.utils.dom.js";
+import { useValueAsRef as L } from "../../../../utils/esm/useValueAsRef.js";
+import { useStableCallback as M } from "../../../../utils/esm/useStableCallback.js";
+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 { 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
+};
+function de(b, $ = {}) {
+  const n = "rootStore" in b ? b.rootStore : b, {
+    dataRef: k,
+    events: I
+  } = n.context, {
+    enabled: c = !0,
+    delay: j = 0,
+    handleClose: q = null,
+    mouseOnly: C = !1,
+    restMs: z = 0,
+    move: x = !0,
+    triggerElementRef: D = te,
+    externalTree: G,
+    isActiveTrigger: S = !0,
+    getHandleCloseContext: _
+  } = $, p = K(G), e = Q(n), R = L(q), T = L(j), y = L(z), w = L(c);
+  S && (e.handleCloseOptions = R.current?.__options);
+  const E = M(() => Z(k.current.openEvent?.type, e.interactedInside)), A = M((t) => ee(t, n.context.triggerElements)), O = M((t, r, i) => {
+    const o = n.context.triggerElements;
+    if (o.hasElement(r))
+      return !t || !P(t, r);
+    if (!X(i))
+      return !1;
+    const a = i;
+    return o.hasMatchingElement((l) => P(l, a)) && (!t || !P(t, a));
+  }), H = v.useCallback((t, r = !0) => {
+    const i = Y(T.current, "close", e.pointerType);
+    i ? e.openChangeTimeout.start(i, () => {
+      n.setOpen(!1, d(g, t)), p?.events.emit("floating.closed", t);
+    }) : r && (e.openChangeTimeout.clear(), n.setOpen(!1, d(g, t)), p?.events.emit("floating.closed", t));
+  }, [T, n, e, p]), u = M(() => {
+    if (!e.handler)
+      return;
+    B(n.select("domReferenceElement")).removeEventListener("mousemove", e.handler), e.handler = void 0;
+  });
+  v.useEffect(() => u, [u]);
+  const V = M(() => {
+    U(e);
+  });
+  return v.useEffect(() => {
+    if (!c)
+      return;
+    function t(r) {
+      r.open || (u(), e.openChangeTimeout.clear(), e.restTimeout.clear(), e.blockMouseMove = !0, e.restTimeoutPending = !1);
+    }
+    return I.on("openchange", t), () => {
+      I.off("openchange", t);
+    };
+  }, [c, I, e, u]), v.useEffect(() => {
+    if (!c)
+      return;
+    const t = D.current ?? (S ? n.select("domReferenceElement") : null);
+    if (!X(t))
+      return;
+    function r(o) {
+      if (e.openChangeTimeout.clear(), e.blockMouseMove = !1, C && !W(e.pointerType) || N(y.current) > 0 && !Y(T.current, "open"))
+        return;
+      const l = Y(T.current, "open", e.pointerType), s = o.currentTarget ?? null, h = n.select("domReferenceElement"), f = s == null ? !1 : O(h, s, o.target), m = n.select("open"), F = !m || f;
+      f && m ? n.setOpen(!0, d(g, o, s)) : l ? e.openChangeTimeout.start(l, () => {
+        F && n.setOpen(!0, d(g, o, s));
+      }) : F && n.setOpen(!0, d(g, o, s));
+    }
+    function i(o) {
+      if (E()) {
+        V();
+        return;
+      }
+      u();
+      const a = n.select("domReferenceElement"), l = B(a);
+      e.restTimeout.clear(), e.restTimeoutPending = !1;
+      const s = k.current.floatingContext ?? _?.();
+      if (A(o.relatedTarget))
+        return;
+      if (R.current && s) {
+        n.select("open") || e.openChangeTimeout.clear();
+        const m = D.current;
+        e.handler = R.current({
+          ...s,
+          tree: p,
+          x: o.clientX,
+          y: o.clientY,
+          onClose() {
+            V(), u(), w.current && !E() && m === n.select("domReferenceElement") && H(o, !0);
+          }
+        }), l.addEventListener("mousemove", e.handler), e.handler(o);
+        return;
+      }
+      (e.pointerType !== "touch" || !P(n.select("floatingElement"), o.relatedTarget)) && H(o);
+    }
+    return x && t.addEventListener("mousemove", r, {
+      once: !0
+    }), t.addEventListener("mouseenter", r), t.addEventListener("mouseleave", i), () => {
+      x && t.removeEventListener("mousemove", r), t.removeEventListener("mouseenter", r), t.removeEventListener("mouseleave", i);
+    };
+  }, [u, V, k, T, H, n, c, R, e, S, O, E, A, C, x, y, D, p, w, _]), v.useMemo(() => {
+    if (!c)
+      return;
+    function t(r) {
+      e.pointerType = r.pointerType;
+    }
+    return {
+      onPointerDown: t,
+      onPointerEnter: t,
+      onMouseMove(r) {
+        const {
+          nativeEvent: i
+        } = r, o = r.currentTarget, a = n.select("domReferenceElement"), l = n.select("open"), s = O(a, o, r.target);
+        if (C && !W(e.pointerType))
+          return;
+        const h = N(y.current);
+        if (l && !s || h === 0 || !s && e.restTimeoutPending && r.movementX ** 2 + r.movementY ** 2 < 2)
+          return;
+        e.restTimeout.clear();
+        function f() {
+          if (e.restTimeoutPending = !1, E())
+            return;
+          const m = n.select("open");
+          !e.blockMouseMove && (!m || s) && n.setOpen(!0, d(g, i, o));
+        }
+        e.pointerType === "touch" ? J.flushSync(() => {
+          f();
+        }) : s && l ? f() : (e.restTimeoutPending = !0, e.restTimeout.start(h, f));
+      }
+    };
+  }, [c, e, E, O, C, n, y]);
+}
+export {
+  de as useHoverReferenceInteraction
+};