@primeui/chart-core 0.0.1-alpha.1

package/dist/chunk-HDFGCN2F.mjs

@@ -0,0 +1,132 @@
+// src/series/line/shared.ts
+var DEFAULT_TENSION = 0.5;
+function createSvgLinePathBuilder() {
+  const parts = [];
+  return {
+    moveTo: (x, y) => parts.push(`M ${x} ${y}`),
+    lineTo: (x, y) => parts.push(`L ${x} ${y}`),
+    bezierCurveTo: (cp1x, cp1y, cp2x, cp2y, x, y) => parts.push(`C ${cp1x} ${cp1y} ${cp2x} ${cp2y} ${x} ${y}`),
+    closePath: () => parts.push("Z"),
+    build: () => parts.join(" ")
+  };
+}
+function createCanvasLinePathBuilder(ctx) {
+  return {
+    moveTo: (x, y) => ctx.moveTo(x, y),
+    lineTo: (x, y) => ctx.lineTo(x, y),
+    bezierCurveTo: (cp1x, cp1y, cp2x, cp2y, x, y) => ctx.bezierCurveTo(cp1x, cp1y, cp2x, cp2y, x, y),
+    closePath: () => ctx.closePath()
+  };
+}
+function traceLinear(builder, points) {
+  for (let i = 1; i < points.length; i++) {
+    builder.lineTo(points[i].x, points[i].y);
+  }
+}
+function traceStepBefore(builder, points) {
+  for (let i = 1; i < points.length; i++) {
+    builder.lineTo(points[i - 1].x, points[i].y);
+    builder.lineTo(points[i].x, points[i].y);
+  }
+}
+function traceStepAfter(builder, points) {
+  for (let i = 1; i < points.length; i++) {
+    builder.lineTo(points[i].x, points[i - 1].y);
+    builder.lineTo(points[i].x, points[i].y);
+  }
+}
+function traceStepCenter(builder, points) {
+  for (let i = 1; i < points.length; i++) {
+    const mid = (points[i - 1].x + points[i].x) / 2;
+    builder.lineTo(mid, points[i - 1].y);
+    builder.lineTo(mid, points[i].y);
+    builder.lineTo(points[i].x, points[i].y);
+  }
+}
+function traceSmooth(builder, points) {
+  const n = points.length;
+  if (n < 2) return;
+  const slopes = new Array(n - 1);
+  for (let i = 0; i < n - 1; i++) {
+    const dx = points[i + 1].x - points[i].x;
+    slopes[i] = dx !== 0 ? (points[i + 1].y - points[i].y) / dx : 0;
+  }
+  const tangents = new Array(n);
+  tangents[0] = slopes[0];
+  tangents[n - 1] = slopes[n - 2];
+  for (let i = 1; i < n - 1; i++) {
+    tangents[i] = (slopes[i - 1] + slopes[i]) / 2;
+  }
+  for (let i = 0; i < n - 1; i++) {
+    const d = slopes[i];
+    if (d === 0) {
+      tangents[i] = 0;
+      tangents[i + 1] = 0;
+    } else {
+      const alpha = tangents[i] / d;
+      const beta = tangents[i + 1] / d;
+      const sqNorm = alpha * alpha + beta * beta;
+      if (sqNorm > 9) {
+        const scale = 3 / Math.sqrt(sqNorm);
+        tangents[i] = scale * alpha * d;
+        tangents[i + 1] = scale * beta * d;
+      }
+    }
+  }
+  for (let i = 0; i < n - 1; i++) {
+    const p0 = points[i];
+    const p1 = points[i + 1];
+    const dx = (p1.x - p0.x) / 3;
+    builder.bezierCurveTo(p0.x + dx, p0.y + tangents[i] * dx, p1.x - dx, p1.y - tangents[i + 1] * dx, p1.x, p1.y);
+  }
+}
+function traceSpline(builder, points, tension) {
+  const n = points.length;
+  if (n < 2) return;
+  const k = tension / 3;
+  for (let i = 0; i < n - 1; i++) {
+    const p0 = i > 0 ? points[i - 1] : points[0];
+    const p1 = points[i];
+    const p2 = points[i + 1];
+    const p3 = i < n - 2 ? points[i + 2] : points[n - 1];
+    builder.bezierCurveTo(p1.x + (p2.x - p0.x) * k, p1.y + (p2.y - p0.y) * k, p2.x + (p1.x - p3.x) * k, p2.y + (p1.y - p3.y) * k, p2.x, p2.y);
+  }
+}
+function invertCurveForReverse(curve) {
+  if (curve === "step-before") return "step-after";
+  if (curve === "step-after") return "step-before";
+  return curve;
+}
+function traceCurve(builder, points, curve, tension = DEFAULT_TENSION) {
+  if (points.length < 2) return;
+  switch (curve) {
+    case "smooth":
+      return traceSmooth(builder, points);
+    case "spline":
+      return traceSpline(builder, points, tension);
+    case "step-before":
+      return traceStepBefore(builder, points);
+    case "step-after":
+      return traceStepAfter(builder, points);
+    case "step":
+      return traceStepCenter(builder, points);
+    default:
+      return traceLinear(builder, points);
+  }
+}
+var _stackBaseEdge = [];
+function reversedBaseEdge(points) {
+  const n = points.length;
+  const buf = _stackBaseEdge;
+  while (buf.length < n) buf.push({ x: 0, y: 0, dataIndex: 0, value: 0, visible: true, category: "" });
+  if (buf.length > n) buf.length = n;
+  for (let i = 0; i < n; i++) {
+    const src = points[n - 1 - i];
+    const dst = buf[i];
+    dst.x = src.x;
+    dst.y = src.baseY ?? src.y;
+  }
+  return buf;
+}
+
+export { createCanvasLinePathBuilder, createSvgLinePathBuilder, invertCurveForReverse, reversedBaseEdge, traceCurve };

