@primeui/chart-core 0.0.1-alpha.1

package/dist/chunk-SSLTFJ3U.mjs

@@ -0,0 +1,364 @@
+// src/utils/color/parse.ts
+function parseHexColor(hex) {
+  let h = hex.replace("#", "");
+  if (h.length === 3) {
+    h = h[0] + h[0] + h[1] + h[1] + h[2] + h[2];
+  }
+  const r = parseInt(h.substring(0, 2), 16);
+  const g = parseInt(h.substring(2, 4), 16);
+  const b = parseInt(h.substring(4, 6), 16);
+  return [r, g, b];
+}
+var COLOR_CACHE_MAX_SIZE = 256;
+var colorCache = /* @__PURE__ */ new Map();
+var parsingCanvas = null;
+var parsingContext = null;
+function getParsingContext() {
+  if (typeof document === "undefined") return null;
+  if (!parsingCanvas) {
+    parsingCanvas = document.createElement("canvas");
+    parsingCanvas.width = 1;
+    parsingCanvas.height = 1;
+    parsingContext = parsingCanvas.getContext("2d", { willReadFrequently: true });
+  }
+  return parsingContext;
+}
+var browserColorParser = {
+  parse(color) {
+    const ctx = getParsingContext();
+    if (!ctx) return null;
+    ctx.clearRect(0, 0, 1, 1);
+    ctx.fillStyle = color;
+    ctx.fillRect(0, 0, 1, 1);
+    const data = ctx.getImageData(0, 0, 1, 1).data;
+    return { r: data[0], g: data[1], b: data[2] };
+  }
+};
+var activeColorParser = browserColorParser;
+function setColorParser(parser) {
+  activeColorParser = parser ?? browserColorParser;
+}
+function parseColorToRGB(color) {
+  const cached = colorCache.get(color);
+  if (cached) {
+    colorCache.delete(color);
+    colorCache.set(color, cached);
+    return cached;
+  }
+  const result = activeColorParser.parse(color);
+  if (!result) return null;
+  if (colorCache.size >= COLOR_CACHE_MAX_SIZE) {
+    const firstKey = colorCache.keys().next().value;
+    if (firstKey !== void 0) colorCache.delete(firstKey);
+  }
+  colorCache.set(color, result);
+  return result;
+}
+function parseColorToRGBA(color) {
+  if (!color || typeof color !== "string") return null;
+  const trimmed = color.trim().toLowerCase();
+  if (trimmed === "transparent") {
+    return { r: 0, g: 0, b: 0, a: 0 };
+  }
+  if (trimmed.startsWith("#")) {
+    const hex = trimmed.slice(1);
+    if (!/^[0-9a-f]+$/.test(hex)) return null;
+    if (hex.length === 3) {
+      return {
+        r: parseInt(hex[0] + hex[0], 16),
+        g: parseInt(hex[1] + hex[1], 16),
+        b: parseInt(hex[2] + hex[2], 16),
+        a: 1
+      };
+    }
+    if (hex.length === 4) {
+      return {
+        r: parseInt(hex[0] + hex[0], 16),
+        g: parseInt(hex[1] + hex[1], 16),
+        b: parseInt(hex[2] + hex[2], 16),
+        a: parseInt(hex[3] + hex[3], 16) / 255
+      };
+    }
+    if (hex.length === 6) {
+      return {
+        r: parseInt(hex.slice(0, 2), 16),
+        g: parseInt(hex.slice(2, 4), 16),
+        b: parseInt(hex.slice(4, 6), 16),
+        a: 1
+      };
+    }
+    if (hex.length === 8) {
+      return {
+        r: parseInt(hex.slice(0, 2), 16),
+        g: parseInt(hex.slice(2, 4), 16),
+        b: parseInt(hex.slice(4, 6), 16),
+        a: parseInt(hex.slice(6, 8), 16) / 255
+      };
+    }
+    return null;
+  }
+  const rgbMatch = trimmed.match(/^rgba?\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*(?:,\s*([\d.]+)\s*)?\)$/);
+  if (rgbMatch) {
+    return {
+      r: Math.min(255, parseInt(rgbMatch[1], 10)),
+      g: Math.min(255, parseInt(rgbMatch[2], 10)),
+      b: Math.min(255, parseInt(rgbMatch[3], 10)),
+      a: rgbMatch[4] !== void 0 ? parseFloat(rgbMatch[4]) : 1
+    };
+  }
+  const hslMatch = trimmed.match(/^hsla?\(\s*(\d+)\s*,\s*([\d.]+)%\s*,\s*([\d.]+)%\s*(?:,\s*([\d.]+)\s*)?\)$/);
+  if (hslMatch) {
+    const h = parseInt(hslMatch[1], 10) / 360;
+    const s = parseFloat(hslMatch[2]) / 100;
+    const l = parseFloat(hslMatch[3]) / 100;
+    const a = hslMatch[4] !== void 0 ? parseFloat(hslMatch[4]) : 1;
+    const { r, g, b } = hslToRgb(h, s, l);
+    return { r, g, b, a };
+  }
+  return null;
+}
+function hslToRgb(h, s, l) {
+  if (s === 0) {
+    const v = Math.round(l * 255);
+    return { r: v, g: v, b: v };
+  }
+  const hueToRgb = (p2, q2, t) => {
+    if (t < 0) t += 1;
+    if (t > 1) t -= 1;
+    if (t < 1 / 6) return p2 + (q2 - p2) * 6 * t;
+    if (t < 1 / 2) return q2;
+    if (t < 2 / 3) return p2 + (q2 - p2) * (2 / 3 - t) * 6;
+    return p2;
+  };
+  const q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+  const p = 2 * l - q;
+  return {
+    r: Math.round(hueToRgb(p, q, h + 1 / 3) * 255),
+    g: Math.round(hueToRgb(p, q, h) * 255),
+    b: Math.round(hueToRgb(p, q, h - 1 / 3) * 255)
+  };
+}
+
+// src/utils/color/adjust.ts
+function adjustBrightness(color, factor) {
+  if (color.startsWith("#")) {
+    const [r, g, b] = parseHexColor(color);
+    const adjust = (c) => Math.min(255, Math.max(0, Math.round(c * factor)));
+    return `#${adjust(r).toString(16).padStart(2, "0")}${adjust(g).toString(16).padStart(2, "0")}${adjust(b).toString(16).padStart(2, "0")}`;
+  }
+  const rgbMatch = color.match(/rgba?\s*\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*(?:,\s*([\d.]+))?\s*\)/);
+  if (rgbMatch) {
+    const r = Math.min(255, Math.max(0, Math.round(parseInt(rgbMatch[1]) * factor)));
+    const g = Math.min(255, Math.max(0, Math.round(parseInt(rgbMatch[2]) * factor)));
+    const b = Math.min(255, Math.max(0, Math.round(parseInt(rgbMatch[3]) * factor)));
+    const a = rgbMatch[4];
+    return a ? `rgba(${r}, ${g}, ${b}, ${a})` : `rgb(${r}, ${g}, ${b})`;
+  }
+  return color;
+}
+function brightenGradientStops(gradient, factor) {
+  return {
+    ...gradient,
+    stops: gradient.stops.map((stop) => ({ ...stop, color: adjustBrightness(stop.color, factor) }))
+  };
+}
+function hexToRgba(hex, opacity) {
+  const [r, g, b] = parseHexColor(hex);
+  return `rgba(${r}, ${g}, ${b}, ${opacity})`;
+}
+function hexToRgbString(hex) {
+  const [r, g, b] = parseHexColor(hex);
+  return `${r},${g},${b}`;
+}
+
+// src/utils/render/canvas.utils.ts
+function withCanvasState(ctx, fn) {
+  ctx.save();
+  try {
+    return fn();
+  } finally {
+    ctx.restore();
+  }
+}
+function readCssNumber(el, varName, fallback) {
+  if (!el || typeof window === "undefined") return fallback;
+  const raw = getComputedStyle(el).getPropertyValue(varName).trim();
+  if (!raw) return fallback;
+  const parsed = parseFloat(raw);
+  return Number.isFinite(parsed) ? parsed : fallback;
+}
+function getDevicePixelRatio() {
+  return Math.min(Math.ceil(globalThis.devicePixelRatio || 1), 3);
+}
+function configureCanvasHiDPI(canvas, width, height, overrideDpr) {
+  const dpr = overrideDpr ?? getDevicePixelRatio();
+  const scaledWidth = Math.round(width * dpr);
+  const scaledHeight = Math.round(height * dpr);
+  if (canvas.width !== scaledWidth || canvas.height !== scaledHeight) {
+    canvas.width = scaledWidth;
+    canvas.height = scaledHeight;
+  }
+  canvas.style.width = Math.round(width) + "px";
+  canvas.style.height = Math.round(height) + "px";
+  const ctx = canvas.getContext("2d");
+  if (ctx) {
+    ctx.setTransform(dpr, 0, 0, dpr, 0, 0);
+  }
+  return dpr;
+}
+function createCanvasLinearGradient(ctx, x1, y1, x2, y2, stops) {
+  const gradient = ctx.createLinearGradient(x1, y1, x2, y2);
+  for (const stop of stops) {
+    let color = stop.color;
+    if (stop.opacity !== void 0 && color.startsWith("#")) {
+      color = hexToRgba(color, stop.opacity);
+    }
+    gradient.addColorStop(stop.offset, color);
+  }
+  return gradient;
+}
+function createCanvasRadialGradient(ctx, cx, cy, innerRadius, outerRadius, stops) {
+  const gradient = ctx.createRadialGradient(cx, cy, innerRadius, cx, cy, outerRadius);
+  for (const stop of stops) {
+    let color = stop.color;
+    if (stop.opacity !== void 0 && color.startsWith("#")) {
+      color = hexToRgba(color, stop.opacity);
+    }
+    gradient.addColorStop(stop.offset, color);
+  }
+  return gradient;
+}
+
+// src/utils/render/svg.utils.ts
+function svgNode(tag, attributes, children) {
+  const attrs = {};
+  if (attributes) {
+    for (const k in attributes) {
+      const v = attributes[k];
+      if (v !== void 0) attrs[k] = String(v);
+    }
+  }
+  return { tag, attributes: attrs, children: children ? [...children] : [] };
+}
+function setAttr(node, key, value) {
+  node.attributes[key] = String(value);
+  return node;
+}
+function appendChild(parent, ...children) {
+  parent.children.push(...children);
+  return parent;
+}
+function prependChild(parent, child) {
+  parent.children.unshift(child);
+  return parent;
+}
+function addClass(node, cls) {
+  const existing = node.attributes["class"];
+  node.attributes["class"] = existing ? `${existing} ${cls}` : cls;
+  return node;
+}
+function svgClass(...parts) {
+  return parts.filter(Boolean).join(" ");
+}
+function createSvgGroup(transform, attributes) {
+  return svgNode("g", { ...attributes, ...transform ? { transform } : {} });
+}
+function createSvgPath(d, attributes) {
+  return svgNode("path", { d, ...attributes });
+}
+function createSvgText(x, y, content, attributes) {
+  const node = svgNode("text", { x, y, ...attributes });
+  if (content) node.children.push(content);
+  return node;
+}
+function createSvgRect(x, y, width, height, attributes) {
+  return svgNode("rect", {
+    x,
+    y,
+    width: Math.max(0, width),
+    height: Math.max(0, height),
+    ...attributes
+  });
+}
+function createSvgCircle(cx, cy, r, attributes) {
+  return svgNode("circle", { cx, cy, r, ...attributes });
+}
+function createSvgLine(x1, y1, x2, y2, attributes) {
+  return svgNode("line", { x1, y1, x2, y2, ...attributes });
+}
+function createSvgDefs() {
+  return svgNode("defs");
+}
+function createSvgLinearGradient(id, x1, y1, x2, y2, stops, options) {
+  const useAbsolute = options?.useAbsoluteCoords ?? false;
+  const gradient = svgNode("linearGradient", {
+    id,
+    x1: useAbsolute ? x1 : `${x1 * 100}%`,
+    y1: useAbsolute ? y1 : `${y1 * 100}%`,
+    x2: useAbsolute ? x2 : `${x2 * 100}%`,
+    y2: useAbsolute ? y2 : `${y2 * 100}%`,
+    ...useAbsolute && { gradientUnits: "userSpaceOnUse" }
+  });
+  for (const { offset, color, opacity } of stops) {
+    gradient.children.push(
+      svgNode("stop", {
+        offset: `${offset * 100}%`,
+        "stop-color": color,
+        ...opacity !== void 0 && { "stop-opacity": opacity }
+      })
+    );
+  }
+  return gradient;
+}
+function createSvgRadialGradient(id, cx, cy, r, stops, options) {
+  const useAbsolute = options?.useAbsoluteCoords ?? false;
+  const gradient = svgNode("radialGradient", {
+    id,
+    cx: useAbsolute ? cx : `${cx * 100}%`,
+    cy: useAbsolute ? cy : `${cy * 100}%`,
+    r: useAbsolute ? r : `${r * 100}%`,
+    ...useAbsolute && { gradientUnits: "userSpaceOnUse" }
+  });
+  for (const { offset, color, opacity } of stops) {
+    gradient.children.push(
+      svgNode("stop", {
+        offset: `${offset * 100}%`,
+        "stop-color": color,
+        ...opacity !== void 0 && { "stop-opacity": opacity }
+      })
+    );
+  }
+  return gradient;
+}
+var SVG_NS = "http://www.w3.org/2000/svg";
+var browserSvgElementFactory = {
+  createElement(tag) {
+    return document.createElementNS(SVG_NS, tag);
+  }
+};
+var activeSvgElementFactory = browserSvgElementFactory;
+function setSvgElementFactory(factory) {
+  activeSvgElementFactory = factory ?? browserSvgElementFactory;
+}
+function createSvgElement(tag) {
+  return activeSvgElementFactory.createElement(tag);
+}
+function materializeSvgNode(node) {
+  const el = activeSvgElementFactory.createElement(node.tag);
+  for (const key in node.attributes) {
+    el.setAttribute(key, node.attributes[key]);
+  }
+  for (const child of node.children) {
+    if (typeof child === "string") {
+      el.textContent = child;
+    } else {
+      el.appendChild(materializeSvgNode(child));
+    }
+  }
+  return el;
+}
+function materializeSvgGroup(node) {
+  return materializeSvgNode(node);
+}
+
+export { addClass, adjustBrightness, appendChild, brightenGradientStops, configureCanvasHiDPI, createCanvasLinearGradient, createCanvasRadialGradient, createSvgCircle, createSvgDefs, createSvgElement, createSvgGroup, createSvgLine, createSvgLinearGradient, createSvgPath, createSvgRadialGradient, createSvgRect, createSvgText, getDevicePixelRatio, hexToRgbString, hexToRgba, materializeSvgGroup, materializeSvgNode, parseColorToRGB, parseColorToRGBA, parseHexColor, prependChild, readCssNumber, setAttr, setColorParser, setSvgElementFactory, svgClass, svgNode, withCanvasState };

