@primeui/vue-chart 0.0.1-alpha.1

package/dist/chunk-E2U4W5FW.mjs

@@ -0,0 +1,288 @@
+import { RadarLayer_default } from './chunk-DOOXGOOB.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, inject, onMounted, watch, onUnmounted, renderSlot, createCommentVNode } from 'vue';
+
+var radarIdCounter = 0;
+var _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "ChartRadar",
+  props: {
+    id: {},
+    data: {},
+    categoryField: { type: [
+      String,
+      Function,
+      Array
+    ] },
+    valueField: { type: [
+      String,
+      Function,
+      Number,
+      Array
+    ] },
+    name: {},
+    color: {},
+    hoverColor: { type: [
+      String,
+      Function,
+      Array
+    ] },
+    hoverBorderColor: { type: [
+      String,
+      Function,
+      Array
+    ] },
+    fillOpacity: {},
+    lineStrokeWidth: {},
+    lineStyle: {},
+    lineDash: {},
+    showMarkers: { type: Boolean },
+    markerSize: { type: [
+      String,
+      Function,
+      Number,
+      Array
+    ] },
+    curve: {},
+    renderMarker: { type: Function },
+    keyField: {},
+    yAxisId: {},
+    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
+    ] },
+    pointRadius: {},
+    hoverPointRadius: {},
+    pointBackgroundColor: { type: [
+      String,
+      Function,
+      Array
+    ] },
+    pointBorderColor: { type: [
+      String,
+      Function,
+      Array
+    ] },
+    pointBorderStrokeWidth: { type: [
+      String,
+      Function,
+      Number,
+      Array
+    ] },
+    pointBorderDash: { type: [
+      Array,
+      String,
+      Function
+    ] },
+    pointBorderDashOffset: { type: [
+      String,
+      Function,
+      Number,
+      Array
+    ] },
+    pointBorderJoinStyle: {},
+    pointBorderRadius: { type: [
+      String,
+      Function,
+      Number,
+      Array
+    ] },
+    markerShape: { type: [
+      String,
+      Function,
+      Array
+    ] },
+    pointRotation: { type: [
+      String,
+      Function,
+      Number,
+      Array
+    ] },
+    animations: {}
+  },
+  setup(__props) {
+    useRendererHint("radial");
+    registerFamilyRenderer("radial", RadialRenderer_default);
+    registerChartLayer("radar", {
+      family: "radial",
+      frameKind: "grid",
+      layer: RadarLayer_default
+    });
+    const props = __props;
+    function generateRadarId() {
+      return `radar-auto-${++radarIdCounter}`;
+    }
+    const slots = useSlots();
+    const hasChildren = computed(() => !!slots.default);
+    const autoId = props.id || generateRadarId();
+    useDatasetAnimationRegistration(() => autoId, () => props.animations);
+    const stackedContext = inject(STACKED_CONTEXT_KEY, null);
+    const stackId = stackedContext?.stackId;
+    if (!hasChildren.value) {
+      const datasetId = computed(() => autoId);
+      const datasetProps = computed(() => ({
+        id: autoId,
+        data: props.data,
+        categoryField: props.categoryField,
+        valueField: props.valueField,
+        color: props.color,
+        name: props.name,
+        fillOpacity: props.fillOpacity,
+        lineStrokeWidth: props.lineStrokeWidth,
+        lineStyle: props.lineStyle,
+        lineDash: props.lineDash,
+        showMarkers: props.showMarkers,
+        markerSize: props.markerSize,
+        curve: props.curve,
+        markerShape: props.markerShape,
+        pointRotation: props.pointRotation,
+        pointBackgroundColor: props.pointBackgroundColor,
+        pointBorderColor: props.pointBorderColor,
+        pointBorderStrokeWidth: props.pointBorderStrokeWidth,
+        pointBorderDash: props.pointBorderDash,
+        pointBorderDashOffset: props.pointBorderDashOffset,
+        pointBorderJoinStyle: props.pointBorderJoinStyle,
+        pointBorderRadius: props.pointBorderRadius,
+        keyField: props.keyField,
+        renderMarker: props.renderMarker,
+        stackId,
+        yAxisId: props.yAxisId,
+        borderColor: props.borderColor,
+        borderStrokeWidth: props.borderStrokeWidth,
+        borderDash: props.borderDash,
+        borderDashOffset: props.borderDashOffset,
+        borderJoinStyle: props.borderJoinStyle,
+        borderAlign: props.borderAlign,
+        borderRadius: props.borderRadius,
+        borderSkipped: props.borderSkipped,
+        hoverColor: props.hoverColor,
+        hoverBorderColor: props.hoverBorderColor
+      }));
+      useDatasetRegistration({
+        id: datasetId,
+        type: "radar",
+        props: datasetProps
+      });
+    }
+    if (hasChildren.value) {
+      let buildSynthesizedProps2 = function() {
+        return {
+          id: autoId,
+          data: getItems(),
+          categoryField: (ctx) => ctx.datum.label ?? "",
+          valueField: (ctx) => ctx.datum.value,
+          name: props.name,
+          color: props.color,
+          fillOpacity: props.fillOpacity,
+          lineStrokeWidth: props.lineStrokeWidth,
+          lineStyle: props.lineStyle,
+          lineDash: props.lineDash,
+          showMarkers: props.showMarkers,
+          markerSize: props.markerSize,
+          curve: props.curve,
+          markerShape: props.markerShape,
+          pointRotation: props.pointRotation,
+          pointBackgroundColor: props.pointBackgroundColor,
+          pointBorderColor: props.pointBorderColor,
+          pointBorderStrokeWidth: props.pointBorderStrokeWidth,
+          pointBorderDash: props.pointBorderDash,
+          pointBorderDashOffset: props.pointBorderDashOffset,
+          pointBorderJoinStyle: props.pointBorderJoinStyle,
+          pointBorderRadius: props.pointBorderRadius,
+          keyField: props.keyField,
+          renderMarker: props.renderMarker,
+          stackId,
+          yAxisId: props.yAxisId,
+          borderColor: props.borderColor,
+          borderStrokeWidth: props.borderStrokeWidth,
+          borderDash: props.borderDash,
+          borderDashOffset: props.borderDashOffset,
+          borderJoinStyle: props.borderJoinStyle,
+          borderAlign: props.borderAlign,
+          borderRadius: props.borderRadius,
+          borderSkipped: props.borderSkipped
+        };
+      };
+      const methods = useChartMethods();
+      const { getItems } = useItemCollector();
+      let isRegistered = false;
+      onMounted(() => {
+        methods.registerDataset(autoId, "radar", buildSynthesizedProps2());
+        isRegistered = true;
+      });
+      watch([
+        () => props.name,
+        () => props.color,
+        () => props.fillOpacity,
+        () => props.lineStrokeWidth,
+        () => props.lineStyle,
+        () => props.lineDash,
+        () => props.showMarkers,
+        () => props.markerSize,
+        () => props.pointBorderColor,
+        () => props.pointBorderStrokeWidth,
+        () => props.pointBorderDash,
+        () => props.pointBorderDashOffset,
+        () => props.pointBorderJoinStyle,
+        () => props.pointBorderRadius,
+        () => props.curve,
+        () => props.borderColor,
+        () => props.borderStrokeWidth,
+        () => props.borderDash,
+        () => props.borderDashOffset,
+        () => props.borderJoinStyle,
+        () => props.borderAlign,
+        () => props.borderRadius,
+        () => props.borderSkipped
+      ], () => {
+        if (!isRegistered) return;
+        methods.updateDataset(autoId, buildSynthesizedProps2());
+      }, { flush: "post" });
+      onUnmounted(() => {
+        methods.unregisterDataset(autoId);
+        isRegistered = false;
+      });
+    }
+    return (_ctx, _cache) => {
+      return hasChildren.value ? renderSlot(_ctx.$slots, "default", { key: 0 }) : createCommentVNode("", true);
+    };
+  }
+});
+var ChartRadar_default = _sfc_main;
+
+export { ChartRadar_default };

