@koide-labs/ui 0.0.0 → 0.0.2

package/dist/components/tooltip/index.js

@@ -0,0 +1,712 @@
+import { jsx as O, jsxs as ne } from "react/jsx-runtime";
+import { c as Ee } from "../../clsx-OuTLNxxd.js";
+import { textify as Se } from "../../-utils.js";
+import { Surface as xe } from "../surface/index.js";
+import { t as oe, T as be } from "../../tooltip-arrow-C1qXdi5T.js";
+import { R as Oe, P as we, c as N, d as Me, e as Ie, f as Ne, p as $, t as De } from "../../transitions.module-CWX8e5cx.js";
+import * as o from "react";
+import { u as le, T as Ae } from "../../useTimeout-CflX-kz3.js";
+import { u as D } from "../../useIsoLayoutEffect-CIDbvm3Q.js";
+import { g as ke, s as Ve } from "../../safePolygon-DWy1dGKJ.js";
+import { c as _, n as ce, b as W, a as pe, e as de, t as se, i as Le, g as _e } from "../../createBaseUIEventDetails-D8M2Yl-a.js";
+import { f as F } from "../../formatErrorMessage-BqPuTBN-.js";
+import * as He from "react-dom";
+import { a as Ue, u as B } from "../../useRenderElement-DwToLA61.js";
+import { p as Fe, b as Be, c as je, u as Ge, a as Xe, d as Ye } from "../../useSyncedFloatingRootContext-Dorsv-jf.js";
+import { d as fe, a as re, i as We } from "../../floating-ui.utils.dom-C7FS5id0.js";
+import { e as ze, b as $e } from "../../detectBrowser-I-s3yzIE.js";
+import { c as Ke, P as qe } from "../../FloatingPortal-tWyuKRSN.js";
+import { e as me, f as z, h as ie, j as Je, m as Qe, d as Ze } from "../../element-CZEOj04G.js";
+import { u as ae } from "../../useStableCallback-CkTrVkNX.js";
+import { i as et } from "../../event-CKoGyQEJ.js";
+import { u as tt } from "../../useBaseUiId-B7WyxtIE.js";
+import { u as nt, a as ot } from "../../useHoverReferenceInteraction-SfOBPoXM.js";
+import { F as st } from "../../FloatingPortalLite-DVyq6YhV.js";
+import { a as rt, b as it, g as ge } from "../../getDisabledMountTransitionStyles-YfHPge6T.js";
+import { a as at, t as ut } from "../../useOpenChangeComplete-Dse9kY9E.js";
+import { u as lt } from "../../usePopupAutoResize-CNR6Ekmx.js";
+import { u as ct } from "../../DirectionContext-C2o_MF_i.js";
+const K = /* @__PURE__ */ o.createContext({
+  hasProvider: !1,
+  timeoutMs: 0,
+  delayRef: {
+    current: 0
+  },
+  initialDelayRef: {
+    current: 0
+  },
+  timeout: new Ae(),
+  currentIdRef: {
+    current: null
+  },
+  currentContextRef: {
+    current: null
+  }
+});
+process.env.NODE_ENV !== "production" && (K.displayName = "FloatingDelayGroupContext");
+function pt(s) {
+  const {
+    children: e,
+    delay: t,
+    timeoutMs: r = 0
+  } = s, f = o.useRef(t), a = o.useRef(t), c = o.useRef(null), u = o.useRef(null), d = le();
+  return /* @__PURE__ */ O(K.Provider, {
+    value: o.useMemo(() => ({
+      hasProvider: !0,
+      delayRef: f,
+      initialDelayRef: a,
+      currentIdRef: c,
+      timeoutMs: r,
+      currentContextRef: u,
+      timeout: d
+    }), [r, d]),
+    children: e
+  });
+}
+function dt(s, e = {
+  open: !1
+}) {
+  const t = "rootStore" in s ? s.rootStore : s, r = t.useState("floatingId"), {
+    enabled: f = !0,
+    open: a
+  } = e, c = o.useContext(K), {
+    currentIdRef: u,
+    delayRef: d,
+    timeoutMs: p,
+    initialDelayRef: m,
+    currentContextRef: i,
+    hasProvider: l,
+    timeout: n
+  } = c, [y, g] = o.useState(!1);
+  return D(() => {
+    function T() {
+      g(!1), i.current?.setIsInstantPhase(!1), u.current = null, i.current = null, d.current = m.current;
+    }
+    if (f && u.current && !a && u.current === r) {
+      if (g(!1), p) {
+        const h = r;
+        return n.start(p, () => {
+          t.select("open") || u.current && u.current !== h || T();
+        }), () => {
+          n.clear();
+        };
+      }
+      T();
+    }
+  }, [f, a, r, u, d, p, m, i, n, t]), D(() => {
+    if (!f || !a)
+      return;
+    const T = i.current, h = u.current;
+    n.clear(), i.current = {
+      onOpenChange: t.setOpen,
+      setIsInstantPhase: g
+    }, u.current = r, d.current = {
+      open: 0,
+      close: ke(m.current, "close")
+    }, h !== null && h !== r ? (g(!0), T?.setIsInstantPhase(!0), T?.onOpenChange(!1, _(ce))) : (g(!1), T?.setIsInstantPhase(!1));
+  }, [f, a, r, t, u, d, p, m, i, n]), D(() => () => {
+    i.current = null;
+  }, [i]), o.useMemo(() => ({
+    hasProvider: l,
+    delayRef: d,
+    isInstantPhase: y
+  }), [l, d, y]);
+}
+function ft(s, e) {
+  let t = null, r = null, f = !1;
+  return {
+    contextElement: s || void 0,
+    getBoundingClientRect() {
+      const a = s?.getBoundingClientRect() || {
+        width: 0,
+        height: 0,
+        x: 0,
+        y: 0
+      }, c = e.axis === "x" || e.axis === "both", u = e.axis === "y" || e.axis === "both", d = ["mouseenter", "mousemove"].includes(e.dataRef.current.openEvent?.type || "") && e.pointerType !== "touch";
+      let p = a.width, m = a.height, i = a.x, l = a.y;
+      return t == null && e.x && c && (t = a.x - e.x), r == null && e.y && u && (r = a.y - e.y), i -= t || 0, l -= r || 0, p = 0, m = 0, !f || d ? (p = e.axis === "y" ? a.width : 0, m = e.axis === "x" ? a.height : 0, i = c && e.x != null ? e.x : i, l = u && e.y != null ? e.y : l) : f && !d && (m = e.axis === "x" ? a.height : m, p = e.axis === "y" ? a.width : p), f = !0, {
+        width: p,
+        height: m,
+        x: i,
+        y: l,
+        top: l,
+        right: i + p,
+        bottom: l + m,
+        left: i
+      };
+    }
+  };
+}
+function ue(s) {
+  return s != null && s.clientX != null;
+}
+function mt(s, e = {}) {
+  const t = "rootStore" in s ? s.rootStore : s, r = t.useState("open"), f = t.useState("floatingElement"), a = t.useState("domReferenceElement"), c = t.context.dataRef, {
+    enabled: u = !0,
+    axis: d = "both",
+    x: p = null,
+    y: m = null
+  } = e, i = o.useRef(!1), l = o.useRef(null), [n, y] = o.useState(), [g, T] = o.useState([]), h = ae((v, R) => {
+    i.current || c.current.openEvent && !ue(c.current.openEvent) || t.set("positionReference", ft(a, {
+      x: v,
+      y: R,
+      axis: d,
+      dataRef: c,
+      pointerType: n
+    }));
+  }), C = ae((v) => {
+    p != null || m != null || (r ? l.current || T([]) : h(v.clientX, v.clientY));
+  }), b = et(n) ? f : r, S = o.useCallback(() => {
+    if (!b || !u || p != null || m != null)
+      return;
+    const v = fe(f);
+    function R(E) {
+      const w = me(E);
+      z(f, w) ? (v.removeEventListener("mousemove", R), l.current = null) : h(E.clientX, E.clientY);
+    }
+    if (!c.current.openEvent || ue(c.current.openEvent)) {
+      v.addEventListener("mousemove", R);
+      const E = () => {
+        v.removeEventListener("mousemove", R), l.current = null;
+      };
+      return l.current = E, E;
+    }
+    t.set("positionReference", a);
+  }, [b, u, p, m, f, c, a, t, h]);
+  o.useEffect(() => S(), [S, g]), o.useEffect(() => {
+    u && !f && (i.current = !1);
+  }, [u, f]), o.useEffect(() => {
+    !u && r && (i.current = !0);
+  }, [u, r]), D(() => {
+    u && (p != null || m != null) && (i.current = !1, h(p, m));
+  }, [u, p, m, h]);
+  const x = o.useMemo(() => {
+    function v(R) {
+      y(R.pointerType);
+    }
+    return {
+      onPointerDown: v,
+      onPointerEnter: v,
+      onMouseMove: C,
+      onMouseEnter: C
+    };
+  }, [C]);
+  return o.useMemo(() => u ? {
+    reference: x
+  } : {}, [u, x]);
+}
+const Y = ze && $e;
+function gt(s, e = {}) {
+  const t = "rootStore" in s ? s.rootStore : s, {
+    events: r,
+    dataRef: f
+  } = t.context, {
+    enabled: a = !0,
+    visibleOnly: c = !0
+  } = e, u = o.useRef(!1), d = le(), p = o.useRef(!0);
+  o.useEffect(() => {
+    const i = t.select("domReferenceElement");
+    if (!a)
+      return;
+    const l = fe(i);
+    function n() {
+      !t.select("open") && We(i) && i === ie(Ze(i)) && (u.current = !0);
+    }
+    function y() {
+      p.current = !0;
+    }
+    function g() {
+      p.current = !1;
+    }
+    return l.addEventListener("blur", n), Y && (l.addEventListener("keydown", y, !0), l.addEventListener("pointerdown", g, !0)), () => {
+      l.removeEventListener("blur", n), Y && (l.removeEventListener("keydown", y, !0), l.removeEventListener("pointerdown", g, !0));
+    };
+  }, [t, a]), o.useEffect(() => {
+    if (!a)
+      return;
+    function i(l) {
+      (l.reason === pe || l.reason === de) && (u.current = !0);
+    }
+    return r.on("openchange", i), () => {
+      r.off("openchange", i);
+    };
+  }, [r, a]);
+  const m = o.useMemo(() => ({
+    onMouseLeave() {
+      u.current = !1;
+    },
+    onFocus(i) {
+      if (u.current)
+        return;
+      const l = me(i.nativeEvent);
+      if (c && re(l)) {
+        if (Y && !i.relatedTarget) {
+          if (!p.current && !Je(l))
+            return;
+        } else if (!Qe(l))
+          return;
+      }
+      t.setOpen(!0, _(W, i.nativeEvent, i.currentTarget));
+    },
+    onBlur(i) {
+      u.current = !1;
+      const l = i.relatedTarget, n = i.nativeEvent, y = re(l) && l.hasAttribute(Ke("focus-guard")) && l.getAttribute("data-type") === "outside";
+      d.start(0, () => {
+        const g = t.select("domReferenceElement"), T = ie(g ? g.ownerDocument : document);
+        !l && T === g || z(f.current.floatingContext?.refs.floating.current, T) || z(g, T) || y || t.context.triggerElements.hasElement(i.relatedTarget) || t.setOpen(!1, _(W, n));
+      });
+    }
+  }), [f, t, c, d]);
+  return o.useMemo(() => a ? {
+    reference: m,
+    trigger: m
+  } : {}, [a, m]);
+}
+const q = /* @__PURE__ */ o.createContext(void 0);
+process.env.NODE_ENV !== "production" && (q.displayName = "TooltipRootContext");
+function H(s) {
+  const e = o.useContext(q);
+  if (e === void 0 && !s)
+    throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: TooltipRootContext is missing. Tooltip parts must be placed within <Tooltip.Root>." : F(72));
+  return e;
+}
+const yt = {
+  ...Fe,
+  disabled: N((s) => s.disabled),
+  instantType: N((s) => s.instantType),
+  isInstantPhase: N((s) => s.isInstantPhase),
+  trackCursorAxis: N((s) => s.trackCursorAxis),
+  disableHoverablePopup: N((s) => s.disableHoverablePopup),
+  lastOpenChangeReason: N((s) => s.openChangeReason),
+  closeDelay: N((s) => s.closeDelay)
+};
+class J extends Oe {
+  constructor(e) {
+    super({
+      ...ht(),
+      ...e
+    }, {
+      popupRef: /* @__PURE__ */ o.createRef(),
+      onOpenChange: void 0,
+      onOpenChangeComplete: void 0,
+      triggerElements: new we()
+    }, yt);
+  }
+  setOpen = (e, t) => {
+    const r = t.reason, f = r === se, a = e && r === W, c = !e && (r === pe || r === de);
+    if (t.preventUnmountOnClose = () => {
+      this.set("preventUnmountingOnClose", !0);
+    }, this.context.onOpenChange?.(e, t), t.isCanceled)
+      return;
+    const u = () => {
+      const d = {
+        open: e,
+        openChangeReason: r
+      };
+      a ? d.instantType = "focus" : c ? d.instantType = "dismiss" : r === se && (d.instantType = void 0);
+      const p = t.trigger?.id ?? null;
+      (p || e) && (d.activeTriggerId = p, d.activeTriggerElement = t.trigger ?? null), this.update(d);
+    };
+    f ? He.flushSync(u) : u();
+  };
+  static useStore(e, t) {
+    const r = Ue(() => e ?? new J(t)).current, f = Be({
+      popupStore: r,
+      onOpenChange: r.setOpen
+    });
+    return r.state.floatingRootContext = f, r;
+  }
+}
+function ht() {
+  return {
+    ...je(),
+    disabled: !1,
+    instantType: void 0,
+    isInstantPhase: !1,
+    trackCursorAxis: "none",
+    disableHoverablePopup: !1,
+    openChangeReason: null,
+    closeDelay: 0
+  };
+}
+function vt(s) {
+  const {
+    disabled: e = !1,
+    defaultOpen: t = !1,
+    open: r,
+    disableHoverablePopup: f = !1,
+    trackCursorAxis: a = "none",
+    actionsRef: c,
+    onOpenChange: u,
+    onOpenChangeComplete: d,
+    handle: p,
+    triggerId: m,
+    defaultTriggerId: i = null,
+    children: l
+  } = s, n = J.useStore(p?.store, {
+    open: r ?? t,
+    activeTriggerId: m !== void 0 ? m : i
+  });
+  n.useControlledProp("open", r, t), n.useControlledProp("activeTriggerId", m, i), n.useContextCallback("onOpenChange", u), n.useContextCallback("onOpenChangeComplete", d);
+  const y = n.useState("open"), g = n.useState("activeTriggerId"), T = n.useState("payload");
+  n.useSyncedValues({
+    trackCursorAxis: a,
+    disableHoverablePopup: f
+  });
+  const h = !e && y;
+  D(() => {
+    y && e && n.setOpen(!1, _(_e));
+  }, [y, e, n]), n.useSyncedValue("disabled", e), Ge(n);
+  const {
+    forceUnmount: C,
+    transitionStatus: b
+  } = Xe(h, n), S = n.useState("isInstantPhase"), x = n.useState("instantType"), v = n.useState("lastOpenChangeReason"), R = o.useRef(null);
+  D(() => {
+    b === "ending" && v === ce || b !== "ending" && S ? (x !== "delay" && (R.current = x), n.set("instantType", "delay")) : R.current !== null && (n.set("instantType", R.current), R.current = null);
+  }, [b, S, v, x, n]), D(() => {
+    h && g == null && n.set("payload", void 0);
+  }, [n, g, h]);
+  const E = o.useCallback(() => {
+    n.setOpen(!1, Tt(n, Le));
+  }, [n]);
+  o.useImperativeHandle(c, () => ({
+    unmount: C,
+    close: E
+  }), [C, E]);
+  const w = n.useState("floatingRootContext"), M = gt(w, {
+    enabled: !e
+  }), P = Me(w, {
+    enabled: !e,
+    referencePress: !0
+  }), L = mt(w, {
+    enabled: !e && a !== "none",
+    axis: a === "none" ? void 0 : a
+  }), {
+    getReferenceProps: I,
+    getFloatingProps: A,
+    getTriggerProps: k
+  } = Ie([M, P, L]), V = o.useMemo(() => I(), [I]), j = o.useMemo(() => k(), [k]), te = o.useMemo(() => A(), [A]);
+  return n.useSyncedValues({
+    floatingRootContext: w,
+    activeTriggerProps: V,
+    inactiveTriggerProps: j,
+    popupProps: te
+  }), /* @__PURE__ */ O(q.Provider, {
+    value: n,
+    children: typeof l == "function" ? l({
+      payload: T
+    }) : l
+  });
+}
+function Tt(s, e) {
+  const t = _(e);
+  return t.preventUnmountOnClose = () => {
+    s.set("preventUnmountingOnClose", !0);
+  }, t;
+}
+const Q = /* @__PURE__ */ o.createContext(void 0);
+process.env.NODE_ENV !== "production" && (Q.displayName = "TooltipProviderContext");
+function Ct() {
+  return o.useContext(Q);
+}
+const Pt = 600, ye = /* @__PURE__ */ o.forwardRef(function(e, t) {
+  const {
+    className: r,
+    render: f,
+    handle: a,
+    payload: c,
+    disabled: u,
+    delay: d,
+    closeDelay: p,
+    id: m,
+    ...i
+  } = e, l = H(!0), n = a?.store ?? l;
+  if (!n)
+    throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: <Tooltip.Trigger> must be either used within a <Tooltip.Root> component or provided with a handle." : F(82));
+  const y = tt(m), g = n.useState("isTriggerActive", y), T = n.useState("floatingRootContext"), h = n.useState("isOpenedByTrigger", y), C = o.useRef(null), b = d ?? Pt, S = p ?? 0, {
+    registerTrigger: x,
+    isMountedByThisTrigger: v
+  } = Ye(y, C, n, {
+    payload: c,
+    closeDelay: S
+  }), R = Ct(), {
+    delayRef: E,
+    isInstantPhase: w,
+    hasProvider: M
+  } = dt(T, {
+    open: h
+  });
+  n.useSyncedValue("isInstantPhase", w);
+  const P = n.useState("disabled"), L = u ?? P, I = n.useState("trackCursorAxis"), A = n.useState("disableHoverablePopup"), k = nt(T, {
+    enabled: !L,
+    mouseOnly: !0,
+    move: !1,
+    handleClose: !A && I !== "both" ? Ve() : null,
+    restMs() {
+      const G = R?.delay, U = typeof E.current == "object" ? E.current.open : void 0;
+      let X = b;
+      return M && (U !== 0 ? X = d ?? G ?? b : X = 0), X;
+    },
+    delay() {
+      const G = typeof E.current == "object" ? E.current.close : void 0;
+      let U = S;
+      return p == null && M && (U = G), {
+        close: U
+      };
+    },
+    triggerElementRef: C,
+    isActiveTrigger: g
+  }), V = o.useMemo(() => ({
+    open: h
+  }), [h]), j = n.useState("triggerProps", v);
+  return B("button", e, {
+    state: V,
+    ref: [t, x, C],
+    props: [k, j, {
+      id: y
+    }, i],
+    stateAttributesMapping: Ne
+  });
+});
+process.env.NODE_ENV !== "production" && (ye.displayName = "TooltipTrigger");
+const Z = /* @__PURE__ */ o.createContext(void 0);
+process.env.NODE_ENV !== "production" && (Z.displayName = "TooltipPortalContext");
+function Rt() {
+  const s = o.useContext(Z);
+  if (s === void 0)
+    throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: <Tooltip.Portal> is missing." : F(70));
+  return s;
+}
+const he = /* @__PURE__ */ o.forwardRef(function(e, t) {
+  const {
+    keepMounted: r = !1,
+    ...f
+  } = e;
+  return H().useState("mounted") || r ? /* @__PURE__ */ O(Z.Provider, {
+    value: r,
+    children: /* @__PURE__ */ O(st, {
+      ref: t,
+      ...f
+    })
+  }) : null;
+});
+process.env.NODE_ENV !== "production" && (he.displayName = "TooltipPortal");
+const ee = /* @__PURE__ */ o.createContext(void 0);
+process.env.NODE_ENV !== "production" && (ee.displayName = "TooltipPositionerContext");
+function ve() {
+  const s = o.useContext(ee);
+  if (s === void 0)
+    throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: TooltipPositionerContext is missing. TooltipPositioner parts must be placed within <Tooltip.Positioner>." : F(71));
+  return s;
+}
+const Te = /* @__PURE__ */ o.forwardRef(function(e, t) {
+  const {
+    render: r,
+    className: f,
+    anchor: a,
+    positionMethod: c = "absolute",
+    side: u = "top",
+    align: d = "center",
+    sideOffset: p = 0,
+    alignOffset: m = 0,
+    collisionBoundary: i = "clipping-ancestors",
+    collisionPadding: l = 5,
+    arrowPadding: n = 5,
+    sticky: y = !1,
+    disableAnchorTracking: g = !1,
+    collisionAvoidance: T = qe,
+    ...h
+  } = e, C = H(), b = Rt(), S = C.useState("open"), x = C.useState("mounted"), v = C.useState("trackCursorAxis"), R = C.useState("disableHoverablePopup"), E = C.useState("floatingRootContext"), w = C.useState("instantType"), M = C.useState("transitionStatus"), P = rt({
+    anchor: a,
+    positionMethod: c,
+    floatingRootContext: E,
+    mounted: x,
+    side: u,
+    sideOffset: p,
+    align: d,
+    alignOffset: m,
+    collisionBoundary: i,
+    collisionPadding: l,
+    sticky: y,
+    arrowPadding: n,
+    disableAnchorTracking: g,
+    keepMounted: b,
+    collisionAvoidance: T,
+    adaptiveOrigin: it
+  }), L = o.useMemo(() => {
+    const V = {};
+    return (!S || v === "both" || R) && (V.pointerEvents = "none"), {
+      role: "presentation",
+      hidden: !x,
+      style: {
+        ...P.positionerStyles,
+        ...V
+      }
+    };
+  }, [S, v, R, x, P.positionerStyles]), I = o.useMemo(() => ({
+    open: S,
+    side: P.side,
+    align: P.align,
+    anchorHidden: P.anchorHidden,
+    instant: v !== "none" ? "tracking-cursor" : w
+  }), [S, P.side, P.align, P.anchorHidden, v, w]), A = o.useMemo(() => ({
+    ...I,
+    arrowRef: P.arrowRef,
+    arrowStyles: P.arrowStyles,
+    arrowUncentered: P.arrowUncentered
+  }), [I, P.arrowRef, P.arrowStyles, P.arrowUncentered]), k = B("div", e, {
+    state: I,
+    props: [L, ge(M), h],
+    ref: [t, C.useStateSetter("positionerElement")],
+    stateAttributesMapping: $
+  });
+  return /* @__PURE__ */ O(ee.Provider, {
+    value: A,
+    children: k
+  });
+});
+process.env.NODE_ENV !== "production" && (Te.displayName = "TooltipPositioner");
+const Et = {
+  ...$,
+  ...ut
+}, Ce = /* @__PURE__ */ o.forwardRef(function(e, t) {
+  const {
+    className: r,
+    render: f,
+    ...a
+  } = e, c = H(), {
+    side: u,
+    align: d
+  } = ve(), p = c.useState("open"), m = c.useState("mounted"), i = c.useState("instantType"), l = c.useState("transitionStatus"), n = c.useState("popupProps"), y = c.useState("payload"), g = c.useState("popupElement"), T = c.useState("positionerElement"), h = c.useState("floatingRootContext"), C = ct();
+  at({
+    open: p,
+    ref: c.context.popupRef,
+    onComplete() {
+      p && c.context.onOpenChangeComplete?.(!0);
+    }
+  });
+  function b() {
+    h.context.events.emit("measure-layout");
+  }
+  function S(M, P) {
+    h.context.events.emit("measure-layout-complete", {
+      previousDimensions: M,
+      nextDimensions: P
+    });
+  }
+  const x = o.useCallback(() => c.context.triggerElements.size > 1, [c]);
+  lt({
+    popupElement: g,
+    positionerElement: T,
+    mounted: m,
+    content: y,
+    enabled: x,
+    onMeasureLayout: b,
+    onMeasureLayoutComplete: S,
+    side: u,
+    direction: C
+  });
+  const v = c.useState("disabled"), R = c.useState("closeDelay");
+  ot(h, {
+    enabled: !v,
+    closeDelay: R
+  });
+  const E = o.useMemo(() => ({
+    open: p,
+    side: u,
+    align: d,
+    instant: i,
+    transitionStatus: l
+  }), [p, u, d, i, l]);
+  return B("div", e, {
+    state: E,
+    ref: [t, c.context.popupRef, c.useStateSetter("popupElement")],
+    props: [n, ge(l), a],
+    stateAttributesMapping: Et
+  });
+});
+process.env.NODE_ENV !== "production" && (Ce.displayName = "TooltipPopup");
+const Pe = /* @__PURE__ */ o.forwardRef(function(e, t) {
+  const {
+    className: r,
+    render: f,
+    ...a
+  } = e, u = H().useState("instantType"), {
+    open: d,
+    arrowRef: p,
+    side: m,
+    align: i,
+    arrowUncentered: l,
+    arrowStyles: n
+  } = ve(), y = o.useMemo(() => ({
+    open: d,
+    side: m,
+    align: i,
+    uncentered: l,
+    instant: u
+  }), [d, m, i, l, u]);
+  return B("div", e, {
+    state: y,
+    ref: [t, p],
+    props: [{
+      style: n,
+      "aria-hidden": !0
+    }, a],
+    stateAttributesMapping: $
+  });
+});
+process.env.NODE_ENV !== "production" && (Pe.displayName = "TooltipArrow");
+const Re = function(e) {
+  const {
+    delay: t,
+    closeDelay: r,
+    timeout: f = 400
+  } = e, a = o.useMemo(() => ({
+    delay: t,
+    closeDelay: r
+  }), [t, r]), c = o.useMemo(() => ({
+    open: t,
+    close: r
+  }), [t, r]);
+  return /* @__PURE__ */ O(Q.Provider, {
+    value: a,
+    children: /* @__PURE__ */ O(pt, {
+      delay: c,
+      timeoutMs: f,
+      children: e.children
+    })
+  });
+};
+process.env.NODE_ENV !== "production" && (Re.displayName = "TooltipProvider");
+const qt = Re;
+function Jt({
+  children: s,
+  trigger: e,
+  align: t,
+  side: r,
+  className: f,
+  ...a
+}) {
+  return /* @__PURE__ */ ne(vt, { ...a, children: [
+    e ? /* @__PURE__ */ O(ye, { render: e }) : null,
+    /* @__PURE__ */ O(he, { children: /* @__PURE__ */ O(Te, { align: t, side: r, sideOffset: 8, children: /* @__PURE__ */ ne(
+      Ce,
+      {
+        render: /* @__PURE__ */ O(xe, { background: "highest" }),
+        className: Ee(
+          oe.tooltip,
+          De.transition_scale,
+          f
+        ),
+        children: [
+          /* @__PURE__ */ O(Pe, { className: oe.tooltip__arrow, children: /* @__PURE__ */ O(be, {}) }),
+          Se(s)
+        ]
+      }
+    ) }) })
+  ] });
+}
+export {
+  Jt as Tooltip,
+  qt as TooltipProvider
+};

package/dist/components/tooltip/tooltip-arrow.d.ts

@@ -0,0 +1,3 @@
+export declare function TooltipArrow(props: {
+    className?: string;
+}): import("react/jsx-runtime").JSX.Element;