package/dist/chunk-SXHVDJGF.mjs

@@ -0,0 +1,77 @@
+import { buildSvgArcPath } from './chunk-LVMDQ4OJ.mjs';
+import { formatPointDescription } from './chunk-OGJ6IIBW.mjs';
+import { createSvgGradientFromColor } from './chunk-O2X6FF45.mjs';
+import { createSvgGroup, createSvgDefs, appendChild, prependChild, setAttr, adjustBrightness, svgClass, createSvgPath } from './chunk-SSLTFJ3U.mjs';
+
+// src/series/polar/svg/index.ts
+function renderPolarBarsSvg(layout, hoverState, effectConfig, theme, a11y) {
+  const group = createSvgGroup(`translate(${layout.center.x}, ${layout.center.y})`);
+  if (layout.gradientColors.size > 0) {
+    const defs = createSvgDefs();
+    for (const [dsId, gradColor] of layout.gradientColors) {
+      const gradId = `polar-grad-${layout.datasetIndex}-${dsId}`;
+      const gradNode = createSvgGradientFromColor(gradColor, gradId, { x: 0, y: 0 }, layout.maxRadius);
+      appendChild(defs, gradNode);
+    }
+    prependChild(group, defs);
+  }
+  if (a11y?.enabled) {
+    setAttr(group, "role", "region");
+    setAttr(group, "aria-label", "Polar chart data");
+  }
+  const sharedAxisIdx = hoverState.axisIndex ?? null;
+  const anyHover = hoverState.datasetId !== null || sharedAxisIdx !== null;
+  const a11yEnabled = !!(a11y?.enabled && layout.bars.length <= (a11y.pointDescriptionThreshold ?? 200));
+  for (const bar of layout.bars) {
+    if (bar.outerRadius <= bar.innerRadius) continue;
+    const isSeriesHover = sharedAxisIdx === null && hoverState.datasetId !== null && hoverState.index == null;
+    const isHovered = sharedAxisIdx !== null ? bar.categoryIndex === sharedAxisIdx : isSeriesHover ? hoverState.datasetId === bar.datasetId : hoverState.datasetId === bar.datasetId && hoverState.index === bar.categoryIndex;
+    const isInactive = anyHover && !isHovered;
+    const gradColor = layout.gradientColors.get(bar.datasetId);
+    let fillColor = gradColor ? `url(#polar-grad-${layout.datasetIndex}-${bar.datasetId})` : bar.color;
+    let opacity = bar.opacity ?? 1;
+    if (anyHover) {
+      if (isHovered && bar.hoverColor !== void 0) {
+        fillColor = bar.hoverColor;
+      } else if (isHovered && effectConfig.hoverBrightness && !gradColor && bar.color !== void 0) {
+        fillColor = adjustBrightness(bar.color, effectConfig.hoverBrightness);
+      } else if (!isHovered && effectConfig.dimOpacity !== void 0) {
+        opacity = opacity * effectConfig.dimOpacity;
+      }
+    }
+    const pathD = buildSvgArcPath(
+      {
+        rotation: bar.startAngle,
+        endAngle: bar.endAngle,
+        outerRadius: bar.outerRadius,
+        innerRadius: bar.innerRadius,
+        borderRadius: bar.borderRadius
+      },
+      false
+    );
+    const barCls = svgClass("p-chart-arc", `p-chart-series-${bar.seriesIdx}`, fillColor === void 0 && `p-chart-color-${bar.seriesIdx % 10}`, isHovered && "p-chart-point-hover", isInactive && "p-chart-point-inactive");
+    const attrs = {
+      fill: fillColor ?? theme.series[bar.seriesIdx % theme.series.length],
+      stroke: (isHovered ? bar.hoverBorderColor : void 0) ?? bar.borderColor ?? "none",
+      "stroke-width": bar.borderStrokeWidth ?? 0,
+      class: barCls
+    };
+    if (bar.borderDash && bar.borderDash.length > 0) attrs["stroke-dasharray"] = bar.borderDash.join(",");
+    if (bar.borderDashOffset) attrs["stroke-dashoffset"] = bar.borderDashOffset;
+    if (opacity < 1) {
+      attrs.opacity = opacity;
+    }
+    const barEl = createSvgPath(pathD, attrs);
+    setAttr(barEl, "data-index", `${bar.datasetId}:${bar.categoryIndex}`);
+    if (a11yEnabled) {
+      const category = layout.categories[bar.categoryIndex] ?? `Category ${bar.categoryIndex + 1}`;
+      const desc = formatPointDescription({ category, value: bar.value, seriesName: bar.datasetId, index: bar.categoryIndex }, a11y.pointDescriptionFormatter);
+      setAttr(barEl, "role", "img");
+      setAttr(barEl, "aria-label", desc);
+    }
+    appendChild(group, barEl);
+  }
+  return group;
+}
+
+export { renderPolarBarsSvg };

