vue-chrts 2.0.0 → 2.1.0-beta-2

package/dist/components/SankeyChart/SankeyChart.js

@@ -0,0 +1,123 @@
+import { defineComponent as W, useSlots as x, useTemplateRef as V, ref as L, computed as g, createElementBlock as u, openBlock as f, normalizeStyle as d, createVNode as n, createCommentVNode as c, createElementVNode as P, unref as o, withCtx as A, renderSlot as h } from "vue";
+import { VisSingleContainer as N, VisTooltip as p, VisSankey as B, VisBulletLegend as H } from "@unovis/vue";
+import z from "../Tooltip.js";
+import { LegendPosition as M } from "../../types.js";
+import { SankeyNodeAlign as O, Sankey as F } from "@unovis/ts";
+const T = {
+  ref: "slotWrapper",
+  style: { display: "none" }
+}, D = /* @__PURE__ */ W({
+  __name: "SankeyChart",
+  props: {
+    data: {},
+    height: {},
+    padding: { default: () => ({
+      top: 5,
+      right: 5,
+      bottom: 5,
+      left: 5
+    }) },
+    categories: {},
+    hideLegend: { type: Boolean, default: !1 },
+    legendPosition: { default: M.BottomCenter },
+    legendStyle: { default: void 0 },
+    label: {},
+    subLabel: {},
+    nodeColor: {},
+    linkColor: {},
+    linkValue: {},
+    nodeWidth: { default: 10 },
+    nodeAlign: { default: O.Justify },
+    nodePadding: { default: 10 },
+    nodeSort: {},
+    linkSort: {},
+    iterations: { default: 32 },
+    highlightSubtreeOnHover: { type: Boolean, default: !1 },
+    labelFontSize: {},
+    labelColor: {},
+    labelMaxWidth: { default: 70 }
+  },
+  emits: ["click"],
+  setup(e, { emit: b }) {
+    const m = b, t = e, S = x(), k = V("slotWrapper"), i = L(), y = g(() => t.legendPosition.startsWith("top")), v = g(() => t.legendPosition.includes("left") ? "flex-start" : t.legendPosition.includes("right") ? "flex-end" : "center");
+    function C(a) {
+      i.value = a;
+    }
+    return (a, r) => (f(), u("div", {
+      style: d({
+        display: "flex",
+        flexDirection: y.value ? "column-reverse" : "column",
+        gap: "var(--vis-legend-spacing)"
+      }),
+      onClick: r[0] || (r[0] = (l) => m("click", l))
+    }, [
+      n(o(N), {
+        padding: e.padding,
+        height: e.height
+      }, {
+        default: A(() => [
+          n(o(p), {
+            triggers: {
+              [o(F).selectors.node]: (l) => {
+                var s;
+                return C(l), l ? (s = k.value) == null ? void 0 : s.innerHTML : "";
+              }
+            }
+          }, null, 8, ["triggers"]),
+          n(o(B), {
+            data: e.data,
+            label: e.label,
+            subLabel: e.subLabel,
+            nodeColor: e.nodeColor,
+            linkColor: e.linkColor,
+            linkValue: e.linkValue,
+            nodeWidth: e.nodeWidth,
+            nodeAlign: e.nodeAlign,
+            nodePadding: e.nodePadding,
+            nodeSort: e.nodeSort,
+            linkSort: e.linkSort,
+            iterations: e.iterations,
+            highlightSubtreeOnHover: e.highlightSubtreeOnHover,
+            labelFontSize: e.labelFontSize,
+            labelColor: e.labelColor,
+            labelMaxWidth: e.labelMaxWidth
+          }, null, 8, ["data", "label", "subLabel", "nodeColor", "linkColor", "linkValue", "nodeWidth", "nodeAlign", "nodePadding", "nodeSort", "linkSort", "iterations", "highlightSubtreeOnHover", "labelFontSize", "labelColor", "labelMaxWidth"])
+        ]),
+        _: 1
+      }, 8, ["padding", "height"]),
+      !t.hideLegend && t.categories ? (f(), u("div", {
+        key: 0,
+        style: d({
+          display: "flex",
+          justifyContent: v.value
+        })
+      }, [
+        n(o(H), {
+          style: d([
+            t.legendStyle,
+            "display: flex; gap: var(--vis-legend-spacing);"
+          ]),
+          items: Object.values(t.categories).map((l) => ({
+            ...l,
+            color: Array.isArray(l.color) ? l.color[0] : l.color
+          }))
+        }, null, 8, ["style", "items"])
+      ], 4)) : c("", !0),
+      P("div", T, [
+        o(S).tooltip ? h(a.$slots, "tooltip", {
+          key: 0,
+          node: i.value
+        }) : i.value ? h(a.$slots, "fallback", { key: 1 }, () => [
+          n(z, {
+            data: i.value,
+            categories: t.categories ?? {},
+            "title-formatter": (l) => l.label || l.id || "Node"
+          }, null, 8, ["data", "categories", "title-formatter"])
+        ]) : c("", !0)
+      ], 512)
+    ], 4));
+  }
+});
+export {
+  D as default
+};

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

