@primeui/chart-core 0.0.1-alpha.1 → 1.0.0-rc.1

package/dist/{chunk-AUF4CHDP.mjs → chunks/chunk-DJOHDKTP.mjs}

@@ -1,8 +1,9 @@
-import { resolveBorderRadius, clampRectBorderRadius, isUniformBorderRadius, hasBorderRadius } from './chunk-VGLSBZDN.mjs';
-import { isIndexVisible } from './chunk-5JCI2DEB.mjs';
-import { computeItemHoverState, applyHoverEffects } from './chunk-BZN2QHGP.mjs';
-import { batchResolveRequired, batchResolveAccessor, resolveAccessor, makeItemContext, getDefaultColor, resolveDash } from './chunk-O2X6FF45.mjs';
-import { calculateNiceDomain, createBandScale, createLinearScale } from './chunk-RQ3CKQOX.mjs';
+import { resolveBorderRadius, clampRectBorderRadius, isUniformBorderRadius, hasBorderRadius } from './chunk-F2E2QCZM.mjs';
+import { isIndexVisible } from './chunk-JQVX6XFW.mjs';
+import { computeItemHoverState, applyHoverEffects } from './chunk-F6AGZQDA.mjs';
+import { batchResolveRequired, batchResolveAccessor, resolveAccessor, makeItemContext, getDefaultColor, resolveDash } from './chunk-BDCNBS6W.mjs';
+import { resolveCartesianAccessors } from './chunk-G3DIMENH.mjs';
+import { calculateNiceDomain, createBandScale, createLinearScale } from './chunk-K7AGQTVK.mjs';
 
 // src/series/bar/shared.ts
 var EDGES = ["top", "right", "bottom", "left"];
@@ -75,7 +76,6 @@ function tracePartialBorder(pb, x, y, w, h, skipped, radius) {
 }
 
 // src/series/bar/geom/layout.ts
-var DEFAULT_ORIENTATION = "vertical";
 var DEFAULT_BASE = 0;
 function resolveSkippedEdges(borderSkipped, orientation, isNegative) {
   if (borderSkipped === false || borderSkipped === void 0) return EMPTY_EDGE_SET;
@@ -99,13 +99,15 @@ function resolveSkippedEdges(borderSkipped, orientation, isNegative) {
   }
 }
 function calculateBarLayout(props, chartArea, config) {
-  const { data, categoryField, valueField, color: colorProp, orientation = DEFAULT_ORIENTATION, visibility } = props;
-  const categoryAccessor = categoryField;
-  const valueAccessor = valueField;
+  const { data, color: colorProp, visibility } = props;
+  const acc = resolveCartesianAccessors(props);
+  const orientation = acc.orientation;
+  const categoryAccessor = acc.independentField;
+  const valueAccessor = acc.measureField;
   const openAccessor = props.openField;
   const base = props.base ?? DEFAULT_BASE;
   const categories = categoryAccessor ? batchResolveRequired(categoryAccessor, data, "categoryField") : data.map((_, i) => String(i));
-  const values = valueAccessor ? batchResolveRequired(valueAccessor, data, "valueField") : data.map(() => 0);
+  const values = valueAccessor ? batchResolveRequired(valueAccessor, data, "valueField") : [];
   const openValues = openAccessor ? batchResolveAccessor(openAccessor, data) : void 0;
   let valueDomain;
   let categoryScale;
@@ -124,6 +126,9 @@ function calculateBarLayout(props, chartArea, config) {
       valueScale = createLinearScale(valueDomain, [chartArea.x, chartArea.x + chartArea.width]);
     }
   }
+  if (!valueAccessor) {
+    return { bars: [], visibleBars: [], categoryScale, valueScale, orientation, colors: [], borderColors: [], chartArea, valueDomain, base, openValues };
+  }
   const borderColorProp = props.borderColor;
   const seriesExtras = { seriesIndex: props.order ?? 0, seriesId: props.id ?? "" };
   const bars = [];
