@primeui/vue-chart 0.0.1-alpha.1

package/dist/chunk-HANSF33Z.mjs

@@ -0,0 +1,169 @@
+import { CHART_METHODS_KEY, CHART_STATE_KEY, CHART_HOVER_KEY, RENDERER_HINT_KEY, CHART_REFRESH_NONCE_KEY, CHART_CORE_INSTANCE_KEY } from './chunk-FZ3PZ66C.mjs';
+import { createChart, defaultLightTheme } from '@primeui/chart-core';
+import { inject, shallowRef, ref, computed, watch, provide } from 'vue';
+
+function useChartMethods() {
+  const ctx = inject(CHART_METHODS_KEY);
+  if (!ctx) {
+    throw new Error("useChartMethods must be used within a ChartSvg or ChartCanvas");
+  }
+  return ctx;
+}
+function useChartState() {
+  const stateRef = inject(CHART_STATE_KEY);
+  if (!stateRef) {
+    throw new Error("useChartState must be used within a ChartSvg or ChartCanvas");
+  }
+  return stateRef;
+}
+function useChartHover() {
+  const hoverRef = inject(CHART_HOVER_KEY);
+  if (!hoverRef) {
+    throw new Error("useChartHover must be used within a ChartSvg or ChartCanvas");
+  }
+  return hoverRef;
+}
+function useRendererHint(hint) {
+  const hintRef = inject(RENDERER_HINT_KEY);
+  if (hintRef) {
+    hintRef.value = hint;
+  }
+}
+function provideChartContext(options) {
+  const { chartId, renderer, width, height, devicePixelRatio, dir, fontFamily, fontSize, locale, theme } = options;
+  const emitHandlerRef = { current: null };
+  const version = shallowRef(0);
+  let pendingFlush = false;
+  const scheduleFlush = () => {
+    if (!pendingFlush) {
+      pendingFlush = true;
+      queueMicrotask(() => {
+        pendingFlush = false;
+        version.value++;
+      });
+    }
+  };
+  const coreChart = createChart({
+    emits: {
+      // Event emits → routed through emitHandlerRef (written by useChartContext)
+      tooltipChange: (...args) => emitHandlerRef.current?.("tooltip-change", ...args),
+      hoverChange: (...args) => emitHandlerRef.current?.("hover-change", ...args),
+      cursorChange: (...args) => emitHandlerRef.current?.("cursor-change", ...args),
+      syncBroadcast: (...args) => emitHandlerRef.current?.("sync-broadcast", ...args),
+      rectHoverUpdate: (...args) => emitHandlerRef.current?.("rect-hover-update", ...args),
+      clickCallback: (...args) => emitHandlerRef.current?.("click-callback", ...args),
+      datasetToggle: (...args) => emitHandlerRef.current?.("dataset-toggle", ...args),
+      itemToggle: (...args) => emitHandlerRef.current?.("item-toggle", ...args),
+      itemsToggle: (...args) => emitHandlerRef.current?.("items-toggle", ...args),
+      drilldown: (...args) => emitHandlerRef.current?.("drilldown", ...args),
+      legendCallback: (...args) => emitHandlerRef.current?.("legend-callback", ...args),
+      legendHover: (...args) => emitHandlerRef.current?.("legend-hover", ...args),
+      // Registration state change → directly triggers Vue re-render flush
+      stateChanged: () => scheduleFlush()
+    }
+  });
+  const hoverState = ref({ datasetId: null, index: null });
+  const setHover = (datasetId, index, axisIndex, axisX) => {
+    const prev = hoverState.value;
+    if (prev.datasetId === datasetId && prev.index === index && prev.axisIndex === axisIndex && prev.axisX === axisX) return;
+    hoverState.value = { datasetId, index, axisIndex, axisX };
+  };
+  const methods = {
+    registerDataset: (id, type, props) => coreChart.registerDataset(id, type, props),
+    unregisterDataset: (id) => coreChart.unregisterDataset(id),
+    updateDataset: (id, props) => coreChart.updateDataset(id, props),
+    registerXAxis: (id, props) => coreChart.registerXAxis(id, props),
+    updateXAxis: (id, props) => coreChart.updateXAxis(id, props),
+    unregisterXAxis: (id) => coreChart.unregisterXAxis(id),
+    registerYAxis: (id, props) => coreChart.registerYAxis(id, props),
+    updateYAxis: (id, props) => coreChart.updateYAxis(id, props),
+    unregisterYAxis: (id) => coreChart.unregisterYAxis(id),
+    registerCustomization: (type, props) => coreChart.registerCustomization(type, props),
+    unregisterCustomization: (type) => coreChart.unregisterCustomization(type),
+    registerAnnotation: (render) => coreChart.registerAnnotation(render),
+    unregisterAnnotation: (id) => coreChart.unregisterAnnotation(id),
+    setHover,
+    toggleDatasetVisibility: (datasetId) => coreChart.toggleDatasetVisibility(datasetId),
+    setDatasetVisibility: (datasetId, visible) => coreChart.setDatasetVisibility(datasetId, visible),
+    toggleItemVisibility: (datasetId, index) => coreChart.toggleItemVisibility(datasetId, index),
+    chartId,
+    renderer,
+    get dimensions() {
+      return { width: width.value, height: height.value, devicePixelRatio };
+    },
+    get font() {
+      const t = theme?.value ?? defaultLightTheme;
+      return { family: fontFamily ?? t.fontFamily, size: fontSize ?? t.fontSize };
+    },
+    get locale() {
+      return locale?.value;
+    },
+    get dir() {
+      return dir?.value ?? "ltr";
+    },
+    get theme() {
+      return theme?.value ?? defaultLightTheme;
+    }
+  };
+  function mapsEqual(a, b) {
+    if (a.size !== b.size) return false;
+    for (const [k, v] of a) {
+      if (b.get(k) !== v) return false;
+    }
+    return true;
+  }
+  const s0 = coreChart.$state;
+  const snap = {
+    datasets: new Map(s0.datasets),
+    datasetVisibility: new Map(s0.datasetVisibility),
+    hiddenItems: new Map(s0.hiddenItems),
+    features: new Map(s0.features),
+    annotations: new Map(s0.annotations),
+    axesX: new Map(s0.axes.x),
+    axesY: new Map(s0.axes.y)
+  };
+  const stateValue = computed(() => {
+    void version.value;
+    const s = coreChart.$state;
+    const datasets = mapsEqual(s.datasets, snap.datasets) ? snap.datasets : snap.datasets = new Map(s.datasets);
+    const datasetVisibility = mapsEqual(s.datasetVisibility, snap.datasetVisibility) ? snap.datasetVisibility : snap.datasetVisibility = new Map(s.datasetVisibility);
+    const hiddenItems = mapsEqual(s.hiddenItems, snap.hiddenItems) ? snap.hiddenItems : snap.hiddenItems = new Map(s.hiddenItems);
+    const features = mapsEqual(s.features, snap.features) ? snap.features : snap.features = new Map(s.features);
+    const annotations = mapsEqual(s.annotations, snap.annotations) ? snap.annotations : snap.annotations = new Map(s.annotations);
+    const axesX = mapsEqual(s.axes.x, snap.axesX) ? snap.axesX : snap.axesX = new Map(s.axes.x);
+    const axesY = mapsEqual(s.axes.y, snap.axesY) ? snap.axesY : snap.axesY = new Map(s.axes.y);
+    return { datasets, datasetVisibility, hiddenItems, features, annotations, axes: { x: axesX, y: axesY } };
+  });
+  const hoverValue = computed(() => ({
+    hover: hoverState.value
+  }));
+  const rendererHint = ref(null);
+  watch(
+    rendererHint,
+    (hint) => {
+      coreChart.setRendererHint(hint);
+    },
+    { immediate: true }
+  );
+  const refreshNonce = ref(0);
+  const redraw = () => {
+    refreshNonce.value++;
+  };
+  provide(CHART_METHODS_KEY, methods);
+  provide(CHART_STATE_KEY, stateValue);
+  provide(CHART_HOVER_KEY, hoverValue);
+  provide(RENDERER_HINT_KEY, rendererHint);
+  provide(CHART_REFRESH_NONCE_KEY, refreshNonce);
+  provide(CHART_CORE_INSTANCE_KEY, { coreChart, emitHandlerRef, setHover });
+  return {
+    coreChart,
+    emitHandlerRef,
+    methods,
+    state: stateValue,
+    hover: hoverValue,
+    rendererHint,
+    redraw
+  };
+}
+
+export { provideChartContext, useChartHover, useChartMethods, useChartState, useRendererHint };