@ironsource/shared-ui 2.1.11-test.8 → 2.1.11-test.91

package/components/chart/Chart.vue2.js

@@ -0,0 +1,319 @@
+ import "../../Chart.vue_vue_type_style_index_0_scoped_277fde76_lang.css"; import { defineComponent as q, computed as l, ref as g, onMounted as J, watch as T, nextTick as Q, openBlock as d, createElementBlock as C, Fragment as O, createBlock as f, unref as u, isRef as D, withCtx as k, renderSlot as x, createCommentVNode as v, createElementVNode as p, normalizeClass as Y, createVNode as F, normalizeStyle as _ } from "vue";
+import { useVModel as ee } from "@vueuse/core";
+import { Chart as N, ArcElement as te, LineElement as ae, BarElement as oe, PointElement as ie, LineController as le, BarController as re, PieController as ne, ScatterController as se, CategoryScale as de, LinearScale as ue, Filler as ce, Tooltip as pe } from "chart.js";
+import { HoverVerticalLine as me } from "./plugins/HoverVerticalLine.js";
+import { formatValue as H, calcStepSize as he } from "./utils/utils.js";
+import { DEFAULT_TICK_COUNT as fe, DEFAULT_MIN_VISIBLE as ve, DEFAULT_MAX_VISIBLE as ye, COLOR_PALETTE as be, POINT_BORDER_COLOR as ge, TICK_LABEL_COLOR as U, TICK_LABEL_FONT as P, GRID_LINE_COLOR as z } from "./consts.js";
+import { ChartType as n } from "./types.js";
+import { useTooltipPosition as Te } from "./composables/useTooltipPosition.js";
+import Ce from "./ChartTooltip.vue.js";
+import ke from "./ChartLegend.vue.js";
+import xe from "./ChartHeader.vue.js";
+import { hexColorToRgba as Le } from "../../utils/color.js";
+import { useChartValues as Se } from "./composables/useChartValues.js";
+import we from "./ChartLoader.vue.js";
+import Be from "../emptyState/v4/EmptyStateV4.vue.js";
+import Ie from "./SettingsHeader.vue.js";
+const Ae = { class: "chart-container" }, Ee = { class: "header-wrapper" }, Ve = { class: "chart" }, Re = {
+  key: 0,
+  class: "chart-sidebar"
+}, qe = /* @__PURE__ */ q({
+  __name: "Chart",
+  props: {
+    dataSets: { default: () => [] },
+    visibleIds: { default: () => [] },
+    chartType: { default: n.Line },
+    parsing: { default: void 0 },
+    xAxisFormat: { default: "string" },
+    yAxisFormat: { default: "number" },
+    tickCount: { default: fe },
+    header: { default: "" },
+    subheader: { default: "" },
+    withSubheaderTooltip: { type: Boolean, default: !1 },
+    hideLegend: { type: Boolean, default: !1 },
+    minVisible: { default: ve },
+    maxVisible: { default: ye },
+    loading: { type: Boolean, default: !1 },
+    noDataIcon: { default: "file-x" },
+    noDataTitle: { default: "No data to display" },
+    noDataSubtitle: { default: "Search again with different filters" },
+    withSettingsHeader: { type: Boolean, default: !0 },
+    maxLimitTooltipText: { default: "" },
+    withAnimation: { type: Boolean, default: !0 }
+  },
+  emits: ["update:chartType", "update:visibleIds"],
+  setup(a, { emit: L }) {
+    const t = a;
+    N.register(
+      te,
+      ae,
+      oe,
+      ie,
+      le,
+      re,
+      ne,
+      se,
+      de,
+      ue,
+      ce,
+      pe,
+      me
+    );
+    const c = ee(t, "chartType", L), M = l(
+      () => t.withAnimation ? "" : "none"
+    ), m = g(null);
+    let s = null;
+    const S = l(() => t.dataSets.length === 0), w = l(() => !t.loading && !S.value), y = () => {
+      m.value && (s && s.destroy(), s = new N(m.value, I.value));
+    }, $ = () => {
+      s && (s.data.datasets = b.value, s.options = I.value.options, s.update(M.value));
+    };
+    J(y), T(() => t.chartType, y), T(w, async (e) => {
+      e && (await Q(), y());
+    }), T([() => t.visibleIds, () => t.dataSets], $);
+    const h = l(
+      () => t.chartType === n.StackedLine || t.chartType === n.StackedBar
+    ), K = l(
+      () => t.chartType === n.Line || t.chartType === n.StackedLine
+    ), B = l(
+      () => t.dataSets.filter((e) => t.visibleIds.includes(e.id))
+    ), b = l(() => B.value.map((e, o) => {
+      const i = e.color || be[o] || "#000000";
+      return {
+        ...e,
+        fill: h.value ? "start" : void 0,
+        backgroundColor: Le(
+          i,
+          t.chartType === n.StackedLine ? 10 : 70
+        ),
+        borderColor: i,
+        pointBackgroundColor: i,
+        pointHoverBorderColor: i,
+        maxBarThickness: 50,
+        clip: 5,
+        // draw a bit outside the chart area
+        icon: e.icon || null,
+        iconType: e.iconType || "branded"
+      };
+    })), I = l(
+      () => ({
+        type: t.chartType == n.Bar || t.chartType === n.StackedBar ? "bar" : "line",
+        // Chart Data
+        data: {
+          datasets: b.value
+        },
+        // Chart Options
+        options: {
+          parsing: t.parsing,
+          interaction: {
+            intersect: !1,
+            mode: "index",
+            axis: "x"
+          },
+          // plugins
+          plugins: {
+            legend: { display: !1 },
+            title: { display: !1 },
+            hoverVerticalLine: K.value,
+            // tooltip
+            tooltip: {
+              enabled: !1,
+              position: "average",
+              external: ({ tooltip: e }) => {
+                r.value = { ...e };
+              },
+              callbacks: {
+                footer: (e) => {
+                  const o = e.reduce((i, j) => i + (j.parsed.y || 0), 0);
+                  return ["Total", String(o)];
+                }
+              }
+            }
+          },
+          // chart layout
+          responsive: !0,
+          maintainAspectRatio: !1,
+          layout: {
+            padding: {
+              left: 18,
+              top: 18,
+              bottom: 13
+            }
+          },
+          // basic styles
+          elements: {
+            line: {
+              borderWidth: 2,
+              tension: 0.3
+            },
+            point: {
+              radius: 1,
+              hitRadius: 8,
+              borderWidth: 0,
+              hoverRadius: 4,
+              hoverBorderWidth: 2,
+              pointHoverBackgroundColor: ge
+            },
+            bar: {
+              borderRadius: 4
+            }
+          },
+          scales: {
+            // Horizontal Axis (X)
+            x: {
+              beginAtZero: !0,
+              border: { display: !1 },
+              stacked: h.value,
+              // stack on top of each other
+              // ticks
+              ticks: {
+                color: U,
+                font: P,
+                padding: 4,
+                callback: function(e) {
+                  return H(
+                    this.getLabelForValue(e),
+                    t.xAxisFormat
+                  );
+                }
+              },
+              // grid lines
+              grid: {
+                color: z,
+                drawOnChartArea: !1,
+                drawTicks: !0,
+                drawBorder: !1,
+                tickLength: 7
+              }
+            },
+            // Vertical Axis (Y)
+            y: {
+              beginAtZero: !0,
+              border: { display: !1 },
+              // hide left borderline
+              stacked: h.value,
+              // stack on top of each other
+              // ticks
+              ticks: {
+                color: U,
+                font: P,
+                padding: 8,
+                stepSize: R.value,
+                min: V.value,
+                max: R.value * t.tickCount,
+                callback: (e) => H(e, t.yAxisFormat)
+              },
+              // grid lines
+              grid: {
+                color: z,
+                drawOnChartArea: !0,
+                drawTicks: !1
+              }
+            }
+          }
+        }
+      })
+    ), W = l(
+      () => b.value.reduce((e, o) => (e[o.id] = o.borderColor, e), {})
+    ), Z = l(() => t.dataSets.map((e) => ({
+      id: e.id,
+      label: e.label,
+      caption: e.caption || null,
+      color: W.value[e.id] || null,
+      icon: e.icon || null,
+      iconType: e.iconType || "branded"
+    }))), A = g(null), r = g(null), { position: E } = Te(
+      m,
+      A,
+      r
+    ), G = l(() => ({
+      left: `${E.value.left}px`,
+      top: `${E.value.top}px`,
+      opacity: r.value?.opacity || 0
+    })), { minValue: V, maxValue: X } = Se({
+      parsingConfig: t.parsing,
+      dataSets: B,
+      isStacked: h
+    }), R = l(
+      () => he(V.value, X.value, t.tickCount)
+    );
+    return (e, o) => (d(), C(O, null, [
+      a.withSettingsHeader ? (d(), f(Ie, {
+        key: 0,
+        "chart-type": u(c),
+        "onUpdate:chart-type": o[0] || (o[0] = (i) => D(c) ? c.value = i : null),
+        "hide-legend": a.hideLegend
+      }, {
+        metric: k(() => [
+          x(e.$slots, "metric", {}, void 0, !0)
+        ]),
+        breakdowns: k(() => [
+          x(e.$slots, "breakdowns", {}, void 0, !0)
+        ]),
+        _: 3
+      }, 8, ["chart-type", "hide-legend"])) : v("", !0),
+      p("div", Ae, [
+        u(w) ? (d(), C(O, { key: 0 }, [
+          p("section", {
+            class: Y(["chart-content", [{ "with-legend": !a.hideLegend }]])
+          }, [
+            p("div", Ee, [
+              F(xe, {
+                "chart-type": u(c),
+                "onUpdate:chart-type": o[1] || (o[1] = (i) => D(c) ? c.value = i : null),
+                "with-settings-header": a.withSettingsHeader,
+                header: a.header,
+                subheader: a.subheader,
+                "with-subheader-tooltip": a.withSubheaderTooltip
+              }, {
+                "subheader-tooltip": k(() => [
+                  x(e.$slots, "subheader-tooltip", {}, void 0, !0)
+                ]),
+                _: 3
+              }, 8, ["chart-type", "with-settings-header", "header", "subheader", "with-subheader-tooltip"])
+            ]),
+            p("div", Ve, [
+              p("canvas", {
+                ref_key: "chartRef",
+                ref: m,
+                class: "chart__canvas"
+              }, null, 512),
+              p("div", {
+                ref_key: "tooltipRef",
+                ref: A,
+                class: "chart__tooltip",
+                style: _(u(G))
+              }, [
+                r.value ? (d(), f(Ce, {
+                  key: 0,
+                  title: String(r.value.title),
+                  "data-points": r.value.dataPoints,
+                  "x-axis-format": a.xAxisFormat,
+                  "y-axis-format": a.yAxisFormat,
+                  "total-label": r.value.footer[0],
+                  "total-value": Number(r.value.footer[1])
+                }, null, 8, ["title", "data-points", "x-axis-format", "y-axis-format", "total-label", "total-value"])) : v("", !0)
+              ], 4)
+            ])
+          ], 2),
+          a.hideLegend ? v("", !0) : (d(), C("section", Re, [
+            F(ke, {
+              items: u(Z),
+              "visible-ids": a.visibleIds,
+              "max-limit-tooltip-text": a.maxLimitTooltipText,
+              "onUpdate:visibleIds": o[2] || (o[2] = (i) => L("update:visibleIds", i))
+            }, null, 8, ["items", "visible-ids", "max-limit-tooltip-text"])
+          ]))
+        ], 64)) : a.loading ? (d(), f(we, { key: 1 })) : u(S) ? (d(), f(u(Be), {
+          key: 2,
+          title: a.noDataTitle,
+          subtitle: a.noDataSubtitle,
+          "icon-name": a.noDataIcon
+        }, null, 8, ["title", "subtitle", "icon-name"])) : v("", !0)
+      ])
+    ], 64));
+  }
+});
+export {
+  qe as default
+};

