@ledgerhq/lumen-ui-react 0.1.13 → 0.1.15

package/dist/node_modules/@base-ui/react/esm/utils/popups/popupStoreUtils.js

@@ -0,0 +1,95 @@
+import * as l from "react";
+import { useStableCallback as a } from "../../../../utils/esm/useStableCallback.js";
+import { useIsoLayoutEffect as s } from "../../../../utils/esm/useIsoLayoutEffect.js";
+import { useTransitionStatus as f } from "../useTransitionStatus.js";
+import { useOpenChangeComplete as m } from "../useOpenChangeComplete.js";
+function d(e, n) {
+  const t = l.useRef(null), r = l.useRef(null);
+  return l.useCallback((i) => {
+    if (e !== void 0) {
+      if (t.current !== null) {
+        const c = t.current, g = r.current, u = n.context.triggerElements.getById(c);
+        g && u === g && n.context.triggerElements.delete(c), t.current = null, r.current = null;
+      }
+      i !== null && (t.current = e, r.current = i, n.context.triggerElements.add(e, i));
+    }
+  }, [n, e]);
+}
+function x(e, n, t, r) {
+  const i = t.useState("isMountedByTrigger", e), c = d(e, t), g = a((u) => {
+    if (c(u), !u || !t.select("open"))
+      return;
+    const o = t.select("activeTriggerId");
+    if (o === e) {
+      t.update({
+        activeTriggerElement: u,
+        ...r
+      });
+      return;
+    }
+    o == null && t.update({
+      activeTriggerId: e,
+      activeTriggerElement: u,
+      ...r
+    });
+  });
+  return s(() => {
+    i && t.update({
+      activeTriggerElement: n.current,
+      ...r
+    });
+  }, [i, t, n, ...Object.values(r)]), {
+    registerTrigger: g,
+    isMountedByThisTrigger: i
+  };
+}
+function C(e) {
+  const n = e.useState("open");
+  s(() => {
+    if (n && !e.select("activeTriggerId") && e.context.triggerElements.size === 1) {
+      const t = e.context.triggerElements.entries().next();
+      if (!t.done) {
+        const [r, i] = t.value;
+        e.update({
+          activeTriggerId: r,
+          activeTriggerElement: i
+        });
+      }
+    }
+  }, [n, e]);
+}
+function I(e, n, t) {
+  const {
+    mounted: r,
+    setMounted: i,
+    transitionStatus: c
+  } = f(e);
+  n.useSyncedValues({
+    mounted: r,
+    transitionStatus: c
+  });
+  const g = a(() => {
+    i(!1), n.update({
+      activeTriggerId: null,
+      activeTriggerElement: null,
+      mounted: !1
+    }), t?.(), n.context.onOpenChangeComplete?.(!1);
+  }), u = n.useState("preventUnmountingOnClose");
+  return m({
+    enabled: !u,
+    open: e,
+    ref: n.context.popupRef,
+    onComplete() {
+      e || g();
+    }
+  }), {
+    forceUnmount: g,
+    transitionStatus: c
+  };
+}
+export {
+  C as useImplicitActiveTrigger,
+  I as useOpenStateTransitions,
+  x as useTriggerDataForwarding,
+  d as useTriggerRegistration
+};

package/dist/node_modules/@base-ui/react/esm/utils/popups/popupTriggerMap.js

