@koide-labs/ui 0.0.0 → 0.0.2

package/dist/use-toast-manager-Dq-44AuW.js

@@ -0,0 +1,37 @@
+import { f as i } from "./formatErrorMessage-BqPuTBN-.js";
+import * as e from "react";
+const o = /* @__PURE__ */ e.createContext(void 0);
+process.env.NODE_ENV !== "production" && (o.displayName = "ToastContext");
+function p() {
+  const t = e.useContext(o);
+  if (!t)
+    throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: useToastManager must be used within <Toast.Provider>." : i(73));
+  return t;
+}
+function c() {
+  const t = e.useContext(o);
+  if (!t)
+    throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: useToastManager must be used within <Toast.Provider>." : i(73));
+  const {
+    toasts: s,
+    add: r,
+    close: a,
+    update: n,
+    promise: u
+  } = t;
+  return e.useMemo(() => ({
+    toasts: s,
+    add: r,
+    close: a,
+    update: n,
+    promise: u
+  }), [s, r, a, n, u]);
+}
+function f() {
+  return c();
+}
+export {
+  o as T,
+  p as a,
+  f as u
+};

package/dist/useAnimationFrame-451ugS_6.js

@@ -0,0 +1,68 @@
+import { a as u } from "./useRenderElement-DwToLA61.js";
+import { u as h } from "./useOnMount-VRW6CK2u.js";
+const s = null;
+let l = globalThis.requestAnimationFrame;
+class o {
+  /* This implementation uses an array as a backing data-structure for frame callbacks.
+   * It allows `O(1)` callback cancelling by inserting a `null` in the array, though it
+   * never calls the native `cancelAnimationFrame` if there are no frames left. This can
+   * be much more efficient if there is a call pattern that alterns as
+   * "request-cancel-request-cancel-…".
+   * But in the case of "request-request-…-cancel-cancel-…", it leaves the final animation
+   * frame to run anyway. We turn that frame into a `O(1)` no-op via `callbacksCount`. */
+  callbacks = [];
+  callbacksCount = 0;
+  nextId = 1;
+  startId = 1;
+  isScheduled = !1;
+  tick = (t) => {
+    this.isScheduled = !1;
+    const e = this.callbacks, a = this.callbacksCount;
+    if (this.callbacks = [], this.callbacksCount = 0, this.startId = this.nextId, a > 0)
+      for (let r = 0; r < e.length; r += 1)
+        e[r]?.(t);
+  };
+  request(t) {
+    const e = this.nextId;
+    this.nextId += 1, this.callbacks.push(t), this.callbacksCount += 1;
+    const a = process.env.NODE_ENV === "test" && l !== requestAnimationFrame && (l = requestAnimationFrame, !0);
+    return (!this.isScheduled || a) && (requestAnimationFrame(this.tick), this.isScheduled = !0), e;
+  }
+  cancel(t) {
+    const e = t - this.startId;
+    e < 0 || e >= this.callbacks.length || (this.callbacks[e] = null, this.callbacksCount -= 1);
+  }
+}
+const c = new o();
+class i {
+  static create() {
+    return new i();
+  }
+  static request(t) {
+    return c.request(t);
+  }
+  static cancel(t) {
+    return c.cancel(t);
+  }
+  currentId = s;
+  /**
+   * Executes `fn` after `delay`, clearing any previously scheduled call.
+   */
+  request(t) {
+    this.cancel(), this.currentId = c.request(() => {
+      this.currentId = s, t();
+    });
+  }
+  cancel = () => {
+    this.currentId !== s && (c.cancel(this.currentId), this.currentId = s);
+  };
+  disposeEffect = () => this.cancel;
+}
+function k() {
+  const n = u(i.create).current;
+  return h(n.disposeEffect), n;
+}
+export {
+  i as A,
+  k as u
+};

package/dist/useBaseUiId-B7WyxtIE.js

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

package/dist/useButton-DfIwsdb8.js

