vue-chrts 0.2.0-test.7 → 0.2.0-test.9

package/dist/components/BarChart/BarChart.js

@@ -0,0 +1,170 @@
+import { defineComponent as C, useSlots as N, useTemplateRef as O, ref as D, computed as T, createElementBlock as m, openBlock as n, normalizeClass as L, createVNode as g, createCommentVNode as c, createElementVNode as w, unref as i, withCtx as E, createBlock as u, Fragment as M, renderList as S, renderSlot as v } from "vue";
+import { Orientation as l, StackedBar as j, GroupedBar as z } from "@unovis/ts";
+import { getFirstPropertyValue as H } from "../../utils.js";
+import { useStackedGrouped as W } from "./stackedGroupedUtils.js";
+import { VisXYContainer as X, VisTooltip as Y, VisStackedBar as B, VisGroupedBar as $, VisAxis as A, VisBulletLegend as R } from "@unovis/vue";
+import q from "../Tooltip.js";
+import { LegendPosition as U } from "../../types.js";
+const I = {
+  ref: "slotWrapper",
+  class: "hidden"
+}, ae = /* @__PURE__ */ C({
+  __name: "BarChart",
+  props: {
+    data: {},
+    stacked: { type: Boolean },
+    height: {},
+    xLabel: {},
+    yLabel: {},
+    padding: { default: () => ({
+      top: 5,
+      right: 5,
+      bottom: 5,
+      left: 5
+    }) },
+    categories: {},
+    xFormatter: {},
+    yFormatter: {},
+    yNumTicks: { default: (t) => t.data.length > 24 ? 24 / 4 : t.data.length - 1 },
+    minMaxTicksOnly: { type: Boolean },
+    xNumTicks: { default: (t) => t.data.length > 24 ? 24 / 4 : t.data.length - 1 },
+    xExplicitTicks: {},
+    yAxis: {},
+    groupPadding: {},
+    barPadding: {},
+    radius: {},
+    hideLegend: { type: Boolean },
+    hideTooltip: { type: Boolean, default: !1 },
+    orientation: { default: l.Vertical },
+    legendPosition: {},
+    xDomainLine: { type: Boolean },
+    yDomainLine: { type: Boolean },
+    xTickLine: { type: Boolean },
+    yTickLine: { type: Boolean },
+    xGridLine: { type: Boolean },
+    yGridLine: { type: Boolean, default: !0 },
+    hideXAxis: { type: Boolean },
+    hideYAxis: { type: Boolean },
+    stackAndGrouped: { type: Boolean },
+    xAxis: {}
+  },
+  emits: ["click"],
+  setup(t, { emit: V }) {
+    const x = V, a = t, P = N(), y = O("slotWrapper"), r = D();
+    if (!a.yAxis || a.yAxis.length === 0)
+      throw new Error("yAxis is required");
+    const k = T(() => a.yAxis.map((e) => (d) => d[e])), f = (e, d) => {
+      var o;
+      return (o = Object.values(a.categories)[d]) == null ? void 0 : o.color;
+    }, s = W({
+      data: a.data,
+      categories: a.categories,
+      stackAndGrouped: a.stackAndGrouped,
+      xAxis: a.xAxis
+    }), h = T(
+      () => a.legendPosition === U.Top
+    );
+    function b(e) {
+      return r.value = e, G();
+    }
+    function G(e) {
+      return typeof window > "u" ? "" : y.value ? y.value.innerHTML : "";
+    }
+    return (e, d) => (n(), m("div", {
+      class: L(["flex flex-col space-y-4", { "flex-col-reverse": h.value }]),
+      onClick: d[0] || (d[0] = (o) => x("click", o, r.value))
+    }, [
+      g(i(X), {
+        padding: e.padding,
+        height: e.height
+      }, {
+        default: E(() => [
+          g(i(Y), {
+            triggers: {
+              [i(z).selectors.bar]: b,
+              [i(j).selectors.bar]: b
+            }
+          }, null, 8, ["triggers"]),
+          e.stackAndGrouped ? (n(!0), m(M, { key: 0 }, S(i(s).states, (o) => (n(), u(i(B), {
+            key: o,
+            data: i(s).chartData,
+            x: (p, F) => F + i(s).positions[o],
+            y: i(s).bars[o],
+            color: i(s).colorFunctions[o],
+            "rounded-corners": e.radius ?? 0,
+            "group-padding": e.groupPadding ?? 0,
+            "bar-padding": e.barPadding ?? 0.2,
+            orientation: e.orientation ?? i(l).Vertical
+          }, null, 8, ["data", "x", "y", "color", "rounded-corners", "group-padding", "bar-padding", "orientation"]))), 128)) : e.stacked ? (n(), u(i(B), {
+            key: 2,
+            data: e.data,
+            x: (o, p) => p,
+            y: k.value,
+            color: f,
+            "rounded-corners": e.radius ?? 0,
+            "group-padding": e.groupPadding ?? 0,
+            "bar-padding": e.barPadding ?? 0.2,
+            orientation: e.orientation ?? i(l).Vertical
+          }, null, 8, ["data", "x", "y", "rounded-corners", "group-padding", "bar-padding", "orientation"])) : (n(), u(i($), {
+            key: 1,
+            data: e.data,
+            x: (o, p) => p,
+            y: k.value,
+            color: f,
+            "rounded-corners": e.radius ?? 0,
+            "group-padding": e.groupPadding ?? 0,
+            "bar-padding": e.barPadding ?? 0.2,
+            orientation: e.orientation ?? i(l).Vertical
+          }, null, 8, ["data", "x", "y", "rounded-corners", "group-padding", "bar-padding", "orientation"])),
+          e.hideXAxis ? c("", !0) : (n(), u(i(A), {
+            key: 3,
+            type: "x",
+            "tick-format": e.xFormatter,
+            label: e.xLabel,
+            "grid-line": e.xGridLine,
+            "domain-line": !!e.xDomainLine,
+            "tick-line": e.xTickLine,
+            "num-ticks": e.xNumTicks,
+            "tick-values": e.xExplicitTicks,
+            minMaxTicksOnly: e.minMaxTicksOnly
+          }, null, 8, ["tick-format", "label", "grid-line", "domain-line", "tick-line", "num-ticks", "tick-values", "minMaxTicksOnly"])),
+          e.hideYAxis ? c("", !0) : (n(), u(i(A), {
+            key: 4,
+            type: "y",
+            label: e.yLabel,
+            "grid-line": e.orientation !== i(l).Horizontal && e.yGridLine,
+            "domain-line": !!e.yDomainLine,
+            "tick-format": e.yFormatter,
+            "num-ticks": e.yNumTicks,
+            "tick-line": e.yTickLine
+          }, null, 8, ["label", "grid-line", "domain-line", "tick-format", "num-ticks", "tick-line"]))
+        ]),
+        _: 1
+      }, 8, ["padding", "height"]),
+      e.hideLegend ? c("", !0) : (n(), m("div", {
+        key: 0,
+        class: L(["flex items center justify-end", { "pb-4": h.value }])
+      }, [
+        g(i(R), {
+          items: Object.values(a.categories)
+        }, null, 8, ["items"])
+      ], 2)),
+      w("div", I, [
+        i(P).tooltip ? v(e.$slots, "tooltip", {
+          key: 0,
+          values: r.value
+        }) : r.value ? v(e.$slots, "fallback", { key: 1 }, () => [
+          g(q, {
+            data: r.value,
+            categories: a.categories,
+            toolTipTitle: i(H)(r.value) ?? "",
+            yFormatter: a.orientation === i(l).Horizontal ? a.xFormatter : a.yFormatter
+          }, null, 8, ["data", "categories", "toolTipTitle", "yFormatter"])
+        ]) : c("", !0)
+      ], 512)
+    ], 2));
+  }
+});
+export {
+  ae as default
+};

