@primeui/vue-chart 0.0.1-alpha.1

package/dist/chunk-HTZVV6VV.mjs

@@ -0,0 +1,550 @@
+import { useChartLayers, useCartesianLayout, provideCartesianFrame, useCartesianAnimation } from './chunk-CQHNYT2V.mjs';
+import { useChartMethods, useChartState, useChartHover } from './chunk-HANSF33Z.mjs';
+import { SYNC_BUS_KEY } from './chunk-LD57I4SY.mjs';
+import { defineComponent, computed, inject, ref, onUnmounted, watch, shallowRef, toRef, h, openBlock, createElementBlock, Fragment, unref, createElementVNode, createCommentVNode, renderList, createBlock, resolveDynamicComponent } from 'vue';
+import { applyAxisOverrides, calculateCartesianArea, computeNaturalAxisWidths, needsAxisPadding, buildMarkerRenderItems, computeReferenceLines, computeReferenceBands, CanvasCompositor, normalizeDataLabelConfig, shallowEqual, AnimatedPropertyStore, renderCartesianFrame, resolveNearestHit, mergeAllNearestResults, buildZoomScales } from '@primeui/chart-core';
+
+var _hoisted_1 = { key: 0 };
+var _hoisted_2 = ["id"];
+var _hoisted_3 = [
+  "x",
+  "y",
+  "width",
+  "height"
+];
+var _hoisted_4 = {
+  key: 0,
+  class: "data-labels-custom"
+};
+var _hoisted_5 = ["clip-path"];
+var _hoisted_6 = ["id"];
+var _hoisted_7 = [
+  "x",
+  "y",
+  "width",
+  "height"
+];
+var _hoisted_8 = ["transform", "opacity"];
+var _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "CartesianRenderer",
+  props: {
+    chartArea: {},
+    width: {},
+    height: {},
+    canvasEl: {},
+    overlayCanvasEl: {},
+    zoomState: {},
+    adaptiveDataLabelFontSize: {},
+    adaptiveDataLabelRotation: {},
+    ruleOverrides: {}
+  },
+  setup(__props, { expose: __expose }) {
+    const VNodeRenderer = defineComponent({
+      props: { node: {
+        type: Object,
+        required: true
+      } },
+      render() {
+        return this.node;
+      }
+    });
+    const chartLayers = useChartLayers();
+    const cartesianRenderersByType = computed(() => {
+      const m = /* @__PURE__ */ new Map();
+      if (chartLayers) {
+        for (const [type, entry] of chartLayers) {
+          if (entry.family === "cartesian" && entry.axisHints) m.set(type, entry.axisHints);
+        }
+      }
+      return m;
+    });
+    const props = __props;
+    const methods = useChartMethods();
+    const state = useChartState();
+    const hoverCtx = useChartHover();
+    const features = computed(() => state.value.features);
+    const hoverConfig = computed(() => features.value.get("hover")?.props);
+    const effectiveAxes = computed(() => ({
+      x: applyAxisOverrides(state.value.axes.x, props.ruleOverrides?.xAxis),
+      y: applyAxisOverrides(state.value.axes.y, props.ruleOverrides?.yAxis)
+    }));
+    const syncBus = inject(SYNC_BUS_KEY, null);
+    const maxAxisWidths = ref({
+      left: 0,
+      right: 0
+    });
+    if (syncBus) {
+      maxAxisWidths.value = syncBus.getMaxAxisWidths();
+      const unsub = syncBus.subscribeAxisWidths((max) => {
+        maxAxisWidths.value = { ...max };
+      });
+      onUnmounted(unsub);
+    }
+    let _prevChartArea = null;
+    const stableChartArea = computed(() => {
+      const c = props.chartArea;
+      if (_prevChartArea && _prevChartArea.x === c.x && _prevChartArea.y === c.y && _prevChartArea.width === c.width && _prevChartArea.height === c.height) {
+        return _prevChartArea;
+      }
+      return _prevChartArea = c;
+    });
+    const naturalArea = computed(() => calculateCartesianArea(stableChartArea.value, effectiveAxes.value, state.value.datasets, features.value, methods.font, methods.locale, cartesianRenderersByType.value));
+    if (syncBus) {
+      watch(naturalArea, (area) => {
+        syncBus.publishAxisWidths(methods.chartId, computeNaturalAxisWidths(area, stableChartArea.value));
+      }, { immediate: true });
+    }
+    const cartesianArea = computed(() => {
+      const area = naturalArea.value;
+      const max = maxAxisWidths.value;
+      if (!syncBus || !needsAxisPadding(area, stableChartArea.value, max)) return area;
+      return calculateCartesianArea(stableChartArea.value, effectiveAxes.value, state.value.datasets, features.value, methods.font, methods.locale, cartesianRenderersByType.value, max);
+    });
+    const layoutData = useCartesianLayout({
+      cartesianArea,
+      datasets: computed(() => state.value.datasets),
+      axes: effectiveAxes,
+      features,
+      datasetVisibility: computed(() => state.value.datasetVisibility),
+      hover: computed(() => hoverCtx.value.hover),
+      hoverConfig,
+      chartId: methods.chartId,
+      renderer: methods.renderer,
+      width: computed(() => props.width),
+      height: computed(() => props.height),
+      zoomState: computed(() => props.zoomState ?? null),
+      dir: computed(() => methods.dir),
+      globalFont: methods.font,
+      locale: computed(() => methods.locale),
+      theme: computed(() => methods.theme)
+    });
+    const groupRef = ref(null);
+    const gridGroupRef = ref(null);
+    const markerRenderItems = computed(() => {
+      if (methods.renderer !== "svg") return [];
+      return buildMarkerRenderItems(allMarkerOverlays.value, hoverCtx.value.hover);
+    });
+    const customReferenceLinesBeforeData = computed(() => {
+      if (methods.renderer !== "svg" || !layoutData.value?.cartesianArea) return [];
+      const { referenceLines, axisLayouts, cartesianArea: cartesianArea2, sharedCategoryScale, orientation } = layoutData.value;
+      if (!referenceLines) return [];
+      const custom = referenceLines.filter((l) => l.render && (l.placement ?? "afterData") === "beforeData");
+      if (custom.length === 0) return [];
+      const geos = computeReferenceLines(custom, axisLayouts, cartesianArea2, sharedCategoryScale ?? null, orientation);
+      return custom.map((l, i) => ({
+        key: `rl-before-${l.referenceLineId}`,
+        geo: geos[i],
+        renderFn: l.render,
+        placement: "beforeData"
+      }));
+    });
+    const customReferenceLinesAfterData = computed(() => {
+      if (methods.renderer !== "svg" || !layoutData.value?.cartesianArea) return [];
+      const { referenceLines, axisLayouts, cartesianArea: cartesianArea2, sharedCategoryScale, orientation } = layoutData.value;
+      if (!referenceLines) return [];
+      const custom = referenceLines.filter((l) => l.render && (l.placement ?? "afterData") === "afterData");
+      if (custom.length === 0) return [];
+      const geos = computeReferenceLines(custom, axisLayouts, cartesianArea2, sharedCategoryScale ?? null, orientation);
+      return custom.map((l, i) => ({
+        key: `rl-after-${l.referenceLineId}`,
+        geo: geos[i],
+        renderFn: l.render,
+        placement: "afterData"
+      }));
+    });
+    const customReferenceBandsBeforeData = computed(() => {
+      if (methods.renderer !== "svg" || !layoutData.value?.cartesianArea) return [];
+      const { referenceBands, axisLayouts, cartesianArea: cartesianArea2, sharedCategoryScale, orientation } = layoutData.value;
+      if (!referenceBands) return [];
+      const custom = referenceBands.filter((b) => b.render && (b.placement ?? "beforeData") === "beforeData");
+      if (custom.length === 0) return [];
+      const geos = computeReferenceBands(custom, axisLayouts, cartesianArea2, sharedCategoryScale ?? null, orientation);
+      return custom.map((b, i) => ({
+        key: `rb-before-${b.referenceBandId}`,
+        geo: geos[i],
+        renderFn: b.render,
+        placement: "beforeData"
+      }));
+    });
+    const customReferenceBandsAfterData = computed(() => {
+      if (methods.renderer !== "svg" || !layoutData.value?.cartesianArea) return [];
+      const { referenceBands, axisLayouts, cartesianArea: cartesianArea2, sharedCategoryScale, orientation } = layoutData.value;
+      if (!referenceBands) return [];
+      const custom = referenceBands.filter((b) => b.render && (b.placement ?? "beforeData") === "afterData");
+      if (custom.length === 0) return [];
+      const geos = computeReferenceBands(custom, axisLayouts, cartesianArea2, sharedCategoryScale ?? null, orientation);
+      return custom.map((b, i) => ({
+        key: `rb-after-${b.referenceBandId}`,
+        geo: geos[i],
+        renderFn: b.render,
+        placement: "afterData"
+      }));
+    });
+    const sharedCompositor = new CanvasCompositor();
+    const labelConfig = computed(() => {
+      if (props.ruleOverrides?.dataLabels?.enabled === false) return null;
+      const dlProps = features.value.get("dataLabels")?.props;
+      return normalizeDataLabelConfig(dlProps, props.adaptiveDataLabelFontSize, props.adaptiveDataLabelRotation, methods.font) ?? null;
+    });
+    let _prevMergedPA;
+    const mergedPropertyAnimations = computed(() => {
+      const f = state.value.features;
+      const animProps = f.get("animation")?.props;
+      const merged = [];
+      if (animProps?.propertyAnimations) merged.push(...animProps.propertyAnimations);
+      f.forEach((entry, key) => {
+        if (typeof key !== "string" || !key.startsWith("animation:")) return;
+        const p = entry.props;
+        if (p.propertyAnimations) merged.push(...p.propertyAnimations);
+      });
+      if (!merged.length) {
+        _prevMergedPA = void 0;
+        return void 0;
+      }
+      const prev = _prevMergedPA;
+      if (prev && prev.length === merged.length && prev.every((m, i) => shallowEqual(m, merged[i]))) {
+        return prev;
+      }
+      return _prevMergedPA = merged;
+    });
+    const animStoreRef = shallowRef(new AnimatedPropertyStore());
+    const frame = provideCartesianFrame({
+      canvasEl: toRef(props, "canvasEl"),
+      width: computed(() => props.width),
+      height: computed(() => props.height),
+      plotClipId: `plot-clip-${methods.chartId}`,
+      cartesianArea,
+      layoutData,
+      labelConfig,
+      hoverConfig,
+      zoomState: computed(() => props.zoomState ?? null),
+      adaptiveDataLabelFontSize: computed(() => props.adaptiveDataLabelFontSize),
+      adaptiveDataLabelRotation: computed(() => props.adaptiveDataLabelRotation),
+      compositor: sharedCompositor,
+      animStore: animStoreRef
+    });
+    const cartesianSeriesLayers = computed(() => collectCartesianLayers("grid"));
+    const cartesianFramelessLayers = computed(() => collectCartesianLayers(null));
+    function collectCartesianLayers(frameKind) {
+      if (!chartLayers) return [];
+      const mode = methods.renderer === "canvas" ? "canvas" : "svg";
+      const out = [];
+      for (const [type, entry] of chartLayers) {
+        if (entry.family !== "cartesian" || entry.frameKind !== frameKind) continue;
+        const layer = entry.layerByMode ? entry.layerByMode[mode] : entry.layer;
+        if (layer) out.push({
+          type,
+          layer
+        });
+      }
+      return out;
+    }
+    const allMarkerOverlays = computed(() => Array.from(frame.handles.values()).flatMap((handle) => handle.markerOverlays?.value ?? []));
+    const customDataLabelVNodes = computed(() => {
+      if (methods.renderer !== "svg" || !layoutData.value) return [];
+      const dlProps = features.value.get("dataLabels")?.props;
+      const lc = normalizeDataLabelConfig(dlProps, props.adaptiveDataLabelFontSize, props.adaptiveDataLabelRotation, methods.font);
+      if (!lc?.render) return [];
+      const nodes = [];
+      for (const handle of frame.handles.values()) {
+        if (handle.dataLabelVNodes) nodes.push(...handle.dataLabelVNodes.value);
+      }
+      return nodes;
+    });
+    const customTickOverlayRefs = /* @__PURE__ */ new Map();
+    const customTickVNodes = computed(() => {
+      if (methods.renderer !== "svg" || !layoutData.value) return [];
+      const nodes = [];
+      for (const [axisKey, axisInfo] of layoutData.value.axisLayouts) {
+        const renderFn = axisInfo.props.render;
+        const renderTickFn = axisInfo.props.renderTick;
+        if (renderFn) {
+          const tickNodes = [];
+          for (const tick of axisInfo.layout.ticks) {
+            const result = renderFn({
+              value: tick.value,
+              label: tick.label,
+              index: tick.tickIndex,
+              position: axisInfo.layout.position,
+              x: tick.labelX,
+              y: tick.labelY
+            });
+            if (result != null) {
+              tickNodes.push(h("g", {
+                key: tick.tickIndex,
+                transform: `translate(${tick.labelX},${tick.labelY})${tick.rotation ? ` rotate(${tick.rotation})` : ""}`,
+                "text-anchor": tick.anchor,
+                "dominant-baseline": tick.baseline === "top" ? "hanging" : tick.baseline
+              }, [result]));
+            }
+          }
+          nodes.push(h("g", {
+            key: axisKey,
+            ref: (el) => {
+              customTickOverlayRefs.set(axisKey, el);
+            },
+            class: "axis-custom-ticks"
+          }, tickNodes));
+        }
+        if (renderTickFn) {
+          const markNodes = [];
+          for (const tick of axisInfo.layout.ticks) {
+            const result = renderTickFn({
+              value: tick.value,
+              label: tick.label,
+              index: tick.tickIndex,
+              position: axisInfo.layout.position,
+              x: tick.x1,
+              y: tick.y1
+            });
+            if (result != null) {
+              markNodes.push(h("g", {
+                key: tick.tickIndex,
+                transform: `translate(${tick.x1},${tick.y1})`,
+                "text-anchor": "middle"
+              }, [result]));
+            }
+          }
+          nodes.push(h("g", {
+            key: `${axisKey}-tick`,
+            ref: (el) => {
+              customTickOverlayRefs.set(`${axisKey}-tick`, el);
+            },
+            class: "axis-custom-tick-marks"
+          }, markNodes));
+        }
+      }
+      return nodes;
+    });
+    const skipHoverRepaint = computed(() => {
+      if (!frame.handles.get("scatter")?.boostActive?.value) return false;
+      for (const [, ds] of state.value.datasets) {
+        if (ds.type !== "scatter") return false;
+      }
+      return true;
+    });
+    useCartesianAnimation({
+      layoutData,
+      renderer: methods.renderer,
+      canvasEl: toRef(props, "canvasEl"),
+      overlayCanvasEl: toRef(props, "overlayCanvasEl"),
+      markerOverlays: allMarkerOverlays,
+      groupRef,
+      gridGroupRef,
+      hover: computed(() => hoverCtx.value.hover),
+      features,
+      width: computed(() => props.width),
+      height: computed(() => props.height),
+      customTickOverlayRefs,
+      skipHoverRepaint,
+      isZoomed: computed(() => !!(props.zoomState?.x || props.zoomState?.y)),
+      // enabled={false} disables every animation system. Configs merged from
+      // chart-level `animation` and all per-dataset `animation:${id}` keyed entries.
+      propertyAnimations: mergedPropertyAnimations,
+      animStoreRef,
+      onAnimFrame: () => {
+        const store = animStoreRef.value;
+        if (store) {
+          for (const handle of frame.handles.values()) handle.applyPropertyAnimations?.(store);
+        }
+      },
+      onPropertyComplete: () => {
+        for (const handle of frame.handles.values()) handle.renderFrameCycle?.();
+      },
+      renderFrame: (params) => {
+        const staticCategoryScale = layoutData.value?.sharedCategoryScale;
+        const staticValueScales = layoutData.value?.valueScales;
+        const staticScatterXScales = layoutData.value?.scatterXScales;
+        const categoryChanged = !!(staticCategoryScale && params.categoryScale && params.categoryScale !== staticCategoryScale);
+        const valueChanged = !!(staticValueScales && params.valueScales && params.valueScales !== staticValueScales);
+        const scatterXChanged = !!(staticScatterXScales && params.valueXScales && params.valueXScales !== staticScatterXScales);
+        if (categoryChanged || valueChanged || scatterXChanged) {
+          for (const handle of frame.handles.values()) handle.syncWithAnimatedScale?.(params.categoryScale ?? staticCategoryScale, params.valueScales, params.valueXScales);
+        }
+        renderCartesianFrame(params);
+      },
+      compositor: sharedCompositor,
+      dir: computed(() => methods.dir),
+      globalFont: methods.font,
+      locale: methods.locale,
+      theme: () => methods.theme
+    });
+    function hitTest(x, y) {
+      const hmHit = frame.handles.get("heatmap")?.hitTest(x, y);
+      if (hmHit) return hmHit;
+      const csHit = frame.handles.get("candlestick")?.hitTest(x, y);
+      if (csHit) return csHit;
+      const scHit = frame.handles.get("scatter")?.hitTest(x, y);
+      if (scHit) return scHit;
+      const lnHit = frame.handles.get("line")?.hitTest(x, y);
+      if (lnHit) return lnHit;
+      return frame.handles.get("bar")?.hitTest(x, y) ?? null;
+    }
+    function findNearest(x, y) {
+      const barHit = frame.handles.get("bar")?.findNearest?.(x, y) ?? null;
+      const lineResult = frame.handles.get("line")?.findAllNearest?.(x, y) ?? null;
+      const lineHit = lineResult?.primary ?? null;
+      if (!barHit && !lineHit) return null;
+      if (!barHit) return lineHit;
+      if (!lineHit) return barHit;
+      return resolveNearestHit(lineHit, barHit, x, y);
+    }
+    function findAllNearest(x, y) {
+      const barResult = frame.handles.get("bar")?.findAllNearest?.(x, y) ?? null;
+      const lineResult = frame.handles.get("line")?.findAllNearest?.(x, y) ?? null;
+      const csResult = frame.handles.get("candlestick")?.findAllNearest?.(x, y) ?? null;
+      return mergeAllNearestResults([
+        barResult,
+        lineResult,
+        csResult
+      ], x, y);
+    }
+    function getPlotArea() {
+      return layoutData.value?.cartesianArea ?? cartesianArea.value ?? null;
+    }
+    function getScales() {
+      const ld = layoutData.value;
+      if (!ld) return null;
+      return buildZoomScales(ld, props.zoomState);
+    }
+    function getOriginalDomains() {
+      return layoutData.value?.originalDomains ?? {};
+    }
+    const plotClipId = computed(() => `plot-clip-${methods.chartId}`);
+    const plotArea = computed(() => layoutData.value?.cartesianArea ?? null);
+    function getColorScaleInfo() {
+      return frame.handles.get("heatmap")?.getColorScaleInfo?.() ?? null;
+    }
+    function getCrosshairContext() {
+      const ld = layoutData.value;
+      if (!ld) return null;
+      const isHorizontal = ld.orientation === "horizontal";
+      return {
+        orientation: ld.orientation,
+        categoryAxisPosition: isHorizontal ? ld.valueAxisPosition : ld.categoryAxisPosition,
+        valueAxisPosition: isHorizontal ? ld.categoryAxisPosition : ld.valueAxisPosition
+      };
+    }
+    function getPointPosition(datasetId, index) {
+      const barPos = frame.handles.get("bar")?.getPointPosition(datasetId, index);
+      if (barPos) return barPos;
+      const linePos = frame.handles.get("line")?.getPointPosition(datasetId, index);
+      if (linePos) return linePos;
+      const scatterPos = frame.handles.get("scatter")?.getPointPosition(datasetId, index);
+      if (scatterPos) return scatterPos;
+      const csPos = frame.handles.get("candlestick")?.getPointPosition(datasetId, index);
+      if (csPos) return csPos;
+      const heatmapPos = frame.handles.get("heatmap")?.getPointPosition(datasetId, index);
+      if (heatmapPos) return heatmapPos;
+      return null;
+    }
+    const isTimeAxis = computed(() => !!layoutData.value?.sharedTimeScale);
+    function getHeatmapScales() {
+      return frame.handles.get("heatmap")?.scaleResult?.value ?? null;
+    }
+    function getScaleById(axisId) {
+      return layoutData.value?.valueScales.get(axisId);
+    }
+    __expose({
+      hitTest,
+      findNearest,
+      findAllNearest,
+      getPlotArea,
+      getScales,
+      getOriginalDomains,
+      getColorScaleInfo,
+      getCrosshairContext,
+      getPointPosition,
+      isTimeAxis,
+      getHeatmapScales,
+      getScaleById
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock(Fragment, null, [
+        unref(methods).renderer === "svg" ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [
+          plotArea.value ? (openBlock(), createElementBlock("defs", _hoisted_1, [createElementVNode("clipPath", { id: plotClipId.value }, [createElementVNode("rect", {
+            x: plotArea.value.x,
+            y: plotArea.value.y,
+            width: plotArea.value.width,
+            height: plotArea.value.height
+          }, null, 8, _hoisted_3)], 8, _hoisted_2)])) : createCommentVNode("", true),
+          (openBlock(true), createElementBlock(Fragment, null, renderList(customReferenceBandsBeforeData.value, (entry) => {
+            return openBlock(), createElementBlock("g", {
+              key: entry.key,
+              class: "reference-band-custom"
+            }, [(openBlock(), createBlock(resolveDynamicComponent(() => entry.renderFn(entry.geo))))]);
+          }), 128)),
+          (openBlock(true), createElementBlock(Fragment, null, renderList(customReferenceLinesBeforeData.value, (entry) => {
+            return openBlock(), createElementBlock("g", {
+              key: entry.key,
+              class: "reference-line-custom"
+            }, [(openBlock(), createBlock(resolveDynamicComponent(() => entry.renderFn(entry.geo))))]);
+          }), 128)),
+          createElementVNode("g", {
+            ref: (el) => {
+              gridGroupRef.value = el;
+            },
+            class: "cartesian-grid"
+          }, null, 512)
+        ], 64)) : createCommentVNode("", true),
+        (openBlock(true), createElementBlock(Fragment, null, renderList(cartesianFramelessLayers.value, (layer) => {
+          return openBlock(), createBlock(resolveDynamicComponent(layer.layer), { key: layer.type });
+        }), 128)),
+        (openBlock(true), createElementBlock(Fragment, null, renderList(cartesianSeriesLayers.value, (layer) => {
+          return openBlock(), createBlock(resolveDynamicComponent(layer.layer), { key: layer.type });
+        }), 128)),
+        unref(methods).renderer === "svg" ? (openBlock(), createElementBlock(Fragment, { key: 1 }, [
+          createElementVNode("g", {
+            ref: (el) => {
+              groupRef.value = el;
+            },
+            class: "cartesian-chart"
+          }, null, 512),
+          (openBlock(true), createElementBlock(Fragment, null, renderList(customTickVNodes.value, (node) => {
+            return openBlock(), createBlock(unref(VNodeRenderer), {
+              key: node.key ?? void 0,
+              node
+            }, null, 8, ["node"]);
+          }), 128)),
+          (openBlock(true), createElementBlock(Fragment, null, renderList(customReferenceLinesAfterData.value, (entry) => {
+            return openBlock(), createElementBlock("g", {
+              key: entry.key,
+              class: "reference-line-custom"
+            }, [(openBlock(), createBlock(resolveDynamicComponent(() => entry.renderFn(entry.geo))))]);
+          }), 128)),
+          (openBlock(true), createElementBlock(Fragment, null, renderList(customReferenceBandsAfterData.value, (entry) => {
+            return openBlock(), createElementBlock("g", {
+              key: entry.key,
+              class: "reference-band-custom"
+            }, [(openBlock(), createBlock(resolveDynamicComponent(() => entry.renderFn(entry.geo))))]);
+          }), 128)),
+          customDataLabelVNodes.value.length ? (openBlock(), createElementBlock("g", _hoisted_4, [(openBlock(true), createElementBlock(Fragment, null, renderList(customDataLabelVNodes.value, (node, i) => {
+            return openBlock(), createBlock(resolveDynamicComponent(() => node), { key: i });
+          }), 128))])) : createCommentVNode("", true),
+          createElementVNode("g", {
+            ref: "markerOverlayRef",
+            class: "marker-overlay",
+            "clip-path": unref(layoutData)?.cartesianArea ? `url(#marker-clip-${unref(methods).chartId})` : void 0
+          }, [unref(layoutData)?.cartesianArea ? (openBlock(), createElementBlock("clipPath", {
+            key: 0,
+            id: `marker-clip-${unref(methods).chartId}`
+          }, [createElementVNode("rect", {
+            x: unref(layoutData).cartesianArea.x,
+            y: unref(layoutData).cartesianArea.y,
+            width: unref(layoutData).cartesianArea.width,
+            height: unref(layoutData).cartesianArea.height
+          }, null, 8, _hoisted_7)], 8, _hoisted_6)) : createCommentVNode("", true), (openBlock(true), createElementBlock(Fragment, null, renderList(markerRenderItems.value, (item) => {
+            return openBlock(), createElementBlock("g", {
+              key: item.key,
+              transform: `translate(${item.x}, ${item.y})`,
+              opacity: item.opacity !== 1 ? item.opacity : void 0
+            }, [(openBlock(), createBlock(resolveDynamicComponent(() => item.renderMarker(item.context))))], 8, _hoisted_8);
+          }), 128))], 8, _hoisted_5)
+        ], 64)) : createCommentVNode("", true)
+      ], 64);
+    };
+  }
+});
+var CartesianRenderer_default = _sfc_main;
+
+export { CartesianRenderer_default };