package/components/chart/ChartHeader.vue.d.ts

@@ -1,16 +1,16 @@
 import { ChartType } from '@/components/chart/types';
-declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
     chartType: ChartType;
     withSettingsHeader: boolean;
     header?: string;
     subheader?: string;
-    subheaderTooltip?: string;
+    withSubheaderTooltip?: boolean;
 }>, {
     chartType: ChartType;
     withSettingsHeader: boolean;
     header: string;
     subheader: string;
-    subheaderTooltip: string;
+    withSubheaderTooltip: boolean;
 }>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     "update:chartType": (type: ChartType) => void;
 }, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
@@ -18,13 +18,13 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
     withSettingsHeader: boolean;
     header?: string;
     subheader?: string;
-    subheaderTooltip?: string;
+    withSubheaderTooltip?: boolean;
 }>, {
     chartType: ChartType;
     withSettingsHeader: boolean;
     header: string;
     subheader: string;
-    subheaderTooltip: string;
+    withSubheaderTooltip: boolean;
 }>>> & {
     "onUpdate:chartType"?: (type: ChartType) => any;
 }, {
@@ -32,7 +32,9 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
     chartType: ChartType;
     withSettingsHeader: boolean;
     subheader: string;
-    subheaderTooltip: string;
+    withSubheaderTooltip: boolean;
+}>, {
+    "subheader-tooltip"?(_: {}): any;
 }>;
 export default _default;
 type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