package/dist/components/BarChart/BarChart2.js

@@ -0,0 +1,4 @@
+import f from "./BarChart.js";
+export {
+  f as default
+};

package/dist/components/BarChart/stackedGroupedUtils.js

@@ -0,0 +1,67 @@
+import { computed as u } from "vue";
+import { flattenData as i } from "../../utils.js";
+function b(t) {
+  return u(() => {
+    const o = f(t.categories), e = l(t.categories, o), r = p(e, t.categories), c = d(e), n = m(r), s = h(o);
+    console.log(t, "config");
+    const a = t.stackAndGrouped ? i(t.data, t.xAxis) : t.data;
+    return {
+      states: o,
+      groupedByState: e,
+      colors: r,
+      bars: c,
+      colorFunctions: n,
+      positions: s,
+      chartData: a
+    };
+  });
+}
+function f(t) {
+  const o = /* @__PURE__ */ new Set();
+  return Object.keys(t).forEach((r) => {
+    const c = r.match(/([A-Z][a-z]+)$/);
+    c && o.add(c[1]);
+  }), Array.from(o);
+}
+function l(t, o) {
+  const e = {};
+  return o.forEach((r) => {
+    e[r] = Object.keys(t).filter(
+      (c) => c.endsWith(r)
+    );
+  }), e;
+}
+function p(t, o) {
+  const e = {};
+  return Object.entries(t).forEach(([r, c]) => {
+    e[r] = c.map((n) => {
+      var s;
+      return ((s = o[n]) == null ? void 0 : s.color) ?? "#ccc";
+    });
+  }), e;
+}
+function d(t) {
+  const o = {};
+  return Object.entries(t).forEach(([e, r]) => {
+    o[e] = r.map((c) => {
+      const n = c.replace(e, "").toLowerCase();
+      return (s) => s[n + e];
+    });
+  }), o;
+}
+function m(t) {
+  const o = {};
+  return Object.entries(t).forEach(([e, r]) => {
+    o[e] = (c, n) => r[n] ?? "#ccc";
+  }), o;
+}
+function h(t) {
+  const o = t.length, e = 0.4, r = {};
+  return t.forEach((c, n) => {
+    const s = (n - (o - 1) / 2) * e;
+    r[c] = s;
+  }), r;
+}
+export {
+  b as useStackedGrouped
+};

package/dist/components/Tooltip.js

@@ -0,0 +1,48 @@
+import { defineComponent as b, computed as v, createElementBlock as r, openBlock as l, createElementVNode as o, toDisplayString as i, Fragment as y, renderList as h, normalizeStyle as n } from "vue";
+const f = {
+  class: "capitalize border-b mb-1 pb-1",
+  style: {
+    color: "var(--tooltip-value-color)",
+    borderColor: "rgba(255, 255, 255, 0.05)"
+  }
+}, F = /* @__PURE__ */ b({
+  __name: "Tooltip",
+  props: {
+    data: {},
+    categories: {},
+    toolTipTitle: {},
+    yFormatter: { type: Function }
+  },
+  setup(p) {
+    const a = p, d = ["_index", "_stacked", "_ending"], m = v(() => Object.entries(a.data ?? []).filter(
+      ([e, g]) => !d.includes(e) && Object.keys(a.categories).includes(e)
+    ));
+    return (e, g) => (l(), r("div", null, [
+      o("div", f, i(e.toolTipTitle), 1),
+      (l(!0), r(y, null, h(m.value, ([t, s], u) => {
+        var c;
+        return l(), r("div", {
+          key: t,
+          style: { display: "flex", "align-items": "center", "margin-bottom": "4px" }
+        }, [
+          o("span", {
+            style: n([{ width: "8px", height: "8px", "border-radius": "4px", "margin-right": "8px" }, {
+              backgroundColor: (c = e.categories[t]) != null && c.color ? e.categories[t].color : `var(--vis-color${u})`
+            }])
+          }, null, 4),
+          o("div", null, [
+            o("span", {
+              style: n([{ "font-weight": "600", "margin-right": "8px" }, { color: "var(--tooltip-label-color)" }])
+            }, i(e.categories[t].name) + ":", 1),
+            o("span", {
+              style: n([{ "font-weight": "400" }, { color: "var(--tooltip-value-color)" }])
+            }, i(e.yFormatter ? e.yFormatter(s) : s), 1)
+          ])
+        ]);
+      }), 128))
+    ]));
+  }
+});
+export {
+  F as default
+};

package/dist/components/Tooltip2.js

@@ -0,0 +1,4 @@
+import f from "./Tooltip.js";
+export {
+  f as default
+};