@@ -0,0 +1,64 @@
+class n {
+  constructor() {
+    this.elementsSet = /* @__PURE__ */ new Set(), this.idMap = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Adds a trigger element with the given ID.
+   *
+   * Note: The provided element is assumed to not be registered under multiple IDs.
+   */
+  add(e, t) {
+    const s = this.idMap.get(e);
+    if (s !== t && (s !== void 0 && this.elementsSet.delete(s), this.elementsSet.add(t), this.idMap.set(e, t), process.env.NODE_ENV !== "production" && this.elementsSet.size !== this.idMap.size))
+      throw new Error("Base UI: A trigger element cannot be registered under multiple IDs in PopupTriggerMap.");
+  }
+  /**
+   * Removes the trigger element with the given ID.
+   */
+  delete(e) {
+    const t = this.idMap.get(e);
+    t && (this.elementsSet.delete(t), this.idMap.delete(e));
+  }
+  /**
+   * Whether the given element is registered as a trigger.
+   */
+  hasElement(e) {
+    return this.elementsSet.has(e);
+  }
+  /**
+   * Whether there is a registered trigger element matching the given predicate.
+   */
+  hasMatchingElement(e) {
+    for (const t of this.elementsSet)
+      if (e(t))
+        return !0;
+    return !1;
+  }
+  /**
+   * Returns the trigger element associated with the given ID, or undefined if no such element exists.
+   */
+  getById(e) {
+    return this.idMap.get(e);
+  }
+  /**
+   * Returns an iterable of all registered trigger entries, where each entry is a tuple of [id, element].
+   */
+  entries() {
+    return this.idMap.entries();
+  }
+  /**
+   * Returns an iterable of all registered trigger elements.
+   */
+  elements() {
+    return this.elementsSet.values();
+  }
+  /**
+   * Returns the number of registered trigger elements.
+   */
+  get size() {
+    return this.idMap.size;
+  }
+}
+export {
+  n as PopupTriggerMap
+};

package/dist/node_modules/@base-ui/react/esm/utils/popups/store.js

@@ -0,0 +1,52 @@
+import { getEmptyRootContext as i } from "../../floating-ui-react/utils/getEmptyRootContext.js";
+import { EMPTY_OBJECT as r } from "../../../../utils/esm/empty.js";
+import { createSelector as o } from "../../../../utils/esm/store/createSelector.js";
+function u() {
+  return {
+    open: !1,
+    openProp: void 0,
+    mounted: !1,
+    transitionStatus: "idle",
+    floatingRootContext: i(),
+    preventUnmountingOnClose: !1,
+    payload: void 0,
+    activeTriggerId: null,
+    activeTriggerElement: null,
+    triggerIdProp: void 0,
+    popupElement: null,
+    positionerElement: null,
+    activeTriggerProps: r,
+    inactiveTriggerProps: r,
+    popupProps: r
+  };
+}
+const t = o((e) => e.triggerIdProp ?? e.activeTriggerId), a = {
+  open: o((e) => e.openProp ?? e.open),
+  mounted: o((e) => e.mounted),
+  transitionStatus: o((e) => e.transitionStatus),
+  floatingRootContext: o((e) => e.floatingRootContext),
+  preventUnmountingOnClose: o((e) => e.preventUnmountingOnClose),
+  payload: o((e) => e.payload),
+  activeTriggerId: t,
+  activeTriggerElement: o((e) => e.mounted ? e.activeTriggerElement : null),
+  /**
+   * Whether the trigger with the given ID was used to open the popup.
+   */
+  isTriggerActive: o((e, n) => n !== void 0 && t(e) === n),
+  /**
+   * Whether the popup is open and was activated by a trigger with the given ID.
+   */
+  isOpenedByTrigger: o((e, n) => n !== void 0 && t(e) === n && e.open),
+  /**
+   * Whether the popup is mounted and was activated by a trigger with the given ID.
+   */
+  isMountedByTrigger: o((e, n) => n !== void 0 && t(e) === n && e.mounted),
+  triggerProps: o((e, n) => n ? e.activeTriggerProps : e.inactiveTriggerProps),
+  popupProps: o((e) => e.popupProps),
+  popupElement: o((e) => e.popupElement),
+  positionerElement: o((e) => e.positionerElement)
+};
+export {
+  u as createInitialPopupStoreState,
+  a as popupStoreSelectors
+};

package/dist/node_modules/@base-ui/react/esm/utils/reason-parts.js

@@ -0,0 +1,9 @@
+const e = "trigger-press", s = "trigger-hover", t = "outside-press", r = "focus-out", o = "escape-key", c = "imperative-action";
+export {
+  o as escapeKey,
+  r as focusOut,
+  c as imperativeAction,
+  t as outsidePress,
+  s as triggerHover,
+  e as triggerPress
+};

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

@@ -0,0 +1,6 @@
+function t(n, o) {
+  return typeof n == "function" ? n(o) : n;
+}
+export {
+  t as resolveClassName
+};

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

@@ -0,0 +1,6 @@
+function n(r) {
+  return r == null ? r : "current" in r ? r.current : r;
+}
+export {
+  n as resolveRef
+};

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

@@ -0,0 +1,6 @@
+function e(n, o) {
+  return typeof n == "function" ? n(o) : n;
+}
+export {
+  e as resolveStyle
+};

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

@@ -0,0 +1,16 @@
+let n = /* @__PURE__ */ (function(t) {
+  return t.startingStyle = "data-starting-style", t.endingStyle = "data-ending-style", t;
+})({});
+const e = {
+  [n.startingStyle]: ""
+}, i = {
+  [n.endingStyle]: ""
+}, r = {
+  transitionStatus(t) {
+    return t === "starting" ? e : t === "ending" ? i : null;
+  }
+};
+export {
+  n as TransitionStatusDataAttributes,
+  r as transitionStatusMapping
+};

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

@@ -0,0 +1,267 @@
+import * as d from "react";
+import { getSide as T, getAlignment as Fe, getSideAxis as Me } from "../../../../@floating-ui/utils/dist/floating-ui.utils.js";
+import { ownerDocument as qe } from "../../../utils/esm/owner.js";
+import { useIsoLayoutEffect as N } from "../../../utils/esm/useIsoLayoutEffect.js";
+import { useValueAsRef as Q } from "../../../utils/esm/useValueAsRef.js";
+import { useStableCallback as Ge } from "../../../utils/esm/useStableCallback.js";
+import { useDirection as Je } from "../direction-provider/DirectionContext.js";
+import { arrow as Ke } from "../floating-ui-react/middleware/arrow.js";
+import { hide as Ne } from "./hideMiddleware.js";
+import { DEFAULT_SIDES as Qe } from "./adaptiveOriginMiddleware.js";
+import { useFloating as Ze } from "../floating-ui-react/hooks/useFloating.js";
+import { autoUpdate as De } from "../../../../@floating-ui/dom/dist/floating-ui.dom.js";
+import { offset as et, shift as tt, flip as nt, size as ot, limitShift as it } from "../../../../@floating-ui/react-dom/dist/floating-ui.react-dom.js";
+function He(a, u, h) {
+  const n = a === "inline-start" || a === "inline-end";
+  return {
+    top: "top",
+    right: n ? h ? "inline-start" : "inline-end" : "right",
+    bottom: "bottom",
+    left: n ? h ? "inline-end" : "inline-start" : "left"
+  }[u];
+}
+function ke(a, u, h) {
+  const {
+    rects: n,
+    placement: c
+  } = a;
+  return {
+    side: He(u, T(c), h),
+    align: Fe(c) || "center",
+    anchor: {
+      width: n.reference.width,
+      height: n.reference.height
+    },
+    positioner: {
+      width: n.floating.width,
+      height: n.floating.height
+    }
+  };
+}
+function wt(a) {
+  const {
+    // Public parameters
+    anchor: u,
+    positionMethod: h = "absolute",
+    side: n = "bottom",
+    sideOffset: c = 0,
+    align: S = "center",
+    alignOffset: z = 0,
+    collisionBoundary: Z,
+    collisionPadding: Le = 5,
+    sticky: B = !1,
+    arrowPadding: ee = 5,
+    disableAnchorTracking: V = !1,
+    // Private parameters
+    keepMounted: I = !1,
+    floatingRootContext: M,
+    mounted: r,
+    collisionAvoidance: U,
+    shiftCrossAxis: R = !1,
+    nodeId: Te,
+    adaptiveOrigin: W,
+    lazyFlip: te = !1,
+    externalTree: ze
+  } = a, [ne, oe] = d.useState(null);
+  !r && ne !== null && oe(null);
+  const P = U.side || "flip", O = U.align || "flip", Be = U.fallbackAxisSide || "end", ie = typeof u == "function" ? u : void 0, Ve = Ge(ie), re = ie ? Ve : u, D = Q(u), y = Je() === "rtl", se = ne || {
+    top: "top",
+    right: "right",
+    bottom: "bottom",
+    left: "left",
+    "inline-end": y ? "left" : "right",
+    "inline-start": y ? "right" : "left"
+  }[n], Ie = S === "center" ? se : `${se}-${S}`;
+  let t = Le;
+  const p = 1, ce = n === "bottom" ? p : 0, le = n === "top" ? p : 0, ae = n === "right" ? p : 0, fe = n === "left" ? p : 0;
+  typeof t == "number" ? t = {
+    top: t + ce,
+    right: t + fe,
+    bottom: t + le,
+    left: t + ae
+  } : t && (t = {
+    top: (t.top || 0) + ce,
+    right: (t.right || 0) + fe,
+    bottom: (t.bottom || 0) + le,
+    left: (t.left || 0) + ae
+  });
+  const k = {
+    boundary: Z === "clipping-ancestors" ? "clippingAncestors" : Z,
+    padding: t
+  }, x = d.useRef(null), Y = Q(c), X = Q(z), C = [et((e) => {
+    const o = ke(e, n, y), l = typeof Y.current == "function" ? Y.current(o) : Y.current, i = typeof X.current == "function" ? X.current(o) : X.current;
+    return {
+      mainAxis: l,
+      crossAxis: i,
+      alignmentAxis: i
+    };
+  }, [typeof c != "function" ? c : 0, typeof z != "function" ? z : 0, y, n])], de = O === "none" && P !== "shift", ue = !de && (B || R || P === "shift"), pe = P === "none" ? null : nt({
+    ...k,
+    // Ensure the popup flips if it's been limited by its --available-height and it resizes.
+    // Since the size() padding is smaller than the flip() padding, flip() will take precedence.
+    padding: {
+      top: t.top + p,
+      right: t.right + p,
+      bottom: t.bottom + p,
+      left: t.left + p
+    },
+    mainAxis: !R && P === "flip",
+    crossAxis: O === "flip" ? "alignment" : !1,
+    fallbackAxisSideDirection: Be
+  }), he = de ? null : tt((e) => {
+    const o = qe(e.elements.floating).documentElement;
+    return {
+      ...k,
+      // Use the Layout Viewport to avoid shifting around when pinch-zooming
+      // for context menus.
+      rootBoundary: R ? {
+        x: 0,
+        y: 0,
+        width: o.clientWidth,
+        height: o.clientHeight
+      } : void 0,
+      mainAxis: O !== "none",
+      crossAxis: ue,
+      limiter: B || R ? void 0 : it((l) => {
+        if (!x.current)
+          return {};
+        const {
+          width: i,
+          height: f
+        } = x.current.getBoundingClientRect(), s = Me(T(l.placement)), g = s === "y" ? i : f, A = s === "y" ? t.left + t.right : t.top + t.bottom;
+        return {
+          offset: g / 2 + A / 2
+        };
+      })
+    };
+  }, [k, B, R, t, O]);
+  P === "shift" || O === "shift" || S === "center" ? C.push(he, pe) : C.push(pe, he), C.push(ot({
+    ...k,
+    apply({
+      elements: {
+        floating: e
+      },
+      availableWidth: o,
+      availableHeight: l,
+      rects: i
+    }) {
+      const f = e.style;
+      f.setProperty("--available-width", `${o}px`), f.setProperty("--available-height", `${l}px`);
+      const s = window.devicePixelRatio || 1, {
+        x: g,
+        y: A,
+        width: L,
+        height: q
+      } = i.reference, G = (Math.round((g + L) * s) - Math.round(g * s)) / s, J = (Math.round((A + q) * s) - Math.round(A * s)) / s;
+      f.setProperty("--anchor-width", `${G}px`), f.setProperty("--anchor-height", `${J}px`);
+    }
+  }), Ke(() => ({
+    // `transform-origin` calculations rely on an element existing. If the arrow hasn't been set,
+    // we'll create a fake element.
+    element: x.current || document.createElement("div"),
+    padding: ee,
+    offsetParent: "floating"
+  }), [ee]), {
+    name: "transformOrigin",
+    fn(e) {
+      const {
+        elements: o,
+        middlewareData: l,
+        placement: i,
+        rects: f,
+        y: s
+      } = e, g = T(i), A = Me(g), L = x.current, q = l.arrow?.x || 0, G = l.arrow?.y || 0, J = L?.clientWidth || 0, Ue = L?.clientHeight || 0, K = q + J / 2, Ee = G + Ue / 2, We = Math.abs(l.shift?.y || 0), Ye = f.reference.height / 2, E = typeof c == "function" ? c(ke(e, n, y)) : c, Xe = We > E, je = {
+        top: `${K}px calc(100% + ${E}px)`,
+        bottom: `${K}px ${-E}px`,
+        left: `calc(100% + ${E}px) ${Ee}px`,
+        right: `${-E}px ${Ee}px`
+      }[g], _e = `${K}px ${f.reference.y + Ye - s}px`;
+      return o.floating.style.setProperty("--transform-origin", ue && A === "y" && Xe ? _e : je), {};
+    }
+  }, Ne, W), N(() => {
+    !r && M && M.update({
+      referenceElement: null,
+      floatingElement: null,
+      domReferenceElement: null
+    });
+  }, [r, M]);
+  const j = d.useMemo(() => ({
+    elementResize: !V && typeof ResizeObserver < "u",
+    layoutShift: !V && typeof IntersectionObserver < "u"
+  }), [V]), {
+    refs: b,
+    elements: v,
+    x: me,
+    y: ge,
+    middlewareData: w,
+    update: F,
+    placement: ye,
+    context: xe,
+    isPositioned: m,
+    floatingStyles: be
+  } = Ze({
+    rootContext: M,
+    placement: Ie,
+    middleware: C,
+    strategy: h,
+    whileElementsMounted: I ? void 0 : (...e) => De(...e, j),
+    nodeId: Te,
+    externalTree: ze
+  }), {
+    sideX: we,
+    sideY: Ae
+  } = w.adaptiveOrigin || Qe, _ = m ? h : "fixed", Se = d.useMemo(() => {
+    const e = W ? {
+      position: _,
+      [we]: me,
+      [Ae]: ge
+    } : {
+      position: _,
+      ...be
+    };
+    return m || (e.opacity = 0), e;
+  }, [W, _, we, me, Ae, ge, be, m]), H = d.useRef(null);
+  N(() => {
+    if (!r)
+      return;
+    const e = D.current, o = typeof e == "function" ? e() : e, i = (Ce(o) ? o.current : o) || null || null;
+    i !== H.current && (b.setPositionReference(i), H.current = i);
+  }, [r, b, re, D]), d.useEffect(() => {
+    if (!r)
+      return;
+    const e = D.current;
+    typeof e != "function" && Ce(e) && e.current !== H.current && (b.setPositionReference(e.current), H.current = e.current);
+  }, [r, b, re, D]), d.useEffect(() => {
+    if (I && r && v.domReference && v.floating)
+      return De(v.domReference, v.floating, F, j);
+  }, [I, r, v, F, j]);
+  const $ = T(ye), Re = He(n, $, y), Pe = Fe(ye) || "center", Oe = !!w.hide?.referenceHidden;
+  N(() => {
+    te && r && m && oe($);
+  }, [te, r, m, $]);
+  const ve = d.useMemo(() => ({
+    position: "absolute",
+    top: w.arrow?.y,
+    left: w.arrow?.x
+  }), [w.arrow]), $e = w.arrow?.centerOffset !== 0;
+  return d.useMemo(() => ({
+    positionerStyles: Se,
+    arrowStyles: ve,
+    arrowRef: x,
+    arrowUncentered: $e,
+    side: Re,
+    align: Pe,
+    physicalSide: $,
+    anchorHidden: Oe,
+    refs: b,
+    context: xe,
+    isPositioned: m,
+    update: F
+  }), [Se, ve, x, $e, Re, Pe, $, Oe, b, xe, m, F]);
+}
+function Ce(a) {
+  return a != null && "current" in a;
+}
+export {
+  wt as useAnchorPositioning
+};

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

@@ -0,0 +1,57 @@
+import * as b from "react-dom";
+import { useAnimationFrame as A } from "../../../utils/esm/useAnimationFrame.js";
+import { useStableCallback as d } from "../../../utils/esm/useStableCallback.js";
+import { resolveRef as S } from "./resolveRef.js";
+import { TransitionStatusDataAttributes as h } from "./stateAttributesMapping.js";
+function D(c, f = !1, l = !0) {
+  const i = A();
+  return d((s, o = null) => {
+    i.cancel();
+    function a() {
+      b.flushSync(s);
+    }
+    const u = S(c);
+    if (u == null)
+      return;
+    const e = u;
+    if (typeof e.getAnimations != "function" || globalThis.BASE_UI_ANIMATIONS_DISABLED)
+      s();
+    else {
+      let m = function() {
+        const t = h.startingStyle;
+        if (!e.hasAttribute(t)) {
+          i.request(r);
+          return;
+        }
+        const n = new MutationObserver(() => {
+          e.hasAttribute(t) || (n.disconnect(), r());
+        });
+        n.observe(e, {
+          attributes: !0,
+          attributeFilter: [t]
+        }), o?.addEventListener("abort", () => n.disconnect(), {
+          once: !0
+        });
+      }, r = function() {
+        Promise.all(e.getAnimations().map((t) => t.finished)).then(() => {
+          o?.aborted || a();
+        }).catch(() => {
+          const t = e.getAnimations();
+          if (l) {
+            if (o?.aborted)
+              return;
+            a();
+          } else t.length > 0 && t.some((n) => n.pending || n.playState !== "finished") && r();
+        });
+      };
+      if (f) {
+        m();
+        return;
+      }
+      i.request(r);
+    }
+  });
+}
+export {
+  D as useAnimationsFinished
+};

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

@@ -0,0 +1,7 @@
+import { useId as r } from "../../../utils/esm/useId.js";
+function i(e) {
+  return r(e, "base-ui");
+}
+export {
+  i as useBaseUiId
+};

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

@@ -0,0 +1,24 @@
+import * as r from "react";
+function f(l) {
+  const {
+    focusableWhenDisabled: e,
+    disabled: o,
+    composite: t = !1,
+    tabIndex: i = 0,
+    isNativeButton: s
+  } = l, n = t && e !== !1, b = t && e === !1;
+  return {
+    props: r.useMemo(() => {
+      const a = {
+        // allow Tabbing away from focusableWhenDisabled elements
+        onKeyDown(d) {
+          o && e && d.key !== "Tab" && d.preventDefault();
+        }
+      };
+      return t || (a.tabIndex = i, !s && o && (a.tabIndex = e ? i : -1)), (s && (e || n) || !s && o) && (a["aria-disabled"] = o), s && (!e || b) && (a.disabled = o), a;
+    }, [t, o, e, n, b, s, i])
+  };
+}
+export {
+  f as useFocusableWhenDisabled
+};

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

@@ -0,0 +1,22 @@
+import * as l from "react";
+import { useStableCallback as m } from "../../../utils/esm/useStableCallback.js";
+import { useAnimationsFinished as f } from "./useAnimationsFinished.js";
+function c(a) {
+  const {
+    enabled: e = !0,
+    open: n,
+    ref: i,
+    onComplete: s
+  } = a, o = m(s), t = f(i, n, !1);
+  l.useEffect(() => {
+    if (!e)
+      return;
+    const r = new AbortController();
+    return t(o, r.signal), () => {
+      r.abort();
+    };
+  }, [e, n, o, t]);
+}
+export {
+  c as useOpenChangeComplete
+};

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

@@ -0,0 +1,30 @@
+import * as l from "react";
+import { useStableCallback as c } from "../../../utils/esm/useStableCallback.js";
+import { useEnhancedClickHandler as u } from "../../../utils/esm/useEnhancedClickHandler.js";
+import { isIOS as m } from "../../../utils/esm/detectBrowser.js";
+import { useValueChanged as p } from "./useValueChanged.js";
+function C(e) {
+  const [o, t] = l.useState(null), s = c((i, a) => {
+    e || t(a || // On iOS Safari, the hitslop around touch targets means tapping outside an element's
+    // bounds does not fire `pointerdown` but does fire `mousedown`. The `interactionType`
+    // will be "" in that case.
+    (m ? "touch" : ""));
+  });
+  p(e, (i) => {
+    i && !e && t(null);
+  });
+  const {
+    onClick: r,
+    onPointerDown: n
+  } = u(s);
+  return l.useMemo(() => ({
+    openMethod: o,
+    triggerProps: {
+      onClick: r,
+      onPointerDown: n
+    }
+  }), [o, r, n]);
+}
+export {
+  C as useOpenInteractionType
+};