package/dist/chunk-TA4MVAEX.mjs

@@ -0,0 +1,243 @@
+import { toRad, generateNiceTicks } from './chunk-RQ3CKQOX.mjs';
+
+// src/renderers/radial-grid.geometry.ts
+function valueToRadius(value, domain, outerRadius) {
+  const [min, max] = domain;
+  if (max === min) return 0;
+  return Math.max(0, Math.min(outerRadius, (value - min) / (max - min) * outerRadius));
+}
+function buildCircleSvgPath(cx, cy, r) {
+  return `M ${cx},${cy - r} A ${r},${r} 0 1 1 ${cx},${cy + r} A ${r},${r} 0 1 1 ${cx},${cy - r} Z`;
+}
+function buildPolygonPath(center, r, sides, angleStep) {
+  if (sides < 3) return "";
+  const parts = [];
+  for (let i = 0; i < sides; i++) {
+    const angleRad = toRad(-90 + i * angleStep);
+    const x = center.x + Math.cos(angleRad) * r;
+    const y = center.y + Math.sin(angleRad) * r;
+    parts.push(i === 0 ? `M${x},${y}` : `L${x},${y}`);
+  }
+  parts.push("Z");
+  return parts.join(" ");
+}
+function buildWedgePath(center, rInner, rOuter, angleStartDeg, angleEndDeg) {
+  const a1 = toRad(angleStartDeg);
+  const a2 = toRad(angleEndDeg);
+  const x1o = center.x + Math.cos(a1) * rOuter;
+  const y1o = center.y + Math.sin(a1) * rOuter;
+  const x2o = center.x + Math.cos(a2) * rOuter;
+  const y2o = center.y + Math.sin(a2) * rOuter;
+  const largeArc = Math.abs(angleEndDeg - angleStartDeg) > 180 ? 1 : 0;
+  if (rInner <= 0) {
+    return `M${center.x},${center.y} L${x1o},${y1o} A${rOuter},${rOuter} 0 ${largeArc} 1 ${x2o},${y2o} Z`;
+  }
+  const x1i = center.x + Math.cos(a1) * rInner;
+  const y1i = center.y + Math.sin(a1) * rInner;
+  const x2i = center.x + Math.cos(a2) * rInner;
+  const y2i = center.y + Math.sin(a2) * rInner;
+  return `M${x1i},${y1i} L${x1o},${y1o} A${rOuter},${rOuter} 0 ${largeArc} 1 ${x2o},${y2o} L${x2i},${y2i} A${rInner},${rInner} 0 ${largeArc} 0 ${x1i},${y1i} Z`;
+}
+function resolveBandGeometry(band, layout, yAxis) {
+  const outer = layout.radius;
+  if (band.r1 != null || band.r2 != null) {
+    const f1 = band.r1 ?? 0;
+    const f2 = band.r2 ?? 1;
+    const rInner = Math.max(0, Math.min(outer, Math.min(f1, f2) * outer));
+    const rOuter = Math.max(0, Math.min(outer, Math.max(f1, f2) * outer));
+    return rOuter > 0 ? { rInner, rOuter, mode: "annulus" } : null;
+  }
+  if (band.category != null) {
+    if (!yAxis || yAxis.mode !== "perSpoke") return null;
+    const ci = layout.categories.indexOf(band.category);
+    if (ci < 0) return null;
+    const spokeDomain = yAxis.spokes[ci]?.domain;
+    if (!spokeDomain) return null;
+    const r1 = band.y1 != null ? valueToRadius(band.y1, spokeDomain, outer) : 0;
+    const r2 = band.y2 != null ? valueToRadius(band.y2, spokeDomain, outer) : outer;
+    const rInner = Math.min(r1, r2);
+    const rOuter = Math.max(r1, r2);
+    if (rOuter <= 0) return null;
+    const halfStep = layout.angleStep / 2;
+    const centerAngle = -90 + ci * layout.angleStep;
+    return {
+      rInner,
+      rOuter,
+      mode: "wedge",
+      angleStartDeg: centerAngle - halfStep,
+      angleEndDeg: centerAngle + halfStep
+    };
+  }
+  if ((band.y1 != null || band.y2 != null) && layout.domain && yAxis?.mode === "shared") {
+    const r1 = band.y1 != null ? valueToRadius(band.y1, layout.domain, outer) : 0;
+    const r2 = band.y2 != null ? valueToRadius(band.y2, layout.domain, outer) : outer;
+    const rInner = Math.min(r1, r2);
+    const rOuter = Math.max(r1, r2);
+    return rOuter > 0 ? { rInner, rOuter, mode: "annulus" } : null;
+  }
+  return null;
+}
+function resolveLineGeometry(line, layout, yAxis) {
+  const outer = layout.radius;
+  if (line.r != null) {
+    const r = Math.max(0, Math.min(outer, line.r * outer));
+    return r > 0 ? { mode: "ring", r } : null;
+  }
+  if (line.category != null) {
+    if (line.y == null) return null;
+    if (!yAxis || yAxis.mode !== "perSpoke") return null;
+    const ci = layout.categories.indexOf(line.category);
+    if (ci < 0) return null;
+    const spokeDomain = yAxis.spokes[ci]?.domain;
+    if (!spokeDomain) return null;
+    const r = valueToRadius(line.y, spokeDomain, outer);
+    if (r <= 0) return null;
+    const angleDeg = -90 + ci * layout.angleStep;
+    const angleRad = toRad(angleDeg);
+    const dx = Math.cos(angleRad);
+    const dy = Math.sin(angleRad);
+    const tx = -dy;
+    const ty = dx;
+    const halfLen = Math.max(8, outer * 0.04);
+    const cx = layout.center.x + dx * r;
+    const cy = layout.center.y + dy * r;
+    return {
+      mode: "crossbar",
+      x1: cx - tx * halfLen,
+      y1: cy - ty * halfLen,
+      x2: cx + tx * halfLen,
+      y2: cy + ty * halfLen
+    };
+  }
+  if (line.y != null && layout.domain && yAxis?.mode === "shared") {
+    const r = valueToRadius(line.y, layout.domain, outer);
+    return r > 0 ? { mode: "ring", r } : null;
+  }
+  return null;
+}
+function resolveSharedRadialGrid(grid, domain, rawDataMax, radius, tickCount) {
+  let levelValues = grid.levelValues.slice();
+  let levelRadii = grid.levelRadii.slice();
+  let outDomain = [domain[0], domain[1]];
+  const place = (vals, d) => vals.map((v) => d[1] === d[0] ? 0 : (v - d[0]) / (d[1] - d[0]) * radius);
+  if (tickCount != null && tickCount >= 2) {
+    const rawMax = rawDataMax ?? domain[1];
+    levelValues = generateNiceTicks(domain[0], rawMax, tickCount, true);
+    outDomain = [domain[0], levelValues[levelValues.length - 1]];
+    levelRadii = place(levelValues, outDomain);
+  } else {
+    const lastTick = levelValues[levelValues.length - 1];
+    if (levelValues.length >= 2 && rawDataMax != null && lastTick != null && lastTick <= rawDataMax) {
+      const tickStep = lastTick - levelValues[levelValues.length - 2];
+      if (tickStep > 0) {
+        levelValues.push(Math.round((lastTick + tickStep) * 1e10) / 1e10);
+        outDomain = [domain[0], levelValues[levelValues.length - 1]];
+        levelRadii = place(levelValues, outDomain);
+      }
+    }
+  }
+  return { levelValues, levelRadii, domain: outDomain };
+}
+function buildRadialGridLayout(base, xAxisProps, yAxisProps, yAxesByCategory, chartType) {
+  const defaultGridShape = chartType === "radar" ? "polygon" : "circle";
+  const xAxis = xAxisProps ? {
+    labelFontSize: base.labelFontSize,
+    labelPadding: base.labelPadding,
+    color: xAxisProps.color,
+    visible: xAxisProps.visible ?? true,
+    shape: xAxisProps.gridShape ?? defaultGridShape,
+    showLine: xAxisProps.showLine ?? true,
+    showLabels: xAxisProps.showLabels ?? true
+  } : null;
+  let domain = base.domain;
+  let yAxis = null;
+  const isPerSpokeMode = !!base.perSpokeDomains && base.perSpokeDomains.size > 0;
+  if (isPerSpokeMode && (yAxisProps || yAxesByCategory && yAxesByCategory.size > 0)) {
+    const spokes = [];
+    for (let ci = 0; ci < base.categories.length; ci++) {
+      const spokeDomain = base.perSpokeDomains.get(ci) ?? base.domain;
+      const declared = yAxesByCategory?.get(base.categories[ci]);
+      const propsForSpoke = declared ?? yAxisProps;
+      const tickCount = propsForSpoke?.tickCount;
+      const useExact = tickCount != null && tickCount >= 2;
+      const ticks = useExact ? generateNiceTicks(spokeDomain[0], spokeDomain[1], tickCount, true) : generateNiceTicks(spokeDomain[0], spokeDomain[1]);
+      const lo = ticks[0] ?? spokeDomain[0];
+      const hi = ticks[ticks.length - 1] ?? spokeDomain[1];
+      const aligned = [Math.min(spokeDomain[0], lo), Math.max(spokeDomain[1], hi)];
+      const span = aligned[1] - aligned[0];
+      const radii = ticks.map((v) => span === 0 ? 0 : (v - aligned[0]) / span * base.radius);
+      const uniformTickStyle = declared?.tickStyle && typeof declared.tickStyle !== "function" ? declared.tickStyle : void 0;
+      const rawTickFormat = declared?.tickFormat;
+      spokes.push({
+        domain: aligned,
+        levelValues: ticks,
+        levelRadii: radii,
+        tickFormat: typeof rawTickFormat === "function" ? (v) => rawTickFormat(v) : void 0,
+        tickColor: uniformTickStyle?.color ?? declared?.color,
+        tickFontSize: uniformTickStyle?.fontSize,
+        showLine: propsForSpoke?.showLine ?? true,
+        showLabels: propsForSpoke?.showLabels ?? true
+      });
+    }
+    const referenceRingRadii = [0.2, 0.4, 0.6, 0.8].map((f) => f * base.radius);
+    const defaultUniformTickStyle = yAxisProps?.tickStyle && typeof yAxisProps.tickStyle !== "function" ? yAxisProps.tickStyle : void 0;
+    yAxis = {
+      mode: "perSpoke",
+      spokes,
+      referenceRingRadii,
+      shape: yAxisProps?.gridShape ?? defaultGridShape,
+      gridColor: yAxisProps?.gridColor,
+      gridOpacity: yAxisProps?.gridOpacity ?? 0.6,
+      gridStyle: yAxisProps?.gridStyle ?? "solid",
+      gridStrokeWidth: yAxisProps?.gridStrokeWidth ?? 0.5,
+      tickFontSize: defaultUniformTickStyle?.fontSize ?? base.labelFontSize,
+      tickColor: defaultUniformTickStyle?.color ?? yAxisProps?.color,
+      visible: yAxisProps?.visible ?? true,
+      gridLines: yAxisProps?.gridLines ?? true
+    };
+  } else if (yAxisProps) {
+    let levelValues;
+    let levelRadii;
+    if (base.gridAnimating) {
+      levelValues = base.grid.levelValues.slice();
+      levelRadii = base.grid.levelRadii.slice();
+    } else {
+      const resolved = resolveSharedRadialGrid(base.grid, domain, base.rawDataMax, base.radius, yAxisProps.tickCount);
+      levelValues = resolved.levelValues;
+      levelRadii = resolved.levelRadii;
+      domain = resolved.domain;
+    }
+    const uniformTickStyle = yAxisProps.tickStyle && typeof yAxisProps.tickStyle !== "function" ? yAxisProps.tickStyle : void 0;
+    const rawTickFormat = yAxisProps.tickFormat;
+    yAxis = {
+      mode: "shared",
+      levelValues,
+      levelRadii,
+      shape: yAxisProps.gridShape ?? defaultGridShape,
+      gridColor: yAxisProps.gridColor,
+      gridOpacity: yAxisProps.gridOpacity ?? 0.6,
+      gridStyle: yAxisProps.gridStyle ?? "solid",
+      gridStrokeWidth: yAxisProps.gridStrokeWidth ?? 0.5,
+      tickFontSize: uniformTickStyle?.fontSize ?? base.labelFontSize,
+      tickColor: uniformTickStyle?.color ?? yAxisProps.color,
+      tickFormat: typeof rawTickFormat === "function" ? (v) => rawTickFormat(v) : void 0,
+      visible: yAxisProps.visible ?? true,
+      showLine: yAxisProps.showLine ?? true,
+      gridLines: yAxisProps.gridLines ?? true,
+      showLabels: yAxisProps.showLabels ?? true
+    };
+  }
+  return {
+    center: base.center,
+    radius: base.radius,
+    categories: base.categories,
+    angleStep: base.angleStep,
+    spokeEndpoints: base.spokeEndpoints,
+    fontFamily: base.fontFamily,
+    domain,
+    xAxis,
+    yAxis
+  };
+}
+
+export { buildCircleSvgPath, buildPolygonPath, buildRadialGridLayout, buildWedgePath, resolveBandGeometry, resolveLineGeometry, resolveSharedRadialGrid };