@primeui/vue-chart 0.0.1-alpha.1

package/dist/chunk-YRKAI2R2.mjs

@@ -0,0 +1,151 @@
+import { useCartesianFrame, useCartesianFrameRegistration } from './chunk-CQHNYT2V.mjs';
+import { useChartMethods, useChartState, useChartHover } from './chunk-HANSF33Z.mjs';
+import { resolveBarLabels } from '@primeui/chart-core';
+import { computed, h, ref, watch, onUnmounted } from 'vue';
+
+function useBarLayer(useBarRenderer) {
+  const frame = useCartesianFrame();
+  const methods = useChartMethods();
+  const state = useChartState();
+  const hoverCtx = useChartHover();
+  const features = computed(() => state.value.features);
+  const bar = useBarRenderer({
+    chartArea: frame.cartesianArea,
+    renderer: methods.renderer,
+    canvasEl: frame.canvasEl,
+    datasets: computed(() => state.value.datasets),
+    datasetVisibility: computed(() => state.value.datasetVisibility),
+    hover: computed(() => hoverCtx.value.hover),
+    hoverConfig: frame.hoverConfig,
+    chartId: methods.chartId,
+    width: frame.width,
+    height: frame.height,
+    layoutData: frame.layoutData,
+    features,
+    labelConfig: frame.labelConfig,
+    compositor: frame.compositor,
+    dir: computed(() => methods.dir),
+    theme: computed(() => methods.theme)
+  });
+  const dataLabelVNodes = computed(() => {
+    const layout = frame.layoutData.value;
+    const lc = frame.labelConfig.value;
+    if (methods.renderer !== "svg" || !layout || !lc?.render) return [];
+    const visibility = state.value.datasetVisibility;
+    const nodes = [];
+    for (const [dsId, barLayout] of bar.barLayouts) {
+      if (visibility?.get(dsId) === false) continue;
+      const dsTotal = layout.datasetTotals.get(dsId) ?? 0;
+      const resolved = resolveBarLabels(barLayout.visibleBars, barLayout.colors, dsTotal, layout.orientation, lc, layout.isPercentStacked, bar.barRenderProps.get(dsId)?.name, bar.barRenderProps.get(dsId)?.data);
+      for (const lbl of resolved) {
+        const result = lc.render({ index: lbl.dataIndex, value: lbl.value, percentage: lbl.percentage, formattedText: lbl.text, label: lbl.seriesName ?? lbl.category, color: lbl.color, x: lbl.x, y: lbl.y });
+        if (result != null) {
+          nodes.push(h("g", { key: `bar-${dsId}-${lbl.dataIndex}`, transform: `translate(${lbl.x},${lbl.y})`, "text-anchor": lbl.textAnchor, "dominant-baseline": lbl.baseline }, [result]));
+        }
+      }
+    }
+    return nodes;
+  });
+  useCartesianFrameRegistration({
+    type: "bar",
+    hitTest: (x, y) => bar.hitTest(x, y),
+    findNearest: (x, y) => bar.findNearest(x, y),
+    findAllNearest: (x, y) => bar.findAllNearest(x, y),
+    applyPropertyAnimations: (store) => bar.applyPropertyAnimations(store),
+    renderFrameCycle: () => bar.renderFrameCycle(),
+    dataLabelVNodes,
+    getPointPosition: (datasetId, index) => {
+      const barLayout = bar.barLayouts.get(datasetId);
+      if (barLayout) {
+        const found = barLayout.visibleBars.find((b) => b.dataIndex === index);
+        if (found) return { x: found.x, y: found.y, width: found.width, height: found.height, shape: "rect" };
+      }
+      return null;
+    }
+  });
+  return { bar, methods, frame };
+}
+function useBarRendererBase(controller, options) {
+  const { renderer, canvasEl, datasets, datasetVisibility, hover, hoverConfig, chartId, layoutData, features, labelConfig, isZoomed, compositor, dir, theme } = options;
+  const groupRef = ref(null);
+  const hasBarData = computed(() => {
+    const visibility = datasetVisibility.value;
+    for (const [id, ds] of datasets.value) {
+      if (ds.type === "bar" && visibility.get(id) !== false) return true;
+    }
+    return false;
+  });
+  watch(
+    [layoutData, datasetVisibility, features, groupRef, hoverConfig, theme, dir],
+    () => {
+      const ld = layoutData.value;
+      if (!ld) {
+        if (renderer === "svg" && groupRef.value) {
+          while (groupRef.value.firstChild) groupRef.value.removeChild(groupRef.value.firstChild);
+        }
+        return;
+      }
+      if (renderer === "svg" && !groupRef.value) return;
+      controller.dir = dir.value;
+      controller.update({
+        datasets: datasets.value,
+        datasetVisibility: datasetVisibility.value,
+        chartArea: ld.cartesianArea,
+        width: ld.context.width,
+        height: ld.context.height,
+        chartId,
+        renderer,
+        layoutData: ld,
+        features: features.value,
+        hover: hover.value,
+        context: ld.context,
+        compositor,
+        canvasEl: canvasEl.value,
+        isZoomed: isZoomed?.value,
+        labelConfig: labelConfig?.value ?? null,
+        hoverConfig: hoverConfig.value,
+        svgGroup: groupRef.value,
+        theme: theme.value
+      });
+    },
+    { immediate: true, flush: "post" }
+  );
+  watch(hover, () => {
+    controller.applyHover(hover.value);
+  });
+  onUnmounted(() => {
+    controller.destroy();
+  });
+  function hitTest(x, y) {
+    return controller.hitTest(x, y);
+  }
+  function findNearest(x, y) {
+    return controller.findNearest(x, y);
+  }
+  function findAllNearest(x, y) {
+    return controller.findAllNearest(x, y);
+  }
+  function applyPropertyAnimations(store) {
+    controller.applyPropertyAnimations(store);
+  }
+  function renderFrameCycle() {
+    controller.renderFrameCycle();
+  }
+  return {
+    groupRef,
+    hitTest,
+    findNearest,
+    findAllNearest,
+    hasBarData,
+    applyPropertyAnimations,
+    renderFrameCycle,
+    get barLayouts() {
+      return controller.layouts;
+    },
+    get barRenderProps() {
+      return controller.renderProps;
+    }
+  };
+}
+
+export { useBarLayer, useBarRendererBase };

