@primeui/chart-core 0.0.1-alpha.1

package/dist/chunk-PLSDU3C2.mjs

@@ -0,0 +1,890 @@
+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';
+
+// src/series/radar/controller/helpers.ts
+function buildRadarFingerprint(layout, entries) {
+  const parts = [];
+  for (const sd of layout.series) {
+    const dsEntry = entries.find((e) => e.id === sd.id);
+    const visible = dsEntry?.visible ?? sd.visible;
+    const ptHash = sd.points.map((p2) => `${p2.categoryIndex}:${p2.value}:${Math.round(p2.x)}:${Math.round(p2.y)}`).join(",");
+    const p = dsEntry?.props;
+    const visualHash = `sm:${p?.showMarkers}|fo:${p?.fillOpacity}|lw:${p?.lineStrokeWidth}|ls:${p?.lineStyle}|cv:${p?.curve}|c:${sd.color}`;
+    parts.push(`${sd.id}|v:${visible}|${visualHash}|${ptHash}`);
+  }
+  parts.push(`dom:${layout.domain[0]},${layout.domain[1]}`);
+  parts.push(`r:${Math.round(layout.radius)}`);
+  const g = layout.grid;
+  parts.push(`grid:${g.shape}|${g.levels}|${g.color}|${g.opacity}|${g.width}|${g.style}`);
+  return parts.join("||");
+}
+function lerpSeriesFade(fade, now) {
+  if (fade.startTime === -1) {
+    return { fillOpacity: fade.fromFillOpacity, lineStrokeWidth: fade.fromLineStrokeWidth };
+  }
+  const elapsed = now - fade.startTime;
+  const raw = Math.max(0, Math.min(1, elapsed / Math.max(1, fade.duration)));
+  const p = fade.easing(raw);
+  return {
+    fillOpacity: fade.fromFillOpacity + (fade.toFillOpacity - fade.fromFillOpacity) * p,
+    lineStrokeWidth: fade.fromLineStrokeWidth + (fade.toLineStrokeWidth - fade.fromLineStrokeWidth) * p
+  };
+}
+function mergeRadarPropsWithOverrides(overrides, baseProps) {
+  if (!overrides || !baseProps) return baseProps;
+  return { ...baseProps, ...overrides };
+}
+
+// src/series/radar/controller/types.ts
+var RADAR_POINT_REGISTRY = {
+  number: ["x", "y", "value", "baseX", "baseY", "baseValue"],
+  color: []
+};
+function pointKey(seriesId, categoryIndex) {
+  return `${seriesId}::${categoryIndex}`;
+}
+
+// src/series/radar/controller/paint.ts
+function buildRadarSvgChildren(ctx, layout, entries, input) {
+  const children = [];
+  const context = input.chartId ? { chartId: input.chartId } : void 0;
+  const a11y = buildAccessibilityRenderContext(input.features);
+  for (let si = 0; si < layout.series.length; si++) {
+    const ds = entries[si];
+    const mergedProps = ds ? mergeRadarPropsWithOverrides(ctx._propertyOverrides.get(ds.id), ds.props) : void 0;
+    const node = ctx._paint.renderSvg(layout, si, ctx.hoverState, input.theme, ctx.effectConfig, mergedProps, void 0, context);
+    const sd = layout.series[si];
+    if (sd) setAttr(node, "data-dataset", sd.id);
+    if (sd && a11y?.enabled && a11y.landmarkVerbosity === "all") {
+      setAttr(node, "role", "region");
+      setAttr(node, "aria-label", generateSeriesDescription(mergedProps?.name ?? sd.id, "radar", sd.points.length));
+    }
+    children.push(node);
+  }
+  const lc = input.labelConfig;
+  if (lc) {
+    for (let si = 0; si < layout.series.length; si++) {
+      const sd = layout.series[si];
+      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 labelNode = createSvgGroup();
+      renderResolvedLabels(labels, lc, { renderer: "svg", svgGroup: labelNode, theme: input.theme });
+      setAttr(labelNode, "data-layer", `labels-${sd.id}`);
+      children.push(labelNode);
+    }
+  }
+  return children;
+}
+function renderToSvg(ctx, group, layout, entries, input) {
+  group.replaceChildren(...buildRadarSvgChildren(ctx, layout, entries, input).map(materializeSvgNode));
+}
+function renderCanvasContent(ctx, c2d) {
+  const layout = ctx.lastRenderedLayout ?? ctx._layout;
+  if (!layout || ctx._entries.length === 0) return;
+  for (let si = 0; si < layout.series.length; si++) {
+    const ds = ctx._entries[si];
+    const mergedProps = ds ? mergeRadarPropsWithOverrides(ctx._propertyOverrides.get(ds.id), ds.props) : void 0;
+    ctx._paint.renderCanvas(c2d, layout, si, ctx.hoverState, ctx.effectConfig, mergedProps, ctx.lastInput?.theme ?? defaultLightTheme);
+  }
+  const markerEntries = [];
+  for (let si = 0; si < layout.series.length; si++) {
+    const ds = ctx._entries[si];
+    const sd = layout.series[si];
+    if (!ds || !sd.visible) continue;
+    const renderMarkerFn = ds.props.renderMarker;
+    if (!renderMarkerFn) continue;
+    const mergedProps = mergeRadarPropsWithOverrides(ctx._propertyOverrides.get(ds.id), ds.props) ?? ds.props;
+    markerEntries.push({
+      dsId: ds.id,
+      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),
+      markerSize: typeof mergedProps.markerSize === "number" ? mergedProps.markerSize : 4,
+      effects: { dimOpacity: ctx.effectConfig.dimOpacity }
+    });
+  }
+  if (markerEntries.length > 0) {
+    renderCustomMarkersCanvas(c2d, markerEntries, ctx.hoverState);
+  }
+  const lc = ctx.lastInput?.labelConfig;
+  if (lc) {
+    for (let si = 0; si < layout.series.length; si++) {
+      const sd = layout.series[si];
+      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);
+      renderResolvedLabels(labels, lc, { renderer: "canvas", ctx: c2d, theme: ctx.lastInput?.theme ?? defaultLightTheme });
+    }
+  }
+}
+
+// src/series/radar/controller/scene.ts
+function fullReset(ctx) {
+  ctx._layout = null;
+  ctx.lastRenderedLayout = null;
+  setMarkerData(ctx, null);
+  if (ctx._animRafId !== null) {
+    cancelRaf(ctx._animRafId);
+    ctx._animRafId = null;
+  }
+  ctx._scene.reset();
+  ctx._seriesFades.clear();
+  ctx._seriesSettledStyle.clear();
+  ctx._gridLerp = null;
+  ctx._lastSettledDomain = null;
+  ctx._lastFingerprint = "";
+  ctx._firstRender = true;
+  ctx._propertyOverrides.clear();
+}
+function runAllHidden(ctx, features) {
+  const liveCount = ctx._scene.getElements().length;
+  const hasFades = ctx._seriesFades.size > 0;
+  if (liveCount === 0 && !hasFades) {
+    ctx._layout = null;
+    ctx.lastRenderedLayout = null;
+    setMarkerData(ctx, null);
+    if (ctx._animRafId !== null) {
+      cancelRaf(ctx._animRafId);
+      ctx._animRafId = null;
+    }
+    ctx._gridLerp = null;
+    ctx._lastFingerprint = "|EMPTY";
+    return;
+  }
+  const animConfig = features.get("animation")?.props;
+  const { enabled: animEnabled, duration, easing } = parseAnimationConfig(animConfig);
+  const shouldAnimate = animEnabled && duration > 0;
+  const fingerprint = "|EMPTY";
+  if (fingerprint === ctx._lastFingerprint) {
+    if (ctx._animRafId !== null) return;
+    return;
+  }
+  ctx._lastFingerprint = fingerprint;
+  if (ctx._animRafId !== null) {
+    cancelRaf(ctx._animRafId);
+    ctx._animRafId = null;
+  }
+  const opts = { numbers: { duration: shouldAnimate ? duration : 0, easing } };
+  ctx._scene.diff(/* @__PURE__ */ new Map(), opts);
+  const now = performance.now();
+  for (const [seriesId, settled] of ctx._seriesSettledStyle) {
+    if (settled.fillOpacity <= 1e-3 && settled.lineStrokeWidth <= 1e-3) continue;
+    let fromFill = settled.fillOpacity;
+    let fromStroke = settled.lineStrokeWidth;
+    const existing = ctx._seriesFades.get(seriesId);
+    if (existing) {
+      const lerped = lerpSeriesFade(existing, now);
+      fromFill = lerped.fillOpacity;
+      fromStroke = lerped.lineStrokeWidth;
+    }
+    ctx._seriesFades.set(seriesId, {
+      fromFillOpacity: fromFill,
+      toFillOpacity: 0,
+      fromLineStrokeWidth: fromStroke,
+      toLineStrokeWidth: 0,
+      startTime: -1,
+      duration: shouldAnimate ? duration : 0,
+      easing
+    });
+  }
+  ctx._gridLerp = null;
+  if (shouldAnimate) {
+    renderSceneFrame(ctx);
+    startAnimLoop(ctx);
+  } else {
+    ctx._scene.tick(performance.now());
+    if (ctx._scene.getElements().length === 0) {
+      ctx._layout = null;
+      setMarkerData(ctx, null);
+    }
+    ctx._seriesFades.clear();
+    renderSceneFrame(ctx);
+  }
+}
+function updateGridLerp(ctx, targetLayout, shouldAnimate, duration, easing, tickCount) {
+  const isPerSpoke = !!targetLayout.perSpokeDomains && targetLayout.perSpokeDomains.size > 0;
+  let targetDomain;
+  let targetGrid;
+  if (isPerSpoke) {
+    targetDomain = targetLayout.domain;
+    targetGrid = targetLayout.grid;
+  } else {
+    const resolved = resolveSharedRadialGrid(targetLayout.grid, targetLayout.domain, targetLayout.rawDataMax, targetLayout.radius, tickCount);
+    targetDomain = resolved.domain;
+    targetGrid = { ...targetLayout.grid, levels: resolved.levelValues.length, levelValues: resolved.levelValues, levelRadii: resolved.levelRadii };
+  }
+  const prevSettled = ctx._lastSettledDomain;
+  const domainChanged = !prevSettled || prevSettled[0] !== targetDomain[0] || prevSettled[1] !== targetDomain[1];
+  if (shouldAnimate && domainChanged && prevSettled) {
+    const fromDomain = ctx._gridLerp ? currentGridDomain(ctx) : prevSettled;
+    ctx._gridLerp = {
+      fromDomain,
+      toDomain: targetDomain,
+      targetGrid,
+      targetRadius: targetLayout.radius,
+      startTime: -1,
+      duration,
+      easing
+    };
+  } else {
+    ctx._gridLerp = null;
+    ctx._lastSettledDomain = targetDomain;
+  }
+}
+function currentGridDomain(ctx) {
+  if (!ctx._gridLerp) return ctx._lastSettledDomain ?? [0, 0];
+  const { fromDomain, toDomain, startTime, duration, easing } = ctx._gridLerp;
+  if (startTime === -1) return fromDomain;
+  const elapsed = performance.now() - startTime;
+  const raw = Math.max(0, Math.min(1, elapsed / duration));
+  const p = easing(raw);
+  return [fromDomain[0] + (toDomain[0] - fromDomain[0]) * p, fromDomain[1] + (toDomain[1] - fromDomain[1]) * p];
+}
+function buildLayoutFromScene(ctx, now) {
+  if (!ctx._layout) return null;
+  const elementsBySeries = /* @__PURE__ */ new Map();
+  for (const el of ctx._scene.getElements()) {
+    const s = el.current;
+    const list = elementsBySeries.get(s.seriesId);
+    if (list) list.push(s);
+    else elementsBySeries.set(s.seriesId, [s]);
+  }
+  const series = [];
+  for (const targetSd of ctx._layout.series) {
+    const stateList = elementsBySeries.get(targetSd.id);
+    if (!stateList || stateList.length === 0) {
+      continue;
+    }
+    stateList.sort((a, b) => a.categoryIndex - b.categoryIndex);
+    const points = stateList.map((s) => ({
+      x: s.x,
+      y: s.y,
+      value: s.value,
+      angle: s.angle,
+      categoryIndex: s.categoryIndex
+    }));
+    const basePoints = stateList[0].hasBase ? stateList.map((s) => ({
+      x: s.baseX,
+      y: s.baseY,
+      value: s.baseValue,
+      angle: s.angle,
+      categoryIndex: s.categoryIndex
+    })) : void 0;
+    let fillOpacity = targetSd.fillOpacity;
+    let lineStrokeWidth = targetSd.lineStrokeWidth;
+    const fade = ctx._seriesFades.get(targetSd.id);
+    if (fade) {
+      if (fade.startTime === -1) fade.startTime = now;
+      const lerped = lerpSeriesFade(fade, now);
+      fillOpacity = lerped.fillOpacity;
+      lineStrokeWidth = lerped.lineStrokeWidth;
+    } else if (!targetSd.visible) {
+      const settled = ctx._seriesSettledStyle.get(targetSd.id);
+      if (settled) {
+        fillOpacity = settled.fillOpacity;
+        lineStrokeWidth = settled.lineStrokeWidth;
+      }
+    }
+    const overrides = ctx._propertyOverrides.get(targetSd.id);
+    if (overrides) {
+      if (typeof overrides.fillOpacity === "number") fillOpacity = overrides.fillOpacity;
+      if (typeof overrides.lineStrokeWidth === "number") lineStrokeWidth = overrides.lineStrokeWidth;
+    }
+    series.push({
+      ...targetSd,
+      points,
+      basePoints,
+      visible: true,
+      // keep drawn during exit; opacity carries the fade
+      fillOpacity,
+      lineStrokeWidth
+    });
+  }
+  let grid = ctx._layout.grid;
+  let gridAnimating = false;
+  if (ctx._gridLerp) {
+    if (ctx._gridLerp.startTime === -1) ctx._gridLerp.startTime = now;
+    const elapsed = now - ctx._gridLerp.startTime;
+    const raw = Math.max(0, Math.min(1, elapsed / ctx._gridLerp.duration));
+    const p = ctx._gridLerp.easing(raw);
+    grid = interpolateRadialGrid(ctx._gridLerp.fromDomain, ctx._gridLerp.toDomain, ctx._gridLerp.targetGrid, ctx._gridLerp.targetRadius, p);
+    gridAnimating = true;
+    if (raw >= 1) {
+      ctx._lastSettledDomain = ctx._gridLerp.toDomain;
+      ctx._gridLerp = null;
+    }
+  }
+  return { ...ctx._layout, series, grid, gridAnimating };
+}
+function renderSceneFrame(ctx) {
+  const layout = buildLayoutFromScene(ctx, performance.now());
+  if (!layout || !ctx.lastInput) return;
+  ctx.lastRenderedLayout = layout;
+  setMarkerData(ctx, { layout, entries: ctx._entries });
+  if (ctx.lastInput.renderer === "svg" && ctx.svgGroup) {
+    renderToSvg(ctx, ctx.svgGroup, layout, ctx._entries, ctx.lastInput);
+  } else if (ctx.lastInput.renderer === "canvas") {
+    ctx.lastInput.requestRedraw?.();
+  }
+}
+function startAnimLoop(ctx) {
+  if (ctx._animRafId !== null) {
+    cancelRaf(ctx._animRafId);
+  }
+  const tick = (now) => {
+    ctx._animRafId = null;
+    const { allIdle } = ctx._scene.tick(now);
+    for (const [seriesId, fade] of [...ctx._seriesFades]) {
+      if (fade.startTime === -1) continue;
+      const elapsed = now - fade.startTime;
+      const raw = elapsed / Math.max(1, fade.duration);
+      if (raw >= 1) {
+        ctx._seriesSettledStyle.set(seriesId, {
+          fillOpacity: fade.toFillOpacity,
+          lineStrokeWidth: fade.toLineStrokeWidth
+        });
+        ctx._seriesFades.delete(seriesId);
+      }
+    }
+    renderSceneFrame(ctx);
+    ctx.onFrame?.();
+    const fadesActive = ctx._seriesFades.size > 0;
+    if (!allIdle || ctx._gridLerp !== null || fadesActive) {
+      ctx._animRafId = raf(tick);
+    }
+  };
+  ctx._animRafId = raf(tick);
+}
+function setMarkerData(ctx, data) {
+  ctx._markerData = data;
+  ctx.onMarkerDataChange?.(data);
+}
+
+// src/series/radar/controller/index.ts
+function buildPerAxisDomains(entries, yAxes) {
+  if (!yAxes || yAxes.size === 0) return void 0;
+  const result = /* @__PURE__ */ new Map();
+  for (const [axisId, axis] of yAxes) {
+    const rawMin = axis.props.min;
+    const rawMax = axis.props.max;
+    const explicitMin = typeof rawMin === "number" ? rawMin : void 0;
+    const explicitMax = typeof rawMax === "number" ? rawMax : void 0;
+    const axisValues = [];
+    for (const ds of entries) {
+      if (!ds.visible) continue;
+      if (ds.props.yAxisId !== axisId) continue;
+      const data = ds.props.data;
+      const valueField = ds.props.valueField ?? FIELD_DEFAULTS.valueField;
+      if (!data || !valueField) continue;
+      for (let i = 0; i < data.length; i++) {
+        const item = data[i];
+        const v = typeof valueField === "function" ? valueField(makeItemContext(item, i)) : item[valueField];
+        if (typeof v === "number" && isFinite(v)) axisValues.push(v);
+      }
+    }
+    let domainMin;
+    let domainMax;
+    if (explicitMin !== void 0 && explicitMax !== void 0) {
+      domainMin = explicitMin;
+      domainMax = explicitMax;
+    } else {
+      const auto = axisValues.length ? calculateNiceDomain(axisValues, { includeZero: true, nice: true }) : [0, 1];
+      domainMin = explicitMin ?? auto[0];
+      domainMax = explicitMax ?? auto[1];
+    }
+    result.set(axisId, [domainMin, domainMax]);
+  }
+  return result.size ? result : void 0;
+}
+function buildPerSpokeDomains(entries, yAxes, categories, isStacked) {
+  if (!yAxes || yAxes.size === 0 || categories.length === 0) return void 0;
+  const yAxisByCategory = /* @__PURE__ */ new Map();
+  for (const axis of yAxes.values()) {
+    const cat = axis.props.category;
+    if (typeof cat === "string" && cat.length > 0) yAxisByCategory.set(cat, axis);
+  }
+  if (yAxisByCategory.size === 0) return void 0;
+  const valuesPerSpoke = categories.map(() => []);
+  if (isStacked) {
+    const stackedPerSpoke = new Array(categories.length).fill(0);
+    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;
+      if (!data || !valueField || !categoryField) continue;
+      for (let i = 0; i < data.length; i++) {
+        const item = data[i];
+        const cat = typeof categoryField === "function" ? categoryField(makeItemContext(item, i)) : item[categoryField];
+        const v = typeof valueField === "function" ? valueField(makeItemContext(item, i)) : item[valueField];
+        const ci = categories.indexOf(cat);
+        if (ci < 0) continue;
+        if (typeof v !== "number" || !isFinite(v)) continue;
+        stackedPerSpoke[ci] += v;
+      }
+    }
+    for (let ci = 0; ci < categories.length; ci++) valuesPerSpoke[ci].push(stackedPerSpoke[ci]);
+  } else {
+    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;
+      if (!data || !valueField || !categoryField) continue;
+      for (let i = 0; i < data.length; i++) {
+        const item = data[i];
+        const cat = typeof categoryField === "function" ? categoryField(makeItemContext(item, i)) : item[categoryField];
+        const v = typeof valueField === "function" ? valueField(makeItemContext(item, i)) : item[valueField];
+        const ci = categories.indexOf(cat);
+        if (ci < 0) continue;
+        if (typeof v !== "number" || !isFinite(v)) continue;
+        valuesPerSpoke[ci].push(v);
+      }
+    }
+  }
+  const result = /* @__PURE__ */ new Map();
+  for (let ci = 0; ci < categories.length; ci++) {
+    const declared = yAxisByCategory.get(categories[ci]);
+    const rawMin = declared ? declared.props.min : void 0;
+    const rawMax = declared ? declared.props.max : void 0;
+    const explicitMin = typeof rawMin === "number" ? rawMin : void 0;
+    const explicitMax = typeof rawMax === "number" ? rawMax : void 0;
+    let domainMin;
+    let domainMax;
+    if (explicitMin !== void 0 && explicitMax !== void 0) {
+      domainMin = explicitMin;
+      domainMax = explicitMax;
+    } else {
+      const auto = valuesPerSpoke[ci].length ? calculateNiceDomain(valuesPerSpoke[ci], { includeZero: true, nice: true }) : [0, 1];
+      domainMin = explicitMin ?? auto[0];
+      domainMax = explicitMax ?? auto[1];
+    }
+    result.set(ci, [domainMin, domainMax]);
+  }
+  return result;
+}
+var RadarRendererController = class {
+  constructor(paint) {
+    this._animRafId = null;
+    this._lastFingerprint = "";
+    /**
+     * Per-dataset property-animation overrides resolved from AnimatedPropertyStore.
+     * Set by `applyPropertyAnimations()` each property-animation tick and merged
+     * into the rendered output at two places:
+     *   - `_buildLayoutFromScene` — fields that live on RadarSeriesData
+     *     (fillOpacity, lineStrokeWidth) get merged into the per-frame layout.
+     *   - `renderToSvg` / `renderCanvasContent` / `applyHover` — fields that
+     *     the renderers read directly from `ds.props` (markerSize,
+     *     borderStrokeWidth, lineDashOffset, opacity, tension) get spread onto
+     *     a shim props object passed to the radar renderers.
+     *
+     * Tension note: radar's SVG children are rebuilt from the descriptor tree on
+     * every `_renderSceneFrame` — a full render goes through
+     * `replaceChildren(...buildRadarSvgChildren(...).map(materializeSvgNode))`,
+     * while hover diffs the same descriptors through `reconcileSvgChildren`. Either
+     * way the path `d` attribute is recomputed from the rebuilt descriptors when
+     * `tension` changes — no surgical `setAttribute('d', …)` patching is needed
+     * (unlike Line, whose SVG DOM is segmented per-dataset and patched in-place).
+     */
+    this._propertyOverrides = /* @__PURE__ */ new Map();
+    // First-render flag: lets emptyState collapse to center on first diff (matches
+    // createRadarEntranceLayout). After first diff, emptyState collapses to base
+    // (matches toggle-on "ring inflates from base").
+    this._firstRender = true;
+    // Captured before each diff() so the emptyState closure can read center.
+    this._activeCenter = { x: 0, y: 0 };
+    // Per-series opacity fade for stacked enter/exit. Non-stacked series don't fade.
+    this._seriesFades = /* @__PURE__ */ new Map();
+    // Last settled (non-fading) per-series fill/stroke values. Used as the
+    // starting point for the next fade.
+    this._seriesSettledStyle = /* @__PURE__ */ new Map();
+    // Grid lerp (radial axis rings + tick labels).
+    this._gridLerp = null;
+    this._lastSettledDomain = null;
+    // Target layout (reference; bars/points come from the scene per-frame).
+    this._layout = null;
+    // Last frame's rendered layout (read by hover repaint, hit-testing, grid consumers).
+    this.lastRenderedLayout = null;
+    this._entries = [];
+    this.hoverState = { datasetId: null, index: null };
+    this.effectConfig = { hoverBrightness: 1, dimOpacity: 1 };
+    this.lastInput = null;
+    this.svgGroup = null;
+    this._hasRadarDatasets = false;
+    this._markerData = null;
+    this.onFrame = null;
+    this.onMarkerDataChange = null;
+    this._paint = paint;
+    this._scene = new AnimatedScene({
+      // ENTER: on the very first diff, collapse outer + base both to center
+      // (matches createRadarEntranceLayout's "all points at center, value=0").
+      // After the first diff, collapse outer to base (matches toggle-on
+      // "stacked ring inflates from base"; non-stacked has baseX=center.x).
+      emptyState: (target) => {
+        if (this._firstRender) {
+          return {
+            ...target,
+            x: this._activeCenter.x,
+            y: this._activeCenter.y,
+            value: 0,
+            baseX: this._activeCenter.x,
+            baseY: this._activeCenter.y,
+            baseValue: 0
+          };
+        }
+        return { ...target, x: target.baseX, y: target.baseY, value: 0 };
+      },
+      // EXIT: collapse outer to base. For stacked this is the inner ring boundary;
+      // for non-stacked, baseX/baseY === center.x/center.y so collapse → center.
+      exitEmptyState: (target) => ({ ...target, x: target.baseX, y: target.baseY, value: 0 }),
+      registry: RADAR_POINT_REGISTRY
+    });
+  }
+  // ================================================================
+  // PUBLIC API
+  // ================================================================
+  update(input) {
+    this.lastInput = input;
+    this.svgGroup = input.svgGroup ?? null;
+    const { datasets, datasetVisibility, chartArea, features, globalFont, sharedContext, yAxes } = input;
+    this._hasRadarDatasets = Array.from(datasets.values()).some((ds) => ds.type === "radar");
+    if (!this._hasRadarDatasets) {
+      this._fullReset();
+      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();
+      return;
+    }
+    this._entries = radarEntries;
+    const anyVisible = radarEntries.some((e) => e.visible);
+    if (!anyVisible) {
+      this._runAllHidden(features);
+      return;
+    }
+    const perAxisDomains = buildPerAxisDomains(radarEntries, yAxes);
+    const sharedCategoriesForDomain = sharedContext?.categories ?? Array.from(
+      new Set(
+        radarEntries.flatMap((ds) => {
+          const data = ds.props.data;
+          const cf = ds.props.categoryField;
+          if (!data || !cf) return [];
+          return data.map((item, i) => typeof cf === "function" ? cf(makeItemContext(item, i)) : item[cf]);
+        })
+      )
+    );
+    const isStacked = radarEntries.some((ds) => !!ds.props.stackId);
+    const perSpokeDomains = buildPerSpokeDomains(radarEntries, yAxes, sharedCategoriesForDomain, isStacked);
+    const referenceBoundaryValues = [];
+    for (const [key, feat] of features) {
+      if (typeof key === "string" && key.startsWith("referenceBand:")) {
+        const bp = feat.props;
+        if (bp.y1 != null) referenceBoundaryValues.push(bp.y1);
+        if (bp.y2 != null) referenceBoundaryValues.push(bp.y2);
+      } else if (typeof key === "string" && key.startsWith("referenceLine:")) {
+        const lp = feat.props;
+        if (lp.y != null) referenceBoundaryValues.push(lp.y);
+      }
+    }
+    const defaultYAxis = yAxes ? Array.from(yAxes.values()).find((a) => !a.props.category) : void 0;
+    const yAxisProps = defaultYAxis?.props;
+    const baseLayout = calculateRadarLayout(radarEntries, chartArea, globalFont, sharedContext?.categories, sharedContext?.domain, perAxisDomains, referenceBoundaryValues, perSpokeDomains, yAxisProps?.tickCount);
+    if (yAxisProps) {
+      const g = baseLayout.grid;
+      if (yAxisProps.gridShape) g.shape = yAxisProps.gridShape;
+      if (yAxisProps.gridColor !== void 0) g.color = yAxisProps.gridColor;
+      if (yAxisProps.gridOpacity !== void 0) g.opacity = yAxisProps.gridOpacity;
+      if (yAxisProps.gridStrokeWidth !== void 0) g.width = yAxisProps.gridStrokeWidth;
+      if (yAxisProps.gridStyle !== void 0) g.style = yAxisProps.gridStyle;
+    }
+    const targetLayout = {
+      ...baseLayout,
+      datasetIndex: 0
+    };
+    this._layout = targetLayout;
+    this._activeCenter = targetLayout.center;
+    const animConfig = features.get("animation")?.props;
+    const { enabled: animEnabled, duration, easing } = parseAnimationConfig(animConfig);
+    const fingerprint = buildRadarFingerprint(targetLayout, radarEntries);
+    const dataChanged = fingerprint !== this._lastFingerprint;
+    const shouldAnimate = animEnabled && duration > 0 && dataChanged;
+    if (!dataChanged) return;
+    if (this._animRafId !== null) {
+      cancelRaf(this._animRafId);
+      this._animRafId = null;
+    }
+    const sceneTargets = /* @__PURE__ */ new Map();
+    for (const sd of targetLayout.series) {
+      if (!sd.visible) continue;
+      const hasBase = !!sd.basePoints && sd.basePoints.length > 0;
+      for (let pi = 0; pi < sd.points.length; pi++) {
+        const p = sd.points[pi];
+        const base = hasBase ? sd.basePoints[pi] : null;
+        sceneTargets.set(pointKey(sd.id, p.categoryIndex), {
+          x: p.x,
+          y: p.y,
+          value: p.value,
+          baseX: base ? base.x : targetLayout.center.x,
+          baseY: base ? base.y : targetLayout.center.y,
+          baseValue: base ? base.value : 0,
+          seriesId: sd.id,
+          categoryIndex: p.categoryIndex,
+          angle: p.angle,
+          hasBase
+        });
+      }
+    }
+    const opts = { numbers: { duration: shouldAnimate ? duration : 0, easing } };
+    this._scene.diff(sceneTargets, opts);
+    this._lastFingerprint = fingerprint;
+    const now = performance.now();
+    for (const sd of targetLayout.series) {
+      const hasBase = !!sd.basePoints && sd.basePoints.length > 0;
+      const settled = this._seriesSettledStyle.get(sd.id);
+      if (!hasBase) {
+        this._seriesFades.delete(sd.id);
+        this._seriesSettledStyle.set(sd.id, { fillOpacity: sd.fillOpacity, lineStrokeWidth: sd.lineStrokeWidth });
+        continue;
+      }
+      const targetFill = sd.visible ? sd.fillOpacity : 0;
+      const targetStroke = sd.visible ? sd.lineStrokeWidth : 0;
+      const settledFill = settled?.fillOpacity ?? 0;
+      const settledStroke = settled?.lineStrokeWidth ?? 0;
+      if (Math.abs(settledFill - targetFill) < 1e-3 && Math.abs(settledStroke - targetStroke) < 1e-3) {
+        this._seriesFades.delete(sd.id);
+        if (sd.visible) {
+          this._seriesSettledStyle.set(sd.id, { fillOpacity: sd.fillOpacity, lineStrokeWidth: sd.lineStrokeWidth });
+        }
+        continue;
+      }
+      if (!shouldAnimate) {
+        this._seriesFades.delete(sd.id);
+        this._seriesSettledStyle.set(sd.id, { fillOpacity: targetFill, lineStrokeWidth: targetStroke });
+        continue;
+      }
+      let fromFill = settledFill;
+      let fromStroke = settledStroke;
+      const existing = this._seriesFades.get(sd.id);
+      if (existing) {
+        const lerped = lerpSeriesFade(existing, now);
+        fromFill = lerped.fillOpacity;
+        fromStroke = lerped.lineStrokeWidth;
+      }
+      this._seriesFades.set(sd.id, {
+        fromFillOpacity: fromFill,
+        toFillOpacity: targetFill,
+        fromLineStrokeWidth: fromStroke,
+        toLineStrokeWidth: targetStroke,
+        startTime: -1,
+        duration,
+        easing
+      });
+    }
+    const liveSeriesIds = new Set(targetLayout.series.map((s) => s.id));
+    for (const id of [...this._seriesFades.keys()]) {
+      if (!liveSeriesIds.has(id)) this._seriesFades.delete(id);
+    }
+    this._updateGridLerp(targetLayout, shouldAnimate, duration, easing, yAxisProps?.tickCount);
+    if (shouldAnimate) {
+      this._renderSceneFrame();
+      this._startAnimLoop();
+    } else {
+      this._scene.tick(performance.now());
+      this._renderSceneFrame();
+    }
+    this._firstRender = false;
+  }
+  applyHover(hover) {
+    const hoverConfig = this.lastInput?.hoverConfig;
+    this.hoverState = { datasetId: hover.datasetId, index: hover.index, axisIndex: hover.axisIndex ?? null };
+    this.effectConfig = hoverConfig ? { hoverBrightness: hoverConfig.brightness ?? DEFAULT_HOVER_BRIGHTNESS, dimOpacity: hoverConfig.dimOpacity ?? DEFAULT_HOVER_DIM_OPACITY } : { hoverBrightness: 1, dimOpacity: 1 };
+    const layout = this.lastRenderedLayout ?? this._layout;
+    if (!layout || this._entries.length === 0 || !this.lastInput) return;
+    if (this.lastInput.renderer === "svg" && this.svgGroup) {
+      if (this._animRafId !== null) return;
+      reconcileSvgChildren(this.svgGroup, buildRadarSvgChildren(this, layout, this._entries, this.lastInput));
+    } else if (this.lastInput.renderer === "canvas") {
+      this.lastInput.requestRedraw?.();
+    }
+  }
+  hitTest(x, y) {
+    if (!this._layout) return null;
+    return hitTestRadar(x, y, this._layout, this.lastInput?.theme ?? defaultLightTheme);
+  }
+  /**
+   * Shared-mode lookup: snap to the nearest spoke (categoryIndex) by angle and
+   * return every series' point at that spoke as `allSeries` (parity with
+   * cartesian bar/line shared tooltip).
+   */
+  findAllNearest(x, y) {
+    const layout = this.lastRenderedLayout ?? this._layout;
+    if (!layout || layout.series.length === 0 || layout.categories.length === 0) return null;
+    const dx = x - layout.center.x;
+    const dy = y - layout.center.y;
+    const dist = Math.sqrt(dx * dx + dy * dy);
+    if (dist > layout.radius * 1.15) return null;
+    let cursorAngle = Math.atan2(dx, -dy) * (180 / Math.PI);
+    if (cursorAngle < 0) cursorAngle += 360;
+    const angleStep = 360 / layout.categories.length;
+    const categoryIndex = Math.round(cursorAngle / angleStep) % layout.categories.length;
+    const label = layout.categories[categoryIndex] ?? "";
+    const allSeries = [];
+    let primary = null;
+    let bestDist = Infinity;
+    for (const sd of layout.series) {
+      if (!sd.visible) 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)),
+        colorGradient: sd.gradientColor,
+        swatchColor: resolveSwatchColor({ color: sd.color ?? sd.gradientColor }, sd.seriesIdx, void 0, this.lastInput?.theme),
+        value: pt.value,
+        formattedValue: String(pt.value),
+        cursorFormattedValue: String(pt.value),
+        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);
+      if (d < bestDist) {
+        bestDist = d;
+        primary = {
+          datasetId: sd.id,
+          index: categoryIndex,
+          label,
+          value: pt.value,
+          color: sd.color ?? (sd.gradientColor ? getPrimaryColor(sd.gradientColor) : getDefaultColor(sd.seriesIdx, this.lastInput?.theme ?? defaultLightTheme)),
+          colorGradient: sd.gradientColor,
+          swatchColor: resolveSwatchColor({ color: sd.color ?? sd.gradientColor }, sd.seriesIdx, void 0, this.lastInput?.theme)
+        };
+      }
+    }
+    if (!primary) return null;
+    return { primary, allSeries };
+  }
+  renderCanvasContent(ctx) {
+    renderCanvasContent(this, ctx);
+  }
+  get hasData() {
+    return this._hasRadarDatasets;
+  }
+  get layout() {
+    return this.lastRenderedLayout ?? this._layout;
+  }
+  get markerData() {
+    return this._markerData;
+  }
+  destroy() {
+    if (this._animRafId !== null) {
+      cancelRaf(this._animRafId);
+      this._animRafId = null;
+    }
+    this._scene.reset();
+    this._seriesFades.clear();
+    this._seriesSettledStyle.clear();
+    this._gridLerp = null;
+    this._propertyOverrides.clear();
+  }
+  /**
+   * Apply animated property values without triggering a full layout cycle.
+   * Called from the property-animation framework wrapper (RadialRenderer)
+   * each animation tick.
+   *
+   * Per-dataset: writes overrides into `_propertyOverrides` (or deletes the
+   * entry when the store has no live values for it), then triggers a frame
+   * rebuild so `_buildLayoutFromScene` re-merges into the rendered series
+   * and `renderToSvg` / `renderCanvasContent` see the merged props.
+   *
+   * SVG: re-renders imperatively via `_renderSceneFrame`. The wholesale
+   * DOM rebuild covers the `tension` path-rebuild concern — when tension
+   * changes, `buildSmoothPath` / `buildPointsPath` get called fresh by the
+   * next `renderToSvg` pass. Canvas: calls `requestRedraw` so the canvas
+   * pipeline repaints with the merged props baked in.
+   */
+  applyPropertyAnimations(store) {
+    const layout = this._layout;
+    const input = this.lastInput;
+    if (!layout || !input) return;
+    let appliedAny = false;
+    for (const sd of layout.series) {
+      const overrides = resolveAnimatedProps(store, "radar", sd.id, RADAR_ANIMATABLE_PROPS);
+      if (Object.keys(overrides).length === 0) {
+        if (this._propertyOverrides.delete(sd.id)) appliedAny = true;
+        continue;
+      }
+      appliedAny = true;
+      this._propertyOverrides.set(sd.id, overrides);
+    }
+    if (!appliedAny) return;
+    this._renderSceneFrame();
+  }
+  /**
+   * Full re-render of the current scene state.
+   *
+   * Used by the property-animation framework wrapper: when a property
+   * animation completes and its override is released from the store,
+   * `_renderSceneFrame()` rebuilds the series from `_propertyOverrides`-
+   * cleared base values so SVG attributes snap back to the layout-derived
+   * defaults.
+   */
+  renderFrameCycle() {
+    this._renderSceneFrame();
+  }
+  // ================================================================
+  // PRIVATE — delegators to scene / paint sibling modules
+  // ================================================================
+  _fullReset() {
+    fullReset(this);
+  }
+  _runAllHidden(features) {
+    runAllHidden(this, features);
+  }
+  _updateGridLerp(targetLayout, shouldAnimate, duration, easing, tickCount) {
+    updateGridLerp(this, targetLayout, shouldAnimate, duration, easing, tickCount);
+  }
+  _currentGridDomain() {
+    return currentGridDomain(this);
+  }
+  _buildLayoutFromScene(now) {
+    return buildLayoutFromScene(this, now);
+  }
+  _renderSceneFrame() {
+    renderSceneFrame(this);
+  }
+  _startAnimLoop() {
+    startAnimLoop(this);
+  }
+  setMarkerData(data) {
+    setMarkerData(this, data);
+  }
+  buildRadarSvgChildren(layout, entries, input) {
+    return buildRadarSvgChildren(this, layout, entries, input);
+  }
+  renderToSvg(group, layout, entries, input) {
+    renderToSvg(this, group, layout, entries, input);
+  }
+};
+
+export { RadarRendererController };