@@ -315,6 +320,7 @@ function computeBarRenderStates(props, layout, theme) {
   const isSeriesDimmed = interaction?.isSeriesDimmed ?? false;
   const isSeriesHovered = interaction?.isSeriesHovered ?? false;
   const seriesIdx = props.order ?? 0;
+  const colorIndex = layout.colorIndex;
   const seriesExtras = { seriesIndex: seriesIdx, seriesId: props.id ?? "" };
   const bars = visibleBars.map((bar) => {
     const { dataIndex, width, height, isNegative } = bar;
@@ -323,7 +329,7 @@ function computeBarRenderStates(props, layout, theme) {
     const borderColor = borderColors[dataIndex];
     const borderWidth = resolveBarBorderWidth(ctx);
     const resolvedRadius = resolveBorderRadius(resolveBarBorderRadius(ctx));
-    const canvasFill = userFill ?? getDefaultColor(seriesIdx, theme);
+    const canvasFill = userFill ?? getDefaultColor(colorIndex, theme);
     let hoverState;
     if (hoverEnabled && isSeriesDimmed) {
       hoverState = { isHovered: false, hasAnyHover: true };
@@ -378,6 +384,7 @@ function computeBarRenderStates(props, layout, theme) {
       hoverColorOverride: itemEffects?.hoverBackgroundColor,
       userBorder: borderColor === "transparent" ? void 0 : borderColor,
       seriesIdx,
+      colorIndex,
       isHovered: hoverState.isHovered,
       isInactive,
       drawX: bar.x + offsetX - (drawWidth - width) / 2,

package/dist/{chunk-3Z62EUJN.mjs → chunks/chunk-DKWZKYHF.mjs}

@@ -1,7 +1,7 @@
-import { CHAR_WIDTH_RATIO, formatCompactValue, measureFontMetrics } from './chunk-XTVE4P3L.mjs';
-import { resolveColorScaleRange, interpolateColor } from './chunk-QS76E3TD.mjs';
-import { FIELD_DEFAULTS, batchResolveAccessor } from './chunk-O2X6FF45.mjs';
-import { hexToRgbString } from './chunk-SSLTFJ3U.mjs';
+import { CHAR_WIDTH_RATIO, formatCompactValue, measureFontMetrics } from './chunk-56MASQS2.mjs';
+import { resolveColorScaleRange, interpolateColor } from './chunk-RI32WIDX.mjs';
+import { FIELD_DEFAULTS, batchResolveAccessor } from './chunk-BDCNBS6W.mjs';
+import { hexToRgbString } from './chunk-BF7RP4A3.mjs';
 
 // src/series/heatmap/geometry.ts
 var DEFAULT_HEATMAP_NULL_COLOR = "#f3f4f6";
@@ -27,7 +27,7 @@ function getHeatmapLabelInfo(cell) {
   return { fontSize: 0, show: false };
 }
 function calculateHeatmapLayout(props, chartArea, scales, theme) {
-  const { data, columnField: xField = FIELD_DEFAULTS.columnField, rowField: yField = FIELD_DEFAULTS.rowField, valueField = FIELD_DEFAULTS.valueField } = props;
+  const { data, categoryXField: xField = FIELD_DEFAULTS.columnField, categoryYField: yField = FIELD_DEFAULTS.rowField, valueField = FIELD_DEFAULTS.valueField } = props;
   const { xScale, yScale } = scales;
   const cellPadding = props.spacing ?? DEFAULT_HEATMAP_CELL_PADDING;
   const showEmptyCells = props.showEmptyCells !== false;

package/dist/{chunk-Y3L3D4GQ.mjs → chunks/chunk-DORUY7GR.mjs}

@@ -1,18 +1,18 @@
-import { barHitTest, barFindNearest, barFindAllNearest } from './chunk-JGOVWSKH.mjs';
-import { animatableBarToComputedBar } from './chunk-FRST55HY.mjs';
-import { registerDatasetLayers, triggerCompositorRepaint } from './chunk-Q6PPVIHU.mjs';
-import { resolveBarLabels } from './chunk-66T4MRC5.mjs';
-import { renderResolvedLabels } from './chunk-QQBXUDM4.mjs';
-import { computeBarVisualLayout } from './chunk-7QQ6ETB4.mjs';
-import { AnimatedScene, resolveAnimatedProps, BAR_ANIMATABLE_PROPS } from './chunk-VN7CKCSE.mjs';
-import { reconcileSvgChildren } from './chunk-KP2TWD4Z.mjs';
-import { parseAnimationConfig } from './chunk-3WEMHXZI.mjs';
-import { cancelRaf, raf } from './chunk-EDAKJLNA.mjs';
-import { hoverConfigToFullEffect } from './chunk-BZN2QHGP.mjs';
-import { generateSeriesDescription } from './chunk-OGJ6IIBW.mjs';
-import { collectItems } from './chunk-FFMT6OCO.mjs';
-import { defaultLightTheme } from './chunk-O2X6FF45.mjs';
-import { setAttr, createSvgGroup, svgNode, appendChild, createSvgRect, materializeSvgNode } from './chunk-SSLTFJ3U.mjs';
+import { barHitTest, barFindNearest, barFindAllNearest } from './chunk-TW3KLJVO.mjs';
+import { animatableBarToComputedBar } from './chunk-ZZCVDIU5.mjs';
+import { registerDatasetLayers, triggerCompositorRepaint } from './chunk-MT3OLVZC.mjs';
+import { renderResolvedLabels } from './chunk-G3DYNMWT.mjs';
+import { resolveBarLabels } from './chunk-7IKKWWRT.mjs';
+import { computeBarVisualLayout } from './chunk-LBNP5PJA.mjs';
+import { AnimatedScene, resolveAnimatedProps, BAR_ANIMATABLE_PROPS } from './chunk-JS47MSB2.mjs';
+import { reconcileSvgChildren } from './chunk-FWNWV3H7.mjs';
+import { parseAnimationConfig } from './chunk-LTQH3LQJ.mjs';
+import { cancelRaf, raf } from './chunk-5WFF272M.mjs';
+import { hoverConfigToFullEffect } from './chunk-F6AGZQDA.mjs';
+import { generateSeriesDescription } from './chunk-IFJPDARC.mjs';
+import { collectItems } from './chunk-FRVJH7ZG.mjs';
+import { buildColorIndexMap, defaultLightTheme } from './chunk-BDCNBS6W.mjs';
+import { setAttr, createSvgGroup, svgNode, appendChild, createSvgRect, materializeSvgNode } from './chunk-BF7RP4A3.mjs';
 
 // src/series/bar/controller/types.ts
 var BAR_SCENE_REGISTRY = {
@@ -33,14 +33,28 @@ function groupAnimatedBarsByDataset(animatedBars) {
   }
   return grouped;
 }
-function barHoverInteraction(base, dsId, hover, flags) {
+function findNearestBarIndexByX(visibleBars, axisX, orientation) {
+  let bestIdx = null;
+  let bestDist = Infinity;
+  for (const bar of visibleBars) {
+    const center = orientation === "vertical" ? bar.x + bar.width / 2 : bar.y + bar.height / 2;
+    const dist = Math.abs(center - axisX);
+    if (dist < bestDist) {
+      bestDist = dist;
+      bestIdx = bar.dataIndex;
+    }
+  }
+  return bestIdx;
+}
+function barHoverInteraction(base, dsId, hover, flags, visibleBars, orientation) {
   const isAnyHover = hover.datasetId !== null;
-  const isAxisHover = hover.axisIndex != null;
   const isThisSeriesHovered = hover.datasetId === dsId;
   const { isWaterfall, isStacked, isGrouped } = flags;
+  const resolvedAxisIndex = hover.axisX != null && visibleBars ? findNearestBarIndexByX(visibleBars, hover.axisX, orientation ?? "vertical") : hover.axisIndex ?? null;
+  const isAxisHover = resolvedAxisIndex != null;
   return {
     ...base,
-    hoveredIndex: isAxisHover ? hover.axisIndex ?? null : isThisSeriesHovered ? hover.index : null,
+    hoveredIndex: isAxisHover ? resolvedAxisIndex : isThisSeriesHovered ? hover.index : null,
     isSeriesHovered: isAxisHover || isWaterfall ? false : (isStacked || isGrouped) && isAnyHover && isThisSeriesHovered,
     isSeriesDimmed: isAxisHover || isWaterfall ? false : isAnyHover && !isThisSeriesHovered
   };
@@ -54,7 +68,7 @@ function buildBarSvgChildren(params) {
     if (!props) continue;
     const propsWithHover = {
       ...props,
-      interaction: barHoverInteraction(props.interaction, dsId, hover, flags)
+      interaction: barHoverInteraction(props.interaction, dsId, hover, flags, layout.visibleBars, orientation)
     };
     const barNode = paint.renderSvg(propsWithHover, layout, context);
     setAttr(barNode, "data-dataset", dsId);
@@ -156,7 +170,7 @@ function renderBarsFrame(params) {
       if (!props) continue;
       const propsWithHover = {
         ...props,
-        interaction: barHoverInteraction(props.interaction, dsId, hover, { isWaterfall, isStacked, isGrouped })
+        interaction: barHoverInteraction(props.interaction, dsId, hover, { isWaterfall, isStacked, isGrouped }, layout.visibleBars, orientation)
       };
       paint.renderCanvas(propsWithHover, layout, ctx, context);
     }
@@ -242,7 +256,7 @@ function applyHover(ctx, hover) {
 // src/series/bar/controller/scene.ts
 function buildBarsFromScene(ctx) {
   const result = [];
-  for (const el of ctx._scene.getElements()) {
+  for (const el of ctx._scene.elementValues()) {
     const s = el.current;
     result.push({
       dataIndex: s.dataIndex,
@@ -411,7 +425,8 @@ var BarRendererController = class {
       axisLayouts: layoutData.axisLayouts,
       hover: this.hover,
       hoverConfig: input.hoverConfig ? hoverConfigToFullEffect(input.hoverConfig) : void 0,
-      theme: input.theme
+      theme: input.theme,
+      colorIndexById: buildColorIndexMap(datasets)
     }) : null;
     const prevLayoutCache = this.layoutCache;
     const prevRenderPropsCache = this.renderPropsCache;
@@ -430,6 +445,7 @@ var BarRendererController = class {
       }
       this._scene.reset();
       this._lastFingerprint = "";
+      compositor?.removeLayersByPrefix("bar:");
       if (input.renderer === "svg" && this.svgGroup) {
         while (this.svgGroup.firstChild) this.svgGroup.removeChild(this.svgGroup.firstChild);
       }
@@ -455,17 +471,9 @@ var BarRendererController = class {
             ctx.rect(layoutData.cartesianArea.x, layoutData.cartesianArea.y, layoutData.cartesianArea.width, layoutData.cartesianArea.height);
             ctx.clip();
           }
-          const isAnyHoverCompositor = this.hover.datasetId !== null;
-          const isAxisHoverCompositor = this.hover.axisIndex != null;
-          const isThisSeriesHoveredCompositor = this.hover.datasetId === dsId;
           const propsWithHover = {
             ...props,
-            interaction: {
-              ...props.interaction,
-              hoveredIndex: isAxisHoverCompositor ? this.hover.axisIndex ?? null : isThisSeriesHoveredCompositor ? this.hover.index : null,
-              isSeriesHovered: isAxisHoverCompositor ? false : (layoutData.isStacked || layoutData.isGrouped) && isAnyHoverCompositor && isThisSeriesHoveredCompositor,
-              isSeriesDimmed: isAxisHoverCompositor ? false : isAnyHoverCompositor && !isThisSeriesHoveredCompositor
-            }
+            interaction: barHoverInteraction(props.interaction, dsId, this.hover, { isWaterfall: layoutData.isWaterfall, isStacked: layoutData.isStacked, isGrouped: layoutData.isGrouped }, layout.visibleBars, orientation)
           };
           this._paint.renderCanvas(propsWithHover, layout, ctx, context);
           if (this.labelConfig && this.lastInput?.datasetVisibility?.get(dsId) !== false) {
@@ -550,26 +558,44 @@ var BarRendererController = class {
   applyHover(hover) {
     applyHover(this, hover);
   }
+  /**
+   * Hit-test layouts excluding toggled-off datasets. `computeBarVisualLayout`
+   * writes a full-size layout into `layoutCache` for EVERY dataset (the
+   * `layouts.set` runs before its `if (ds.visible)` gate) so an exiting bar
+   * can animate out, which means a hidden dataset lingers in the cache at full
+   * size. Gating on the authoritative `datasetVisibility` keeps a toggled-off
+   * series from producing a tooltip without disturbing the cache the exit
+   * animation relies on.
+   */
+  get _hitTestLayouts() {
+    const vis = this.lastInput?.datasetVisibility;
+    if (!vis) return this.layoutCache;
+    const visible = /* @__PURE__ */ new Map();
+    for (const [id, layout] of this.layoutCache) {
+      if (vis.get(id) !== false) visible.set(id, layout);
+    }
+    return visible;
+  }
   /**
    * Hit test at pixel coordinates.
    */
   hitTest(x, y) {
     if (!this.lastInput?.layoutData) return null;
-    return barHitTest(x, y, { layouts: this.layoutCache, renderPropsCache: this.renderPropsCache, datasets: this.lastInput.datasets, layoutData: this.lastInput.layoutData, theme: this.lastInput.theme });
+    return barHitTest(x, y, { layouts: this._hitTestLayouts, renderPropsCache: this.renderPropsCache, datasets: this.lastInput.datasets, layoutData: this.lastInput.layoutData, theme: this.lastInput.theme });
   }
   /**
    * Find the nearest data point by category axis proximity (for crosshair mode).
    */
   findNearest(x, y) {
     if (!this.lastInput?.layoutData) return null;
-    return barFindNearest(x, y, { layouts: this.layoutCache, renderPropsCache: this.renderPropsCache, datasets: this.lastInput.datasets, layoutData: this.lastInput.layoutData, theme: this.lastInput.theme });
+    return barFindNearest(x, y, { layouts: this._hitTestLayouts, renderPropsCache: this.renderPropsCache, datasets: this.lastInput.datasets, layoutData: this.lastInput.layoutData, theme: this.lastInput.theme });
   }
   /**
    * Find ALL dataset hits at the nearest category (for multi-series crosshair badges).
    */
   findAllNearest(x, y) {
     if (!this.lastInput?.layoutData) return null;
-    return barFindAllNearest(x, y, { layouts: this.layoutCache, renderPropsCache: this.renderPropsCache, datasets: this.lastInput.datasets, layoutData: this.lastInput.layoutData, theme: this.lastInput.theme });
+    return barFindAllNearest(x, y, { layouts: this._hitTestLayouts, renderPropsCache: this.renderPropsCache, datasets: this.lastInput.datasets, layoutData: this.lastInput.layoutData, theme: this.lastInput.theme });
   }
   /**
    * Not used for bar (renders directly to DOM). Provided for interface compliance.
@@ -585,6 +611,15 @@ var BarRendererController = class {
   get layouts() {
     return this.layoutCache;
   }
+  /**
+   * Live animated bar layouts — the geometry of the current rAF frame, falling back to
+   * the settled target layout when no frame has rendered yet. Per-frame consumers (e.g.
+   * custom SVG data-label VNodes) read this so their positions track the entrance/transition
+   * animation instead of snapping to the final layout, matching the canvas label path.
+   */
+  get renderedLayouts() {
+    return this.lastRenderedLayouts ?? this.layoutCache;
+  }
   /** Current bar render props (for external consumers) */
   get renderProps() {
     return this.renderPropsCache;

package/dist/chunks/chunk-DWBJKYLH.mjs

@@ -0,0 +1,238 @@
+import { computeSliceGeometry } from './chunk-ARVMVGWS.mjs';
+import { buildSvgArcPath, CLIP_PIXEL_MARGIN } from './chunk-4S3FOFCN.mjs';
+import { computeSliceHoverEffects } from './chunk-F6AGZQDA.mjs';
+import { DEFAULT_FALLBACK_COLOR, DEFAULT_HOVER_BRIGHTNESS, DEFAULT_HOVER_DIM_OPACITY } from './chunk-6LUIVTNV.mjs';
+import { getDefaultColor, makeItemContext, resolveAccessor, getColor, isGradientColor, remapStopsForDonut, createSvgGradientFromColor } from './chunk-BDCNBS6W.mjs';
+import { svgNode, svgClass, brightenGradientStops, adjustBrightness } from './chunk-BF7RP4A3.mjs';
+import { pointOnCircle, toRad } from './chunk-K7AGQTVK.mjs';
+
+// src/series/pie/svg/index.ts
+function buildSliceRenderContext(slice, renderInfo, position, geo, theme, chartCenter, fontFamily) {
+  const item = renderInfo.data[slice.originalIndex];
+  const angle = slice.endAngle - slice.rotation;
+  const sliceCtx = makeItemContext(item, slice.originalIndex);
+  const originalValue = Number(resolveAccessor(renderInfo.props.valueField, sliceCtx)) || slice.value;
+  const sliceLabel = String(resolveAccessor(renderInfo.props.categoryField, sliceCtx) ?? "");
+  return {
+    index: slice.originalIndex,
+    data: item,
+    value: originalValue,
+    percentage: slice.percentage,
+    label: sliceLabel,
+    color: slice.color ?? getColor(renderInfo.props, slice.originalIndex, item, theme, { value: originalValue, category: sliceLabel }),
+    center: chartCenter ?? position,
+    x: position.x,
+    y: position.y,
+    angle: geo.midAngle,
+    isHovered: geo.isHovered,
+    isVisible: angle > 0.1,
+    fontFamily: fontFamily ?? "sans-serif"
+  };
+}
+function updatePieCustomContent(frame, refs, theme, fontFamily) {
+  const { slices, center } = frame;
+  const activeCustomKeys = /* @__PURE__ */ new Set();
+  for (const slice of slices) {
+    const key = `${slice.datasetIndex}-${slice.originalIndex}`;
+    const angle = slice.endAngle - slice.rotation;
+    const geo = computeSliceGeometry(slice, slice.rotation, frame);
+    const customEl = refs.customContent.get(key);
+    if (!customEl) continue;
+    const pt = pointOnCircle(center.x + geo.offsetX, center.y + geo.offsetY, geo.midAngle, geo.midRadius);
+    customEl.setAttribute("transform", `translate(${pt.x}, ${pt.y})`);
+    customEl.style.opacity = String(Math.min(1, angle / 10));
+    activeCustomKeys.add(key);
+    let renderInfo;
+    for (const [, info] of refs.renderFns) {
+      if (info.datasetIndex === slice.datasetIndex) {
+        renderInfo = info;
+        break;
+      }
+    }
+    if (renderInfo && renderInfo.data[slice.originalIndex]) {
+      const result = renderInfo.fn(buildSliceRenderContext(slice, renderInfo, pt, geo, theme, void 0, fontFamily));
+      if (result && typeof result === "object" && "text" in result) {
+        const textEl = customEl.querySelector("text");
+        if (textEl) {
+          textEl.textContent = result.text;
+        }
+      }
+    }
+  }
+  if (activeCustomKeys.size > 0) {
+    for (const [key, el] of refs.customContent) {
+      if (!activeCustomKeys.has(key)) {
+        el.style.opacity = "0";
+      }
+    }
+  }
+}
+function resolveSliceFillDescriptor(slice, isHovered, hasAnyHover, hoverConfig, theme, gradientId, innerRadius, outerRadius) {
+  const colorValue = slice.colorValue;
+  const isGradient = colorValue !== void 0 && isGradientColor(colorValue);
+  let baseFill;
+  if (isGradient) {
+    baseFill = `url(#${gradientId})`;
+  } else if (typeof colorValue === "string") {
+    baseFill = colorValue;
+  } else if (typeof slice.color === "string") {
+    baseFill = slice.color;
+  } else {
+    baseFill = theme.series[slice.originalIndex % theme.series.length];
+  }
+  const originalFill = baseFill;
+  const fillHoverConfig = isHovered && slice.hoverColor ? { ...hoverConfig, backgroundColor: slice.hoverColor } : hoverConfig;
+  let fill = baseFill;
+  let opacityAttr;
+  let hoverClass = false;
+  let inactiveClass = false;
+  let gradStops = isGradient ? colorValue.stops : void 0;
+  if (fillHoverConfig) {
+    const brightness = fillHoverConfig.brightness ?? theme.hoverBrightness ?? DEFAULT_HOVER_BRIGHTNESS;
+    if (isHovered) {
+      if (fillHoverConfig.backgroundColor) {
+        fill = fillHoverConfig.backgroundColor;
+      } else if (isGradient) {
+        gradStops = brightenGradientStops(colorValue, brightness).stops;
+        fill = baseFill;
+      } else if (fillHoverConfig.brightness === void 0) {
+        hoverClass = true;
+        fill = baseFill;
+      } else {
+        fill = adjustBrightness(baseFill, fillHoverConfig.brightness);
+      }
+    } else if (hasAnyHover) {
+      if (fillHoverConfig.dimOpacity !== void 0) {
+        if (fillHoverConfig.dimOpacity < 1) opacityAttr = String(fillHoverConfig.dimOpacity);
+      } else if ((theme.dimOpacity ?? DEFAULT_HOVER_DIM_OPACITY) < 1) {
+        inactiveClass = true;
+      }
+      fill = baseFill;
+    }
+  }
+  let gradientDef;
+  if (isGradient) {
+    const cv = colorValue;
+    const remapped = innerRadius > 0 && cv.radialGradient ? remapStopsForDonut(gradStops ?? cv.stops, innerRadius / outerRadius) : gradStops ?? cv.stops;
+    const gradientColor = { ...cv, stops: remapped };
+    gradientDef = createSvgGradientFromColor(gradientColor, gradientId, { x: 0, y: 0 }, outerRadius);
+  }
+  return { fill, opacityAttr, originalFill, gradientDef, hoverClass, inactiveClass };
+}
+function buildPieSvgChildren(frame, hoverConfig, theme, chartId, datasetIndex) {
+  const { fullCircle, hoverState } = frame;
+  const hasAnyHover = hoverState.index !== null;
+  const defsChildren = [];
+  const sliceGroups = [];
+  for (const slice of frame.slices) {
+    if (slice.datasetIndex !== datasetIndex) continue;
+    const dataIndex = slice.originalIndex;
+    const angle = slice.endAngle - slice.rotation;
+    const geo = computeSliceGeometry(slice, slice.rotation, frame);
+    const isHovered = geo.isHovered;
+    const gradientId = `${chartId}-pie-${datasetIndex}-grad-${dataIndex}`;
+    const clipId = `${chartId}-pie-${datasetIndex}-clip-${dataIndex}`;
+    const pathD = buildSvgArcPath(
+      {
+        rotation: geo.renderRotation,
+        endAngle: geo.renderRotation + geo.renderAngle,
+        outerRadius: geo.sliceOuterRadius,
+        innerRadius: geo.sliceInnerRadius,
+        borderRadius: slice.borderRadius
+      },
+      fullCircle
+    );
+    const PIXEL_MARGIN = CLIP_PIXEL_MARGIN;
+    const angleDelta = geo.sliceOuterRadius > 0 ? PIXEL_MARGIN / geo.sliceOuterRadius * (180 / Math.PI) : 0;
+    const expandedClipPath = buildSvgArcPath(
+      {
+        rotation: geo.renderRotation - angleDelta,
+        endAngle: geo.renderRotation + geo.renderAngle + angleDelta,
+        outerRadius: geo.sliceOuterRadius,
+        innerRadius: geo.sliceInnerRadius,
+        borderRadius: slice.borderRadius
+      },
+      fullCircle
+    );
+    defsChildren.push(svgNode("clipPath", { id: clipId }, [svgNode("path", { d: expandedClipPath })]));
+    const { fill, opacityAttr, originalFill, gradientDef, hoverClass, inactiveClass } = resolveSliceFillDescriptor(slice, isHovered, hasAnyHover, hoverConfig, theme, gradientId, frame.innerRadius, frame.outerRadius);
+    if (gradientDef) defsChildren.push(gradientDef);
+    const {
+      borderStrokeWidth: bw,
+      borderColor: computedBorderColor,
+      borderDash: hoverBorderDash
+    } = computeSliceHoverEffects(slice.color ?? DEFAULT_FALLBACK_COLOR, slice.borderColor ?? "transparent", slice.borderStrokeWidth ?? 0, isHovered, hasAnyHover, hoverConfig, theme);
+    const bc = isHovered && slice.hoverBorderColor ? slice.hoverBorderColor : computedBorderColor;
+    const isInner = (frame.borderAlign ?? "inner") === "inner";
+    const joinStyle = frame.borderJoinStyle ?? "miter";
+    const strokeAttrs = {
+      d: pathD,
+      fill: "none",
+      "stroke-linejoin": joinStyle,
+      "data-stroke-path": "true",
+      "data-clip-id": clipId,
+      ...isInner ? { "clip-path": `url(#${clipId})` } : {}
+    };
+    if (bw > 0 && bc !== "transparent") {
+      strokeAttrs.stroke = bc;
+      strokeAttrs["stroke-width"] = String(isInner ? bw * 2 : bw);
+      const bd = hoverBorderDash ?? slice.borderDash;
+      if (bd && bd.length > 0) {
+        strokeAttrs["stroke-dasharray"] = bd.join(" ");
+        strokeAttrs["stroke-dashoffset"] = String(slice.borderDashOffset ?? 0);
+      }
+    } else {
+      strokeAttrs.stroke = "transparent";
+      strokeAttrs["stroke-width"] = "0";
+    }
+    const colorClassN = `p-chart-color-${dataIndex % 14}`;
+    const usesColorClass = slice.colorValue === getDefaultColor(slice.originalIndex, theme);
+    const fillCls = svgClass("p-chart-arc", `p-chart-series-${dataIndex}`, usesColorClass && colorClassN, hoverClass && "p-chart-point-hover", inactiveClass && "p-chart-point-inactive");
+    const fillAttrs = {
+      d: pathD,
+      fill,
+      "data-index": dataIndex,
+      class: fillCls,
+      "data-fill-path": "true",
+      // applySvgHoverFill / applySvgHoverStroke bookkeeping (only written when a hoverConfig is
+      // present). applySvgHoverStroke runs on the FILL path (updateSvgSlices:286); on its first
+      // call it seeds `data-original-stroke` / `data-original-stroke-width` from the fill path's
+      // (absent) stroke attrs → empty strings. `data-original-stroke-dasharray` is only seeded
+      // when a base dasharray exists (the fill path never has one), so it stays absent here.
+      ...hoverConfig ? { "data-original-fill": originalFill, "data-original-stroke": "", "data-original-stroke-width": "" } : {},
+      ...opacityAttr !== void 0 ? { opacity: opacityAttr } : {}
+    };
+    if (isHovered && hoverConfig && (hoverConfig.borderColor || hoverConfig.borderStrokeWidth !== void 0)) {
+      if (hoverConfig.borderColor) fillAttrs.stroke = hoverConfig.borderColor;
+      if (hoverConfig.borderStrokeWidth !== void 0) fillAttrs["stroke-width"] = String(hoverConfig.borderStrokeWidth * 2);
+      if (hoverConfig.borderDash) fillAttrs["stroke-dasharray"] = hoverConfig.borderDash.join(" ");
+      fillAttrs["paint-order"] = "stroke fill";
+    }
+    const fillPath = svgNode("path", fillAttrs);
+    const strokePath = svgNode("path", strokeAttrs);
+    const slotX = Math.cos(toRad(geo.midAngle)) * geo.midRadius;
+    const slotY = Math.sin(toRad(geo.midAngle)) * geo.midRadius;
+    const contentSlot = svgNode("g", {
+      class: "slice-content",
+      "data-content-index": dataIndex,
+      transform: `translate(${slotX}, ${slotY})`,
+      opacity: angle < 0.1 ? "0" : "1"
+    });
+    const hasOffset = geo.offsetX !== 0 || geo.offsetY !== 0;
+    const hasScale = geo.scale !== 1;
+    const transformParts = [];
+    if (hasOffset) transformParts.push(`translate(${geo.offsetX}, ${geo.offsetY})`);
+    if (hasScale) transformParts.push(`scale(${geo.scale})`);
+    const groupAttrs = {
+      "data-slice-index": dataIndex,
+      "data-index": dataIndex,
+      // userOpacity + span<0.1 hide, as an ATTRIBUTE (normalized vs style in the parity test).
+      opacity: angle < 0.1 ? "0" : String(slice.userOpacity ?? 1),
+      ...transformParts.length > 0 ? { transform: transformParts.join(" ") } : {}
+    };
+    sliceGroups.push(svgNode("g", groupAttrs, [fillPath, strokePath, contentSlot]));
+  }
+  return defsChildren.length > 0 ? [svgNode("defs", void 0, defsChildren), ...sliceGroups] : sliceGroups;
+}
+
+export { buildPieSvgChildren, updatePieCustomContent };

package/dist/{chunk-XQQCGFYB.mjs → chunks/chunk-EQLCJTM4.mjs}

@@ -1,4 +1,4 @@
-import { lerpValues } from './chunk-WH3C3Y7P.mjs';
+import { lerpValues } from './chunk-CKQ4DNNJ.mjs';
 
 // src/animations/line.ts
 function detectLineUpdateKind(startVals, targetVals) {

package/dist/{chunk-VGLSBZDN.mjs → chunks/chunk-F2E2QCZM.mjs}

@@ -1,4 +1,4 @@
-import { clamp } from './chunk-RQ3CKQOX.mjs';
+import { clamp } from './chunk-K7AGQTVK.mjs';
 
 // src/utils/layout/borderRadius.utils.ts
 function resolveBorderRadius(borderRadius) {

package/dist/{chunk-BZN2QHGP.mjs → chunks/chunk-F6AGZQDA.mjs}

@@ -1,6 +1,6 @@
-import { DEFAULT_HOVER_BRIGHTNESS, DEFAULT_HOVER_DIM_OPACITY } from './chunk-NKUYIWAP.mjs';
-import { defaultLightTheme, isGradientColor } from './chunk-O2X6FF45.mjs';
-import { adjustBrightness, brightenGradientStops } from './chunk-SSLTFJ3U.mjs';
+import { DEFAULT_HOVER_BRIGHTNESS, DEFAULT_HOVER_DIM_OPACITY } from './chunk-6LUIVTNV.mjs';
+import { defaultLightTheme, isGradientColor } from './chunk-BDCNBS6W.mjs';
+import { adjustBrightness, brightenGradientStops } from './chunk-BF7RP4A3.mjs';
 
 // src/utils/interaction/hover.utils.ts
 function computeItemHoverState(dataIndex, hoveredIndex, hoverEnabled) {
@@ -122,74 +122,6 @@ function computeLeaderLineHoverEffects(baseColor, isHovered, hasAnyHover, hoverP
   }
   return { strokeColor, strokeWidth };
 }
-function applySvgHoverFill(pathEl, isHovered, hasAnyHover, hoverConfig, applyGradientBrightness, restoreGradientBrightness, theme) {
-  if (!hoverConfig) return;
-  if (!pathEl.hasAttribute("data-original-fill")) {
-    pathEl.setAttribute("data-original-fill", pathEl.getAttribute("fill") || "");
-  }
-  const originalFill = pathEl.getAttribute("data-original-fill") || "";
-  const isGradient = originalFill.startsWith("url(");
-  const brightness = hoverConfig.brightness ?? theme.hoverBrightness ?? DEFAULT_HOVER_BRIGHTNESS;
-  if (isHovered) {
-    if (hoverConfig.backgroundColor) {
-      pathEl.setAttribute("fill", hoverConfig.backgroundColor);
-    } else if (isGradient && applyGradientBrightness) {
-      applyGradientBrightness(pathEl, brightness);
-    } else if (originalFill) {
-      pathEl.setAttribute("fill", adjustBrightness(originalFill, brightness));
-    }
-    pathEl.removeAttribute("opacity");
-  } else if (hasAnyHover && hoverConfig.dimOpacity !== void 0 && hoverConfig.dimOpacity < 1) {
-    pathEl.setAttribute("opacity", String(hoverConfig.dimOpacity));
-    if (isGradient && restoreGradientBrightness) {
-      restoreGradientBrightness(pathEl);
-    } else if (originalFill) {
-      pathEl.setAttribute("fill", originalFill);
-    }
-  } else {
-    if (isGradient && restoreGradientBrightness) {
-      restoreGradientBrightness(pathEl);
-    } else if (originalFill) {
-      pathEl.setAttribute("fill", originalFill);
-    }
-    pathEl.removeAttribute("opacity");
-  }
-}
-function applySvgHoverStroke(pathEl, isHovered, hoverConfig) {
-  if (!hoverConfig) return;
-  if (!pathEl.hasAttribute("data-original-stroke")) {
-    pathEl.setAttribute("data-original-stroke", pathEl.getAttribute("stroke") || "");
-    pathEl.setAttribute("data-original-stroke-width", pathEl.getAttribute("stroke-width") || "");
-    const dashArray = pathEl.getAttribute("stroke-dasharray");
-    if (dashArray) {
-      pathEl.setAttribute("data-original-stroke-dasharray", dashArray);
-    }
-  }
-  if (isHovered && (hoverConfig.borderColor || hoverConfig.borderStrokeWidth !== void 0)) {
-    if (hoverConfig.borderColor) {
-      pathEl.setAttribute("stroke", hoverConfig.borderColor);
-    }
-    if (hoverConfig.borderStrokeWidth !== void 0) {
-      pathEl.setAttribute("stroke-width", String(hoverConfig.borderStrokeWidth * 2));
-    }
-    if (hoverConfig.borderDash) {
-      pathEl.setAttribute("stroke-dasharray", hoverConfig.borderDash.join(" "));
-    }
-    if (!pathEl.hasAttribute("paint-order")) {
-      pathEl.setAttribute("paint-order", "stroke fill");
-    }
-  } else {
-    const originalStroke = pathEl.getAttribute("data-original-stroke");
-    const originalWidth = pathEl.getAttribute("data-original-stroke-width");
-    const originalDash = pathEl.getAttribute("data-original-stroke-dasharray");
-    if (originalStroke) pathEl.setAttribute("stroke", originalStroke);
-    else pathEl.removeAttribute("stroke");
-    if (originalWidth) pathEl.setAttribute("stroke-width", originalWidth);
-    else pathEl.removeAttribute("stroke-width");
-    if (originalDash) pathEl.setAttribute("stroke-dasharray", originalDash);
-    else pathEl.removeAttribute("stroke-dasharray");
-  }
-}
 function resolveSvgHoverFill(baseFill, isHovered, overrideColor) {
   if (isHovered && typeof overrideColor === "string") {
     return { fill: overrideColor, overridden: true };
@@ -197,4 +129,4 @@ function resolveSvgHoverFill(baseFill, isHovered, overrideColor) {
   return { fill: baseFill, overridden: false };
 }
 
-export { applyHoverEffects, applySvgHoverFill, applySvgHoverStroke, computeItemHoverState, computeLeaderLineHoverEffects, computeSliceHoverEffects, hoverConfigToBaseEffect, hoverConfigToFullEffect, resolveSvgHoverFill };
+export { applyHoverEffects, computeItemHoverState, computeLeaderLineHoverEffects, computeSliceHoverEffects, hoverConfigToBaseEffect, hoverConfigToFullEffect, resolveSvgHoverFill };