package/dist/chunk-E4ROAOPT.mjs

@@ -0,0 +1,291 @@
+import { defineComponent, computed, ref, watch, openBlock, createElementBlock, normalizeStyle, createVNode, unref, createElementVNode, createCommentVNode, Fragment, renderList, toDisplayString } from 'vue';
+import { DEFAULT_HEAT_COLORS, buildAutoColorScale, interpolateColor, formatCompactValue } from '@primeui/chart-core';
+
+// src/components/renderers/ColorLegendRenderer.vue
+var _hoisted_1 = ["aria-label"];
+var _hoisted_2 = ["viewBox"];
+var _hoisted_3 = ["points", "fill"];
+var _hoisted_4 = ["viewBox"];
+var _hoisted_5 = ["points", "fill"];
+var INDICATOR_SIZE = 6;
+var _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "ColorLegendRenderer",
+  props: {
+    config: {},
+    area: {},
+    autoColorScale: {},
+    hoveredValue: {}
+  },
+  setup(__props) {
+    const VNodeRenderer = defineComponent({
+      props: { node: {
+        type: Object,
+        required: true
+      } },
+      render() {
+        return this.node;
+      }
+    });
+    const props = __props;
+    const position = computed(() => props.config.position ?? "bottom");
+    const isHorizontal = computed(() => position.value === "top" || position.value === "bottom");
+    const resolved = computed(() => {
+      const range = props.config.colorRange ?? props.autoColorScale?.colorRange ?? DEFAULT_HEAT_COLORS;
+      let scale;
+      if (props.config.colorScale && props.config.colorScale.length > 0) {
+        scale = props.config.colorScale;
+      } else if (props.autoColorScale?.colorScale && props.autoColorScale.colorScale.length > 0) {
+        scale = props.autoColorScale.colorScale;
+      } else {
+        const min = props.autoColorScale?.min ?? 0;
+        const max = props.autoColorScale?.max ?? 100;
+        scale = buildAutoColorScale(min, max, range.length);
+      }
+      const scaleMin = scale[0];
+      const scaleMax = scale[scale.length - 1];
+      const tickVals = [];
+      if (props.config.colorScale && props.config.colorScale.length > 0 && props.config.ticks === void 0) {
+        tickVals.push(...props.config.colorScale);
+      } else {
+        const numTicks = props.config.ticks ?? 3;
+        if (numTicks === 1) {
+          tickVals.push((scaleMin + scaleMax) / 2);
+        } else {
+          for (let i = 0; i < numTicks; i++) {
+            tickVals.push(scaleMin + (scaleMax - scaleMin) * (i / (numTicks - 1)));
+          }
+        }
+      }
+      return {
+        colorScale: scale,
+        colorRange: range,
+        tickValues: tickVals
+      };
+    });
+    const canvasRef = ref(null);
+    const barHeight = computed(() => props.config.height ?? 12);
+    const barWidth = computed(() => props.config.width ?? 16);
+    const borderRadius = computed(() => props.config.borderRadius ?? 4);
+    watch([
+      resolved,
+      canvasRef,
+      isHorizontal
+    ], () => {
+      const canvas = canvasRef.value;
+      if (!canvas) return;
+      const dpr = window.devicePixelRatio || 1;
+      const rect = canvas.getBoundingClientRect();
+      const w = rect.width;
+      const h = rect.height;
+      if (w === 0 || h === 0) return;
+      canvas.width = w * dpr;
+      canvas.height = h * dpr;
+      const ctx = canvas.getContext("2d");
+      if (!ctx) return;
+      ctx.scale(dpr, dpr);
+      const { colorScale, colorRange } = resolved.value;
+      const scaleMin = colorScale[0];
+      const scaleMax = colorScale[colorScale.length - 1];
+      const steps = props.config.steps;
+      if (steps && steps > 1) {
+        const dim = isHorizontal.value ? w : h;
+        const stepSize = dim / steps;
+        for (let i = 0; i < steps; i++) {
+          const t = (i + 0.5) / steps;
+          const value = scaleMin + (scaleMax - scaleMin) * t;
+          const color = interpolateColor(colorScale, colorRange, value);
+          ctx.fillStyle = color;
+          if (isHorizontal.value) {
+            ctx.fillRect(i * stepSize, 0, stepSize + 0.5, h);
+          } else {
+            const y = h - (i + 1) * stepSize;
+            ctx.fillRect(0, y, w, stepSize + 0.5);
+          }
+        }
+      } else {
+        const dim = isHorizontal.value ? w : h;
+        const resolution = Math.min(Math.round(dim * 2), 512);
+        for (let i = 0; i < resolution; i++) {
+          const t = i / (resolution - 1);
+          const value = scaleMin + (scaleMax - scaleMin) * t;
+          const color = interpolateColor(colorScale, colorRange, value);
+          ctx.fillStyle = color;
+          if (isHorizontal.value) {
+            const x = t * w;
+            const cellW = w / resolution + 1;
+            ctx.fillRect(x, 0, cellW, h);
+          } else {
+            const y = (1 - t) * h;
+            const cellH = h / resolution + 1;
+            ctx.fillRect(0, y - cellH, w, cellH);
+          }
+        }
+      }
+    }, {
+      immediate: true,
+      flush: "post"
+    });
+    const showIndicator = computed(() => props.config.showIndicator !== false);
+    const indicatorColor = computed(() => props.config.indicatorColor ?? "#374151");
+    const indicatorT = computed(() => {
+      if (!showIndicator.value || props.hoveredValue == null) return null;
+      const { colorScale } = resolved.value;
+      const scaleMin = colorScale[0];
+      const scaleMax = colorScale[colorScale.length - 1];
+      if (scaleMax === scaleMin) return null;
+      return Math.max(0, Math.min(1, (props.hoveredValue - scaleMin) / (scaleMax - scaleMin)));
+    });
+    const format = computed(() => props.config.formatLabel ?? formatCompactValue);
+    const labelSize = computed(() => props.config.labelSize ?? 11);
+    const labelColor = computed(() => props.config.labelColor ?? "#6b7280");
+    const containerStyle = computed(() => ({
+      position: "absolute",
+      left: `${props.area.x}px`,
+      top: `${props.area.y}px`,
+      width: `${props.area.width}px`,
+      height: `${props.area.height}px`,
+      display: "flex",
+      flexDirection: isHorizontal.value ? "column" : "row",
+      alignItems: "stretch",
+      justifyContent: "center",
+      gap: "4px",
+      padding: isHorizontal.value ? "4px 0" : "0 4px"
+    }));
+    const barStyle = computed(() => ({
+      width: isHorizontal.value ? "100%" : `${barWidth.value}px`,
+      height: isHorizontal.value ? `${barHeight.value}px` : "100%",
+      borderRadius: `${borderRadius.value}px`,
+      overflow: "hidden",
+      flexShrink: 0
+    }));
+    const tickContainerStyle = computed(() => isHorizontal.value ? {
+      display: "flex",
+      justifyContent: "space-between",
+      width: "100%"
+    } : {
+      position: "relative",
+      flex: "1"
+    });
+    function tickLabelStyle(i) {
+      const base = {
+        fontSize: `${labelSize.value}px`,
+        color: labelColor.value,
+        fontFamily: "system-ui, sans-serif",
+        lineHeight: "1",
+        whiteSpace: "nowrap"
+      };
+      if (isHorizontal.value) {
+        return {
+          ...base,
+          textAlign: i === 0 ? "left" : i === resolved.value.tickValues.length - 1 ? "right" : "center",
+          flex: i > 0 && i < resolved.value.tickValues.length - 1 ? "1" : "none"
+        };
+      }
+      const t = resolved.value.tickValues.length > 1 ? i / (resolved.value.tickValues.length - 1) : 0.5;
+      return {
+        ...base,
+        position: "absolute",
+        top: `${(1 - t) * 100}%`,
+        transform: "translateY(-50%)",
+        left: "0"
+      };
+    }
+    const hIndicatorPoints = computed(() => {
+      if (indicatorT.value == null) return "";
+      const pct = indicatorT.value * 100;
+      return `${pct},0 ${Math.max(0, pct - 1)},${INDICATOR_SIZE} ${Math.min(100, pct + 1)},${INDICATOR_SIZE}`;
+    });
+    const vIndicatorPoints = computed(() => {
+      if (indicatorT.value == null) return "";
+      const pct = (1 - indicatorT.value) * 100;
+      return `0,${pct} ${INDICATOR_SIZE},${Math.max(0, pct - 1)} ${INDICATOR_SIZE},${Math.min(100, pct + 1)}`;
+    });
+    const ariaLabel = computed(() => {
+      const tvs = resolved.value.tickValues;
+      return `Color scale from ${format.value(tvs[0])} to ${format.value(tvs[tvs.length - 1])}`;
+    });
+    const customRenderVNode = computed(() => {
+      const renderFn = props.config.render;
+      if (!renderFn) return null;
+      const { colorScale, colorRange } = resolved.value;
+      const ctx = {
+        colorScale,
+        colorRange,
+        min: colorScale[0],
+        max: colorScale[colorScale.length - 1],
+        indicatorValue: props.hoveredValue
+      };
+      return renderFn(ctx) ?? null;
+    });
+    const customContainerStyle = computed(() => ({
+      position: "absolute",
+      left: `${props.area.x}px`,
+      top: `${props.area.y}px`,
+      width: `${props.area.width}px`,
+      height: `${props.area.height}px`
+    }));
+    return (_ctx, _cache) => {
+      return customRenderVNode.value ? (openBlock(), createElementBlock("div", {
+        key: 0,
+        style: normalizeStyle(customContainerStyle.value)
+      }, [createVNode(unref(VNodeRenderer), { node: customRenderVNode.value }, null, 8, ["node"])], 4)) : (openBlock(), createElementBlock("div", {
+        key: 1,
+        style: normalizeStyle(containerStyle.value),
+        role: "img",
+        "aria-label": ariaLabel.value
+      }, [createElementVNode("div", { style: normalizeStyle({
+        position: "relative",
+        width: barStyle.value.width,
+        height: barStyle.value.height,
+        flexShrink: 0
+      }) }, [
+        createElementVNode("canvas", {
+          ref: (el) => {
+            canvasRef.value = el;
+          },
+          style: normalizeStyle(barStyle.value)
+        }, null, 4),
+        indicatorT.value != null && isHorizontal.value ? (openBlock(), createElementBlock("svg", {
+          key: 0,
+          viewBox: `0 0 100 ${INDICATOR_SIZE}`,
+          width: "100%",
+          height: INDICATOR_SIZE,
+          style: normalizeStyle({
+            position: "absolute",
+            bottom: `${-INDICATOR_SIZE}px`,
+            left: "0",
+            pointerEvents: "none",
+            overflow: "visible"
+          })
+        }, [createElementVNode("polygon", {
+          points: hIndicatorPoints.value,
+          fill: indicatorColor.value
+        }, null, 8, _hoisted_3)], 12, _hoisted_2)) : createCommentVNode("", true),
+        indicatorT.value != null && !isHorizontal.value ? (openBlock(), createElementBlock("svg", {
+          key: 1,
+          viewBox: `0 0 ${INDICATOR_SIZE} 100`,
+          width: INDICATOR_SIZE,
+          height: "100%",
+          style: normalizeStyle({
+            position: "absolute",
+            right: `${-INDICATOR_SIZE}px`,
+            top: "0",
+            pointerEvents: "none",
+            overflow: "visible"
+          })
+        }, [createElementVNode("polygon", {
+          points: vIndicatorPoints.value,
+          fill: indicatorColor.value
+        }, null, 8, _hoisted_5)], 12, _hoisted_4)) : createCommentVNode("", true)
+      ], 4), createElementVNode("div", { style: normalizeStyle(tickContainerStyle.value) }, [(openBlock(true), createElementBlock(Fragment, null, renderList(resolved.value.tickValues, (v, i) => {
+        return openBlock(), createElementBlock("span", {
+          key: i,
+          style: normalizeStyle(tickLabelStyle(i))
+        }, toDisplayString(format.value(v)), 5);
+      }), 128))], 4)], 12, _hoisted_1));
+    };
+  }
+});
+var ColorLegendRenderer_default = _sfc_main;
+
+export { ColorLegendRenderer_default };

