vue-chrts 0.1.0-beta.2 → 0.1.0-beta.3

package/README.md

@@ -1,5 +1,86 @@
-# Vue 3 + TypeScript + Vite
+# Vue-Chrts
 
-This template should help get you started developing with Vue 3 and TypeScript in Vite. The template uses Vue 3 `<script setup>` SFCs, check out the [script setup docs](https://v3.vuejs.org/api/sfc-script-setup.html#sfc-script-setup) to learn more.
+A Vue 3 charts package inspired by [Tremor](https://tremor.so/), built on top of [Unovis](https://unovis.dev). Vue-Chrts provides beautiful, responsive charts for your Vue applications with minimal setup.
 
-Learn more about the recommended Project Setup and IDE Support in the [Vue Docs TypeScript Guide](https://vuejs.org/guide/typescript/overview.html#project-setup).
+![alt text](https://nuxtcharts.com/og-image.png)
+
+[Check the docs and examples](https://nuxtcharts.com/docs)
+
+## Features
+
+- 📊 Multiple chart types: Line, Bar, Area, Stacked Area, Donut
+- 🎨 Customizable appearance
+- 📱 Responsive design
+- 💡 Simple, intuitive API
+- 🚀 Built with Vue 3 and TypeScript
+
+## Installation
+
+```bash
+# npm
+npm install vue-chrts
+
+# yarn
+yarn add vue-chrts
+
+# pnpm
+pnpm add vue-chrts
+```
+[Check the docs and examples](https://nuxtcharts.com/docs)
+
+## Usage Example
+
+```vue
+<script setup>
+import { LineChart } from 'vue-chrts';
+
+const data = [
+  { month: 'Jan', sales: 100, profit: 50 },
+  { month: 'Feb', sales: 120, profit: 55 },
+  { month: 'Mar', sales: 180, profit: 80 },
+  { month: 'Apr', sales: 110, profit: 40 },
+  { month: 'May', sales: 90, profit: 30 },
+];
+
+const categories = {
+  sales: {
+    name: 'Sales',
+    color: '#3b82f6'
+  },
+  profit: {
+    name: 'Profit', 
+    color: '#10b981'
+  }
+};
+
+const xFormatter = (i) => data[i].month;
+</script>
+
+<template>
+  <LineChart
+    :data="data"
+    :categories="categories"
+    :height="300"
+    :xFormatter="xFormatter"
+    xLabel="Month"
+    yLabel="Amount"
+  />
+</template>
+```
+[Check the docs and examples](https://nuxtcharts.com/docs)
+
+## Available Charts
+
+- `LineChart`
+- `BarChart`
+- `AreaChart`
+- `AreaStackedChart`
+- `DonutChart`
+
+## Credits
+
+This library is inspired by [Tremor](https://tremor.so/) and built on top of [Unovis](https://unovis.dev).
+
+## License
+
+MIT

package/dist/components/AreaChart/AreaChart.js

@@ -0,0 +1,133 @@
+import { defineComponent as D, computed as c, createApp as N, createElementBlock as d, openBlock as l, normalizeClass as v, createVNode as s, createCommentVNode as g, unref as t, withCtx as $, createBlock as k, Fragment as L, renderList as x, mergeProps as P } from "vue";
+import { Position as T, CurveType as b } from "@unovis/ts";
+import { VisXYContainer as j, VisTooltip as F, VisArea as A, VisLine as w, VisAxis as B, VisCrosshair as z, VisBulletLegend as I } from "@unovis/vue";
+import M from "../Tooltip.js";
+import { LegendPosition as O } from "../../types.js";
+import { getDistributedIndices as X } from "../../utils.js";
+const Q = /* @__PURE__ */ D({
+  __name: "AreaChart",
+  props: {
+    data: {},
+    height: {},
+    xLabel: {},
+    yLabel: {},
+    categories: {},
+    xFormatter: {},
+    yFormatter: {},
+    curveType: {},
+    xNumTicks: { default: (a) => a.data.length > 24 ? 24 / 4 : a.data.length - 1 },
+    yNumTicks: { default: (a) => a.data.length > 24 ? 24 / 4 : a.data.length - 1 },
+    hideLegend: { type: Boolean },
+    hideTooltip: { type: Boolean },
+    xGridLine: { type: Boolean },
+    xDomainLine: { type: Boolean },
+    yGridLine: { type: Boolean },
+    yDomainLine: { type: Boolean },
+    legendPosition: {}
+  },
+  setup(a) {
+    const n = a, u = Object.values(n.categories).map((e) => e.color), V = c(() => (e) => {
+      if (typeof window > "u" || typeof document > "u")
+        return "";
+      try {
+        const o = N(M, {
+          data: e,
+          categories: n.categories
+        }), i = document.createElement("div");
+        o.mount(i);
+        const r = i.innerHTML;
+        return o.unmount(), r;
+      } catch {
+        return "";
+      }
+    });
+    function C(e) {
+      var o;
+      return {
+        y: (i) => Number(i[e]),
+        color: ((o = n.categories[e]) == null ? void 0 : o.color) ?? "#3b82f6"
+      };
+    }
+    const G = u.map(
+      (e, o) => `
+  <linearGradient id="gradient${o}-${e}" gradientTransform="rotate(90)">
+    <stop offset="0%" stop-color="${e}" stop-opacity="1" />
+    <stop offset="100%" stop-color="${e}" stop-opacity="0" />
+  </linearGradient>
+`
+    ).join(""), h = c(
+      () => n.legendPosition === O.Top
+    ), m = c(() => X(n.data.length, n.xNumTicks)), p = c(() => {
+      var e;
+      return !((e = n.data) != null && e.length) || !m || m.value.length === 0 ? [] : m.value.map((o) => n.data[o]);
+    });
+    return (e, o) => (l(), d("div", {
+      class: v(["flex flex-col space-y-4", { "flex-col-reverse": h.value }])
+    }, [
+      s(t(j), {
+        data: p.value,
+        height: e.height,
+        "svg-defs": t(G)
+      }, {
+        default: $(() => [
+          e.hideTooltip ? g("", !0) : (l(), k(t(F), {
+            key: 0,
+            "horizontal-placement": t(T).Right,
+            "vertical-placement": t(T).Top
+          }, null, 8, ["horizontal-placement", "vertical-placement"])),
+          (l(!0), d(L, null, x(Object.keys(n.categories), (i, r) => (l(), d(L, { key: r }, [
+            s(t(A), P({
+              x: (f, y) => y,
+              ref_for: !0
+            }, C(i), {
+              color: `url(#gradient${r}-${t(u)[r]})`,
+              opacity: 0.5,
+              "curve-type": e.curveType ?? t(b).MonotoneX
+            }), null, 16, ["x", "color", "curve-type"]),
+            s(t(w), {
+              x: (f, y) => y,
+              y: (f) => f[i],
+              color: t(u)[r],
+              "curve-type": e.curveType ?? t(b).MonotoneX
+            }, null, 8, ["x", "y", "color", "curve-type"])
+          ], 64))), 128)),
+          s(t(B), {
+            type: "x",
+            "num-ticks": p.value.length,
+            "tick-format": (i, r) => e.xFormatter(p.value[i], r),
+            label: e.xLabel,
+            "grid-line": e.xGridLine,
+            "domain-line": e.xDomainLine,
+            "tick-line": !!e.xGridLine
+          }, null, 8, ["num-ticks", "tick-format", "label", "grid-line", "domain-line", "tick-line"]),
+          s(t(B), {
+            type: "y",
+            "num-ticks": e.yNumTicks,
+            "tick-format": e.yFormatter,
+            label: e.yLabel,
+            "grid-line": e.yGridLine,
+            "domain-line": e.yDomainLine,
+            "tick-line": !!e.yGridLine
+          }, null, 8, ["num-ticks", "tick-format", "label", "grid-line", "domain-line", "tick-line"]),
+          e.hideTooltip ? g("", !0) : (l(), k(t(z), {
+            key: 1,
+            color: "#666",
+            template: V.value
+          }, null, 8, ["template"]))
+        ]),
+        _: 1
+      }, 8, ["data", "height", "svg-defs"]),
+      e.hideLegend ? g("", !0) : (l(), d("div", {
+        key: 0,
+        class: v(["flex items center justify-end", { "pb-4": h.value }])
+      }, [
+        s(t(I), {
+          items: Object.values(e.categories)
+        }, null, 8, ["items"])
+      ], 2))
+    ], 2));
+  }
+});
+export {
+  Q as default
+};

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

@@ -0,0 +1,14 @@
+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<{} & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, never> & AreaChartProps<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/AreaChart/AreaChart2.js

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

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

@@ -0,0 +1,83 @@
+import { LegendPosition } from '../../types';
+import { BulletLegendItemInterface, CurveType } from '@unovis/ts';
+export interface AreaChartProps<T> {
+    /**
+     * The data to be displayed in the area chart.
+     * Each element of the array represents a data point.
+     * The structure of 'T' should be compatible with the chart's rendering logic.
+     */
+    data: T[];
+    /**
+     * The height of the chart in pixels.
+     */
+    height: number;
+    /**
+     * Optional label for the x-axis.
+     */
+    xLabel?: string;
+    /**
+     * Optional label for the y-axis.
+     */
+    yLabel?: string;
+    /**
+     * A record mapping category keys to `BulletLegendItemInterface` objects.
+     * This defines the visual representation and labels for each category in the chart's legend.
+     */
+    categories: Record<string, BulletLegendItemInterface>;
+    /**
+     * A function that formats the x-axis tick labels.
+     * @param item The x-axis value to be formatted.
+     * @param idx The index of the data point.
+     * @returns The formatted x-axis label.
+     */
+    xFormatter: (item: T, idx: number) => string | number;
+    /**
+     * An optional function that formats the y-axis tick labels.
+     * @param i The value to be formatted.
+     * @param idx The index of the data point (optional).
+     * @returns The formatted y-axis label or value.
+     */
+    yFormatter?: (i: number, idx?: number) => string | number;
+    /**
+     * The type of curve to use for the area chart lines.
+     * See `CurveType` for available options.
+     */
+    curveType?: CurveType;
+    /**
+     * The desired number of ticks on the x-axis.
+     */
+    xNumTicks?: number;
+    /**
+     * The desired number of ticks on the y-axis.
+     */
+    yNumTicks?: number;
+    /**
+     * If `true`, hides the chart legend.
+     */
+    hideLegend?: boolean;
+    /**
+     * If `true`, hides the chart tooltip.
+     */
+    hideTooltip?: boolean;
+    /**
+     * If `true`, displays grid lines along the x-axis.
+     */
+    xGridLine?: boolean;
+    /**
+     * If `true`, displays a domain line (axis line) along the x-axis.
+     */
+    xDomainLine?: boolean;
+    /**
+     * If `true`, displays grid lines along the y-axis.
+     */
+    yGridLine?: boolean;
+    /**
+     * If `true`, displays a domain line (axis line) along the y-axis.
+     */
+    yDomainLine?: boolean;
+    /**
+     * Optional position for the legend, if applicable.
+     * See `LegendPosition` for available options.
+     */
+    legendPosition?: LegendPosition;
+}

package/dist/components/AreaStackedChart/AreaStackedChart.js

@@ -0,0 +1,69 @@
+import { defineComponent as d, computed as f, createApp as h, createElementBlock as y, openBlock as a, createVNode as o, createElementVNode as g, unref as t, withCtx as v, createBlock as _, createCommentVNode as V } from "vue";
+import { VisXYContainer as k, VisArea as C, VisAxis as c, VisCrosshair as T, VisBulletLegend as b } from "@unovis/vue";
+import { CurveType as x } from "@unovis/ts";
+import B from "../Tooltip.js";
+const N = { class: "flex flex-col space-y-4" }, A = { class: "flex items center justify-end" }, O = /* @__PURE__ */ d({
+  __name: "AreaStackedChart",
+  props: {
+    data: {},
+    height: {},
+    categories: {},
+    hideTooltip: { type: Boolean }
+  },
+  setup(s) {
+    const i = s, l = f(() => (e) => {
+      if (typeof window > "u" || typeof document > "u")
+        return "";
+      try {
+        const r = h(B, {
+          data: e,
+          categories: i.categories
+        }), n = document.createElement("div");
+        r.mount(n);
+        const p = n.innerHTML;
+        return r.unmount(), p;
+      } catch {
+        return "";
+      }
+    }), m = (e) => Number.parseInt(e.time), u = [(e) => e.firstTime, (e) => e.returning];
+    return (e, r) => (a(), y("div", N, [
+      o(t(k), {
+        data: e.data,
+        height: e.height
+      }, {
+        default: v(() => [
+          o(t(C), {
+            x: m,
+            y: u,
+            color: Object.values(i.categories).map((n) => n.color),
+            "curve-type": t(x).Linear
+          }, null, 8, ["color", "curve-type"]),
+          o(t(c), {
+            type: "x",
+            label: "Time",
+            "num-ticks": 12
+          }),
+          o(t(c), {
+            type: "y",
+            label: "Number of visitors",
+            "num-ticks": 3
+          }),
+          e.hideTooltip ? V("", !0) : (a(), _(t(T), {
+            key: 0,
+            color: "#666",
+            template: l.value
+          }, null, 8, ["template"]))
+        ]),
+        _: 1
+      }, 8, ["data", "height"]),
+      g("div", A, [
+        o(t(b), {
+          items: Object.values(e.categories)
+        }, null, 8, ["items"])
+      ])
+    ]));
+  }
+});
+export {
+  O as default
+};

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

@@ -0,0 +1,20 @@
+import { BulletLegendItemInterface } from '@unovis/ts';
+export type AreaStackedChartProps<T> = {
+    data: T[];
+    height: number;
+    categories: Record<string, BulletLegendItemInterface>;
+    hideTooltip?: boolean;
+};
+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/AreaStackedChart/AreaStackedChart2.js

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

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

@@ -0,0 +1,58 @@
+import { BulletLegendItemInterface } from '@unovis/ts';
+export interface AreaStackedChartProps<T> {
+    /**
+     * The data to be displayed in the stacked area chart.
+     * Each element of the array represents a data point.
+     * The structure of 'T' should be compatible with the chart's rendering logic.
+     */
+    data: T[];
+    /**
+     * The height of the chart in pixels.
+     */
+    height: number;
+    /**
+     * A record mapping category keys to `BulletLegendItemInterface` objects.
+     * This defines the visual representation and labels for each category in the chart's legend.
+     */
+    categories: Record<string, BulletLegendItemInterface>;
+    /**
+     * If `true`, hides the chart tooltip.
+     */
+    hideTooltip?: boolean;
+    /**
+     * Optional label for the x-axis.
+     */
+    xLabel?: string;
+    /**
+     * Optional label for the y-axis.
+     */
+    yLabel?: string;
+    /**
+     * If `true`, hides the chart legend.
+     */
+    hideLegend?: boolean;
+    /**
+     * If `true`, displays grid lines along the x-axis.
+     */
+    xGridLine?: boolean;
+    /**
+     * If `true`, displays a domain line (axis line) along the x-axis.
+     */
+    xDomainLine?: boolean;
+    /**
+     * If `true`, displays grid lines along the y-axis.
+     */
+    yGridLine?: boolean;
+    /**
+     * If `true`, displays a domain line (axis line) along the y-axis.
+     */
+    yDomainLine?: boolean;
+    /**
+     * If `true`, displays tick lines on the x-axis.
+     */
+    xTickLine?: boolean;
+    /**
+     * If `true`, displays tick lines on the y-axis.
+     */
+    yTickLine?: boolean;
+}

package/dist/components/BarChart/BarChart.js

@@ -0,0 +1,123 @@
+import { defineComponent as v, computed as d, createApp as B, createElementBlock as k, openBlock as c, normalizeClass as h, createVNode as l, createCommentVNode as T, unref as i, withCtx as V, createBlock as L } from "vue";
+import { Orientation as s, StackedBar as P, GroupedBar as C } from "@unovis/ts";
+import { VisXYContainer as D, VisTooltip as G, VisGroupedBar as N, VisStackedBar as A, VisAxis as b, VisBulletLegend as F } from "@unovis/vue";
+import x from "../Tooltip.js";
+import { LegendPosition as j } from "../../types.js";
+import { getDistributedIndices as w } from "../../utils.js";
+const M = /* @__PURE__ */ v({
+  __name: "BarChart",
+  props: {
+    data: {},
+    stacked: { type: Boolean },
+    height: {},
+    xLabel: {},
+    yLabel: {},
+    categories: {},
+    xFormatter: {},
+    yFormatter: {},
+    yNumTicks: { default: (t) => t.data.length > 24 ? 24 / 4 : t.data.length - 1 },
+    xNumTicks: { default: (t) => t.data.length > 24 ? 24 / 4 : t.data.length - 1 },
+    yAxis: {},
+    groupPadding: {},
+    barPadding: {},
+    radius: {},
+    hideLegend: { type: Boolean },
+    orientation: { default: s.Vertical },
+    legendPosition: {},
+    xDomainLine: { type: Boolean },
+    yDomainLine: { type: Boolean },
+    xTickLine: { type: Boolean },
+    yTickLine: { type: Boolean },
+    xGridLine: { type: Boolean },
+    yGridLine: { type: Boolean, default: !0 }
+  },
+  setup(t) {
+    const a = t, g = d(() => a.yAxis.map((e) => (n) => n[e])), p = (e, n) => Object.values(a.categories)[n].color, y = d(
+      () => a.legendPosition === j.Top
+    ), m = d(
+      () => w(a.data.length, a.xNumTicks)
+    ), u = d(() => {
+      var e;
+      return !((e = a.data) != null && e.length) || !m || m.value.length === 0 ? [] : m.value.map((n) => a.data[n]);
+    }), f = d(() => (e) => {
+      if (typeof window > "u" || typeof document > "u")
+        return "";
+      try {
+        const n = B(x, {
+          data: e,
+          categories: a.categories
+        }), r = document.createElement("div");
+        n.mount(r);
+        const o = r.innerHTML;
+        return n.unmount(), o;
+      } catch {
+        return "";
+      }
+    });
+    return (e, n) => (c(), k("div", {
+      class: h(["flex flex-col space-y-4", { "flex-col-reverse": y.value }])
+    }, [
+      l(i(D), { height: e.height }, {
+        default: V(() => [
+          l(i(G), {
+            triggers: {
+              [i(C).selectors.bar]: f.value,
+              [i(P).selectors.bar]: f.value
+            }
+          }, null, 8, ["triggers"]),
+          e.stacked ? (c(), L(i(A), {
+            key: 1,
+            data: u.value,
+            x: (r, o) => o,
+            y: g.value,
+            color: p,
+            "rounded-corners": e.radius ?? 0,
+            "group-padding": e.groupPadding ?? 0,
+            "bar-padding": e.barPadding ?? 0.2,
+            orientation: e.orientation ?? i(s).Vertical
+          }, null, 8, ["data", "x", "y", "rounded-corners", "group-padding", "bar-padding", "orientation"])) : (c(), L(i(N), {
+            key: 0,
+            data: u.value,
+            x: (r, o) => o,
+            y: g.value,
+            color: p,
+            "rounded-corners": e.radius ?? 0,
+            "group-padding": e.groupPadding ?? 0,
+            "bar-padding": e.barPadding ?? 0.2,
+            orientation: e.orientation ?? i(s).Vertical
+          }, null, 8, ["data", "x", "y", "rounded-corners", "group-padding", "bar-padding", "orientation"])),
+          l(i(b), {
+            type: "x",
+            "num-ticks": u.value.length,
+            "tick-format": a.orientation === i(s).Horizontal ? e.xFormatter : (r, o) => e.xFormatter(u.value[r], o),
+            label: e.xLabel,
+            "grid-line": e.xGridLine,
+            "domain-line": e.xDomainLine,
+            "tick-line": e.xTickLine
+          }, null, 8, ["num-ticks", "tick-format", "label", "grid-line", "domain-line", "tick-line"]),
+          l(i(b), {
+            type: "y",
+            label: e.yLabel,
+            "grid-line": e.orientation !== i(s).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, ["height"]),
+      e.hideLegend ? T("", !0) : (c(), k("div", {
+        key: 0,
+        class: h(["flex items center justify-end", { "pb-4": y.value }])
+      }, [
+        l(i(F), {
+          items: Object.values(e.categories)
+        }, null, 8, ["items"])
+      ], 2))
+    ], 2));
+  }
+});
+export {
+  M as default
+};

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

@@ -0,0 +1,14 @@
+import { BarChartProps } 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> & BarChartProps<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/BarChart/BarChart2.js

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

package/dist/components/BarChart/types.d.ts

@@ -0,0 +1,106 @@
+import { BulletLegendItemInterface, Orientation, LegendPosition } from '../../types';
+export interface BarChartProps<T> {
+    /**
+     * The data to be displayed in the bar chart.
+     * Each element of the array represents a data point.
+     * The structure of 'T' should be compatible with the chart's rendering logic.
+     */
+    data: T[];
+    /**
+     * If `true`, creates a stacked bar chart instead of grouped bars.
+     */
+    stacked?: boolean;
+    /**
+     * The height of the chart in pixels.
+     */
+    height: number;
+    /**
+     * Optional label for the x-axis.
+     */
+    xLabel?: string;
+    /**
+     * Optional label for the y-axis.
+     */
+    yLabel?: string;
+    /**
+     * A record mapping category keys to `BulletLegendItemInterface` objects.
+     * This defines the visual representation and labels for each category in the chart's legend.
+     */
+    categories: Record<string, BulletLegendItemInterface>;
+    /**
+     * A function that formats the x-axis tick labels.
+     * @param item The x-axis value to be formatted.
+     * @param idx The index of the data point.
+     * @returns The formatted x-axis label.
+     */
+    xFormatter: (item: T, idx: number) => string | number;
+    /**
+     * An optional function that formats the y-axis tick labels.
+     * @param i The value to be formatted.
+     * @param idx The index of the data point (optional).
+     * @returns The formatted y-axis label or value.
+     */
+    yFormatter?: (i: number, idx?: number) => string | number;
+    /**
+     * The desired number of ticks on the y-axis.
+     */
+    yNumTicks?: number;
+    /**
+     * The desired number of ticks on the x-axis.
+     */
+    xNumTicks?: number;
+    /**
+     * An array of property keys from the data object type 'T' to be used for the y-axis values.
+     */
+    yAxis: (keyof T)[];
+    /**
+     * The padding between groups of bars in pixels.
+     */
+    groupPadding?: number;
+    /**
+     * The padding between bars within the same group in pixels.
+     */
+    barPadding?: number;
+    /**
+     * The corner radius of the bars in pixels.
+     */
+    radius?: number;
+    /**
+     * If `true`, hides the chart legend.
+     */
+    hideLegend?: boolean;
+    /**
+     * The orientation of the bars (vertical or horizontal).
+     * See `Orientation` for available options.
+     */
+    orientation?: Orientation;
+    /**
+     * Optional position for the legend, if applicable.
+     * See `LegendPosition` for available options.
+     */
+    legendPosition?: LegendPosition;
+    /**
+     * If `true`, displays a domain line (axis line) along the x-axis.
+     */
+    xDomainLine?: boolean;
+    /**
+     * If `true`, displays a domain line (axis line) along the y-axis.
+     */
+    yDomainLine?: boolean;
+    /**
+     * If `true`, displays tick lines on the x-axis.
+     */
+    xTickLine?: boolean;
+    /**
+     * If `true`, displays tick lines on the y-axis.
+     */
+    yTickLine?: boolean;
+    /**
+     * If `true`, displays grid lines along the x-axis.
+     */
+    xGridLine?: boolean;
+    /**
+     * If `true`, displays grid lines along the y-axis.
+     */
+    yGridLine?: boolean;
+}

package/dist/components/DonutChart/DonutChart.js

@@ -0,0 +1,58 @@
+import { defineComponent as u, createElementBlock as n, openBlock as i, Fragment as m, createElementVNode as f, createCommentVNode as p, createVNode as t, renderSlot as g, unref as o, withCtx as h } from "vue";
+import { Donut as v } from "@unovis/ts";
+import { VisSingleContainer as y, VisTooltip as V, VisDonut as b, VisBulletLegend as C } from "@unovis/vue";
+import { DonutType as _ } from "./types.js";
+const k = { class: "flex items-center justify-center" }, B = {
+  key: 0,
+  class: "flex items-center justify-center mt-4"
+}, w = /* @__PURE__ */ u({
+  __name: "DonutChart",
+  props: {
+    type: {},
+    data: {},
+    height: {},
+    radius: {},
+    hideLegend: { type: Boolean },
+    labels: {}
+  },
+  setup(l) {
+    const r = l, s = (e) => e, a = r.type === _.Half, d = {
+      [v.selectors.segment]: (e) => `<div class='flex items-center'><div class='w-2 h-2 rounded-full mr-2' style='background-color: ${r.labels[e.index].color} ;'></div>
+        <div>${e.data}</div>
+      </vistooltip>
+    </vissinglecontainer>
+  </div>`
+    };
+    return (e, D) => (i(), n(m, null, [
+      f("div", k, [
+        t(o(y), {
+          data: e.data,
+          height: e.height,
+          margin: {}
+        }, {
+          default: h(() => [
+            t(o(V), {
+              "horizontal-shift": 20,
+              "vertical-shift": 20,
+              triggers: d
+            }),
+            t(o(b), {
+              value: s,
+              "corner-radius": e.radius,
+              color: r.labels.map((c) => c.color),
+              "angle-range": a ? [-1.5707963267948966, 1.5707963267948966] : []
+            }, null, 8, ["corner-radius", "color", "angle-range"])
+          ]),
+          _: 1
+        }, 8, ["data", "height"]),
+        g(e.$slots, "default")
+      ]),
+      e.hideLegend ? p("", !0) : (i(), n("div", B, [
+        t(o(C), { items: e.labels }, null, 8, ["items"])
+      ]))
+    ], 64));
+  }
+});
+export {
+  w as default
+};

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

@@ -0,0 +1,18 @@
+import { DonutChartProps } from './types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<DonutChartProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<DonutChartProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/DonutChart/DonutChart2.js

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

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

@@ -0,0 +1,36 @@
+interface DonutChartProps {
+    /**
+     * The type of donut chart to render.
+     * See `DonutType` for available options.
+     */
+    type?: string;
+    /**
+     * The data to be displayed in the donut chart.
+     * Each number in the array represents a segment value.
+     */
+    data: number[];
+    /**
+     * The height of the chart in pixels.
+     */
+    height: number;
+    /**
+     * The radius of the donut in pixels.
+     */
+    radius: number;
+    /**
+     * If `true`, hides the chart legend.
+     */
+    hideLegend?: boolean;
+    /**
+     * An array of label objects defining the name and color for each segment.
+     */
+    labels: {
+        name: string;
+        color: string;
+    }[];
+}
+declare enum DonutType {
+    Half = "half",
+    Full = "full"
+}
+export { type DonutChartProps, DonutType };

package/dist/components/DonutChart/types.js

@@ -0,0 +1,4 @@
+var r = /* @__PURE__ */ ((l) => (l.Half = "half", l.Full = "full", l))(r || {});
+export {
+  r as DonutType
+};

package/dist/components/LineChart/LineChart.js

@@ -0,0 +1,112 @@
+import { defineComponent as B, computed as m, createApp as C, createElementBlock as u, openBlock as r, normalizeClass as g, createVNode as c, createCommentVNode as f, unref as t, withCtx as V, createBlock as h, Fragment as x, renderList as D } from "vue";
+import { Position as k, CurveType as N } from "@unovis/ts";
+import { VisXYContainer as F, VisTooltip as P, VisLine as j, VisAxis as L, VisCrosshair as G, VisBulletLegend as w } from "@unovis/vue";
+import z from "../Tooltip.js";
+import { LegendPosition as I } from "../../types.js";
+import { getDistributedIndices as O } from "../../utils.js";
+const Y = /* @__PURE__ */ B({
+  __name: "LineChart",
+  props: {
+    data: {},
+    height: {},
+    xLabel: {},
+    yLabel: {},
+    categories: {},
+    xFormatter: {},
+    yFormatter: {},
+    curveType: {},
+    hideTooltip: { type: Boolean },
+    yNumTicks: { default: (n) => n.data.length > 24 ? 24 / 4 : n.data.length - 1 },
+    xNumTicks: { default: (n) => n.data.length > 24 ? 24 / 4 : n.data.length - 1 },
+    hideLegend: { type: Boolean },
+    legendPosition: {},
+    xGridLine: { type: Boolean },
+    xDomainLine: { type: Boolean },
+    yGridLine: { type: Boolean },
+    yDomainLine: { type: Boolean },
+    xTickLine: { type: Boolean },
+    yTickLine: { type: Boolean }
+  },
+  setup(n) {
+    const i = n, v = (e) => Object.values(i.categories)[e].color, T = m(() => (e) => {
+      if (typeof window > "u" || typeof document > "u")
+        return "";
+      try {
+        const o = C(z, {
+          data: e,
+          categories: i.categories
+        }), a = document.createElement("div");
+        o.mount(a);
+        const l = a.innerHTML;
+        return o.unmount(), l;
+      } catch {
+        return "";
+      }
+    }), p = m(
+      () => i.legendPosition === I.Top
+    ), s = m(
+      () => O(i.data.length, i.xNumTicks)
+    ), d = m(() => {
+      var e;
+      return !((e = i.data) != null && e.length) || !s || s.value.length === 0 ? [] : s.value.map((o) => i.data[o]);
+    });
+    return (e, o) => (r(), u("div", {
+      class: g(["flex flex-col space-y-4", { "flex-col-reverse": p.value }])
+    }, [
+      c(t(F), {
+        data: d.value,
+        height: e.height
+      }, {
+        default: V(() => [
+          c(t(P), {
+            "horizontal-placement": t(k).Right,
+            "vertical-placement": t(k).Top
+          }, null, 8, ["horizontal-placement", "vertical-placement"]),
+          (r(!0), u(x, null, D(Object.keys(i.categories), (a, l) => (r(), h(t(j), {
+            key: l,
+            x: (y, b) => b,
+            y: (y) => y[a],
+            color: v(l),
+            "curve-type": e.curveType ?? t(N).MonotoneX
+          }, null, 8, ["x", "y", "color", "curve-type"]))), 128)),
+          c(t(L), {
+            type: "x",
+            "num-ticks": d.value.length,
+            "tick-format": (a, l) => e.xFormatter(d.value[a], l),
+            label: e.xLabel,
+            "label-margin": 8,
+            "domain-line": e.xDomainLine,
+            "grid-line": e.xGridLine,
+            "tick-line": e.xTickLine
+          }, null, 8, ["num-ticks", "tick-format", "label", "domain-line", "grid-line", "tick-line"]),
+          c(t(L), {
+            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 ? f("", !0) : (r(), h(t(G), {
+            key: 0,
+            color: "#666",
+            template: T.value
+          }, null, 8, ["template"]))
+        ]),
+        _: 1
+      }, 8, ["data", "height"]),
+      e.hideLegend ? f("", !0) : (r(), u("div", {
+        key: 0,
+        class: g(["flex items center justify-end", { "pb-4": p.value }])
+      }, [
+        c(t(w), {
+          items: Object.values(e.categories)
+        }, null, 8, ["items"])
+      ], 2))
+    ], 2));
+  }
+});
+export {
+  Y as default
+};

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

@@ -0,0 +1,14 @@
+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<{} & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, never> & LineChartProps<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/LineChart/LineChart2.js

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

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

@@ -0,0 +1,90 @@
+import { BulletLegendItemInterface, CurveType, LegendPosition } from '../../types';
+export interface LineChartProps<T> {
+    /**
+     * The data to be displayed in the line chart.
+     * Each element of the array represents a data point.
+     * The structure of 'T' should be compatible with the chart's rendering logic.
+     */
+    data: T[];
+    /**
+     * The height of the chart in pixels.
+     */
+    height: number;
+    /**
+     * Optional label for the x-axis.
+     */
+    xLabel?: string;
+    /**
+     * Optional label for the y-axis.
+     */
+    yLabel?: string;
+    /**
+     * A record mapping category keys to `BulletLegendItemInterface` objects.
+     * This defines the visual representation and labels for each category in the chart's legend.
+     */
+    categories: Record<string, BulletLegendItemInterface>;
+    /**
+     * A function that formats the x-axis tick labels.
+     * @param item The x-axis value to be formatted.
+     * @param idx The index of the data point.
+     * @returns The formatted x-axis label.
+     */
+    xFormatter: (item: T, idx: number) => string | number;
+    /**
+     * An optional function that formats the y-axis tick labels.
+     * @param i The value to be formatted.
+     * @param idx The index of the data point.
+     * @returns The formatted y-axis label.
+     */
+    yFormatter?: (i: number, idx: number) => string;
+    /**
+     * The type of curve to use for the line chart.
+     * See `CurveType` for available options.
+     */
+    curveType?: CurveType;
+    /**
+     * If `true`, hides the chart tooltip.
+     */
+    hideTooltip?: boolean;
+    /**
+     * The desired number of ticks on the y-axis.
+     */
+    yNumTicks?: number;
+    /**
+     * The desired number of ticks on the x-axis.
+     */
+    xNumTicks?: number;
+    /**
+     * If `true`, hides the chart legend.
+     */
+    hideLegend?: boolean;
+    /**
+     * Optional position for the legend, if applicable.
+     * See `LegendPosition` for available options.
+     */
+    legendPosition?: LegendPosition;
+    /**
+     * If `true`, displays grid lines along the x-axis.
+     */
+    xGridLine?: boolean;
+    /**
+     * If `true`, displays a domain line (axis line) along the x-axis.
+     */
+    xDomainLine?: boolean;
+    /**
+     * If `true`, displays grid lines along the y-axis.
+     */
+    yGridLine?: boolean;
+    /**
+     * If `true`, displays a domain line (axis line) along the y-axis.
+     */
+    yDomainLine?: boolean;
+    /**
+     * If `true`, displays tick lines on the x-axis.
+     */
+    xTickLine?: boolean;
+    /**
+     * If `true`, displays tick lines on the y-axis.
+     */
+    yTickLine?: boolean;
+}

package/dist/components/Tooltip.js

@@ -0,0 +1,37 @@
+import { defineComponent as g, computed as m, createElementBlock as r, openBlock as l, Fragment as x, renderList as _, createElementVNode as o, normalizeStyle as n, toDisplayString as a } from "vue";
+const h = /* @__PURE__ */ g({
+  __name: "Tooltip",
+  props: {
+    data: {},
+    categories: {}
+  },
+  setup(s) {
+    const i = s, c = ["_index", "_stacked", "_ending"], p = m(() => Object.entries(i.data ?? []).filter(
+      ([t, d]) => {
+        var e;
+        return !c.includes(t) && ((e = i.categories[t]) == null ? void 0 : e.color);
+      }
+    ));
+    return (t, d) => (l(), r("div", null, [
+      (l(!0), r(x, null, _(p.value, ([e, u]) => (l(), r("div", {
+        key: e,
+        style: { display: "flex", "align-items": "center", "margin-bottom": "4px" }
+      }, [
+        o("span", {
+          style: n([{ width: "8px", height: "8px", "border-radius": "4px", "margin-right": "8px" }, { backgroundColor: t.categories[e].color }])
+        }, null, 4),
+        o("div", null, [
+          o("span", {
+            style: n([{ "font-weight": "600", "margin-right": "8px" }, { color: "var(--tooltip-label-color)" }])
+          }, a(e) + ":", 1),
+          o("span", {
+            style: n([{ "font-weight": "400" }, { color: "var(--tooltip-value-color)" }])
+          }, a(u), 1)
+        ])
+      ]))), 128))
+    ]));
+  }
+});
+export {
+  h as default
+};

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

@@ -0,0 +1,17 @@
+import { BulletLegendItemInterface } from '@unovis/ts';
+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> & {
+        data: T;
+        categories: Record<string, BulletLegendItemInterface>;
+    } & 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/Tooltip2.js

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

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+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, CurveType, Orientation, BulletLegendItemInterface } from './types';
+export { AreaChart, AreaStackedChart, LineChart, BarChart, DonutChart, Orientation, CurveType, LegendPosition };
+export type { BulletLegendItemInterface, };

package/dist/index.js

@@ -0,0 +1,16 @@
+import { default as a } from "./components/AreaChart/AreaChart.js";
+import { default as o } from "./components/AreaStackedChart/AreaStackedChart.js";
+import { default as d } from "./components/LineChart/LineChart.js";
+import { default as u } from "./components/BarChart/BarChart.js";
+import { default as n } from "./components/DonutChart/DonutChart.js";
+import { CurveType as x, LegendPosition as C, Orientation as h } from "./types.js";
+export {
+  a as AreaChart,
+  o as AreaStackedChart,
+  u as BarChart,
+  x as CurveType,
+  n as DonutChart,
+  C as LegendPosition,
+  d as LineChart,
+  h as Orientation
+};

package/dist/types.d.ts

@@ -0,0 +1,42 @@
+import { AreaChartProps } from './components/AreaChart/types';
+import { BarChartProps } from './components/BarChart/types';
+import { LineChartProps } from './components/LineChart/types';
+import { DonutChartProps } from './components/DonutChart/types';
+declare enum LegendPosition {
+    Top = "top",
+    Bottom = "bottom"
+}
+declare enum CurveType {
+    Basis = "basis",
+    BasisClosed = "basisClosed",
+    BasisOpen = "basisOpen",
+    Bundle = "bundle",
+    Cardinal = "cardinal",
+    CardinalClosed = "cardinalClosed",
+    CardinalOpen = "cardinalOpen",
+    CatmullRom = "catmullRom",
+    CatmullRomClosed = "catmullRomClosed",
+    CatmullRomOpen = "catmullRomOpen",
+    Linear = "linear",
+    LinearClosed = "linearClosed",
+    MonotoneX = "monotoneX",
+    MonotoneY = "monotoneY",
+    Natural = "natural",
+    Step = "step",
+    StepAfter = "stepAfter",
+    StepBefore = "stepBefore"
+}
+interface BulletLegendItemInterface {
+    name: string | number;
+    color?: string;
+    className?: string;
+    shape?: any;
+    inactive?: boolean;
+    hidden?: boolean;
+    pointer?: boolean;
+}
+declare enum Orientation {
+    Horizontal = "horizontal",
+    Vertical = "vertical"
+}
+export { LegendPosition, CurveType, Orientation, type AreaChartProps, type BarChartProps, type LineChartProps, type DonutChartProps, type BulletLegendItemInterface, };

package/dist/types.js

@@ -0,0 +1,6 @@
+var l = /* @__PURE__ */ ((a) => (a.Top = "top", a.Bottom = "bottom", a))(l || {}), o = /* @__PURE__ */ ((a) => (a.Basis = "basis", a.BasisClosed = "basisClosed", a.BasisOpen = "basisOpen", a.Bundle = "bundle", a.Cardinal = "cardinal", a.CardinalClosed = "cardinalClosed", a.CardinalOpen = "cardinalOpen", a.CatmullRom = "catmullRom", a.CatmullRomClosed = "catmullRomClosed", a.CatmullRomOpen = "catmullRomOpen", a.Linear = "linear", a.LinearClosed = "linearClosed", a.MonotoneX = "monotoneX", a.MonotoneY = "monotoneY", a.Natural = "natural", a.Step = "step", a.StepAfter = "stepAfter", a.StepBefore = "stepBefore", a))(o || {}), t = /* @__PURE__ */ ((a) => (a.Horizontal = "horizontal", a.Vertical = "vertical", a))(t || {});
+export {
+  o as CurveType,
+  l as LegendPosition,
+  t as Orientation
+};

package/dist/utils.d.ts

@@ -0,0 +1 @@
+export declare function getDistributedIndices(length: number, numTicks: number): number[];

package/dist/utils.js

@@ -0,0 +1,18 @@
+function i(t, r) {
+  if (r <= 0) return [];
+  if (r >= t)
+    return Array.from({ length: t }, (o, e) => e);
+  if (r === 1)
+    return [Math.floor((t - 1) / 2)];
+  if (r === 2)
+    return [0, t - 1];
+  const f = [];
+  for (let o = 0; o < r; o++) {
+    const e = Math.round(o * (t - 1) / (r - 1));
+    f.push(e);
+  }
+  return f;
+}
+export {
+  i as getDistributedIndices
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vue-chrts",
-  "version": "0.1.0-beta.2",
+  "version": "0.1.0-beta.3",
   "type": "module",
   "files": [
     "dist"