package/dist/index.d.ts

@@ -1,7 +1,2 @@
-import { default as AreaChart } from './components/AreaChart/AreaChart.vue';
-import { default as AreaStackedChart } from './components/AreaStackedChart/AreaStackedChart.vue';
-import { default as LineChart } from './components/LineChart/LineChart.vue';
-import { default as BarChart } from './components/BarChart/BarChart.vue';
-import { default as DonutChart } from './components/DonutChart/DonutChart.vue';
-import { LegendPosition } from './types';
-export { AreaChart, AreaStackedChart, LineChart, BarChart, DonutChart, LegendPosition };
+export { default as BarChart } from './components/BarChart/BarChart.vue';
+export { LegendPosition } from './types';

package/dist/index.js

@@ -0,0 +1,6 @@
+import { default as e } from "./components/BarChart/BarChart.js";
+import { LegendPosition as a } from "./types.js";
+export {
+  e as BarChart,
+  a as LegendPosition
+};

package/dist/types.js

@@ -0,0 +1,4 @@
+var o = /* @__PURE__ */ ((t) => (t.Top = "top", t.Bottom = "bottom", t))(o || {});
+export {
+  o as LegendPosition
+};

package/dist/utils.js

@@ -0,0 +1,24 @@
+function u(t) {
+  if (t && Object.keys(t).length > 0) {
+    const c = Object.keys(t)[0];
+    return t[c];
+  }
+}
+function o(t) {
+  return t.charAt(0).toUpperCase() + t.slice(1);
+}
+const a = (t, c) => {
+  const s = Object.keys(t[0]).filter((e) => e !== c), i = Object.keys(t[0][s[0]]);
+  return t.map((e) => ({
+    month: e.month,
+    ...s.flatMap(
+      (r) => i.map((n) => ({
+        [`${r}${o(n)}`]: e[r][n]
+      }))
+    ).reduce((r, n) => ({ ...r, ...n }), {})
+  }));
+};
+export {
+  a as flattenData,
+  u as getFirstPropertyValue
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vue-chrts",
-  "version": "0.2.0-test.7",
+  "version": "0.2.0-test.9",
   "type": "module",
   "files": [
     "dist"
@@ -20,6 +20,8 @@
     "release": "commit-and-tag-version"
   },
   "peerDependencies": {
+    "@unovis/ts": "^1.5.2",
+    "@unovis/vue": "^1.5.2",
     "vue": "^3.5.13"
   },
   "devDependencies": {

package/dist/components/AreaChart/AreaChart.vue.d.ts

@@ -1,21 +0,0 @@
-import { AreaChartProps } from './types';
-declare const _default: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
-    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
-        readonly onClick?: ((event: MouseEvent, values?: T | undefined) => any) | undefined;
-    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onClick"> & AreaChartProps<T> & Partial<{}>> & import('vue').PublicProps;
-    expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
-    attrs: any;
-    slots: {
-        tooltip?(_: {
-            values: T | undefined;
-        }): any;
-        fallback?(_: {}): any;
-    };
-    emit: (e: "click", event: MouseEvent, values?: T) => void;
-}>) => import('vue').VNode & {
-    __ctx?: Awaited<typeof __VLS_setup>;
-};
-export default _default;
-type __VLS_PrettifyLocal<T> = {
-    [K in keyof T]: T[K];
-} & {};

package/dist/components/AreaStackedChart/AreaStackedChart.vue.d.ts

@@ -1,14 +0,0 @@
-import { AreaStackedChartProps } from './types';
-declare const _default: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
-    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{} & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, never> & AreaStackedChartProps<T> & Partial<{}>> & import('vue').PublicProps;
-    expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
-    attrs: any;
-    slots: {};
-    emit: {};
-}>) => import('vue').VNode & {
-    __ctx?: Awaited<typeof __VLS_setup>;
-};
-export default _default;
-type __VLS_PrettifyLocal<T> = {
-    [K in keyof T]: T[K];
-} & {};

package/dist/components/DonutChart/DonutChart.vue.d.ts

@@ -1,22 +0,0 @@
-import { DonutChartProps } from './types';
-declare const _default: <T extends {}>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
-    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
-        readonly onClick?: ((event: MouseEvent, values?: any) => any) | undefined;
-    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onClick"> & DonutChartProps & Partial<{}>> & import('vue').PublicProps;
-    expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
-    attrs: any;
-    slots: {
-        default?(_: {}): any;
-        tooltip?(_: {
-            values: any;
-        }): any;
-        fallback?(_: {}): any;
-    };
-    emit: (e: "click", event: MouseEvent, values?: any) => void;
-}>) => import('vue').VNode & {
-    __ctx?: Awaited<typeof __VLS_setup>;
-};
-export default _default;
-type __VLS_PrettifyLocal<T> = {
-    [K in keyof T]: T[K];
-} & {};

package/dist/components/LineChart/LineChart.vue.d.ts

@@ -1,21 +0,0 @@
-import { LineChartProps } from './types';
-declare const _default: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
-    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
-        readonly onClick?: ((event: MouseEvent, values?: T | undefined) => any) | undefined;
-    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onClick"> & LineChartProps<T> & Partial<{}>> & import('vue').PublicProps;
-    expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
-    attrs: any;
-    slots: {
-        tooltip?(_: {
-            values: T | undefined;
-        }): any;
-        fallback?(_: {}): any;
-    };
-    emit: (e: "click", event: MouseEvent, values?: T) => void;
-}>) => import('vue').VNode & {
-    __ctx?: Awaited<typeof __VLS_setup>;
-};
-export default _default;
-type __VLS_PrettifyLocal<T> = {
-    [K in keyof T]: T[K];
-} & {};

package/dist/index.js.js

