@primeui/chart-core 0.0.1-alpha.1

package/dist/chunk-WFTX4AQJ.mjs

@@ -0,0 +1,194 @@
+import { formatTimeLabel, formatHitValue, formatCursorValue } from './chunk-DP2IZNN3.mjs';
+import { getColor, resolveSwatchColor, asGradient } from './chunk-O2X6FF45.mjs';
+
+// src/cartesian/hittest-wrappers/line.ts
+function lineHitTest(x, y, ctx) {
+  for (const [datasetId, lineLayout] of ctx.layouts) {
+    const props = ctx.renderPropsCache.get(datasetId);
+    if (!props) continue;
+    const hitIndex = ctx.hitTest(x, y, props, lineLayout);
+    if (hitIndex !== null) {
+      const pt = lineLayout.visiblePoints.find((p) => p.dataIndex === hitIndex);
+      if (!pt) continue;
+      const color = getColor({ color: lineLayout.lineColor }, lineLayout.seriesIdx, void 0, ctx.theme);
+      const rawLabel = pt.category ?? String(hitIndex);
+      const label = formatTimeLabel(String(rawLabel), ctx.layoutData);
+      return {
+        datasetId,
+        index: hitIndex,
+        label,
+        value: pt.value ?? 0,
+        x: pt.x,
+        y: pt.y,
+        color,
+        colorGradient: asGradient(lineLayout.lineColor),
+        swatchColor: resolveSwatchColor({ color: lineLayout.lineColor }, lineLayout.seriesIdx, void 0, ctx.theme)
+      };
+    }
+  }
+  return null;
+}
+function lineFindAllNearest(x, y, ctx) {
+  const { layouts, layoutData, renderPropsCache } = ctx;
+  if (layouts.size === 0) return null;
+  const firstLayout = layouts.values().next().value;
+  const area = firstLayout.chartArea;
+  if (x < area.x || x > area.x + area.width || y < area.y || y > area.y + area.height) return null;
+  const firstPts = firstLayout.visiblePoints;
+  const bandStep = firstPts.length >= 2 ? Math.abs(firstPts[1].x - firstPts[0].x) : Infinity;
+  const halfStep = isFinite(bandStep) ? bandStep / 2 : Infinity;
+  let targetX = -1;
+  let minAnyDist = Infinity;
+  for (const [, layout] of layouts) {
+    for (const pt of layout.visiblePoints) {
+      const d = Math.abs(pt.x - x);
+      if (d < minAnyDist) {
+        minAnyDist = d;
+        targetX = pt.x;
+      }
+    }
+  }
+  if (targetX === -1 || minAnyDist > halfStep) return null;
+  let primaryHit = null;
+  let bestDist = Infinity;
+  const allSeries = [];
+  for (const [datasetId, layout] of layouts) {
+    let pt;
+    let nearestXDist = Infinity;
+    for (const p of layout.visiblePoints) {
+      const d = Math.abs(p.x - targetX);
+      if (d < nearestXDist) {
+        nearestXDist = d;
+        pt = p;
+      }
+    }
+    if (!pt || nearestXDist > halfStep) continue;
+    const color = getColor({ color: layout.lineColor }, layout.seriesIdx, void 0, ctx.theme);
+    const colorGradient = asGradient(layout.lineColor);
+    const swatchColor = resolveSwatchColor({ color: layout.lineColor }, layout.seriesIdx, void 0, ctx.theme);
+    const value = pt.value ?? 0;
+    const rawLabel = pt.category ?? String(pt.dataIndex);
+    const label = formatTimeLabel(String(rawLabel), layoutData);
+    const lineProps = renderPropsCache.get(datasetId);
+    const formattedValue = lineProps ? formatHitValue(value, lineProps, "vertical", layoutData) : String(value);
+    const cursorFormattedValue = lineProps ? formatCursorValue(x, y, lineProps, "vertical", layoutData) : formattedValue;
+    const name = lineProps?.name;
+    allSeries.push({ datasetId, name, label, color, colorGradient, swatchColor, value, formattedValue, cursorFormattedValue, snapPixel: pt.y });
+    const dist = Math.sqrt((x - pt.x) ** 2 + (y - pt.y) ** 2);
+    if (dist < bestDist) {
+      bestDist = dist;
+      primaryHit = { datasetId, index: pt.dataIndex, label, value, color, colorGradient, swatchColor, snapX: pt.x, snapY: pt.y, formattedValue, cursorFormattedValue };
+    }
+  }
+  if (!primaryHit) return null;
+  return { primary: primaryHit, allSeries };
+}
+
+// src/cartesian/stacking.ts
+function detectCartesianMode(datasets, features) {
+  const stackedDatasets = datasets.filter((d) => d.stackId !== void 0);
+  const distinctStackIds = new Set(stackedDatasets.map((d) => d.stackId));
+  const isGroupedStacked = distinctStackIds.size > 1;
+  const isStacked = stackedDatasets.length > 0;
+  const isPercentStacked = isStacked && !isGroupedStacked && features.stacking?.mode === "percent";
+  const isWaterfall = features.waterfall !== void 0;
+  const isOverlap = features.overlap !== void 0;
+  const isGrouped = isGroupedStacked || !isStacked && !isOverlap && datasets.length > 1;
+  return { isStacked, isPercentStacked, isWaterfall, isOverlap, isGrouped };
+}
+function transformValues(valuesPerDataset, categoryCount, mode) {
+  let result = valuesPerDataset;
+  if (mode.isPercentStacked) {
+    const categoryTotals = new Array(categoryCount).fill(0);
+    for (const values of result) {
+      for (let catIdx = 0; catIdx < categoryCount; catIdx++) {
+        categoryTotals[catIdx] += Math.abs(values[catIdx] ?? 0);
+      }
+    }
+    result = result.map(
+      (values) => values.map((v, catIdx) => {
+        const total = categoryTotals[catIdx];
+        return total > 0 ? Math.abs(v) / total * 100 : 0;
+      })
+    );
+    return { transformed: result, categoryTotals };
+  }
+  return { transformed: result };
+}
+function computeWaterfallBases(valuesPerDataset, categoryCount, data, totalField) {
+  const bases = new Array(categoryCount).fill(0);
+  let running = 0;
+  for (let i = 0; i < categoryCount; i++) {
+    const isTotal = totalField && data[i]?.[totalField];
+    if (isTotal) {
+      bases[i] = 0;
+      for (let j = 0; j < valuesPerDataset.length; j++) {
+        valuesPerDataset[j][i] = j === 0 ? running : 0;
+      }
+    } else {
+      bases[i] = running;
+      let catSum = 0;
+      for (const vals of valuesPerDataset) {
+        catSum += vals[i];
+      }
+      running += catSum;
+    }
+  }
+  return bases;
+}
+function computeStackBases(datasetIds, valuesPerDataset, categoryCount, mode, waterfallBases, signsPerDataset) {
+  const stackBasesMap = /* @__PURE__ */ new Map();
+  if (mode.isWaterfall) {
+    if (mode.isStacked) {
+      for (const id of datasetIds) {
+        stackBasesMap.set(id, new Array(categoryCount).fill(0));
+      }
+      const catTotalDeltas = new Array(categoryCount).fill(0);
+      for (let i = 0; i < categoryCount; i++) {
+        for (const vals of valuesPerDataset) {
+          catTotalDeltas[i] += vals[i];
+        }
+      }
+      for (let i = 0; i < categoryCount; i++) {
+        let running = waterfallBases[i];
+        if (catTotalDeltas[i] < 0) {
+          for (let dsIdx = datasetIds.length - 1; dsIdx >= 0; dsIdx--) {
+            stackBasesMap.get(datasetIds[dsIdx])[i] = running;
+            running += valuesPerDataset[dsIdx][i];
+          }
+        } else {
+          for (let dsIdx = 0; dsIdx < datasetIds.length; dsIdx++) {
+            stackBasesMap.get(datasetIds[dsIdx])[i] = running;
+            running += valuesPerDataset[dsIdx][i];
+          }
+        }
+      }
+    } else {
+      for (const id of datasetIds) {
+        stackBasesMap.set(id, [...waterfallBases]);
+      }
+    }
+  } else {
+    const runningPos = new Array(categoryCount).fill(0);
+    const runningNeg = new Array(categoryCount).fill(0);
+    for (let dsIdx = 0; dsIdx < datasetIds.length; dsIdx++) {
+      const bases = new Array(categoryCount).fill(0);
+      const values = valuesPerDataset[dsIdx];
+      for (let i = 0; i < values.length; i++) {
+        const v = isFinite(values[i]) ? values[i] : 0;
+        const sign = v !== 0 ? v > 0 ? 1 : -1 : signsPerDataset?.[dsIdx]?.[i] ?? 1;
+        if (sign >= 0) {
+          bases[i] = runningPos[i];
+          runningPos[i] += v;
+        } else {
+          bases[i] = runningNeg[i];
+          runningNeg[i] += v;
+        }
+      }
+      stackBasesMap.set(datasetIds[dsIdx], bases);
+    }
+  }
+  return stackBasesMap;
+}
+
+export { computeStackBases, computeWaterfallBases, detectCartesianMode, lineFindAllNearest, lineHitTest, transformValues };

