@primeui/chart-core 0.0.1-alpha.1

package/dist/chunk-WYLILAOO.mjs

@@ -0,0 +1,167 @@
+import { makeItemContext, resolveAccessor, getColor, asGradient, getColorValue } from './chunk-O2X6FF45.mjs';
+
+// src/orchestrator/syncHandlers.ts
+function handleSyncedHighlightCartesian(event, delegate, hasCrosshair, isSharedMode, datasets) {
+  if (event.normalized === null) {
+    return { tooltip: null, hoverDatasetId: null, hoverIndex: null };
+  }
+  const plotArea = delegate?.getPlotArea();
+  if (!plotArea) {
+    return { tooltip: null, hoverDatasetId: null, hoverIndex: null };
+  }
+  let px = plotArea.x + event.normalized * plotArea.width;
+  let py = plotArea.y + plotArea.height / 2;
+  if (event.categoryIndex != null && event.sourceType !== "cartesian" && datasets) {
+    for (const dsId of datasets.keys()) {
+      const pt = delegate?.getPointPosition(dsId, event.categoryIndex) ?? null;
+      if (pt) {
+        px = pt.x + pt.width / 2;
+        py = pt.y + pt.height / 2;
+        break;
+      }
+    }
+  }
+  const result = delegate?.findAllNearest(px, py) ?? null;
+  if (!result?.primary) {
+    return { tooltip: null, hoverDatasetId: null, hoverIndex: null };
+  }
+  const hit = result.primary;
+  const cartHit = "snapX" in hit ? hit : null;
+  const axisIdx = isSharedMode ? hit.index : null;
+  const axisX = isSharedMode ? cartHit?.snapX ?? null : null;
+  const crosshair = hasCrosshair;
+  const syncCursorX = crosshair && cartHit ? cartHit.snapX : px;
+  const syncCursorY = crosshair && cartHit ? cartHit.snapY : py;
+  const tooltip = {
+    visible: true,
+    x: (cartHit?.snapX ?? px) + 10,
+    y: (cartHit?.snapY ?? py) + 10,
+    label: hit.label,
+    value: hit.value,
+    color: hit.color,
+    datasetId: hit.datasetId,
+    index: hit.index,
+    snapX: crosshair && cartHit ? cartHit.snapX : void 0,
+    snapY: crosshair && cartHit ? cartHit.snapY : void 0,
+    cursorX: crosshair ? syncCursorX : void 0,
+    cursorY: crosshair ? syncCursorY : void 0,
+    formattedValue: cartHit?.formattedValue,
+    // A synced chart has no real cursor — the broadcast only carries the X position
+    // (py defaults to the plot middle), so a pixel-inverted cursor value would be
+    // meaningless. Show the snapped data value at the synced category instead.
+    cursorFormattedValue: cartHit?.formattedValue,
+    ohlc: cartHit?.ohlc,
+    allSeriesHits: result.allSeries
+  };
+  return { tooltip, hoverDatasetId: hit.datasetId, hoverIndex: hit.index, axisIdx, axisX };
+}
+function handleSyncedHighlightRadial(event, datasets, delegate, width, height) {
+  if (event.normalized === null || event.categoryIndex == null) {
+    return { tooltip: null, hoverDatasetId: null, hoverIndex: null };
+  }
+  const catIdx = event.categoryIndex;
+  for (const [dsId, ds] of datasets) {
+    if (ds.type !== "pie" && ds.type !== "donut" && ds.type !== "radar" && ds.type !== "polar") continue;
+    const props = ds.props;
+    const data = props.data;
+    if (!data || catIdx >= data.length) continue;
+    const item = data[catIdx];
+    const itemCtx = makeItemContext(item, catIdx);
+    const label = props.categoryField ? String(resolveAccessor(props.categoryField, itemCtx)) : "";
+    const value = props.valueField ? resolveAccessor(props.valueField, itemCtx) : 0;
+    let color = "";
+    if (props.color != null) {
+      const resolved = resolveAccessor(props.color, itemCtx);
+      color = typeof resolved === "string" ? resolved : "";
+    }
+    const ptPos = delegate?.getPointPosition(dsId, catIdx);
+    const tooltipX = ptPos ? ptPos.x + ptPos.width / 2 + 10 : width / 2 + 10;
+    const tooltipY = ptPos ? ptPos.y + ptPos.height / 2 + 10 : height / 2 + 10;
+    const tooltip = {
+      visible: true,
+      x: tooltipX,
+      y: tooltipY,
+      label,
+      value,
+      color,
+      datasetId: dsId,
+      index: catIdx
+    };
+    return { tooltip, hoverDatasetId: dsId, hoverIndex: catIdx };
+  }
+  return { tooltip: null, hoverDatasetId: null, hoverIndex: null };
+}
+function handleSyncedHighlightRect(event, datasets, width, height) {
+  if (event.normalized === null || event.categoryIndex == null) {
+    return { tooltip: null, hoverDatasetId: null, hoverIndex: null };
+  }
+  const catIdx = event.categoryIndex;
+  for (const [dsId, ds] of datasets) {
+    if (ds.type !== "treemap" && ds.type !== "heatmap") continue;
+    const dProps = ds.props;
+    const data = dProps["data"];
+    if (!data || catIdx >= data.length) continue;
+    const item = data[catIdx];
+    const itemCtx = makeItemContext(item, catIdx);
+    const categoryField = dProps["categoryField"];
+    const valueField = dProps["valueField"];
+    const label = categoryField ? String(resolveAccessor(categoryField, itemCtx)) : "";
+    const value = valueField ? resolveAccessor(valueField, itemCtx) : 0;
+    return {
+      tooltip: {
+        visible: true,
+        x: width / 2 + 10,
+        y: height / 2 + 10,
+        label,
+        value,
+        color: "",
+        datasetId: dsId,
+        index: catIdx
+      },
+      hoverDatasetId: dsId,
+      hoverIndex: catIdx
+    };
+  }
+  return { tooltip: null, hoverDatasetId: null, hoverIndex: null };
+}
+function buildDatasetRegistrations(chartId, datasets, theme) {
+  const infos = [];
+  for (const [datasetId, dataset] of datasets) {
+    const props = dataset.props;
+    const firstItem = props.data?.[0];
+    const color = getColor(props, dataset.order, firstItem, theme);
+    infos.push({
+      chartId,
+      datasetId,
+      label: props.name ?? datasetId,
+      color,
+      colorGradient: asGradient(getColorValue(props, dataset.order, firstItem, theme)),
+      type: dataset.type,
+      order: dataset.order
+    });
+    const data = props.data;
+    const labelAccessor = props.label;
+    if (data && labelAccessor) {
+      const valueAccessor = props.valueField;
+      data.forEach((item, i) => {
+        const itemLabel = String(resolveAccessor(labelAccessor, makeItemContext(item, i)));
+        const itemValue = valueAccessor ? resolveAccessor(valueAccessor, makeItemContext(item, i)) ?? null : null;
+        const itemExtras = { value: itemValue, category: itemLabel, seriesIndex: dataset.order, seriesId: datasetId };
+        const itemColor = getColor(props, i, item, theme, itemExtras);
+        infos.push({
+          chartId,
+          datasetId,
+          itemIndex: i,
+          label: itemLabel,
+          color: itemColor,
+          colorGradient: asGradient(getColorValue(props, i, item, theme, itemExtras)),
+          type: dataset.type,
+          order: dataset.order * 1e4 + i
+        });
+      });
+    }
+  }
+  return infos;
+}
+
+export { buildDatasetRegistrations, handleSyncedHighlightCartesian, handleSyncedHighlightRadial, handleSyncedHighlightRect };