@@ -0,0 +1,127 @@
+import * as u from "react";
+import { i as I } from "./floating-ui.utils.dom-C7FS5id0.js";
+import { u as D } from "./useStableCallback-CkTrVkNX.js";
+import { u as K } from "./useIsoLayoutEffect-CIDbvm3Q.js";
+import { f as R } from "./formatErrorMessage-BqPuTBN-.js";
+import { m as T, d as C } from "./useRenderElement-DwToLA61.js";
+let b;
+process.env.NODE_ENV !== "production" && (b = /* @__PURE__ */ new Set());
+function E(...r) {
+  if (process.env.NODE_ENV !== "production") {
+    const e = r.join(" ");
+    b.has(e) || (b.add(e), console.error(`Base UI: ${e}`));
+  }
+}
+const x = /* @__PURE__ */ u.createContext(void 0);
+process.env.NODE_ENV !== "production" && (x.displayName = "CompositeRootContext");
+function U(r = !1) {
+  const e = u.useContext(x);
+  if (e === void 0 && !r)
+    throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: CompositeRootContext is missing. Composite parts must be placed within <Composite.Root>." : R(16));
+  return e;
+}
+function M(r) {
+  const {
+    focusableWhenDisabled: e,
+    disabled: i,
+    composite: c = !1,
+    tabIndex: n = 0,
+    isNativeButton: s
+  } = r, f = c && e !== !1, l = c && e === !1;
+  return {
+    props: u.useMemo(() => {
+      const a = {
+        // allow Tabbing away from focusableWhenDisabled elements
+        onKeyDown(d) {
+          i && e && d.key !== "Tab" && d.preventDefault();
+        }
+      };
+      return c || (a.tabIndex = n, !s && i && (a.tabIndex = e ? n : -1)), (s && (e || f) || !s && i) && (a["aria-disabled"] = i), s && (!e || l) && (a.disabled = i), a;
+    }, [c, i, e, f, l, s, n])
+  };
+}
+function L(r = {}) {
+  const {
+    disabled: e = !1,
+    focusableWhenDisabled: i,
+    tabIndex: c = 0,
+    native: n = !0
+  } = r, s = u.useRef(null), f = U(!0) !== void 0, l = D(() => {
+    const o = s.current;
+    return !!(o?.tagName === "A" && o?.href);
+  }), {
+    props: p
+  } = M({
+    focusableWhenDisabled: i,
+    disabled: e,
+    composite: f,
+    tabIndex: c,
+    isNativeButton: n
+  });
+  process.env.NODE_ENV !== "production" && u.useEffect(() => {
+    if (!s.current)
+      return;
+    const o = s.current.tagName === "BUTTON";
+    n ? o || E("A component that acts as a button was not rendered as a native <button>, which does not match the default. Ensure that the element passed to the `render` prop of the component is a real <button>, or set the `nativeButton` prop on the component to `false`.") : o && E("A component that acts as a button was rendered as a native <button>, which does not match the default. Ensure that the element passed to the `render` prop of the component is not a real <button>, or set the `nativeButton` prop on the component to `true`.");
+  }, [n]);
+  const a = u.useCallback(() => {
+    const o = s.current;
+    V(o) && f && e && p.disabled === void 0 && o.disabled && (o.disabled = !1);
+  }, [e, p.disabled, f]);
+  K(a, [a]);
+  const d = u.useCallback((o = {}) => {
+    const {
+      onClick: m,
+      onMouseDown: w,
+      onKeyUp: y,
+      onKeyDown: g,
+      onPointerDown: k,
+      ...B
+    } = o;
+    return T({
+      type: n ? "button" : void 0,
+      onClick(t) {
+        if (e) {
+          t.preventDefault();
+          return;
+        }
+        m?.(t);
+      },
+      onMouseDown(t) {
+        e || w?.(t);
+      },
+      onKeyDown(t) {
+        if (e || (C(t), g?.(t)), t.baseUIHandlerPrevented)
+          return;
+        const O = t.target === t.currentTarget && !n && !l() && !e, h = t.key === "Enter", P = t.key === " ";
+        O && ((P || h) && t.preventDefault(), h && m?.(t));
+      },
+      onKeyUp(t) {
+        e || (C(t), y?.(t)), !t.baseUIHandlerPrevented && t.target === t.currentTarget && !n && !e && t.key === " " && m?.(t);
+      },
+      onPointerDown(t) {
+        if (e) {
+          t.preventDefault();
+          return;
+        }
+        k?.(t);
+      }
+    }, n ? void 0 : {
+      role: "button"
+    }, p, B);
+  }, [e, p, n, l]), N = D((o) => {
+    s.current = o, a();
+  });
+  return {
+    getButtonProps: d,
+    buttonRef: N
+  };
+}
+function V(r) {
+  return I(r) && r.tagName === "BUTTON";
+}
+export {
+  x as C,
+  U as a,
+  L as u
+};

