@primeui/chart-core 0.0.1-alpha.1

package/dist/chunk-LVMDQ4OJ.mjs

@@ -0,0 +1,305 @@
+import { clampArcBorderRadius, hasArcBorderRadius } from './chunk-VGLSBZDN.mjs';
+import { toRad, normalizeAngleRelativeTo, xCalc, yCalc } from './chunk-RQ3CKQOX.mjs';
+
+// src/circular/arc/shared.ts
+var CLIP_PIXEL_MARGIN = 1;
+var FULL_CIRCLE_THRESHOLD = 359.9;
+var HALF_PI = Math.PI / 2;
+function isFullCircle(sweepAngle) {
+  return sweepAngle >= FULL_CIRCLE_THRESHOLD;
+}
+function isFullSweepSlice(angleSpan, sweepAngle) {
+  const threshold = sweepAngle * 0.9997;
+  return angleSpan >= threshold;
+}
+function rThetaToXY(r, theta, cx, cy) {
+  return {
+    x: cx + Math.cos(theta) * r,
+    y: cy + Math.sin(theta) * r
+  };
+}
+var ZERO_BORDER_RADIUS = { outerStart: 0, outerEnd: 0, innerStart: 0, innerEnd: 0 };
+function preprocessArcConfig(config, isFullCircleChart) {
+  const { rotation, endAngle, outerRadius, innerRadius, borderRadius } = config;
+  const angleSpan = endAngle - rotation;
+  if (isFullSweepSlice(angleSpan, 360) && isFullCircleChart) {
+    return {
+      type: "fullCircle",
+      startAngleRad: 0,
+      endAngleRad: 0,
+      borderRadius: ZERO_BORDER_RADIUS
+    };
+  }
+  const startAngleRad = toRad(rotation);
+  const endAngleRad = toRad(endAngle);
+  const angleDeltaRad = endAngleRad - startAngleRad;
+  const br = clampArcBorderRadius(borderRadius, innerRadius, outerRadius, angleDeltaRad);
+  return {
+    type: hasArcBorderRadius(br) ? "rounded" : "simple",
+    startAngleRad,
+    endAngleRad,
+    borderRadius: br
+  };
+}
+
+// src/circular/arc/slices.ts
+function computeSlices(data, originalIndices, rotation = -90, sweepAngle = 360) {
+  if (data.length === 0) return [];
+  const total = data.reduce((a, b) => {
+    const safe = isFinite(b) ? Math.max(0, b) : 0;
+    return a + safe;
+  }, 0) || 1;
+  let currentAngle = rotation;
+  return data.map((value, i) => {
+    const safeValue = isFinite(value) ? Math.max(0, value) : 0;
+    const ratio = safeValue / total;
+    const angle = ratio * sweepAngle;
+    const slice = {
+      value,
+      percentage: ratio * 100,
+      rotation: currentAngle,
+      endAngle: currentAngle + angle,
+      valueAngle: currentAngle + angle / 2,
+      originalIndex: originalIndices[i]
+    };
+    currentAngle += angle;
+    return slice;
+  });
+}
+function getSweepCenterAngle(rotation = -90, sweepAngle = 360) {
+  return rotation + sweepAngle / 2;
+}
+function isPointInSlice(x, y, slice, outerRadius, innerRadius = 0) {
+  if (outerRadius <= 0) return false;
+  const distanceSq = x * x + y * y;
+  const innerRadiusSq = innerRadius * innerRadius;
+  const outerRadiusSq = outerRadius * outerRadius;
+  if (distanceSq < innerRadiusSq || distanceSq > outerRadiusSq) {
+    return false;
+  }
+  const pointAngle = Math.atan2(y, x) * (180 / Math.PI);
+  const { rotation, endAngle } = slice;
+  const normalizedAngle = normalizeAngleRelativeTo(pointAngle, rotation);
+  return normalizedAngle >= rotation && normalizedAngle <= endAngle;
+}
+function findSliceAtPoint(x, y, slices, outerRadius, innerRadius = 0) {
+  for (let i = 0; i < slices.length; i++) {
+    if (isPointInSlice(x, y, slices[i], outerRadius, innerRadius)) {
+      return i;
+    }
+  }
+  return -1;
+}
+
+// src/circular/arc/svg.ts
+function buildSvgArcPath(config, isFullCircleChart = true) {
+  const { rotation, endAngle, outerRadius, innerRadius } = config;
+  const prep = preprocessArcConfig(config, isFullCircleChart);
+  switch (prep.type) {
+    case "fullCircle":
+      return buildFullCircleSvgPath(outerRadius, innerRadius);
+    case "simple":
+      return buildSimpleSvgArcPath(rotation, endAngle, outerRadius, innerRadius);
+    case "rounded":
+      return buildRoundedSvgArcPath(prep.startAngleRad, prep.endAngleRad, outerRadius, innerRadius, prep.borderRadius);
+  }
+}
+function buildFullCircleSvgPath(outerRadius, innerRadius) {
+  if (innerRadius > 0) {
+    return `
+            M ${outerRadius} 0
+            A ${outerRadius} ${outerRadius} 0 1 1 ${-outerRadius} 0
+            A ${outerRadius} ${outerRadius} 0 1 1 ${outerRadius} 0
+            M ${innerRadius} 0
+            A ${innerRadius} ${innerRadius} 0 1 0 ${-innerRadius} 0
+            A ${innerRadius} ${innerRadius} 0 1 0 ${innerRadius} 0
+        `;
+  } else {
+    return `
+            M ${outerRadius} 0
+            A ${outerRadius} ${outerRadius} 0 1 1 ${-outerRadius} 0
+            A ${outerRadius} ${outerRadius} 0 1 1 ${outerRadius} 0
+        `;
+  }
+}
+function buildSimpleSvgArcPath(rotation, endAngle, outerRadius, innerRadius) {
+  const angleSpan = endAngle - rotation;
+  const x1 = xCalc(rotation, outerRadius);
+  const y1 = yCalc(rotation, outerRadius);
+  const x2 = xCalc(endAngle, outerRadius);
+  const y2 = yCalc(endAngle, outerRadius);
+  const largeArc = angleSpan > 180 ? 1 : 0;
+  if (innerRadius > 0) {
+    const ix1 = xCalc(rotation, innerRadius);
+    const iy1 = yCalc(rotation, innerRadius);
+    const ix2 = xCalc(endAngle, innerRadius);
+    const iy2 = yCalc(endAngle, innerRadius);
+    return `
+            M ${x1} ${y1}
+            A ${outerRadius} ${outerRadius} 0 ${largeArc} 1 ${x2} ${y2}
+            L ${ix2} ${iy2}
+            A ${innerRadius} ${innerRadius} 0 ${largeArc} 0 ${ix1} ${iy1}
+            Z`;
+  } else {
+    return `
+            M 0 0
+            L ${x1} ${y1}
+            A ${outerRadius} ${outerRadius} 0 ${largeArc} 1 ${x2} ${y2}
+            Z`;
+  }
+}
+function buildRoundedSvgArcPath(startAngle, endAngle, outerRadius, innerRadius, br) {
+  const { outerStart, outerEnd, innerStart, innerEnd } = br;
+  const outerStartAdjR = outerRadius - outerStart;
+  const outerEndAdjR = outerRadius - outerEnd;
+  const outerStartAdjAngle = outerStart > 0 ? startAngle + outerStart / outerStartAdjR : startAngle;
+  const outerEndAdjAngle = outerEnd > 0 ? endAngle - outerEnd / outerEndAdjR : endAngle;
+  const innerStartAdjR = innerRadius + innerStart;
+  const innerEndAdjR = innerRadius + innerEnd;
+  const innerStartAdjAngle = innerStart > 0 ? startAngle + innerStart / innerStartAdjR : startAngle;
+  const innerEndAdjAngle = innerEnd > 0 ? endAngle - innerEnd / innerEndAdjR : endAngle;
+  const outerAngleSpan = outerEndAdjAngle - outerStartAdjAngle;
+  const innerAngleSpan = innerEndAdjAngle - innerStartAdjAngle;
+  const outerLargeArc = outerAngleSpan > Math.PI ? 1 : 0;
+  const innerLargeArc = innerAngleSpan > Math.PI ? 1 : 0;
+  const pathParts = [];
+  if (innerRadius > 0) {
+    const p1 = rThetaToXY(outerStartAdjR, startAngle, 0, 0);
+    pathParts.push(`M ${p1.x} ${p1.y}`);
+    if (outerStart > 0) {
+      const cornerEnd = rThetaToXY(outerRadius, outerStartAdjAngle, 0, 0);
+      pathParts.push(`A ${outerStart} ${outerStart} 0 0 1 ${cornerEnd.x} ${cornerEnd.y}`);
+    }
+    const p2 = rThetaToXY(outerRadius, outerEndAdjAngle, 0, 0);
+    pathParts.push(`A ${outerRadius} ${outerRadius} 0 ${outerLargeArc} 1 ${p2.x} ${p2.y}`);
+    if (outerEnd > 0) {
+      const cornerEnd = rThetaToXY(outerEndAdjR, endAngle, 0, 0);
+      pathParts.push(`A ${outerEnd} ${outerEnd} 0 0 1 ${cornerEnd.x} ${cornerEnd.y}`);
+    }
+    const p3 = rThetaToXY(innerEndAdjR, endAngle, 0, 0);
+    pathParts.push(`L ${p3.x} ${p3.y}`);
+    if (innerEnd > 0) {
+      const cornerEnd = rThetaToXY(innerRadius, innerEndAdjAngle, 0, 0);
+      pathParts.push(`A ${innerEnd} ${innerEnd} 0 0 1 ${cornerEnd.x} ${cornerEnd.y}`);
+    }
+    const p4 = rThetaToXY(innerRadius, innerStartAdjAngle, 0, 0);
+    pathParts.push(`A ${innerRadius} ${innerRadius} 0 ${innerLargeArc} 0 ${p4.x} ${p4.y}`);
+    if (innerStart > 0) {
+      const cornerEnd = rThetaToXY(innerStartAdjR, startAngle, 0, 0);
+      pathParts.push(`A ${innerStart} ${innerStart} 0 0 1 ${cornerEnd.x} ${cornerEnd.y}`);
+    }
+    pathParts.push("Z");
+  } else {
+    pathParts.push("M 0 0");
+    const p1 = rThetaToXY(outerStartAdjR, startAngle, 0, 0);
+    pathParts.push(`L ${p1.x} ${p1.y}`);
+    if (outerStart > 0) {
+      const cornerEnd = rThetaToXY(outerRadius, outerStartAdjAngle, 0, 0);
+      pathParts.push(`A ${outerStart} ${outerStart} 0 0 1 ${cornerEnd.x} ${cornerEnd.y}`);
+    }
+    const p2 = rThetaToXY(outerRadius, outerEndAdjAngle, 0, 0);
+    pathParts.push(`A ${outerRadius} ${outerRadius} 0 ${outerLargeArc} 1 ${p2.x} ${p2.y}`);
+    if (outerEnd > 0) {
+      const cornerEnd = rThetaToXY(outerEndAdjR, endAngle, 0, 0);
+      pathParts.push(`A ${outerEnd} ${outerEnd} 0 0 1 ${cornerEnd.x} ${cornerEnd.y}`);
+    }
+    pathParts.push("Z");
+  }
+  return pathParts.join(" ");
+}
+
+// src/circular/arc/canvas.ts
+function drawCanvasArc(ctx, cx, cy, config, isFullCircleChart = true) {
+  const { outerRadius, innerRadius } = config;
+  const prep = preprocessArcConfig(config, isFullCircleChart);
+  ctx.beginPath();
+  switch (prep.type) {
+    case "fullCircle":
+      drawFullCircleCanvasArc(ctx, cx, cy, outerRadius, innerRadius);
+      break;
+    case "simple":
+      drawSimpleCanvasArc(ctx, cx, cy, prep.startAngleRad, prep.endAngleRad, outerRadius, innerRadius);
+      break;
+    case "rounded":
+      drawRoundedCanvasArc(ctx, cx, cy, prep.startAngleRad, prep.endAngleRad, outerRadius, innerRadius, prep.borderRadius);
+      break;
+  }
+}
+function drawFullCircleCanvasArc(ctx, cx, cy, outerRadius, innerRadius) {
+  outerRadius = Math.max(0, outerRadius);
+  innerRadius = Math.max(0, innerRadius);
+  if (innerRadius > 0) {
+    ctx.arc(cx, cy, outerRadius, 0, Math.PI * 2);
+    ctx.arc(cx, cy, innerRadius, Math.PI * 2, 0, true);
+    ctx.closePath();
+  } else {
+    ctx.arc(cx, cy, outerRadius, 0, Math.PI * 2);
+  }
+}
+function drawSimpleCanvasArc(ctx, cx, cy, startAngle, endAngle, outerRadius, innerRadius) {
+  outerRadius = Math.max(0, outerRadius);
+  innerRadius = Math.max(0, innerRadius);
+  if (innerRadius > 0) {
+    ctx.arc(cx, cy, outerRadius, startAngle, endAngle);
+    ctx.arc(cx, cy, innerRadius, endAngle, startAngle, true);
+    ctx.closePath();
+  } else {
+    ctx.moveTo(cx, cy);
+    ctx.arc(cx, cy, outerRadius, startAngle, endAngle);
+    ctx.closePath();
+  }
+}
+function drawRoundedCanvasArc(ctx, cx, cy, startAngle, endAngle, outerRadius, innerRadius, br) {
+  outerRadius = Math.max(0, outerRadius);
+  innerRadius = Math.max(0, innerRadius);
+  const { outerStart, outerEnd, innerStart, innerEnd } = br;
+  const outerStartAdjR = outerRadius - outerStart;
+  const outerEndAdjR = outerRadius - outerEnd;
+  const outerStartAdjAngle = outerStart > 0 ? startAngle + outerStart / outerStartAdjR : startAngle;
+  const outerEndAdjAngle = outerEnd > 0 ? endAngle - outerEnd / outerEndAdjR : endAngle;
+  const innerStartAdjR = innerRadius + innerStart;
+  const innerEndAdjR = innerRadius + innerEnd;
+  const innerStartAdjAngle = innerStart > 0 ? startAngle + innerStart / innerStartAdjR : startAngle;
+  const innerEndAdjAngle = innerEnd > 0 ? endAngle - innerEnd / innerEndAdjR : endAngle;
+  if (innerRadius > 0) {
+    const p1 = rThetaToXY(outerStartAdjR, startAngle, cx, cy);
+    ctx.moveTo(p1.x, p1.y);
+    if (outerStart > 0) {
+      const cornerCenter = rThetaToXY(outerStartAdjR, outerStartAdjAngle, cx, cy);
+      ctx.arc(cornerCenter.x, cornerCenter.y, outerStart, startAngle - HALF_PI, outerStartAdjAngle);
+    }
+    ctx.arc(cx, cy, outerRadius, outerStartAdjAngle, outerEndAdjAngle);
+    if (outerEnd > 0) {
+      const cornerCenter = rThetaToXY(outerEndAdjR, outerEndAdjAngle, cx, cy);
+      ctx.arc(cornerCenter.x, cornerCenter.y, outerEnd, outerEndAdjAngle, endAngle + HALF_PI);
+    }
+    const p3 = rThetaToXY(innerEndAdjR, endAngle, cx, cy);
+    ctx.lineTo(p3.x, p3.y);
+    if (innerEnd > 0) {
+      const cornerCenter = rThetaToXY(innerEndAdjR, innerEndAdjAngle, cx, cy);
+      ctx.arc(cornerCenter.x, cornerCenter.y, innerEnd, endAngle + HALF_PI, innerEndAdjAngle + Math.PI);
+    }
+    ctx.arc(cx, cy, innerRadius, innerEndAdjAngle, innerStartAdjAngle, true);
+    if (innerStart > 0) {
+      const cornerCenter = rThetaToXY(innerStartAdjR, innerStartAdjAngle, cx, cy);
+      ctx.arc(cornerCenter.x, cornerCenter.y, innerStart, innerStartAdjAngle + Math.PI, startAngle - HALF_PI);
+    }
+    ctx.closePath();
+  } else {
+    ctx.moveTo(cx, cy);
+    const p1 = rThetaToXY(outerStartAdjR, startAngle, cx, cy);
+    ctx.lineTo(p1.x, p1.y);
+    if (outerStart > 0) {
+      const cornerCenter = rThetaToXY(outerStartAdjR, outerStartAdjAngle, cx, cy);
+      ctx.arc(cornerCenter.x, cornerCenter.y, outerStart, startAngle - HALF_PI, outerStartAdjAngle);
+    }
+    ctx.arc(cx, cy, outerRadius, outerStartAdjAngle, outerEndAdjAngle);
+    if (outerEnd > 0) {
+      const cornerCenter = rThetaToXY(outerEndAdjR, outerEndAdjAngle, cx, cy);
+      ctx.arc(cornerCenter.x, cornerCenter.y, outerEnd, outerEndAdjAngle, endAngle + HALF_PI);
+    }
+    ctx.closePath();
+  }
+}
+
+export { CLIP_PIXEL_MARGIN, FULL_CIRCLE_THRESHOLD, HALF_PI, buildSvgArcPath, computeSlices, drawCanvasArc, findSliceAtPoint, getSweepCenterAngle, isFullCircle, isFullSweepSlice, isPointInSlice, preprocessArcConfig, rThetaToXY };