package/dist/chunk-FFBK7Q3W.mjs

@@ -0,0 +1,91 @@
+import { useCartesianFrame, useCandlestickRenderer, useCartesianFrameRegistration } from './chunk-CQHNYT2V.mjs';
+import { useChartMethods, useChartState, useChartHover } from './chunk-HANSF33Z.mjs';
+import { defineComponent, computed, unref, openBlock, createElementBlock, createCommentVNode } from 'vue';
+
+var _hoisted_1 = ["clip-path"];
+var _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "CandlestickLayer",
+  setup(__props) {
+    const frame = useCartesianFrame();
+    const methods = useChartMethods();
+    const state = useChartState();
+    const hoverCtx = useChartHover();
+    const features = computed(() => state.value.features);
+    const candlestick = useCandlestickRenderer({
+      chartArea: frame.cartesianArea,
+      renderer: methods.renderer,
+      canvasEl: frame.canvasEl,
+      datasets: computed(() => state.value.datasets),
+      datasetVisibility: computed(() => state.value.datasetVisibility),
+      features,
+      hover: computed(() => hoverCtx.value.hover),
+      hoverConfig: frame.hoverConfig,
+      chartId: methods.chartId,
+      width: frame.width,
+      height: frame.height,
+      categoryScale: computed(() => frame.layoutData.value?.sharedCategoryScale),
+      valueScales: computed(() => frame.layoutData.value?.valueScales),
+      firstValueAxisId: computed(() => frame.layoutData.value?.valueScales?.keys().next().value ?? "default"),
+      layoutData: computed(() => frame.layoutData.value ?? null),
+      compositor: frame.compositor,
+      theme: computed(() => methods.theme)
+    });
+    useCartesianFrameRegistration({
+      type: "candlestick",
+      applyPropertyAnimations: (store) => candlestick.applyPropertyAnimations(store),
+      renderFrameCycle: () => candlestick.renderFrameCycle(),
+      findAllNearest: (x, y) => candlestick.findAllNearest(x, y),
+      hitTest: (x, y) => {
+        const csHit = candlestick.hitTest(x, y);
+        if (!csHit) return null;
+        return {
+          datasetId: csHit.datasetId,
+          index: csHit.index,
+          label: csHit.label,
+          value: csHit.close,
+          color: csHit.color,
+          snapX: csHit.x,
+          snapY: csHit.y,
+          formattedValue: `O:${csHit.open} H:${csHit.high} L:${csHit.low} C:${csHit.close}`,
+          cursorFormattedValue: "",
+          ohlc: {
+            open: csHit.open,
+            high: csHit.high,
+            low: csHit.low,
+            close: csHit.close
+          }
+        };
+      },
+      getPointPosition: (datasetId, index) => {
+        const csLayout = candlestick.candlestickLayouts.get(datasetId);
+        if (csLayout) {
+          const found = csLayout.visibleCandles?.find((c) => c.dataIndex === index);
+          if (found) {
+            const w = found.bodyWidth || 8;
+            return {
+              x: found.x - w / 2,
+              y: found.wickTop,
+              width: w,
+              height: found.wickBottom - found.wickTop,
+              shape: "rect"
+            };
+          }
+        }
+        return null;
+      }
+    });
+    return (_ctx, _cache) => {
+      return unref(methods).renderer === "svg" && unref(candlestick).hasCandlestickData.value ? (openBlock(), createElementBlock("g", {
+        key: 0,
+        ref: (el) => {
+          unref(candlestick).groupRef.value = el;
+        },
+        class: "candlestick-chart",
+        "clip-path": unref(frame).layoutData.value?.cartesianArea ? `url(#${unref(frame).plotClipId})` : void 0
+      }, null, 8, _hoisted_1)) : createCommentVNode("", true);
+    };
+  }
+});
+var CandlestickLayer_default = _sfc_main;
+
+export { CandlestickLayer_default };

package/dist/chunk-FQTWLAVA.mjs

@@ -0,0 +1,23 @@
+import { AXIS_GROUP_COLLECTOR_KEY } from './chunk-5SRBQVU5.mjs';
+import { defineComponent, inject, onMounted, onUnmounted } from 'vue';
+
+var _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "ChartAxisCategory",
+  props: { value: {} },
+  setup(__props) {
+    const props = __props;
+    const collector = inject(AXIS_GROUP_COLLECTOR_KEY, null);
+    onMounted(() => {
+      collector?.addValue(props.value);
+    });
+    onUnmounted(() => {
+      collector?.removeValue(props.value);
+    });
+    return (_ctx, _cache) => {
+      return null;
+    };
+  }
+});
+var ChartAxisCategory_default = _sfc_main;
+
+export { ChartAxisCategory_default };