@@ -1,753 +0,0 @@
-import { defineComponent as x, computed as $, createElementBlock as v, openBlock as c, createElementVNode as T, toDisplayString as N, Fragment as O, renderList as U, normalizeStyle as P, useSlots as X, useTemplateRef as R, ref as Y, normalizeClass as w, createVNode as y, createCommentVNode as h, unref as n, withCtx as j, createBlock as b, mergeProps as S, renderSlot as C, createApp as ae } from "vue";
-import { Position as M, CurveType as H, Orientation as F, StackedBar as re, GroupedBar as le, Donut as se } from "@unovis/ts";
-import { VisXYContainer as W, VisTooltip as I, VisArea as te, VisLine as ie, VisAxis as D, VisCrosshair as z, VisBulletLegend as V, VisStackedBar as Q, VisGroupedBar as de, VisSingleContainer as ce, VisDonut as ue } from "@unovis/vue";
-function J(t) {
-  if (t && Object.keys(t).length > 0) {
-    const a = Object.keys(t)[0];
-    return t[a];
-  }
-}
-const pe = (t, a, o, i, l) => {
-  switch (t) {
-    case "circle":
-      return `<circle cx="${a / 2}" cy="${a / 2}" r="${(a - o) / 2}" stroke-width="${o}" stroke="${l}" fill="${i}" />`;
-    case "square":
-      return `<rect x="${o / 2}" y="${o / 2}" width="${a - o}" height="${a - o}" stroke-width="${o}" stroke="${l}" fill="${i}" />`;
-    case "triangle":
-      return `<polygon points="${a / 2},${o / 2} ${a - o / 2},${a - o / 2} ${o / 2},${a - o / 2}" stroke-width="${o}" stroke="${l}" fill="${i}" />`;
-    case "diamond":
-      return `<polygon points="${a / 2},${o / 2} ${a - o / 2},${a / 2} ${a / 2},${a - o / 2} ${o / 2},${a / 2}" stroke-width="${o}" stroke="${l}" fill="${i}" />`;
-    default:
-      return "";
-  }
-};
-function ne(t) {
-  return Object.entries(t).map(([a, o]) => {
-    const i = o.type || "circle", l = o.size || 10, d = o.strokeWidth || 2, s = o.color || "#000", u = o.strokeColor || o.color || "#000";
-    return `<marker id="circle-marker-${a}" viewBox="0 0 ${l} ${l}" refX="${l / 2}" refY="${l / 2}" markerWidth="${l / 2}" markerHeight="${l / 2}">
-        ${pe(i, l, d, s, u)}
-      </marker>`;
-  }).join(`
-`);
-}
-function me(t) {
-  return t.charAt(0).toUpperCase() + t.slice(1);
-}
-const ye = (t, a) => {
-  const o = Object.keys(t[0]).filter((l) => l !== a), i = Object.keys(t[0][o[0]]);
-  return t.map((l) => ({
-    month: l.month,
-    ...o.flatMap(
-      (d) => i.map((s) => ({
-        [`${d}${me(s)}`]: l[d][s]
-      }))
-    ).reduce((d, s) => ({ ...d, ...s }), {})
-  }));
-}, ge = {
-  class: "capitalize border-b mb-1 pb-1",
-  style: {
-    color: "var(--tooltip-value-color)",
-    borderColor: "rgba(255, 255, 255, 0.05)"
-  }
-}, K = /* @__PURE__ */ x({
-  __name: "Tooltip",
-  props: {
-    data: {},
-    categories: {},
-    toolTipTitle: {},
-    yFormatter: { type: Function }
-  },
-  setup(t) {
-    const a = t, o = ["_index", "_stacked", "_ending"], i = $(() => Object.entries(a.data ?? []).filter(
-      ([l, d]) => !o.includes(l) && Object.keys(a.categories).includes(l)
-    ));
-    return (l, d) => (c(), v("div", null, [
-      T("div", ge, N(l.toolTipTitle), 1),
-      (c(!0), v(O, null, U(i.value, ([s, u], L) => {
-        var f;
-        return c(), v("div", {
-          key: s,
-          style: { display: "flex", "align-items": "center", "margin-bottom": "4px" }
-        }, [
-          T("span", {
-            style: P([{ width: "8px", height: "8px", "border-radius": "4px", "margin-right": "8px" }, {
-              backgroundColor: (f = l.categories[s]) != null && f.color ? l.categories[s].color : `var(--vis-color${L})`
-            }])
-          }, null, 4),
-          T("div", null, [
-            T("span", {
-              style: P([{ "font-weight": "600", "margin-right": "8px" }, { color: "var(--tooltip-label-color)" }])
-            }, N(l.categories[s].name) + ":", 1),
-            T("span", {
-              style: P([{ "font-weight": "400" }, { color: "var(--tooltip-value-color)" }])
-            }, N(l.yFormatter ? l.yFormatter(u) : u), 1)
-          ])
-        ]);
-      }), 128))
-    ]));
-  }
-});
-var q = /* @__PURE__ */ ((t) => (t.Top = "top", t.Bottom = "bottom", t))(q || {});
-const fe = {
-  ref: "slotWrapper",
-  class: "hidden"
-}, E = 24, _ = 4, he = 0.5, ee = "#3b82f6", Ee = /* @__PURE__ */ x({
-  __name: "AreaChart",
-  props: {
-    data: {},
-    height: {},
-    xLabel: {},
-    yLabel: {},
-    padding: { default: () => ({ top: 5, right: 5, bottom: 5, left: 5 }) },
-    categories: {},
-    markerConfig: {},
-    xFormatter: {},
-    yFormatter: {},
-    curveType: {},
-    lineWidth: { default: 2 },
-    lineDashArray: {},
-    xNumTicks: { default: (t) => t.data.length > E ? E / _ : t.data.length - 1 },
-    xExplicitTicks: {},
-    minMaxTicksOnly: { type: Boolean },
-    yNumTicks: { default: (t) => t.data.length > E ? E / _ : t.data.length - 1 },
-    hideLegend: { type: Boolean },
-    hideTooltip: { type: Boolean },
-    legendPosition: {},
-    xDomainLine: { type: Boolean },
-    yDomainLine: { type: Boolean },
-    xTickLine: { type: Boolean },
-    yTickLine: { type: Boolean },
-    xGridLine: { type: Boolean },
-    yGridLine: { type: Boolean },
-    hideXAxis: { type: Boolean },
-    hideYAxis: { type: Boolean },
-    crosshairConfig: { default: () => ({
-      color: "#666"
-    }) }
-  },
-  emits: ["click"],
-  setup(t, { emit: a }) {
-    const o = a, i = t, l = X(), d = R("slotWrapper"), s = Y(), u = $(
-      () => Object.values(i.categories).map((r) => r.color)
-    ), L = $(() => i.markerConfig ? ne(i.markerConfig) : ""), f = $(() => i.legendPosition === q.Top), B = $(() => {
-      const r = (p, k) => `
-    <linearGradient id="gradient${p}-${k}" gradientTransform="rotate(90)">
-      <stop offset="0%" stop-color="${k}" stop-opacity="1" />
-      <stop offset="100%" stop-color="${k}" stop-opacity="0" />
-    </linearGradient>
-  `, m = (p, k) => `
-    <linearGradient id="gradient${p}-${k}" gradientTransform="rotate(90)">
-      <stop offset="0%" style="stop-color:var(--vis-color0);stop-opacity:1" />
-      <stop offset="100%" style="stop-color:var(--vis-color0);stop-opacity:0" />
-    </linearGradient>
-  `;
-      return u.value.map(
-        (p, k) => p != null && p.includes("#") ? r(k, p) : m(k, p ?? ee)
-      ).join("");
-    });
-    function g(r) {
-      var m;
-      return {
-        y: (p) => Number(p[r]),
-        color: ((m = i.categories[r]) == null ? void 0 : m.color) ?? ee
-      };
-    }
-    function A(r) {
-      return typeof window > "u" ? "" : d.value ? d.value.innerHTML : "";
-    }
-    function e(r) {
-      return s.value = r, A();
-    }
-    return (r, m) => (c(), v("div", {
-      class: w(["flex flex-col", { "flex-col-reverse": f.value, markers: !!i.markerConfig }]),
-      onClick: m[0] || (m[0] = (p) => o("click", p, s.value))
-    }, [
-      y(n(W), {
-        data: r.data,
-        height: r.height,
-        padding: r.padding,
-        "svg-defs": B.value + L.value
-      }, {
-        default: j(() => [
-          r.hideTooltip ? h("", !0) : (c(), b(n(I), {
-            key: 0,
-            "horizontal-placement": n(M).Right,
-            "vertical-placement": n(M).Top
-          }, null, 8, ["horizontal-placement", "vertical-placement"])),
-          (c(!0), v(O, null, U(Object.keys(i.categories), (p, k) => (c(), v(O, { key: p }, [
-            y(n(te), S({
-              x: (G, Z) => Z
-            }, { ref_for: !0 }, g(p), {
-              color: `url(#gradient${k}-${u.value[k]})`,
-              opacity: he,
-              "curve-type": r.curveType ?? n(H).MonotoneX
-            }), null, 16, ["x", "color", "curve-type"]),
-            y(n(ie), {
-              x: (G, Z) => Z,
-              y: (G) => G[p],
-              color: u.value[k],
-              "curve-type": r.curveType ?? n(H).MonotoneX,
-              "line-width": r.lineWidth,
-              lineDashArray: r.lineDashArray
-            }, null, 8, ["x", "y", "color", "curve-type", "line-width", "lineDashArray"])
-          ], 64))), 128)),
-          r.hideXAxis ? h("", !0) : (c(), b(n(D), {
-            key: 1,
-            type: "x",
-            label: r.xLabel,
-            "label-margin": 8,
-            "num-ticks": r.xNumTicks,
-            "tick-format": r.xFormatter,
-            "tick-values": r.xExplicitTicks,
-            "grid-line": r.xGridLine,
-            "domain-line": r.xDomainLine,
-            "tick-line": r.xTickLine,
-            "min-max-ticks-only": r.minMaxTicksOnly
-          }, null, 8, ["label", "num-ticks", "tick-format", "tick-values", "grid-line", "domain-line", "tick-line", "min-max-ticks-only"])),
-          r.hideYAxis ? h("", !0) : (c(), b(n(D), {
-            key: 2,
-            type: "y",
-            label: r.yLabel,
-            "num-ticks": r.yNumTicks,
-            "tick-format": r.yFormatter,
-            "grid-line": r.yGridLine,
-            "domain-line": r.yDomainLine,
-            "tick-line": r.yTickLine
-          }, null, 8, ["label", "num-ticks", "tick-format", "grid-line", "domain-line", "tick-line"])),
-          r.hideTooltip ? h("", !0) : (c(), b(n(z), S({ key: 3 }, r.crosshairConfig, { template: e }), null, 16))
-        ]),
-        _: 1
-      }, 8, ["data", "height", "padding", "svg-defs"]),
-      r.hideLegend ? h("", !0) : (c(), v("div", {
-        key: 0,
-        class: w(["flex items-center justify-end", { "pb-4": f.value, "pt-4": !f.value }])
-      }, [
-        y(n(V), {
-          items: Object.values(r.categories)
-        }, null, 8, ["items"])
-      ], 2)),
-      T("div", fe, [
-        n(l).tooltip ? C(r.$slots, "tooltip", {
-          key: 0,
-          values: s.value
-        }) : s.value ? C(r.$slots, "fallback", { key: 1 }, () => [
-          y(K, {
-            data: s.value,
-            categories: r.categories,
-            toolTipTitle: n(J)(s.value) ?? "",
-            yFormatter: i.yFormatter
-          }, null, 8, ["data", "categories", "toolTipTitle", "yFormatter"])
-        ]) : h("", !0)
-      ], 512)
-    ], 2));
-  }
-}), ke = { class: "flex flex-col space-y-4" }, ve = { class: "flex items center justify-end" }, Ne = /* @__PURE__ */ x({
-  __name: "AreaStackedChart",
-  props: {
-    data: {},
-    height: {},
-    categories: {},
-    hideTooltip: { type: Boolean },
-    xLabel: {},
-    yLabel: {},
-    padding: {},
-    hideLegend: { type: Boolean },
-    xGridLine: { type: Boolean },
-    xDomainLine: { type: Boolean },
-    yGridLine: { type: Boolean },
-    yDomainLine: { type: Boolean },
-    xTickLine: { type: Boolean },
-    yTickLine: { type: Boolean },
-    crosshairConfig: {}
-  },
-  setup(t) {
-    const a = t, o = $(() => (d, s) => {
-      if (typeof window > "u" || typeof document > "u")
-        return "";
-      try {
-        const u = ae(K, {
-          data: d,
-          categories: a.categories
-        }), L = document.createElement("div");
-        u.mount(L);
-        const f = L.innerHTML;
-        return u.unmount(), f;
-      } catch {
-        return "";
-      }
-    }), i = (d) => Number.parseInt(d.time), l = [(d) => d.firstTime, (d) => d.returning];
-    return (d, s) => (c(), v("div", ke, [
-      y(n(W), {
-        data: d.data,
-        padding: d.padding,
-        height: d.height
-      }, {
-        default: j(() => [
-          y(n(te), {
-            x: i,
-            y: l,
-            color: Object.values(a.categories).map((u) => u.color),
-            "curve-type": n(H).Linear
-          }, null, 8, ["color", "curve-type"]),
-          y(n(D), {
-            type: "x",
-            label: "Time",
-            "num-ticks": 12
-          }),
-          y(n(D), {
-            type: "y",
-            label: "Number of visitors",
-            "num-ticks": 3
-          }),
-          d.hideTooltip ? h("", !0) : (c(), b(n(z), S({ key: 0 }, d.crosshairConfig, { template: o.value }), null, 16, ["template"]))
-        ]),
-        _: 1
-      }, 8, ["data", "padding", "height"]),
-      T("div", ve, [
-        y(n(V), {
-          items: Object.values(d.categories)
-        }, null, 8, ["items"])
-      ])
-    ]));
-  }
-}), Te = {
-  ref: "slotWrapper",
-  class: "hidden"
-}, Pe = /* @__PURE__ */ x({
-  __name: "LineChart",
-  props: {
-    data: {},
-    height: {},
-    xLabel: {},
-    yLabel: {},
-    padding: { default: () => ({
-      top: 5,
-      right: 5,
-      bottom: 5,
-      left: 5
-    }) },
-    categories: {},
-    markerConfig: {},
-    xFormatter: {},
-    yFormatter: {},
-    curveType: {},
-    lineWidth: { default: 2 },
-    lineDashArray: {},
-    xNumTicks: { default: (t) => t.data.length > 24 ? 24 / 4 : t.data.length - 1 },
-    xExplicitTicks: {},
-    minMaxTicksOnly: { type: Boolean },
-    yNumTicks: { default: (t) => t.data.length > 24 ? 24 / 4 : t.data.length - 1 },
-    hideTooltip: { type: Boolean },
-    hideLegend: { type: Boolean },
-    legendPosition: {},
-    xGridLine: { type: Boolean },
-    xDomainLine: { type: Boolean },
-    yGridLine: { type: Boolean },
-    yDomainLine: { type: Boolean },
-    xTickLine: { type: Boolean },
-    yTickLine: { type: Boolean },
-    hideXAxis: { type: Boolean },
-    hideYAxis: { type: Boolean },
-    crosshairConfig: { default: () => ({
-      color: "#666"
-    }) }
-  },
-  emits: ["click"],
-  setup(t, { emit: a }) {
-    const o = a, i = t, l = $(() => i.markerConfig ? ne(i.markerConfig) : ""), d = X(), s = R("slotWrapper"), u = Y();
-    function L(e) {
-      return typeof window > "u" ? "" : s.value ? s.value.innerHTML : "";
-    }
-    function f(e) {
-      return u.value = e, L();
-    }
-    const B = $(
-      () => i.legendPosition === q.Top
-    ), g = Object.values(i.categories).map(
-      (e, r) => `var(--vis-color${r})`
-    ), A = (e) => Object.values(i.categories)[e].color ?? g[e];
-    return (e, r) => (c(), v("div", {
-      class: w(["flex flex-col space-y-4", {
-        "flex-col-reverse": B.value,
-        markers: !!i.markerConfig
-      }]),
-      onClick: r[0] || (r[0] = (m) => o("click", m, u.value))
-    }, [
-      y(n(W), {
-        data: e.data,
-        padding: e.padding,
-        height: e.height,
-        svgDefs: l.value
-      }, {
-        default: j(() => [
-          y(n(I), {
-            "horizontal-placement": n(M).Right,
-            "vertical-placement": n(M).Top
-          }, null, 8, ["horizontal-placement", "vertical-placement"]),
-          (c(!0), v(O, null, U(Object.keys(i.categories), (m, p) => (c(), b(n(ie), {
-            key: p,
-            x: (k, G) => G,
-            y: (k) => k[m],
-            color: A(p),
-            "curve-type": e.curveType ?? n(H).MonotoneX,
-            "line-width": e.lineWidth,
-            lineDashArray: e.lineDashArray
-          }, null, 8, ["x", "y", "color", "curve-type", "line-width", "lineDashArray"]))), 128)),
-          e.hideXAxis ? h("", !0) : (c(), b(n(D), {
-            key: 0,
-            type: "x",
-            "tick-format": e.xFormatter,
-            label: e.xLabel,
-            "label-margin": 8,
-            "domain-line": e.xDomainLine,
-            "grid-line": e.xGridLine,
-            "tick-line": e.xTickLine,
-            "num-ticks": e.xNumTicks,
-            "tick-values": e.xExplicitTicks,
-            "min-max-ticks-only": e.minMaxTicksOnly
-          }, null, 8, ["tick-format", "label", "domain-line", "grid-line", "tick-line", "num-ticks", "tick-values", "min-max-ticks-only"])),
-          e.hideYAxis ? h("", !0) : (c(), b(n(D), {
-            key: 1,
-            type: "y",
-            "tick-format": e.yFormatter,
-            label: e.yLabel,
-            "num-ticks": e.yNumTicks,
-            "domain-line": e.yDomainLine,
-            "grid-line": e.yGridLine,
-            "tick-line": e.yTickLine
-          }, null, 8, ["tick-format", "label", "num-ticks", "domain-line", "grid-line", "tick-line"])),
-          e.hideTooltip ? h("", !0) : (c(), b(n(z), S({ key: 2 }, e.crosshairConfig, { template: f }), null, 16))
-        ]),
-        _: 1
-      }, 8, ["data", "padding", "height", "svgDefs"]),
-      e.hideLegend ? h("", !0) : (c(), v("div", {
-        key: 0,
-        class: w(["flex items center justify-end", { "pb-4": B.value }])
-      }, [
-        y(n(V), {
-          items: Object.values(e.categories)
-        }, null, 8, ["items"])
-      ], 2)),
-      T("div", Te, [
-        n(d).tooltip ? C(e.$slots, "tooltip", {
-          key: 0,
-          values: u.value
-        }) : u.value ? C(e.$slots, "fallback", { key: 1 }, () => [
-          y(K, {
-            data: u.value,
-            categories: e.categories,
-            toolTipTitle: n(J)(u.value) ?? "",
-            yFormatter: i.yFormatter
-          }, null, 8, ["data", "categories", "toolTipTitle", "yFormatter"])
-        ]) : h("", !0)
-      ], 512)
-    ], 2));
-  }
-});
-function be(t) {
-  return $(() => {
-    const a = Le(t.categories), o = $e(t.categories, a), i = Be(o, t.categories), l = Ce(o), d = Ae(i), s = De(a);
-    console.log(t, "config");
-    const u = t.stackAndGrouped ? ye(t.data, t.xAxis) : t.data;
-    return {
-      states: a,
-      groupedByState: o,
-      colors: i,
-      bars: l,
-      colorFunctions: d,
-      positions: s,
-      chartData: u
-    };
-  });
-}
-function Le(t) {
-  const a = /* @__PURE__ */ new Set();
-  return Object.keys(t).forEach((i) => {
-    const l = i.match(/([A-Z][a-z]+)$/);
-    l && a.add(l[1]);
-  }), Array.from(a);
-}
-function $e(t, a) {
-  const o = {};
-  return a.forEach((i) => {
-    o[i] = Object.keys(t).filter(
-      (l) => l.endsWith(i)
-    );
-  }), o;
-}
-function Be(t, a) {
-  const o = {};
-  return Object.entries(t).forEach(([i, l]) => {
-    o[i] = l.map((d) => {
-      var s;
-      return ((s = a[d]) == null ? void 0 : s.color) ?? "#ccc";
-    });
-  }), o;
-}
-function Ce(t) {
-  const a = {};
-  return Object.entries(t).forEach(([o, i]) => {
-    a[o] = i.map((l) => {
-      const d = l.replace(o, "").toLowerCase();
-      return (s) => s[d + o];
-    });
-  }), a;
-}
-function Ae(t) {
-  const a = {};
-  return Object.entries(t).forEach(([o, i]) => {
-    a[o] = (l, d) => i[d] ?? "#ccc";
-  }), a;
-}
-function De(t) {
-  const a = t.length, o = 0.4, i = {};
-  return t.forEach((l, d) => {
-    const s = (d - (a - 1) / 2) * o;
-    i[l] = s;
-  }), i;
-}
-const Fe = {
-  ref: "slotWrapper",
-  class: "hidden"
-}, Se = /* @__PURE__ */ x({
-  __name: "BarChart",
-  props: {
-    data: {},
-    stacked: { type: Boolean },
-    height: {},
-    xLabel: {},
-    yLabel: {},
-    padding: { default: () => ({
-      top: 5,
-      right: 5,
-      bottom: 5,
-      left: 5
-    }) },
-    categories: {},
-    xFormatter: {},
-    yFormatter: {},
-    yNumTicks: { default: (t) => t.data.length > 24 ? 24 / 4 : t.data.length - 1 },
-    minMaxTicksOnly: { type: Boolean },
-    xNumTicks: { default: (t) => t.data.length > 24 ? 24 / 4 : t.data.length - 1 },
-    xExplicitTicks: {},
-    yAxis: {},
-    groupPadding: {},
-    barPadding: {},
-    radius: {},
-    hideLegend: { type: Boolean },
-    hideTooltip: { type: Boolean, default: !1 },
-    orientation: { default: F.Vertical },
-    legendPosition: {},
-    xDomainLine: { type: Boolean },
-    yDomainLine: { type: Boolean },
-    xTickLine: { type: Boolean },
-    yTickLine: { type: Boolean },
-    xGridLine: { type: Boolean },
-    yGridLine: { type: Boolean, default: !0 },
-    hideXAxis: { type: Boolean },
-    hideYAxis: { type: Boolean },
-    stackAndGrouped: { type: Boolean },
-    xAxis: {}
-  },
-  emits: ["click"],
-  setup(t, { emit: a }) {
-    const o = a, i = t, l = X(), d = R("slotWrapper"), s = Y();
-    if (!i.yAxis || i.yAxis.length === 0)
-      throw new Error("yAxis is required");
-    const u = $(() => i.yAxis.map((e) => (r) => r[e])), L = (e, r) => {
-      var m;
-      return (m = Object.values(i.categories)[r]) == null ? void 0 : m.color;
-    }, f = be({
-      data: i.data,
-      categories: i.categories,
-      stackAndGrouped: i.stackAndGrouped,
-      xAxis: i.xAxis
-    }), B = $(
-      () => i.legendPosition === q.Top
-    );
-    function g(e) {
-      return s.value = e, A();
-    }
-    function A(e) {
-      return typeof window > "u" ? "" : d.value ? d.value.innerHTML : "";
-    }
-    return (e, r) => (c(), v("div", {
-      class: w(["flex flex-col space-y-4", { "flex-col-reverse": B.value }]),
-      onClick: r[0] || (r[0] = (m) => o("click", m, s.value))
-    }, [
-      y(n(W), {
-        padding: e.padding,
-        height: e.height
-      }, {
-        default: j(() => [
-          y(n(I), {
-            triggers: {
-              [n(le).selectors.bar]: g,
-              [n(re).selectors.bar]: g
-            }
-          }, null, 8, ["triggers"]),
-          e.stackAndGrouped ? (c(!0), v(O, { key: 0 }, U(n(f).states, (m) => (c(), b(n(Q), {
-            key: m,
-            data: n(f).chartData,
-            x: (p, k) => k + n(f).positions[m],
-            y: n(f).bars[m],
-            color: n(f).colorFunctions[m],
-            "rounded-corners": e.radius ?? 0,
-            "group-padding": e.groupPadding ?? 0,
-            "bar-padding": e.barPadding ?? 0.2,
-            orientation: e.orientation ?? n(F).Vertical
-          }, null, 8, ["data", "x", "y", "color", "rounded-corners", "group-padding", "bar-padding", "orientation"]))), 128)) : e.stacked ? (c(), b(n(Q), {
-            key: 2,
-            data: e.data,
-            x: (m, p) => p,
-            y: u.value,
-            color: L,
-            "rounded-corners": e.radius ?? 0,
-            "group-padding": e.groupPadding ?? 0,
-            "bar-padding": e.barPadding ?? 0.2,
-            orientation: e.orientation ?? n(F).Vertical
-          }, null, 8, ["data", "x", "y", "rounded-corners", "group-padding", "bar-padding", "orientation"])) : (c(), b(n(de), {
-            key: 1,
-            data: e.data,
-            x: (m, p) => p,
-            y: u.value,
-            color: L,
-            "rounded-corners": e.radius ?? 0,
-            "group-padding": e.groupPadding ?? 0,
-            "bar-padding": e.barPadding ?? 0.2,
-            orientation: e.orientation ?? n(F).Vertical
-          }, null, 8, ["data", "x", "y", "rounded-corners", "group-padding", "bar-padding", "orientation"])),
-          e.hideXAxis ? h("", !0) : (c(), b(n(D), {
-            key: 3,
-            type: "x",
-            "tick-format": e.xFormatter,
-            label: e.xLabel,
-            "grid-line": e.xGridLine,
-            "domain-line": !!e.xDomainLine,
-            "tick-line": e.xTickLine,
-            "num-ticks": e.xNumTicks,
-            "tick-values": e.xExplicitTicks,
-            minMaxTicksOnly: e.minMaxTicksOnly
-          }, null, 8, ["tick-format", "label", "grid-line", "domain-line", "tick-line", "num-ticks", "tick-values", "minMaxTicksOnly"])),
-          e.hideYAxis ? h("", !0) : (c(), b(n(D), {
-            key: 4,
-            type: "y",
-            label: e.yLabel,
-            "grid-line": e.orientation !== n(F).Horizontal && e.yGridLine,
-            "domain-line": !!e.yDomainLine,
-            "tick-format": e.yFormatter,
-            "num-ticks": e.yNumTicks,
-            "tick-line": e.yTickLine
-          }, null, 8, ["label", "grid-line", "domain-line", "tick-format", "num-ticks", "tick-line"]))
-        ]),
-        _: 1
-      }, 8, ["padding", "height"]),
-      e.hideLegend ? h("", !0) : (c(), v("div", {
-        key: 0,
-        class: w(["flex items center justify-end", { "pb-4": B.value }])
-      }, [
-        y(n(V), {
-          items: Object.values(i.categories)
-        }, null, 8, ["items"])
-      ], 2)),
-      T("div", Fe, [
-        n(l).tooltip ? C(e.$slots, "tooltip", {
-          key: 0,
-          values: s.value
-        }) : s.value ? C(e.$slots, "fallback", { key: 1 }, () => [
-          y(K, {
-            data: s.value,
-            categories: i.categories,
-            toolTipTitle: n(J)(s.value) ?? "",
-            yFormatter: i.orientation === n(F).Horizontal ? i.xFormatter : i.yFormatter
-          }, null, 8, ["data", "categories", "toolTipTitle", "yFormatter"])
-        ]) : h("", !0)
-      ], 512)
-    ], 2));
-  }
-});
-var oe = /* @__PURE__ */ ((t) => (t.Half = "half", t.Full = "full", t))(oe || {});
-const Oe = {
-  ref: "slotWrapper",
-  class: "hidden"
-}, we = { class: "flex items-center" }, xe = {
-  key: 0,
-  class: "flex items-center justify-center mt-4"
-}, Me = /* @__PURE__ */ x({
-  __name: "DonutChart",
-  props: {
-    type: {},
-    data: {},
-    height: {},
-    radius: {},
-    hideLegend: { type: Boolean },
-    labels: {},
-    padAngle: {}
-  },
-  emits: ["click"],
-  setup(t, { emit: a }) {
-    const o = a, i = t, l = X(), d = R("slotWrapper"), s = Y(), u = (g) => g, L = i.type === oe.Half;
-    function f(g) {
-      return s.value = g, B();
-    }
-    function B(g) {
-      return typeof window > "u" ? "" : d.value ? d.value.innerHTML : "";
-    }
-    return (g, A) => (c(), v(O, null, [
-      T("div", {
-        class: "flex items-center justify-center",
-        onClick: A[0] || (A[0] = (e) => o("click", e, s.value))
-      }, [
-        y(n(ce), {
-          data: g.data,
-          height: g.height,
-          margin: {}
-        }, {
-          default: j(() => [
-            y(n(I), {
-              "horizontal-shift": 20,
-              "vertical-shift": 20,
-              triggers: {
-                [n(se).selectors.segment]: f
-              }
-            }, null, 8, ["triggers"]),
-            y(n(ue), {
-              value: u,
-              "corner-radius": g.radius,
-              color: i.labels.map((e) => e.color),
-              "angle-range": L ? [-1.5707963267948966, 1.5707963267948966] : [],
-              "pad-angle": i.padAngle || 0
-            }, null, 8, ["corner-radius", "color", "angle-range", "pad-angle"])
-          ]),
-          _: 1
-        }, 8, ["data", "height"]),
-        C(g.$slots, "default"),
-        T("div", Oe, [
-          n(l).tooltip ? C(g.$slots, "tooltip", {
-            key: 0,
-            values: s.value
-          }) : s.value ? C(g.$slots, "fallback", { key: 1 }, () => [
-            T("div", we, [
-              T("div", {
-                class: "w-2 h-2 rounded-full mr-2",
-                style: P(`background-color: ${i.labels[s.value.index].color} ;`)
-              }, null, 4),
-              T("div", null, N(s.value.data), 1)
-            ])
-          ]) : h("", !0)
-        ], 512)
-      ]),
-      g.hideLegend ? h("", !0) : (c(), v("div", xe, [
-        y(n(V), { items: g.labels }, null, 8, ["items"])
-      ]))
-    ], 64));
-  }
-});
-export {
-  Ee as AreaChart,
-  Ne as AreaStackedChart,
-  Se as BarChart,
-  Me as DonutChart,
-  q as LegendPosition,
-  Pe as LineChart
-};