package/dist/chunk-ZHFL3RYO.mjs

@@ -0,0 +1,228 @@
+import { PieLayer_default } from './chunk-UO27BCRL.mjs';
+import { RadialRenderer_default } from './chunk-4NJ2PSHV.mjs';
+import { registerFamilyRenderer, registerChartLayer, useDatasetAnimationRegistration, useDatasetRegistration, useItemCollector } from './chunk-CQHNYT2V.mjs';
+import { STACKED_CONTEXT_KEY } from './chunk-TEOO4OLV.mjs';
+import { useRendererHint, useChartMethods } from './chunk-HANSF33Z.mjs';
+import { defineComponent, useSlots, computed, useId, inject, onMounted, watch, onUnmounted, renderSlot, createCommentVNode } from 'vue';
+import { resolveAccessor } from '@primeui/chart-core';
+
+var _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "ChartPie",
+  props: {
+    id: {},
+    data: {},
+    categoryField: { type: [
+      String,
+      Function,
+      Array
+    ] },
+    valueField: { type: [
+      String,
+      Function,
+      Number,
+      Array
+    ] },
+    name: {},
+    color: { type: [
+      String,
+      Function,
+      Array
+    ] },
+    opacity: { type: [
+      String,
+      Function,
+      Number,
+      Array
+    ] },
+    hoverColor: { type: [
+      String,
+      Function,
+      Array
+    ] },
+    hoverBorderColor: { type: [
+      String,
+      Function,
+      Array
+    ] },
+    offset: { type: [
+      String,
+      Function,
+      Number,
+      Array
+    ] },
+    outerRadius: {},
+    startAngle: {},
+    sweepAngle: {},
+    order: {},
+    stackId: {},
+    sort: {},
+    innerRadius: {},
+    sliceRadiusValue: { type: [
+      String,
+      Function,
+      Number,
+      Array
+    ] },
+    renderContent: { type: Function },
+    keyField: {},
+    borderColor: { type: [
+      String,
+      Function,
+      Array
+    ] },
+    borderStrokeWidth: { type: [
+      String,
+      Function,
+      Number,
+      Array
+    ] },
+    borderDash: { type: [
+      Array,
+      String,
+      Function
+    ] },
+    borderDashOffset: { type: [
+      String,
+      Function,
+      Number,
+      Array
+    ] },
+    borderJoinStyle: {},
+    borderAlign: {},
+    borderRadius: { type: [
+      String,
+      Function,
+      Number,
+      Object,
+      Array
+    ] },
+    borderSkipped: { type: [
+      String,
+      Function,
+      Boolean,
+      Array
+    ] },
+    spacing: {},
+    animations: {}
+  },
+  setup(__props) {
+    useRendererHint("radial");
+    registerFamilyRenderer("radial", RadialRenderer_default);
+    registerChartLayer("pie", {
+      family: "radial",
+      frameKind: null,
+      layer: PieLayer_default
+    });
+    const props = __props;
+    const slots = useSlots();
+    const hasChildren = computed(() => !!slots.default);
+    const hasData = computed(() => !!props.data);
+    if (hasData.value && hasChildren.value) {
+      throw new Error('ChartPie: Provide either a `data` prop or <ChartItem> children, not both.\n\nData array mode:\n  <ChartPie :data="data" value-field="value" category-field="name" />\n\nDeclarative mode:\n  <ChartPie>\n    <ChartItem :value="30" label="A" />\n  </ChartPie>');
+    }
+    const autoId = props.id || `pie-${useId()}`;
+    useDatasetAnimationRegistration(() => autoId, () => props.animations);
+    const stackedContext = inject(STACKED_CONTEXT_KEY, null);
+    const autoOrder = stackedContext && props.order === void 0 ? stackedContext.getNextOrder() : void 0;
+    const effectiveOrder = props.order ?? autoOrder;
+    if (!hasChildren.value) {
+      const datasetId = computed(() => autoId);
+      const datasetProps = computed(() => ({
+        ...props,
+        id: autoId,
+        order: effectiveOrder,
+        stackId: stackedContext?.stackId
+      }));
+      useDatasetRegistration({
+        id: datasetId,
+        type: "pie",
+        props: datasetProps
+      });
+    }
+    if (hasChildren.value) {
+      let buildSynthesizedProps2 = function() {
+        const items = getItems();
+        return {
+          id: autoId,
+          data: items,
+          valueField: (ctx) => ctx.datum.value,
+          categoryField: (ctx) => ctx.datum.label ?? "",
+          color: ((ctx) => ctx.datum.color ?? resolveAccessor(props.color, ctx)),
+          // Pie-level props pass through
+          innerRadius: props.innerRadius,
+          outerRadius: props.outerRadius,
+          startAngle: props.startAngle,
+          sweepAngle: props.sweepAngle,
+          name: props.name,
+          order: effectiveOrder,
+          stackId: stackedContext?.stackId,
+          spacing: props.spacing,
+          borderRadius: props.borderRadius,
+          borderColor: props.borderColor,
+          borderStrokeWidth: props.borderStrokeWidth,
+          borderAlign: props.borderAlign,
+          borderDash: props.borderDash,
+          borderDashOffset: props.borderDashOffset,
+          borderJoinStyle: props.borderJoinStyle,
+          opacity: props.opacity,
+          hoverColor: props.hoverColor,
+          hoverBorderColor: props.hoverBorderColor,
+          offset: props.offset,
+          renderContent: props.renderContent,
+          sliceRadiusValue: props.sliceRadiusValue,
+          sort: props.sort
+        };
+      };
+      const methods = useChartMethods();
+      const { getItems } = useItemCollector();
+      const resolvedType = computed(() => "pie");
+      let isRegistered = false;
+      onMounted(() => {
+        const synthesizedProps = buildSynthesizedProps2();
+        methods.registerDataset(autoId, resolvedType.value, synthesizedProps);
+        isRegistered = true;
+      });
+      watch([
+        () => props.innerRadius,
+        () => props.outerRadius,
+        () => props.startAngle,
+        () => props.sweepAngle,
+        () => props.name,
+        () => props.order,
+        () => props.spacing,
+        () => props.color,
+        () => props.renderContent,
+        () => props.sliceRadiusValue,
+        () => props.sort,
+        () => props.borderRadius,
+        () => props.borderColor,
+        () => props.borderStrokeWidth,
+        () => props.borderAlign,
+        () => props.borderDash,
+        () => props.borderDashOffset,
+        () => props.borderJoinStyle
+      ], () => {
+        if (!isRegistered) return;
+        const synthesizedProps = buildSynthesizedProps2();
+        methods.updateDataset(autoId, synthesizedProps);
+      }, { flush: "post" });
+      watch(resolvedType, (newType, oldType) => {
+        if (newType !== oldType && isRegistered) {
+          methods.unregisterDataset(autoId);
+          const synthesizedProps = buildSynthesizedProps2();
+          methods.registerDataset(autoId, newType, synthesizedProps);
+        }
+      });
+      onUnmounted(() => {
+        methods.unregisterDataset(autoId);
+        isRegistered = false;
+      });
+    }
+    return (_ctx, _cache) => {
+      return hasChildren.value ? renderSlot(_ctx.$slots, "default", { key: 0 }) : createCommentVNode("", true);
+    };
+  }
+});
+var ChartPie_default = _sfc_main;
+
+export { ChartPie_default };

