@primeui/vue-chart 0.0.1-alpha.1

package/dist/chunk-VWABO23U.mjs

@@ -0,0 +1,143 @@
+import { useTreemapRenderer, usePropertyAnimations } from './chunk-CQHNYT2V.mjs';
+import { useChartMethods, useChartState, useChartHover } from './chunk-HANSF33Z.mjs';
+import { defineComponent, computed, toRef, shallowRef, onUnmounted, unref, openBlock, createElementBlock, createElementVNode, Fragment, renderList, createBlock, createCommentVNode } from 'vue';
+import { AnimatedPropertyStore, AnimationRegistry } from '@primeui/chart-core';
+
+var _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "RectRenderer",
+  props: {
+    chartArea: {},
+    width: {},
+    height: {},
+    canvasEl: {},
+    drilldownState: {}
+  },
+  setup(__props, { expose: __expose }) {
+    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 treemap = useTreemapRenderer({
+      chartArea: computed(() => props.chartArea),
+      renderer: methods.renderer,
+      canvasEl: toRef(props, "canvasEl"),
+      datasets: computed(() => state.value.datasets),
+      features: computed(() => state.value.features),
+      datasetVisibility: computed(() => state.value.datasetVisibility),
+      hover: computed(() => hoverCtx.value.hover),
+      width: computed(() => props.width),
+      height: computed(() => props.height),
+      chartId: methods.chartId,
+      drilldownState: props.drilldownState,
+      globalFont: methods.font,
+      theme: computed(() => methods.theme)
+    });
+    function hitTest(x, y) {
+      return treemap.hitTest(x, y);
+    }
+    function handleDrilldownClick(hit) {
+      return treemap.handleDrilldownClick(hit);
+    }
+    function prepareDrillOut() {
+      treemap.prepareDrillOut();
+    }
+    function updateHoverOverlay(hit) {
+      treemap.updateHoverOverlay(hit);
+    }
+    function getColorScaleInfo() {
+      return treemap.getColorScaleInfo();
+    }
+    const setWrapperRef = (el) => {
+      treemap.wrapperRef.value = el;
+    };
+    const setGroupRef = (el) => {
+      treemap.groupRef.value = el;
+    };
+    const setOverlayRef = (el) => {
+      treemap.overlayRef.value = el;
+    };
+    function getPlotArea() {
+      return props.chartArea ?? null;
+    }
+    function getPointPosition(datasetId, index) {
+      return treemap.getPointPosition(datasetId, index);
+    }
+    const mergedPropertyAnimations = computed(() => {
+      const f = state.value.features;
+      const animProps = f.get("animation")?.props;
+      if (animProps?.enabled === false) {
+        return void 0;
+      }
+      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) {
+        return void 0;
+      }
+      return merged;
+    });
+    const animStoreRef = shallowRef(new AnimatedPropertyStore());
+    const animRegistry = new AnimationRegistry();
+    const propertyAnimatableControllers = [];
+    for (const candidate of [treemap]) {
+      const partial = candidate;
+      if (typeof partial.applyPropertyAnimations === "function" && typeof partial.renderFrameCycle === "function") {
+        propertyAnimatableControllers.push(partial);
+      }
+    }
+    animRegistry.setRepaintCallback(() => {
+      const store = animStoreRef.value;
+      if (!store) return;
+      for (const c of propertyAnimatableControllers) c.applyPropertyAnimations(store);
+    });
+    function onPropertyComplete() {
+      for (const c of propertyAnimatableControllers) c.renderFrameCycle();
+    }
+    usePropertyAnimations(mergedPropertyAnimations, animRegistry, animStoreRef.value, onPropertyComplete);
+    onUnmounted(() => {
+      animRegistry.destroy();
+      animStoreRef.value?.destroy();
+      animStoreRef.value = null;
+    });
+    __expose({
+      hitTest,
+      handleDrilldownClick,
+      prepareDrillOut,
+      updateHoverOverlay,
+      getColorScaleInfo,
+      getPlotArea,
+      getPointPosition
+    });
+    return (_ctx, _cache) => {
+      return unref(methods).renderer === "svg" ? (openBlock(), createElementBlock("g", {
+        key: 0,
+        ref: setWrapperRef
+      }, [
+        createElementVNode("g", { ref: setGroupRef }),
+        (openBlock(true), createElementBlock(Fragment, null, renderList(unref(treemap).svgContent.value, (el) => {
+          return openBlock(), createBlock(unref(VNodeRenderer), {
+            key: el.key ?? el.props?.key,
+            node: el
+          }, null, 8, ["node"]);
+        }), 128)),
+        createElementVNode("g", { ref: setOverlayRef })
+      ])) : createCommentVNode("", true);
+    };
+  }
+});
+var RectRenderer_default = _sfc_main;
+
+export { RectRenderer_default };

