@primeui/vue-chart 0.0.1-alpha.1

package/dist/chunk-O6L3PNFC.mjs

@@ -0,0 +1,49 @@
+import { registerKeyboardController } from './chunk-CQHNYT2V.mjs';
+import { useCustomizationRegistration } from './chunk-PQV55JYI.mjs';
+import { defineComponent, getCurrentInstance, computed } from 'vue';
+import { KeyboardNavigationController } from '@primeui/chart-core';
+
+var _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "ChartAccessibility",
+  props: {
+    enabled: { type: Boolean },
+    description: {},
+    typeDescription: {},
+    headingLevel: {},
+    pointDescriptionThreshold: {},
+    dataTableMaxRows: {},
+    dataTableCellFormatter: { type: Function },
+    pointDescriptionFormatter: { type: Function },
+    seriesDescriptionFormatter: { type: Function },
+    landmarkVerbosity: {},
+    keyboardNavigation: {}
+  },
+  setup(__props) {
+    registerKeyboardController(KeyboardNavigationController);
+    const props = __props;
+    const instance = getCurrentInstance();
+    const registrationProps = computed(() => {
+      const vnodeProps = instance?.vnode?.props ?? {};
+      return {
+        ..."enabled" in vnodeProps ? { enabled: props.enabled } : {},
+        description: props.description,
+        typeDescription: props.typeDescription,
+        headingLevel: props.headingLevel,
+        pointDescriptionThreshold: props.pointDescriptionThreshold,
+        dataTableMaxRows: props.dataTableMaxRows,
+        dataTableCellFormatter: props.dataTableCellFormatter,
+        pointDescriptionFormatter: props.pointDescriptionFormatter,
+        seriesDescriptionFormatter: props.seriesDescriptionFormatter,
+        landmarkVerbosity: props.landmarkVerbosity,
+        keyboardNavigation: props.keyboardNavigation
+      };
+    });
+    useCustomizationRegistration("accessibility", registrationProps);
+    return (_ctx, _cache) => {
+      return null;
+    };
+  }
+});
+var ChartAccessibility_default = _sfc_main;
+
+export { ChartAccessibility_default };

package/dist/chunk-PJVOZSPF.mjs

@@ -0,0 +1,55 @@
+import { SYNC_BUS_KEY } from './chunk-LD57I4SY.mjs';
+import { CHART_GROUP_TEXT_KEY } from './chunk-FZ3PZ66C.mjs';
+import { defineComponent, provide, ref, openBlock, createElementBlock, toDisplayString, createCommentVNode, renderSlot } from 'vue';
+import { SyncBus, DEFAULT_CHART_CAPTION_PADDING, DEFAULT_CHART_TITLE_COLOR, DEFAULT_CHART_TITLE_FONT_SIZE, DEFAULT_CHART_TITLE_PADDING, DEFAULT_CHART_CAPTION_COLOR, DEFAULT_CHART_CAPTION_FONT_SIZE } from '@primeui/chart-core';
+
+var _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "ChartGroup",
+  setup(__props) {
+    const bus = new SyncBus();
+    provide(SYNC_BUS_KEY, bus);
+    const groupTitle = ref(void 0);
+    const groupCaption = ref(void 0);
+    provide(CHART_GROUP_TEXT_KEY, {
+      setTitle: (text) => {
+        groupTitle.value = text;
+      },
+      setCaption: (text) => {
+        groupCaption.value = text;
+      }
+    });
+    const captionPadding = DEFAULT_CHART_CAPTION_PADDING;
+    const titleStyle = {
+      margin: `0 0 ${DEFAULT_CHART_TITLE_PADDING}px`,
+      fontSize: `${DEFAULT_CHART_TITLE_FONT_SIZE}px`,
+      fontWeight: 600,
+      lineHeight: 1.3,
+      color: DEFAULT_CHART_TITLE_COLOR,
+      textAlign: "center"
+    };
+    const captionStyle = {
+      margin: `${captionPadding.top}px 0 ${captionPadding.bottom}px`,
+      fontSize: `${DEFAULT_CHART_CAPTION_FONT_SIZE}px`,
+      fontWeight: "normal",
+      lineHeight: 1.4,
+      color: DEFAULT_CHART_CAPTION_COLOR,
+      textAlign: "center"
+    };
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", null, [
+        groupTitle.value ? (openBlock(), createElementBlock("p", {
+          key: 0,
+          style: titleStyle
+        }, toDisplayString(groupTitle.value), 1)) : createCommentVNode("", true),
+        renderSlot(_ctx.$slots, "default"),
+        groupCaption.value ? (openBlock(), createElementBlock("p", {
+          key: 1,
+          style: captionStyle
+        }, toDisplayString(groupCaption.value), 1)) : createCommentVNode("", true)
+      ]);
+    };
+  }
+});
+var ChartGroup_default = _sfc_main;
+
+export { ChartGroup_default };