package/dist/chunk-X4D7FKUS.mjs

@@ -0,0 +1,62 @@
+import { DEFAULT_FALLBACK_COLOR } from './chunk-NKUYIWAP.mjs';
+import { getPrimaryColor } from './chunk-O2X6FF45.mjs';
+
+// src/cartesian/marker-overlay.utils.ts
+function literalSeriesColor(c) {
+  if (c == null) return void 0;
+  if (typeof c === "string") return c;
+  if (typeof c === "object" && !Array.isArray(c) && typeof c !== "function") return c;
+  return void 0;
+}
+function collectLineMarkerOverlays(layouts, renderPropsMap, snapshot) {
+  const entries = [];
+  for (const [dsId, layout] of layouts) {
+    const props = renderPropsMap.get(dsId);
+    if (!props?.renderMarker) continue;
+    const points = snapshot ? layout.visiblePoints.map((p) => ({ ...p })) : layout.visiblePoints.map((pt) => ({
+      x: pt.x,
+      y: pt.y,
+      dataIndex: pt.dataIndex,
+      value: pt.value,
+      category: pt.category
+    }));
+    const color = typeof layout.lineColor === "string" ? layout.lineColor : typeof props.color === "string" ? props.color : DEFAULT_FALLBACK_COLOR;
+    entries.push({
+      dsId,
+      renderMarker: props.renderMarker,
+      visiblePoints: points,
+      data: props.data,
+      color,
+      markerSize: typeof props.markerSize === "number" ? props.markerSize : 4,
+      effects: props.effects ? { dimOpacity: props.effects.dimOpacity, hoverPointRadius: props.effects.hoverPointRadius } : void 0,
+      pointBackgroundColor: props.pointBackgroundColor
+    });
+  }
+  return entries;
+}
+function collectScatterMarkerOverlays(layouts, renderPropsMap) {
+  const entries = [];
+  for (const [dsId, scatterLayout] of layouts) {
+    const props = renderPropsMap.get(dsId);
+    if (!props?.renderMarker) continue;
+    entries.push({
+      dsId,
+      renderMarker: props.renderMarker,
+      visiblePoints: scatterLayout.points.filter((pt) => pt.visible).map((pt) => ({
+        x: pt.px,
+        y: pt.py,
+        dataIndex: pt.dataIndex,
+        value: pt.yValue,
+        category: String(pt.xValue)
+      })),
+      data: props.data,
+      color: getPrimaryColor(literalSeriesColor(props.color) ?? DEFAULT_FALLBACK_COLOR),
+      markerSize: typeof props.markerSize === "number" ? props.markerSize : 4,
+      effects: { dimOpacity: props.effects?.dimOpacity },
+      pointBackgroundColor: props.pointBackgroundColor
+    });
+  }
+  return entries;
+}
+
+export { collectLineMarkerOverlays, collectScatterMarkerOverlays };

