@sberbusiness/triplex-next 0.1.4 → 0.1.6

package/components/Tooltip/TootlipContext.js

@@ -0,0 +1,18 @@
+import e from "react";
+const l = e.createContext({
+  elements: {
+    body: null,
+    link: null,
+    closeButton: null,
+    mobileHeader: null,
+    target: null
+  },
+  setTooltipOpen: () => {
+  },
+  targetHoveredRef: { current: !1 },
+  tooltipOpen: !1
+});
+export {
+  l as TooltipContext
+};
+//# sourceMappingURL=TootlipContext.js.map

package/components/Tooltip/components/common/TooltipBody.js

@@ -0,0 +1,16 @@
+import { jsx as o } from "react/jsx-runtime";
+import r from "react";
+import { MobileView as s } from "../../../MobileView/MobileView.js";
+import { Text as a } from "../../../Typography/Text.js";
+import { ELineType as l, ETextSize as p } from "../../../Typography/enums.js";
+import { c } from "../../../../chunks/vendor-CF2m175I.js";
+import { s as f } from "../../../../chunks/TooltipDesktop.module-BRkBuup-.js";
+const d = r.forwardRef(({ className: m, ...i }, t) => {
+  const e = c(f.tooltipBody, m);
+  return /* @__PURE__ */ o(s, { fallback: /* @__PURE__ */ o("div", { className: e, ...i, ref: t }), children: /* @__PURE__ */ o(a, { className: e, size: p.B3, line: l.NORMAL, tag: "div", ...i, ref: t }) });
+});
+d.displayName = "TooltipBody";
+export {
+  d as TooltipBody
+};
+//# sourceMappingURL=TooltipBody.js.map

package/components/Tooltip/components/common/TooltipLink.js

@@ -0,0 +1,34 @@
+import { jsx as t } from "react/jsx-runtime";
+import n from "react";
+import { c as s } from "../../../../chunks/vendor-CF2m175I.js";
+import { MobileView as a } from "../../../MobileView/MobileView.js";
+const k = "tooltipLink__97250ef3", r = "desktop__d60bfd8c", c = "mobile__766c8fc7", o = {
+  tooltipLink: k,
+  desktop: r,
+  mobile: c
+}, m = n.forwardRef(
+  ({ children: i, className: e, ...l }, p) => /* @__PURE__ */ t(a, { fallback: /* @__PURE__ */ t(
+    "a",
+    {
+      className: s(o.tooltipLink, o.desktop, e),
+      ...l,
+      "data-tx": "0.1.6",
+      ref: p,
+      children: i
+    }
+  ), children: /* @__PURE__ */ t(
+    "a",
+    {
+      className: s(o.tooltipLink, o.mobile, e),
+      ...l,
+      "data-tx": "0.1.6",
+      ref: p,
+      children: i
+    }
+  ) })
+);
+m.displayName = "TooltipLink";
+export {
+  m as TooltipLink
+};
+//# sourceMappingURL=TooltipLink.js.map

package/components/Tooltip/components/common/TooltipTarget.js

@@ -0,0 +1,19 @@
+import r, { useContext as d } from "react";
+import { TooltipContext as m } from "../../TootlipContext.js";
+import { isKey as T } from "../../../../utils/keyboard.js";
+const y = ({ children: c }) => {
+  const { toggleType: i, tooltipOpen: l, targetHoveredRef: n, setTooltipOpen: p } = d(m), o = r.Children.only(c), s = (t) => (e) => {
+    const f = e.code || e.keyCode;
+    T(f, "TAB") && l && p(!1), t == null || t(e);
+  }, a = (t) => (e) => {
+    (i === "click" || i === "hover" && !n.current && e.currentTarget.contains(e.target)) && p(!l), t == null || t(e);
+  };
+  return r.isValidElement(o) ? r.cloneElement(o, {
+    onClick: a(o.props.onClick),
+    onKeyDown: s(o.props.onKeyDown)
+  }) : o;
+};
+export {
+  y as TooltipTarget
+};
+//# sourceMappingURL=TooltipTarget.js.map

package/components/Tooltip/components/common/TooltipXButton.js