package/dist/chunk-PQV55JYI.mjs

@@ -0,0 +1,38 @@
+import { useChartMethods } from './chunk-HANSF33Z.mjs';
+import { CHART_REFRESH_NONCE_KEY } from './chunk-FZ3PZ66C.mjs';
+import { shallowEqual } from '@primeui/chart-core';
+import { inject, ref, watch, shallowRef, onMounted, onUnmounted } from 'vue';
+
+function useChartRefreshHook(callback) {
+  const refreshNonce = inject(CHART_REFRESH_NONCE_KEY, ref(0));
+  watch(refreshNonce, callback);
+}
+
+// src/composables/useCustomizationRegistration.ts
+function useCustomizationRegistration(type, props, methodsOverride) {
+  const methods = methodsOverride ?? useChartMethods();
+  const stableProps = shallowRef(props.value);
+  watch(
+    props,
+    (newProps) => {
+      if (!shallowEqual(stableProps.value, newProps)) {
+        stableProps.value = newProps;
+      }
+    },
+    { deep: false }
+  );
+  onMounted(() => {
+    methods.registerCustomization(type, stableProps.value);
+  });
+  watch(stableProps, () => {
+    methods.registerCustomization(type, stableProps.value);
+  });
+  useChartRefreshHook(() => {
+    methods.registerCustomization(type, props.value);
+  });
+  onUnmounted(() => {
+    methods.unregisterCustomization(type);
+  });
+}
+
+export { useChartRefreshHook, useCustomizationRegistration };

package/dist/chunk-PSSXPTLQ.mjs