package/dist/chunk-X7T34OLW.mjs

@@ -0,0 +1,139 @@
+import { computeBarRenderStates, traceRoundedRect, tracePartialBorder } from './chunk-AUF4CHDP.mjs';
+import { isGradientColor, createCanvasGradientFromColor } from './chunk-O2X6FF45.mjs';
+import { readCssNumber, withCanvasState } from './chunk-SSLTFJ3U.mjs';
+
+// src/series/bar/canvas/index.ts
+function createCanvasPathBuilder(ctx) {
+  return {
+    moveTo(x, y) {
+      ctx.moveTo(x, y);
+    },
+    lineTo(x, y) {
+      ctx.lineTo(x, y);
+    },
+    arcTo(cx, cy, toX, toY, r) {
+      if (r > 0) ctx.arcTo(cx, cy, toX, toY, r);
+    },
+    closePath() {
+      ctx.closePath();
+    }
+  };
+}
+function drawRoundedRectCanvas(ctx, x, y, w, h, radius) {
+  ctx.beginPath();
+  traceRoundedRect(createCanvasPathBuilder(ctx), x, y, w, h, radius);
+}
+function drawPartialBorderCanvas(ctx, x, y, w, h, skipped, radius) {
+  ctx.beginPath();
+  tracePartialBorder(createCanvasPathBuilder(ctx), x, y, w, h, skipped, radius);
+}
+function renderBarCanvas(props, layout, ctx, context) {
+  const { bars: barStates, borderJoinStyle, borderAlign } = computeBarRenderStates(props, layout, context.theme);
+  const shapeFn = props.renderShape;
+  const canvasGradientCache = /* @__PURE__ */ new Map();
+  const cssBarStrokeWidth = readCssNumber(ctx.canvas, "--p-chart-bar-stroke-width", 0);
+  withCanvasState(ctx, () => {
+    for (const state of barStates) {
+      const { bar, effectColor, effectBorderColor, effectBorderWidth, effectBorderDash, effectBorderDashOffset, opacity, drawX, drawY, drawWidth, drawHeight, clampedRadius, hasRadius, skippedEdges } = state;
+      const { dataIndex } = bar;
+      const width = drawWidth;
+      const height = drawHeight;
+      let path2d;
+      if (shapeFn) {
+        const shapeInfo = {
+          x: drawX,
+          y: drawY,
+          width,
+          height,
+          value: bar.value,
+          category: bar.category,
+          dataIndex,
+          isNegative: bar.isNegative
+        };
+        path2d = new Path2D(shapeFn(shapeInfo));
+      }
+      if (isGradientColor(effectColor)) {
+        const cx = drawX + width / 2;
+        const cy = drawY + height / 2;
+        const radius = Math.max(width, height);
+        const gradKey = `${drawX}_${drawY}_${width}_${height}_${effectColor.radialGradient ? "r" : "l"}_${effectColor.stops.length}`;
+        let grad = canvasGradientCache.get(gradKey);
+        if (!grad) {
+          grad = createCanvasGradientFromColor(ctx, effectColor, { x: cx, y: cy }, radius, { x: drawX, y: drawY, width, height });
+          canvasGradientCache.set(gradKey, grad);
+        }
+        ctx.fillStyle = grad;
+      } else {
+        ctx.fillStyle = effectColor;
+      }
+      ctx.globalAlpha = opacity;
+      if (path2d) {
+        ctx.fill(path2d);
+      } else if (hasRadius) {
+        drawRoundedRectCanvas(ctx, drawX, drawY, width, height, clampedRadius);
+        ctx.fill();
+      } else {
+        ctx.fillRect(drawX, drawY, width, height);
+      }
+      const cssDrivenStroke = effectBorderWidth === 0 && cssBarStrokeWidth > 0;
+      const drawStrokeWidth = cssDrivenStroke ? cssBarStrokeWidth : effectBorderWidth;
+      const drawStrokeColor = cssDrivenStroke ? effectColor : effectBorderColor;
+      if (drawStrokeWidth > 0 && drawStrokeColor !== "transparent") {
+        ctx.strokeStyle = typeof drawStrokeColor === "string" ? drawStrokeColor : context.theme.borderColor;
+        ctx.lineJoin = borderJoinStyle;
+        if (effectBorderDash && effectBorderDash.length > 0) {
+          ctx.setLineDash(effectBorderDash);
+          ctx.lineDashOffset = effectBorderDashOffset;
+        } else {
+          ctx.setLineDash([]);
+        }
+        const usePartialBorder = skippedEdges.size > 0 && !path2d;
+        if (borderAlign === "inner") {
+          ctx.save();
+          if (path2d) {
+            ctx.clip(path2d);
+          } else if (hasRadius) {
+            drawRoundedRectCanvas(ctx, drawX, drawY, width, height, clampedRadius);
+            ctx.clip();
+          } else {
+            ctx.beginPath();
+            ctx.rect(drawX, drawY, width, height);
+            ctx.clip();
+          }
+          ctx.lineWidth = drawStrokeWidth * 2;
+          ctx.lineCap = usePartialBorder ? effectBorderDash && effectBorderDash.length > 0 ? "butt" : "square" : "butt";
+          if (usePartialBorder) {
+            drawPartialBorderCanvas(ctx, drawX, drawY, width, height, skippedEdges, clampedRadius);
+            ctx.stroke();
+          } else if (path2d) {
+            ctx.stroke(path2d);
+          } else if (hasRadius) {
+            drawRoundedRectCanvas(ctx, drawX, drawY, width, height, clampedRadius);
+            ctx.stroke();
+          } else {
+            ctx.beginPath();
+            ctx.rect(drawX, drawY, width, height);
+            ctx.stroke();
+          }
+          ctx.restore();
+        } else {
+          ctx.lineWidth = drawStrokeWidth;
+          ctx.lineCap = usePartialBorder ? effectBorderDash && effectBorderDash.length > 0 ? "butt" : "square" : "butt";
+          if (usePartialBorder) {
+            drawPartialBorderCanvas(ctx, drawX, drawY, width, height, skippedEdges, clampedRadius);
+            ctx.stroke();
+          } else if (path2d) {
+            ctx.stroke(path2d);
+          } else if (hasRadius) {
+            drawRoundedRectCanvas(ctx, drawX, drawY, width, height, clampedRadius);
+            ctx.stroke();
+          } else {
+            ctx.strokeRect(drawX, drawY, width, height);
+          }
+        }
+      }
+    }
+  });
+}
+
+export { renderBarCanvas };