package/dist/chunk-ZNINPVG7.mjs

@@ -0,0 +1,30 @@
+import { useChartMethods } from './chunk-HANSF33Z.mjs';
+import { defineComponent, onMounted, watch, onUnmounted } from 'vue';
+
+var _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "ChartAnnotation",
+  props: { render: { type: Function } },
+  setup(__props) {
+    const props = __props;
+    const methods = useChartMethods();
+    let annotationId = null;
+    onMounted(() => {
+      annotationId = methods.registerAnnotation(props.render);
+    });
+    watch(() => props.render, (newRender) => {
+      if (annotationId) methods.unregisterAnnotation(annotationId);
+      annotationId = methods.registerAnnotation(newRender);
+    });
+    onUnmounted(() => {
+      if (annotationId) {
+        methods.unregisterAnnotation(annotationId);
+      }
+    });
+    return (_ctx, _cache) => {
+      return null;
+    };
+  }
+});
+var ChartAnnotation_default = _sfc_main;
+
+export { ChartAnnotation_default };

package/dist/chunk-ZRCOVQQM.mjs

@@ -0,0 +1,47 @@
+import { registerZoomController } from './chunk-CQHNYT2V.mjs';
+import { useCustomizationRegistration } from './chunk-PQV55JYI.mjs';
+import { defineComponent, getCurrentInstance, computed } from 'vue';
+import { ZoomPanController } from '@primeui/chart-core';
+
+var _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "ChartZoom",
+  props: {
+    mode: {},
+    wheel: { type: [Boolean, Object] },
+    drag: { type: [Boolean, Object] },
+    pan: { type: [Boolean, Object] },
+    pinch: { type: [Boolean, Object] },
+    limits: {},
+    onZoomChange: { type: Function },
+    zoomRef: {},
+    resetButton: { type: [Boolean, Object] }
+  },
+  setup(__props) {
+    const props = __props;
+    registerZoomController(ZoomPanController);
+    const vnodeProps = getCurrentInstance()?.vnode.props || {};
+    function passThrough(value, propName) {
+      const kebab = propName.replace(/([A-Z])/g, "-$1").toLowerCase();
+      if (propName in vnodeProps || kebab in vnodeProps) return value;
+      return void 0;
+    }
+    const registrationProps = computed(() => ({
+      mode: props.mode,
+      wheel: passThrough(props.wheel, "wheel"),
+      drag: passThrough(props.drag, "drag"),
+      pan: passThrough(props.pan, "pan"),
+      pinch: passThrough(props.pinch, "pinch"),
+      limits: props.limits,
+      onZoomChange: props.onZoomChange,
+      zoomRef: props.zoomRef,
+      resetButton: passThrough(props.resetButton, "resetButton")
+    }));
+    useCustomizationRegistration("zoom", registrationProps);
+    return (_ctx, _cache) => {
+      return null;
+    };
+  }
+});
+var ChartZoom_default = _sfc_main;
+
+export { ChartZoom_default };