@@ -0,0 +1,16 @@
+import { jsx as o } from "react/jsx-runtime";
+import { useContext as p } from "react";
+import { CrossStrokeSrvIcon16 as n } from "@sberbusiness/icons-next";
+import { TooltipContext as i } from "../../TootlipContext.js";
+import { ButtonIcon as l } from "../../../Button/ButtonIcon.js";
+import { s as f } from "../../../../chunks/TooltipDesktop.module-BRkBuup-.js";
+const I = ({ onClick: t, ...r }) => {
+  const { setTooltipOpen: e } = p(i), s = (m) => {
+    e(!1), t == null || t(m);
+  };
+  return /* @__PURE__ */ o(l, { className: f.tooltipXButton, onClick: s, ...r, children: /* @__PURE__ */ o(n, { paletteIndex: 6 }) });
+};
+export {
+  I as TooltipXButton
+};
+//# sourceMappingURL=TooltipXButton.js.map

package/components/Tooltip/components/desktop/TooltipDesktop.js

@@ -0,0 +1,69 @@
+var l = Object.defineProperty;
+var h = (n, s, e) => s in n ? l(n, s, { enumerable: !0, configurable: !0, writable: !0, value: e }) : n[s] = e;
+var o = (n, s, e) => h(n, typeof s != "symbol" ? s + "" : s, e);
+import { jsx as d } from "react/jsx-runtime";
+import u from "react";
+import { TooltipDesktopBase as a } from "./components/TooltipDesktopBase.js";
+import { TooltipContext as m } from "../../TootlipContext.js";
+import { isKey as f } from "../../../../utils/keyboard.js";
+class p extends u.Component {
+  constructor() {
+    super(...arguments);
+    o(this, "tooltip", null);
+    o(this, "timeout");
+    o(this, "setTooltipRef", (e) => {
+      const { toggleType: t } = this.props;
+      e && t === "hover" && this.addHoverListeners(e), this.tooltip = e;
+    });
+    // Закрываем Tooltip при клике за его пределами.
+    o(this, "closeIfOuterAction", (e) => {
+      const { targetRef: t } = this.props, { setTooltipOpen: i } = this.context;
+      if (t.current && this.tooltip) {
+        const r = !t.current.contains(e.target), c = !this.tooltip.contains(e.target);
+        r && c && i(!1);
+      }
+    });
+    // Закрываем Tooltip по нажатию Esc
+    o(this, "closeIfEscapeKey", (e) => {
+      const t = e.code || e.keyCode;
+      f(t, "ESCAPE") && this.context.setTooltipOpen(!1);
+    });
+    o(this, "addHoverListeners", (e) => {
+      e.addEventListener("mouseenter", this.handleMouseEnter), e.addEventListener("mouseleave", this.handleMouseLeave);
+    });
+    o(this, "removeHoverListeners", (e) => {
+      e.removeEventListener("mouseenter", this.handleMouseEnter), e.removeEventListener("mouseleave", this.handleMouseLeave);
+    });
+    o(this, "handleMouseEnter", () => {
+      const { tooltipOpen: e, targetHoveredRef: t, setTooltipOpen: i } = this.context;
+      e || (i(!0), t.current = !0), clearTimeout(this.timeout);
+    });
+    o(this, "handleMouseLeave", () => {
+      const { setTooltipOpen: e } = this.context;
+      this.timeout = window.setTimeout(() => {
+        e(!1);
+      }, 500);
+    });
+  }
+  render() {
+    const { children: e, toggleType: t, ...i } = this.props;
+    return /* @__PURE__ */ d(a, { ...i, setTooltipRef: this.setTooltipRef });
+  }
+  componentDidMount() {
+    const { toggleType: e, targetRef: t } = this.props;
+    this.props.isOpen && (document.addEventListener("click", this.closeIfOuterAction), document.addEventListener("keydown", this.closeIfEscapeKey)), t.current && e === "hover" && this.addHoverListeners(t.current);
+  }
+  componentDidUpdate(e) {
+    const { targetRef: t } = this.props, i = !e.isOpen && this.props.isOpen, r = e.isOpen && !this.props.isOpen;
+    i && (document.addEventListener("mousedown", this.closeIfOuterAction), document.addEventListener("keydown", this.closeIfEscapeKey)), r && (document.removeEventListener("mousedown", this.closeIfOuterAction), document.removeEventListener("keydown", this.closeIfEscapeKey), this.props.toggleType === "hover" && this.removeHoverListeners(this.tooltip)), t.current && e.toggleType != this.props.toggleType && (this.props.toggleType === "hover" ? this.addHoverListeners(t.current) : e.toggleType === "hover" && this.removeHoverListeners(t.current));
+  }
+  componentWillUnmount() {
+    const { toggleType: e, targetRef: t } = this.props;
+    document.removeEventListener("mousedown", this.closeIfOuterAction), document.removeEventListener("keydown", this.closeIfEscapeKey), t.current && e === "hover" && this.removeHoverListeners(t.current), clearTimeout(this.timeout);
+  }
+}
+o(p, "displayName", "TooltipDesktop"), o(p, "contextType", m);
+export {
+  p as TooltipDesktop
+};
+//# sourceMappingURL=TooltipDesktop.js.map