package/dist/useCompositeListItem-OkcAim_1.js

@@ -0,0 +1,148 @@
+import * as o from "react";
+import { a as L } from "./useRenderElement-DwToLA61.js";
+import { u as R } from "./useStableCallback-CkTrVkNX.js";
+import { u as x } from "./useIsoLayoutEffect-CIDbvm3Q.js";
+import { jsx as T } from "react/jsx-runtime";
+const b = /* @__PURE__ */ o.createContext({
+  register: () => {
+  },
+  unregister: () => {
+  },
+  subscribeMapChange: () => () => {
+  },
+  elementsRef: {
+    current: []
+  },
+  nextIndexRef: {
+    current: 0
+  }
+});
+process.env.NODE_ENV !== "production" && (b.displayName = "CompositeListContext");
+function D() {
+  return o.useContext(b);
+}
+function y(u) {
+  const {
+    children: m,
+    elementsRef: t,
+    labelsRef: r,
+    onMapChange: E
+  } = u, f = R(E), O = o.useRef(0), p = L(S).current, d = L(_).current, [C, N] = o.useState(0), c = o.useRef(C), M = R((e, i) => {
+    d.set(e, i ?? null), c.current += 1, N(c.current);
+  }), a = R((e) => {
+    d.delete(e), c.current += 1, N(c.current);
+  }), n = o.useMemo(() => {
+    const e = /* @__PURE__ */ new Map();
+    return Array.from(d.keys()).filter((s) => s.isConnected).sort(P).forEach((s, I) => {
+      const l = d.get(s) ?? {};
+      e.set(s, {
+        ...l,
+        index: I
+      });
+    }), e;
+  }, [d, C]);
+  x(() => {
+    if (typeof MutationObserver != "function" || n.size === 0)
+      return;
+    const e = new MutationObserver((i) => {
+      const s = /* @__PURE__ */ new Set(), I = (l) => s.has(l) ? s.delete(l) : s.add(l);
+      i.forEach((l) => {
+        l.removedNodes.forEach(I), l.addedNodes.forEach(I);
+      }), s.size === 0 && (c.current += 1, N(c.current));
+    });
+    return n.forEach((i, s) => {
+      s.parentElement && e.observe(s.parentElement, {
+        childList: !0
+      });
+    }), () => {
+      e.disconnect();
+    };
+  }, [n]), x(() => {
+    c.current === C && (t.current.length !== n.size && (t.current.length = n.size), r && r.current.length !== n.size && (r.current.length = n.size), O.current = n.size), f(n);
+  }, [f, n, t, r, C]), x(() => () => {
+    t.current = [];
+  }, [t]), x(() => () => {
+    r && (r.current = []);
+  }, [r]);
+  const h = R((e) => (p.add(e), () => {
+    p.delete(e);
+  }));
+  x(() => {
+    p.forEach((e) => e(n));
+  }, [p, n]);
+  const g = o.useMemo(() => ({
+    register: M,
+    unregister: a,
+    subscribeMapChange: h,
+    elementsRef: t,
+    labelsRef: r,
+    nextIndexRef: O
+  }), [M, a, h, t, r, O]);
+  return /* @__PURE__ */ T(b.Provider, {
+    value: g,
+    children: m
+  });
+}
+function _() {
+  return /* @__PURE__ */ new Map();
+}
+function S() {
+  return /* @__PURE__ */ new Set();
+}
+function P(u, m) {
+  const t = u.compareDocumentPosition(m);
+  return t & Node.DOCUMENT_POSITION_FOLLOWING || t & Node.DOCUMENT_POSITION_CONTAINED_BY ? -1 : t & Node.DOCUMENT_POSITION_PRECEDING || t & Node.DOCUMENT_POSITION_CONTAINS ? 1 : 0;
+}
+let w = /* @__PURE__ */ (function(u) {
+  return u[u.None = 0] = "None", u[u.GuessFromOrder = 1] = "GuessFromOrder", u;
+})({});
+function F(u = {}) {
+  const {
+    label: m,
+    metadata: t,
+    textRef: r,
+    indexGuessBehavior: E,
+    index: f
+  } = u, {
+    register: O,
+    unregister: p,
+    subscribeMapChange: d,
+    elementsRef: C,
+    labelsRef: N,
+    nextIndexRef: c
+  } = D(), M = o.useRef(-1), [a, n] = o.useState(f ?? (E === w.GuessFromOrder ? () => {
+    if (M.current === -1) {
+      const e = c.current;
+      c.current += 1, M.current = e;
+    }
+    return M.current;
+  } : -1)), h = o.useRef(null), g = o.useCallback((e) => {
+    if (h.current = e, a !== -1 && e !== null && (C.current[a] = e, N)) {
+      const i = m !== void 0;
+      N.current[a] = i ? m : r?.current?.textContent ?? e.textContent;
+    }
+  }, [a, C, N, m, r]);
+  return x(() => {
+    if (f != null)
+      return;
+    const e = h.current;
+    if (e)
+      return O(e, t), () => {
+        p(e);
+      };
+  }, [f, O, p, t]), x(() => {
+    if (f == null)
+      return d((e) => {
+        const i = h.current ? e.get(h.current)?.index : null;
+        i != null && n(i);
+      });
+  }, [f, d, n]), o.useMemo(() => ({
+    ref: g,
+    index: a
+  }), [a, g]);
+}
+export {
+  y as C,
+  w as I,
+  F as u
+};