package/dist/chunk-J2P5JBHC.mjs

@@ -0,0 +1,26 @@
+import { useCustomizationRegistration } from './chunk-PQV55JYI.mjs';
+import { defineComponent, computed } from 'vue';
+
+var _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "ChartResponsive",
+  props: {
+    rules: {},
+    breakpoints: {},
+    disableAutoAdaptive: { type: Boolean }
+  },
+  setup(__props) {
+    const props = __props;
+    const registrationProps = computed(() => ({
+      rules: props.rules,
+      breakpoints: props.breakpoints,
+      disableAutoAdaptive: props.disableAutoAdaptive
+    }));
+    useCustomizationRegistration("responsive", registrationProps);
+    return (_ctx, _cache) => {
+      return null;
+    };
+  }
+});
+var ChartResponsive_default = _sfc_main;
+
+export { ChartResponsive_default };

package/dist/chunk-J43KLCZF.mjs

@@ -0,0 +1,10 @@
+import { LEGEND_ITEM_BASE_STYLE as LEGEND_ITEM_BASE_STYLE$1, LEGEND_SWATCH_STYLE as LEGEND_SWATCH_STYLE$1, TOOLTIP_BASE_STYLE as TOOLTIP_BASE_STYLE$1, TOOLTIP_DEFAULT_STYLE as TOOLTIP_DEFAULT_STYLE$1 } from '@primeui/chart-core';
+export { normalizeDataLabelConfig } from '@primeui/chart-core';
+
+// src/utils/styles.ts
+var LEGEND_ITEM_BASE_STYLE = LEGEND_ITEM_BASE_STYLE$1;
+var LEGEND_SWATCH_STYLE = LEGEND_SWATCH_STYLE$1;
+var TOOLTIP_BASE_STYLE = TOOLTIP_BASE_STYLE$1;
+var TOOLTIP_DEFAULT_STYLE = TOOLTIP_DEFAULT_STYLE$1;
+
+export { LEGEND_ITEM_BASE_STYLE, LEGEND_SWATCH_STYLE, TOOLTIP_BASE_STYLE, TOOLTIP_DEFAULT_STYLE };