package/dist/components/charts/ChartBar.mjs

@@ -0,0 +1,13 @@
+export { ChartBar_default as default } from '../../chunk-K326BBF7.mjs';
+import '../../chunk-RRHYGSK6.mjs';
+import '../../chunk-MDA22SIZ.mjs';
+import '../../chunk-YRKAI2R2.mjs';
+import '../../chunk-HTZVV6VV.mjs';
+import '../../chunk-CQHNYT2V.mjs';
+import '../../chunk-TEOO4OLV.mjs';
+import '../../chunk-PQV55JYI.mjs';
+import '../../chunk-J43KLCZF.mjs';
+import '../../chunk-HANSF33Z.mjs';
+import '../../chunk-LD57I4SY.mjs';
+import '../../chunk-FZ3PZ66C.mjs';
+import '../../chunk-7P6ASYW6.mjs';

package/dist/components/charts/ChartBar.vue.d.ts

@@ -0,0 +1,11 @@
+import type { ChartBarProps } from '../../types';
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<ChartBarProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ChartBarProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    default?: (props: {}) => any;
+}>;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/charts/ChartCandlestick.mjs

@@ -0,0 +1,11 @@
+export { ChartCandlestick_default as default } from '../../chunk-WKSQR6L5.mjs';
+import '../../chunk-FFBK7Q3W.mjs';
+import '../../chunk-HTZVV6VV.mjs';
+import '../../chunk-CQHNYT2V.mjs';
+import '../../chunk-TEOO4OLV.mjs';
+import '../../chunk-PQV55JYI.mjs';
+import '../../chunk-J43KLCZF.mjs';
+import '../../chunk-HANSF33Z.mjs';
+import '../../chunk-LD57I4SY.mjs';
+import '../../chunk-FZ3PZ66C.mjs';
+import '../../chunk-7P6ASYW6.mjs';