package/dist/chunk-W5M3BR6N.mjs

@@ -0,0 +1,26 @@
+import { useChartMethods } from './chunk-HANSF33Z.mjs';
+import { defineComponent, onMounted, watch, onUnmounted, renderSlot } from 'vue';
+
+var _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "ChartWaterfall",
+  props: { totalField: {} },
+  setup(__props) {
+    const props = __props;
+    const methods = useChartMethods();
+    onMounted(() => {
+      methods.registerCustomization("waterfall", { totalField: props.totalField });
+    });
+    watch(() => props.totalField, (totalField) => {
+      methods.registerCustomization("waterfall", { totalField });
+    });
+    onUnmounted(() => {
+      methods.unregisterCustomization("waterfall");
+    });
+    return (_ctx, _cache) => {
+      return renderSlot(_ctx.$slots, "default");
+    };
+  }
+});
+var ChartWaterfall_default = _sfc_main;
+
+export { ChartWaterfall_default };

package/dist/chunk-WA735Y26.mjs

@@ -0,0 +1,101 @@
+import { AXIS_GROUP_DEPTH_KEY, AXIS_GROUP_COLLECTOR_KEY, AXIS_GROUP_REGISTRY_KEY } from './chunk-5SRBQVU5.mjs';
+import { defineComponent, inject, provide, ref, watch, onMounted, onUnmounted, renderSlot } from 'vue';
+
+var _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "ChartAxisGroup",
+  props: {
+    render: { type: Function },
+    label: {},
+    range: {},
+    labelStyle: {},
+    bracket: { type: [Boolean, Object] },
+    separator: { type: [Boolean, Object] },
+    fill: { type: [Boolean, Object] },
+    tickSeparator: { type: [Boolean, Object] }
+  },
+  setup(__props) {
+    const props = __props;
+    const parentDepth = inject(AXIS_GROUP_DEPTH_KEY, -1);
+    const depth = parentDepth + 1;
+    provide(AXIS_GROUP_DEPTH_KEY, depth);
+    const categoryValues = ref([]);
+    const categoryCollector = {
+      addValue: (value) => {
+        if (!categoryValues.value.includes(value)) {
+          categoryValues.value = [...categoryValues.value, value];
+        }
+      },
+      removeValue: (value) => {
+        categoryValues.value = categoryValues.value.filter((v) => v !== value);
+      }
+    };
+    provide(AXIS_GROUP_COLLECTOR_KEY, categoryCollector);
+    const parentCollector = inject(AXIS_GROUP_COLLECTOR_KEY, null);
+    const axisRegistry = inject(AXIS_GROUP_REGISTRY_KEY, null);
+    function buildDefinition() {
+      const def = {
+        label: props.label,
+        depth,
+        labelStyle: props.labelStyle,
+        bracket: props.bracket,
+        separator: props.separator,
+        fill: props.fill,
+        tickSeparator: props.tickSeparator,
+        render: props.render
+      };
+      if (props.range) {
+        def.range = props.range;
+        return def;
+      }
+      const vals = categoryValues.value;
+      const allNumeric = vals.length > 0 && vals.every((v) => typeof v === "number");
+      if (allNumeric && vals.length >= 2) {
+        const nums = vals;
+        def.range = [Math.min(...nums), Math.max(...nums)];
+      } else if (vals.length > 0) {
+        def.categories = vals.map(String);
+      }
+      return def;
+    }
+    let mounted = false;
+    watch(categoryValues, (newVals, oldVals) => {
+      if (parentCollector) {
+        if (oldVals) {
+          for (const v of oldVals) {
+            parentCollector.removeValue(v);
+          }
+        }
+        for (const v of newVals) {
+          parentCollector.addValue(v);
+        }
+      }
+      if (mounted && axisRegistry) {
+        axisRegistry.addGroup(buildDefinition());
+      }
+    });
+    let mountTimerId;
+    onMounted(() => {
+      mountTimerId = setTimeout(() => {
+        mounted = true;
+        if (axisRegistry) {
+          axisRegistry.addGroup(buildDefinition());
+        }
+      }, 0);
+    });
+    onUnmounted(() => {
+      clearTimeout(mountTimerId);
+      axisRegistry?.removeGroup(props.label);
+      if (parentCollector) {
+        for (const v of categoryValues.value) {
+          parentCollector.removeValue(v);
+        }
+      }
+    });
+    return (_ctx, _cache) => {
+      return renderSlot(_ctx.$slots, "default");
+    };
+  }
+});
+var ChartAxisGroup_default = _sfc_main;
+
+export { ChartAxisGroup_default };