@@ -52,3 +54,8 @@ type __VLS_WithDefaults<P, D> = {
 type __VLS_Prettify<T> = {
     [K in keyof T]: T[K];
 } & {};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/components/chart/ChartHeader.vue.js

@@ -0,0 +1,7 @@
+import e from "./ChartHeader.vue2.js";
+/* empty css                  */import o from "../../_virtual/_plugin-vue_export-helper.js";
+// import "../../ChartHeader.vue_vue_type_style_index_0_scoped_b8213498_lang.css"; //*');
+const s = /* @__PURE__ */ o(e, [["__scopeId", "data-v-b8213498"]]);
+export {
+  s as default
+};

package/components/chart/ChartHeader.vue2.js

@@ -0,0 +1,69 @@
+ import "../../ChartHeader.vue_vue_type_style_index_0_scoped_b8213498_lang.css"; import { defineComponent as y, computed as T, openBlock as c, createElementBlock as b, createElementVNode as S, createVNode as i, unref as a, withCtx as o, renderSlot as V, createTextVNode as s, toDisplayString as u, createBlock as g, isRef as v, createCommentVNode as w } from "vue";
+import h from "../typography/v4/Typography.vue.js";
+import B from "../switch/v4/SwitchV4.vue.js";
+import { ChartType as r } from "./types.js";
+import k from "../tooltip/v4/TooltipV4.vue.js";
+const C = { class: "chart-header" }, x = { class: "header-texts" }, D = /* @__PURE__ */ y({
+  __name: "ChartHeader",
+  props: {
+    chartType: { default: r.Line },
+    withSettingsHeader: { type: Boolean, default: !0 },
+    header: { default: "" },
+    subheader: { default: "" },
+    withSubheaderTooltip: { type: Boolean, default: !1 }
+  },
+  emits: ["update:chartType"],
+  setup(e, { emit: p }) {
+    const m = e, l = [
+      { id: r.Line, icon: "chart-line-up" },
+      { id: r.Bar, icon: "chart-bar" },
+      { id: r.StackedLine, icon: "chart-line" }
+    ], d = T({
+      get() {
+        return l.find(({ id: t }) => t === m.chartType);
+      },
+      set(t) {
+        p("update:chartType", t.id);
+      }
+    });
+    return (t, n) => (c(), b("div", C, [
+      S("div", x, [
+        i(a(k), {
+          placement: "right",
+          disabled: !e.withSubheaderTooltip
+        }, {
+          tooltip: o(() => [
+            V(t.$slots, "subheader-tooltip", {}, void 0, !0)
+          ]),
+          default: o(() => [
+            i(a(h), {
+              class: "subheader",
+              variant: "h5"
+            }, {
+              default: o(() => [
+                s(u(e.subheader), 1)
+              ]),
+              _: 1
+            })
+          ]),
+          _: 3
+        }, 8, ["disabled"]),
+        i(a(h), { variant: "chart2" }, {
+          default: o(() => [
+            s(u(e.header), 1)
+          ]),
+          _: 1
+        })
+      ]),
+      e.withSettingsHeader ? w("", !0) : (c(), g(a(B), {
+        key: 0,
+        modelValue: a(d),
+        "onUpdate:modelValue": n[0] || (n[0] = (f) => v(d) ? d.value = f : null),
+        options: l
+      }, null, 8, ["modelValue"]))
+    ]));
+  }
+});
+export {
+  D as default
+};

package/components/chart/ChartLegend.vue.d.ts

@@ -4,11 +4,13 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
     visibleIds: unknown[];
     minVisible?: number;
     maxVisible?: number;
+    maxLimitTooltipText?: string;
 }>, {
     items: () => any[];
     visibleIds: () => any[];
     minVisible: number;
     maxVisible: number;
+    maxLimitTooltipText: string;
 }>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     "update:visibleIds": (visibleIds: unknown[]) => void;
 }, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
