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

package/dist/{chunk-PLSDU3C2.mjs → chunks/chunk-DOC4YOCD.mjs}

@@ -1,19 +1,20 @@
-import { resolveRadarLabels } from './chunk-UPRXABX5.mjs';
-import { resolveSharedRadialGrid } from './chunk-TA4MVAEX.mjs';
-import { calculateRadarLayout, hitTestRadar } from './chunk-A6ZQZFL2.mjs';
-import { renderResolvedLabels } from './chunk-QQBXUDM4.mjs';
-import { AnimatedScene, resolveAnimatedProps, RADAR_ANIMATABLE_PROPS } from './chunk-VN7CKCSE.mjs';
-import { renderCustomMarkersCanvas } from './chunk-ZT2Z7ERM.mjs';
-import { reconcileSvgChildren } from './chunk-KP2TWD4Z.mjs';
-import { parseAnimationConfig } from './chunk-3WEMHXZI.mjs';
-import { cancelRaf, raf } from './chunk-EDAKJLNA.mjs';
-import { buildAccessibilityRenderContext, generateSeriesDescription } from './chunk-OGJ6IIBW.mjs';
-import { collectItems } from './chunk-FFMT6OCO.mjs';
-import { DEFAULT_HOVER_DIM_OPACITY, DEFAULT_HOVER_BRIGHTNESS } from './chunk-NKUYIWAP.mjs';
-import { interpolateRadialGrid } from './chunk-WH3C3Y7P.mjs';
-import { makeItemContext, defaultLightTheme, resolveSwatchColor, getPrimaryColor, getDefaultColor, FIELD_DEFAULTS } from './chunk-O2X6FF45.mjs';
-import { setAttr, createSvgGroup, materializeSvgNode } from './chunk-SSLTFJ3U.mjs';
-import { calculateNiceDomain } from './chunk-RQ3CKQOX.mjs';
+import { resolveSharedRadialGrid } from './chunk-CFA2SUBF.mjs';
+import { resolveRadarLabels } from './chunk-RH3OQ2VX.mjs';
+import { calculateRadarLayout, hitTestRadar } from './chunk-3CUSPV47.mjs';
+import { renderResolvedLabels } from './chunk-G3DYNMWT.mjs';
+import { AnimatedScene, resolveAnimatedProps, RADAR_ANIMATABLE_PROPS } from './chunk-JS47MSB2.mjs';
+import { renderCustomMarkersCanvas } from './chunk-AC5EAWIP.mjs';
+import { reconcileSvgChildren } from './chunk-FWNWV3H7.mjs';
+import { parseAnimationConfig } from './chunk-LTQH3LQJ.mjs';
+import { cancelRaf, raf } from './chunk-5WFF272M.mjs';
+import { buildAccessibilityRenderContext, generateSeriesDescription } from './chunk-IFJPDARC.mjs';
+import { collectItems } from './chunk-FRVJH7ZG.mjs';
+import { resolveRadialAccessors } from './chunk-6MAO6I3E.mjs';
+import { DEFAULT_HOVER_DIM_OPACITY, DEFAULT_HOVER_BRIGHTNESS } from './chunk-6LUIVTNV.mjs';
+import { makeItemContext, defaultLightTheme, resolveSwatchColor, getPrimaryColor, getDefaultColor, FIELD_DEFAULTS } from './chunk-BDCNBS6W.mjs';
+import { interpolateRadialGrid } from './chunk-CKQ4DNNJ.mjs';
+import { setAttr, createSvgGroup, materializeSvgNode } from './chunk-BF7RP4A3.mjs';
+import { calculateNiceDomain } from './chunk-K7AGQTVK.mjs';
 
 // src/series/radar/controller/helpers.ts
 function buildRadarFingerprint(layout, entries) {
@@ -82,7 +83,7 @@ function buildRadarSvgChildren(ctx, layout, entries, input) {
       const ds = entries[si];
       if (!sd.visible || !ds) continue;
       const dsTotal = sd.points.reduce((sum, pt) => sum + Math.abs(pt.value), 0);
-      const labels = resolveRadarLabels(sd.points, layout.categories, sd.color ?? getDefaultColor(sd.seriesIdx, input.theme), dsTotal, layout.center, lc, ds.props.data);
+      const labels = resolveRadarLabels(sd.points, layout.categories, sd.color ?? getDefaultColor(sd.colorIndex, input.theme), dsTotal, layout.center, lc, ds.props.data);
       const labelNode = createSvgGroup();
       renderResolvedLabels(labels, lc, { renderer: "svg", svgGroup: labelNode, theme: input.theme });
       setAttr(labelNode, "data-layer", `labels-${sd.id}`);
@@ -115,7 +116,7 @@ function renderCanvasContent(ctx, c2d) {
       renderMarker: renderMarkerFn,
       visiblePoints: sd.points.map((pt, pi) => ({ x: pt.x, y: pt.y, dataIndex: pi, value: pt.value, category: layout.categories[pt.categoryIndex] })),
       data: ds.props.data,
-      color: sd.color ?? getDefaultColor(sd.seriesIdx, ctx.lastInput?.theme ?? defaultLightTheme),
+      color: sd.color ?? getDefaultColor(sd.colorIndex, ctx.lastInput?.theme ?? defaultLightTheme),
       markerSize: typeof mergedProps.markerSize === "number" ? mergedProps.markerSize : 4,
       effects: { dimOpacity: ctx.effectConfig.dimOpacity }
     });
@@ -130,7 +131,7 @@ function renderCanvasContent(ctx, c2d) {
       const ds = ctx._entries[si];
       if (!sd.visible || !ds) continue;
       const dsTotal = sd.points.reduce((sum, pt) => sum + Math.abs(pt.value), 0);
-      const labels = resolveRadarLabels(sd.points, layout.categories, sd.color ?? getDefaultColor(sd.seriesIdx, ctx.lastInput?.theme ?? defaultLightTheme), dsTotal, layout.center, lc, ds.props.data);
+      const labels = resolveRadarLabels(sd.points, layout.categories, sd.color ?? getDefaultColor(sd.colorIndex, ctx.lastInput?.theme ?? defaultLightTheme), dsTotal, layout.center, lc, ds.props.data);
       renderResolvedLabels(labels, lc, { renderer: "canvas", ctx: c2d, theme: ctx.lastInput?.theme ?? defaultLightTheme });
     }
   }