package/components/Tooltip/components/desktop/components/TooltipDesktopBase.js

@@ -0,0 +1,241 @@
+var _ = Object.defineProperty;
+var H = (p, a, i) => a in p ? _(p, a, { enumerable: !0, configurable: !0, writable: !0, value: i }) : p[a] = i;
+var t = (p, a, i) => H(p, typeof a != "symbol" ? a + "" : a, i);
+import { jsxs as S, Fragment as P, jsx as x } from "react/jsx-runtime";
+import O from "react";
+import { i as M, c as $ } from "../../../../../chunks/vendor-CF2m175I.js";
+import { TooltipContext as X } from "../../../TootlipContext.js";
+import { Portal as Y } from "../../../../Portal/Portal.js";
+import { ETooltipPreferPlace as u, ETooltipDirection as B, ETooltipAlign as z, ETooltipFlowTypes as I, ETooltipSizeParameter as r, ETooltipTypeName as C, ETooltipEndCoordinates as N, ETooltipStartCoordinates as R, ETooltipAxesType as G, ETooltipSize as U } from "../../../enums.js";
+import { TooltipDesktopTip as V } from "./TooltipDesktopTip.js";
+import { pickZone as j, axes as q, calcRelPos as K, centerOfBoundsFromBounds as Z, calcBounds as L, equalCoords as J } from "../../../utils/Positioning.js";
+import { s as f } from "../../../../../chunks/TooltipDesktop.module-BRkBuup-.js";
+const Q = {
+  column: "translateX",
+  row: "translateY"
+}, b = {
+  column: "translateY",
+  row: "translateX"
+}, tt = {
+  [u.ABOVE]: B.DOWN,
+  [u.BELOW]: B.UP,
+  [u.LEFT]: B.RIGHT,
+  [u.RIGHT]: B.LEFT
+}, ot = 200, st = 500, v = 2, n = 8, h = 16;
+class W extends O.Component {
+  constructor() {
+    super(...arguments);
+    t(this, "zone", {
+      [C.FLOW]: I.COLUMN,
+      [C.STANDING]: u.ABOVE,
+      [C.SIDE]: z.CENTER,
+      cutOff: 0,
+      order: 0,
+      [r.H]: 0,
+      [r.W]: 0
+    });
+    t(this, "tooltipBodySize", {
+      [r.H]: 0,
+      [r.W]: 0
+    });
+    t(this, "targetBounds", {
+      [R.X]: 0,
+      [N.X]: 0,
+      [R.Y]: 0,
+      [N.Y]: 0,
+      [r.H]: 0,
+      [r.W]: 0
+    });
+    t(this, "windowBounds", {
+      [R.X]: 0,
+      [N.X]: 0,
+      [R.Y]: 0,
+      [N.Y]: 0,
+      [r.H]: 0,
+      [r.W]: 0
+    });
+    t(this, "bodyRef", O.createRef());
+    t(this, "tipRef", O.createRef());
+    t(this, "tipEl", null);
+    t(this, "bodyEl", null);
+    t(this, "tooltipNode", null);
+    t(this, "hasTracked", !1);
+    t(this, "exitingAnimationTimer1", null);
+    t(this, "exitingAnimationTimer2", null);
+    t(this, "checkLayoutInterval", null);
+    t(this, "state", {
+      exiting: !1,
+      // для отслеживания того что анимация при закрытии тултипа в прогрессе.
+      isOpen: this.props.isOpen,
+      // для отслеживания открыт/закрыт ли tooltip.
+      needRenderTooltip: this.props.isOpen,
+      // нужно рендерить тултип или нет, признак анимационно зависимого рендериннга открыт/закрыт ли tooltip
+      standing: u.ABOVE
+    });
+    // Открыть поповер
+    t(this, "prepareOpen", () => {
+      this.state.exiting && this.animateExitStop(), this.setState({ isOpen: !0, needRenderTooltip: !0 });
+    });
+    // Закрыть поповер
+    t(this, "close", () => {
+      this.setState({ isOpen: !1 });
+    });
+    // Метод начала отслеживания поповера и анимация его появления
+    t(this, "enter", () => {
+      this.trackTooltip(), this.animateEnter(), this.props.onShow && this.tooltipNode && this.props.onShow(this.tooltipNode);
+    });
+    // Метод окончания отслеживания поповера и анимация его исчезновения
+    t(this, "exit", () => {
+      this.animateExit(), this.untrackTooltip();
+    });
+    t(this, "setTooltipNode", (i) => {
+      const { setTooltipRef: s } = this.props;
+      i && (this.bodyEl = this.bodyRef.current, this.tipEl = this.tipRef.current), this.tooltipNode = i, s == null || s(this.tooltipNode);
+    });
+    // Рендер поповера
+    t(this, "resolveTooltipLayout", () => {
+      if (!this.tooltipNode)
+        return;
+      const { alignTip: i } = this.props, s = j(
+        this.props.preferPlace,
+        this.windowBounds,
+        this.targetBounds,
+        n,
+        h,
+        {
+          h: this.tooltipBodySize.h + n,
+          w: this.tooltipBodySize.w + n
+        }
+      );
+      this.zone = s, this.setState({
+        standing: s.standing
+      });
+      const o = q[s.flow], l = { ...this.tooltipBodySize };
+      l[s.flow === I.ROW ? r.W : r.H] += n;
+      const e = K(s, this.targetBounds, l);
+      e[o.main.start] += v * s.order;
+      let T = 0;
+      this.bodyEl && (T = Math.round(+getComputedStyle(this.bodyEl).borderRadius.slice(0, -2)) || 0);
+      const d = n + v, m = T * 2 + n * 2 + d, k = this.windowBounds[o.cross.start], A = this.windowBounds[o.cross.end], w = this.windowBounds[o.cross.size], c = w - d * 2, y = k + d, g = A - d, D = e[o.cross.start], F = e[o.cross.end];
+      i === z.START ? e[o.cross.start] = this.targetBounds[o.cross.end] - h - n - this.targetBounds[o.cross.size] / 2 : i === z.END ? e[o.cross.start] = this.targetBounds[o.cross.start] - l[o.cross.size] + h + n + this.targetBounds[o.cross.size] / 2 : e.crossLength > w ? e[o.cross.start] = 0 : this.targetBounds[o.cross.end] < m ? e[o.cross.start] = this.targetBounds[o.cross.end] - m : this.targetBounds[o.cross.start] > g ? e[o.cross.start] = this.targetBounds[o.cross.start] - l[o.cross.size] : e.crossLength > c ? e[o.cross.start] = (w - e.crossLength) / 2 : D < y ? e[o.cross.start] = y : F > g && (e[o.cross.start] = e[o.cross.start] - (e[o.cross.end] - g)), this.tooltipNode.style.flexFlow = s.flow, this.bodyEl && (this.bodyEl.style.order = s.order.toString()), this.tooltipNode.style.top = `${e.y}px`, this.tooltipNode.style.left = `${e.x}px`;
+      let E = Z(s.flow, G.CROSS, this.targetBounds, e) - n;
+      E < h ? E = h : E > e.crossLength - h - n * 2 && (E = e.crossLength - h - n * 2), this.tipEl && (this.tipEl.style.transform = `${Q[s.flow]}(${E}px)`, this.tipEl.style.borderWidth = `${n}px`);
+    });
+    // Метод проверки изменения границ обернутого элемента.
+    t(this, "setAndCheckResizeTargetBounds", () => {
+      const { targetRef: i } = this.props;
+      if (!i.current)
+        return !1;
+      const s = L(i.current);
+      return this.targetBounds && J(this.targetBounds, s) ? !1 : (this.targetBounds = s, !0);
+    });
+    // Метод проверки необходимости перерисовки лейаута
+    t(this, "checkTargetReposition", () => {
+      this.setAndCheckResizeTargetBounds() && this.resolveTooltipLayout();
+    });
+    // Метод измерения размеров тела тултипа (без стрелочки)
+    t(this, "setTooltipBodySize", () => {
+      this.bodyEl && (this.tooltipBodySize = { w: this.bodyEl.offsetWidth, h: this.bodyEl.offsetHeight });
+    });
+    // Очистка таймеров анимации исчезновения
+    t(this, "animateExitStop", () => {
+      this.exitingAnimationTimer1 && window.clearTimeout(this.exitingAnimationTimer1), this.exitingAnimationTimer2 && window.clearTimeout(this.exitingAnimationTimer2), this.setState({ exiting: !1 });
+    });
+    // Анимация исчезновения
+    t(this, "animateExit", () => {
+      this.setState({ exiting: !0 }), this.exitingAnimationTimer2 = window.setTimeout(() => {
+        window.setTimeout(() => {
+          this.tooltipNode && (this.tooltipNode.style.transform = `${b[this.zone.flow]}(${this.zone.order * 50}px)`, this.tooltipNode.style.opacity = "0");
+        }, 0);
+      }, 0), this.exitingAnimationTimer1 = window.setTimeout(() => {
+        this.setState({ exiting: !1, needRenderTooltip: !1 });
+      }, st);
+    });
+    // Анимация появления
+    t(this, "animateEnter", () => {
+      this.tooltipNode && (this.tooltipNode.style.transform = `${b[this.zone.flow]}(${this.zone.order * 50}px)`, this.tooltipNode.style.opacity = "0", this.tooltipNode.offsetHeight, this.tipEl && (this.tipEl.style.transition = "transform 150ms ease-in"), this.tooltipNode.style.transitionProperty = "opacity, transform", this.tooltipNode.style.transitionDuration = "500ms", this.tooltipNode.style.transitionTimingFunction = "cubic-bezier(0.230, 1.000, 0.320, 1.000)", this.tooltipNode.style.opacity = "1", this.tooltipNode.style.transform = "translateY(0)");
+    });
+    //  Отслеживание поповера
+    t(this, "trackTooltip", () => {
+      this.tooltipNode && (this.hasTracked = !0, this.checkLayoutInterval = window.setInterval(this.checkTargetReposition, ot), window.addEventListener("scroll", this.onWindowScroll), window.addEventListener("resize", this.onWindowResize), this.windowBounds = L(window), this.setTooltipBodySize(), this.setAndCheckResizeTargetBounds(), this.resolveTooltipLayout());
+    });
+    // Отписка от отслеживания поповера
+    t(this, "untrackTooltip", () => {
+      this.tooltipNode && (this.checkLayoutInterval && window.clearInterval(this.checkLayoutInterval), window.removeEventListener("scroll", this.onWindowScroll), window.removeEventListener("resize", this.onWindowResize), this.hasTracked = !1);
+    });
+    // Перерисовка при скролле "рамки"
+    t(this, "onWindowScroll", () => {
+      this.setAndCheckResizeTargetBounds(), this.resolveTooltipLayout();
+    });
+    // Перерисовка при изменении размеров "рамки"
+    t(this, "onWindowResize", () => {
+      this.windowBounds = L(window), this.resolveTooltipLayout();
+    });
+    // Отрисовка самого Tooltip
+    t(this, "tooltipRender", () => {
+      const {
+        className: i,
+        size: s,
+        preferPlace: o,
+        alignTip: l,
+        isOpen: e,
+        renderContainer: T,
+        onShow: d,
+        setTooltipRef: m,
+        onKeyDown: k,
+        targetRef: A,
+        ...w
+      } = this.props, { elements: c } = this.context, y = s === U.SM ? f.tooltipSM : f.tooltipLG, g = $(
+        f.tooltipDesktop,
+        y,
+        { [f.closable]: !!c.closeButton },
+        i
+      );
+      return /* @__PURE__ */ x("div", { className: f.tooltipOverlay, children: /* @__PURE__ */ S("div", { className: g, ...w, ref: this.setTooltipNode, children: [
+        /* @__PURE__ */ S("div", { className: f.tooltipDesktopContent, ref: this.bodyRef, children: [
+          c.body,
+          c.link,
+          c.closeButton
+        ] }),
+        /* @__PURE__ */ x(V, { direction: tt[this.state.standing], ref: this.tipRef })
+      ] }) });
+    });
+  }
+  render() {
+    const { renderContainer: i } = this.props, { needRenderTooltip: s } = this.state, { elements: o } = this.context;
+    return /* @__PURE__ */ S(P, { children: [
+      o.target,
+      s && /* @__PURE__ */ x(Y, { container: i ?? document.body, children: this.tooltipRender() })
+    ] });
+  }
+  componentDidMount() {
+    this.props.isOpen && this.enter();
+  }
+  componentDidUpdate(i, s) {
+    const o = this.props, l = this.state, e = !i.isOpen && o.isOpen, T = i.isOpen && !o.isOpen;
+    if (e) {
+      this.prepareOpen();
+      return;
+    } else if (T) {
+      this.close();
+      return;
+    }
+    const d = !s.isOpen && l.isOpen, m = s.isOpen && !l.isOpen;
+    if (d) {
+      this.enter();
+      return;
+    } else if (m) {
+      this.exit();
+      return;
+    }
+    l.isOpen && !M(i.children, o.children) && (this.setTooltipBodySize(), this.setAndCheckResizeTargetBounds(), this.resolveTooltipLayout());
+  }
+  componentWillUnmount() {
+    this.animateExitStop(), this.hasTracked && this.untrackTooltip();
+  }
+}
+t(W, "displayName", "TooltipBase"), t(W, "contextType", X);
+export {
+  W as TooltipDesktopBase
+};
+//# sourceMappingURL=TooltipDesktopBase.js.map