@@ -16,11 +18,13 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
     visibleIds: unknown[];
     minVisible?: number;
     maxVisible?: number;
+    maxLimitTooltipText?: string;
 }>, {
     items: () => any[];
     visibleIds: () => any[];
     minVisible: number;
     maxVisible: number;
+    maxLimitTooltipText: string;
 }>>> & {
     "onUpdate:visibleIds"?: (visibleIds: unknown[]) => any;
 }, {
@@ -28,6 +32,7 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
     visibleIds: unknown[];
     minVisible: number;
     maxVisible: number;
+    maxLimitTooltipText: string;
 }>;
 export default _default;
 type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;

package/components/chart/ChartLegend.vue.js

@@ -0,0 +1,7 @@
+import e from "./ChartLegend.vue2.js";
+/* empty css                  */import o from "../../_virtual/_plugin-vue_export-helper.js";
+// import "../../ChartLegend.vue_vue_type_style_index_0_scoped_a1c626cd_lang.css"; //*');
+const s = /* @__PURE__ */ o(e, [["__scopeId", "data-v-a1c626cd"]]);
+export {
+  s as default
+};

package/components/chart/ChartLegend.vue2.js

@@ -0,0 +1,122 @@
+ import "../../ChartLegend.vue_vue_type_style_index_0_scoped_a1c626cd_lang.css"; import { defineComponent as M, ref as N, computed as p, openBlock as r, createElementBlock as u, createElementVNode as a, createVNode as n, unref as i, mergeProps as x, Fragment as S, renderList as P, normalizeClass as A, withCtx as m, withModifiers as F, createBlock as H, createCommentVNode as U, createTextVNode as h, toDisplayString as I } from "vue";
+import { useVirtualList as z } from "@vueuse/core";
+import _ from "../typography/v4/Typography.vue.js";
+import R from "../checkbox/v4/CheckboxV4.vue.js";
+import q from "../search/v4/SearchV4.vue.js";
+import { DEFAULT_MIN_VISIBLE as G, DEFAULT_MAX_VISIBLE as X } from "./consts.js";
+import $ from "../icon/v4/IconV4.vue.js";
+import "../icon/v4/IconFlag.vue.js";
+import j from "../tooltip/v4/TooltipV4.vue.js";
+const J = { class: "chart-legend" }, K = { class: "search-box" }, O = ["onClick"], Q = { class: "label-container" }, ae = /* @__PURE__ */ M({
+  __name: "ChartLegend",
+  props: {
+    items: { default: () => [] },
+    visibleIds: { default: () => [] },
+    minVisible: { default: G },
+    maxVisible: { default: X },
+    maxLimitTooltipText: { default: "" }
+  },
+  emits: ["update:visibleIds"],
+  setup(b, { emit: L }) {
+    const o = b, T = 32, d = N(""), g = p(() => {
+      const t = d.value.toLowerCase();
+      return o.items.filter(
+        (l) => l.label.toLowerCase().includes(t)
+      );
+    }), s = (t) => o.visibleIds.includes(t.id), f = p(
+      () => o.visibleIds.length >= o.maxVisible
+    ), k = p(
+      () => o.visibleIds.length <= o.minVisible
+    ), c = (t) => k.value && s(t) || f.value && !s(t), C = (t) => !o.maxLimitTooltipText || s(t) || !f.value, V = (t, l) => {
+      L(
+        "update:visibleIds",
+        t ? [...o.visibleIds, l.id] : o.visibleIds.filter((e) => e !== l.id)
+      );
+    }, { list: y, containerProps: w, wrapperProps: E } = z(g, {
+      itemHeight: T,
+      overscan: 10
+    }), B = (t) => {
+      c(t) || V(!s(t), t);
+    };
+    return (t, l) => (r(), u("div", J, [
+      a("div", K, [
+        n(i(q), {
+          modelValue: d.value,
+          "onUpdate:modelValue": l[0] || (l[0] = (e) => d.value = e)
+        }, null, 8, ["modelValue"])
+      ]),
+      a("div", x({ class: "legend" }, i(w)), [
+        a("ul", x({ class: "legend__list" }, i(E)), [
+          (r(!0), u(S, null, P(i(y), ({ data: e, index: D }) => (r(), u("li", {
+            key: D,
+            class: A({ "disabled-item": c(e) })
+          }, [
+            n(i(j), {
+              text: b.maxLimitTooltipText,
+              disabled: C(e),
+              class: "disabled-tooltip"
+            }, {
+              default: m(() => [
+                a("div", {
+                  class: "item-wrapper",
+                  onClick: (v) => B(e)
+                }, [
+                  n(i(R), {
+                    color: e.color,
+                    "is-checked": s(e),
+                    disabled: c(e),
+                    onClick: l[1] || (l[1] = F(
+                      (v) => {
+                        v.stopPropagation();
+                      },
+                      ["stop"]
+                    ))
+                  }, null, 8, ["color", "is-checked", "disabled"]),
+                  e.icon ? (r(), H(i($), {
+                    key: 0,
+                    class: "icon-color",
+                    type: e.iconType,
+                    name: e.icon,
+                    size: "16px"
+                  }, null, 8, ["type", "name"])) : U("", !0),
+                  a("div", Q, [
+                    n(i(_), {
+                      variant: "body2",
+                      class: "legend-label",
+                      "is-truncated": "",
+                      "with-tooltip": "",
+                      "tooltip-text": e.label,
+                      "tooltip-placement": "left"
+                    }, {
+                      default: m(() => [
+                        h(I(e.label), 1)
+                      ]),
+                      _: 2
+                    }, 1032, ["tooltip-text"]),
+                    n(i(_), {
+                      variant: "caption",
+                      class: "legend-caption legend-label",
+                      "is-truncated": "",
+                      "with-tooltip": "",
+                      "tooltip-text": e.caption,
+                      "tooltip-placement": "left"
+                    }, {
+                      default: m(() => [
+                        h(I(e.caption), 1)
+                      ]),
+                      _: 2
+                    }, 1032, ["tooltip-text"])
+                  ])
+                ], 8, O)
+              ]),
+              _: 2
+            }, 1032, ["text", "disabled"])
+          ], 2))), 128))
+        ], 16)
+      ], 16)
+    ]));
+  }
+});
+export {
+  ae as default
+};