@@ -155,7 +156,7 @@ function fullReset(ctx) {
   ctx._propertyOverrides.clear();
 }
 function runAllHidden(ctx, features) {
-  const liveCount = ctx._scene.getElements().length;
+  const liveCount = ctx._scene.elementCount;
   const hasFades = ctx._seriesFades.size > 0;
   if (liveCount === 0 && !hasFades) {
     ctx._layout = null;
@@ -211,7 +212,7 @@ function runAllHidden(ctx, features) {
     startAnimLoop(ctx);
   } else {
     ctx._scene.tick(performance.now());
-    if (ctx._scene.getElements().length === 0) {
+    if (ctx._scene.elementCount === 0) {
       ctx._layout = null;
       setMarkerData(ctx, null);
     }
@@ -261,7 +262,7 @@ function currentGridDomain(ctx) {
 function buildLayoutFromScene(ctx, now) {
   if (!ctx._layout) return null;
   const elementsBySeries = /* @__PURE__ */ new Map();
-  for (const el of ctx._scene.getElements()) {
+  for (const el of ctx._scene.elementValues()) {
     const s = el.current;
     const list = elementsBySeries.get(s.seriesId);
     if (list) list.push(s);
@@ -392,7 +393,7 @@ function buildPerAxisDomains(entries, yAxes) {
       if (!ds.visible) continue;
       if (ds.props.yAxisId !== axisId) continue;
       const data = ds.props.data;
-      const valueField = ds.props.valueField ?? FIELD_DEFAULTS.valueField;
+      const valueField = resolveRadialAccessors(ds.props).radialField ?? FIELD_DEFAULTS.valueField;
       if (!data || !valueField) continue;
       for (let i = 0; i < data.length; i++) {
         const item = data[i];
@@ -428,8 +429,8 @@ function buildPerSpokeDomains(entries, yAxes, categories, isStacked) {
     for (const ds of entries) {
       if (!ds.visible) continue;
       const data = ds.props.data;
-      const valueField = ds.props.valueField ?? FIELD_DEFAULTS.valueField;
-      const categoryField = ds.props.categoryField ?? FIELD_DEFAULTS.categoryField;
+      const valueField = resolveRadialAccessors(ds.props).radialField ?? FIELD_DEFAULTS.valueField;
+      const categoryField = resolveRadialAccessors(ds.props).angularField ?? FIELD_DEFAULTS.categoryField;
       if (!data || !valueField || !categoryField) continue;
       for (let i = 0; i < data.length; i++) {
         const item = data[i];
@@ -446,8 +447,8 @@ function buildPerSpokeDomains(entries, yAxes, categories, isStacked) {
     for (const ds of entries) {
       if (!ds.visible) continue;
       const data = ds.props.data;
-      const valueField = ds.props.valueField ?? FIELD_DEFAULTS.valueField;
-      const categoryField = ds.props.categoryField ?? FIELD_DEFAULTS.categoryField;
+      const valueField = resolveRadialAccessors(ds.props).radialField ?? FIELD_DEFAULTS.valueField;
+      const categoryField = resolveRadialAccessors(ds.props).angularField ?? FIELD_DEFAULTS.categoryField;
       if (!data || !valueField || !categoryField) continue;
       for (let i = 0; i < data.length; i++) {
         const item = data[i];
@@ -568,12 +569,18 @@ var RadarRendererController = class {
     this._hasRadarDatasets = Array.from(datasets.values()).some((ds) => ds.type === "radar");
     if (!this._hasRadarDatasets) {
       this._fullReset();
+      if (input.renderer === "svg" && this.svgGroup) {
+        while (this.svgGroup.firstChild) this.svgGroup.removeChild(this.svgGroup.firstChild);
+      }
       return;
     }
     const sortedDatasets = Array.from(datasets.entries()).sort(([, a], [, b]) => a.order - b.order);
     const radarEntries = collectItems(sortedDatasets, datasetVisibility).radar;
     if (radarEntries.length === 0) {
       this._fullReset();
+      if (input.renderer === "svg" && this.svgGroup) {
+        while (this.svgGroup.firstChild) this.svgGroup.removeChild(this.svgGroup.firstChild);
+      }
       return;
     }
     this._entries = radarEntries;
@@ -587,7 +594,7 @@ var RadarRendererController = class {
       new Set(
         radarEntries.flatMap((ds) => {
           const data = ds.props.data;
-          const cf = ds.props.categoryField;
+          const cf = resolveRadialAccessors(ds.props).angularField;
           if (!data || !cf) return [];
           return data.map((item, i) => typeof cf === "function" ? cf(makeItemContext(item, i)) : item[cf]);
         })
@@ -628,7 +635,10 @@ var RadarRendererController = class {
     const fingerprint = buildRadarFingerprint(targetLayout, radarEntries);
     const dataChanged = fingerprint !== this._lastFingerprint;
     const shouldAnimate = animEnabled && duration > 0 && dataChanged;
-    if (!dataChanged) return;
+    if (!dataChanged) {
+      if (input.renderer === "canvas") input.requestRedraw?.();
+      return;
+    }
     if (this._animRafId !== null) {
       cancelRaf(this._animRafId);
       this._animRafId = null;
@@ -727,9 +737,24 @@ var RadarRendererController = class {
       this.lastInput.requestRedraw?.();
     }
   }
+  /**
+   * Authoritative per-series visibility for hit-testing. The layout's
+   * `sd.visible` is unreliable here: it is forced `true` during a series'
+   * exit fade (so the renderer keeps drawing the fading polygon), and
+   * `_layout` goes stale on the all-hidden path (`_runAllHidden` keeps the
+   * previous layout shell). A toggled-off series can therefore linger with
+   * `visible: true`. The registered entry's `visible` is the real legend
+   * state — fall back to the layout flag only when no entry matches.
+   * Mirrors `buildRadarFingerprint`'s `dsEntry?.visible ?? sd.visible`.
+   */
+  _isEntryVisible(sd) {
+    const entry = this._entries.find((e) => e.id === sd.id);
+    return entry ? entry.visible : sd.visible;
+  }
   hitTest(x, y) {
     if (!this._layout) return null;
-    return hitTestRadar(x, y, this._layout, this.lastInput?.theme ?? defaultLightTheme);
+    const gated = { ...this._layout, series: this._layout.series.filter((sd) => this._isEntryVisible(sd)) };
+    return hitTestRadar(x, y, gated, this.lastInput?.theme ?? defaultLightTheme);
   }
   /**
    * Shared-mode lookup: snap to the nearest spoke (categoryIndex) by angle and
@@ -752,19 +777,20 @@ var RadarRendererController = class {
     let primary = null;
     let bestDist = Infinity;
     for (const sd of layout.series) {
-      if (!sd.visible) continue;
+      if (!this._isEntryVisible(sd)) continue;
       const pt = sd.points.find((p) => p.categoryIndex === categoryIndex);
       if (!pt) continue;
       allSeries.push({
         datasetId: sd.id,
         name: sd.name,
         label,
-        color: sd.color ?? (sd.gradientColor ? getPrimaryColor(sd.gradientColor) : getDefaultColor(sd.seriesIdx, this.lastInput?.theme ?? defaultLightTheme)),
+        color: sd.color ?? (sd.gradientColor ? getPrimaryColor(sd.gradientColor) : getDefaultColor(sd.colorIndex, this.lastInput?.theme ?? defaultLightTheme)),
         colorGradient: sd.gradientColor,
-        swatchColor: resolveSwatchColor({ color: sd.color ?? sd.gradientColor }, sd.seriesIdx, void 0, this.lastInput?.theme),
+        swatchColor: resolveSwatchColor({ color: sd.color ?? sd.gradientColor }, sd.colorIndex, void 0, this.lastInput?.theme),
         value: pt.value,
-        formattedValue: String(pt.value),
-        cursorFormattedValue: String(pt.value),
+        // No pre-formatted value: the HTML tooltip formats the raw value via
+        // `buildTooltipContent` (locale-aware, 2dp). Radar has no crosshair, so
+        // `cursorFormattedValue` is unused.
         snapPixel: Math.sqrt((pt.x - layout.center.x) ** 2 + (pt.y - layout.center.y) ** 2)
       });
       const d = Math.sqrt((pt.x - x) ** 2 + (pt.y - y) ** 2);
@@ -775,9 +801,9 @@ var RadarRendererController = class {
           index: categoryIndex,
           label,
           value: pt.value,
-          color: sd.color ?? (sd.gradientColor ? getPrimaryColor(sd.gradientColor) : getDefaultColor(sd.seriesIdx, this.lastInput?.theme ?? defaultLightTheme)),
+          color: sd.color ?? (sd.gradientColor ? getPrimaryColor(sd.gradientColor) : getDefaultColor(sd.colorIndex, this.lastInput?.theme ?? defaultLightTheme)),
           colorGradient: sd.gradientColor,
-          swatchColor: resolveSwatchColor({ color: sd.color ?? sd.gradientColor }, sd.seriesIdx, void 0, this.lastInput?.theme)
+          swatchColor: resolveSwatchColor({ color: sd.color ?? sd.gradientColor }, sd.colorIndex, void 0, this.lastInput?.theme)
         };
       }
     }

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) {