@primeui/chart-core 0.0.1-alpha.1

package/dist/chunk-SALTGZFR.mjs

@@ -0,0 +1,208 @@
+import { computeBarRenderStates, traceRoundedRect, tracePartialBorder } from './chunk-AUF4CHDP.mjs';
+import { resolveSvgHoverFill } from './chunk-BZN2QHGP.mjs';
+import { formatPointDescription } from './chunk-OGJ6IIBW.mjs';
+import { SVG_ELEMENT_CEILING_WARNING } from './chunk-NKUYIWAP.mjs';
+import { isGradientColor, createSvgGradientFromColor } from './chunk-O2X6FF45.mjs';
+import { createSvgGroup, createSvgDefs, appendChild, createSvgLinearGradient, svgClass, createSvgPath, createSvgRect, setAttr, svgNode, prependChild } from './chunk-SSLTFJ3U.mjs';
+import { warnChartDevOnce } from './chunk-RQ3CKQOX.mjs';
+
+// src/series/bar/svg/index.ts
+function createSvgPathBuilder() {
+  const parts = [];
+  return {
+    moveTo(x, y) {
+      parts.push(`M ${x} ${y}`);
+    },
+    lineTo(x, y) {
+      parts.push(`L ${x} ${y}`);
+    },
+    arcTo(_cx, _cy, toX, toY, r) {
+      if (r > 0) parts.push(`A ${r} ${r} 0 0 1 ${toX} ${toY}`);
+    },
+    closePath() {
+      parts.push("Z");
+    },
+    toPath() {
+      return parts.join(" ");
+    }
+  };
+}
+function buildRoundedRectPath(x, y, w, h, radius) {
+  const pb = createSvgPathBuilder();
+  traceRoundedRect(pb, x, y, w, h, radius);
+  return pb.toPath();
+}
+function buildPartialBorderPath(x, y, w, h, skipped, radius) {
+  const pb = createSvgPathBuilder();
+  tracePartialBorder(pb, x, y, w, h, skipped, radius);
+  return pb.toPath();
+}
+function renderBarSvg(props, layout, context) {
+  const { bars: barStates, borderJoinStyle, borderAlign } = computeBarRenderStates(props, layout, context.theme);
+  if (barStates.length >= SVG_ELEMENT_CEILING_WARNING) {
+    warnChartDevOnce("bar-svg-ceiling", `SVG bar is rendering ${barStates.length.toLocaleString()} bars. Above ~8k elements, prefer <ChartCanvas> or wrap the dataset in <ChartDecimation> for materially better performance.`);
+  }
+  const shapeFn = props.renderShape;
+  const a11y = context.accessibility;
+  const a11yEnabled = !!(a11y?.enabled && barStates.length <= (a11y.pointDescriptionThreshold ?? 200));
+  const group = createSvgGroup();
+  const defs = createSvgDefs();
+  let hasDefs = false;
+  const gradientDefsCache = /* @__PURE__ */ new Map();
+  for (const state of barStates) {
+    const {
+      bar,
+      effectBorderColor,
+      effectBorderWidth,
+      effectBorderDash,
+      effectBorderDashOffset,
+      userFill,
+      hoverColorOverride,
+      seriesIdx,
+      isHovered,
+      isInactive,
+      opacity,
+      drawX,
+      drawY,
+      drawWidth,
+      drawHeight,
+      clampedRadius,
+      hasRadius,
+      uniformRadius,
+      skippedEdges
+    } = state;
+    const { dataIndex } = bar;
+    const width = drawWidth;
+    const height = drawHeight;
+    let customPath;
+    if (shapeFn) {
+      const shapeInfo = {
+        x: drawX,
+        y: drawY,
+        width,
+        height,
+        value: bar.value,
+        category: bar.category,
+        dataIndex,
+        isNegative: bar.isNegative
+      };
+      customPath = shapeFn(shapeInfo);
+    }
+    let fill;
+    if (userFill && isGradientColor(userFill)) {
+      if (userFill.radialGradient) {
+        const gradientId = `${context.chartId}-bar-${layout.datasetIndex}-grad-${dataIndex}`;
+        const gradient = createSvgGradientFromColor(userFill, gradientId, { x: drawX + width / 2, y: drawY + height / 2 }, Math.max(width, height));
+        appendChild(defs, gradient);
+        hasDefs = true;
+        fill = `url(#${gradientId})`;
+      } else {
+        const cacheKey = userFill.stops.map((s) => `${s.offset}:${s.color}:${s.opacity ?? ""}`).join("|");
+        let gradientId = gradientDefsCache.get(cacheKey);
+        if (!gradientId) {
+          gradientId = `${context.chartId}-bar-${layout.datasetIndex}-grad-shared-${gradientDefsCache.size}`;
+          const gradient = createSvgLinearGradient(gradientId, 0.5, 0, 0.5, 1, userFill.stops);
+          appendChild(defs, gradient);
+          hasDefs = true;
+          gradientDefsCache.set(cacheKey, gradientId);
+        }
+        fill = `url(#${gradientId})`;
+      }
+    } else if (userFill) {
+      fill = userFill;
+    }
+    const { fill: hoverFill, overridden: fillOverridden } = resolveSvgHoverFill(fill, isHovered, hoverColorOverride);
+    fill = hoverFill;
+    const cls = svgClass("p-chart-bar", `p-chart-series-${seriesIdx}`, !fill && `p-chart-color-${seriesIdx % 10}`, isHovered && !fillOverridden && "p-chart-point-hover", isInactive && "p-chart-point-inactive");
+    const cssStroke = fill && effectBorderWidth === 0 ? fill.startsWith("url(") ? context.theme.borderColor : fill : void 0;
+    const baseAttrs = {
+      class: cls,
+      fill: fill ?? context.theme.series[seriesIdx % context.theme.series.length],
+      ...cssStroke && { stroke: cssStroke, "stroke-width": 0 },
+      opacity,
+      "data-index": dataIndex
+    };
+    let fillElement;
+    if (customPath) {
+      fillElement = createSvgPath(customPath, baseAttrs);
+    } else if (!hasRadius) {
+      fillElement = createSvgRect(drawX, drawY, width, height, baseAttrs);
+    } else if (uniformRadius) {
+      fillElement = createSvgRect(drawX, drawY, width, height, { ...baseAttrs, rx: clampedRadius.topLeft });
+    } else {
+      const pathD = buildRoundedRectPath(drawX, drawY, width, height, clampedRadius);
+      fillElement = createSvgPath(pathD, baseAttrs);
+    }
+    if (a11yEnabled) {
+      const desc = formatPointDescription({ category: bar.category, value: bar.value, seriesName: props.name ?? "Series", index: bar.dataIndex }, context.accessibility.pointDescriptionFormatter);
+      setAttr(fillElement, "role", "img");
+      setAttr(fillElement, "aria-label", desc);
+    }
+    appendChild(group, fillElement);
+    if (effectBorderWidth > 0 && effectBorderColor !== "transparent") {
+      const borderCls = svgClass(isHovered && "p-chart-point-hover", isInactive && "p-chart-point-inactive");
+      const strokeAttrs = {
+        fill: "none",
+        stroke: typeof effectBorderColor === "string" ? effectBorderColor : context.theme.borderColor,
+        "stroke-linejoin": borderJoinStyle,
+        // Distinct reconciler key (keyOf falls through to `id`). The border MUST NOT
+        // share the fill's `data-index` key: both elements independently flip tag
+        // (rect <-> path, via hover-scaled `uniformRadius`), and a same-key sibling
+        // whose tag flips fails the reconciler's FIFO tag-guard — letting the border
+        // descriptor consume the stale fill node and patch border attrs onto it.
+        id: `${context.chartId}-bar-${layout.datasetIndex}-border-${dataIndex}`,
+        ...borderCls && { class: borderCls }
+      };
+      if (effectBorderDash && effectBorderDash.length > 0) {
+        strokeAttrs["stroke-dasharray"] = effectBorderDash.join(" ");
+        if (effectBorderDashOffset > 0) {
+          strokeAttrs["stroke-dashoffset"] = effectBorderDashOffset;
+        }
+      }
+      const usePartialBorder = skippedEdges.size > 0 && !customPath;
+      if (borderAlign === "inner") {
+        const clipId = `${context.chartId}-bar-${layout.datasetIndex}-clip-${dataIndex}`;
+        const clipPathNode = svgNode("clipPath", { id: clipId });
+        let clipElement;
+        if (customPath) {
+          clipElement = createSvgPath(customPath, {});
+        } else if (!hasRadius || uniformRadius) {
+          clipElement = createSvgRect(drawX, drawY, width, height, hasRadius ? { rx: clampedRadius.topLeft } : {});
+        } else {
+          const pathD = buildRoundedRectPath(drawX, drawY, width, height, clampedRadius);
+          clipElement = createSvgPath(pathD, {});
+        }
+        appendChild(clipPathNode, clipElement);
+        appendChild(defs, clipPathNode);
+        hasDefs = true;
+        strokeAttrs["stroke-width"] = effectBorderWidth * 2;
+        strokeAttrs["clip-path"] = `url(#${clipId})`;
+      } else {
+        strokeAttrs["stroke-width"] = effectBorderWidth;
+      }
+      let borderElement;
+      if (usePartialBorder) {
+        const pathD = buildPartialBorderPath(drawX, drawY, width, height, skippedEdges, clampedRadius);
+        const lineCap = effectBorderDash && effectBorderDash.length > 0 ? "butt" : "square";
+        borderElement = createSvgPath(pathD, { ...strokeAttrs, "stroke-linecap": lineCap });
+      } else if (customPath) {
+        borderElement = createSvgPath(customPath, strokeAttrs);
+      } else if (!hasRadius || uniformRadius) {
+        borderElement = createSvgRect(drawX, drawY, width, height, {
+          ...hasRadius && { rx: clampedRadius.topLeft },
+          ...strokeAttrs
+        });
+      } else {
+        const pathD = buildRoundedRectPath(drawX, drawY, width, height, clampedRadius);
+        borderElement = createSvgPath(pathD, strokeAttrs);
+      }
+      appendChild(group, borderElement);
+    }
+  }
+  if (hasDefs) {
+    prependChild(group, defs);
+  }
+  return group;
+}
+
+export { renderBarSvg };

package/dist/chunk-SANZPAJ4.mjs

@@ -0,0 +1,14 @@
+// src/animations/heatmap.ts
+function cellKey(cell) {
+  return cell.dataKey != null ? String(cell.dataKey) : `${cell.xLabel}|${cell.yLabel}`;
+}
+function buildHeatmapFingerprint(layouts) {
+  const parts = [];
+  for (const [dsId, layout] of layouts) {
+    const cellParts = layout.cells.filter((c) => !c.isEmpty).map((c) => `${cellKey(c)}:${c.value}`).join(",");
+    parts.push(`${dsId}=${cellParts}`);
+  }
+  return parts.join(";");
+}
+
+export { buildHeatmapFingerprint };