@@ -0,0 +1,210 @@
+import { useCustomizationRegistration } from './chunk-PQV55JYI.mjs';
+import { SYNC_BUS_KEY } from './chunk-LD57I4SY.mjs';
+import { CHART_METHODS_KEY } from './chunk-FZ3PZ66C.mjs';
+import { defineComponent, inject, computed, ref, onMounted, onBeforeUnmount, openBlock, createElementBlock, Fragment, unref, normalizeStyle, normalizeClass, renderList, createBlock, resolveDynamicComponent, createElementVNode, toDisplayString, createCommentVNode } from 'vue';
+import { gradientToCssBackground, buildSharedLegendItems } from '@primeui/chart-core';
+
+var _hoisted_1 = ["onClick", "onMouseenter"];
+var _hoisted_2 = ["data-chart-gradient"];
+var SHARED_LEGEND_SOURCE = "__shared_legend__";
+var _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "ChartLegend",
+  props: {
+    render: {},
+    class: {},
+    style: {},
+    position: {},
+    align: {},
+    verticalAlign: {},
+    layout: {},
+    interactive: {
+      type: Boolean,
+      default: true
+    },
+    width: {},
+    height: {},
+    maxWidth: {},
+    maxHeight: {},
+    itemGap: {},
+    iconSize: {},
+    iconShape: {},
+    fontSize: {},
+    fontFamily: {},
+    fontWeight: {},
+    color: {},
+    mode: { default: "dataset" },
+    onClick: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const chartMethods = inject(CHART_METHODS_KEY, null);
+    const isInsideChart = !!chartMethods;
+    const syncBus = !isInsideChart ? inject(SYNC_BUS_KEY, null) : null;
+    const isShared = !isInsideChart && !!syncBus;
+    if (isInsideChart) {
+      const registrationProps = computed(() => ({
+        position: props.position,
+        align: props.align,
+        verticalAlign: props.verticalAlign,
+        layout: props.layout,
+        interactive: props.interactive,
+        render: props.render,
+        width: props.width,
+        maxWidth: props.maxWidth,
+        height: props.height,
+        maxHeight: props.maxHeight,
+        itemGap: props.itemGap,
+        fontSize: props.fontSize,
+        iconSize: props.iconSize,
+        iconShape: props.iconShape,
+        fontFamily: props.fontFamily,
+        fontWeight: props.fontWeight,
+        color: props.color,
+        onClick: props.onClick
+      }));
+      useCustomizationRegistration("legend", registrationProps);
+    }
+    const sharedItems = ref([]);
+    const visibilityMap = ref(/* @__PURE__ */ new Map());
+    const hoveredId = ref(null);
+    function rebuildItems() {
+      if (!syncBus) return;
+      const allEntries = [...syncBus.getAllDatasets().values()].flat();
+      sharedItems.value = buildSharedLegendItems(allEntries, props.mode ?? "dataset", visibilityMap.value);
+    }
+    function getItemKey(item) {
+      return item.type === "item" ? `item:${item.itemLabel}` : item.datasetId;
+    }
+    function handleSharedClick(item) {
+      if (!props.interactive || !syncBus) return;
+      if (props.onClick) {
+        props.onClick({
+          datasetId: item.datasetId,
+          label: item.label,
+          type: item.type
+        });
+        return;
+      }
+      const isCategory = item.type === "item";
+      const key = getItemKey(item);
+      const newVisible = !(visibilityMap.value.get(key) ?? true);
+      const next = new Map(visibilityMap.value);
+      if (isCategory) {
+        next.set(key, newVisible);
+        syncBus.broadcastVisibility({
+          sourceId: SHARED_LEGEND_SOURCE,
+          seriesId: "",
+          itemLabel: item.itemLabel,
+          visible: newVisible
+        });
+      } else {
+        const allEntries = [...syncBus.getAllDatasets().values()].flat();
+        for (const ds of allEntries) {
+          if (ds.label === item.label) {
+            next.set(ds.datasetId, newVisible);
+            syncBus.broadcastVisibility({
+              sourceId: SHARED_LEGEND_SOURCE,
+              seriesId: ds.datasetId,
+              visible: newVisible
+            });
+          }
+        }
+      }
+      visibilityMap.value = next;
+      rebuildItems();
+    }
+    if (isShared && syncBus) {
+      syncBus.register(SHARED_LEGEND_SOURCE, {
+        extremes: false,
+        highlight: false,
+        visibility: true
+      });
+      const unsubDatasets = syncBus.subscribeDatasets(() => rebuildItems());
+      const unsubVisibility = syncBus.subscribe(SHARED_LEGEND_SOURCE, "visibility", (event) => {
+        const next = new Map(visibilityMap.value);
+        next.set(event.seriesId, event.visible);
+        visibilityMap.value = next;
+        rebuildItems();
+      });
+      let rebuildTimerId;
+      onMounted(() => {
+        rebuildTimerId = setTimeout(rebuildItems, 50);
+      });
+      onBeforeUnmount(() => {
+        clearTimeout(rebuildTimerId);
+        unsubDatasets();
+        unsubVisibility();
+        syncBus.unregister(SHARED_LEGEND_SOURCE);
+      });
+    }
+    const containerStyle = computed(() => ({
+      display: "flex",
+      flexDirection: props.layout === "vertical" ? "column" : "row",
+      flexWrap: "wrap",
+      justifyContent: props.align === "start" ? "flex-start" : props.align === "end" ? "flex-end" : "center",
+      gap: `${props.itemGap ?? 8}px`,
+      padding: "8px"
+    }));
+    return (_ctx, _cache) => {
+      return isInsideChart ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [], 64)) : unref(isShared) && sharedItems.value.length > 0 ? (openBlock(), createElementBlock("div", {
+        key: 1,
+        class: normalizeClass(props.class),
+        style: normalizeStyle([containerStyle.value, props.style])
+      }, [(openBlock(true), createElementBlock(Fragment, null, renderList(sharedItems.value, (item) => {
+        return openBlock(), createElementBlock(Fragment, { key: getItemKey(item) }, [__props.render ? (openBlock(), createBlock(resolveDynamicComponent(() => __props.render({
+          type: item.type,
+          datasetId: item.datasetId,
+          label: item.label,
+          color: item.color,
+          colorGradient: item.colorGradient,
+          visible: item.visible,
+          isHovered: hoveredId.value === getItemKey(item),
+          onClick: () => handleSharedClick(item),
+          onMouseEnter: () => {
+            hoveredId.value = getItemKey(item);
+          },
+          onMouseLeave: () => {
+            hoveredId.value = null;
+          }
+        })), { key: 0 })) : (openBlock(), createElementBlock("button", {
+          key: 1,
+          type: "button",
+          style: normalizeStyle({
+            display: "inline-flex",
+            alignItems: "center",
+            gap: "6px",
+            background: "none",
+            border: "none",
+            font: "inherit",
+            padding: "4px 8px",
+            borderRadius: "4px",
+            cursor: __props.interactive ? "pointer" : "default",
+            opacity: item.visible ? 1 : 0.4,
+            fontSize: __props.fontSize ? `${__props.fontSize}px` : "12px",
+            ...__props.fontFamily ? { fontFamily: __props.fontFamily } : {},
+            ...__props.fontWeight !== void 0 ? { fontWeight: __props.fontWeight } : {},
+            ...__props.color ? { color: __props.color } : {},
+            transition: "opacity 0.15s",
+            backgroundColor: hoveredId.value === getItemKey(item) ? "var(--p-chart-legend-hover-background, rgba(0,0,0,0.05))" : "transparent"
+          }),
+          onClick: ($event) => handleSharedClick(item),
+          onMouseenter: ($event) => hoveredId.value = getItemKey(item),
+          onMouseleave: _cache[0] || (_cache[0] = ($event) => hoveredId.value = null)
+        }, [createElementVNode("span", {
+          "data-chart-gradient": item.colorGradient ? JSON.stringify(item.colorGradient) : void 0,
+          style: normalizeStyle({
+            width: `${__props.iconSize ?? 12}px`,
+            height: __props.iconShape === "line" ? "2px" : `${__props.iconSize ?? 12}px`,
+            borderRadius: __props.iconShape === "circle" ? "50%" : __props.iconShape === "line" ? "1px" : "2px",
+            backgroundColor: item.color,
+            ...item.colorGradient ? { backgroundImage: unref(gradientToCssBackground)(item.colorGradient) } : {},
+            flexShrink: 0
+          })
+        }, null, 12, _hoisted_2), createElementVNode("span", null, toDisplayString(item.label), 1)], 44, _hoisted_1))], 64);
+      }), 128))], 6)) : createCommentVNode("", true);
+    };
+  }
+});
+var ChartLegend_default = _sfc_main;
+
+export { ChartLegend_default };