package/dist/useControlled-Du4sJyMj.js

@@ -0,0 +1,31 @@
+import * as n from "react";
+function d({
+  controlled: o,
+  default: s,
+  name: t,
+  state: i = "value"
+}) {
+  const {
+    current: e
+  } = n.useRef(o !== void 0), [l, c] = n.useState(s), u = e ? o : l;
+  if (process.env.NODE_ENV !== "production") {
+    n.useEffect(() => {
+      e !== (o !== void 0) && console.error([`Base UI: A component is changing the ${e ? "" : "un"}controlled ${i} state of ${t} to be ${e ? "un" : ""}controlled.`, "Elements should not switch from uncontrolled to controlled (or vice versa).", `Decide between using a controlled or uncontrolled ${t} element for the lifetime of the component.`, "The nature of the state is determined during the first render. It's considered controlled if the value is not `undefined`.", "More info: https://fb.me/react-controlled-components"].join(`
+`));
+    }, [i, t, o]);
+    const {
+      current: r
+    } = n.useRef(s);
+    n.useEffect(() => {
+      !e && JSON.stringify(r) !== JSON.stringify(s) && console.error([`Base UI: A component is changing the default ${i} state of an uncontrolled ${t} after being initialized. To suppress this warning opt to use a controlled ${t}.`].join(`
+`));
+    }, [JSON.stringify(s)]);
+  }
+  const f = n.useCallback((r) => {
+    e || c(r);
+  }, []);
+  return [u, f];
+}
+export {
+  d as u
+};

package/dist/useHoverReferenceInteraction-SfOBPoXM.js