package/dist/chunk-M7B3JF43.mjs

@@ -0,0 +1,90 @@
+import { hitTestCandlestick } from './chunk-3OZLP4I4.mjs';
+import { formatTimeLabel, formatHitValue, formatCursorValue } from './chunk-DP2IZNN3.mjs';
+
+// src/cartesian/hittest-wrappers/candlestick.ts
+function candlestickHitTest(x, y, ctx) {
+  const { layouts, layoutData } = ctx;
+  for (const [datasetId, csLayout] of layouts) {
+    const hitIndex = hitTestCandlestick(x, y, csLayout);
+    if (hitIndex !== null) {
+      const candle = csLayout.candles[hitIndex];
+      if (!candle) continue;
+      return {
+        datasetId,
+        index: hitIndex,
+        label: formatTimeLabel(candle.label, layoutData),
+        open: candle.open,
+        high: candle.high,
+        low: candle.low,
+        close: candle.close,
+        x: candle.x,
+        y: candle.bodyTop,
+        color: candle.bodyStroke
+      };
+    }
+  }
+  return null;
+}
+function candlestickFindAllNearest(x, y, ctx) {
+  const { layouts, renderPropsCache, layoutData } = 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;
+  let nearestCatIdx = -1;
+  let minCatDist = Infinity;
+  for (const layout of layouts.values()) {
+    for (const candle of layout.visibleCandles) {
+      const dist = Math.abs(x - candle.x);
+      if (dist < minCatDist) {
+        minCatDist = dist;
+        nearestCatIdx = candle.dataIndex;
+      }
+    }
+  }
+  if (nearestCatIdx === -1) return null;
+  let primaryHit = null;
+  let bestDist = Infinity;
+  const allSeries = [];
+  for (const [datasetId, layout] of layouts) {
+    const candle = layout.visibleCandles.find((c) => c.dataIndex === nearestCatIdx);
+    if (!candle) continue;
+    const props = renderPropsCache.get(datasetId);
+    const color = candle.bodyStroke;
+    const ohlc = { open: candle.open, high: candle.high, low: candle.low, close: candle.close };
+    const label = formatTimeLabel(candle.label, layoutData);
+    const formattedValue = props ? formatHitValue(candle.close, props, "vertical", layoutData) : String(candle.close);
+    const cursorFormattedValue = props ? formatCursorValue(x, y, props, "vertical", layoutData) : formattedValue;
+    allSeries.push({
+      datasetId,
+      name: props?.name,
+      label,
+      color,
+      value: candle.close,
+      formattedValue,
+      cursorFormattedValue,
+      snapPixel: candle.closeY,
+      ohlc
+    });
+    const dist = Math.abs(x - candle.x);
+    if (dist < bestDist) {
+      bestDist = dist;
+      primaryHit = {
+        datasetId,
+        index: nearestCatIdx,
+        label,
+        value: candle.close,
+        color,
+        snapX: candle.x,
+        snapY: candle.closeY,
+        formattedValue,
+        cursorFormattedValue,
+        ohlc
+      };
+    }
+  }
+  if (!primaryHit) return null;
+  return { primary: primaryHit, allSeries };
+}
+
+export { candlestickFindAllNearest, candlestickHitTest };