package/components/Tooltip/components/desktop/components/TooltipDesktopTip.js

@@ -0,0 +1,29 @@
+import { jsx as a } from "react/jsx-runtime";
+import p from "react";
+import { ETooltipDirection as e } from "../../../enums.js";
+import { c } from "../../../../../chunks/vendor-CF2m175I.js";
+import { s as t } from "../../../../../chunks/TooltipDesktop.module-BRkBuup-.js";
+const l = p.forwardRef((r, i) => {
+  const { direction: s } = r;
+  let o;
+  switch (s) {
+    case e.UP:
+      o = t.up;
+      break;
+    case e.DOWN:
+      o = t.down;
+      break;
+    case e.LEFT:
+      o = t.left;
+      break;
+    case e.RIGHT:
+      o = t.right;
+      break;
+  }
+  return /* @__PURE__ */ a("div", { className: c(t.tooltipDesktopTip, o), ref: i });
+});
+l.displayName = "TooltipDesktopTip";
+export {
+  l as TooltipDesktopTip
+};
+//# sourceMappingURL=TooltipDesktopTip.js.map

package/components/Tooltip/components/mobile/TooltipMobile.js

@@ -0,0 +1,57 @@
+import { jsxs as l, Fragment as b, jsx as s } from "react/jsx-runtime";
+import { useContext as f, useRef as u, useEffect as M } from "react";
+import { TooltipContext as C } from "../../TootlipContext.js";
+import { Portal as x } from "../../../Portal/Portal.js";
+import { DropdownMobile as _ } from "../../../Dropdown/mobile/DropdownMobile.js";
+import { DropdownMobileBody as h } from "../../../Dropdown/mobile/DropdownMobileBody.js";
+import { TooltipMobileCloseButton as y } from "./components/TooltipMobileCloseButton.js";
+import { c as B } from "../../../../chunks/vendor-CF2m175I.js";
+const T = "tooltipMobile__47897569", g = "tooltipMobileContent__d269bb2b", H = "headerless__2937d68e", r = {
+  tooltipMobile: T,
+  tooltipMobileContent: g,
+  headerless: H
+}, z = ({
+  children: N,
+  className: d,
+  renderContainer: R,
+  targetRef: j,
+  disableAdaptiveMode: D,
+  isOpen: o,
+  onShow: t,
+  ...p
+}) => {
+  const { elements: e, setTooltipOpen: m } = f(C), i = u(null), c = B(r.tooltipMobile, { [r.headerless]: e.mobileHeader === null }, d);
+  M(() => {
+    o && (t == null || t(i.current));
+  }, [o]);
+  const a = () => {
+    var n;
+    return /* @__PURE__ */ s(y, { ...(n = e.closeButton) == null ? void 0 : n.props });
+  };
+  return /* @__PURE__ */ l(b, { children: [
+    e.target,
+    /* @__PURE__ */ s(x, { container: document.body, children: /* @__PURE__ */ l(
+      _,
+      {
+        className: c,
+        tabIndex: -1,
+        opened: o,
+        setOpened: m,
+        ...p,
+        ref: i,
+        children: [
+          e.mobileHeader,
+          /* @__PURE__ */ l(h, { className: r.tooltipMobileContent, children: [
+            e.body,
+            e.link,
+            e.mobileHeader === null && a()
+          ] })
+        ]
+      }
+    ) })
+  ] });
+};
+export {
+  z as TooltipMobile
+};
+//# sourceMappingURL=TooltipMobile.js.map

