@televet/kibble-ui 4.0.0-beta.73 → 4.0.0-beta.76

package/dist/chunks/withTruncation-BAxxp5gA.js

@@ -0,0 +1,822 @@
+import { j as f } from "./jsx-runtime-C5mzlN2N.js";
+import { forwardRef as L, useId as De, memo as ee, useState as Ae, useRef as te, useCallback as Re, useEffect as Ne } from "react";
+import { B as _e } from "./box-Ck9I7FYv.js";
+import { c as Ve } from "./create-recipe-context-D7FewUR4.js";
+import { c as Ie, f as A, u as le, h as Fe, g as oe, d as We, b as $e, i as Ke, j as Be, k as ze, n as Ge, s as ce, l as de, m as pe, P as He } from "./use-locale-context-KeBTTMq9.js";
+import { c as qe } from "./create-slot-recipe-context-BJmsuxih.js";
+import { Y as E, Z as D, a2 as Z, b2 as Ue, D as ue, b3 as Ye, c as Ze, y as Je, R as B, b4 as Qe, b as Xe, d as et, m as tt } from "./index-Czx27hGN.js";
+const { withContext: ot } = Ve({
+  key: "text"
+}), nt = ot("p"), [fe, R] = Ie({
+  name: "TooltipContext",
+  hookName: "useTooltipContext",
+  providerName: "<TooltipProvider />"
+}), ge = L((e, t) => {
+  const o = R(), n = E(o.getArrowProps(), e);
+  return /* @__PURE__ */ f.jsx(A.div, { ...n, ref: t });
+});
+ge.displayName = "TooltipArrow";
+const ve = L((e, t) => {
+  const o = R(), n = E(o.getArrowTipProps(), e);
+  return /* @__PURE__ */ f.jsx(A.div, { ...n, ref: t });
+});
+ve.displayName = "TooltipArrowTip";
+const me = L((e, t) => {
+  const o = R(), n = le(), r = E(o.getContentProps(), n.getPresenceProps(), e);
+  return n.unmounted ? null : /* @__PURE__ */ f.jsx(A.div, { ...r, ref: Fe(n.ref, t) });
+});
+me.displayName = "TooltipContent";
+const ye = L((e, t) => {
+  const o = R(), n = E(o.getPositionerProps(), e);
+  return le().unmounted ? null : /* @__PURE__ */ f.jsx(A.div, { ...n, ref: t });
+});
+ye.displayName = "TooltipPositioner";
+function rt(e) {
+  return !(e.metaKey || !Ye() && e.altKey || e.ctrlKey || e.key === "Control" || e.key === "Shift" || e.key === "Meta");
+}
+var it = /* @__PURE__ */ new Set(["checkbox", "radio", "range", "color", "file", "image", "button", "submit", "reset"]);
+function st(e, t, o) {
+  const n = o ? ue(o) : null, r = D(n);
+  return e = e || n instanceof r.HTMLInputElement && !it.has(n?.type) || n instanceof r.HTMLTextAreaElement || n instanceof r.HTMLElement && n.isContentEditable, !(e && t === "keyboard" && o instanceof r.KeyboardEvent && !Reflect.has(at, o.key));
+}
+var C = null, G = /* @__PURE__ */ new Set(), j = /* @__PURE__ */ new Map(), k = !1, H = !1, at = {
+  Tab: !0,
+  Escape: !0
+};
+function $(e, t) {
+  for (let o of G)
+    o(e, t);
+}
+function F(e) {
+  k = !0, rt(e) && (C = "keyboard", $("keyboard", e));
+}
+function w(e) {
+  C = "pointer", (e.type === "mousedown" || e.type === "pointerdown") && (k = !0, $("pointer", e));
+}
+function Pe(e) {
+  Ue(e) && (k = !0, C = "virtual");
+}
+function Oe(e) {
+  const t = ue(e);
+  t === D(t) || t === Z(t) || (!k && !H && (C = "virtual", $("virtual", e)), k = !1, H = !1);
+}
+function we() {
+  k = !1, H = !0;
+}
+function lt(e) {
+  if (typeof window > "u" || j.get(D(e)))
+    return;
+  const t = D(e), o = Z(e);
+  let n = t.HTMLElement.prototype.focus;
+  t.HTMLElement.prototype.focus = function() {
+    C = "virtual", $("virtual", null), k = !0, n.apply(this, arguments);
+  }, o.addEventListener("keydown", F, !0), o.addEventListener("keyup", F, !0), o.addEventListener("click", Pe, !0), t.addEventListener("focus", Oe, !0), t.addEventListener("blur", we, !1), typeof t.PointerEvent < "u" ? (o.addEventListener("pointerdown", w, !0), o.addEventListener("pointermove", w, !0), o.addEventListener("pointerup", w, !0)) : (o.addEventListener("mousedown", w, !0), o.addEventListener("mousemove", w, !0), o.addEventListener("mouseup", w, !0)), t.addEventListener(
+    "beforeunload",
+    () => {
+      ct(e);
+    },
+    { once: !0 }
+  ), j.set(t, { focus: n });
+}
+var ct = (e, t) => {
+  const o = D(e), n = Z(e);
+  j.has(o) && (o.HTMLElement.prototype.focus = j.get(o).focus, n.removeEventListener("keydown", F, !0), n.removeEventListener("keyup", F, !0), n.removeEventListener("click", Pe, !0), o.removeEventListener("focus", Oe, !0), o.removeEventListener("blur", we, !1), typeof o.PointerEvent < "u" ? (n.removeEventListener("pointerdown", w, !0), n.removeEventListener("pointermove", w, !0), n.removeEventListener("pointerup", w, !0)) : (n.removeEventListener("mousedown", w, !0), n.removeEventListener("mousemove", w, !0), n.removeEventListener("mouseup", w, !0)), j.delete(o));
+};
+function q() {
+  return C === "keyboard";
+}
+function dt(e = {}) {
+  const { isTextInput: t, autoFocus: o, onChange: n, root: r } = e;
+  lt(r), n?.({ isFocusVisible: o || q(), modality: C });
+  const l = (d, s) => {
+    st(!!t, d, s) && n?.({ isFocusVisible: q(), modality: d });
+  };
+  return G.add(l), () => {
+    G.delete(l);
+  };
+}
+const pt = Symbol(), ne = Object.getPrototypeOf, U = /* @__PURE__ */ new WeakMap(), ut = (e) => e && (U.has(e) ? U.get(e) : ne(e) === Object.prototype || ne(e) === Array.prototype), ft = (e) => ut(e) && e[pt] || null, re = (e, t = !0) => {
+  U.set(e, t);
+};
+function gt() {
+  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 be(e, t) {
+  const o = gt();
+  return o ? (o[e] || (o[e] = t()), o[e]) : t();
+}
+var I = be("__zag__refSet", () => /* @__PURE__ */ new WeakSet()), vt = (e) => typeof e == "object" && e !== null && "$$typeof" in e && "props" in e, mt = (e) => typeof e == "object" && e !== null && "__v_isVNode" in e, yt = (e) => typeof e == "object" && e !== null && "nodeType" in e && typeof e.nodeName == "string", Pt = (e) => vt(e) || mt(e) || yt(e), Y = (e) => e !== null && typeof e == "object", ie = (e) => Y(e) && !I.has(e) && (Array.isArray(e) || !(Symbol.iterator in e)) && !Pt(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), W = () => process.env.NODE_ENV !== "production", T = be("__zag__proxyStateMap", () => /* @__PURE__ */ new WeakMap()), Ot = (e = Object.is, t = (s, m) => new Proxy(s, m), o = /* @__PURE__ */ new WeakMap(), n = (s, m) => {
+  const g = o.get(s);
+  if (g?.[0] === m)
+    return g[1];
+  const c = Array.isArray(s) ? [] : Object.create(Object.getPrototypeOf(s));
+  return re(c, !0), o.set(s, [m, c]), Reflect.ownKeys(s).forEach((y) => {
+    const v = Reflect.get(s, y);
+    I.has(v) ? (re(v, !1), c[y] = v) : T.has(v) ? c[y] = ht(v) : c[y] = v;
+  }), Object.freeze(c);
+}, r = /* @__PURE__ */ new WeakMap(), l = [1, 1], d = (s) => {
+  if (!Y(s))
+    throw new Error("object required");
+  const m = r.get(s);
+  if (m)
+    return m;
+  let g = l[0];
+  const c = /* @__PURE__ */ new Set(), y = (a, i = ++l[0]) => {
+    g !== i && (g = i, c.forEach((p) => p(a, i)));
+  };
+  let v = l[1];
+  const P = (a = ++l[1]) => (v !== a && !c.size && (v = a, u.forEach(([i]) => {
+    const p = i[1](a);
+    p > g && (g = p);
+  })), g), b = (a) => (i, p) => {
+    const O = [...i];
+    O[1] = [a, ...O[1]], y(O, p);
+  }, u = /* @__PURE__ */ new Map(), J = (a, i) => {
+    if (W() && u.has(a))
+      throw new Error("prop listener already exists");
+    if (c.size) {
+      const p = i[3](b(a));
+      u.set(a, [i, p]);
+    } else
+      u.set(a, [i]);
+  }, Q = (a) => {
+    const i = u.get(a);
+    i && (u.delete(a), i[1]?.());
+  }, Se = (a) => (c.add(a), c.size === 1 && u.forEach(([p, O], M) => {
+    if (W() && O)
+      throw new Error("remove already exists");
+    const x = p[3](b(M));
+    u.set(M, [p, x]);
+  }), () => {
+    c.delete(a), c.size === 0 && u.forEach(([p, O], M) => {
+      O && (O(), u.set(M, [p]));
+    });
+  }), K = Array.isArray(s) ? [] : Object.create(Object.getPrototypeOf(s)), _ = t(K, {
+    deleteProperty(a, i) {
+      const p = Reflect.get(a, i);
+      Q(i);
+      const O = Reflect.deleteProperty(a, i);
+      return O && y(["delete", [i], p]), O;
+    },
+    set(a, i, p, O) {
+      const M = Reflect.has(a, i), x = Reflect.get(a, i, O);
+      if (M && (e(x, p) || r.has(p) && e(x, r.get(p))))
+        return !0;
+      Q(i), Y(p) && (p = ft(p) || p);
+      let V = p;
+      if (!Object.getOwnPropertyDescriptor(a, i)?.set) {
+        !T.has(p) && ie(p) && (V = he(p));
+        const X = !I.has(V) && T.get(V);
+        X && J(i, X);
+      }
+      return Reflect.set(a, i, V, O), y(["set", [i], p, x]), !0;
+    }
+  });
+  r.set(s, _);
+  const je = [K, P, n, Se];
+  return T.set(_, je), Reflect.ownKeys(s).forEach((a) => {
+    const i = Object.getOwnPropertyDescriptor(s, a);
+    i.get || i.set ? Object.defineProperty(K, a, i) : _[a] = s[a];
+  }), _;
+}) => [
+  // public functions
+  d,
+  // shared state
+  T,
+  I,
+  // internal things
+  e,
+  t,
+  ie,
+  o,
+  n,
+  r,
+  l
+], [wt] = Ot();
+function he(e = {}) {
+  return wt(e);
+}
+function bt(e, t, o) {
+  const n = T.get(e);
+  W() && !n && console.warn("Please use proxy object");
+  let r;
+  const l = [], d = n[3];
+  let s = !1;
+  const g = d((c) => {
+    l.push(c), r || (r = Promise.resolve().then(() => {
+      r = void 0, s && t(l.splice(0));
+    }));
+  });
+  return s = !0, () => {
+    s = !1, g();
+  };
+}
+function ht(e) {
+  const t = T.get(e);
+  W() && !t && console.warn("Please use proxy object");
+  const [o, n, r] = t;
+  return r(o, n());
+}
+var Tt = Xe("tooltip").parts("trigger", "arrow", "arrowTip", "positioner", "content"), S = Tt.build(), Te = (e) => e.ids?.trigger ?? `tooltip:${e.id}:trigger`, kt = (e) => e.ids?.content ?? `tooltip:${e.id}:content`, Et = (e) => e.ids?.arrow ?? `tooltip:${e.id}:arrow`, ke = (e) => e.ids?.positioner ?? `tooltip:${e.id}:popper`, z = (e) => e.getById(Te(e)), se = (e) => e.getById(ke(e)), h = he({ id: null });
+function Ct(e, t) {
+  const { state: o, context: n, send: r, scope: l, prop: d, event: s } = e, m = d("id"), g = !!d("aria-label"), c = o.matches("open", "closing"), y = Te(l), v = kt(l), P = d("disabled"), b = We({
+    ...d("positioning"),
+    placement: n.get("currentPlacement")
+  });
+  return {
+    open: c,
+    setOpen(u) {
+      o.matches("open", "closing") !== u && r({ type: u ? "open" : "close" });
+    },
+    reposition(u = {}) {
+      r({ type: "positioning.set", options: u });
+    },
+    getTriggerProps() {
+      return t.button({
+        ...S.trigger.attrs,
+        id: y,
+        dir: d("dir"),
+        "data-expanded": et(c),
+        "data-state": c ? "open" : "closed",
+        "aria-describedby": c ? v : void 0,
+        onClick(u) {
+          u.defaultPrevented || P || d("closeOnClick") && r({ type: "close", src: "trigger.click" });
+        },
+        onFocus(u) {
+          queueMicrotask(() => {
+            u.defaultPrevented || P || s.src !== "trigger.pointerdown" && q() && r({ type: "open", src: "trigger.focus" });
+          });
+        },
+        onBlur(u) {
+          u.defaultPrevented || P || m === h.id && r({ type: "close", src: "trigger.blur" });
+        },
+        onPointerDown(u) {
+          u.defaultPrevented || P || d("closeOnPointerDown") && m === h.id && r({ type: "close", src: "trigger.pointerdown" });
+        },
+        onPointerMove(u) {
+          u.defaultPrevented || P || u.pointerType !== "touch" && r({ type: "pointer.move" });
+        },
+        onPointerLeave() {
+          P || r({ type: "pointer.leave" });
+        },
+        onPointerCancel() {
+          P || r({ type: "pointer.leave" });
+        }
+      });
+    },
+    getArrowProps() {
+      return t.element({
+        id: Et(l),
+        ...S.arrow.attrs,
+        dir: d("dir"),
+        style: b.arrow
+      });
+    },
+    getArrowTipProps() {
+      return t.element({
+        ...S.arrowTip.attrs,
+        dir: d("dir"),
+        style: b.arrowTip
+      });
+    },
+    getPositionerProps() {
+      return t.element({
+        id: ke(l),
+        ...S.positioner.attrs,
+        dir: d("dir"),
+        style: b.floating
+      });
+    },
+    getContentProps() {
+      return t.element({
+        ...S.content.attrs,
+        dir: d("dir"),
+        hidden: !c,
+        "data-state": c ? "open" : "closed",
+        role: g ? void 0 : "tooltip",
+        id: g ? void 0 : v,
+        "data-placement": n.get("currentPlacement"),
+        onPointerEnter() {
+          r({ type: "content.pointer.move" });
+        },
+        onPointerLeave() {
+          r({ type: "content.pointer.leave" });
+        },
+        style: {
+          pointerEvents: d("interactive") ? "auto" : "none"
+        }
+      });
+    }
+  };
+}
+var { and: Mt, not: ae } = Je(), Lt = Ze({
+  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: Mt("noVisibleTooltip", ae("hasPointerMoveOpened")),
+            target: "opening"
+          },
+          {
+            guard: ae("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 = () => se(n);
+        return oe(z(n), r, {
+          ...o("positioning"),
+          ...t.options,
+          defer: !0,
+          listeners: !1,
+          onComplete(l) {
+            e.set("currentPlacement", l.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 }) => dt({ root: e.getRootNode?.() }),
+      trackPositioning: ({ context: e, prop: t, scope: o }) => {
+        e.get("currentPlacement") || e.set("currentPlacement", t("positioning").placement);
+        const n = () => se(o);
+        return oe(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 l = Qe(n).map((d) => B(d, "scroll", () => {
+          e({ type: "close", src: "scroll" });
+        }, {
+          passive: !0,
+          capture: !0
+        }));
+        return () => {
+          l.forEach((d) => d?.());
+        };
+      },
+      trackStore: ({ prop: e, send: t }) => {
+        let o;
+        return queueMicrotask(() => {
+          o = bt(h, () => {
+            h.id !== e("id") && t({ type: "close", src: "id.change" });
+          });
+        }), () => o?.();
+      },
+      trackEscapeKey: ({ send: e, prop: t }) => t("closeOnEscape") ? B(document, "keydown", (n) => {
+        tt(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);
+      }
+    }
+  }
+});
+$e()([
+  "aria-label",
+  "closeDelay",
+  "closeOnEscape",
+  "closeOnPointerDown",
+  "closeOnScroll",
+  "closeOnClick",
+  "dir",
+  "disabled",
+  "getRootNode",
+  "id",
+  "ids",
+  "interactive",
+  "onOpenChange",
+  "defaultOpen",
+  "open",
+  "openDelay",
+  "positioning"
+]);
+const xt = (e) => {
+  const t = De(), { getRootNode: o } = Ke(), { dir: n } = Be(), r = {
+    id: t,
+    dir: n,
+    getRootNode: o,
+    ...e
+  }, l = ze(Lt, r);
+  return Ct(l, Ge);
+}, St = (e) => {
+  const [t, { children: o, ...n }] = ce(e), r = xt(n), l = de(E({ present: r.open }, t));
+  return /* @__PURE__ */ f.jsx(fe, { value: r, children: /* @__PURE__ */ f.jsx(pe, { value: l, children: o }) });
+}, jt = (e) => {
+  const [t, { value: o, children: n }] = ce(e), r = de(E({ present: o.open }, t));
+  return /* @__PURE__ */ f.jsx(fe, { value: o, children: /* @__PURE__ */ f.jsx(pe, { value: r, children: n }) });
+}, Ee = L((e, t) => {
+  const o = R(), n = E(o.getTriggerProps(), e);
+  return /* @__PURE__ */ f.jsx(A.button, { ...n, ref: t });
+});
+Ee.displayName = "TooltipTrigger";
+const {
+  withRootProvider: Ce,
+  withContext: N
+} = qe({ key: "tooltip" });
+Ce(
+  jt
+);
+const Dt = Ce(St, {
+  defaultProps: { lazyMount: !0, unmountOnExit: !0 }
+}), At = N(Ee, "trigger", { forwardAsChild: !0 }), Rt = N(ye, "positioner", { forwardAsChild: !0 }), Nt = N(
+  me,
+  "content",
+  { forwardAsChild: !0 }
+), Me = N(ve, "arrowTip", { forwardAsChild: !0 }), _t = N(
+  ge,
+  "arrow",
+  { forwardAsChild: !0, defaultProps: { children: /* @__PURE__ */ f.jsx(Me, {}) } }
+), Le = ({ children: e, ...t }) => /* @__PURE__ */ f.jsx(nt, { className: "Text", "data-testid": "kibble-text", ...t, children: e });
+Le.displayName = "Text";
+const Vt = It(Le), xe = L(
+  (e, t) => {
+    const {
+      children: o,
+      disabled: n = !1,
+      openDelay: r = 350,
+      placement: l = "top",
+      positioning: d,
+      portalled: s = !0,
+      label: m,
+      ...g
+    } = e;
+    return o ? n ? o : /* @__PURE__ */ f.jsxs(
+      Dt,
+      {
+        positioning: {
+          ...d,
+          placement: d?.placement || l
+        },
+        openDelay: r,
+        unmountOnExit: !1,
+        ...g,
+        children: [
+          /* @__PURE__ */ f.jsx(
+            At,
+            {
+              asChild: !0,
+              className: "Tooltip__Trigger",
+              "data-testid": "kibble-tooltip-trigger",
+              display: "inline-block",
+              children: o
+            }
+          ),
+          /* @__PURE__ */ f.jsx(
+            He,
+            {
+              disabled: !s,
+              children: /* @__PURE__ */ f.jsx(Rt, { className: "Tooltip", "data-testid": "kibble-tooltip", children: /* @__PURE__ */ f.jsxs(
+                Nt,
+                {
+                  className: "Tooltip__Content",
+                  "data-testid": "kibble-tooltip-content",
+                  ref: t,
+                  children: [
+                    /* @__PURE__ */ f.jsx(
+                      _t,
+                      {
+                        className: "Tooltip__Arrow",
+                        "data-testid": "kibble-tooltip-arrow",
+                        children: /* @__PURE__ */ f.jsx(Me, {})
+                      }
+                    ),
+                    /* @__PURE__ */ f.jsx(Vt, { truncated: !1, variant: "onContrast", size: "sm", children: m })
+                  ]
+                }
+              ) })
+            }
+          )
+        ]
+      }
+    ) : /* @__PURE__ */ f.jsx(f.Fragment, {});
+  }
+);
+xe.displayName = "Tooltip";
+const It = (e) => {
+  const t = ee(e);
+  function o({
+    truncated: n = !1,
+    noOfLines: r = 1,
+    children: l,
+    tooltipProps: d,
+    ...s
+  }) {
+    const [m, g] = Ae(!1), c = te(null), y = te(null), v = Re(() => {
+      if (c.current) {
+        const P = c.current?.children[0].scrollHeight || 0, b = c.current?.offsetHeight || 0;
+        g(P > b);
+      }
+    }, []);
+    return Ne(() => {
+      if (n && c.current) {
+        let P;
+        const b = () => {
+          window.clearTimeout(P), P = window.setTimeout(v, 100);
+        };
+        return y.current = new ResizeObserver(() => {
+          b();
+        }), y.current.observe(c.current), v(), () => {
+          window.clearTimeout(P), y.current && y.current.disconnect();
+        };
+      }
+    }, [n, v]), n ? /* @__PURE__ */ f.jsx(
+      xe,
+      {
+        ...d,
+        label: d?.label || l?.toLocaleString() || "",
+        disabled: !m,
+        "data-testid": "kibble-truncated-text-tooltip",
+        children: /* @__PURE__ */ f.jsx(
+          _e,
+          {
+            ref: c,
+            display: "inline-block",
+            position: "relative",
+            className: "TruncatedText__Wrapper",
+            "data-testid": "kibble-truncated-text-wrapper",
+            children: /* @__PURE__ */ f.jsx(
+              t,
+              {
+                className: "TruncatedText__TextContent",
+                "data-testid": "kibble-truncated-text-content",
+                lineClamp: r,
+                ...s,
+                children: l
+              }
+            )
+          }
+        )
+      }
+    ) : /* @__PURE__ */ f.jsx(t, { ...s, children: l });
+  }
+  return o.displayName = `withTruncation(${e.displayName || e.name}`, ee(o);
+};
+export {
+  xe as T,
+  Vt as W,
+  Tt as a,
+  q as i,
+  dt as t,
+  It as w
+};
+//# sourceMappingURL=withTruncation-BAxxp5gA.js.map