package/dist/chunk-XIHBK5D3.mjs

@@ -0,0 +1,68 @@
+import { renderTreemapCanvas } from './chunk-55Y3WI6S.mjs';
+import { renderTreemapSvg } from './chunk-RO4N6YFS.mjs';
+import { calculateTreemapLayout } from './chunk-VVI3OBPJ.mjs';
+import { CHAR_WIDTH_RATIO } from './chunk-XTVE4P3L.mjs';
+
+// src/series/treemap/geometry.ts
+function hitTestTreemap(_x, _y, _props, layout) {
+  for (const cell of layout.cells) {
+    if (_x >= cell.x && _x <= cell.x + cell.width && _y >= cell.y && _y <= cell.y + cell.height) {
+      return cell.index;
+    }
+  }
+  return null;
+}
+
+// src/series/treemap/shared.ts
+var LABEL_TIERS = [
+  { minArea: 25e3, minWidth: 100, minHeight: 60, fontSize: 16, secondaryFontSize: 12, showSecondary: true },
+  { minArea: 1e4, minWidth: 70, minHeight: 45, fontSize: 14, secondaryFontSize: 10, showSecondary: true },
+  { minArea: 4e3, minWidth: 50, minHeight: 35, fontSize: 12, secondaryFontSize: 9, showSecondary: true },
+  { minArea: 1500, minWidth: 38, minHeight: 26, fontSize: 10, secondaryFontSize: 8, showSecondary: true },
+  { minArea: 600, minWidth: 28, minHeight: 20, fontSize: 9, secondaryFontSize: 0, showSecondary: false },
+  { minArea: 250, minWidth: 22, minHeight: 14, fontSize: 8, secondaryFontSize: 0, showSecondary: false }
+];
+function getCellLabelInfo(cell, labelMinSize) {
+  const area = cell.width * cell.height;
+  const none = { fontSize: 0, secondaryFontSize: 0, showPrimary: false, showSecondary: false, cx: 0, cy: 0, primaryY: 0, secondaryY: 0 };
+  const minSize = labelMinSize ?? 30;
+  if (cell.width < minSize || cell.height < minSize) return none;
+  for (const tier of LABEL_TIERS) {
+    if (area >= tier.minArea && cell.width >= tier.minWidth && cell.height >= tier.minHeight) {
+      const primaryTextWidth = cell.label.length * CHAR_WIDTH_RATIO * tier.fontSize;
+      if (primaryTextWidth > cell.width - 8) {
+        continue;
+      }
+      let showSec = tier.showSecondary && !!cell.secondaryLabel;
+      if (showSec) {
+        const secTextWidth = (cell.secondaryLabel?.length ?? 0) * CHAR_WIDTH_RATIO * tier.secondaryFontSize;
+        if (secTextWidth > cell.width - 8) {
+          showSec = false;
+        }
+      }
+      const cx = cell.x + cell.width / 2;
+      const cy = cell.y + cell.height / 2;
+      return {
+        fontSize: tier.fontSize,
+        secondaryFontSize: tier.secondaryFontSize,
+        showPrimary: true,
+        showSecondary: showSec,
+        cx,
+        cy,
+        primaryY: showSec ? cy - tier.fontSize * 0.4 : cy,
+        secondaryY: cy + tier.fontSize * 0.6
+      };
+    }
+  }
+  return none;
+}
+
+// src/series/treemap/index.ts
+var treemapRenderer = {
+  calculateLayout: calculateTreemapLayout,
+  renderSvg: (props, layout, context) => renderTreemapSvg(props, layout, context),
+  renderCanvas: (props, layout, ctx, context) => renderTreemapCanvas(props, layout, ctx, context),
+  hitTest: hitTestTreemap
+};
+
+export { getCellLabelInfo, hitTestTreemap, treemapRenderer };