package/dist/chunk-WKSQR6L5.mjs

@@ -0,0 +1,247 @@
+import { CandlestickLayer_default } from './chunk-FFBK7Q3W.mjs';
+import { CartesianRenderer_default } from './chunk-HTZVV6VV.mjs';
+import { registerFamilyRenderer, registerChartLayer, useDatasetAnimationRegistration, useDatasetRegistration, useItemCollector } from './chunk-CQHNYT2V.mjs';
+import { useRendererHint, useChartMethods } from './chunk-HANSF33Z.mjs';
+import { defineComponent, useSlots, computed, onMounted, watch, onUnmounted, renderSlot, createCommentVNode } from 'vue';
+import { candlestickRenderer } from '@primeui/chart-core';
+
+var candlestickIdCounter = 0;
+var _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "ChartCandlestick",
+  props: {
+    id: {},
+    name: {},
+    data: {},
+    timeField: { type: [
+      String,
+      Function,
+      Number,
+      Array
+    ] },
+    openField: { type: [
+      String,
+      Function,
+      Number,
+      Array
+    ] },
+    highField: { type: [
+      String,
+      Function,
+      Number,
+      Array
+    ] },
+    lowField: { type: [
+      String,
+      Function,
+      Number,
+      Array
+    ] },
+    closeField: { type: [
+      String,
+      Function,
+      Number,
+      Array
+    ] },
+    variant: {},
+    upColor: {},
+    downColor: {},
+    neutralColor: {},
+    color: { type: [
+      String,
+      Function,
+      Array
+    ] },
+    barWidthRatio: {},
+    wickStrokeWidth: { type: [
+      String,
+      Function,
+      Number,
+      Array
+    ] },
+    hoverColor: { type: [
+      String,
+      Function,
+      Array
+    ] },
+    hoverBorderColor: { type: [
+      String,
+      Function,
+      Array
+    ] },
+    xAxisId: {},
+    yAxisId: {},
+    order: {},
+    keyField: {},
+    borderUpColor: {},
+    borderDownColor: {},
+    borderNeutralColor: {},
+    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
+    ] },
+    animations: {}
+  },
+  setup(__props) {
+    useRendererHint("cartesian");
+    registerFamilyRenderer("cartesian", CartesianRenderer_default);
+    registerChartLayer("candlestick", {
+      family: "cartesian",
+      frameKind: "grid",
+      layer: CandlestickLayer_default,
+      axisHints: candlestickRenderer
+    });
+    const props = __props;
+    function generateCandlestickId() {
+      return `candlestick-auto-${++candlestickIdCounter}`;
+    }
+    const slots = useSlots();
+    const hasChildren = computed(() => !!slots.default);
+    const autoId = props.id || generateCandlestickId();
+    useDatasetAnimationRegistration(() => autoId, () => props.animations);
+    if (!hasChildren.value) {
+      const datasetId = computed(() => autoId);
+      const datasetProps = computed(() => ({
+        id: autoId,
+        data: props.data,
+        timeField: props.timeField,
+        openField: props.openField,
+        highField: props.highField,
+        lowField: props.lowField,
+        closeField: props.closeField,
+        name: props.name,
+        variant: props.variant,
+        upColor: props.upColor,
+        downColor: props.downColor,
+        neutralColor: props.neutralColor,
+        color: props.color,
+        barWidthRatio: props.barWidthRatio,
+        wickStrokeWidth: props.wickStrokeWidth,
+        xAxisId: props.xAxisId,
+        yAxisId: props.yAxisId,
+        order: props.order,
+        borderColor: props.borderColor,
+        borderStrokeWidth: props.borderStrokeWidth,
+        borderDash: props.borderDash,
+        borderDashOffset: props.borderDashOffset,
+        borderJoinStyle: props.borderJoinStyle,
+        borderAlign: props.borderAlign,
+        borderRadius: props.borderRadius,
+        borderUpColor: props.borderUpColor,
+        borderDownColor: props.borderDownColor,
+        borderNeutralColor: props.borderNeutralColor
+      }));
+      useDatasetRegistration({
+        id: datasetId,
+        type: "candlestick",
+        props: datasetProps
+      });
+    }
+    if (hasChildren.value) {
+      let buildSynthesizedProps2 = function() {
+        const items = getItems();
+        return {
+          id: autoId,
+          data: items,
+          timeField: (ctx) => ctx.datum.time ?? ctx.datum.label ?? "",
+          openField: (ctx) => ctx.datum.open ?? 0,
+          highField: (ctx) => ctx.datum.high ?? 0,
+          lowField: (ctx) => ctx.datum.low ?? 0,
+          closeField: (ctx) => ctx.datum.close ?? 0,
+          color: (ctx) => ctx.datum.color,
+          name: props.name,
+          variant: props.variant,
+          upColor: props.upColor,
+          downColor: props.downColor,
+          neutralColor: props.neutralColor,
+          barWidthRatio: props.barWidthRatio,
+          wickStrokeWidth: props.wickStrokeWidth,
+          xAxisId: props.xAxisId,
+          yAxisId: props.yAxisId,
+          order: props.order,
+          borderColor: props.borderColor,
+          borderStrokeWidth: props.borderStrokeWidth,
+          borderDash: props.borderDash,
+          borderDashOffset: props.borderDashOffset,
+          borderJoinStyle: props.borderJoinStyle,
+          borderAlign: props.borderAlign,
+          borderRadius: props.borderRadius,
+          borderUpColor: props.borderUpColor,
+          borderDownColor: props.borderDownColor,
+          borderNeutralColor: props.borderNeutralColor
+        };
+      };
+      const methods = useChartMethods();
+      const { getItems } = useItemCollector();
+      let isRegistered = false;
+      onMounted(() => {
+        methods.registerDataset(autoId, "candlestick", buildSynthesizedProps2());
+        isRegistered = true;
+      });
+      watch([
+        () => props.name,
+        () => props.variant,
+        () => props.upColor,
+        () => props.downColor,
+        () => props.neutralColor,
+        () => props.color,
+        () => props.order,
+        () => props.borderColor,
+        () => props.borderStrokeWidth,
+        () => props.borderDash,
+        () => props.borderDashOffset,
+        () => props.borderJoinStyle,
+        () => props.borderAlign,
+        () => props.borderRadius,
+        () => props.borderUpColor,
+        () => props.borderDownColor,
+        () => props.borderNeutralColor
+      ], () => {
+        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 ChartCandlestick_default = _sfc_main;
+
+export { ChartCandlestick_default };

package/dist/chunk-WYV2MHP6.mjs

@@ -0,0 +1,34 @@
+import { useCustomizationRegistration } from './chunk-PQV55JYI.mjs';
+import { defineComponent, computed, renderSlot } from 'vue';
+
+var _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "ChartColorLegend",
+  props: {
+    position: {},
+    colorScale: {},
+    colorRange: {},
+    height: {},
+    width: {},
+    borderRadius: {},
+    ticks: {},
+    formatLabel: { type: Function },
+    steps: {},
+    labelSize: {},
+    labelColor: {},
+    showIndicator: { type: Boolean },
+    indicatorColor: {},
+    reservedSize: {},
+    render: { type: Function }
+  },
+  setup(__props) {
+    const props = __props;
+    const registrationProps = computed(() => ({ ...props }));
+    useCustomizationRegistration("colorLegend", registrationProps);
+    return (_ctx, _cache) => {
+      return renderSlot(_ctx.$slots, "default");
+    };
+  }
+});
+var ChartColorLegend_default = _sfc_main;
+
+export { ChartColorLegend_default };

package/dist/chunk-XBDNMPF7.mjs

@@ -0,0 +1,87 @@
+import { AXIS_GROUP_REGISTRY_KEY } from './chunk-5SRBQVU5.mjs';
+import { useAxisComponentBase } from './chunk-CQHNYT2V.mjs';
+import { defineComponent, useSlots, computed, provide, renderSlot } from 'vue';
+
+var __default__ = { inheritAttrs: false };
+var _sfc_main = /* @__PURE__ */ defineComponent({
+  ...__default__,
+  __name: "ChartYAxis",
+  props: {
+    position: { default: "left" },
+    render: {},
+    renderTick: {},
+    id: {},
+    type: {},
+    min: {},
+    max: {},
+    label: {},
+    labelFontSize: {},
+    titleGap: {},
+    tickCount: {},
+    tickFormat: {},
+    tickRotation: {},
+    tickStyle: {},
+    color: {},
+    gridLines: { type: Boolean },
+    gridColor: {},
+    gridStyle: {},
+    gridStrokeWidth: {},
+    gridShape: {},
+    category: {},
+    gridOpacity: {},
+    tickInterval: {},
+    minorGridLines: { type: Boolean },
+    minorGridColor: {},
+    minorGridStrokeWidth: {},
+    minorGridOpacity: {},
+    minorGridCount: {},
+    minorGridStyle: {},
+    alternateGridColor: {},
+    alternateGridOpacity: {},
+    visible: { type: Boolean },
+    scale: {},
+    timezone: {},
+    dateTimeFormats: {},
+    tickConfig: {},
+    minUnit: {},
+    gapless: { type: Boolean },
+    grouping: {},
+    autoRotate: { type: Boolean },
+    autoRotateAngle: {},
+    labelMinSpacing: {},
+    autoSkip: { type: Boolean },
+    minGridDistance: {},
+    startFromZero: { type: Boolean },
+    reversed: { type: Boolean },
+    softMin: {},
+    softMax: {},
+    tickPosition: {},
+    minorTicks: { type: Boolean },
+    minorTickLength: {},
+    minorTickColor: {},
+    minorTickStrokeWidth: {},
+    showFirstLabel: { type: Boolean },
+    showLastLabel: { type: Boolean },
+    showLine: { type: Boolean },
+    showTicks: { type: Boolean },
+    showLabels: { type: Boolean },
+    chartPaddingMin: {},
+    chartPaddingMax: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const slots = useSlots();
+    const hasChildren = !!slots.default;
+    const axisId = computed(() => props.id ?? props.category ?? props.position);
+    const { collectorValue } = useAxisComponentBase("y", axisId, props, hasChildren);
+    if (hasChildren) {
+      provide(AXIS_GROUP_REGISTRY_KEY, collectorValue);
+    }
+    return (_ctx, _cache) => {
+      return renderSlot(_ctx.$slots, "default");
+    };
+  }
+});
+var ChartYAxis_default = _sfc_main;
+
+export { ChartYAxis_default };

package/dist/chunk-YGHWUR7K.mjs

@@ -0,0 +1,45 @@
+import { useCustomizationRegistration } from './chunk-PQV55JYI.mjs';
+import { defineComponent, computed } from 'vue';
+
+var _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "ChartTooltip",
+  props: {
+    render: {},
+    mode: {},
+    snap: {},
+    crosshair: { type: [Boolean, Object] },
+    position: {},
+    offsetX: {},
+    offsetY: {},
+    followCursor: {
+      type: Boolean,
+      default: true
+    },
+    showDelay: {},
+    hideDelay: {},
+    valueFormatter: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const registrationProps = computed(() => ({
+      mode: props.mode,
+      snap: props.snap,
+      render: props.render,
+      crosshair: props.crosshair,
+      position: props.position,
+      offsetX: props.offsetX,
+      offsetY: props.offsetY,
+      followCursor: props.followCursor,
+      showDelay: props.showDelay,
+      hideDelay: props.hideDelay,
+      valueFormatter: props.valueFormatter
+    }));
+    useCustomizationRegistration("tooltip", registrationProps);
+    return (_ctx, _cache) => {
+      return null;
+    };
+  }
+});
+var ChartTooltip_default = _sfc_main;
+
+export { ChartTooltip_default };