package/dist/chunk-IEGLX7VL.mjs

@@ -0,0 +1,42 @@
+// src/utils/render/path.utils.ts
+function createSvgPathBuilder() {
+  const parts = [];
+  return {
+    moveTo: (x, y) => parts.push(`M ${x} ${y}`),
+    lineTo: (x, y) => parts.push(`L ${x} ${y}`),
+    bezierCurveTo: (cp1x, cp1y, cp2x, cp2y, x, y) => parts.push(`C ${cp1x} ${cp1y} ${cp2x} ${cp2y} ${x} ${y}`),
+    closePath: () => parts.push("Z"),
+    build: () => parts.join(" ")
+  };
+}
+function createCanvasPathBuilder(ctx) {
+  return {
+    moveTo: (x, y) => ctx.moveTo(x, y),
+    lineTo: (x, y) => ctx.lineTo(x, y),
+    bezierCurveTo: (cp1x, cp1y, cp2x, cp2y, x, y) => ctx.bezierCurveTo(cp1x, cp1y, cp2x, cp2y, x, y),
+    closePath: () => ctx.closePath()
+  };
+}
+function traceClosedSpline(builder, points, tension = 0.3) {
+  const n = points.length;
+  if (n < 3) {
+    for (let i = 0; i < n; i++) {
+      if (i === 0) builder.moveTo(points[i].x, points[i].y);
+      else builder.lineTo(points[i].x, points[i].y);
+    }
+    builder.closePath();
+    return;
+  }
+  const k = tension / 3;
+  builder.moveTo(points[0].x, points[0].y);
+  for (let i = 0; i < n; i++) {
+    const p0 = points[(i - 1 + n) % n];
+    const p1 = points[i];
+    const p2 = points[(i + 1) % n];
+    const p3 = points[(i + 2) % n];
+    builder.bezierCurveTo(p1.x + (p2.x - p0.x) * k, p1.y + (p2.y - p0.y) * k, p2.x + (p1.x - p3.x) * k, p2.y + (p1.y - p3.y) * k, p2.x, p2.y);
+  }
+  builder.closePath();
+}
+
+export { createCanvasPathBuilder, createSvgPathBuilder, traceClosedSpline };

package/dist/chunk-ILUWFYGY.mjs

