@televet/kibble-ui 4.0.0-beta.64 → 4.0.0-beta.65

package/dist/chunks/tooltip.component-DgOzrNG3.js

@@ -0,0 +1,758 @@
+import { j as f } from "./jsx-runtime-C5mzlN2N.js";
+import { forwardRef as j, useId as Le, createContext as Se, useContext as De } from "react";
+import { c as Ae, f as R, u as ie, h as je, g as ee, d as Re, b as xe, i as Ve, j as Ie, k as _e, n as Fe, s as ae, l as le, m as ce, P as Ne } from "./use-locale-context-D-agiW5E.js";
+import { c as Ke } from "./create-slot-recipe-context-BJmsuxih.js";
+import { Y as E, Z as A, a2 as Z, au as $e, D as de, av as We, c as Be, y as ze, R as B, aw as Ge, b as qe, d as He, m as Ue } from "./index-CYk-7wwG.js";
+const [pe, x] = Ae({
+  name: "TooltipContext",
+  hookName: "useTooltipContext",
+  providerName: "<TooltipProvider />"
+}), ue = j((e, t) => {
+  const o = x(), n = E(o.getArrowProps(), e);
+  return /* @__PURE__ */ f.jsx(R.div, { ...n, ref: t });
+});
+ue.displayName = "TooltipArrow";
+const fe = j((e, t) => {
+  const o = x(), n = E(o.getArrowTipProps(), e);
+  return /* @__PURE__ */ f.jsx(R.div, { ...n, ref: t });
+});
+fe.displayName = "TooltipArrowTip";
+const ge = j((e, t) => {
+  const o = x(), n = ie(), r = E(o.getContentProps(), n.getPresenceProps(), e);
+  return n.unmounted ? null : /* @__PURE__ */ f.jsx(R.div, { ...r, ref: je(n.ref, t) });
+});
+ge.displayName = "TooltipContent";
+const ve = j((e, t) => {
+  const o = x(), n = E(o.getPositionerProps(), e);
+  return ie().unmounted ? null : /* @__PURE__ */ f.jsx(R.div, { ...n, ref: t });
+});
+ve.displayName = "TooltipPositioner";
+function Ye(e) {
+  return !(e.metaKey || !We() && e.altKey || e.ctrlKey || e.key === "Control" || e.key === "Shift" || e.key === "Meta");
+}
+var Ze = /* @__PURE__ */ new Set(["checkbox", "radio", "range", "color", "file", "image", "button", "submit", "reset"]);
+function Je(e, t, o) {
+  const n = o ? de(o) : null, r = A(n);
+  return e = e || n instanceof r.HTMLInputElement && !Ze.has(n?.type) || n instanceof r.HTMLTextAreaElement || n instanceof r.HTMLElement && n.isContentEditable, !(e && t === "keyboard" && o instanceof r.KeyboardEvent && !Reflect.has(Qe, o.key));
+}
+var T = null, G = /* @__PURE__ */ new Set(), D = /* @__PURE__ */ new Map(), k = !1, q = !1, Qe = {
+  Tab: !0,
+  Escape: !0
+};
+function $(e, t) {
+  for (let o of G)
+    o(e, t);
+}
+function N(e) {
+  k = !0, Ye(e) && (T = "keyboard", $("keyboard", e));
+}
+function P(e) {
+  T = "pointer", (e.type === "mousedown" || e.type === "pointerdown") && (k = !0, $("pointer", e));
+}
+function ye(e) {
+  $e(e) && (k = !0, T = "virtual");
+}
+function me(e) {
+  const t = de(e);
+  t === A(t) || t === Z(t) || (!k && !q && (T = "virtual", $("virtual", e)), k = !1, q = !1);
+}
+function Pe() {
+  k = !1, q = !0;
+}
+function Xe(e) {
+  if (typeof window > "u" || D.get(A(e)))
+    return;
+  const t = A(e), o = Z(e);
+  let n = t.HTMLElement.prototype.focus;
+  t.HTMLElement.prototype.focus = function() {
+    T = "virtual", $("virtual", null), k = !0, n.apply(this, arguments);
+  }, o.addEventListener("keydown", N, !0), o.addEventListener("keyup", N, !0), o.addEventListener("click", ye, !0), t.addEventListener("focus", me, !0), t.addEventListener("blur", Pe, !1), typeof t.PointerEvent < "u" ? (o.addEventListener("pointerdown", P, !0), o.addEventListener("pointermove", P, !0), o.addEventListener("pointerup", P, !0)) : (o.addEventListener("mousedown", P, !0), o.addEventListener("mousemove", P, !0), o.addEventListener("mouseup", P, !0)), t.addEventListener(
+    "beforeunload",
+    () => {
+      et(e);
+    },
+    { once: !0 }
+  ), D.set(t, { focus: n });
+}
+var et = (e, t) => {
+  const o = A(e), n = Z(e);
+  D.has(o) && (o.HTMLElement.prototype.focus = D.get(o).focus, n.removeEventListener("keydown", N, !0), n.removeEventListener("keyup", N, !0), n.removeEventListener("click", ye, !0), o.removeEventListener("focus", me, !0), o.removeEventListener("blur", Pe, !1), typeof o.PointerEvent < "u" ? (n.removeEventListener("pointerdown", P, !0), n.removeEventListener("pointermove", P, !0), n.removeEventListener("pointerup", P, !0)) : (n.removeEventListener("mousedown", P, !0), n.removeEventListener("mousemove", P, !0), n.removeEventListener("mouseup", P, !0)), D.delete(o));
+};
+function H() {
+  return T === "keyboard";
+}
+function tt(e = {}) {
+  const { isTextInput: t, autoFocus: o, onChange: n, root: r } = e;
+  Xe(r), n?.({ isFocusVisible: o || H(), modality: T });
+  const c = (p, a) => {
+    Je(!!t, p, a) && n?.({ isFocusVisible: H(), modality: p });
+  };
+  return G.add(c), () => {
+    G.delete(c);
+  };
+}
+const ot = Symbol(), te = Object.getPrototypeOf, U = /* @__PURE__ */ new WeakMap(), nt = (e) => e && (U.has(e) ? U.get(e) : te(e) === Object.prototype || te(e) === Array.prototype), rt = (e) => nt(e) && e[ot] || null, oe = (e, t = !0) => {
+  U.set(e, t);
+};
+function st() {
+  if (typeof globalThis < "u") return globalThis;
+  if (typeof self < "u") return self;
+  if (typeof window < "u") return window;
+  if (typeof global < "u") return global;
+}
+function Oe(e, t) {
+  const o = st();
+  return o ? (o[e] || (o[e] = t()), o[e]) : t();
+}
+var F = Oe("__zag__refSet", () => /* @__PURE__ */ new WeakSet()), it = (e) => typeof e == "object" && e !== null && "$$typeof" in e && "props" in e, at = (e) => typeof e == "object" && e !== null && "__v_isVNode" in e, lt = (e) => typeof e == "object" && e !== null && "nodeType" in e && typeof e.nodeName == "string", ct = (e) => it(e) || at(e) || lt(e), Y = (e) => e !== null && typeof e == "object", ne = (e) => Y(e) && !F.has(e) && (Array.isArray(e) || !(Symbol.iterator in e)) && !ct(e) && !(e instanceof WeakMap) && !(e instanceof WeakSet) && !(e instanceof Error) && !(e instanceof Number) && !(e instanceof Date) && !(e instanceof String) && !(e instanceof RegExp) && !(e instanceof ArrayBuffer) && !(e instanceof Promise), K = () => process.env.NODE_ENV !== "production", b = Oe("__zag__proxyStateMap", () => /* @__PURE__ */ new WeakMap()), dt = (e = Object.is, t = (a, v) => new Proxy(a, v), o = /* @__PURE__ */ new WeakMap(), n = (a, v) => {
+  const y = o.get(a);
+  if (y?.[0] === v)
+    return y[1];
+  const u = Array.isArray(a) ? [] : Object.create(Object.getPrototypeOf(a));
+  return oe(u, !0), o.set(a, [v, u]), Reflect.ownKeys(a).forEach((O) => {
+    const m = Reflect.get(a, O);
+    F.has(m) ? (oe(m, !1), u[O] = m) : b.has(m) ? u[O] = ft(m) : u[O] = m;
+  }), Object.freeze(u);
+}, r = /* @__PURE__ */ new WeakMap(), c = [1, 1], p = (a) => {
+  if (!Y(a))
+    throw new Error("object required");
+  const v = r.get(a);
+  if (v)
+    return v;
+  let y = c[0];
+  const u = /* @__PURE__ */ new Set(), O = (i, s = ++c[0]) => {
+    y !== s && (y = s, u.forEach((l) => l(i, s)));
+  };
+  let m = c[1];
+  const w = (i = ++c[1]) => (m !== i && !u.size && (m = i, d.forEach(([s]) => {
+    const l = s[1](i);
+    l > y && (y = l);
+  })), y), C = (i) => (s, l) => {
+    const g = [...s];
+    g[1] = [i, ...g[1]], O(g, l);
+  }, d = /* @__PURE__ */ new Map(), J = (i, s) => {
+    if (K() && d.has(i))
+      throw new Error("prop listener already exists");
+    if (u.size) {
+      const l = s[3](C(i));
+      d.set(i, [s, l]);
+    } else
+      d.set(i, [s]);
+  }, Q = (i) => {
+    const s = d.get(i);
+    s && (d.delete(i), s[1]?.());
+  }, Ce = (i) => (u.add(i), u.size === 1 && d.forEach(([l, g], M) => {
+    if (K() && g)
+      throw new Error("remove already exists");
+    const L = l[3](C(M));
+    d.set(M, [l, L]);
+  }), () => {
+    u.delete(i), u.size === 0 && d.forEach(([l, g], M) => {
+      g && (g(), d.set(M, [l]));
+    });
+  }), W = Array.isArray(a) ? [] : Object.create(Object.getPrototypeOf(a)), I = t(W, {
+    deleteProperty(i, s) {
+      const l = Reflect.get(i, s);
+      Q(s);
+      const g = Reflect.deleteProperty(i, s);
+      return g && O(["delete", [s], l]), g;
+    },
+    set(i, s, l, g) {
+      const M = Reflect.has(i, s), L = Reflect.get(i, s, g);
+      if (M && (e(L, l) || r.has(l) && e(L, r.get(l))))
+        return !0;
+      Q(s), Y(l) && (l = rt(l) || l);
+      let _ = l;
+      if (!Object.getOwnPropertyDescriptor(i, s)?.set) {
+        !b.has(l) && ne(l) && (_ = we(l));
+        const X = !F.has(_) && b.get(_);
+        X && J(s, X);
+      }
+      return Reflect.set(i, s, _, g), O(["set", [s], l, L]), !0;
+    }
+  });
+  r.set(a, I);
+  const Me = [W, w, n, Ce];
+  return b.set(I, Me), Reflect.ownKeys(a).forEach((i) => {
+    const s = Object.getOwnPropertyDescriptor(a, i);
+    s.get || s.set ? Object.defineProperty(W, i, s) : I[i] = a[i];
+  }), I;
+}) => [
+  // public functions
+  p,
+  // shared state
+  b,
+  F,
+  // internal things
+  e,
+  t,
+  ne,
+  o,
+  n,
+  r,
+  c
+], [pt] = dt();
+function we(e = {}) {
+  return pt(e);
+}
+function ut(e, t, o) {
+  const n = b.get(e);
+  K() && !n && console.warn("Please use proxy object");
+  let r;
+  const c = [], p = n[3];
+  let a = !1;
+  const y = p((u) => {
+    c.push(u), r || (r = Promise.resolve().then(() => {
+      r = void 0, a && t(c.splice(0));
+    }));
+  });
+  return a = !0, () => {
+    a = !1, y();
+  };
+}
+function ft(e) {
+  const t = b.get(e);
+  K() && !t && console.warn("Please use proxy object");
+  const [o, n, r] = t;
+  return r(o, n());
+}
+var gt = qe("tooltip").parts("trigger", "arrow", "arrowTip", "positioner", "content"), S = gt.build(), he = (e) => e.ids?.trigger ?? `tooltip:${e.id}:trigger`, vt = (e) => e.ids?.content ?? `tooltip:${e.id}:content`, yt = (e) => e.ids?.arrow ?? `tooltip:${e.id}:arrow`, be = (e) => e.ids?.positioner ?? `tooltip:${e.id}:popper`, z = (e) => e.getById(he(e)), re = (e) => e.getById(be(e)), h = we({ id: null });
+function mt(e, t) {
+  const { state: o, context: n, send: r, scope: c, prop: p, event: a } = e, v = p("id"), y = !!p("aria-label"), u = o.matches("open", "closing"), O = he(c), m = vt(c), w = p("disabled"), C = Re({
+    ...p("positioning"),
+    placement: n.get("currentPlacement")
+  });
+  return {
+    open: u,
+    setOpen(d) {
+      o.matches("open", "closing") !== d && r({ type: d ? "open" : "close" });
+    },
+    reposition(d = {}) {
+      r({ type: "positioning.set", options: d });
+    },
+    getTriggerProps() {
+      return t.button({
+        ...S.trigger.attrs,
+        id: O,
+        dir: p("dir"),
+        "data-expanded": He(u),
+        "data-state": u ? "open" : "closed",
+        "aria-describedby": u ? m : void 0,
+        onClick(d) {
+          d.defaultPrevented || w || p("closeOnClick") && r({ type: "close", src: "trigger.click" });
+        },
+        onFocus(d) {
+          queueMicrotask(() => {
+            d.defaultPrevented || w || a.src !== "trigger.pointerdown" && H() && r({ type: "open", src: "trigger.focus" });
+          });
+        },
+        onBlur(d) {
+          d.defaultPrevented || w || v === h.id && r({ type: "close", src: "trigger.blur" });
+        },
+        onPointerDown(d) {
+          d.defaultPrevented || w || p("closeOnPointerDown") && v === h.id && r({ type: "close", src: "trigger.pointerdown" });
+        },
+        onPointerMove(d) {
+          d.defaultPrevented || w || d.pointerType !== "touch" && r({ type: "pointer.move" });
+        },
+        onPointerLeave() {
+          w || r({ type: "pointer.leave" });
+        },
+        onPointerCancel() {
+          w || r({ type: "pointer.leave" });
+        }
+      });
+    },
+    getArrowProps() {
+      return t.element({
+        id: yt(c),
+        ...S.arrow.attrs,
+        dir: p("dir"),
+        style: C.arrow
+      });
+    },
+    getArrowTipProps() {
+      return t.element({
+        ...S.arrowTip.attrs,
+        dir: p("dir"),
+        style: C.arrowTip
+      });
+    },
+    getPositionerProps() {
+      return t.element({
+        id: be(c),
+        ...S.positioner.attrs,
+        dir: p("dir"),
+        style: C.floating
+      });
+    },
+    getContentProps() {
+      return t.element({
+        ...S.content.attrs,
+        dir: p("dir"),
+        hidden: !u,
+        "data-state": u ? "open" : "closed",
+        role: y ? void 0 : "tooltip",
+        id: y ? void 0 : m,
+        "data-placement": n.get("currentPlacement"),
+        onPointerEnter() {
+          r({ type: "content.pointer.move" });
+        },
+        onPointerLeave() {
+          r({ type: "content.pointer.leave" });
+        },
+        style: {
+          pointerEvents: p("interactive") ? "auto" : "none"
+        }
+      });
+    }
+  };
+}
+var { and: Pt, not: se } = ze(), Ot = Be({
+  initialState: ({ prop: e }) => e("open") || e("defaultOpen") ? "open" : "closed",
+  props({ props: e }) {
+    return {
+      id: "x",
+      openDelay: 1e3,
+      closeDelay: 500,
+      closeOnPointerDown: !0,
+      closeOnEscape: !0,
+      interactive: !1,
+      closeOnScroll: !0,
+      closeOnClick: !0,
+      disabled: !1,
+      ...e,
+      positioning: {
+        placement: "bottom",
+        ...e.positioning
+      }
+    };
+  },
+  effects: ["trackFocusVisible", "trackStore"],
+  context: ({ bindable: e }) => ({
+    currentPlacement: e(() => ({ defaultValue: void 0 })),
+    hasPointerMoveOpened: e(() => ({ defaultValue: !1 }))
+  }),
+  watch({ track: e, action: t, prop: o }) {
+    e([() => o("disabled")], () => {
+      t(["closeIfDisabled"]);
+    }), e([() => o("open")], () => {
+      t(["toggleVisibility"]);
+    });
+  },
+  states: {
+    closed: {
+      entry: ["clearGlobalId"],
+      on: {
+        "controlled.open": {
+          target: "open"
+        },
+        open: [
+          {
+            guard: "isOpenControlled",
+            actions: ["invokeOnOpen"]
+          },
+          {
+            target: "open",
+            actions: ["invokeOnOpen"]
+          }
+        ],
+        "pointer.leave": {
+          actions: ["clearPointerMoveOpened"]
+        },
+        "pointer.move": [
+          {
+            guard: Pt("noVisibleTooltip", se("hasPointerMoveOpened")),
+            target: "opening"
+          },
+          {
+            guard: se("hasPointerMoveOpened"),
+            target: "open",
+            actions: ["setPointerMoveOpened", "invokeOnOpen"]
+          }
+        ]
+      }
+    },
+    opening: {
+      effects: ["trackScroll", "trackPointerlockChange", "waitForOpenDelay"],
+      on: {
+        "after.openDelay": [
+          {
+            guard: "isOpenControlled",
+            actions: ["setPointerMoveOpened", "invokeOnOpen"]
+          },
+          {
+            target: "open",
+            actions: ["setPointerMoveOpened", "invokeOnOpen"]
+          }
+        ],
+        "controlled.open": {
+          target: "open"
+        },
+        "controlled.close": {
+          target: "closed"
+        },
+        open: [
+          {
+            guard: "isOpenControlled",
+            actions: ["invokeOnOpen"]
+          },
+          {
+            target: "open",
+            actions: ["invokeOnOpen"]
+          }
+        ],
+        "pointer.leave": [
+          {
+            guard: "isOpenControlled",
+            // We trigger toggleVisibility manually since the `ctx.open` has not changed yet (at this point)
+            actions: ["clearPointerMoveOpened", "invokeOnClose", "toggleVisibility"]
+          },
+          {
+            target: "closed",
+            actions: ["clearPointerMoveOpened", "invokeOnClose"]
+          }
+        ],
+        close: [
+          {
+            guard: "isOpenControlled",
+            // We trigger toggleVisibility manually since the `ctx.open` has not changed yet (at this point)
+            actions: ["invokeOnClose", "toggleVisibility"]
+          },
+          {
+            target: "closed",
+            actions: ["invokeOnClose"]
+          }
+        ]
+      }
+    },
+    open: {
+      effects: ["trackEscapeKey", "trackScroll", "trackPointerlockChange", "trackPositioning"],
+      entry: ["setGlobalId"],
+      on: {
+        "controlled.close": {
+          target: "closed"
+        },
+        close: [
+          {
+            guard: "isOpenControlled",
+            actions: ["invokeOnClose"]
+          },
+          {
+            target: "closed",
+            actions: ["invokeOnClose"]
+          }
+        ],
+        "pointer.leave": [
+          {
+            guard: "isVisible",
+            target: "closing",
+            actions: ["clearPointerMoveOpened"]
+          },
+          // == group ==
+          {
+            guard: "isOpenControlled",
+            actions: ["clearPointerMoveOpened", "invokeOnClose"]
+          },
+          {
+            target: "closed",
+            actions: ["clearPointerMoveOpened", "invokeOnClose"]
+          }
+        ],
+        "content.pointer.leave": {
+          guard: "isInteractive",
+          target: "closing"
+        },
+        "positioning.set": {
+          actions: ["reposition"]
+        }
+      }
+    },
+    closing: {
+      effects: ["trackPositioning", "waitForCloseDelay"],
+      on: {
+        "after.closeDelay": [
+          {
+            guard: "isOpenControlled",
+            actions: ["invokeOnClose"]
+          },
+          {
+            target: "closed",
+            actions: ["invokeOnClose"]
+          }
+        ],
+        "controlled.close": {
+          target: "closed"
+        },
+        "controlled.open": {
+          target: "open"
+        },
+        close: [
+          {
+            guard: "isOpenControlled",
+            actions: ["invokeOnClose"]
+          },
+          {
+            target: "closed",
+            actions: ["invokeOnClose"]
+          }
+        ],
+        "pointer.move": [
+          {
+            guard: "isOpenControlled",
+            // We trigger toggleVisibility manually since the `ctx.open` has not changed yet (at this point)
+            actions: ["setPointerMoveOpened", "invokeOnOpen", "toggleVisibility"]
+          },
+          {
+            target: "open",
+            actions: ["setPointerMoveOpened", "invokeOnOpen"]
+          }
+        ],
+        "content.pointer.move": {
+          guard: "isInteractive",
+          target: "open"
+        },
+        "positioning.set": {
+          actions: ["reposition"]
+        }
+      }
+    }
+  },
+  implementations: {
+    guards: {
+      noVisibleTooltip: () => h.id === null,
+      isVisible: ({ prop: e }) => e("id") === h.id,
+      isInteractive: ({ prop: e }) => !!e("interactive"),
+      hasPointerMoveOpened: ({ context: e }) => e.get("hasPointerMoveOpened"),
+      isOpenControlled: ({ prop: e }) => e("open") !== void 0
+    },
+    actions: {
+      setGlobalId: ({ prop: e }) => {
+        h.id = e("id");
+      },
+      clearGlobalId: ({ prop: e }) => {
+        e("id") === h.id && (h.id = null);
+      },
+      invokeOnOpen: ({ prop: e }) => {
+        e("onOpenChange")?.({ open: !0 });
+      },
+      invokeOnClose: ({ prop: e }) => {
+        e("onOpenChange")?.({ open: !1 });
+      },
+      closeIfDisabled: ({ prop: e, send: t }) => {
+        e("disabled") && t({ type: "close", src: "disabled.change" });
+      },
+      reposition: ({ context: e, event: t, prop: o, scope: n }) => {
+        if (t.type !== "positioning.set") return;
+        const r = () => re(n);
+        return ee(z(n), r, {
+          ...o("positioning"),
+          ...t.options,
+          defer: !0,
+          listeners: !1,
+          onComplete(c) {
+            e.set("currentPlacement", c.placement);
+          }
+        });
+      },
+      toggleVisibility: ({ prop: e, event: t, send: o }) => {
+        queueMicrotask(() => {
+          o({
+            type: e("open") ? "controlled.open" : "controlled.close",
+            previousEvent: t
+          });
+        });
+      },
+      setPointerMoveOpened: ({ context: e }) => {
+        e.set("hasPointerMoveOpened", !0);
+      },
+      clearPointerMoveOpened: ({ context: e }) => {
+        e.set("hasPointerMoveOpened", !1);
+      }
+    },
+    effects: {
+      trackFocusVisible: ({ scope: e }) => tt({ root: e.getRootNode?.() }),
+      trackPositioning: ({ context: e, prop: t, scope: o }) => {
+        e.get("currentPlacement") || e.set("currentPlacement", t("positioning").placement);
+        const n = () => re(o);
+        return ee(z(o), n, {
+          ...t("positioning"),
+          defer: !0,
+          onComplete(r) {
+            e.set("currentPlacement", r.placement);
+          }
+        });
+      },
+      trackPointerlockChange: ({ send: e, scope: t }) => {
+        const o = t.getDoc();
+        return B(o, "pointerlockchange", () => e({ type: "close", src: "pointerlock:change" }), !1);
+      },
+      trackScroll: ({ send: e, prop: t, scope: o }) => {
+        if (!t("closeOnScroll")) return;
+        const n = z(o);
+        if (!n) return;
+        const c = Ge(n).map((p) => B(p, "scroll", () => {
+          e({ type: "close", src: "scroll" });
+        }, {
+          passive: !0,
+          capture: !0
+        }));
+        return () => {
+          c.forEach((p) => p?.());
+        };
+      },
+      trackStore: ({ prop: e, send: t }) => {
+        let o;
+        return queueMicrotask(() => {
+          o = ut(h, () => {
+            h.id !== e("id") && t({ type: "close", src: "id.change" });
+          });
+        }), () => o?.();
+      },
+      trackEscapeKey: ({ send: e, prop: t }) => t("closeOnEscape") ? B(document, "keydown", (n) => {
+        Ue(n) || n.key === "Escape" && (n.stopPropagation(), e({ type: "close", src: "keydown.escape" }));
+      }, !0) : void 0,
+      waitForOpenDelay: ({ send: e, prop: t }) => {
+        const o = setTimeout(() => {
+          e({ type: "after.openDelay" });
+        }, t("openDelay"));
+        return () => clearTimeout(o);
+      },
+      waitForCloseDelay: ({ send: e, prop: t }) => {
+        const o = setTimeout(() => {
+          e({ type: "after.closeDelay" });
+        }, t("closeDelay"));
+        return () => clearTimeout(o);
+      }
+    }
+  }
+});
+xe()([
+  "aria-label",
+  "closeDelay",
+  "closeOnEscape",
+  "closeOnPointerDown",
+  "closeOnScroll",
+  "closeOnClick",
+  "dir",
+  "disabled",
+  "getRootNode",
+  "id",
+  "ids",
+  "interactive",
+  "onOpenChange",
+  "defaultOpen",
+  "open",
+  "openDelay",
+  "positioning"
+]);
+const wt = (e) => {
+  const t = Le(), { getRootNode: o } = Ve(), { dir: n } = Ie(), r = {
+    id: t,
+    dir: n,
+    getRootNode: o,
+    ...e
+  }, c = _e(Ot, r);
+  return mt(c, Fe);
+}, ht = (e) => {
+  const [t, { children: o, ...n }] = ae(e), r = wt(n), c = le(E({ present: r.open }, t));
+  return /* @__PURE__ */ f.jsx(pe, { value: r, children: /* @__PURE__ */ f.jsx(ce, { value: c, children: o }) });
+}, bt = (e) => {
+  const [t, { value: o, children: n }] = ae(e), r = le(E({ present: o.open }, t));
+  return /* @__PURE__ */ f.jsx(pe, { value: o, children: /* @__PURE__ */ f.jsx(ce, { value: r, children: n }) });
+}, ke = j((e, t) => {
+  const o = x(), n = E(o.getTriggerProps(), e);
+  return /* @__PURE__ */ f.jsx(R.button, { ...n, ref: t });
+});
+ke.displayName = "TooltipTrigger";
+const {
+  withRootProvider: Ee,
+  withContext: V
+} = Ke({ key: "tooltip" });
+Ee(
+  bt
+);
+const kt = Ee(ht, {
+  defaultProps: { lazyMount: !0, unmountOnExit: !0 }
+}), Et = V(ke, "trigger", { forwardAsChild: !0 }), Tt = V(ve, "positioner", { forwardAsChild: !0 }), Ct = V(
+  ge,
+  "content",
+  { forwardAsChild: !0 }
+), Te = V(fe, "arrowTip", { forwardAsChild: !0 }), Mt = V(
+  ue,
+  "arrow",
+  { forwardAsChild: !0, defaultProps: { children: /* @__PURE__ */ f.jsx(Te, {}) } }
+), Lt = Se(
+  void 0
+), St = () => {
+  const e = De(Lt);
+  return e === void 0 ? { contentRef: null } : e;
+}, Dt = ({
+  children: e,
+  disabled: t = !1,
+  openDelay: o = 350,
+  placement: n = "top",
+  positioning: r,
+  portalled: c = !0,
+  label: p,
+  ...a
+}) => {
+  const { contentRef: v } = St();
+  return e ? t ? /* @__PURE__ */ f.jsx(f.Fragment, { children: "children" }) : /* @__PURE__ */ f.jsxs(
+    kt,
+    {
+      positioning: {
+        ...r,
+        placement: r?.placement || n
+      },
+      openDelay: o,
+      ...a,
+      children: [
+        /* @__PURE__ */ f.jsx(
+          Et,
+          {
+            asChild: !0,
+            className: "Tooltip__Trigger",
+            "data-testid": "kibble-tooltip-trigger",
+            display: "inline-block",
+            children: e
+          }
+        ),
+        /* @__PURE__ */ f.jsx(Ne, { disabled: !c, container: v || void 0, children: /* @__PURE__ */ f.jsx(Tt, { className: "Tooltip", "data-testid": "kibble-tooltip", children: /* @__PURE__ */ f.jsxs(
+          Ct,
+          {
+            className: "Tooltip__Content",
+            "data-testid": "kibble-tooltip-content",
+            fontSize: "sm",
+            p: 2,
+            color: "text.contrast",
+            css: { "--tooltip-bg": "colors.background.overlay.contrast" },
+            zIndex: "tooltipExtra",
+            children: [
+              /* @__PURE__ */ f.jsx(
+                Mt,
+                {
+                  className: "Tooltip__Arrow",
+                  "data-testid": "kibble-tooltip-arrow",
+                  css: { "--arrow-size": "10px" },
+                  children: /* @__PURE__ */ f.jsx(Te, {})
+                }
+              ),
+              p
+            ]
+          }
+        ) }) })
+      ]
+    }
+  ) : /* @__PURE__ */ f.jsx(f.Fragment, {});
+};
+Dt.displayName = "Tooltip";
+export {
+  Lt as M,
+  Dt as T,
+  gt as a,
+  H as i,
+  tt as t,
+  St as u
+};
+//# sourceMappingURL=tooltip.component-DgOzrNG3.js.map