@primeui/chart-core 0.0.1-alpha.1

package/dist/chunk-WCG35U6M.mjs

@@ -0,0 +1,964 @@
+import { isPointInSlice } from './chunk-LVMDQ4OJ.mjs';
+import { MARKER_SHAPE_NAMES, renderMarkerShapeSvg, drawMarkerCanvas } from './chunk-PRDVPOZX.mjs';
+import { calculateRadiusAndCenter } from './chunk-NPDZLYIF.mjs';
+import { formatPointDescription } from './chunk-OGJ6IIBW.mjs';
+import { measureText } from './chunk-XTVE4P3L.mjs';
+import { DEFAULT_RADIAL_LABEL_FONT_SIZE, DEFAULT_GRID_LEVELS, resolveFontSize, resolveFontFamily, DEFAULT_RADAR_FILL_OPACITY, DEFAULT_LINE_WIDTH, DEFAULT_HOVER_POINT_RADIUS_MULTIPLIER, DEFAULT_POLAR_GAP_PX, DEFAULT_RADAR_HIT_RADIUS, DEFAULT_LINE_MARKER_SIZE } from './chunk-NKUYIWAP.mjs';
+import { isGradientColor, batchResolveAccessor, FIELD_DEFAULTS, createSvgGradientFromColor, makeItemContext, resolveDash, resolveAccessor, getDefaultColor, createCanvasGradientFromColor, sampleGradientAt, resolveSwatchColor, getPrimaryColor, batchResolveRequired } from './chunk-O2X6FF45.mjs';
+import { createCanvasPathBuilder, traceClosedSpline, createSvgPathBuilder } from './chunk-IEGLX7VL.mjs';
+import { createSvgGroup, setAttr, adjustBrightness, createSvgDefs, appendChild, prependChild, svgClass, createSvgPath, svgNode, withCanvasState } from './chunk-SSLTFJ3U.mjs';
+import { calculateNiceDomain, generateNiceTicks, toRad } from './chunk-RQ3CKQOX.mjs';
+
+// src/renderers/radar.layout.ts
+function calculateRadarLayout(datasets, chartArea, globalFont, sharedCategories, sharedDomain, perAxisDomains, referenceBoundaryValues, perSpokeDomains, tickCount) {
+  const categories = sharedCategories ?? extractCategories(datasets);
+  const categoryCount = categories.length;
+  const angleStep = categoryCount > 0 ? 360 / categoryCount : 0;
+  const allValues = [];
+  const stackCumulatives = /* @__PURE__ */ new Map();
+  for (const ds of datasets) {
+    if (!ds.visible) continue;
+    if (ds.props.yAxisId) continue;
+    const values = resolveValues(ds.props);
+    const stackId = ds.props.stackId;
+    if (stackId) {
+      if (!stackCumulatives.has(stackId)) {
+        stackCumulatives.set(stackId, new Array(categoryCount).fill(0));
+      }
+      const cumulative = stackCumulatives.get(stackId);
+      for (let ci = 0; ci < categoryCount; ci++) {
+        cumulative[ci] = (cumulative[ci] ?? 0) + (values[ci] ?? 0);
+        allValues.push(cumulative[ci]);
+      }
+    } else {
+      allValues.push(...values);
+    }
+  }
+  if (allValues.length === 0) {
+    for (const ds of datasets) {
+      if (ds.visible) allValues.push(...resolveValues(ds.props));
+    }
+  }
+  const rawDataMax = allValues.length ? Math.max(...allValues) : 0;
+  let [rawDomainMin, rawDomainMax] = sharedDomain ?? calculateNiceDomain(allValues.length ? allValues : [0, 1], { includeZero: true, nice: true });
+  if (referenceBoundaryValues?.length) {
+    for (const v of referenceBoundaryValues) {
+      if (v < rawDomainMin) rawDomainMin = v;
+      if (v > rawDomainMax) rawDomainMax = v;
+    }
+  }
+  const rawDomain = [rawDomainMin, rawDomainMax];
+  const levelValues = generateNiceTicks(rawDomain[0], rawDomain[1], tickCount ?? DEFAULT_GRID_LEVELS);
+  const firstTick = levelValues[0] ?? rawDomain[0];
+  const lastTick = levelValues[levelValues.length - 1] ?? rawDomain[1];
+  const domain = [Math.min(rawDomain[0], firstTick), Math.max(rawDomain[1], lastTick)];
+  const resolvedLabelFontSize = resolveFontSize(DEFAULT_RADIAL_LABEL_FONT_SIZE, globalFont);
+  const resolvedFontFamily = resolveFontFamily(void 0, globalFont);
+  const labelPadding = measureText("Xg", resolvedLabelFontSize).height;
+  const labelMargins = calculateLabelMargins(categories, angleStep, labelPadding, resolvedLabelFontSize);
+  const adjustedArea = {
+    x: chartArea.x + labelMargins.left,
+    y: chartArea.y + labelMargins.top,
+    width: Math.max(0, chartArea.width - labelMargins.left - labelMargins.right),
+    height: Math.max(0, chartArea.height - labelMargins.top - labelMargins.bottom)
+  };
+  const { center, radius } = calculateRadiusAndCenter(adjustedArea);
+  const levelRadii = levelValues.map((v) => {
+    if (domain[1] === domain[0]) return 0;
+    return (v - domain[0]) / (domain[1] - domain[0]) * radius;
+  });
+  const grid = {
+    shape: "polygon",
+    levels: levelValues.length,
+    levelValues,
+    levelRadii
+  };
+  const spokeEndpoints = [];
+  for (let i = 0; i < categoryCount; i++) {
+    const angleDeg = -90 + i * angleStep;
+    const angleRad = toRad(angleDeg);
+    spokeEndpoints.push({
+      x: center.x + Math.cos(angleRad) * radius,
+      y: center.y + Math.sin(angleRad) * radius
+    });
+  }
+  const series = [];
+  const stackRunning = /* @__PURE__ */ new Map();
+  for (let si = 0; si < datasets.length; si++) {
+    const ds = datasets[si];
+    const gradientColor = ds.props.color && isGradientColor(ds.props.color) ? ds.props.color : void 0;
+    const color = typeof ds.props.color === "string" ? ds.props.color : void 0;
+    const fillOpacity = ds.props.fillOpacity ?? DEFAULT_RADAR_FILL_OPACITY;
+    const lineWidth = ds.props.lineStrokeWidth ?? DEFAULT_LINE_WIDTH;
+    const lineStyle = ds.props.lineStyle;
+    const lineDash = ds.props.lineDash;
+    const curve = ds.props.curve;
+    const stackId = ds.props.stackId;
+    const values = resolveValues(ds.props);
+    const points = [];
+    const basePoints = [];
+    const isStacked = !!stackId;
+    if (isStacked && !stackRunning.has(stackId)) {
+      stackRunning.set(stackId, new Array(categoryCount).fill(0));
+    }
+    const cumulative = isStacked ? stackRunning.get(stackId) : null;
+    const yAxisId = ds.props.yAxisId;
+    const axisOverride = yAxisId ? perAxisDomains?.get(yAxisId) : void 0;
+    const seriesDomain = axisOverride ?? domain;
+    for (let ci = 0; ci < categoryCount; ci++) {
+      const rawValue = values[ci] ?? 0;
+      const baseValue = isStacked ? cumulative[ci] ?? 0 : 0;
+      const topValue = baseValue + rawValue;
+      const [sMin, sMax] = perSpokeDomains?.get(ci) ?? seriesDomain;
+      const domainSpan = sMax - sMin;
+      const angleDeg = -90 + ci * angleStep;
+      const angleRad = toRad(angleDeg);
+      const topR = domainSpan === 0 ? 0 : Math.max(0, (topValue - sMin) / domainSpan) * radius;
+      const baseR = domainSpan === 0 ? 0 : Math.max(0, (baseValue - sMin) / domainSpan) * radius;
+      points.push({
+        x: center.x + Math.cos(angleRad) * topR,
+        y: center.y + Math.sin(angleRad) * topR,
+        value: rawValue,
+        angle: angleDeg,
+        categoryIndex: ci
+      });
+      if (isStacked) {
+        basePoints.push({
+          x: center.x + Math.cos(angleRad) * baseR,
+          y: center.y + Math.sin(angleRad) * baseR,
+          value: baseValue,
+          angle: angleDeg,
+          categoryIndex: ci
+        });
+      }
+    }
+    if (isStacked && ds.visible) {
+      for (let ci = 0; ci < categoryCount; ci++) {
+        cumulative[ci] = (cumulative[ci] ?? 0) + (values[ci] ?? 0);
+      }
+    }
+    series.push({
+      id: ds.id,
+      name: ds.props.name,
+      points,
+      basePoints: isStacked ? basePoints : void 0,
+      color,
+      seriesIdx: si,
+      gradientColor,
+      fillOpacity,
+      lineStrokeWidth: lineWidth,
+      lineStyle,
+      lineDash,
+      curve,
+      visible: ds.visible
+    });
+  }
+  return {
+    center,
+    radius,
+    categories,
+    angleStep,
+    domain,
+    grid,
+    series,
+    spokeEndpoints,
+    chartArea,
+    labelPadding,
+    labelFontSize: resolvedLabelFontSize,
+    fontFamily: resolvedFontFamily,
+    rawDataMax,
+    perSpokeDomains: perSpokeDomains ?? null
+  };
+}
+function extractCategories(datasets) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const ds of datasets) {
+    const props = ds.props;
+    if (!props.data) continue;
+    const cats = batchResolveAccessor(props.categoryField ?? FIELD_DEFAULTS.categoryField, props.data);
+    for (const cat of cats) {
+      const str = String(cat);
+      if (!seen.has(str)) {
+        seen.add(str);
+        result.push(str);
+      }
+    }
+  }
+  return result;
+}
+function resolveValues(props) {
+  if (!props.data) return [];
+  return batchResolveAccessor(props.valueField ?? FIELD_DEFAULTS.valueField, props.data).map((v) => Number(v) || 0);
+}
+function computeRadialComboContext(radarDatasets, polarDatasets) {
+  const allEntries = [...radarDatasets, ...polarDatasets];
+  const categories = extractCategories(allEntries);
+  const allValues = [];
+  for (const ds of allEntries) {
+    allValues.push(...resolveValues(ds.props));
+  }
+  const domain = calculateNiceDomain(allValues, { includeZero: true, nice: true });
+  return { categories, domain };
+}
+function getCategoryLabelAnchor(angleDeg) {
+  const cosA = Math.cos(toRad(angleDeg));
+  if (cosA > 0.15) return "start";
+  if (cosA < -0.15) return "end";
+  return "middle";
+}
+function calculateLabelMargins(categories, angleStep, labelPadding, fontSize = DEFAULT_RADIAL_LABEL_FONT_SIZE) {
+  let top = 0;
+  let right = 0;
+  let bottom = 0;
+  let left = 0;
+  for (let i = 0; i < categories.length; i++) {
+    const angleDeg = -90 + i * angleStep;
+    const angleRad = toRad(angleDeg);
+    const cosA = Math.cos(angleRad);
+    const sinA = Math.sin(angleRad);
+    const { width: textWidth, height: textHeight } = measureText(categories[i], fontSize);
+    const halfH = textHeight / 2;
+    const dx = cosA * labelPadding;
+    const dy = sinA * labelPadding;
+    const anchor = getCategoryLabelAnchor(angleDeg);
+    let textExtentRight;
+    let textExtentLeft;
+    if (anchor === "start") {
+      textExtentRight = textWidth;
+      textExtentLeft = 0;
+    } else if (anchor === "end") {
+      textExtentRight = 0;
+      textExtentLeft = textWidth;
+    } else {
+      textExtentRight = textWidth / 2;
+      textExtentLeft = textWidth / 2;
+    }
+    right = Math.max(right, dx + textExtentRight);
+    left = Math.max(left, -dx + textExtentLeft);
+    bottom = Math.max(bottom, dy + halfH);
+    top = Math.max(top, -dy + halfH);
+  }
+  const buffer = 4;
+  return {
+    top: Math.max(top, 0) + buffer,
+    right: Math.max(right, 0) + buffer,
+    bottom: Math.max(bottom, 0) + buffer,
+    left: Math.max(left, 0) + buffer
+  };
+}
+
+// src/renderers/radar.svg.ts
+function buildSmoothPath(points) {
+  if (points.length < 3) return buildPointsPath(points);
+  const builder = createSvgPathBuilder();
+  traceClosedSpline(builder, points);
+  return builder.build();
+}
+function buildPointsPath(points) {
+  if (points.length === 0) return "";
+  const parts = [];
+  for (let i = 0; i < points.length; i++) {
+    parts.push(`${i === 0 ? "M" : "L"} ${points[i].x} ${points[i].y}`);
+  }
+  parts.push("Z");
+  return parts.join(" ");
+}
+function buildPointsPathReversed(points) {
+  if (points.length === 0) return "";
+  const parts = [];
+  for (let i = points.length - 1; i >= 0; i--) {
+    parts.push(`${i === points.length - 1 ? "M" : "L"} ${points[i].x} ${points[i].y}`);
+  }
+  parts.push("Z");
+  return parts.join(" ");
+}
+function renderRadarSeriesSvg(layout, seriesIndex, hoverState, theme, effectConfig, seriesProps, a11y, context) {
+  const sd = layout.series[seriesIndex];
+  if (!sd || !sd.visible || sd.points.length === 0) return createSvgGroup();
+  const group = createSvgGroup();
+  if (a11y?.enabled) {
+    setAttr(group, "role", "region");
+    setAttr(group, "aria-label", seriesProps?.name ?? sd.id);
+  }
+  const sharedAxisIdx = hoverState.axisIndex ?? null;
+  const isSharedHover = sharedAxisIdx !== null;
+  const isSeriesHovered = isSharedHover ? true : hoverState.datasetId === sd.id;
+  const anyHover = hoverState.datasetId !== null || isSharedHover;
+  let seriesOpacity = 1;
+  if (anyHover && !isSharedHover && !isSeriesHovered && effectConfig?.dimOpacity !== void 0) {
+    seriesOpacity = effectConfig.dimOpacity;
+  }
+  const isSmooth = sd.curve === "smooth";
+  const outerPathD = isSmooth ? buildSmoothPath(sd.points) : buildPointsPath(sd.points);
+  const isStacked = sd.basePoints && sd.basePoints.length > 0;
+  const innerPathD = isStacked ? isSmooth ? buildSmoothPath([...sd.basePoints].reverse()) : buildPointsPathReversed(sd.basePoints) : "";
+  const fillPathD = isStacked ? `${outerPathD} ${innerPathD}` : outerPathD;
+  const colorClassN = `p-chart-color-${sd.seriesIdx % 10}`;
+  const seriesIsHoveredJs = !isSharedHover && isSeriesHovered;
+  let fillColor = sd.color;
+  let strokeColor = sd.color;
+  if (sd.color !== void 0 && seriesIsHoveredJs && effectConfig?.hoverBrightness) {
+    fillColor = adjustBrightness(sd.color, effectConfig.hoverBrightness);
+    strokeColor = adjustBrightness(sd.color, effectConfig.hoverBrightness);
+  }
+  let fillValue = fillColor;
+  let strokeValue = strokeColor;
+  let gradientUrl = null;
+  if (sd.gradientColor && context) {
+    const defs = createSvgDefs();
+    const gradId = `${context.chartId}-radar-${seriesIndex}-grad`;
+    const gradNode = createSvgGradientFromColor(sd.gradientColor, gradId, layout.center, layout.radius);
+    setAttr(defs, "id", `${gradId}-defs`);
+    appendChild(defs, gradNode);
+    prependChild(group, defs);
+    gradientUrl = `url(#${gradId})`;
+    fillValue = gradientUrl;
+    strokeValue = sd.gradientColor.stops[0]?.color ?? strokeColor;
+  }
+  const borderColor = seriesProps?.borderColor && typeof seriesProps.borderColor === "string" ? seriesProps.borderColor : void 0;
+  const borderWidth = typeof seriesProps?.borderStrokeWidth === "number" ? seriesProps.borderStrokeWidth : 0;
+  const dashAttrs = {};
+  const dashPattern = sd.lineDash ?? (sd.lineStyle === "dashed" ? [6, 4] : sd.lineStyle === "dotted" ? [2, 3] : null);
+  if (dashPattern?.length) dashAttrs["stroke-dasharray"] = dashPattern.join(" ");
+  const fillAreaCls = svgClass("p-chart-area", `p-chart-series-${sd.seriesIdx}`, fillValue === void 0 && colorClassN, seriesIsHoveredJs && "p-chart-point-hover", anyHover && !isSeriesHovered && "p-chart-series-inactive");
+  const themedSeriesColor = theme.series[sd.seriesIdx % theme.series.length];
+  appendChild(
+    group,
+    createSvgPath(fillPathD, {
+      fill: fillValue ?? themedSeriesColor,
+      "fill-opacity": sd.fillOpacity * seriesOpacity,
+      "fill-rule": isStacked ? "evenodd" : "nonzero",
+      stroke: "none",
+      class: fillAreaCls,
+      "data-layer": "area"
+    })
+  );
+  const borderAlign = seriesProps?.borderAlign ?? "center";
+  const radarDataArr = seriesProps?.data;
+  const radarSeriesDashCtx = makeItemContext(radarDataArr?.[0], 0);
+  const borderDash = resolveDash(seriesProps?.borderDash, radarSeriesDashCtx);
+  const borderDashOffset = resolveAccessor(seriesProps?.borderDashOffset, radarSeriesDashCtx, { arrayMode: "clip", fallback: 0 }) ?? 0;
+  if (borderColor && borderWidth > 0 && borderAlign === "center") {
+    const borderAttrs = {
+      fill: "none",
+      stroke: borderColor,
+      "stroke-width": sd.lineStrokeWidth + borderWidth * 2,
+      "stroke-opacity": seriesOpacity,
+      "stroke-linejoin": seriesProps?.borderJoinStyle ?? "round",
+      "data-layer": "center-border"
+    };
+    if (borderDash && borderDash.length > 0) borderAttrs["stroke-dasharray"] = borderDash.join(" ");
+    if (borderDashOffset) borderAttrs["stroke-dashoffset"] = borderDashOffset;
+    appendChild(group, createSvgPath(outerPathD, borderAttrs));
+  }
+  const strokeLineCls = svgClass("p-chart-line", `p-chart-series-${sd.seriesIdx}`, strokeValue === void 0 && colorClassN, seriesIsHoveredJs && "p-chart-point-hover", anyHover && !isSeriesHovered && "p-chart-series-inactive");
+  appendChild(
+    group,
+    createSvgPath(outerPathD, {
+      fill: "none",
+      stroke: strokeValue ?? themedSeriesColor,
+      "stroke-width": sd.lineStrokeWidth,
+      "stroke-opacity": seriesOpacity,
+      "stroke-linejoin": "round",
+      class: strokeLineCls,
+      "data-layer": "line",
+      ...dashAttrs
+    })
+  );
+  if (borderColor && borderWidth > 0 && borderAlign === "inner") {
+    const clipId = context ? `${context.chartId}-radar-${seriesIndex}-border-clip` : `radar-${seriesIndex}-border-clip`;
+    const clipPathEl = svgNode("clipPath", { id: clipId });
+    appendChild(clipPathEl, createSvgPath(outerPathD, {}));
+    const defs = createSvgDefs();
+    setAttr(defs, "id", `${clipId}-defs`);
+    appendChild(defs, clipPathEl);
+    prependChild(group, defs);
+    const borderAttrs = {
+      fill: "none",
+      stroke: borderColor,
+      "stroke-width": borderWidth * 2,
+      "stroke-opacity": seriesOpacity,
+      "stroke-linejoin": seriesProps?.borderJoinStyle ?? "round",
+      "clip-path": `url(#${clipId})`,
+      "data-layer": "inner-border"
+    };
+    if (borderDash && borderDash.length > 0) borderAttrs["stroke-dasharray"] = borderDash.join(" ");
+    if (borderDashOffset) borderAttrs["stroke-dashoffset"] = borderDashOffset;
+    appendChild(group, createSvgPath(outerPathD, borderAttrs));
+  }
+  const showMarkers = seriesProps?.showMarkers !== false;
+  const a11yEnabled = !!(a11y?.enabled && sd.points.length <= (a11y.pointDescriptionThreshold ?? 200));
+  const seriesName = seriesProps?.name ?? sd.id;
+  const anyPointHovered = isSharedHover ? sharedAxisIdx !== null : isSeriesHovered && hoverState.index !== null;
+  if ((showMarkers || anyPointHovered) && !seriesProps?.renderMarker) {
+    const dataArr = seriesProps?.data;
+    const ptValue = (idx) => sd.points[idx]?.value;
+    const ptCategory = (idx) => layout.categories[sd.points[idx]?.categoryIndex ?? idx];
+    const seriesExtras = { seriesIndex, seriesId: sd.id ?? "" };
+    const resolveMarkerSize = (idx) => resolveAccessor(seriesProps?.markerSize, makeItemContext(dataArr?.[idx], idx, { value: ptValue(idx), category: ptCategory(idx), ...seriesExtras }), { arrayMode: "clip", fallback: DEFAULT_LINE_MARKER_SIZE }) ?? DEFAULT_LINE_MARKER_SIZE;
+    const resolveMarkerHoverColor = (idx) => {
+      const v = resolveAccessor(seriesProps?.hoverColor, makeItemContext(dataArr?.[idx], idx, { value: ptValue(idx), category: ptCategory(idx), ...seriesExtras }), { arrayMode: "cycle" });
+      return typeof v === "string" ? v : v ? getPrimaryColor(v) : void 0;
+    };
+    const resolveMarkerHoverBorderColor = (idx) => {
+      const v = resolveAccessor(seriesProps?.hoverBorderColor, makeItemContext(dataArr?.[idx], idx, { value: ptValue(idx), category: ptCategory(idx), ...seriesExtras }), { arrayMode: "cycle" });
+      return typeof v === "string" ? v : v ? getPrimaryColor(v) : void 0;
+    };
+    const resolveMarkerShape = (idx, size) => resolveAccessor(seriesProps?.markerShape, makeItemContext(dataArr?.[idx], idx, { size, value: ptValue(idx), category: ptCategory(idx), ...seriesExtras }), { arrayMode: "clip" }) ?? "circle";
+    const resolvePointRotation = (idx) => resolveAccessor(seriesProps?.pointRotation, makeItemContext(dataArr?.[idx], idx, { value: ptValue(idx), category: ptCategory(idx), ...seriesExtras }), { arrayMode: "clip", fallback: 0 }) ?? 0;
+    for (let pi = 0; pi < sd.points.length; pi++) {
+      const pt = sd.points[pi];
+      const isPointHovered = isSharedHover ? pi === sharedAxisIdx : isSeriesHovered && hoverState.index === pi;
+      if (!showMarkers && !isPointHovered) continue;
+      const ptMarkerSize = resolveMarkerSize(pi);
+      const pointR = isPointHovered ? ptMarkerSize * (effectConfig?.hoverRadiusMultiplier ?? DEFAULT_HOVER_POINT_RADIUS_MULTIPLIER) : ptMarkerSize;
+      let ptColor = gradientUrl ?? strokeColor;
+      if (isPointHovered) {
+        const ptHoverColor = resolveMarkerHoverColor(pi);
+        if (ptHoverColor) {
+          ptColor = ptHoverColor;
+        } else if (typeof ptColor === "string" && !gradientUrl && effectConfig?.hoverBrightness && effectConfig.hoverBrightness !== 1) {
+          ptColor = adjustBrightness(ptColor, effectConfig.hoverBrightness);
+        }
+      }
+      const userPointBorder = seriesProps?.pointBorderColor;
+      const ptHoverBorderColor = isPointHovered ? resolveMarkerHoverBorderColor(pi) : void 0;
+      const markerStrokeStr = ptHoverBorderColor ?? userPointBorder ?? ptColor;
+      const markerCls = svgClass("p-chart-marker", `p-chart-series-${sd.seriesIdx}`, ptColor === void 0 && colorClassN, isPointHovered && "p-chart-point-hover", anyHover && !isSeriesHovered && "p-chart-point-inactive");
+      const radarMarkerAttrs = {
+        fill: ptColor ?? themedSeriesColor,
+        stroke: markerStrokeStr ?? themedSeriesColor,
+        "stroke-width": resolveAccessor(seriesProps?.pointBorderStrokeWidth, makeItemContext(dataArr?.[pi], pi, { value: pt.value, category: ptCategory(pi), ...seriesExtras }), { arrayMode: "clip", fallback: 0 }) ?? 0,
+        "stroke-linejoin": seriesProps?.pointBorderJoinStyle ?? "miter",
+        opacity: seriesOpacity,
+        class: markerCls
+      };
+      const ptDash = resolveDash(seriesProps?.pointBorderDash, makeItemContext(dataArr?.[pi], pi, { value: pt.value, category: ptCategory(pi), ...seriesExtras }));
+      const ptDashOffset = resolveAccessor(seriesProps?.pointBorderDashOffset, makeItemContext(dataArr?.[pi], pi, { value: pt.value, category: ptCategory(pi), ...seriesExtras }), { arrayMode: "clip", fallback: 0 }) ?? 0;
+      if (ptDash && ptDash.length > 0) radarMarkerAttrs["stroke-dasharray"] = ptDash.join(" ");
+      if (ptDashOffset) radarMarkerAttrs["stroke-dashoffset"] = ptDashOffset;
+      const ptShape = resolveMarkerShape(pi, pointR);
+      let markerEl;
+      const ptRotation = resolvePointRotation(pi);
+      if (MARKER_SHAPE_NAMES.has(ptShape)) {
+        if (ptRotation) radarMarkerAttrs.transform = `rotate(${ptRotation}, ${pt.x}, ${pt.y})`;
+        markerEl = renderMarkerShapeSvg(ptShape, pt.x, pt.y, pointR, radarMarkerAttrs);
+      } else {
+        radarMarkerAttrs.transform = ptRotation ? `translate(${pt.x}, ${pt.y}) rotate(${ptRotation})` : `translate(${pt.x}, ${pt.y})`;
+        markerEl = createSvgPath(ptShape, radarMarkerAttrs);
+      }
+      if (a11yEnabled) {
+        const category = layout.categories[pt.categoryIndex] ?? `Category ${pt.categoryIndex + 1}`;
+        const desc = formatPointDescription({ category, value: pt.value, seriesName, index: pt.categoryIndex }, a11y.pointDescriptionFormatter);
+        setAttr(markerEl, "role", "img");
+        setAttr(markerEl, "aria-label", desc);
+      }
+      setAttr(markerEl, "data-index", String(pi));
+      appendChild(group, markerEl);
+    }
+  }
+  return group;
+}
+
+// src/renderers/radar.canvas.ts
+function renderRadarSeriesCanvas(ctx, layout, seriesIndex, hoverState, effectConfig, seriesProps, theme) {
+  const sd = layout.series[seriesIndex];
+  if (!sd || !sd.visible || sd.points.length === 0) return;
+  const sharedAxisIdx = hoverState.axisIndex ?? null;
+  const isSharedHover = sharedAxisIdx !== null;
+  const isSeriesHovered = isSharedHover ? true : hoverState.datasetId === sd.id;
+  const anyHover = hoverState.datasetId !== null || isSharedHover;
+  let seriesOpacity = 1;
+  if (anyHover && !isSharedHover && !isSeriesHovered && effectConfig?.dimOpacity !== void 0) {
+    seriesOpacity = effectConfig.dimOpacity;
+  }
+  const baseColor = sd.color ?? getDefaultColor(sd.seriesIdx, theme);
+  let fillColor = baseColor;
+  let strokeColor = baseColor;
+  if (!isSharedHover && isSeriesHovered && effectConfig?.hoverBrightness) {
+    fillColor = adjustBrightness(fillColor, effectConfig.hoverBrightness);
+    strokeColor = adjustBrightness(strokeColor, effectConfig.hoverBrightness);
+  }
+  const isStacked = sd.basePoints && sd.basePoints.length > 0;
+  const isSmooth = sd.curve === "smooth";
+  const canvasBuilder = createCanvasPathBuilder(ctx);
+  const borderColor = seriesProps?.borderColor && typeof seriesProps.borderColor === "string" ? seriesProps.borderColor : void 0;
+  const borderWidth = typeof seriesProps?.borderStrokeWidth === "number" ? seriesProps.borderStrokeWidth : 0;
+  withCanvasState(ctx, () => {
+    ctx.beginPath();
+    if (isSmooth) {
+      traceClosedSpline(canvasBuilder, sd.points);
+    } else {
+      for (let i = 0; i < sd.points.length; i++) {
+        const pt = sd.points[i];
+        if (i === 0) ctx.moveTo(pt.x, pt.y);
+        else ctx.lineTo(pt.x, pt.y);
+      }
+      ctx.closePath();
+    }
+    if (isStacked) {
+      const basePts = sd.basePoints;
+      if (isSmooth) {
+        traceClosedSpline(canvasBuilder, [...basePts].reverse());
+      } else {
+        for (let i = basePts.length - 1; i >= 0; i--) {
+          const pt = basePts[i];
+          if (i === basePts.length - 1) ctx.moveTo(pt.x, pt.y);
+          else ctx.lineTo(pt.x, pt.y);
+        }
+        ctx.closePath();
+      }
+    }
+    const resolvedFill = sd.gradientColor ? createCanvasGradientFromColor(ctx, sd.gradientColor, layout.center, layout.radius) : fillColor;
+    const resolvedStroke = sd.gradientColor ? sd.gradientColor.stops[0]?.color ?? strokeColor : strokeColor;
+    ctx.fillStyle = resolvedFill;
+    ctx.globalAlpha = sd.fillOpacity * seriesOpacity;
+    ctx.fill(isStacked ? "evenodd" : "nonzero");
+    const traceOuterPath = () => {
+      ctx.beginPath();
+      if (isSmooth) {
+        traceClosedSpline(canvasBuilder, sd.points);
+      } else {
+        for (let i = 0; i < sd.points.length; i++) {
+          const pt = sd.points[i];
+          if (i === 0) ctx.moveTo(pt.x, pt.y);
+          else ctx.lineTo(pt.x, pt.y);
+        }
+        ctx.closePath();
+      }
+    };
+    ctx.globalAlpha = seriesOpacity;
+    const borderAlign = seriesProps?.borderAlign ?? "center";
+    const radarDataArrCanvas = seriesProps?.data;
+    const radarSeriesDashCtx = makeItemContext(radarDataArrCanvas?.[0], 0);
+    const resolvedSeriesDash = resolveDash(seriesProps?.borderDash, radarSeriesDashCtx);
+    const resolvedSeriesDashOffset = resolveAccessor(seriesProps?.borderDashOffset, radarSeriesDashCtx, { arrayMode: "clip", fallback: 0 }) ?? 0;
+    const borderDashPattern = resolvedSeriesDash && resolvedSeriesDash.length > 0 ? resolvedSeriesDash : [];
+    if (borderColor && borderWidth > 0 && borderAlign === "center") {
+      traceOuterPath();
+      ctx.strokeStyle = borderColor;
+      ctx.lineWidth = sd.lineStrokeWidth + borderWidth * 2;
+      ctx.lineJoin = seriesProps?.borderJoinStyle ?? "round";
+      ctx.setLineDash(borderDashPattern);
+      if (resolvedSeriesDashOffset) ctx.lineDashOffset = resolvedSeriesDashOffset;
+      ctx.stroke();
+      ctx.setLineDash([]);
+      ctx.lineDashOffset = 0;
+    }
+    traceOuterPath();
+    ctx.strokeStyle = resolvedStroke;
+    ctx.lineWidth = sd.lineStrokeWidth;
+    ctx.lineJoin = "round";
+    const dashArray = sd.lineDash ?? (sd.lineStyle === "dashed" ? [6, 4] : sd.lineStyle === "dotted" ? [2, 3] : []);
+    ctx.setLineDash(dashArray);
+    ctx.stroke();
+    if (borderColor && borderWidth > 0 && borderAlign === "inner") {
+      ctx.save();
+      traceOuterPath();
+      ctx.clip();
+      traceOuterPath();
+      ctx.strokeStyle = borderColor;
+      ctx.lineWidth = borderWidth * 2;
+      ctx.lineJoin = seriesProps?.borderJoinStyle ?? "round";
+      ctx.setLineDash(borderDashPattern);
+      if (resolvedSeriesDashOffset) ctx.lineDashOffset = resolvedSeriesDashOffset;
+      ctx.stroke();
+      ctx.restore();
+      ctx.setLineDash([]);
+      ctx.lineDashOffset = 0;
+    }
+  });
+  const showMarkers = seriesProps?.showMarkers !== false;
+  const dataArrCanvas = seriesProps?.data;
+  const ptValueCanvas = (idx) => sd.points[idx]?.value;
+  const ptCategoryCanvas = (idx) => layout.categories[sd.points[idx]?.categoryIndex ?? idx];
+  const seriesExtras = { seriesIndex, seriesId: sd.id ?? "" };
+  const resolveMarkerSize = (idx) => resolveAccessor(seriesProps?.markerSize, makeItemContext(dataArrCanvas?.[idx], idx, { value: ptValueCanvas(idx), category: ptCategoryCanvas(idx), ...seriesExtras }), {
+    arrayMode: "clip",
+    fallback: DEFAULT_LINE_MARKER_SIZE
+  }) ?? DEFAULT_LINE_MARKER_SIZE;
+  const resolveMarkerHoverColorCanvas = (idx) => {
+    const v = resolveAccessor(seriesProps?.hoverColor, makeItemContext(dataArrCanvas?.[idx], idx, { value: ptValueCanvas(idx), category: ptCategoryCanvas(idx), ...seriesExtras }), { arrayMode: "cycle" });
+    return typeof v === "string" ? v : v ? getPrimaryColor(v) : void 0;
+  };
+  const resolveMarkerHoverBorderColorCanvas = (idx) => {
+    const v = resolveAccessor(seriesProps?.hoverBorderColor, makeItemContext(dataArrCanvas?.[idx], idx, { value: ptValueCanvas(idx), category: ptCategoryCanvas(idx), ...seriesExtras }), { arrayMode: "cycle" });
+    return typeof v === "string" ? v : v ? getPrimaryColor(v) : void 0;
+  };
+  const resolveMarkerShapeCanvas = (idx, size) => resolveAccessor(seriesProps?.markerShape, makeItemContext(dataArrCanvas?.[idx], idx, { size, value: ptValueCanvas(idx), category: ptCategoryCanvas(idx), ...seriesExtras }), { arrayMode: "clip" }) ?? "circle";
+  const resolvePointRotationCanvas = (idx) => resolveAccessor(seriesProps?.pointRotation, makeItemContext(dataArrCanvas?.[idx], idx, { value: ptValueCanvas(idx), category: ptCategoryCanvas(idx), ...seriesExtras }), { arrayMode: "clip", fallback: 0 }) ?? 0;
+  const anyPointHoveredCanvas = isSharedHover ? sharedAxisIdx !== null : isSeriesHovered && hoverState.index !== null;
+  if (showMarkers || anyPointHoveredCanvas) {
+    for (let pi = 0; pi < sd.points.length; pi++) {
+      const pt = sd.points[pi];
+      const isPointHovered = isSharedHover ? pi === sharedAxisIdx : isSeriesHovered && hoverState.index === pi;
+      if (!showMarkers && !isPointHovered) continue;
+      const ptMarkerSize = resolveMarkerSize(pi);
+      const pointR = isPointHovered ? ptMarkerSize * (effectConfig?.hoverRadiusMultiplier ?? DEFAULT_HOVER_POINT_RADIUS_MULTIPLIER) : ptMarkerSize;
+      let ptColor = sd.gradientColor ? sampleGradientAt(sd.gradientColor, pt, layout.center, layout.radius) : strokeColor;
+      if (isPointHovered) {
+        const ptHoverColor = resolveMarkerHoverColorCanvas(pi);
+        if (ptHoverColor) {
+          ptColor = ptHoverColor;
+        } else if (effectConfig?.hoverBrightness && effectConfig.hoverBrightness !== 1) {
+          ptColor = adjustBrightness(ptColor, effectConfig.hoverBrightness);
+        }
+      }
+      const ptHoverBorderColorCanvas = isPointHovered ? resolveMarkerHoverBorderColorCanvas(pi) : void 0;
+      if (!seriesProps?.renderMarker) {
+        drawMarkerCanvas(ctx, {
+          x: pt.x,
+          y: pt.y,
+          size: pointR,
+          shape: resolveMarkerShapeCanvas(pi, pointR),
+          fillStyle: ptColor,
+          strokeStyle: ptHoverBorderColorCanvas ?? seriesProps?.pointBorderColor ?? ptColor,
+          lineStrokeWidth: resolveAccessor(seriesProps?.pointBorderStrokeWidth, makeItemContext(dataArrCanvas?.[pi], pi, { value: pt.value, category: ptCategoryCanvas(pi), ...seriesExtras }), { arrayMode: "clip", fallback: 0 }) ?? 0,
+          opacity: seriesOpacity,
+          lineDash: resolveDash(seriesProps?.pointBorderDash, makeItemContext(dataArrCanvas?.[pi], pi, { value: pt.value, category: ptCategoryCanvas(pi), ...seriesExtras })),
+          lineDashOffset: resolveAccessor(seriesProps?.pointBorderDashOffset, makeItemContext(dataArrCanvas?.[pi], pi, { value: pt.value, category: ptCategoryCanvas(pi), ...seriesExtras }), { arrayMode: "clip", fallback: 0 }) ?? 0,
+          lineJoin: seriesProps?.pointBorderJoinStyle,
+          rotation: resolvePointRotationCanvas(pi)
+        });
+      }
+    }
+  }
+}
+
+// src/renderers/radar.renderer.ts
+function hitTestRadar(x, y, layout, theme) {
+  let closest = null;
+  let minDist = DEFAULT_RADAR_HIT_RADIUS;
+  for (const sd of layout.series) {
+    if (!sd.visible) continue;
+    for (let pi = 0; pi < sd.points.length; pi++) {
+      const pt = sd.points[pi];
+      const dx = x - pt.x;
+      const dy = y - pt.y;
+      const dist = Math.sqrt(dx * dx + dy * dy);
+      if (dist < minDist) {
+        minDist = dist;
+        closest = {
+          datasetId: sd.id,
+          index: pi,
+          label: layout.categories[pi] ?? "",
+          value: pt.value,
+          color: sd.color ?? (sd.gradientColor ? getPrimaryColor(sd.gradientColor) : getDefaultColor(sd.seriesIdx, theme)),
+          colorGradient: sd.gradientColor,
+          swatchColor: resolveSwatchColor({ color: sd.color ?? sd.gradientColor }, sd.seriesIdx, void 0, theme)
+        };
+      }
+    }
+  }
+  return closest;
+}
+
+// src/series/polar/geometry.ts
+function resolveBorderProps(props, item, index, value, category, seriesIndex, seriesId) {
+  const borderColor = typeof props.borderColor === "string" ? props.borderColor : void 0;
+  const borderStrokeWidth = typeof props.borderStrokeWidth === "number" ? props.borderStrokeWidth : void 0;
+  const borderRadius = typeof props.borderRadius === "number" ? props.borderRadius : void 0;
+  const ctx = makeItemContext(item, index, { value: value ?? null, category, seriesIndex: seriesIndex ?? 0, seriesId: seriesId ?? "" });
+  const borderDash = resolveDash(props.borderDash, ctx);
+  const borderDashOffset = resolveAccessor(props.borderDashOffset, ctx, { arrayMode: "clip" });
+  const hoverColorResolved = resolveAccessor(props.hoverColor, ctx, { arrayMode: "cycle" });
+  const hoverBorderColorResolved = resolveAccessor(props.hoverBorderColor, ctx, { arrayMode: "cycle" });
+  const hoverColor = typeof hoverColorResolved === "string" ? hoverColorResolved : hoverColorResolved ? getPrimaryColor(hoverColorResolved) : void 0;
+  const hoverBorderColor = typeof hoverBorderColorResolved === "string" ? hoverBorderColorResolved : hoverBorderColorResolved ? getPrimaryColor(hoverBorderColorResolved) : void 0;
+  const opacity = props.opacity !== void 0 ? resolveAccessor(props.opacity, ctx, { arrayMode: "clip" }) ?? void 0 : void 0;
+  if (!borderColor && !borderStrokeWidth && !borderRadius && !borderDash && borderDashOffset === void 0 && !hoverColor && !hoverBorderColor && opacity === void 0) return {};
+  return { borderColor, borderStrokeWidth, borderRadius, borderDash, borderDashOffset, hoverColor, hoverBorderColor, opacity };
+}
+function calculatePolarLayout(datasets, chartArea, stackConfig, globalFont, sharedCategories, sharedDomain) {
+  const categories = sharedCategories ?? extractCategories(datasets);
+  const categoryCount = categories.length;
+  const angleStep = categoryCount > 0 ? 360 / categoryCount : 0;
+  const firstProps = datasets[0]?.props;
+  const innerRadiusRatio = firstProps?.innerRadius ?? 0;
+  const allValues = [];
+  const visibleDatasets = datasets.filter((ds) => ds.visible);
+  const globalDatasetIndex = new Map(visibleDatasets.map((ds) => [ds.id, datasets.indexOf(ds)]));
+  const isStacked = visibleDatasets.some((ds) => ds.props.stackId !== void 0);
+  const categoryValuesByDataset = [];
+  const keysByDataset = [];
+  for (const ds of visibleDatasets) {
+    const values = resolveValues(ds.props);
+    categoryValuesByDataset.push(values);
+    allValues.push(...values);
+    keysByDataset.push(ds.props.keyField && ds.props.data ? batchResolveRequired(ds.props.keyField, ds.props.data, "keyField") : []);
+  }
+  const visibleIndexById = new Map(visibleDatasets.map((ds, i) => [ds.id, i]));
+  const keysById = /* @__PURE__ */ new Map();
+  for (let i = 0; i < visibleDatasets.length; i++) keysById.set(visibleDatasets[i].id, keysByDataset[i]);
+  for (const ds of datasets) {
+    if (keysById.has(ds.id)) continue;
+    keysById.set(ds.id, ds.props.keyField && ds.props.data ? batchResolveRequired(ds.props.keyField, ds.props.data, "keyField") : []);
+  }
+  const sortProp = firstProps?.sort;
+  const originalCategoryIndices = categories.map((_, i) => i);
+  if (sortProp && categories.length > 0) {
+    const sortIndices = categories.map((_, i) => i);
+    if (sortProp === "label-asc") {
+      sortIndices.sort((a, b) => categories[a].localeCompare(categories[b]));
+    } else if (sortProp === "label-desc") {
+      sortIndices.sort((a, b) => categories[b].localeCompare(categories[a]));
+    } else {
+      const sums = categories.map((_, ci) => categoryValuesByDataset.reduce((s, vals) => s + (vals[ci] ?? 0), 0));
+      if (sortProp === "value-asc") sortIndices.sort((a, b) => sums[a] - sums[b]);
+      else sortIndices.sort((a, b) => sums[b] - sums[a]);
+    }
+    const sortedCategories = sortIndices.map((i) => categories[i]);
+    const sortedValues = categoryValuesByDataset.map((vals) => sortIndices.map((i) => vals[i] ?? 0));
+    categories.splice(0, categories.length, ...sortedCategories);
+    for (let di = 0; di < categoryValuesByDataset.length; di++) {
+      categoryValuesByDataset[di] = sortedValues[di];
+    }
+    for (let ci = 0; ci < sortIndices.length; ci++) {
+      originalCategoryIndices[ci] = sortIndices[ci];
+    }
+  }
+  let domain;
+  let rawDataMax = 0;
+  if (sharedDomain) {
+    domain = sharedDomain;
+    rawDataMax = sharedDomain[1];
+  } else if (isStacked && stackConfig?.mode !== "percent") {
+    const categoryTotals = [];
+    for (let ci = 0; ci < categoryCount; ci++) {
+      let total = 0;
+      for (const values of categoryValuesByDataset) {
+        total += values[ci] ?? 0;
+      }
+      categoryTotals.push(total);
+    }
+    rawDataMax = categoryTotals.length > 0 ? Math.max(...categoryTotals) : 0;
+    domain = calculateNiceDomain(categoryTotals, { includeZero: true, nice: true });
+  } else if (isStacked && stackConfig?.mode === "percent") {
+    domain = [0, 100];
+    rawDataMax = 100;
+  } else {
+    rawDataMax = allValues.length > 0 ? Math.max(...allValues) : 0;
+    domain = calculateNiceDomain(allValues, { includeZero: true, nice: true });
+  }
+  const resolvedLabelFontSize = resolveFontSize(DEFAULT_RADIAL_LABEL_FONT_SIZE, globalFont);
+  const resolvedFontFamily = resolveFontFamily(void 0, globalFont);
+  const labelPadding = measureText("Xg", resolvedLabelFontSize).height;
+  const labelMargins = calculateLabelMargins(categories, angleStep, labelPadding, resolvedLabelFontSize);
+  const adjustedArea = {
+    x: chartArea.x + labelMargins.left,
+    y: chartArea.y + labelMargins.top,
+    width: Math.max(0, chartArea.width - labelMargins.left - labelMargins.right),
+    height: Math.max(0, chartArea.height - labelMargins.top - labelMargins.bottom)
+  };
+  const { center, radius: maxRadius } = calculateRadiusAndCenter(adjustedArea);
+  const levelValues = generateNiceTicks(domain[0], domain[1]);
+  const firstTick = levelValues[0] ?? domain[0];
+  const lastTick = levelValues[levelValues.length - 1] ?? domain[1];
+  domain = [Math.min(domain[0], firstTick), Math.max(domain[1], lastTick)];
+  const levelRadii = levelValues.map((v) => {
+    if (domain[1] === domain[0]) return 0;
+    return (v - domain[0]) / (domain[1] - domain[0]) * maxRadius;
+  });
+  const grid = {
+    shape: "circle",
+    levels: levelValues.length,
+    levelValues,
+    levelRadii
+  };
+  const spokeEndpoints = [];
+  for (let i = 0; i < categoryCount; i++) {
+    const angleDeg = -90 + i * angleStep;
+    const angleRad = toRad(angleDeg);
+    spokeEndpoints.push({
+      x: center.x + Math.cos(angleRad) * maxRadius,
+      y: center.y + Math.sin(angleRad) * maxRadius
+    });
+  }
+  const bars = [];
+  const baseInnerRadius = innerRadiusRatio * maxRadius;
+  const availableRadius = maxRadius - baseInnerRadius;
+  const gapPx = firstProps?.spacing ?? DEFAULT_POLAR_GAP_PX;
+  const gapDeg = maxRadius > 0 ? gapPx / maxRadius * (180 / Math.PI) : 0;
+  if (isStacked) {
+    for (let ci = 0; ci < categoryCount; ci++) {
+      const sectorStart = -90 + ci * angleStep;
+      const barStart = sectorStart + gapDeg / 2;
+      const barEnd = sectorStart + angleStep - gapDeg / 2;
+      let categoryTotal = 0;
+      if (stackConfig?.mode === "percent") {
+        for (const values of categoryValuesByDataset) {
+          categoryTotal += values[ci] ?? 0;
+        }
+      }
+      let currentInner = baseInnerRadius;
+      for (const ds of datasets) {
+        const dsSeriesIdx = globalDatasetIndex.get(ds.id) ?? datasets.indexOf(ds);
+        if (!ds.visible) {
+          if (ds.props.stackId === void 0) continue;
+          const color2 = resolveBarColor(ds.props, originalCategoryIndices[ci], dsSeriesIdx, ds.props.data?.[originalCategoryIndices[ci]], 0, categories[ci], ds.id ?? "");
+          const border2 = resolveBorderProps(ds.props, ds.props.data?.[originalCategoryIndices[ci]], originalCategoryIndices[ci], 0, categories[ci], dsSeriesIdx, ds.id ?? "");
+          bars.push({
+            datasetId: ds.id,
+            name: ds.props.name,
+            category: categories[ci],
+            categoryIndex: ci,
+            dataIndex: ci,
+            dataKey: keysById.get(ds.id)?.[ci],
+            startAngle: barStart,
+            endAngle: barEnd,
+            innerRadius: currentInner,
+            outerRadius: currentInner,
+            value: 0,
+            color: color2,
+            seriesIdx: dsSeriesIdx,
+            hidden: true,
+            ...border2
+          });
+          continue;
+        }
+        const rawValue = categoryValuesByDataset[visibleIndexById.get(ds.id)][ci] ?? 0;
+        let valueRadius;
+        if (stackConfig?.mode === "percent" && categoryTotal > 0) {
+          const pct = rawValue / categoryTotal * 100;
+          valueRadius = pct / (domain[1] - domain[0]) * availableRadius;
+        } else {
+          valueRadius = domain[1] === domain[0] ? 0 : rawValue / (domain[1] - domain[0]) * availableRadius;
+        }
+        const outerRadius = currentInner + valueRadius;
+        const color = resolveBarColor(ds.props, originalCategoryIndices[ci], dsSeriesIdx, ds.props.data?.[originalCategoryIndices[ci]], rawValue, categories[ci], ds.id ?? "");
+        const border = resolveBorderProps(ds.props, ds.props.data?.[originalCategoryIndices[ci]], originalCategoryIndices[ci], rawValue, categories[ci], dsSeriesIdx, ds.id ?? "");
+        bars.push({
+          datasetId: ds.id,
+          name: ds.props.name,
+          category: categories[ci],
+          categoryIndex: ci,
+          dataIndex: ci,
+          dataKey: keysById.get(ds.id)?.[ci],
+          startAngle: barStart,
+          endAngle: barEnd,
+          innerRadius: currentInner,
+          outerRadius,
+          value: rawValue,
+          color,
+          seriesIdx: dsSeriesIdx,
+          ...border
+        });
+        currentInner = outerRadius;
+      }
+    }
+  } else if (visibleDatasets.length > 1) {
+    const datasetCount = visibleDatasets.length;
+    const sectorWidth = angleStep - gapDeg;
+    const subBarWidth = sectorWidth / datasetCount;
+    for (let ci = 0; ci < categoryCount; ci++) {
+      const sectorStart = -90 + ci * angleStep + gapDeg / 2;
+      for (let di = 0; di < visibleDatasets.length; di++) {
+        const ds = visibleDatasets[di];
+        const rawValue = categoryValuesByDataset[di][ci] ?? 0;
+        const valueRadius = domain[1] === domain[0] ? 0 : (rawValue - domain[0]) / (domain[1] - domain[0]) * availableRadius;
+        const dsSeriesIdx = globalDatasetIndex.get(ds.id);
+        const color = resolveBarColor(ds.props, originalCategoryIndices[ci], dsSeriesIdx, ds.props.data?.[originalCategoryIndices[ci]], rawValue, categories[ci], ds.id ?? "");
+        const border = resolveBorderProps(ds.props, ds.props.data?.[originalCategoryIndices[ci]], originalCategoryIndices[ci], rawValue, categories[ci], dsSeriesIdx, ds.id ?? "");
+        bars.push({
+          datasetId: ds.id,
+          name: ds.props.name,
+          category: categories[ci],
+          categoryIndex: ci,
+          dataIndex: ci,
+          dataKey: keysByDataset[di]?.[ci],
+          startAngle: sectorStart + di * subBarWidth,
+          endAngle: sectorStart + (di + 1) * subBarWidth,
+          innerRadius: baseInnerRadius,
+          outerRadius: baseInnerRadius + valueRadius,
+          value: rawValue,
+          color,
+          seriesIdx: dsSeriesIdx,
+          ...border
+        });
+      }
+    }
+  } else {
+    const ds = visibleDatasets[0];
+    if (ds) {
+      const values = categoryValuesByDataset[0];
+      for (let ci = 0; ci < categoryCount; ci++) {
+        const sectorStart = -90 + ci * angleStep;
+        const rawValue = values[ci] ?? 0;
+        const valueRadius = domain[1] === domain[0] ? 0 : (rawValue - domain[0]) / (domain[1] - domain[0]) * availableRadius;
+        const dsSeriesIdx = globalDatasetIndex.get(ds.id);
+        const color = resolveBarColor(ds.props, originalCategoryIndices[ci], dsSeriesIdx, ds.props.data?.[originalCategoryIndices[ci]], rawValue, categories[ci], ds.id ?? "");
+        const border = resolveBorderProps(ds.props, ds.props.data?.[originalCategoryIndices[ci]], originalCategoryIndices[ci], rawValue, categories[ci], dsSeriesIdx, ds.id ?? "");
+        bars.push({
+          datasetId: ds.id,
+          name: ds.props.name,
+          category: categories[ci],
+          categoryIndex: ci,
+          dataIndex: ci,
+          dataKey: keysByDataset[0]?.[ci],
+          startAngle: sectorStart + gapDeg / 2,
+          endAngle: sectorStart + angleStep - gapDeg / 2,
+          innerRadius: baseInnerRadius,
+          outerRadius: baseInnerRadius + valueRadius,
+          value: rawValue,
+          color,
+          seriesIdx: dsSeriesIdx,
+          ...border
+        });
+      }
+    }
+  }
+  const gradientColors = /* @__PURE__ */ new Map();
+  for (const ds of visibleDatasets) {
+    const c = ds.props.color;
+    if (c != null && typeof c === "object" && !Array.isArray(c) && typeof c !== "function" && isGradientColor(c)) {
+      gradientColors.set(ds.id, c);
+    }
+  }
+  return {
+    center,
+    maxRadius,
+    innerRadiusRatio,
+    categories,
+    angleStep,
+    domain,
+    grid,
+    bars,
+    spokeEndpoints,
+    chartArea,
+    labelPadding,
+    labelFontSize: resolvedLabelFontSize,
+    fontFamily: resolvedFontFamily,
+    gradientColors,
+    rawDataMax
+  };
+}
+function hitTestPolar(x, y, layout, theme) {
+  const relX = x - layout.center.x;
+  const relY = y - layout.center.y;
+  for (let i = layout.bars.length - 1; i >= 0; i--) {
+    const bar = layout.bars[i];
+    if (bar.outerRadius <= bar.innerRadius) continue;
+    const hit = isPointInSlice(relX, relY, { rotation: bar.startAngle, endAngle: bar.endAngle }, bar.outerRadius, bar.innerRadius);
+    if (hit) {
+      const gradColor = layout.gradientColors.get(bar.datasetId);
+      return {
+        datasetId: bar.datasetId,
+        index: bar.categoryIndex,
+        label: layout.categories[bar.categoryIndex] ?? "",
+        value: bar.value,
+        color: bar.color ?? getDefaultColor(bar.seriesIdx, theme),
+        colorGradient: gradColor,
+        swatchColor: resolveSwatchColor({ color: bar.color ?? gradColor }, bar.seriesIdx, void 0, theme)
+      };
+    }
+  }
+  return null;
+}
+function resolveBarColor(props, categoryIndex, datasetIndex, dataItem, value, category, seriesId) {
+  if (props.color == null) return void 0;
+  const color = resolveAccessor(props.color, makeItemContext(dataItem, categoryIndex, { value: value ?? null, category, seriesIndex: datasetIndex, seriesId: seriesId ?? "" }));
+  return typeof color === "string" ? color : void 0;
+}
+
+export { calculateLabelMargins, calculatePolarLayout, calculateRadarLayout, computeRadialComboContext, extractCategories, getCategoryLabelAnchor, hitTestPolar, hitTestRadar, renderRadarSeriesCanvas, renderRadarSeriesSvg, resolveValues };