package/dist/components/charts/ChartCandlestick.vue.d.ts

@@ -0,0 +1,11 @@
+import type { ChartCandlestickProps } from '../../types';
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<ChartCandlestickProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ChartCandlestickProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    default?: (props: {}) => any;
+}>;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/charts/ChartHeatmap.mjs

@@ -0,0 +1,11 @@
+export { ChartHeatmap_default as default } from '../../chunk-DLUFOM5K.mjs';
+import '../../chunk-54DLUFIA.mjs';
+import '../../chunk-HTZVV6VV.mjs';
+import '../../chunk-CQHNYT2V.mjs';
+import '../../chunk-TEOO4OLV.mjs';
+import '../../chunk-PQV55JYI.mjs';
+import '../../chunk-J43KLCZF.mjs';
+import '../../chunk-HANSF33Z.mjs';
+import '../../chunk-LD57I4SY.mjs';
+import '../../chunk-FZ3PZ66C.mjs';
+import '../../chunk-7P6ASYW6.mjs';

package/dist/components/charts/ChartHeatmap.vue.d.ts

@@ -0,0 +1,11 @@
+import type { ChartHeatmapProps } from '../../types';
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<ChartHeatmapProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ChartHeatmapProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    default?: (props: {}) => any;
+}>;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/charts/ChartLine.mjs

@@ -0,0 +1,11 @@
+export { ChartLine_default as default } from '../../chunk-644ROAHU.mjs';
+import '../../chunk-HTZVV6VV.mjs';
+import '../../chunk-4CRHCZV3.mjs';
+import '../../chunk-CQHNYT2V.mjs';
+import '../../chunk-TEOO4OLV.mjs';
+import '../../chunk-PQV55JYI.mjs';
+import '../../chunk-J43KLCZF.mjs';
+import '../../chunk-HANSF33Z.mjs';
+import '../../chunk-LD57I4SY.mjs';
+import '../../chunk-FZ3PZ66C.mjs';
+import '../../chunk-7P6ASYW6.mjs';