@@ -0,0 +1,22 @@
+import { SankeyInputLink, SankeyInputNode } from '../../types';
+import { SankeyChartProps } from './types';
+declare const _default: <N extends SankeyInputNode, L extends SankeyInputLink>(__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) => any) | undefined;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onClick"> & SankeyChartProps<N, L> & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: {
+        tooltip?(_: {
+            node: any;
+        }): any;
+        fallback?(_: {}): any;
+    };
+    emit: (e: "click", event: MouseEvent) => 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/SankeyChart/SankeyChart2.js

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

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

@@ -0,0 +1,103 @@
+import { BulletLegendItemInterface, LegendPosition, SankeyInputLink, SankeyInputNode, SankeyNodeAlign } from '../../types';
+export type SankeyChartProps<N extends SankeyInputNode, L extends SankeyInputLink> = {
+    /**
+     * The data to be displayed in the Sankey diagram.
+     * Contains nodes and links representing the flow between entities.
+     */
+    data: {
+        nodes: N[];
+        links: L[];
+    };
+    /**
+     * The height of the chart in pixels.
+     */
+    height: number;
+    /**
+     * Optional padding applied to the chart.
+     * Allows specifying individual padding values for the top, right, bottom, and left sides.
+     */
+    padding?: {
+        top: number;
+        right: number;
+        bottom: number;
+        left: 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 legend.
+     */
+    hideLegend?: boolean;
+    /**
+     * Optional position for the legend, if applicable.
+     * See `LegendPosition` for available options.
+     */
+    legendPosition?: LegendPosition;
+    /**
+     * Optional style object for the legend container. Allows custom CSS styling.
+     */
+    legendStyle?: string | Record<string, string>;
+    /**
+     * Node label accessor function or value.
+     */
+    label?: (node: N) => string;
+    /**
+     * Node sub-label accessor function or value.
+     */
+    subLabel?: (node: N) => string;
+    /**
+     * Node color accessor function or value.
+     */
+    nodeColor?: (node: N) => string;
+    /**
+     * Link color accessor function or value.
+     */
+    linkColor?: (link: L) => string;
+    /**
+     * Link value accessor function or value.
+     */
+    linkValue?: (link: L) => number;
+    /**
+     * Sankey node width in pixels. Default: 10
+     */
+    nodeWidth?: number;
+    /**
+     * Sankey node alignment method. Default: 'justify'
+     */
+    nodeAlign?: SankeyNodeAlign;
+    /**
+     * Sankey vertical separation between nodes in pixels. Default: 10
+     */
+    nodePadding?: number;
+    /**
+     * Node sorting function.
+     */
+    nodeSort?: (node1: any, node2: any) => number;
+    /**
+     * Link sorting function.
+     */
+    linkSort?: (link1: any, link2: any) => number;
+    /**
+     * Sankey algorithm iterations. Default: 32
+     */
+    iterations?: number;
+    /**
+     * Highlight the corresponding subtree on node / link hover. Default: false
+     */
+    highlightSubtreeOnHover?: boolean;
+    /**
+     * Label font size in pixels.
+     */
+    labelFontSize?: number;
+    /**
+     * Label color accessor function or value.
+     */
+    labelColor?: (node: N) => string;
+    /**
+     * Maximum label width in pixels. Default: 70
+     */
+    labelMaxWidth?: number;
+};

package/dist/index.d.ts

@@ -4,6 +4,9 @@ import { default as BarChart } from './components/BarChart/BarChart.vue';
 import { default as DonutChart } from './components/DonutChart/DonutChart.vue';
 import { default as BubbleChart } from './components/BubbleChart/BubbleChart.vue';
 import { default as GanttChart } from './components/GanttChart/GanttChart.vue';
-import { LegendPosition, CurveType, Orientation, BulletLegendItemInterface, MarkerConfig, CrosshairConfig, DonutType } from './types';
-export { AreaChart, LineChart, BarChart, DonutChart, BubbleChart, GanttChart, Orientation, CurveType, LegendPosition, DonutType };
-export type { BulletLegendItemInterface, MarkerConfig, CrosshairConfig };
+import { default as DagreGraph } from './components/DagreGraph/DagreGraph.vue';
+import { default as DualChart } from './components/DualChart/DualChart.vue';
+import { default as SankeyChart } from './components/SankeyChart/SankeyChart.vue';
+import { LegendPosition, CurveType, Orientation, MarkerConfig, CrosshairConfig, AxisConfig, DonutType, SankeyNodeAlign, BulletLegendItemInterface, AreaChartProps, AreaChartProps as AreaStackedChartProps, BarChartProps, LineChartProps, DonutChartProps, BubbleChartProps, GanttChartProps, DagreGraphProps, SankeyChartProps, DualChartProps, axisFormatter, SankeyInputNode, SankeyInputLink, GraphNodeDatum, GraphLinkDatum, GraphData, DagreLayoutSettings, DagreRankDir, DagreAlign, DagreRanker, NodeShape, LinkArrowPosition } from './types';
+export { AreaChart, AreaChart as AreaStackedChart, LineChart, BarChart, DonutChart, BubbleChart, GanttChart, DagreGraph, DualChart, SankeyChart, SankeyNodeAlign, Orientation, CurveType, LegendPosition, DonutType };
+export type { BulletLegendItemInterface, AreaChartProps, AreaStackedChartProps, BarChartProps, LineChartProps, DonutChartProps, BubbleChartProps, GanttChartProps, DagreGraphProps, SankeyChartProps, DualChartProps, MarkerConfig, CrosshairConfig, AxisConfig, axisFormatter, SankeyInputNode, SankeyInputLink, GraphNodeDatum, GraphLinkDatum, GraphData, DagreLayoutSettings, DagreRankDir, DagreAlign, DagreRanker, NodeShape, LinkArrowPosition };

package/dist/index.js

@@ -1,20 +1,29 @@
-import { default as e } from "./components/AreaChart/AreaChart.js";
-import { default as o } from "./components/LineChart/LineChart.js";
-import { default as p } from "./components/BarChart/BarChart.js";
-import { default as m } from "./components/DonutChart/DonutChart.js";
+import { default as t, default as e } from "./components/AreaChart/AreaChart.js";
+import { default as f } from "./components/LineChart/LineChart.js";
+import { default as u } from "./components/BarChart/BarChart.js";
+import { default as l } from "./components/DonutChart/DonutChart.js";
 import { default as x } from "./components/BubbleChart/BubbleChart.js";
-import { default as l } from "./components/GanttChart/GanttChart.js";
-import { CurveType as C, LegendPosition as h, Orientation as i } from "./types.js";
-import { DonutType as y } from "./components/DonutChart/types.js";
+import { default as s } from "./components/GanttChart/GanttChart.js";
+import { default as C } from "./components/DagreGraph/DagreGraph.js";
+import { default as y } from "./components/DualChart/DualChart.js";
+import { default as g } from "./components/SankeyChart/SankeyChart.js";
+import { LegendPosition as A } from "./types.js";
+import { DonutType as b } from "./components/DonutChart/types.js";
+import { CurveType as G, Orientation as L, SankeyNodeAlign as T } from "@unovis/ts";
 export {
-  e as AreaChart,
-  p as BarChart,
+  t as AreaChart,
+  e as AreaStackedChart,
+  u as BarChart,
   x as BubbleChart,
-  C as CurveType,
-  m as DonutChart,
-  y as DonutType,
-  l as GanttChart,
-  h as LegendPosition,
-  o as LineChart,
-  i as Orientation
+  G as CurveType,
+  C as DagreGraph,
+  l as DonutChart,
+  b as DonutType,
+  y as DualChart,
+  s as GanttChart,
+  A as LegendPosition,
+  f as LineChart,
+  L as Orientation,
+  g as SankeyChart,
+  T as SankeyNodeAlign
 };

package/dist/types.d.ts

@@ -1,10 +1,16 @@
-import { AreaChartProps } from './components/AreaChart/types';
-import { BarChartProps } from './components/BarChart/types';
-import { LineChartProps } from './components/LineChart/types';
-import { DonutChartProps, DonutType } from './components/DonutChart/types';
-import { BubbleChartProps } from './components/BubbleChart/types';
-import { GanttChartProps } from './components/GanttChart/types';
-declare enum LegendPosition {
+export type { SankeyInputLink, SankeyInputNode, BulletLegendItemInterface } from '@unovis/ts';
+export { SankeyNodeAlign, CurveType, Orientation } from '@unovis/ts';
+export type { AreaChartProps, AreaChartProps as AreaStackedChartProps } from './components/AreaChart/types';
+export type { BarChartProps } from './components/BarChart/types';
+export type { LineChartProps } from './components/LineChart/types';
+export type { DonutChartProps } from './components/DonutChart/types';
+export { DonutType } from './components/DonutChart/types';
+export type { BubbleChartProps } from './components/BubbleChart/types';
+export type { GanttChartProps } from './components/GanttChart/types';
+export type { DagreGraphProps, GraphNodeDatum, GraphLinkDatum, GraphData, DagreLayoutSettings, DagreRankDir, DagreAlign, DagreRanker, NodeShape, LinkArrowPosition, } from './components/DagreGraph/types';
+export type { DualChartProps } from './components/DualChart/types';
+export type { SankeyChartProps } from './components/SankeyChart/types';
+export declare enum LegendPosition {
     TopLeft = "top-left",
     TopCenter = "top-center",
     TopRight = "top-right",
@@ -12,39 +18,6 @@ declare enum LegendPosition {
     BottomCenter = "bottom-center",
     BottomRight = "bottom-right"
 }
-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 | Array<string>;
-    className?: string;
-    inactive?: boolean;
-    hidden?: boolean;
-    pointer?: boolean;
-}
-declare enum Orientation {
-    Horizontal = "horizontal",
-    Vertical = "vertical"
-}
-export { LegendPosition, CurveType, Orientation, DonutType, type AreaChartProps, type BarChartProps, type LineChartProps, type DonutChartProps, type BulletLegendItemInterface, type BubbleChartProps, type GanttChartProps, };
 export type axisFormatter = ((tick: number, i?: number, ticks?: number[]) => string) | ((tick: Date, i?: number, ticks?: Date[]) => string);
 export interface AxisConfig {
     tickLine?: boolean;

package/dist/types.js

@@ -1,6 +1,8 @@
-var o = /* @__PURE__ */ ((t) => (t.TopLeft = "top-left", t.TopCenter = "top-center", t.TopRight = "top-right", t.BottomLeft = "bottom-left", t.BottomCenter = "bottom-center", t.BottomRight = "bottom-right", t))(o || {}), a = /* @__PURE__ */ ((t) => (t.Basis = "basis", t.BasisClosed = "basisClosed", t.BasisOpen = "basisOpen", t.Bundle = "bundle", t.Cardinal = "cardinal", t.CardinalClosed = "cardinalClosed", t.CardinalOpen = "cardinalOpen", t.CatmullRom = "catmullRom", t.CatmullRomClosed = "catmullRomClosed", t.CatmullRomOpen = "catmullRomOpen", t.Linear = "linear", t.LinearClosed = "linearClosed", t.MonotoneX = "monotoneX", t.MonotoneY = "monotoneY", t.Natural = "natural", t.Step = "step", t.StepAfter = "stepAfter", t.StepBefore = "stepBefore", t))(a || {}), l = /* @__PURE__ */ ((t) => (t.Horizontal = "horizontal", t.Vertical = "vertical", t))(l || {});
+import { CurveType as p, Orientation as m, SankeyNodeAlign as f } from "@unovis/ts";
+var r = /* @__PURE__ */ ((t) => (t.TopLeft = "top-left", t.TopCenter = "top-center", t.TopRight = "top-right", t.BottomLeft = "bottom-left", t.BottomCenter = "bottom-center", t.BottomRight = "bottom-right", t))(r || {});
 export {
-  a as CurveType,
-  o as LegendPosition,
-  l as Orientation
+  p as CurveType,
+  r as LegendPosition,
+  m as Orientation,
+  f as SankeyNodeAlign
 };

package/dist/utils.d.ts

@@ -3,6 +3,9 @@ export declare function getDistributedIndices(length: number, numTicks: number):
 export declare function getFirstPropertyValue(obj: unknown): undefined;
 export declare const markerShape: (type: string, size: number, strokeWidth: number, color: string, strokeColor: string) => string;
 export declare function createMarkers(markerConfig: MarkerConfig): string;
+export declare function createScopedMarkers(markerConfig: MarkerConfig, scopeId: string, options?: {
+    includeLegacy?: boolean;
+}): string;
 export declare const flattenData: (data: any[], xAxis: string) => {
     month: any;
 }[];

package/dist/utils.js

@@ -1,50 +1,54 @@
-function p(t) {
-  if (t && Object.keys(t).length > 0) {
-    const e = Object.keys(t)[0];
-    return t[e];
+function i(e) {
+  if (e && Object.keys(e).length > 0) {
+    const r = Object.keys(e)[0];
+    return e[r];
   }
 }
-const o = (t, e, r, n, $) => {
-  switch (t) {
+const s = (e, r, t, a, $) => {
+  switch (e) {
     case "circle":
-      return `<circle cx="${e / 2}" cy="${e / 2}" r="${(e - r) / 2}" stroke-width="${r}" stroke="${$}" fill="${n}" />`;
+      return `<circle cx="${r / 2}" cy="${r / 2}" r="${(r - t) / 2}" stroke-width="${t}" stroke="${$}" fill="${a}" />`;
     case "square":
-      return `<rect x="${r / 2}" y="${r / 2}" width="${e - r}" height="${e - r}" stroke-width="${r}" stroke="${$}" fill="${n}" />`;
+      return `<rect x="${t / 2}" y="${t / 2}" width="${r - t}" height="${r - t}" stroke-width="${t}" stroke="${$}" fill="${a}" />`;
     case "triangle":
-      return `<polygon points="${e / 2},${r / 2} ${e - r / 2},${e - r / 2} ${r / 2},${e - r / 2}" stroke-width="${r}" stroke="${$}" fill="${n}" />`;
+      return `<polygon points="${r / 2},${t / 2} ${r - t / 2},${r - t / 2} ${t / 2},${r - t / 2}" stroke-width="${t}" stroke="${$}" fill="${a}" />`;
     case "diamond":
-      return `<polygon points="${e / 2},${r / 2} ${e - r / 2},${e / 2} ${e / 2},${e - r / 2} ${r / 2},${e / 2}" stroke-width="${r}" stroke="${$}" fill="${n}" />`;
+      return `<polygon points="${r / 2},${t / 2} ${r - t / 2},${r / 2} ${r / 2},${r - t / 2} ${t / 2},${r / 2}" stroke-width="${t}" stroke="${$}" fill="${a}" />`;
     default:
       return "";
   }
 };
-function m(t) {
-  return Object.entries(t.config).map(([e, r]) => {
-    const n = r.type || "circle", $ = r.size || 10, c = r.strokeWidth || 2, a = r.color || "#000", l = r.strokeColor || r.color || "#000";
-    return `<marker id="${t.id}-${e}" viewBox="0 0 ${$} ${$}" refX="${$ / 2}" refY="${$ / 2}" markerWidth="${$ / 2}" markerHeight="${$ / 2}">
-        ${o(n, $, c, a, l)}
-      </marker>`;
+function f(e, r, t) {
+  const a = ($, n) => {
+    const o = n.type || "circle", c = n.size || 10, l = n.strokeWidth || 2, u = n.color || "#000", p = n.strokeColor || n.color || "#000";
+    return `<marker id="${$}" viewBox="0 0 ${c} ${c}" refX="${c / 2}" refY="${c / 2}" markerWidth="${c / 2}" markerHeight="${c / 2}" orient="auto">
+      ${s(o, c, l, u, p)}
+    </marker>`;
+  };
+  return Object.entries(e.config).flatMap(([$, n]) => {
+    const o = `${e.id}--${r}--${$}`, c = [a(o, n)];
+    return c.push(a(`${e.id}-${$}`, n)), c;
   }).join(`
 `);
 }
-function u(t) {
-  return t.charAt(0).toUpperCase() + t.slice(1);
+function m(e) {
+  return e.charAt(0).toUpperCase() + e.slice(1);
 }
-const f = (t, e) => {
-  const r = Object.keys(t[0]).filter(($) => $ !== e), n = Object.keys(t[0][r[0]]);
-  return t.map(($) => ({
+const y = (e, r) => {
+  const t = Object.keys(e[0]).filter(($) => $ !== r), a = Object.keys(e[0][t[0]]);
+  return e.map(($) => ({
     month: $.month,
-    ...r.flatMap(
-      (c) => n.map((a) => ({
-        [`${c}${u(a)}`]: $[c][a]
+    ...t.flatMap(
+      (n) => a.map((o) => ({
+        [`${n}${m(o)}`]: $[n][o]
       }))
-    ).reduce((c, a) => ({ ...c, ...a }), {})
+    ).reduce((n, o) => ({ ...n, ...o }), {})
   }));
-}, y = (t) => Intl.DateTimeFormat().format(t);
+}, w = (e) => Intl.DateTimeFormat().format(e);
 export {
-  m as createMarkers,
-  y as dateFormatter,
-  f as flattenData,
-  p as getFirstPropertyValue,
-  o as markerShape
+  f as createScopedMarkers,
+  w as dateFormatter,
+  y as flattenData,
+  i as getFirstPropertyValue,
+  s as markerShape
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vue-chrts",
-  "version": "2.0.0",
+  "version": "2.1.0-beta-2",
   "type": "module",
   "files": [
     "dist"
@@ -10,16 +10,11 @@
   "types": "./dist/index.d.ts",
   "exports": {
     ".": {
+      "types": "./dist/index.d.ts",
       "import": "./dist/index.js",
       "require": "./dist/index.umd.cjs"
     }
   },
-  "scripts": {
-    "dev": "vite",
-    "build": "vue-tsc -b && vite build",
-    "preview": "vite preview",
-    "release": "commit-and-tag-version"
-  },
   "peerDependencies": {
     "vue": "^3.5.13"
   },
@@ -42,5 +37,10 @@
     "vue-router": "^4.5.0",
     "vue-tsc": "^2.2.4"
   },
-  "packageManager": "pnpm@8.15.4+sha256.cea6d0bdf2de3a0549582da3983c70c92ffc577ff4410cbf190817ddc35137c2"
-}
+  "scripts": {
+    "dev": "vite",
+    "build": "vue-tsc -b && vite build",
+    "preview": "vite preview",
+    "release": "pnpm run build && commit-and-tag-version && pnpm publish"
+  }
+}