package/components/Tooltip/components/mobile/components/TooltipMobileCloseButton.js

@@ -0,0 +1,14 @@
+import { jsx as p } from "react/jsx-runtime";
+import { useContext as l } from "react";
+import { DropdownMobileClose as s } from "../../../../Dropdown/mobile/DropdownMobileClose.js";
+import { TooltipContext as i } from "../../../TootlipContext.js";
+const d = ({ onClick: o, ...t }) => {
+  const { setTooltipOpen: e } = l(i);
+  return /* @__PURE__ */ p(s, { onClick: (r) => {
+    e(!1), o == null || o(r);
+  }, ...t });
+};
+export {
+  d as TooltipMobileCloseButton
+};
+//# sourceMappingURL=TooltipMobileCloseButton.js.map

package/components/Tooltip/components/mobile/components/TooltipMobileHeader.js

@@ -0,0 +1,18 @@
+import { jsx as o } from "react/jsx-runtime";
+import { useContext as n } from "react";
+import { DropdownMobileHeader as p } from "../../../../Dropdown/mobile/DropdownMobileHeader.js";
+import { TooltipContext as m } from "../../../TootlipContext.js";
+import { TooltipMobileCloseButton as l } from "./TooltipMobileCloseButton.js";
+import { Text as s } from "../../../../Typography/Text.js";
+import { EFontType as d, ETextSize as f } from "../../../../Typography/enums.js";
+const b = ({ children: e, ...r }) => {
+  const { elements: i } = n(m);
+  return /* @__PURE__ */ o(p, { closeButton: () => {
+    var t;
+    return /* @__PURE__ */ o(l, { ...(t = i.closeButton) == null ? void 0 : t.props });
+  }, ...r, children: /* @__PURE__ */ o(s, { size: f.B3, type: d.PRIMARY, tag: "div", children: e }) });
+};
+export {
+  b as TooltipMobileHeader
+};
+//# sourceMappingURL=TooltipMobileHeader.js.map