package/dist/components/charts/ChartLine.vue.d.ts

@@ -0,0 +1,11 @@
+import type { ChartLineProps } from '../../types';
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<ChartLineProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ChartLineProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    default?: (props: {}) => any;
+}>;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/charts/ChartPie.mjs

@@ -0,0 +1,11 @@
+export { ChartPie_default as default } from '../../chunk-ZHFL3RYO.mjs';
+import '../../chunk-UO27BCRL.mjs';
+import '../../chunk-4NJ2PSHV.mjs';
+import '../../chunk-CQHNYT2V.mjs';
+import '../../chunk-TEOO4OLV.mjs';
+import '../../chunk-PQV55JYI.mjs';
+import '../../chunk-J43KLCZF.mjs';
+import '../../chunk-HANSF33Z.mjs';
+import '../../chunk-LD57I4SY.mjs';
+import '../../chunk-FZ3PZ66C.mjs';
+import '../../chunk-7P6ASYW6.mjs';

package/dist/components/charts/ChartPie.vue.d.ts

@@ -0,0 +1,15 @@
+import type { ChartPieProps } from '../../types';
+type __VLS_Props = ChartPieProps;
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/charts/ChartPolar.mjs

@@ -0,0 +1,11 @@
+export { ChartPolar_default as default } from '../../chunk-AAX7FOW3.mjs';
+import '../../chunk-JKK3D33U.mjs';
+import '../../chunk-4NJ2PSHV.mjs';
+import '../../chunk-CQHNYT2V.mjs';
+import '../../chunk-TEOO4OLV.mjs';
+import '../../chunk-PQV55JYI.mjs';
+import '../../chunk-J43KLCZF.mjs';
+import '../../chunk-HANSF33Z.mjs';
+import '../../chunk-LD57I4SY.mjs';
+import '../../chunk-FZ3PZ66C.mjs';
+import '../../chunk-7P6ASYW6.mjs';

package/dist/components/charts/ChartPolar.vue.d.ts

@@ -0,0 +1,11 @@
+import type { ChartPolarProps } from '../../types';
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<ChartPolarProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ChartPolarProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    default?: (props: {}) => any;
+}>;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/charts/ChartRadar.mjs

@@ -0,0 +1,11 @@
+export { ChartRadar_default as default } from '../../chunk-E2U4W5FW.mjs';
+import '../../chunk-DOOXGOOB.mjs';
+import '../../chunk-4NJ2PSHV.mjs';
+import '../../chunk-CQHNYT2V.mjs';
+import '../../chunk-TEOO4OLV.mjs';
+import '../../chunk-PQV55JYI.mjs';
+import '../../chunk-J43KLCZF.mjs';
+import '../../chunk-HANSF33Z.mjs';
+import '../../chunk-LD57I4SY.mjs';
+import '../../chunk-FZ3PZ66C.mjs';
+import '../../chunk-7P6ASYW6.mjs';

package/dist/components/charts/ChartRadar.vue.d.ts

@@ -0,0 +1,11 @@
+import type { ChartRadarProps } from '../../types';
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<ChartRadarProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ChartRadarProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    default?: (props: {}) => any;
+}>;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/charts/ChartScatter.mjs

@@ -0,0 +1,11 @@
+export { ChartScatter_default as default } from '../../chunk-5DWO3G33.mjs';
+import '../../chunk-HTZVV6VV.mjs';
+import '../../chunk-DYVFVVTO.mjs';
+import '../../chunk-CQHNYT2V.mjs';
+import '../../chunk-TEOO4OLV.mjs';
+import '../../chunk-PQV55JYI.mjs';
+import '../../chunk-J43KLCZF.mjs';
+import '../../chunk-HANSF33Z.mjs';
+import '../../chunk-LD57I4SY.mjs';
+import '../../chunk-FZ3PZ66C.mjs';
+import '../../chunk-7P6ASYW6.mjs';

package/dist/components/charts/ChartScatter.vue.d.ts

@@ -0,0 +1,11 @@
+import type { ChartScatterProps } from '../../types';
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<ChartScatterProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ChartScatterProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    default?: (props: {}) => any;
+}>;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};