package/dist/chunk-JKK3D33U.mjs

@@ -0,0 +1,64 @@
+import { usePolarRenderer, useRadialFrameRegistration } from './chunk-CQHNYT2V.mjs';
+import { useChartMethods, useChartState, useChartHover } from './chunk-HANSF33Z.mjs';
+import { defineComponent, computed, toRef, unref, openBlock, createElementBlock, createCommentVNode } from 'vue';
+
+var _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "PolarLayer",
+  props: {
+    chartArea: {},
+    width: {},
+    height: {},
+    canvasEl: {},
+    adaptiveDataLabelFontSize: {},
+    sharedContext: {},
+    requestRedraw: { type: Function }
+  },
+  setup(__props) {
+    const props = __props;
+    const methods = useChartMethods();
+    const state = useChartState();
+    const hoverCtx = useChartHover();
+    const polar = usePolarRenderer({
+      chartArea: computed(() => props.chartArea),
+      renderer: methods.renderer,
+      canvasEl: toRef(props, "canvasEl"),
+      datasets: computed(() => state.value.datasets),
+      features: computed(() => state.value.features),
+      hover: computed(() => hoverCtx.value.hover),
+      datasetVisibility: computed(() => state.value.datasetVisibility),
+      globalFont: methods.font,
+      adaptiveDataLabelFontSize: computed(() => props.adaptiveDataLabelFontSize),
+      chartId: methods.chartId,
+      width: computed(() => props.width),
+      height: computed(() => props.height),
+      sharedContext: computed(() => props.sharedContext),
+      requestRedraw: () => props.requestRedraw(),
+      dir: computed(() => methods.dir),
+      xAxes: computed(() => state.value.axes.x),
+      yAxes: computed(() => state.value.axes.y),
+      theme: computed(() => methods.theme)
+    });
+    useRadialFrameRegistration({
+      type: "polar",
+      layout: polar.layout,
+      renderCanvasContent: polar.renderCanvasContent,
+      hitTest: (x, y) => polar.hitTest(x, y),
+      findAllNearest: (x, y) => polar.findAllNearest(x, y),
+      getCenter: () => polar.center ?? null,
+      getPointPosition: (datasetId, index) => polar.getPointPosition(datasetId, index),
+      applyPropertyAnimations: (store) => polar.applyPropertyAnimations(store),
+      renderFrameCycle: () => polar.renderFrameCycle()
+    });
+    return (_ctx, _cache) => {
+      return unref(methods).renderer === "svg" ? (openBlock(), createElementBlock("g", {
+        key: 0,
+        ref: (el) => {
+          unref(polar).groupRef.value = el;
+        }
+      }, null, 512)) : createCommentVNode("", true);
+    };
+  }
+});
+var PolarLayer_default = _sfc_main;
+
+export { PolarLayer_default };