package/components/Tooltip/enums.js

@@ -0,0 +1,14 @@
+var u = /* @__PURE__ */ ((r) => (r.H = "h", r.W = "w", r))(u || {}), v = /* @__PURE__ */ ((r) => (r.X = "x", r.Y = "y", r))(v || {}), n = /* @__PURE__ */ ((r) => (r.X = "x2", r.Y = "y2", r))(n || {}), O = /* @__PURE__ */ ((r) => (r.MAIN = "main", r.CROSS = "cross", r))(O || {}), L = /* @__PURE__ */ ((r) => (r.COLUMN = "column", r.ROW = "row", r))(L || {}), R = /* @__PURE__ */ ((r) => (r.SIDE = "side", r.STANDING = "standing", r.FLOW = "flow", r))(R || {}), I = /* @__PURE__ */ ((r) => (r.ABOVE = "above", r.BELOW = "below", r.RIGHT = "right", r.LEFT = "left", r))(I || {}), N = /* @__PURE__ */ ((r) => (r.END = "end", r.CENTER = "center", r.START = "start", r))(N || {}), W = /* @__PURE__ */ ((r) => (r.UP = "up", r.DOWN = "down", r.LEFT = "left", r.RIGHT = "right", r))(W || {}), a = /* @__PURE__ */ ((r) => (r.SM = "sm", r.LG = "lg", r))(a || {});
+export {
+  N as ETooltipAlign,
+  O as ETooltipAxesType,
+  W as ETooltipDirection,
+  n as ETooltipEndCoordinates,
+  L as ETooltipFlowTypes,
+  I as ETooltipPreferPlace,
+  a as ETooltipSize,
+  u as ETooltipSizeParameter,
+  v as ETooltipStartCoordinates,
+  R as ETooltipTypeName
+};
+//# sourceMappingURL=enums.js.map

package/components/Tooltip/index.js

@@ -0,0 +1,8 @@
+import { Tooltip as r } from "./Tooltip.js";
+import { ETooltipPreferPlace as t, ETooltipSize as i } from "./enums.js";
+export {
+  t as ETooltipPreferPlace,
+  i as ETooltipSize,
+  r as Tooltip
+};
+//# sourceMappingURL=index.js.map

package/components/Tooltip/types.js

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=types.js.map