package/dist/chunk-RQURY2H3.mjs

@@ -0,0 +1,40 @@
+import { RANGE_CONTEXT_KEY } from './chunk-TEOO4OLV.mjs';
+import { useChartMethods } from './chunk-HANSF33Z.mjs';
+import { defineComponent, provide, computed, onMounted, watch, onUnmounted, renderSlot } from 'vue';
+
+var rangeIdCounter = 0;
+var _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "ChartRange",
+  props: {
+    color: {},
+    fillOpacity: { default: 0.3 },
+    id: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const methods = useChartMethods();
+    const rangeId = props.id || `range-vue-${++rangeIdCounter}`;
+    const featureKey = `range:${rangeId}`;
+    provide(RANGE_CONTEXT_KEY, { rangeId });
+    const config = computed(() => ({
+      rangeId,
+      color: props.color,
+      fillOpacity: props.fillOpacity
+    }));
+    onMounted(() => {
+      methods.registerCustomization(featureKey, config.value);
+    });
+    watch(config, (cfg) => {
+      methods.registerCustomization(featureKey, cfg);
+    });
+    onUnmounted(() => {
+      methods.unregisterCustomization(featureKey);
+    });
+    return (_ctx, _cache) => {
+      return renderSlot(_ctx.$slots, "default");
+    };
+  }
+});
+var ChartRange_default = _sfc_main;
+
+export { ChartRange_default };

package/dist/chunk-RRHYGSK6.mjs

@@ -0,0 +1,29 @@
+import { useBarLayer, useBarRendererBase } from './chunk-YRKAI2R2.mjs';
+import { defineComponent, unref, openBlock, createElementBlock, createCommentVNode } from 'vue';
+import { createBarRendererSvg } from '@primeui/chart-core/series/bar/controller-svg';
+
+function useBarRenderer(options) {
+  return useBarRendererBase(createBarRendererSvg(), options);
+}
+
+// src/components/renderers/layers/BarLayerSvg.vue
+var _hoisted_1 = ["clip-path"];
+var _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "BarLayerSvg",
+  setup(__props) {
+    const { bar, methods, frame } = useBarLayer(useBarRenderer);
+    return (_ctx, _cache) => {
+      return unref(methods).renderer === "svg" && unref(bar).hasBarData.value ? (openBlock(), createElementBlock("g", {
+        key: 0,
+        ref: (el) => {
+          unref(bar).groupRef.value = el;
+        },
+        class: "bar-chart",
+        "clip-path": unref(frame).layoutData.value?.cartesianArea ? `url(#${unref(frame).plotClipId})` : void 0
+      }, null, 8, _hoisted_1)) : createCommentVNode("", true);
+    };
+  }
+});
+var BarLayerSvg_default = _sfc_main;
+
+export { BarLayerSvg_default };