package/components/chart/ChartLoader.vue.js

@@ -0,0 +1,25 @@
+import { openBlock as o, createElementBlock as c, pushScopeId as r, popScopeId as s, createElementVNode as t } from "vue";
+/* empty css                  */import a from "../../_virtual/_plugin-vue_export-helper.js";
+const d = {}, i = (e) => (r("data-v-142c444a"), e = e(), s(), e), n = { class: "chart-loader" }, p = /* @__PURE__ */ i(() => /* @__PURE__ */ t("svg", {
+  xmlns: "http://www.w3.org/2000/svg",
+  viewBox: "0 0 1072 275",
+  preserveAspectRatio: "none",
+  width: "100%",
+  height: "100%",
+  fill: "none"
+}, [
+  /* @__PURE__ */ t("path", {
+    d: "M499.744 87.7024L499 87.4816C399.137 70.0475 293 138.418 218 173.72C120 219.848 87 235.892 0 275L1072 275C979 -57.3526 836.258 -31.5829 732 59.404C648.885 131.939 570.549 108.704 499.744 87.7024Z",
+    fill: "black",
+    "fill-opacity": "0.05"
+  })
+], -1)), _ = [
+  p
+];
+function l(e, h) {
+  return o(), c("div", n, _);
+}
+const w = /* @__PURE__ */ a(d, [["render", l], ["__scopeId", "data-v-142c444a"]]);
+export {
+  w as default
+};