@@ -0,0 +1,264 @@
+import * as u from "react";
+import { a as re } from "./floating-ui.utils.dom-C7FS5id0.js";
+import { u as I } from "./useStableCallback-CkTrVkNX.js";
+import { u as te } from "./useIsoLayoutEffect-CIDbvm3Q.js";
+import { c as A, t as F } from "./createBaseUIEventDetails-D8M2Yl-a.js";
+import { a as oe, u as ue } from "./transitions.module-CWX8e5cx.js";
+import { T as ie, d as G, e as ae, f as q } from "./element-CZEOj04G.js";
+import { i as U } from "./event-CKoGyQEJ.js";
+import * as le from "react-dom";
+import { u as J } from "./useValueAsRef-HURLzret.js";
+import { g as K } from "./safePolygon-DWy1dGKJ.js";
+import { u as ne } from "./useTimeout-CflX-kz3.js";
+import { c as fe } from "./FloatingPortal-tWyuKRSN.js";
+const Z = fe("safe-polygon"), de = `button,a,[role="button"],select,[tabindex]:not([tabindex="-1"]),${ie}`;
+function me(r) {
+  return r ? !!r.closest(de) : !1;
+}
+function se(r) {
+  const M = u.useRef(void 0), e = u.useRef(!1), i = u.useRef(void 0), m = u.useRef(!0), v = u.useRef(!1), T = u.useRef(() => {
+  }), P = u.useRef(!1), y = ne(), Y = ne(), R = u.useRef(void 0);
+  return u.useMemo(() => {
+    const l = r.context.dataRef.current;
+    return l.hoverInteractionState || (l.hoverInteractionState = {
+      pointerTypeRef: M,
+      interactedInsideRef: e,
+      handlerRef: i,
+      blockMouseMoveRef: m,
+      performedPointerEventsMutationRef: v,
+      unbindMouseMoveRef: T,
+      restTimeoutPendingRef: P,
+      openChangeTimeout: y,
+      restTimeout: Y,
+      handleCloseOptionsRef: R
+    }), l.hoverInteractionState;
+  }, [r, M, e, i, m, v, T, P, y, Y, R]);
+}
+const ge = /* @__PURE__ */ new Set(["click", "mousedown"]);
+function Ie(r, M = {}) {
+  const e = "rootStore" in r ? r.rootStore : r, i = e.useState("open"), m = e.useState("floatingElement"), v = e.useState("domReferenceElement"), {
+    dataRef: T
+  } = e.context, {
+    enabled: P = !0,
+    closeDelay: y = 0,
+    externalTree: Y
+  } = M, {
+    pointerTypeRef: R,
+    interactedInsideRef: l,
+    handlerRef: _,
+    performedPointerEventsMutationRef: x,
+    unbindMouseMoveRef: V,
+    restTimeoutPendingRef: g,
+    openChangeTimeout: X,
+    handleCloseOptionsRef: L
+  } = se(e), b = oe(Y), j = ue(), k = I(() => l.current ? !0 : T.current.openEvent ? ge.has(T.current.openEvent.type) : !1), h = I(() => {
+    const n = T.current.openEvent?.type;
+    return n?.includes("mouse") && n !== "mousedown";
+  }), p = u.useCallback((n, a = !0) => {
+    const d = Ee(y, R.current);
+    d && !_.current ? X.start(d, () => e.setOpen(!1, A(F, n))) : a && (X.clear(), e.setOpen(!1, A(F, n)));
+  }, [y, _, e, R, X]), f = I(() => {
+    V.current(), _.current = void 0;
+  }), D = I(() => {
+    if (x.current) {
+      const n = G(m).body;
+      n.style.pointerEvents = "", n.removeAttribute(Z), x.current = !1;
+    }
+  }), H = I((n) => {
+    const a = ae(n);
+    if (!me(a)) {
+      l.current = !1;
+      return;
+    }
+    l.current = !0;
+  });
+  te(() => {
+    i || (R.current = void 0, g.current = !1, l.current = !1, f(), D());
+  }, [i, R, g, l, f, D]), u.useEffect(() => () => {
+    f();
+  }, [f]), u.useEffect(() => D, [D]), te(() => {
+    if (P && i && L.current?.blockPointerEvents && h() && re(v) && m) {
+      x.current = !0;
+      const n = G(m).body;
+      n.setAttribute(Z, "");
+      const a = v, d = m, c = b?.nodesRef.current.find((E) => E.id === j)?.context?.elements.floating;
+      return c && (c.style.pointerEvents = ""), n.style.pointerEvents = "none", a.style.pointerEvents = "auto", d.style.pointerEvents = "auto", () => {
+        n.style.pointerEvents = "", a.style.pointerEvents = "", d.style.pointerEvents = "";
+      };
+    }
+  }, [P, i, v, m, L, h, b, j, x]), u.useEffect(() => {
+    if (!P)
+      return;
+    function n(E) {
+      if (k() || !T.current.floatingContext || !e.select("open"))
+        return;
+      const B = e.context.triggerElements;
+      E.relatedTarget && B.hasElement(E.relatedTarget) || (D(), f(), k() || p(E));
+    }
+    function a(E) {
+      X.clear(), D(), _.current?.(E), f();
+    }
+    function d(E) {
+      k() || p(E, !1);
+    }
+    const c = m;
+    return c && (c.addEventListener("mouseleave", n), c.addEventListener("mouseenter", a), c.addEventListener("mouseleave", d), c.addEventListener("pointerdown", H, !0)), () => {
+      c && (c.removeEventListener("mouseleave", n), c.removeEventListener("mouseenter", a), c.removeEventListener("mouseleave", d), c.removeEventListener("pointerdown", H, !0));
+    };
+  });
+}
+function Ee(r, M) {
+  return M && !U(M) ? 0 : typeof r == "function" ? r() : r;
+}
+function Q(r) {
+  return typeof r == "function" ? r() : r;
+}
+const pe = {
+  current: null
+};
+function Pe(r, M = {}) {
+  const e = "rootStore" in r ? r.rootStore : r, {
+    dataRef: i,
+    events: m
+  } = e.context, {
+    enabled: v = !0,
+    delay: T = 0,
+    handleClose: P = null,
+    mouseOnly: y = !1,
+    restMs: Y = 0,
+    move: R = !0,
+    triggerElementRef: l = pe,
+    externalTree: _,
+    isActiveTrigger: x = !0
+  } = M, V = oe(_), {
+    pointerTypeRef: g,
+    interactedInsideRef: X,
+    handlerRef: L,
+    blockMouseMoveRef: b,
+    performedPointerEventsMutationRef: j,
+    unbindMouseMoveRef: k,
+    restTimeoutPendingRef: h,
+    openChangeTimeout: p,
+    restTimeout: f,
+    handleCloseOptionsRef: D
+  } = se(e), H = J(P), n = J(T), a = J(Y);
+  x && (D.current = H.current?.__options);
+  const d = I(() => X.current ? !0 : i.current.openEvent ? ["click", "mousedown"].includes(i.current.openEvent.type) : !1), c = u.useCallback((t, o = !0) => {
+    const C = K(n.current, "close", g.current);
+    C && !L.current ? p.start(C, () => e.setOpen(!1, A(F, t))) : o && (p.clear(), e.setOpen(!1, A(F, t)));
+  }, [n, L, e, g, p]), E = I(() => {
+    k.current(), L.current = void 0;
+  }), B = I(() => {
+    if (j.current) {
+      const t = G(e.select("domReferenceElement")).body;
+      t.style.pointerEvents = "", t.removeAttribute(Z), j.current = !1;
+    }
+  });
+  u.useEffect(() => {
+    if (!v)
+      return;
+    function t(o) {
+      o.open || (p.clear(), f.clear(), b.current = !0, h.current = !1);
+    }
+    return m.on("openchange", t), () => {
+      m.off("openchange", t);
+    };
+  }, [v, m, p, f, b, h]);
+  const ee = I((t) => {
+    if (d() || !i.current.floatingContext)
+      return;
+    const o = e.context.triggerElements;
+    if (t.relatedTarget && o.hasElement(t.relatedTarget))
+      return;
+    const C = l.current;
+    H.current?.({
+      ...i.current.floatingContext,
+      tree: V,
+      x: t.clientX,
+      y: t.clientY,
+      onClose() {
+        B(), E(), !d() && C === e.select("domReferenceElement") && c(t);
+      }
+    })(t);
+  });
+  return u.useEffect(() => {
+    if (!v)
+      return;
+    const t = l.current ?? (x ? e.select("domReferenceElement") : null);
+    if (!re(t))
+      return;
+    function o(s) {
+      if (p.clear(), b.current = !1, y && !U(g.current) || Q(a.current) > 0 && !K(n.current, "open"))
+        return;
+      const w = K(n.current, "open", g.current), O = e.select("domReferenceElement"), S = e.context.triggerElements, N = (S.hasElement(s.target) || S.hasMatchingElement((ce) => q(ce, s.target))) && (!O || !q(O, s.target)), W = s.currentTarget ?? null, $ = !e.select("open") || N;
+      w ? p.start(w, () => {
+        $ && e.setOpen(!0, A(F, s, W));
+      }) : $ && e.setOpen(!0, A(F, s, W));
+    }
+    function C(s) {
+      if (d()) {
+        B();
+        return;
+      }
+      k.current();
+      const w = e.select("domReferenceElement"), O = G(w);
+      f.clear(), h.current = !1;
+      const S = e.context.triggerElements;
+      if (s.relatedTarget && S.hasElement(s.relatedTarget))
+        return;
+      if (H.current && i.current.floatingContext) {
+        e.select("open") || p.clear();
+        const W = l.current;
+        L.current = H.current({
+          ...i.current.floatingContext,
+          tree: V,
+          x: s.clientX,
+          y: s.clientY,
+          onClose() {
+            B(), E(), !d() && W === e.select("domReferenceElement") && c(s, !0);
+          }
+        });
+        const $ = L.current;
+        $(s), O.addEventListener("mousemove", $), k.current = () => {
+          O.removeEventListener("mousemove", $);
+        };
+        return;
+      }
+      (g.current !== "touch" || !q(e.select("floatingElement"), s.relatedTarget)) && c(s);
+    }
+    function z(s) {
+      ee(s);
+    }
+    return e.select("open") && t.addEventListener("mouseleave", z), R && t.addEventListener("mousemove", o, {
+      once: !0
+    }), t.addEventListener("mouseenter", o), t.addEventListener("mouseleave", C), () => {
+      t.removeEventListener("mouseleave", z), R && t.removeEventListener("mousemove", o), t.removeEventListener("mouseenter", o), t.removeEventListener("mouseleave", C);
+    };
+  }, [E, B, b, i, n, c, e, v, H, ee, x, d, y, R, g, a, f, h, p, l, V, k, L]), u.useMemo(() => {
+    function t(o) {
+      g.current = o.pointerType;
+    }
+    return {
+      onPointerDown: t,
+      onPointerEnter: t,
+      onMouseMove(o) {
+        const {
+          nativeEvent: C
+        } = o, z = o.currentTarget, s = e.select("domReferenceElement"), w = e.context.triggerElements, O = e.select("open"), S = (w.hasElement(o.target) || w.hasMatchingElement((W) => q(W, o.target))) && (!s || !q(s, o.target));
+        if (y && !U(g.current) || O && !S || Q(a.current) === 0 || !S && h.current && o.movementX ** 2 + o.movementY ** 2 < 2)
+          return;
+        f.clear();
+        function N() {
+          !b.current && (!O || S) && e.setOpen(!0, A(F, C, z));
+        }
+        g.current === "touch" ? le.flushSync(() => {
+          N();
+        }) : S && O ? N() : (h.current = !0, f.start(Q(a.current), N));
+      }
+    };
+  }, [b, y, e, g, a, f, h]);
+}
+export {
+  Ie as a,
+  Pe as u
+};