package/dist/chunk-RSAZ7V5Z.mjs

@@ -0,0 +1,42 @@
+import { DECIMATION_CONTEXT_KEY } from './chunk-TEOO4OLV.mjs';
+import { useChartMethods } from './chunk-HANSF33Z.mjs';
+import { defineComponent, watch, onBeforeUnmount, computed, provide, renderSlot } from 'vue';
+
+var _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "ChartDecimation",
+  props: {
+    algorithm: { default: "lttb" },
+    threshold: {},
+    samples: { default: 500 }
+  },
+  setup(__props) {
+    const props = __props;
+    const methods = useChartMethods();
+    watch(() => [
+      props.algorithm,
+      props.threshold,
+      props.samples
+    ], ([algorithm, threshold, samples]) => {
+      methods.registerCustomization("decimation", {
+        algorithm,
+        threshold,
+        samples
+      });
+    }, { immediate: true });
+    onBeforeUnmount(() => {
+      methods.unregisterCustomization("decimation");
+    });
+    const contextValue = computed(() => ({
+      algorithm: props.algorithm,
+      threshold: props.threshold,
+      samples: props.samples
+    }));
+    provide(DECIMATION_CONTEXT_KEY, contextValue);
+    return (_ctx, _cache) => {
+      return renderSlot(_ctx.$slots, "default");
+    };
+  }
+});
+var ChartDecimation_default = _sfc_main;
+
+export { ChartDecimation_default };

package/dist/chunk-RSTIA3KM.mjs

@@ -0,0 +1,41 @@
+import { useCustomizationRegistration } from './chunk-PQV55JYI.mjs';
+import { defineComponent, computed } from 'vue';
+
+var _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "ChartHover",
+  props: {
+    offset: {},
+    brightness: {},
+    scale: {},
+    backgroundColor: {},
+    borderColor: {},
+    borderStrokeWidth: {},
+    borderDash: {},
+    borderDashOffset: {},
+    dimOpacity: {},
+    radiusMultiplier: {},
+    onClick: { type: Function }
+  },
+  setup(__props) {
+    const props = __props;
+    const registrationProps = computed(() => ({
+      offset: props.offset,
+      brightness: props.brightness,
+      scale: props.scale,
+      backgroundColor: props.backgroundColor,
+      borderColor: props.borderColor,
+      borderStrokeWidth: props.borderStrokeWidth,
+      borderDash: props.borderDash,
+      borderDashOffset: props.borderDashOffset,
+      dimOpacity: props.dimOpacity,
+      onClick: props.onClick
+    }));
+    useCustomizationRegistration("hover", registrationProps);
+    return (_ctx, _cache) => {
+      return null;
+    };
+  }
+});
+var ChartHover_default = _sfc_main;
+
+export { ChartHover_default };

package/dist/chunk-TEOO4OLV.mjs

@@ -0,0 +1,6 @@
+// src/components/containers/keys.ts
+var STACKED_CONTEXT_KEY = /* @__PURE__ */ Symbol.for("stacked-context");
+var RANGE_CONTEXT_KEY = /* @__PURE__ */ Symbol.for("range-context");
+var DECIMATION_CONTEXT_KEY = /* @__PURE__ */ Symbol.for("decimation-context");
+
+export { DECIMATION_CONTEXT_KEY, RANGE_CONTEXT_KEY, STACKED_CONTEXT_KEY };

package/dist/chunk-TIV2FI4S.mjs