package/dist/chunk-WFVOQ2QZ.mjs

@@ -0,0 +1,18 @@
+import { renderHeatmapSvg } from './chunk-MTGMXRNF.mjs';
+import { renderHeatmapCanvas } from './chunk-TQ6S34QZ.mjs';
+
+// src/series/heatmap/index.ts
+var heatmapRenderer = {
+  calculateLayout: (_props, _area) => {
+    return { cells: [], chartArea: _area, xCategories: [], yCategories: [], valueRange: [0, 1], resolvedColorScale: [], resolvedColorRange: [] };
+  },
+  renderSvg: (props, layout, context) => {
+    return renderHeatmapSvg(props, layout, context);
+  },
+  renderCanvas: (props, layout, ctx, context) => {
+    renderHeatmapCanvas(props, layout, ctx, context);
+  },
+  hitTest: () => null
+};
+
+export { heatmapRenderer };

package/dist/chunk-WH3C3Y7P.mjs

@@ -0,0 +1,149 @@
+import { parseColorToRGB } from './chunk-SSLTFJ3U.mjs';
+import { clamp } from './chunk-RQ3CKQOX.mjs';
+
+// src/animations/interpolation.ts
+function lerp(start, end, t) {
+  return start + (end - start) * t;
+}
+function lerpValues(start, target, progress) {
+  const n = Math.max(start.length, target.length);
+  const result = new Array(n);
+  for (let i = 0; i < n; i++) {
+    const s = start[i] ?? target[i] ?? 0;
+    const t = target[i] ?? start[i] ?? 0;
+    result[i] = s + (t - s) * progress;
+  }
+  return result;
+}
+function lerpColor(startColor, endColor, t) {
+  const start = parseColorToRGB(startColor);
+  const end = parseColorToRGB(endColor);
+  if (!start || !end) {
+    return t < 0.5 ? startColor : endColor;
+  }
+  const r = Math.round(clamp(lerp(start.r, end.r, t), 0, 255));
+  const g = Math.round(clamp(lerp(start.g, end.g, t), 0, 255));
+  const b = Math.round(clamp(lerp(start.b, end.b, t), 0, 255));
+  return `#${r.toString(16).padStart(2, "0")}${g.toString(16).padStart(2, "0")}${b.toString(16).padStart(2, "0")}`;
+}
+function interpolateRadialGrid(prevDomain, targetDomain, target, radius, progress) {
+  const interpMin = prevDomain[0] + (targetDomain[0] - prevDomain[0]) * progress;
+  const interpMax = prevDomain[1] + (targetDomain[1] - prevDomain[1]) * progress;
+  const domainSpan = interpMax - interpMin;
+  const levelRadii = target.levelValues.map((v) => {
+    if (domainSpan === 0) return 0;
+    return clamp((v - interpMin) / domainSpan * radius, 0, radius);
+  });
+  return { ...target, levelRadii };
+}
+function interpolateCartesianAxisLayout(settledLayout, intermediateScale) {
+  const isHorizontal = settledLayout.position === "top" || settledLayout.position === "bottom";
+  const [rangeStart, rangeEnd] = intermediateScale.range();
+  const rangeMin = Math.min(rangeStart, rangeEnd);
+  const rangeMax = Math.max(rangeStart, rangeEnd);
+  const remappedTicks = [];
+  for (const tick of settledLayout.layout.ticks) {
+    if (tick.rawValue === void 0) {
+      remappedTicks.push(tick);
+      continue;
+    }
+    const newPos = intermediateScale(tick.rawValue);
+    if (!Number.isFinite(newPos) || newPos < rangeMin || newPos > rangeMax) {
+      continue;
+    }
+    const rounded = Math.round(newPos);
+    if (isHorizontal) {
+      remappedTicks.push({
+        ...tick,
+        position: newPos,
+        x1: newPos,
+        x2: newPos,
+        labelX: rounded
+      });
+    } else {
+      remappedTicks.push({
+        ...tick,
+        position: newPos,
+        y1: newPos,
+        y2: newPos,
+        labelY: rounded
+      });
+    }
+  }
+  const settledLayoutData = settledLayout.layout;
+  const gridLines = settledLayoutData.gridLines.length > 0 ? remappedTicks.map(
+    (t, i) => isHorizontal ? { x1: t.position, y1: settledLayoutData.gridLines[i]?.y1 ?? 0, x2: t.position, y2: settledLayoutData.gridLines[i]?.y2 ?? 0 } : { x1: settledLayoutData.gridLines[i]?.x1 ?? 0, y1: t.position, x2: settledLayoutData.gridLines[i]?.x2 ?? 0, y2: t.position }
+  ) : [];
+  return {
+    ...settledLayout,
+    layout: {
+      ...settledLayoutData,
+      ticks: remappedTicks,
+      gridLines
+    }
+  };
+}
+function createRadarEntranceLayout(target) {
+  const series = target.series.map((s) => ({
+    ...s,
+    points: s.points.map((p) => ({
+      ...p,
+      x: target.center.x,
+      y: target.center.y,
+      value: 0
+    })),
+    basePoints: s.basePoints?.map((p) => ({
+      ...p,
+      x: target.center.x,
+      y: target.center.y,
+      value: 0
+    }))
+  }));
+  return { ...target, series };
+}
+function polarBarKey(b) {
+  return b.dataKey != null ? `${b.datasetId}:key:${b.dataKey}` : `${b.datasetId}:cat:${b.category}`;
+}
+function interpolatePolarLayout(prev, target, progress) {
+  const targetKeys = new Set(target.bars.map(polarBarKey));
+  const prevBarMap = new Map(prev.bars.map((b) => [polarBarKey(b), b]));
+  const bars = target.bars.map((tb) => {
+    const pb = prevBarMap.get(polarBarKey(tb));
+    if (!pb) {
+      return {
+        ...tb,
+        outerRadius: tb.innerRadius + (tb.outerRadius - tb.innerRadius) * progress
+      };
+    }
+    return {
+      ...tb,
+      innerRadius: pb.innerRadius + (tb.innerRadius - pb.innerRadius) * progress,
+      outerRadius: pb.outerRadius + (tb.outerRadius - pb.outerRadius) * progress,
+      startAngle: pb.startAngle + (tb.startAngle - pb.startAngle) * progress,
+      endAngle: pb.endAngle + (tb.endAngle - pb.endAngle) * progress
+    };
+  });
+  for (const pb of prev.bars) {
+    if (!targetKeys.has(polarBarKey(pb))) {
+      bars.push({
+        ...pb,
+        outerRadius: pb.outerRadius + (pb.innerRadius - pb.outerRadius) * progress
+      });
+    }
+  }
+  return {
+    ...target,
+    grid: interpolateRadialGrid(prev.domain, target.domain, target.grid, target.maxRadius, progress),
+    bars
+  };
+}
+function createPolarEntranceLayout(target) {
+  const bars = target.bars.map((b) => ({
+    ...b,
+    outerRadius: b.innerRadius
+    // zero height
+  }));
+  return { ...target, bars };
+}
+
+export { createPolarEntranceLayout, createRadarEntranceLayout, interpolateCartesianAxisLayout, interpolatePolarLayout, interpolateRadialGrid, lerp, lerpColor, lerpValues };