package/dist/chunk-MTGMXRNF.mjs

@@ -0,0 +1,136 @@
+import { getHeatmapLabelInfo, resolveLabelMidToAlpha } from './chunk-3Z62EUJN.mjs';
+import { renderAxisSvg } from './chunk-ZTL2FQEW.mjs';
+import { SVG_ELEMENT_CEILING_WARNING, resolveFontFamily, DEFAULT_HOVER_DIM_OPACITY, DEFAULT_HOVER_BRIGHTNESS } from './chunk-NKUYIWAP.mjs';
+import { getContrastColor } from './chunk-QS76E3TD.mjs';
+import { resolveAccessor, makeItemContext, resolveDash } from './chunk-O2X6FF45.mjs';
+import { createSvgGroup, adjustBrightness, createSvgRect, setAttr, appendChild, createSvgText, materializeSvgGroup } from './chunk-SSLTFJ3U.mjs';
+import { warnChartDevOnce } from './chunk-RQ3CKQOX.mjs';
+
+// src/series/heatmap/svg/index.ts
+function makeCellExtras(props, cell) {
+  return { value: cell.value, category: cell.xLabel, seriesIndex: props.order ?? 0, seriesId: props.id ?? "" };
+}
+function renderHeatmapSvg(props, layout, context) {
+  const group = createSvgGroup();
+  const { cells } = layout;
+  if (cells.length >= SVG_ELEMENT_CEILING_WARNING) {
+    warnChartDevOnce("heatmap-svg-ceiling", `SVG heatmap is rendering ${cells.length.toLocaleString()} cells. Above ~8k elements, prefer <ChartCanvas> for materially better performance.`);
+  }
+  const fontFamily = resolveFontFamily(void 0, context.font);
+  const a11y = context.accessibility;
+  const a11yEnabled = !!(a11y?.enabled && cells.length <= (a11y.pointDescriptionThreshold ?? 200));
+  const borderRadius = props.borderRadius ?? 0;
+  const borderJoinStyle = props.borderJoinStyle;
+  const borderAlign = props.borderAlign ?? "center";
+  const hoveredIndex = props.interaction?.hoveredIndex ?? null;
+  const dimOpacity = props.effects?.dimOpacity ?? context.theme.dimOpacity ?? DEFAULT_HOVER_DIM_OPACITY;
+  const hoverBrightness = props.effects?.hoverBrightness ?? context.theme.hoverBrightness ?? DEFAULT_HOVER_BRIGHTNESS;
+  const hoverEnabled = props.effects !== void 0;
+  const anyHover = hoverEnabled && hoveredIndex !== null;
+  const showLabels = props.showLabels === true;
+  const dataArr = props.data;
+  const labelMidToAlpha = /* @__PURE__ */ new Map();
+  const resolveLabelColor = (cell) => {
+    const v = resolveAccessor(props.labelColor, makeItemContext(dataArr?.[cell.index], cell.index, makeCellExtras(props, cell)));
+    return typeof v === "string" ? v : void 0;
+  };
+  const resolveCellBorderDash = (cell) => resolveDash(props.borderDash, makeItemContext(dataArr?.[cell.index], cell.index, makeCellExtras(props, cell)));
+  const resolveCellBorderDashOffset = (cell) => resolveAccessor(props.borderDashOffset, makeItemContext(dataArr?.[cell.index], cell.index, makeCellExtras(props, cell)), { arrayMode: "clip" });
+  const resolveCellOpacity = (cell) => resolveAccessor(props.opacity, makeItemContext(dataArr?.[cell.index], cell.index, makeCellExtras(props, cell)), { arrayMode: "clip" });
+  const resolveCellBorderColor = (cell) => resolveAccessor(props.borderColor, makeItemContext(dataArr?.[cell.index], cell.index, makeCellExtras(props, cell)));
+  const resolveCellBorderWidth = (cell) => resolveAccessor(props.borderStrokeWidth, makeItemContext(dataArr?.[cell.index], cell.index, makeCellExtras(props, cell)), { arrayMode: "clip" });
+  const resolveCellHoverColor = (cell) => resolveAccessor(props.hoverColor, makeItemContext(dataArr?.[cell.index], cell.index, makeCellExtras(props, cell)), { arrayMode: "cycle" });
+  const resolveCellHoverBorderColor = (cell) => resolveAccessor(props.hoverBorderColor, makeItemContext(dataArr?.[cell.index], cell.index, makeCellExtras(props, cell)), { arrayMode: "cycle" });
+  for (const cell of cells) {
+    if (cell.width <= 0 || cell.height <= 0) continue;
+    const isHovered = hoverEnabled && cell.index === hoveredIndex;
+    const hoverOpacity = anyHover && !isHovered ? dimOpacity : 1;
+    const userCellOpacity = resolveCellOpacity(cell);
+    const cellOpacity = (cell.opacity ?? 1) * hoverOpacity * (userCellOpacity ?? 1);
+    const hoverFill = isHovered ? resolveCellHoverColor(cell) : void 0;
+    const hoverBorder = isHovered ? resolveCellHoverBorderColor(cell) : void 0;
+    const cellBorderColor = hoverBorder ?? resolveCellBorderColor(cell);
+    const cellBorderWidth = resolveCellBorderWidth(cell);
+    const effectiveBW = cellBorderColor ? cellBorderWidth ?? 1 : cell.isEmpty ? 0.5 : 0;
+    const inset = cellBorderColor && borderAlign === "inner" && effectiveBW > 0 ? effectiveBW / 2 : 0;
+    const baseFill = isHovered && hoverBrightness ? adjustBrightness(cell.color, hoverBrightness) : cell.color;
+    const fillStr = hoverFill !== void 0 ? typeof hoverFill === "string" ? hoverFill : String(hoverFill) : baseFill;
+    const attrs = { fill: fillStr };
+    if (borderRadius > 0) {
+      attrs.rx = borderRadius;
+      attrs.ry = borderRadius;
+    }
+    if (cellBorderColor) {
+      const cellBorderDash = resolveCellBorderDash(cell);
+      const cellBorderDashOffset = resolveCellBorderDashOffset(cell);
+      attrs.stroke = typeof cellBorderColor === "string" ? cellBorderColor : String(cellBorderColor);
+      attrs["stroke-width"] = effectiveBW;
+      if (cellBorderDash && cellBorderDash.length > 0) attrs["stroke-dasharray"] = cellBorderDash.join(",");
+      if (cellBorderDashOffset) attrs["stroke-dashoffset"] = cellBorderDashOffset;
+      if (borderJoinStyle) attrs["stroke-linejoin"] = borderJoinStyle;
+    }
+    if (cellOpacity < 1) attrs.opacity = cellOpacity;
+    if (cell.isEmpty && !cellBorderColor) {
+      attrs.stroke = context.theme.heatEmpty;
+      attrs["stroke-width"] = 0.5;
+      attrs["stroke-dasharray"] = "2,2";
+    }
+    const centreX = Math.round(cell.x + cell.width / 2);
+    const centreY = Math.round(cell.y + cell.height / 2);
+    const halfW = Math.round(cell.width / 2 - inset);
+    const halfH = Math.round(cell.height / 2 - inset);
+    const left = centreX - halfW;
+    const top = centreY - halfH;
+    const cw = Math.max(0, halfW * 2);
+    const ch = Math.max(0, halfH * 2);
+    const cellEl = createSvgRect(left, top, cw, ch, attrs);
+    if (a11yEnabled && !cell.isEmpty) {
+      setAttr(cellEl, "role", "img");
+      setAttr(cellEl, "aria-label", `${cell.xLabel}, ${cell.yLabel}: ${cell.value}`);
+    }
+    setAttr(cellEl, "data-index", `${cell.row}-${cell.col}`);
+    appendChild(group, cellEl);
+    if (showLabels && !cell.isEmpty) {
+      const info = getHeatmapLabelInfo(cell);
+      if (info.show) {
+        const cx = Math.round(cell.x + cell.width / 2);
+        const cy = cell.y + cell.height / 2;
+        const textColor = resolveLabelColor(cell) ?? getContrastColor(cell.color);
+        const midToAlpha = resolveLabelMidToAlpha(labelMidToAlpha, info.fontSize, fontFamily);
+        const finalY = Math.round(cy + midToAlpha);
+        appendChild(
+          group,
+          createSvgText(cx, finalY, cell.label, {
+            fill: textColor,
+            "font-size": info.fontSize,
+            "font-weight": 600,
+            "font-family": fontFamily,
+            "text-anchor": "middle",
+            "dominant-baseline": "auto",
+            "pointer-events": "none"
+          })
+        );
+      }
+    }
+  }
+  return group;
+}
+function renderHeatmapAxesSvg(gridGroup, axisGroup, axisLayouts, theme) {
+  if (gridGroup) {
+    while (gridGroup.firstChild) gridGroup.removeChild(gridGroup.firstChild);
+    for (const [, axisInfo] of axisLayouts) {
+      if (axisInfo.layout.gridLines.length > 0) {
+        gridGroup.appendChild(materializeSvgGroup(renderAxisSvg(axisInfo.layout, theme, { gridOnly: true })));
+      }
+    }
+  }
+  if (axisGroup) {
+    while (axisGroup.firstChild) axisGroup.removeChild(axisGroup.firstChild);
+    for (const [, axisInfo] of axisLayouts) {
+      const axisProps = axisInfo.props;
+      axisGroup.appendChild(materializeSvgGroup(renderAxisSvg(axisInfo.layout, theme, { skipGrid: true, skipAxisLine: axisProps.showLine === false, skipTicks: axisProps.showTicks === false })));
+    }
+  }
+}
+
+export { renderHeatmapAxesSvg, renderHeatmapSvg };