package/dist/chunk-XQQCGFYB.mjs

@@ -0,0 +1,50 @@
+import { lerpValues } from './chunk-WH3C3Y7P.mjs';
+
+// src/animations/line.ts
+function detectLineUpdateKind(startVals, targetVals) {
+  if (!startVals || startVals.length === 0) return "update";
+  if (targetVals.length === startVals.length + 1) {
+    let allMatch = true;
+    for (let i = 0; i < startVals.length; i++) {
+      if (startVals[i] !== targetVals[i]) {
+        allMatch = false;
+        break;
+      }
+    }
+    if (allMatch) return "append";
+  }
+  if (targetVals.length === startVals.length && startVals.length >= 2) {
+    let isShift = true;
+    for (let i = 0; i < targetVals.length - 1; i++) {
+      if (targetVals[i] !== startVals[i + 1]) {
+        isShift = false;
+        break;
+      }
+    }
+    if (isShift) return "scroll";
+  }
+  return "update";
+}
+function buildLineFingerprint(layouts) {
+  const parts = [];
+  for (const [dsId, layout] of layouts) {
+    const vals = layout.visiblePoints.map((p) => p.value ?? "null").join(",");
+    parts.push(`${dsId}:${vals}`);
+  }
+  return parts.join("|");
+}
+
+// src/utils/specialized/streaming.utils.ts
+function detectStreamingUpdateKind(prev, next) {
+  return detectLineUpdateKind(prev, next);
+}
+function streamingPointsInterpolator(from, to, t) {
+  const f = from;
+  const tt = to;
+  if (tt.streamingHint === "append" || tt.streamingHint === "scroll") {
+    return { values: tt.values, streamingHint: tt.streamingHint };
+  }
+  return { values: lerpValues(f.values, tt.values, t), streamingHint: tt.streamingHint };
+}
+
+export { buildLineFingerprint, detectLineUpdateKind, detectStreamingUpdateKind, streamingPointsInterpolator };