@@ -0,0 +1,53 @@
+import { STACKED_CONTEXT_KEY } from './chunk-TEOO4OLV.mjs';
+import { useChartMethods } from './chunk-HANSF33Z.mjs';
+import { defineComponent, onMounted, reactive, watch, onUnmounted, provide, renderSlot } from 'vue';
+
+var stackIdCounter = 0;
+var _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "ChartStacked",
+  props: {
+    id: {},
+    gap: { default: 0 },
+    mode: { default: "normal" }
+  },
+  setup(__props) {
+    const props = __props;
+    const methods = useChartMethods();
+    const stackId = props.id || `stack-${++stackIdCounter}`;
+    let orderCounter = 0;
+    let isRegistered = false;
+    function registerStacking() {
+      methods.registerCustomization("stacking", {
+        stackId,
+        gap: props.gap,
+        mode: props.mode
+      });
+    }
+    onMounted(() => {
+      registerStacking();
+      isRegistered = true;
+    });
+    const contextValue = reactive({
+      stackId,
+      gap: props.gap,
+      getNextOrder: () => orderCounter++,
+      mode: props.mode
+    });
+    watch([() => props.mode, () => props.gap], ([newMode, newGap]) => {
+      contextValue.mode = newMode;
+      contextValue.gap = newGap;
+      if (isRegistered) registerStacking();
+    }, { flush: "post" });
+    onUnmounted(() => {
+      methods.unregisterCustomization("stacking");
+      isRegistered = false;
+    });
+    provide(STACKED_CONTEXT_KEY, contextValue);
+    return (_ctx, _cache) => {
+      return renderSlot(_ctx.$slots, "default");
+    };
+  }
+});
+var ChartStacked_default = _sfc_main;
+
+export { ChartStacked_default };

package/dist/chunk-UO27BCRL.mjs

@@ -0,0 +1,86 @@
+import { usePieRenderer, useRadialFrameRegistration } from './chunk-CQHNYT2V.mjs';
+import { useChartMethods, useChartState, useChartHover } from './chunk-HANSF33Z.mjs';
+import { defineComponent, computed, toRef, unref, openBlock, createElementBlock, Fragment, createElementVNode, renderList, createBlock, createCommentVNode } from 'vue';
+
+var _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "PieLayer",
+  props: {
+    chartArea: {},
+    width: {},
+    height: {},
+    canvasEl: {},
+    containerEl: {},
+    adaptiveDataLabelFontSize: {}
+  },
+  setup(__props) {
+    const VNodeRenderer = defineComponent({
+      props: { node: {
+        type: Object,
+        required: true
+      } },
+      render() {
+        return this.node;
+      }
+    });
+    const props = __props;
+    const methods = useChartMethods();
+    const state = useChartState();
+    const hoverCtx = useChartHover();
+    const pie = usePieRenderer({
+      chartArea: computed(() => props.chartArea),
+      renderer: methods.renderer,
+      canvasEl: toRef(props, "canvasEl"),
+      containerEl: toRef(props, "containerEl"),
+      datasets: computed(() => state.value.datasets),
+      features: computed(() => state.value.features),
+      hover: computed(() => hoverCtx.value.hover),
+      datasetVisibility: computed(() => state.value.datasetVisibility),
+      hiddenItems: computed(() => state.value.hiddenItems),
+      chartId: methods.chartId,
+      width: computed(() => props.width),
+      height: computed(() => props.height),
+      globalFont: methods.font,
+      adaptiveDataLabelFontSize: computed(() => props.adaptiveDataLabelFontSize),
+      dir: computed(() => methods.dir),
+      theme: computed(() => methods.theme)
+    });
+    useRadialFrameRegistration({
+      type: "pie",
+      hitTest: (x, y) => pie.hitTest(x, y),
+      getPointPosition: (datasetId, index) => {
+        const pos = pie.getSlicePosition(datasetId, index);
+        if (!pos) return null;
+        const r = 6;
+        return {
+          x: pos.x - r,
+          y: pos.y - r,
+          width: r * 2,
+          height: r * 2,
+          shape: "circle"
+        };
+      },
+      getCenter: () => pie.center.value,
+      applyPropertyAnimations: (store) => pie.applyPropertyAnimations(store),
+      renderFrameCycle: () => pie.renderFrameCycle()
+    });
+    return (_ctx, _cache) => {
+      return unref(methods).renderer === "svg" ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [
+        createElementVNode("g", { ref: (el) => {
+          unref(pie).groupRef.value = el;
+        } }, null, 512),
+        createElementVNode("g", { ref: (el) => {
+          unref(pie).labelGroupRef.value = el;
+        } }, null, 512),
+        (openBlock(true), createElementBlock(Fragment, null, renderList(unref(pie).svgContent.value, (el) => {
+          return openBlock(), createBlock(unref(VNodeRenderer), {
+            key: el.key ?? el.props?.key,
+            node: el
+          }, null, 8, ["node"]);
+        }), 128))
+      ], 64)) : createCommentVNode("", true);
+    };
+  }
+});
+var PieLayer_default = _sfc_main;
+
+export { PieLayer_default };