@primeui/chart-core 0.0.1-alpha.1

package/dist/chunk-OWW3K55O.mjs

@@ -0,0 +1,351 @@
+import { FIELD_DEFAULTS } from './chunk-O2X6FF45.mjs';
+
+// src/utils/specialized/exportMenu.utils.ts
+var EXPORT_MENU_CONSTANTS = {
+  /** Button size in pixels */
+  BUTTON_SIZE: 36,
+  /** Button padding */
+  BUTTON_PADDING: 8,
+  /** Menu width */
+  MENU_WIDTH: 180,
+  /** Menu item height */
+  MENU_ITEM_HEIGHT: 32,
+  /** Separator height */
+  SEPARATOR_HEIGHT: 1,
+  /** Menu border radius */
+  BORDER_RADIUS: 4,
+  /** Z-index for menu overlay */
+  Z_INDEX: 1e3
+};
+var DEFAULT_EXPORT_MENU_ITEMS = ["downloadPNG", "downloadJPEG", "downloadSVG", "downloadPDF", "downloadCSV", "separator", "downloadPNGTransparent", "downloadSVGTransparent"];
+var DEFAULT_EXPORT_MENU_PROPS = {
+  enabled: true,
+  filename: "chart",
+  menuItems: DEFAULT_EXPORT_MENU_ITEMS,
+  buttons: {
+    align: "right",
+    verticalAlign: "top",
+    x: -10,
+    y: 10
+  },
+  scale: 2,
+  backgroundColor: "auto",
+  buttonClass: "",
+  menuClass: ""
+};
+var EXPORT_MENU_LABELS = {
+  downloadPNG: "Download PNG",
+  downloadJPEG: "Download JPEG",
+  downloadSVG: "Download SVG",
+  downloadPDF: "Download PDF",
+  downloadCSV: "Download CSV",
+  downloadPNGTransparent: "Download PNG (Transparent)",
+  downloadSVGTransparent: "Download SVG (Transparent)"
+};
+var HAMBURGER_ICON_PATH = "M3 18h18v-2H3v2zm0-5h18v-2H3v2zm0-7v2h18V6H3z";
+function resolveExportMenuProps(props) {
+  return {
+    enabled: props.enabled ?? DEFAULT_EXPORT_MENU_PROPS.enabled,
+    filename: props.filename ?? DEFAULT_EXPORT_MENU_PROPS.filename,
+    menuItems: props.menuItems ?? DEFAULT_EXPORT_MENU_PROPS.menuItems,
+    buttons: {
+      ...DEFAULT_EXPORT_MENU_PROPS.buttons,
+      ...props.buttons
+    },
+    scale: props.scale ?? DEFAULT_EXPORT_MENU_PROPS.scale,
+    backgroundColor: props.backgroundColor ?? DEFAULT_EXPORT_MENU_PROPS.backgroundColor,
+    buttonClass: props.buttonClass ?? "",
+    menuClass: props.menuClass ?? ""
+  };
+}
+function isExportMenuSeparator(item) {
+  return item === "separator";
+}
+function filterExportMenuItems(items) {
+  return items.filter((item, i, arr) => {
+    if (item !== "separator") return true;
+    if (i === 0 || i === arr.length - 1) return false;
+    return arr[i - 1] !== "separator";
+  });
+}
+function estimateExportMenuHeight(items) {
+  const MENU_PADDING_Y = 8;
+  const SEPARATOR_SPACE = 9;
+  let height = MENU_PADDING_Y;
+  for (const item of items) {
+    height += item === "separator" ? SEPARATOR_SPACE : EXPORT_MENU_CONSTANTS.MENU_ITEM_HEIGHT;
+  }
+  return height;
+}
+function resolveExportMenuPlacement(input) {
+  const { align, verticalAlign, x, y, buttonSize, menuWidth, menuHeight, chartWidth, chartHeight } = input;
+  const gap = input.gap ?? 4;
+  const absX = Math.abs(x);
+  const absY = Math.abs(y);
+  const buttonLeft = align === "right" ? chartWidth - absX - buttonSize : absX;
+  const buttonTop = verticalAlign === "top" ? absY : chartHeight - absY - buttonSize;
+  const placement = {};
+  if (buttonLeft + menuWidth > chartWidth) {
+    placement.right = chartWidth - buttonLeft - buttonSize;
+  } else {
+    placement.left = buttonLeft;
+  }
+  if (buttonTop + buttonSize + menuHeight > chartHeight && verticalAlign !== "top") {
+    placement.bottom = chartHeight - buttonTop + gap;
+  } else {
+    placement.top = buttonTop + buttonSize + gap;
+  }
+  return placement;
+}
+function getExportAction(item) {
+  switch (item) {
+    case "downloadPNG":
+      return { format: "png", transparent: false };
+    case "downloadJPEG":
+      return { format: "jpeg", transparent: false };
+    case "downloadSVG":
+      return { format: "svg", transparent: false };
+    case "downloadPDF":
+      return { format: "pdf", transparent: false };
+    case "downloadCSV":
+      return { format: "csv", transparent: false };
+    case "downloadPNGTransparent":
+      return { format: "png", transparent: true };
+    case "downloadSVGTransparent":
+      return { format: "svg", transparent: true };
+  }
+}
+
+// src/utils/specialized/decimation.utils.ts
+function decimateLTTB(yValues, targetCount, xValues) {
+  const n = yValues.length;
+  if (targetCount >= n || targetCount < 3) {
+    return Array.from({ length: n }, (_, i) => i);
+  }
+  const result = new Array(targetCount);
+  result[0] = 0;
+  const bucketCount = targetCount - 2;
+  const bucketSize = (n - 2) / bucketCount;
+  let prevSelectedIdx = 0;
+  for (let bucket = 0; bucket < bucketCount; bucket++) {
+    const bucketStart = Math.floor(bucket * bucketSize) + 1;
+    const bucketEnd = Math.min(Math.floor((bucket + 1) * bucketSize) + 1, n - 1);
+    let avgX = 0;
+    let avgY = 0;
+    if (bucket === bucketCount - 1) {
+      avgX = xValues ? xValues[n - 1] : n - 1;
+      avgY = yValues[n - 1];
+    } else {
+      const nextStart = Math.floor((bucket + 1) * bucketSize) + 1;
+      const nextEnd = Math.min(Math.floor((bucket + 2) * bucketSize) + 1, n - 1);
+      let count = 0;
+      for (let j = nextStart; j < nextEnd; j++) {
+        avgX += xValues ? xValues[j] : j;
+        avgY += yValues[j];
+        count++;
+      }
+      if (count > 0) {
+        avgX /= count;
+        avgY /= count;
+      }
+    }
+    const ax = xValues ? xValues[prevSelectedIdx] : prevSelectedIdx;
+    const ay = yValues[prevSelectedIdx];
+    const cx = avgX;
+    const cy = avgY;
+    let maxArea = -1;
+    let bestIdx = bucketStart;
+    for (let j = bucketStart; j < bucketEnd; j++) {
+      const bx = xValues ? xValues[j] : j;
+      const by = yValues[j];
+      const area = Math.abs(ax * (by - cy) + bx * (cy - ay) + cx * (ay - by));
+      if (area > maxArea) {
+        maxArea = area;
+        bestIdx = j;
+      }
+    }
+    result[bucket + 1] = bestIdx;
+    prevSelectedIdx = bestIdx;
+  }
+  result[targetCount - 1] = n - 1;
+  return result;
+}
+function decimateMinMax(yValues, targetCount) {
+  const n = yValues.length;
+  if (targetCount >= n || targetCount < 2) {
+    return Array.from({ length: n }, (_, i) => i);
+  }
+  const indexSet = /* @__PURE__ */ new Set();
+  indexSet.add(0);
+  indexSet.add(n - 1);
+  const bucketSize = n / targetCount;
+  for (let bucket = 0; bucket < targetCount; bucket++) {
+    const bucketStart = Math.floor(bucket * bucketSize);
+    const bucketEnd = Math.min(Math.floor((bucket + 1) * bucketSize), n);
+    let minIdx = bucketStart;
+    let maxIdx = bucketStart;
+    let minVal = yValues[bucketStart];
+    let maxVal = yValues[bucketStart];
+    for (let j = bucketStart + 1; j < bucketEnd; j++) {
+      const val = yValues[j];
+      if (val < minVal) {
+        minVal = val;
+        minIdx = j;
+      }
+      if (val > maxVal) {
+        maxVal = val;
+        maxIdx = j;
+      }
+    }
+    indexSet.add(minIdx);
+    indexSet.add(maxIdx);
+  }
+  const result = Array.from(indexSet);
+  result.sort((a, b) => a - b);
+  return result;
+}
+function decimateKMeans(xValues, yValues, targetCount) {
+  const n = xValues.length;
+  if (targetCount >= n || targetCount < 2) {
+    return Array.from({ length: n }, (_, i) => ({ x: xValues[i], y: yValues[i] }));
+  }
+  const k = targetCount;
+  let xMin = Infinity, xMax = -Infinity, yMin = Infinity, yMax = -Infinity;
+  for (let i = 0; i < n; i++) {
+    if (xValues[i] < xMin) xMin = xValues[i];
+    if (xValues[i] > xMax) xMax = xValues[i];
+    if (yValues[i] < yMin) yMin = yValues[i];
+    if (yValues[i] > yMax) yMax = yValues[i];
+  }
+  const xRange = xMax - xMin || 1;
+  const yRange = yMax - yMin || 1;
+  const normX = new Float64Array(n);
+  const normY = new Float64Array(n);
+  for (let i = 0; i < n; i++) {
+    normX[i] = (xValues[i] - xMin) / xRange;
+    normY[i] = (yValues[i] - yMin) / yRange;
+  }
+  const centX = new Float64Array(k);
+  const centY = new Float64Array(k);
+  const pool = new Int32Array(n);
+  for (let i = 0; i < n; i++) pool[i] = i;
+  for (let c = 0; c < k; c++) {
+    const j = c + Math.floor(Math.random() * (n - c));
+    const picked = pool[j];
+    pool[j] = pool[c];
+    pool[c] = picked;
+    centX[c] = normX[picked];
+    centY[c] = normY[picked];
+  }
+  const batchSize = Math.min(n, 1e4);
+  const iterations = 5;
+  const clusterCounts = new Float64Array(k);
+  for (let iter = 0; iter < iterations; iter++) {
+    const sumX = new Float64Array(k);
+    const sumY = new Float64Array(k);
+    const counts = new Float64Array(k);
+    for (let b = 0; b < batchSize; b++) {
+      const i = Math.floor(Math.random() * n);
+      const px = normX[i];
+      const py = normY[i];
+      let bestC = 0;
+      let bestDist = Infinity;
+      for (let c = 0; c < k; c++) {
+        const dx = px - centX[c];
+        const dy = py - centY[c];
+        const d = dx * dx + dy * dy;
+        if (d < bestDist) {
+          bestDist = d;
+          bestC = c;
+        }
+      }
+      sumX[bestC] += px;
+      sumY[bestC] += py;
+      counts[bestC]++;
+    }
+    for (let c = 0; c < k; c++) {
+      if (counts[c] > 0) {
+        clusterCounts[c] += counts[c];
+        const lr = counts[c] / clusterCounts[c];
+        centX[c] = centX[c] * (1 - lr) + sumX[c] / counts[c] * lr;
+        centY[c] = centY[c] * (1 - lr) + sumY[c] / counts[c] * lr;
+      }
+    }
+  }
+  const result = [];
+  for (let c = 0; c < k; c++) {
+    if (clusterCounts[c] > 0) {
+      result.push({
+        x: centX[c] * xRange + xMin,
+        y: centY[c] * yRange + yMin
+      });
+    }
+  }
+  return result;
+}
+var DEFAULT_SAMPLES = 500;
+function decimate(yValues, config, xValues) {
+  const samples = config.samples ?? DEFAULT_SAMPLES;
+  const threshold = config.threshold ?? samples;
+  if (yValues.length <= threshold) {
+    return Array.from({ length: yValues.length }, (_, i) => i);
+  }
+  switch (config.algorithm) {
+    case "lttb":
+    case "k-means":
+      return decimateLTTB(yValues, samples, xValues);
+    case "min-max":
+      return decimateMinMax(yValues, samples);
+    default:
+      return Array.from({ length: yValues.length }, (_, i) => i);
+  }
+}
+var ScatterDecimator = class {
+  constructor() {
+    this.cache = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Apply viewport-aware decimation to scatter datasets.
+   * Returns a new array with the same shape as `datasets`, with `props.data` replaced where decimated.
+   */
+  apply(datasets, config, zoomX, zoomY) {
+    const samples = config.samples ?? DEFAULT_SAMPLES;
+    const threshold = config.threshold ?? samples;
+    const activeDataRefs = /* @__PURE__ */ new Set();
+    const result = datasets.map((sd) => {
+      const originalData = sd.props.data ?? [];
+      if (originalData.length <= threshold && !zoomX && !zoomY) return sd;
+      activeDataRefs.add(originalData);
+      const xField = String(sd.props.xField ?? FIELD_DEFAULTS.xField);
+      const yField = String(sd.props.yField ?? FIELD_DEFAULTS.yField);
+      let visibleData = originalData;
+      if (zoomX || zoomY) {
+        visibleData = originalData.filter((row) => {
+          const inX = !zoomX || row[xField] >= zoomX.min && row[xField] <= zoomX.max;
+          const inY = !zoomY || row[yField] >= zoomY.min && row[yField] <= zoomY.max;
+          return inX && inY;
+        });
+      }
+      if (visibleData.length <= samples) {
+        return { ...sd, props: { ...sd.props, data: visibleData } };
+      }
+      const vpKey = `${zoomX?.min ?? ""},${zoomX?.max ?? ""},${zoomY?.min ?? ""},${zoomY?.max ?? ""}`;
+      const cached = this.cache.get(originalData);
+      if (cached && cached.samples === samples && cached.viewportKey === vpKey) {
+        return { ...sd, props: { ...sd.props, data: cached.result } };
+      }
+      const xVals = visibleData.map((r) => r[xField]);
+      const yVals = visibleData.map((r) => r[yField]);
+      const decimated = decimateKMeans(xVals, yVals, samples);
+      const decimatedData = decimated.map((pt) => ({ [xField]: pt.x, [yField]: pt.y }));
+      this.cache.set(originalData, { samples, viewportKey: vpKey, result: decimatedData });
+      return { ...sd, props: { ...sd.props, data: decimatedData } };
+    });
+    for (const key of this.cache.keys()) {
+      if (!activeDataRefs.has(key)) this.cache.delete(key);
+    }
+    return result;
+  }
+};
+
+export { DEFAULT_EXPORT_MENU_ITEMS, DEFAULT_EXPORT_MENU_PROPS, EXPORT_MENU_CONSTANTS, EXPORT_MENU_LABELS, HAMBURGER_ICON_PATH, ScatterDecimator, decimate, decimateKMeans, decimateLTTB, decimateMinMax, estimateExportMenuHeight, filterExportMenuItems, getExportAction, isExportMenuSeparator, resolveExportMenuPlacement, resolveExportMenuProps };

package/dist/chunk-OXTFAWSK.mjs

@@ -0,0 +1,60 @@
+import { DEFAULT_DATA_LABEL_FONT_FAMILY, resolveFontFamily, resolveFontSize, DEFAULT_DATA_LABEL_FONT_SIZE } from './chunk-NKUYIWAP.mjs';
+
+// src/utils/text/datalabel.utils.ts
+function normalizeDataLabelConfig(props, adaptiveFontSize, adaptiveRotation, globalFont) {
+  if (!props) return null;
+  const fontSizeAccessor = props.fontSize;
+  const colorAccessor = props.color;
+  const connectorColorAccessor = props.connectorColor;
+  const connectorWidthAccessor = props.connectorWidth;
+  const scalarFontSize = typeof fontSizeAccessor === "number" ? fontSizeAccessor : void 0;
+  const scalarColor = typeof colorAccessor === "string" ? colorAccessor : void 0;
+  return {
+    display: props.display ?? "percentage",
+    fontSize: scalarFontSize ?? adaptiveFontSize ?? resolveFontSize(DEFAULT_DATA_LABEL_FONT_SIZE, globalFont),
+    fontWeight: props.fontWeight ?? "normal",
+    fontFamily: props.fontFamily ?? resolveFontFamily(void 0, globalFont) ?? DEFAULT_DATA_LABEL_FONT_FAMILY,
+    color: scalarColor,
+    // Pass the raw accessors through when the user supplied a non-scalar form so
+    // renderers can resolve per-label values from each item's ItemContext.
+    fontSizeAccessor: scalarFontSize === void 0 ? fontSizeAccessor : void 0,
+    colorAccessor: scalarColor === void 0 ? colorAccessor : void 0,
+    connectorColorAccessor,
+    connectorWidthAccessor,
+    minPercentage: props.minPercentage ?? 5,
+    formatter: props.formatter,
+    rotation: props.rotation ?? adaptiveRotation ?? 0,
+    leaderOffset: props.leaderOffset ?? 10,
+    horizontalOffset: props.horizontalOffset ?? 15,
+    textOffset: props.textOffset ?? 4,
+    lineHeight: props.lineHeight ?? 1.2,
+    lineStyle: props.lineStyle ?? "angled",
+    alignTo: props.alignTo ?? "labelLine",
+    render: props.render
+  };
+}
+function formatLabelValue(value) {
+  return Number.isFinite(value) ? String(Number(value.toFixed(2))) : String(value);
+}
+function formatDataLabelText(value, percentage, display, formatter, label) {
+  if (formatter) {
+    return formatter(value, percentage, label);
+  }
+  switch (display) {
+    case "percentage":
+      return `${Math.round(percentage)}%`;
+    case "value":
+      return formatLabelValue(value);
+    case "both":
+      return `${formatLabelValue(value)} (${Math.round(percentage)}%)`;
+    case "label":
+      return label ?? null;
+    case "label-percentage":
+      return label ? `${label} ${Math.round(percentage)}%` : `${Math.round(percentage)}%`;
+    case "none":
+    default:
+      return null;
+  }
+}
+
+export { formatDataLabelText, normalizeDataLabelConfig };