package/components/chart/ChartTooltip.vue.d.ts

@@ -1,8 +1,7 @@
-import { TooltipItem } from 'chart.js';
-import { ValueFormat } from '@/components/chart/types';
+import { MyTooltipItem, ValueFormat } from '@/components/chart/types';
 declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
     title?: string;
-    dataPoints: TooltipItem<'line'>[];
+    dataPoints: MyTooltipItem<'line'>[];
     xAxisFormat?: ValueFormat;
     yAxisFormat?: ValueFormat;
     totalLabel?: string;
@@ -16,7 +15,7 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
     totalValue: any;
 }>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
     title?: string;
-    dataPoints: TooltipItem<'line'>[];
+    dataPoints: MyTooltipItem<'line'>[];
     xAxisFormat?: ValueFormat;
     yAxisFormat?: ValueFormat;
     totalLabel?: string;
@@ -30,7 +29,7 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
     totalValue: any;
 }>>>, {
     title: string;
-    dataPoints: TooltipItem<'line'>[];
+    dataPoints: MyTooltipItem<'line'>[];
     xAxisFormat: ValueFormat;
     yAxisFormat: ValueFormat;
     totalLabel: string;

package/components/chart/ChartTooltip.vue.js

@@ -0,0 +1,7 @@
+import o from "./ChartTooltip.vue2.js";
+/* empty css                   */import t from "../../_virtual/_plugin-vue_export-helper.js";
+// import "../../ChartTooltip.vue_vue_type_style_index_0_scoped_6744325c_lang.css"; //*');
+const s = /* @__PURE__ */ t(o, [["__scopeId", "data-v-6744325c"]]);
+export {
+  s as default
+};