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

package/dist/chunks/heading.component-d5jKnwm5.js

@@ -0,0 +1,976 @@
+import { j as n } from "./jsx-runtime-C5mzlN2N.js";
+import fe, { forwardRef as l, useId as Te, memo as H, useState as be, useRef as D, useCallback as Oe, useEffect as we } from "react";
+import { c as F } from "./create-slot-recipe-context-BJmsuxih.js";
+import { v as h, h as g, m as E, w as xe, x as ye, y as Ee, z as Ne, A as Re, c as ke, i as Ae, g as L, e as je, b as _e, u as Ie, j as He, k as De, n as Le, s as B, l as V, o as G, P as Se } from "./portal-CtkZ5xTm.js";
+import { a0 as p, c as $e, w as Fe, t as Be, b as Ve } from "./index-Cb49D-ky.js";
+import { c as z } from "./create-recipe-context-D7FewUR4.js";
+import { B as A } from "./button.component-DahLrK9h.js";
+import { a as Ge } from "./config-DlTdf-Yt.js";
+import { u as _ } from "./use-slot-recipe-DhtQ1j_5.js";
+import { F as j } from "./flex-smlF8uQG.js";
+import { c as ze } from "./factory-Ctbv0Ozn.js";
+import { B as W } from "./box-Ck9I7FYv.js";
+const { withContext: We } = z({
+  key: "heading"
+}), Me = We("h2"), { withContext: Ue } = z({
+  key: "text"
+}), Ye = Ue("p"), M = l((e, o) => {
+  const r = h(), t = p(r.getAnchorProps(), e);
+  return /* @__PURE__ */ n.jsx(g.div, { ...t, ref: o });
+});
+M.displayName = "PopoverAnchor";
+const U = l((e, o) => {
+  const r = h(), t = p(r.getArrowProps(), e);
+  return /* @__PURE__ */ n.jsx(g.div, { ...t, ref: o });
+});
+U.displayName = "PopoverArrow";
+const Y = l((e, o) => {
+  const r = h(), t = p(r.getArrowTipProps(), e);
+  return /* @__PURE__ */ n.jsx(g.div, { ...t, ref: o });
+});
+Y.displayName = "PopoverArrowTip";
+const q = l((e, o) => {
+  const r = h(), t = p(r.getDescriptionProps(), e);
+  return /* @__PURE__ */ n.jsx(g.div, { ...t, ref: o });
+});
+q.displayName = "PopoverDescription";
+const J = l((e, o) => {
+  const r = h(), t = p(r.getIndicatorProps(), e);
+  return /* @__PURE__ */ n.jsx(g.div, { ...t, ref: o });
+});
+J.displayName = "PopoverIndicator";
+const K = l((e, o) => {
+  const r = h(), t = E(), s = p(r.getPositionerProps(), e);
+  return t.unmounted ? null : /* @__PURE__ */ n.jsx(g.div, { ...s, ref: o });
+});
+K.displayName = "PopoverPositioner";
+const Q = l((e, o) => {
+  const r = h(), t = p(r.getTitleProps(), e);
+  return /* @__PURE__ */ n.jsx(g.div, { ...t, ref: o });
+});
+Q.displayName = "PopoverTitle";
+const X = l((e, o) => {
+  const r = h(), t = E(), s = p(
+    {
+      ...r.getTriggerProps(),
+      "aria-controls": t.unmounted ? void 0 : r.getTriggerProps()["aria-controls"]
+    },
+    e
+  );
+  return /* @__PURE__ */ n.jsx(g.button, { ...s, ref: o });
+});
+X.displayName = "PopoverTrigger";
+const {
+  withRootProvider: Z,
+  withContext: v,
+  useStyles: qe,
+  PropsProvider: Je
+} = F({ key: "popover" }), Ke = Z(
+  Re
+), Qe = Z(Ne), Xe = Je, Ze = v(X, "trigger", { forwardAsChild: !0 }), eo = v(K, "positioner", { forwardAsChild: !0 }), oo = v(
+  ye,
+  "content",
+  { forwardAsChild: !0 }
+), ee = v(Y, "arrowTip", { forwardAsChild: !0 }), ro = v(
+  U,
+  "arrow",
+  {
+    forwardAsChild: !0,
+    defaultProps: { children: /* @__PURE__ */ n.jsx(ee, {}) }
+  }
+), to = v(Ee, "closeTrigger", { forwardAsChild: !0 });
+v(J, "indicator", { forwardAsChild: !0 });
+const no = v(
+  Q,
+  "title",
+  { forwardAsChild: !0 }
+), so = v(q, "description", { forwardAsChild: !0 }), io = v(
+  "footer",
+  "footer"
+), ao = v(
+  "header",
+  "header"
+), co = v(
+  "div",
+  "body"
+), po = v(
+  M,
+  void 0,
+  { forwardAsChild: !0 }
+), lo = xe, uo = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  Anchor: po,
+  Arrow: ro,
+  ArrowTip: ee,
+  Body: co,
+  CloseTrigger: to,
+  Content: oo,
+  Context: lo,
+  Description: so,
+  Footer: io,
+  Header: ao,
+  Positioner: eo,
+  PropsProvider: Xe,
+  Root: Qe,
+  RootProvider: Ke,
+  Title: no,
+  Trigger: Ze,
+  usePopoverStyles: qe
+}, Symbol.toStringTag, { value: "Module" })), [oe, T] = ke({
+  name: "HoverCardContext",
+  hookName: "useHoverCardContext",
+  providerName: "<HoverCardProvider />"
+}), re = l((e, o) => {
+  const r = T(), t = p(r.getArrowProps(), e);
+  return /* @__PURE__ */ n.jsx(g.div, { ...t, ref: o });
+});
+re.displayName = "HoverCardArrow";
+const te = l((e, o) => {
+  const r = T(), t = p(r.getArrowTipProps(), e);
+  return /* @__PURE__ */ n.jsx(g.div, { ...t, ref: o });
+});
+te.displayName = "HoverCardArrowTip";
+const ne = l((e, o) => {
+  const r = T(), t = E(), s = p(r.getContentProps(), t.getPresenceProps(), e);
+  return t.unmounted ? null : /* @__PURE__ */ n.jsx(g.div, { ...s, ref: Ae(t.ref, o) });
+});
+ne.displayName = "HoverCardContent";
+const go = (e) => e.children(T()), se = l((e, o) => {
+  const r = T(), t = p(r.getPositionerProps(), e);
+  return E().unmounted ? null : /* @__PURE__ */ n.jsx(g.div, { ...t, ref: o });
+});
+se.displayName = "HoverCardPositioner";
+var vo = Ve("hoverCard").parts("arrow", "arrowTip", "trigger", "positioner", "content"), w = vo.build(), ie = (e) => e.ids?.trigger ?? `hover-card:${e.id}:trigger`, ae = (e) => e.ids?.content ?? `hover-card:${e.id}:content`, ce = (e) => e.ids?.positioner ?? `hover-card:${e.id}:popper`, Po = (e) => e.ids?.arrow ?? `hover-card:${e.id}:arrow`, k = (e) => e.getById(ie(e)), Co = (e) => e.getById(ae(e)), S = (e) => e.getById(ce(e));
+function mo(e, o) {
+  const { state: r, send: t, prop: s, context: i, scope: c } = e, d = r.hasTag("open"), m = je({
+    ...s("positioning"),
+    placement: i.get("currentPlacement")
+  });
+  return {
+    open: d,
+    setOpen(a) {
+      r.hasTag("open") !== a && t({ type: a ? "OPEN" : "CLOSE" });
+    },
+    reposition(a = {}) {
+      t({ type: "POSITIONING.SET", options: a });
+    },
+    getArrowProps() {
+      return o.element({
+        id: Po(c),
+        ...w.arrow.attrs,
+        dir: s("dir"),
+        style: m.arrow
+      });
+    },
+    getArrowTipProps() {
+      return o.element({
+        ...w.arrowTip.attrs,
+        dir: s("dir"),
+        style: m.arrowTip
+      });
+    },
+    getTriggerProps() {
+      return o.element({
+        ...w.trigger.attrs,
+        dir: s("dir"),
+        "data-placement": i.get("currentPlacement"),
+        id: ie(c),
+        "data-state": d ? "open" : "closed",
+        onPointerEnter(a) {
+          a.pointerType !== "touch" && t({ type: "POINTER_ENTER", src: "trigger" });
+        },
+        onPointerLeave(a) {
+          a.pointerType !== "touch" && t({ type: "POINTER_LEAVE", src: "trigger" });
+        },
+        onFocus() {
+          t({ type: "TRIGGER_FOCUS" });
+        },
+        onBlur() {
+          t({ type: "TRIGGER_BLUR" });
+        }
+      });
+    },
+    getPositionerProps() {
+      return o.element({
+        id: ce(c),
+        ...w.positioner.attrs,
+        dir: s("dir"),
+        style: m.floating
+      });
+    },
+    getContentProps() {
+      return o.element({
+        ...w.content.attrs,
+        dir: s("dir"),
+        id: ae(c),
+        hidden: !d,
+        tabIndex: -1,
+        "data-state": d ? "open" : "closed",
+        "data-placement": i.get("currentPlacement"),
+        onPointerEnter(a) {
+          a.pointerType !== "touch" && t({ type: "POINTER_ENTER", src: "content" });
+        },
+        onPointerLeave(a) {
+          a.pointerType !== "touch" && t({ type: "POINTER_LEAVE", src: "content" });
+        }
+      });
+    }
+  };
+}
+var { not: y, and: $ } = Fe(), ho = $e({
+  props({ props: e }) {
+    return {
+      openDelay: 700,
+      closeDelay: 300,
+      ...e,
+      positioning: {
+        placement: "bottom",
+        ...e.positioning
+      }
+    };
+  },
+  initialState({ prop: e }) {
+    return e("open") || e("defaultOpen") ? "open" : "closed";
+  },
+  context({ prop: e, bindable: o }) {
+    return {
+      open: o(() => ({
+        defaultValue: e("defaultOpen"),
+        value: e("open"),
+        onChange(r) {
+          e("onOpenChange")?.({ open: r });
+        }
+      })),
+      currentPlacement: o(() => ({
+        defaultValue: void 0
+      })),
+      isPointer: o(() => ({
+        defaultValue: !1
+      }))
+    };
+  },
+  watch({ track: e, context: o, action: r }) {
+    e([() => o.get("open")], () => {
+      r(["toggleVisibility"]);
+    });
+  },
+  states: {
+    closed: {
+      tags: ["closed"],
+      entry: ["clearIsPointer"],
+      on: {
+        "CONTROLLED.OPEN": {
+          target: "open"
+        },
+        POINTER_ENTER: {
+          target: "opening",
+          actions: ["setIsPointer"]
+        },
+        TRIGGER_FOCUS: {
+          target: "opening"
+        },
+        OPEN: {
+          target: "opening"
+        }
+      }
+    },
+    opening: {
+      tags: ["closed"],
+      effects: ["waitForOpenDelay"],
+      on: {
+        OPEN_DELAY: [
+          {
+            guard: "isOpenControlled",
+            actions: ["invokeOnOpen"]
+          },
+          {
+            target: "open",
+            actions: ["invokeOnOpen"]
+          }
+        ],
+        "CONTROLLED.OPEN": {
+          target: "open"
+        },
+        "CONTROLLED.CLOSE": {
+          target: "closed"
+        },
+        POINTER_LEAVE: [
+          {
+            guard: "isOpenControlled",
+            // We trigger toggleVisibility manually since the `ctx.open` has not changed yet (at this point)
+            actions: ["invokeOnClose", "toggleVisibility"]
+          },
+          {
+            target: "closed",
+            actions: ["invokeOnClose"]
+          }
+        ],
+        TRIGGER_BLUR: [
+          {
+            guard: $("isOpenControlled", y("isPointer")),
+            // We trigger toggleVisibility manually since the `ctx.open` has not changed yet (at this point)
+            actions: ["invokeOnClose", "toggleVisibility"]
+          },
+          {
+            guard: y("isPointer"),
+            target: "closed",
+            actions: ["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: {
+      tags: ["open"],
+      effects: ["trackDismissableElement", "trackPositioning"],
+      on: {
+        "CONTROLLED.CLOSE": {
+          target: "closed"
+        },
+        POINTER_ENTER: {
+          actions: ["setIsPointer"]
+        },
+        POINTER_LEAVE: {
+          target: "closing"
+        },
+        CLOSE: [
+          {
+            guard: "isOpenControlled",
+            actions: ["invokeOnClose"]
+          },
+          {
+            target: "closed",
+            actions: ["invokeOnClose"]
+          }
+        ],
+        TRIGGER_BLUR: [
+          {
+            guard: $("isOpenControlled", y("isPointer")),
+            actions: ["invokeOnClose"]
+          },
+          {
+            guard: y("isPointer"),
+            target: "closed",
+            actions: ["invokeOnClose"]
+          }
+        ],
+        "POSITIONING.SET": {
+          actions: ["reposition"]
+        }
+      }
+    },
+    closing: {
+      tags: ["open"],
+      effects: ["trackPositioning", "waitForCloseDelay"],
+      on: {
+        CLOSE_DELAY: [
+          {
+            guard: "isOpenControlled",
+            actions: ["invokeOnClose"]
+          },
+          {
+            target: "closed",
+            actions: ["invokeOnClose"]
+          }
+        ],
+        "CONTROLLED.CLOSE": {
+          target: "closed"
+        },
+        "CONTROLLED.OPEN": {
+          target: "open"
+        },
+        POINTER_ENTER: {
+          target: "open",
+          // no need to invokeOnOpen here because it's still open (but about to close)
+          actions: ["setIsPointer"]
+        }
+      }
+    }
+  },
+  implementations: {
+    guards: {
+      isPointer: ({ context: e }) => !!e.get("isPointer"),
+      isOpenControlled: ({ prop: e }) => e("open") != null
+    },
+    effects: {
+      waitForOpenDelay({ send: e, prop: o }) {
+        const r = setTimeout(() => {
+          e({ type: "OPEN_DELAY" });
+        }, o("openDelay"));
+        return () => clearTimeout(r);
+      },
+      waitForCloseDelay({ send: e, prop: o }) {
+        const r = setTimeout(() => {
+          e({ type: "CLOSE_DELAY" });
+        }, o("closeDelay"));
+        return () => clearTimeout(r);
+      },
+      trackPositioning({ context: e, prop: o, scope: r }) {
+        e.get("currentPlacement") || e.set("currentPlacement", o("positioning").placement);
+        const t = () => S(r);
+        return L(k(r), t, {
+          ...o("positioning"),
+          defer: !0,
+          onComplete(s) {
+            e.set("currentPlacement", s.placement);
+          }
+        });
+      },
+      trackDismissableElement({ send: e, scope: o, prop: r }) {
+        return Be(() => Co(o), {
+          defer: !0,
+          exclude: [k(o)],
+          onDismiss() {
+            e({ type: "CLOSE", src: "interact-outside" });
+          },
+          onInteractOutside: r("onInteractOutside"),
+          onPointerDownOutside: r("onPointerDownOutside"),
+          onFocusOutside(s) {
+            s.preventDefault(), r("onFocusOutside")?.(s);
+          }
+        });
+      }
+    },
+    actions: {
+      invokeOnClose({ prop: e }) {
+        e("onOpenChange")?.({ open: !1 });
+      },
+      invokeOnOpen({ prop: e }) {
+        e("onOpenChange")?.({ open: !0 });
+      },
+      setIsPointer({ context: e }) {
+        e.set("isPointer", !0);
+      },
+      clearIsPointer({ context: e }) {
+        e.set("isPointer", !1);
+      },
+      reposition({ context: e, prop: o, scope: r, event: t }) {
+        const s = () => S(r);
+        L(k(r), s, {
+          ...o("positioning"),
+          ...t.options,
+          defer: !0,
+          listeners: !1,
+          onComplete(i) {
+            e.set("currentPlacement", i.placement);
+          }
+        });
+      },
+      toggleVisibility({ prop: e, event: o, send: r }) {
+        queueMicrotask(() => {
+          r({ type: e("open") ? "CONTROLLED.OPEN" : "CONTROLLED.CLOSE", previousEvent: o });
+        });
+      }
+    }
+  }
+});
+_e()([
+  "closeDelay",
+  "dir",
+  "getRootNode",
+  "id",
+  "ids",
+  "onOpenChange",
+  "defaultOpen",
+  "open",
+  "openDelay",
+  "positioning",
+  "onInteractOutside",
+  "onPointerDownOutside",
+  "onFocusOutside"
+]);
+const fo = (e) => {
+  const o = Te(), { getRootNode: r } = Ie(), { dir: t } = He(), s = {
+    id: o,
+    dir: t,
+    getRootNode: r,
+    ...e
+  }, i = De(ho, s);
+  return mo(i, Le);
+}, To = (e) => {
+  const [o, { children: r, ...t }] = B(e), s = fo(t), i = V(p({ present: s.open }, o));
+  return /* @__PURE__ */ n.jsx(oe, { value: s, children: /* @__PURE__ */ n.jsx(G, { value: i, children: r }) });
+}, bo = (e) => {
+  const [o, { value: r, children: t }] = B(e), s = V(p({ present: r.open }, o));
+  return /* @__PURE__ */ n.jsx(oe, { value: r, children: /* @__PURE__ */ n.jsx(G, { value: s, children: t }) });
+}, de = l((e, o) => {
+  const r = T(), t = p(r.getTriggerProps(), e);
+  return /* @__PURE__ */ n.jsx(g.button, { ...t, ref: o });
+});
+de.displayName = "HoverCardTrigger";
+const {
+  withRootProvider: pe,
+  withContext: x,
+  PropsProvider: Oo
+} = F({ key: "hoverCard" }), wo = pe(bo), xo = pe(
+  To
+), yo = Oo, Eo = x(de, "trigger", { forwardAsChild: !0 }), No = x(se, "positioner", { forwardAsChild: !0 }), Ro = x(ne, "content", { forwardAsChild: !0 }), le = x(te, "arrowTip", { forwardAsChild: !0 }), ko = x(
+  re,
+  "arrow",
+  {
+    forwardAsChild: !0,
+    defaultProps: { children: /* @__PURE__ */ n.jsx(le, {}) }
+  }
+), Ao = go, jo = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  Arrow: ko,
+  ArrowTip: le,
+  Content: Ro,
+  Context: Ao,
+  Positioner: No,
+  PropsProvider: yo,
+  Root: xo,
+  RootProvider: wo,
+  Trigger: Eo
+}, Symbol.toStringTag, { value: "Module" })), ue = ({ children: e, ...o }) => /* @__PURE__ */ n.jsx(Ye, { className: "Text", "data-testid": "kibble-text", ...o, children: e });
+ue.displayName = "Text";
+const _o = Ce(ue), Io = [
+  "root",
+  "content",
+  "arrow",
+  "arrowTip",
+  "body",
+  "header",
+  "footer"
+], Ho = {
+  xs: {
+    content: {
+      width: 160
+    }
+  },
+  sm: {
+    content: {
+      width: 200
+    }
+  },
+  md: {
+    content: {
+      width: 260
+    }
+  },
+  lg: {
+    content: {
+      width: 320
+    }
+  },
+  xl: {
+    content: {
+      width: 480
+    }
+  }
+}, Do = {
+  default: {
+    arrowTip: {
+      borderColor: "border"
+    },
+    content: {
+      "--popover-bg": "colors.background.default",
+      "--hovercard-bg": "colors.background.default",
+      borderColor: "border",
+      color: "text.default"
+    }
+  },
+  defaultDestructive: {
+    arrowTip: {
+      borderColor: "border"
+    },
+    content: {
+      "--popover-bg": "colors.background.default",
+      "--hovercard-bg": "colors.background.default",
+      borderColor: "border",
+      color: "text.default"
+    }
+  },
+  contrast: {
+    arrowTip: {
+      borderColor: "border.contrast"
+    },
+    content: {
+      "--popover-bg": "colors.background.contrast",
+      "--hovercard-bg": "colors.background.contrast",
+      borderColor: "border.contrast",
+      color: "text.contrast"
+    }
+  },
+  contrastDestructive: {
+    arrowTip: {
+      borderColor: "border.contrast"
+    },
+    content: {
+      "--popover-bg": "colors.background.contrast",
+      "--hovercard-bg": "colors.background.contrast",
+      borderColor: "border.contrast",
+      color: "text.contrast"
+    }
+  }
+}, I = Ge({
+  slots: Io,
+  base: {
+    arrowTip: {
+      borderTopWidth: "1px",
+      borderInlineStartWidth: "1px"
+    },
+    body: {
+      p: 3
+    },
+    content: {
+      borderRadius: "base",
+      border: "1px"
+    },
+    footer: {
+      borderTop: 0,
+      borderRadius: "inherit",
+      pb: 3,
+      pt: 0,
+      px: 3
+    },
+    header: {
+      borderBottom: 0,
+      borderRadius: "inherit",
+      minH: 6,
+      pb: 0,
+      pt: 3,
+      px: 3,
+      w: "100%"
+    }
+  },
+  variants: {
+    size: Ho,
+    variant: Do
+  },
+  defaultVariants: {
+    size: "sm",
+    variant: "default"
+  }
+}), Lo = ({
+  children: e,
+  color: o,
+  hideCloseButton: r = !1,
+  onContrast: t = !0,
+  onClose: s,
+  size: i = "sm",
+  trigger: c,
+  ...d
+}) => {
+  const a = _({ recipe: I })(), { setOpen: u } = (
+    // eslint-disable-next-line react-hooks/rules-of-hooks
+    c === "hover" ? T() : h()
+  );
+  return /* @__PURE__ */ n.jsxs(
+    j,
+    {
+      className: "Popover__HeaderWrapper",
+      "data-testid": "kibble-popover-header-wrapper",
+      css: a.header,
+      ...d,
+      children: [
+        /* @__PURE__ */ n.jsx(
+          $o,
+          {
+            className: "Popover__Header",
+            "data-testid": "kibble-popover-header",
+            size: i,
+            color: o || "inherit",
+            children: e
+          }
+        ),
+        !r && /* @__PURE__ */ n.jsx(
+          A,
+          {
+            className: "Popover__CloseButton",
+            "data-testid": "kibble-popover-close-button",
+            variant: "ghostNeutral",
+            onContrast: t,
+            onClick: s || (() => u(!1)),
+            iconName: "close",
+            position: "absolute",
+            right: 1,
+            top: 1,
+            size: "xs"
+          }
+        )
+      ]
+    }
+  );
+}, ge = ze("div", {
+  base: {
+    flex: 1,
+    justifySelf: "stretch",
+    alignSelf: "stretch"
+  }
+});
+ge.displayName = "Spacer";
+const So = ({
+  children: e,
+  disabled: o,
+  hideButtons: r = !1,
+  hideCancelButton: t = !1,
+  destructive: s,
+  loading: i,
+  onCancel: c,
+  onContrast: d = !0,
+  onSubmit: m,
+  submitText: a = "Submit",
+  trigger: u,
+  ...f
+}) => {
+  const C = _({ recipe: I })(), { setOpen: P } = (
+    // eslint-disable-next-line react-hooks/rules-of-hooks
+    u === "hover" ? T() : h()
+  ), N = () => {
+    c && c(), P(!1);
+  };
+  return /* @__PURE__ */ n.jsxs(
+    j,
+    {
+      className: "Popover__Footer",
+      "data-testid": "kibble-popover-footer",
+      css: C.footer,
+      ...f,
+      children: [
+        e,
+        !r && /* @__PURE__ */ n.jsxs(j, { w: "100%", children: [
+          !t && /* @__PURE__ */ n.jsx(
+            A,
+            {
+              variant: "tertiary",
+              onContrast: d,
+              size: "sm",
+              onClick: N,
+              children: "Cancel"
+            }
+          ),
+          /* @__PURE__ */ n.jsx(ge, {}),
+          /* @__PURE__ */ n.jsx(
+            A,
+            {
+              onClick: m,
+              loading: i,
+              disabled: o,
+              size: "sm",
+              onContrast: d,
+              variant: s ? "primaryDestructive" : "primary",
+              children: a
+            }
+          )
+        ] })
+      ]
+    }
+  );
+}, ve = fe.forwardRef(
+  (e, o) => {
+    const {
+      allowEscape: r = !0,
+      anchor: t,
+      children: s,
+      contentProps: i,
+      footerProps: c,
+      headerProps: d,
+      disabled: m = !1,
+      portalled: a = !0,
+      placement: u = "bottom",
+      positioning: f,
+      size: b = "sm",
+      trigger: C = "click",
+      variant: P = "default",
+      ...N
+    } = e, O = C === "hover" ? jo : uo, he = _({ recipe: I })({ variant: P, size: b });
+    if (!s || m) return /* @__PURE__ */ n.jsx(n.Fragment, {});
+    const R = P === "contrast" || P === "contrastDestructive";
+    return /* @__PURE__ */ n.jsxs(
+      O.Root,
+      {
+        closeOnEscape: r,
+        closeOnInteractOutside: r,
+        positioning: {
+          ...f,
+          placement: f?.placement || u
+        },
+        size: b,
+        variant: P,
+        ...N,
+        children: [
+          /* @__PURE__ */ n.jsx(
+            O.Trigger,
+            {
+              className: "Popover__Trigger",
+              "data-testid": "kibble-popover-trigger",
+              width: "max-content",
+              asChild: !0,
+              children: t
+            }
+          ),
+          /* @__PURE__ */ n.jsx(Se, { disabled: !a, children: /* @__PURE__ */ n.jsx(O.Positioner, { className: "Popover", "data-testid": "kibble-popover", children: /* @__PURE__ */ n.jsxs(
+            O.Content,
+            {
+              className: "Popover__Content",
+              "data-testid": "kibble-popover-content",
+              ref: o,
+              p: 0,
+              ...i,
+              children: [
+                /* @__PURE__ */ n.jsx(
+                  O.Arrow,
+                  {
+                    className: "Popover__Arrow",
+                    "data-testid": "kibble-popover-arrow",
+                    children: /* @__PURE__ */ n.jsx(O.ArrowTip, { top: "-1px !important" })
+                  }
+                ),
+                d && /* @__PURE__ */ n.jsx(
+                  Lo,
+                  {
+                    trigger: C,
+                    onContrast: R,
+                    ...d
+                  }
+                ),
+                /* @__PURE__ */ n.jsx(
+                  W,
+                  {
+                    className: "Popover__Body",
+                    "data-testid": "kibble-popover-body",
+                    css: he.body,
+                    children: typeof s == "string" ? /* @__PURE__ */ n.jsx(
+                      _o,
+                      {
+                        variant: R ? "onContrast" : "default",
+                        size: "sm",
+                        children: s
+                      }
+                    ) : s
+                  }
+                ),
+                c && /* @__PURE__ */ n.jsx(
+                  So,
+                  {
+                    trigger: C,
+                    destructive: P === "contrastDestructive" || P === "defaultDestructive",
+                    onContrast: R,
+                    ...c
+                  }
+                )
+              ]
+            }
+          ) }) })
+        ]
+      }
+    );
+  }
+);
+ve.displayName = "Popover";
+const Pe = l(
+  (e, o) => {
+    const {
+      children: r,
+      disabled: t = !1,
+      openDelay: s = 350,
+      placement: i = "top",
+      label: c,
+      ...d
+    } = e;
+    return r ? t ? r : /* @__PURE__ */ n.jsx(
+      ve,
+      {
+        placement: i,
+        trigger: "hover",
+        anchor: r,
+        variant: "contrast",
+        openDelay: s,
+        contentProps: {
+          width: "auto"
+        },
+        ref: o,
+        ...d,
+        children: c
+      }
+    ) : /* @__PURE__ */ n.jsx(n.Fragment, {});
+  }
+);
+Pe.displayName = "Tooltip";
+const Ce = (e) => {
+  const o = H(e);
+  function r({
+    truncated: t = !1,
+    noOfLines: s = 1,
+    children: i,
+    tooltipProps: c,
+    ...d
+  }) {
+    const [m, a] = be(!1), u = D(null), f = D(null), b = Oe(() => {
+      if (u.current) {
+        const C = u.current?.children[0].scrollHeight || 0, P = u.current?.offsetHeight || 0;
+        a(C > P);
+      }
+    }, []);
+    return we(() => {
+      if (t && u.current) {
+        let C;
+        const P = () => {
+          window.clearTimeout(C), C = window.setTimeout(b, 100);
+        };
+        return f.current = new ResizeObserver(() => {
+          P();
+        }), f.current.observe(u.current), b(), () => {
+          window.clearTimeout(C), f.current && f.current.disconnect();
+        };
+      }
+    }, [t, b]), t ? /* @__PURE__ */ n.jsx(
+      Pe,
+      {
+        ...c,
+        label: c?.label || i?.toLocaleString() || "",
+        disabled: !m,
+        "data-testid": "kibble-truncated-text-tooltip",
+        children: /* @__PURE__ */ n.jsx(
+          W,
+          {
+            ref: u,
+            display: "inline-block",
+            position: "relative",
+            className: "TruncatedText__Wrapper",
+            "data-testid": "kibble-truncated-text-wrapper",
+            children: /* @__PURE__ */ n.jsx(
+              o,
+              {
+                className: "TruncatedText__TextContent",
+                "data-testid": "kibble-truncated-text-content",
+                lineClamp: s,
+                ...d,
+                children: i
+              }
+            )
+          }
+        )
+      }
+    ) : /* @__PURE__ */ n.jsx(o, { ...d, children: i });
+  }
+  return r.displayName = `withTruncation(${e.displayName || e.name}`, H(r);
+}, me = ({ children: e, ...o }) => /* @__PURE__ */ n.jsx(Me, { className: "Heading", "data-testid": "kibble-heading", ...o, children: e });
+me.displayName = "Heading";
+const $o = Ce(me);
+export {
+  ve as P,
+  Pe as T,
+  $o as W,
+  _o as a,
+  Qe as b,
+  Ze as c,
+  eo as d,
+  oo as e,
+  ro as f,
+  co as g,
+  vo as h,
+  I as p
+};
+//# sourceMappingURL=heading.component-d5jKnwm5.js.map