@@ -0,0 +1,220 @@
+import { MARKER_SHAPE_NAMES, renderMarkerShapeSvg } from './chunk-PRDVPOZX.mjs';
+import { formatPointDescription } from './chunk-OGJ6IIBW.mjs';
+import { DEFAULT_HOVER_POINT_RADIUS_MULTIPLIER, DEFAULT_LINE_MARKER_SIZE } from './chunk-NKUYIWAP.mjs';
+import { createSvgGradientFromColor, makeItemContext, resolveDash, resolveAccessor, getPrimaryColor } from './chunk-O2X6FF45.mjs';
+import { createSvgPathBuilder, traceClosedSpline } from './chunk-IEGLX7VL.mjs';
+import { createSvgGroup, setAttr, adjustBrightness, createSvgDefs, appendChild, prependChild, svgClass, createSvgPath, svgNode } from './chunk-SSLTFJ3U.mjs';
+
+// src/series/radar/shared.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(" ");
+}
+
+// src/series/radar/svg/index.ts
+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];
+  const areaEl = createSvgPath(fillPathD, {
+    fill: fillValue ?? themedSeriesColor,
+    "fill-opacity": sd.fillOpacity * seriesOpacity,
+    "fill-rule": isStacked ? "evenodd" : "nonzero",
+    stroke: "none",
+    class: fillAreaCls
+  });
+  setAttr(areaEl, "data-layer", "area");
+  appendChild(group, areaEl);
+  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"
+    };
+    if (borderDash && borderDash.length > 0) borderAttrs["stroke-dasharray"] = borderDash.join(" ");
+    if (borderDashOffset) borderAttrs["stroke-dashoffset"] = borderDashOffset;
+    const centerBorderEl = createSvgPath(outerPathD, borderAttrs);
+    setAttr(centerBorderEl, "data-layer", "center-border");
+    appendChild(group, centerBorderEl);
+  }
+  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");
+  const lineEl = createSvgPath(outerPathD, {
+    fill: "none",
+    stroke: strokeValue ?? themedSeriesColor,
+    "stroke-width": sd.lineStrokeWidth,
+    "stroke-opacity": seriesOpacity,
+    "stroke-linejoin": "round",
+    class: strokeLineCls,
+    ...dashAttrs
+  });
+  setAttr(lineEl, "data-layer", "line");
+  appendChild(group, lineEl);
+  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();
+    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})`
+    };
+    if (borderDash && borderDash.length > 0) borderAttrs["stroke-dasharray"] = borderDash.join(" ");
+    if (borderDashOffset) borderAttrs["stroke-dashoffset"] = borderDashOffset;
+    const innerBorderEl = createSvgPath(outerPathD, borderAttrs);
+    setAttr(innerBorderEl, "data-layer", "inner-border");
+    appendChild(group, innerBorderEl);
+  }
+  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 resolvePointRotation = (idx) => resolveAccessor(seriesProps?.pointRotation, makeItemContext(dataArr?.[idx], idx, { value: ptValue(idx), category: ptCategory(idx), ...seriesExtras }), { arrayMode: "clip", fallback: 0 }) ?? 0;
+    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";
+    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);
+      }
+      setAttr(markerEl, "data-index", String(pi));
+      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);
+      }
+      appendChild(group, markerEl);
+    }
+  }
+  return group;
+}
+
+export { renderRadarSeriesSvg };

package/dist/chunk-IXOWSEHO.mjs

@@ -0,0 +1,114 @@
+import { computeSliceRenderStates } from './chunk-53HW45JB.mjs';
+import { buildSvgArcPath, CLIP_PIXEL_MARGIN } from './chunk-LVMDQ4OJ.mjs';
+import { formatPointDescription } from './chunk-OGJ6IIBW.mjs';
+import { FIELD_DEFAULTS, batchResolveAccessor, isGradientColor, remapStopsForDonut, createSvgGradientFromColor } from './chunk-O2X6FF45.mjs';
+import { createSvgGroup, createSvgDefs, setAttr, appendChild, svgClass, svgNode, createSvgPath, prependChild } from './chunk-SSLTFJ3U.mjs';
+import { toRad } from './chunk-RQ3CKQOX.mjs';
+
+// src/series/pie/svg/index.ts
+function renderPieSvg(props, layout, context) {
+  const renderStates = computeSliceRenderStates(props, layout, context.theme);
+  const { slices: sliceStates, center, outerRadius, innerRadius, isFullCircle: fullCircle } = renderStates;
+  const borderJoinStyle = props.borderJoinStyle ?? "miter";
+  const borderAlign = props.borderAlign ?? "inner";
+  const group = createSvgGroup(`translate(${center.x}, ${center.y})`);
+  const defs = createSvgDefs();
+  let hasDefs = false;
+  const dsIdx = layout.datasetIndex;
+  const a11y = context.accessibility;
+  const a11yEnabled = !!(a11y?.enabled && layout.visibleSlices.length <= (a11y.pointDescriptionThreshold ?? 200));
+  const categoryAccessor = props.categoryField ?? props.labelField ?? FIELD_DEFAULTS.categoryField;
+  const a11yLabels = a11yEnabled && categoryAccessor ? batchResolveAccessor(categoryAccessor, props.data) : [];
+  const total = layout.visibleSlices.reduce((sum, s) => sum + s.value, 0);
+  for (const state of sliceStates) {
+    const { slice, dataIndex, effectBorderColor, effectBorderWidth, effectBorderDash, effectBorderDashOffset, userFill, isHovered, isInactive, offset, scale, arcConfig } = state;
+    const { dx, dy } = offset;
+    const colorClassN = `p-chart-color-${dataIndex % 10}`;
+    const parts = [];
+    if (dx !== 0 || dy !== 0) parts.push(`translate(${dx}, ${dy})`);
+    if (scale !== 1) parts.push(`scale(${scale})`);
+    const sliceGroup = createSvgGroup(parts.length > 0 ? parts.join(" ") : void 0);
+    setAttr(sliceGroup, "data-slice-index", dataIndex);
+    setAttr(sliceGroup, "data-index", dataIndex);
+    if (a11yEnabled) {
+      const label = a11yLabels[dataIndex] ?? `Slice ${dataIndex + 1}`;
+      const desc = formatPointDescription({ category: label, value: slice.value, seriesName: props.name ?? "Chart", index: dataIndex, total, percentage: slice.percentage }, a11y.pointDescriptionFormatter);
+      setAttr(sliceGroup, "role", "img");
+      setAttr(sliceGroup, "aria-label", desc);
+    }
+    const pathD = buildSvgArcPath(arcConfig, fullCircle);
+    let fill;
+    if (userFill && isGradientColor(userFill)) {
+      const gradientId = `${context.chartId}-pie-${dsIdx}-grad-${dataIndex}`;
+      const gradientColor = innerRadius > 0 && userFill.radialGradient ? { ...userFill, stops: remapStopsForDonut(userFill.stops, innerRadius / outerRadius) } : userFill;
+      const gradient = createSvgGradientFromColor(gradientColor, gradientId, { x: 0, y: 0 }, outerRadius);
+      appendChild(defs, gradient);
+      hasDefs = true;
+      fill = `url(#${gradientId})`;
+    } else if (typeof userFill === "string") {
+      fill = userFill;
+    }
+    const sliceCls = svgClass("p-chart-arc", `p-chart-series-${dataIndex}`, fill === void 0 && colorClassN, isHovered && "p-chart-point-hover", isInactive && "p-chart-point-inactive");
+    const pathAttrs = {
+      fill: fill ?? context.theme.series[dataIndex % context.theme.series.length],
+      "data-index": dataIndex,
+      class: sliceCls
+    };
+    const hasBorder = effectBorderWidth > 0 && effectBorderColor !== "transparent";
+    const PIXEL_MARGIN = CLIP_PIXEL_MARGIN;
+    const angleDelta = arcConfig.outerRadius > 0 ? PIXEL_MARGIN / arcConfig.outerRadius * (180 / Math.PI) : 0;
+    const clipId = `${context.chartId}-pie-${dsIdx}-clip-${dataIndex}`;
+    const clipPathNode = svgNode("clipPath", { id: clipId });
+    const expandedClipPath = buildSvgArcPath(
+      {
+        ...arcConfig,
+        rotation: arcConfig.rotation - angleDelta,
+        endAngle: arcConfig.endAngle + angleDelta
+      },
+      fullCircle
+    );
+    const clipPathEl = createSvgPath(expandedClipPath, {});
+    appendChild(clipPathNode, clipPathEl);
+    appendChild(defs, clipPathNode);
+    hasDefs = true;
+    const fillPath = createSvgPath(pathD, { ...pathAttrs, "data-fill-path": "true" });
+    appendChild(sliceGroup, fillPath);
+    const strokeColor = hasBorder ? typeof effectBorderColor === "string" ? effectBorderColor : context.theme.borderColor : "transparent";
+    const strokeWidth = hasBorder ? borderAlign === "inner" ? effectBorderWidth * 2 : effectBorderWidth : 0;
+    const strokeAttrs = {
+      fill: "none",
+      stroke: strokeColor,
+      "stroke-width": strokeWidth,
+      "stroke-linejoin": borderJoinStyle,
+      "data-stroke-path": "true",
+      "data-clip-id": clipId
+    };
+    if (borderAlign === "inner") {
+      strokeAttrs["clip-path"] = `url(#${clipId})`;
+    }
+    if (hasBorder && effectBorderDash && effectBorderDash.length > 0) {
+      strokeAttrs["stroke-dasharray"] = effectBorderDash.join(" ");
+      if (effectBorderDashOffset > 0) {
+        strokeAttrs["stroke-dashoffset"] = effectBorderDashOffset;
+      }
+    }
+    const strokePath = createSvgPath(pathD, strokeAttrs);
+    appendChild(sliceGroup, strokePath);
+    const valueRadius = (outerRadius + innerRadius) / 2;
+    const midAngle = slice.rotation + (slice.endAngle - slice.rotation) / 2;
+    const contentX = Math.cos(toRad(midAngle)) * valueRadius;
+    const contentY = Math.sin(toRad(midAngle)) * valueRadius;
+    const contentSlot = createSvgGroup(`translate(${contentX}, ${contentY})`, {
+      class: "slice-content",
+      "data-content-index": dataIndex
+    });
+    appendChild(sliceGroup, contentSlot);
+    appendChild(group, sliceGroup);
+  }
+  if (hasDefs) {
+    prependChild(group, defs);
+  }
+  return group;
+}
+
+export { renderPieSvg };