@primeui/chart-core 0.0.1-alpha.1

package/dist/chunk-TAHCOZHF.mjs

@@ -0,0 +1,1772 @@
+import { detectDatasetTypes, processClickCore, processMouseLeaveCore, processMouseMoveCore, computeThemeDependentFields, computeChartState } from './chunk-3IYSJ2U7.mjs';
+import { calculateRingLayouts, buildPieVisibilityMap, applyRingLayout, computeSliceRadiusRatios, buildSliceStyleData, buildRingTarget, buildHitTestStates } from './chunk-ARB5T6MP.mjs';
+import { computeCartesianLayout } from './chunk-WY4AURRE.mjs';
+import { boxAreaToBounds, computeLabelAwareRadius, buildPieDataLabelLayout } from './chunk-4C6EVJ54.mjs';
+import { calculatePieLayout } from './chunk-RBLZRT5K.mjs';
+import { findSliceAtPoint, isFullCircle } from './chunk-LVMDQ4OJ.mjs';
+import { AnimatedScene, resolveAnimatedProps, PIE_ANIMATABLE_PROPS } from './chunk-VN7CKCSE.mjs';
+import { resolveLegendHoverTarget, resolveLegendClickAction } from './chunk-ZT2Z7ERM.mjs';
+import { reconcileSvgChildren } from './chunk-KP2TWD4Z.mjs';
+import { parseAnimationConfig } from './chunk-3WEMHXZI.mjs';
+import { ResizeDebouncer } from './chunk-KVDEROP6.mjs';
+import { processDimensions } from './chunk-YBJ56XJS.mjs';
+import { cancelRaf, raf } from './chunk-EDAKJLNA.mjs';
+import { INACTIVE_STATE, getNavigableDatasets, handleKeyNavigation, generateAnnouncement } from './chunk-JWFBOPM6.mjs';
+import { hoverConfigToFullEffect } from './chunk-BZN2QHGP.mjs';
+import { buildAccessibilityRenderContext, generateSeriesDescription } from './chunk-OGJ6IIBW.mjs';
+import { collectItems } from './chunk-FFMT6OCO.mjs';
+import { normalizeDataLabelConfig, formatDataLabelText } from './chunk-OXTFAWSK.mjs';
+import { formatCompactValue } from './chunk-XTVE4P3L.mjs';
+import { DEFAULT_HOVER_BRIGHTNESS } from './chunk-NKUYIWAP.mjs';
+import { isDrilldownEnabled, getDrilldownRootLabel } from './chunk-WA3OVISZ.mjs';
+import { FIELD_DEFAULTS, resolveAccessor, makeItemContext, getColorValue, resolveSwatchColor, asGradient, getDefaultColor, defaultLightTheme } from './chunk-O2X6FF45.mjs';
+import { createSvgElement } from './chunk-SSLTFJ3U.mjs';
+import { shallowEqual, warnChartDevOnce } from './chunk-RQ3CKQOX.mjs';
+import { defineComponent } from '@primeui/core';
+
+// src/controllers/AxisRegistrationController.ts
+var AxisRegistrationController = class {
+  constructor(options) {
+    this.stableProps = null;
+    this.options = options;
+  }
+  mount(props) {
+    this.stableProps = props;
+    if (this.options.axis === "x") {
+      this.options.registerX(this.options.id, props);
+    } else {
+      this.options.registerY(this.options.id, props);
+    }
+  }
+  update(props) {
+    if (this.stableProps === null) return;
+    const propsChanged = !shallowEqual(this.stableProps, props);
+    if (!propsChanged) return;
+    this.stableProps = props;
+    if (this.options.axis === "x") {
+      this.options.updateX(this.options.id, props);
+    } else {
+      this.options.updateY(this.options.id, props);
+    }
+  }
+  unmount() {
+    if (this.options.axis === "x") {
+      this.options.unregisterX(this.options.id);
+    } else {
+      this.options.unregisterY(this.options.id);
+    }
+  }
+  // Bypasses the shallowEqual gate — used by chart.redraw() to flush fresh
+  // function references (callbacks, formatters) that shallowEqual would suppress.
+  forceRefresh(props) {
+    if (this.options.axis === "x") {
+      this.options.updateX(this.options.id, props);
+    } else {
+      this.options.updateY(this.options.id, props);
+    }
+  }
+};
+
+// src/controllers/DatasetRegistrationController.ts
+var DatasetRegistrationController = class {
+  constructor(options) {
+    this.stableProps = null;
+    this.prevType = void 0;
+    this.options = options;
+  }
+  mount(props, extras) {
+    this.stableProps = props;
+    const resolvedType = this.resolveType(props);
+    this.prevType = resolvedType;
+    this.options.register(this.options.id, resolvedType, this.mergeProps(props, extras));
+  }
+  update(props, extras) {
+    if (this.stableProps === null) return;
+    const propsChanged = !shallowEqual(this.stableProps, props);
+    if (propsChanged) {
+      this.stableProps = props;
+    }
+    const stable = this.stableProps;
+    if (this.options.typeResolver) {
+      const resolvedType = this.resolveType(stable);
+      if (resolvedType !== this.prevType) {
+        this.options.unregister(this.options.id);
+        this.prevType = resolvedType;
+        this.options.register(this.options.id, resolvedType, this.mergeProps(stable, extras));
+        return;
+      }
+    }
+    if (!propsChanged) return;
+    this.options.update(this.options.id, this.mergeProps(stable, extras));
+  }
+  unmount() {
+    this.options.unregister(this.options.id);
+  }
+  // Bypasses the shallowEqual gate — used by chart.redraw() to flush fresh
+  // function references (callbacks, formatters) that shallowEqual would suppress.
+  forceRefresh(props, extras) {
+    this.options.update(this.options.id, this.mergeProps(props, extras));
+  }
+  resolveType(props) {
+    return this.options.typeResolver ? this.options.typeResolver(props) : this.options.type;
+  }
+  mergeProps(props, extras) {
+    return {
+      ...props,
+      order: extras?.order,
+      stackId: extras?.stackId,
+      rangeId: extras?.rangeId
+    };
+  }
+};
+
+// src/controllers/CartesianLayoutController.ts
+var CartesianLayoutController = class {
+  constructor() {
+    this._lastVisibleLayouts = /* @__PURE__ */ new Map();
+    this._prevInputs = null;
+    this._prevResult = null;
+  }
+  /**
+   * Compute cartesian layout with built-in memoization.
+   * Skips recomputation when layout-affecting inputs are reference-equal to the
+   * previous call — `hover` is intentionally excluded so pointer movement
+   * does not trigger an expensive full layout pass.
+   */
+  compute(input) {
+    if (this._prevInputs !== null && this._prevResult !== null) {
+      if (this._inputsEqual(this._prevInputs, input)) {
+        return this._prevResult;
+      }
+      if (this._inputsEqualExceptTheme(this._prevInputs, input)) {
+        const refreshed = { ...this._prevResult, context: { ...this._prevResult.context, theme: input.theme } };
+        this._prevInputs = input;
+        this._prevResult = refreshed;
+        return refreshed;
+      }
+    }
+    const { hoverConfig, ...rest } = input;
+    const result = computeCartesianLayout({ ...rest, hoverConfig: hoverConfig ? hoverConfigToFullEffect(hoverConfig) : void 0 }, this._lastVisibleLayouts);
+    this._prevInputs = input;
+    this._prevResult = result;
+    return result;
+  }
+  destroy() {
+    this._lastVisibleLayouts.clear();
+    this._prevInputs = null;
+    this._prevResult = null;
+  }
+  _inputsEqual(a, b) {
+    return a.theme === b.theme && this._inputsEqualExceptTheme(a, b);
+  }
+  // Same as `_inputsEqual` but ignores `theme` — used to detect a color-only theme
+  // change so the controller can refresh `context.theme` without recomputing geometry.
+  _inputsEqualExceptTheme(a, b) {
+    return a.cartesianArea === b.cartesianArea && a.datasets === b.datasets && a.axes === b.axes && a.features === b.features && a.datasetVisibility === b.datasetVisibility && a.hoverConfig === b.hoverConfig && a.chartId === b.chartId && a.renderer === b.renderer && a.dimensions.width === b.dimensions.width && a.dimensions.height === b.dimensions.height && a.zoomState === b.zoomState && a.dir === b.dir && a.font === b.font && a.locale === b.locale;
+  }
+};
+
+// src/controllers/ChartStateController.ts
+var ChartStateController = class {
+  constructor() {
+    this._prevInputs = null;
+    this._prevResult = null;
+  }
+  /**
+   * Compute chart state with built-in memoization.
+   *  - Inputs reference-equal to the previous call → return the cached result.
+   *  - Only `theme` changed → reuse the cached (theme-independent) geometry and
+   *    recompute ONLY the theme-dependent style/legend fields (SPREAD-CLONE,
+   *    never mutating the cached result).
+   *  - Otherwise → full `computeChartState`.
+   */
+  compute(inputs) {
+    if (this._prevInputs !== null && this._prevResult !== null) {
+      if (this._inputsEqual(this._prevInputs, inputs)) {
+        return this._prevResult;
+      }
+      if (this._inputsEqualExceptTheme(this._prevInputs, inputs)) {
+        const themeTail = computeThemeDependentFields(inputs, {
+          isCartesian: this._prevResult.isCartesian,
+          datasetTypes: this._prevResult.datasetTypes,
+          titleLayout: this._prevResult.titleLayout,
+          titleConfig: this._prevResult.titleConfig,
+          captionConfig: this._prevResult.captionConfig,
+          titleRO: inputs.ruleOverrides.title,
+          captionRO: inputs.ruleOverrides.caption
+        });
+        const refreshed = { ...this._prevResult, ...themeTail };
+        this._prevInputs = inputs;
+        this._prevResult = refreshed;
+        return refreshed;
+      }
+    }
+    const result = computeChartState(inputs);
+    this._prevInputs = inputs;
+    this._prevResult = result;
+    return result;
+  }
+  destroy() {
+    this._prevInputs = null;
+    this._prevResult = null;
+  }
+  _inputsEqual(a, b) {
+    return a.theme === b.theme && this._inputsEqualExceptTheme(a, b);
+  }
+  // Same as `_inputsEqual` but ignores `theme` — used to detect a color-only theme
+  // change so the controller can refresh the style/legend fields without recomputing
+  // the area geometry. Reference-equality on every other input.
+  _inputsEqualExceptTheme(a, b) {
+    return a.width === b.width && a.height === b.height && a.features === b.features && a.datasets === b.datasets && a.datasetVisibility === b.datasetVisibility && a.hiddenItems === b.hiddenItems && a.axes === b.axes && a.rendererHint === b.rendererHint && a.drilldownIsActive === b.drilldownIsActive && a.measuredCaptionHeight === b.measuredCaptionHeight && a.adaptive === b.adaptive && a.ruleOverrides === b.ruleOverrides && a.globalFontFamily === b.globalFontFamily;
+  }
+};
+
+// src/controllers/KeyboardNavigationController.ts
+var KeyboardNavigationController = class {
+  constructor() {
+    this._state = { ...INACTIVE_STATE };
+    this._lastFocusedIndexMap = /* @__PURE__ */ new Map();
+    /** Called when navigation moves to a point. */
+    this.onNavigate = null;
+    /** Called when navigation resets (mouse move, Escape, or disabled). */
+    this.onReset = null;
+  }
+  get state() {
+    return this._state;
+  }
+  /**
+   * Process a keydown event. Returns true if the key was handled (caller should preventDefault).
+   */
+  handleKeyDown(key, datasets, visibility, config) {
+    const navDatasets = getNavigableDatasets(datasets, visibility);
+    const action = handleKeyNavigation(
+      key,
+      this._state.focusedDatasetId,
+      this._state.focusedIndex,
+      navDatasets,
+      {
+        wrapAround: config?.wrapAround ?? true,
+        seriesMode: config?.seriesNavigation?.mode ?? "normal",
+        rememberPointFocus: config?.seriesNavigation?.rememberPointFocus ?? false
+      },
+      this._lastFocusedIndexMap
+    );
+    if (action.type === "none") return false;
+    this._applyAction(action, datasets);
+    return true;
+  }
+  /**
+   * Activate navigation from a focus event (keyboard Tab into the chart) rather than
+   * a key press, so the focus indicator + screen-reader announcement appear immediately
+   * on focus instead of waiting for the first arrow key. No-op when already active or
+   * there is nothing navigable. Navigates to the remembered point of the first dataset
+   * when `rememberPointFocus` is set, otherwise its first point. Fires `onNavigate`
+   * exactly like an arrow key.
+   *
+   * @returns true if navigation was activated.
+   */
+  activate(datasets, visibility, config) {
+    if (this._state.active) return false;
+    const navDatasets = getNavigableDatasets(datasets, visibility);
+    if (navDatasets.length === 0) return false;
+    const first = navDatasets[0];
+    const remembered = config?.seriesNavigation?.rememberPointFocus ? this._lastFocusedIndexMap.get(first.id) : void 0;
+    const index = remembered != null ? Math.min(remembered, first.dataLength - 1) : 0;
+    this._applyAction({ type: "navigate", datasetId: first.id, index }, datasets);
+    return true;
+  }
+  /** Call on mousemove — resets active keyboard nav. */
+  handleMouseMove() {
+    if (this._state.active) {
+      this._state = { ...INACTIVE_STATE };
+      this.onReset?.();
+    }
+  }
+  reset() {
+    this._state = { ...INACTIVE_STATE };
+  }
+  destroy() {
+    this.reset();
+    this.onNavigate = null;
+    this.onReset = null;
+  }
+  _applyAction(action, datasets) {
+    if (action.type === "navigate") {
+      this._state = {
+        active: true,
+        focusedDatasetId: action.datasetId,
+        focusedIndex: action.index,
+        focusedSection: "series"
+      };
+      this._lastFocusedIndexMap.set(action.datasetId, action.index);
+      const ann = generateAnnouncement(datasets, action.datasetId, action.index);
+      this.onNavigate?.(action.datasetId, action.index, ann);
+    } else if (action.type === "reset") {
+      this._state = { ...INACTIVE_STATE };
+      this.onReset?.();
+    }
+  }
+};
+
+// src/controllers/ResponsiveDimensionsController.ts
+var ResponsiveDimensionsController = class {
+  constructor() {
+    this._observer = null;
+    this._debouncer = null;
+    this._options = {};
+    /** Called with processed dimensions whenever the container resizes. */
+    this.onDimensionsChange = null;
+  }
+  /**
+   * Attach to a container element. Performs an initial synchronous measurement
+   * and begins observing resizes. Call detach() before re-attaching.
+   */
+  attach(containerEl, options) {
+    this.detach();
+    this._options = options;
+    this._debouncer = new ResizeDebouncer({
+      useRAF: options.debounceWithRAF ?? true,
+      delayMs: options.debounceDelay ?? 0
+    });
+    const rect = containerEl.getBoundingClientRect();
+    if (rect.width > 0 && rect.height > 0) {
+      this._emit(rect.width, rect.height);
+    }
+    this._observer = new ResizeObserver((entries) => {
+      const entry = entries[0];
+      if (!entry) return;
+      const { width, height } = entry.contentRect;
+      if (width <= 0 || height <= 0) return;
+      const processed = this._process(width, height);
+      this._debouncer.schedule(processed, (dims) => this._emit(dims.width, dims.height));
+    });
+    this._observer.observe(containerEl);
+  }
+  detach() {
+    this._observer?.disconnect();
+    this._observer = null;
+    this._debouncer?.cancel();
+    this._debouncer = null;
+  }
+  destroy() {
+    this.detach();
+    this.onDimensionsChange = null;
+  }
+  _process(rawWidth, rawHeight) {
+    const { aspectRatio, maxDimensions, maxWidth, maxHeight } = this._options;
+    return processDimensions(rawWidth, rawHeight, {
+      aspectRatio,
+      maxWidth: maxDimensions ? maxWidth : void 0,
+      maxHeight: maxDimensions ? maxHeight : void 0
+    });
+  }
+  _emit(rawWidth, rawHeight) {
+    const { width, height } = this._process(rawWidth, rawHeight);
+    this.onDimensionsChange?.(width, height);
+  }
+};
+
+// src/controllers/DrilldownStateController.ts
+var EMPTY_SNAPSHOT = Object.freeze({
+  currentParentId: null,
+  path: [],
+  enabled: false,
+  isActive: false
+});
+var DrilldownStateController = class {
+  constructor() {
+    this.snapshot = EMPTY_SNAPSHOT;
+    this.subscribers = /* @__PURE__ */ new Set();
+    /** Stable getter — same reference until state actually changes (required for useSyncExternalStore). */
+    this.getSnapshot = () => this.snapshot;
+    this.subscribe = (fn) => {
+      this.subscribers.add(fn);
+      return () => {
+        this.subscribers.delete(fn);
+      };
+    };
+    this.drillInto = (nodeId, label, ancestors) => {
+      const prev = this.snapshot;
+      let nextPath;
+      if (ancestors && ancestors.length > 0) {
+        const existingIds = new Set(prev.path.map((b) => b.id));
+        const missing = ancestors.filter((a) => !existingIds.has(a.id));
+        nextPath = [...prev.path, ...missing, { id: nodeId, label }];
+      } else {
+        nextPath = [...prev.path, { id: nodeId, label }];
+      }
+      this.commit({
+        currentParentId: nodeId,
+        path: nextPath,
+        enabled: prev.enabled,
+        isActive: true
+      });
+    };
+    this.drillToLevel = (index) => {
+      const prev = this.snapshot;
+      if (index < 0 || index >= prev.path.length) return;
+      const newPath = prev.path.slice(0, index + 1);
+      const target = newPath[newPath.length - 1];
+      this.commit({
+        currentParentId: target.id,
+        path: newPath,
+        enabled: prev.enabled,
+        isActive: target.id !== null
+      });
+    };
+  }
+  /**
+   * Sync controller to the current dataset map. Called whenever datasets change.
+   * Recomputes `enabled` and the root breadcrumb label without touching the rest
+   * of the path.
+   */
+  setDatasets(datasets) {
+    const enabled = isDrilldownEnabled(datasets);
+    const prev = this.snapshot;
+    if (!enabled) {
+      if (!prev.enabled && prev.path.length === 0 && prev.currentParentId === null) return;
+      this.commit({ currentParentId: null, path: [], enabled: false, isActive: false });
+      return;
+    }
+    const rootLabel = getDrilldownRootLabel(datasets);
+    let nextPath = prev.path;
+    if (prev.path.length === 0) {
+      nextPath = [{ id: null, label: rootLabel }];
+    } else if (prev.path[0].label !== rootLabel) {
+      nextPath = [{ id: null, label: rootLabel }, ...prev.path.slice(1)];
+    }
+    if (prev.enabled === enabled && nextPath === prev.path) return;
+    this.commit({
+      currentParentId: prev.currentParentId,
+      path: nextPath,
+      enabled,
+      isActive: prev.currentParentId !== null
+    });
+  }
+  commit(next) {
+    this.snapshot = next;
+    for (const fn of this.subscribers) fn();
+  }
+};
+
+// src/chart.logic.ts
+var annotationIdCounter = 0;
+function generateAnnotationId() {
+  return `annotation-${++annotationIdCounter}`;
+}
+function getTooltipConfig(instance) {
+  return instance.$state.features.get("tooltip")?.props;
+}
+function getIsCartesian(instance) {
+  return instance.$state.rendererHint === "cartesian" || instance.$state.rendererHint === "heatmap";
+}
+function getIsRect(instance) {
+  return instance.$state.rendererHint === "rect";
+}
+function getIsSharedMode(tooltipConfig) {
+  return tooltipConfig?.mode === "shared";
+}
+function getHasCrosshair(tooltipConfig) {
+  const crosshair = tooltipConfig?.crosshair;
+  if (typeof crosshair === "boolean") return crosshair;
+  return crosshair?.enabled !== false && crosshair !== void 0;
+}
+function getUseNearestSnap(tooltipConfig, isSharedMode, hasCrosshair) {
+  const snap = tooltipConfig?.snap;
+  return snap !== "none" && (isSharedMode || hasCrosshair || snap != null);
+}
+function useChartLogic(instance) {
+  const { $props, $state, $emit } = instance;
+  const onMouseMove = (x, y) => {
+    const tooltipConfig = getTooltipConfig(instance);
+    const isCartesian = getIsCartesian(instance);
+    const isSharedMode = getIsSharedMode(tooltipConfig);
+    const hasCrosshair = getHasCrosshair(tooltipConfig);
+    const ctx = {
+      isCartesian,
+      isRect: getIsRect(instance),
+      isSharedMode,
+      hasCrosshair,
+      useNearestSnap: getUseNearestSnap(tooltipConfig, isSharedMode, hasCrosshair),
+      dir: $props.dir,
+      delegate: $props.rendererDelegate,
+      syncInfo: $props.syncInfo,
+      datasets: $state.datasets,
+      width: $props.width,
+      height: $props.height
+    };
+    const result = processMouseMoveCore(x, y, ctx, $state.lastHover, tooltipConfig);
+    $emit("tooltip-change", result.tooltip);
+    if (result.hoverUpdate) {
+      $emit("hover-change", result.hoverUpdate);
+    }
+    if (result.cursor !== $state.cursor) {
+      $emit("cursor-change", result.cursor);
+    }
+    if (result.syncBroadcast) {
+      $emit("sync-broadcast", result.syncBroadcast);
+    }
+  };
+  const onMouseLeave = () => {
+    const result = processMouseLeaveCore($state.lastHover, $props.syncInfo, getIsRect(instance));
+    $emit("tooltip-change", null);
+    if (result.clearHover) {
+      $emit("hover-change", { datasetId: null, index: null });
+    }
+    if (result.cursor !== $state.cursor) {
+      $emit("cursor-change", result.cursor);
+    }
+    if (result.syncBroadcast) {
+      $emit("sync-broadcast", result.syncBroadcast);
+    }
+    if (result.clearRectOverlay) {
+      $emit("rect-hover-update", null);
+    }
+  };
+  const onClick = (x, y) => {
+    const result = processClickCore(x, y, {
+      isCartesian: getIsCartesian(instance),
+      isRect: getIsRect(instance),
+      delegate: $props.rendererDelegate,
+      onClickCb: $props.onClickCb,
+      drilldownEnabled: $props.drilldownEnabled
+    });
+    switch (result.kind) {
+      case "callback":
+        $emit("click-callback", { datasetId: result.datasetId, index: result.index, label: result.label, value: result.value, color: result.color });
+        break;
+      case "toggleDataset":
+        $emit("dataset-toggle", result.datasetId);
+        break;
+      case "toggleItem":
+        $emit("item-toggle", { datasetId: result.datasetId, index: result.index });
+        break;
+      case "drilldown":
+        $emit("tooltip-change", null);
+        $emit("hover-change", { datasetId: null, index: null });
+        $emit("rect-hover-update", null);
+        $emit("drilldown");
+        break;
+    }
+  };
+  const onLegendClick = (item) => {
+    if ($props.onLegendClickCb) {
+      $emit("legend-callback", { datasetId: item.datasetId, index: item.index, label: item.label, type: item.type });
+      return;
+    }
+    const isCartesian = getIsCartesian(instance);
+    const isRect = getIsRect(instance);
+    const { hasRadarDatasets, hasPolarDatasets } = detectDatasetTypes($state.datasets);
+    const result = resolveLegendClickAction(item, {
+      isCartesian,
+      isRect,
+      hasRadarDatasets,
+      hasPolarDatasets,
+      datasets: $state.datasets,
+      hiddenItems: $state.hiddenItems
+    });
+    switch (result.kind) {
+      case "toggleDataset":
+        $emit("dataset-toggle", result.datasetId);
+        break;
+      case "toggleItems":
+        $emit("items-toggle", { datasetId: result.datasetId, indices: result.indices });
+        break;
+    }
+  };
+  const onLegendHover = (item) => {
+    const isCartesian = getIsCartesian(instance);
+    const { hasRadarDatasets, hasPolarDatasets } = detectDatasetTypes($state.datasets);
+    const target = resolveLegendHoverTarget(item, { isCartesian, hasRadarDatasets, hasPolarDatasets });
+    $emit("legend-hover", target ?? { datasetId: null, index: null });
+  };
+  const onSyncedResult = (result) => {
+    $emit("tooltip-change", result.tooltip);
+    const hoverChanged = $state.lastHover.datasetId !== result.hoverDatasetId || $state.lastHover.index !== result.hoverIndex;
+    if (hoverChanged) {
+      $emit("hover-change", { datasetId: result.hoverDatasetId, index: result.hoverIndex, axisIdx: result.axisIdx, axisX: result.axisX });
+    }
+    const newCursor = result.hoverDatasetId !== null ? "pointer" : "default";
+    if (newCursor !== $state.cursor) {
+      $emit("cursor-change", newCursor);
+    }
+  };
+  const registerDataset = (id, type, props) => {
+    const order = $state.orderCounter;
+    const propsRec = props;
+    const storedProps = propsRec.order === void 0 ? { ...propsRec, order } : props;
+    if ($state.datasets.has(id)) {
+      warnChartDevOnce(`duplicate-dataset-id:${id}`, `Duplicate dataset id "${id}" \u2014 the later series overwrites the earlier one in the registry, so they cannot be shown, toggled, or hit-tested independently. Give each series a unique id.`);
+    }
+    $state.datasets.set(id, { id, type, props: storedProps, order });
+    $state.orderCounter++;
+    $state.datasetVisibility.set(id, true);
+    $emit("state-changed");
+  };
+  const unregisterDataset = (id) => {
+    $state.datasets.delete(id);
+    $state.datasetVisibility.delete(id);
+    $state.hiddenItems.delete(id);
+    $emit("state-changed");
+  };
+  const updateDataset = (id, props) => {
+    const existing = $state.datasets.get(id);
+    if (!existing) return;
+    const propsRec = props;
+    const storedProps = propsRec.order === void 0 ? { ...propsRec, order: existing.order } : props;
+    if (shallowEqual(existing.props, storedProps)) {
+      return;
+    }
+    $state.datasets.set(id, { ...existing, props: storedProps });
+    $emit("state-changed");
+  };
+  const registerXAxis = (id, props) => {
+    $state.axes.x.set(id, { id, axis: "x", props });
+    $emit("state-changed");
+  };
+  const updateXAxis = (id, props) => {
+    const existing = $state.axes.x.get(id);
+    if (!existing) return;
+    if (shallowEqual(existing.props, props)) {
+      return;
+    }
+    $state.axes.x.set(id, { ...existing, props });
+    $emit("state-changed");
+  };
+  const unregisterXAxis = (id) => {
+    $state.axes.x.delete(id);
+    $emit("state-changed");
+  };
+  const registerYAxis = (id, props) => {
+    $state.axes.y.set(id, { id, axis: "y", props });
+    $emit("state-changed");
+  };
+  const updateYAxis = (id, props) => {
+    const existing = $state.axes.y.get(id);
+    if (!existing) return;
+    if (shallowEqual(existing.props, props)) {
+      return;
+    }
+    $state.axes.y.set(id, { ...existing, props });
+    $emit("state-changed");
+  };
+  const unregisterYAxis = (id) => {
+    $state.axes.y.delete(id);
+    $emit("state-changed");
+  };
+  const registerCustomization = (type, props) => {
+    const existing = $state.features.get(type);
+    if (existing && shallowEqual(existing.props, props)) {
+      return;
+    }
+    $state.features.set(type, { type, props });
+    $emit("state-changed");
+  };
+  const unregisterCustomization = (type) => {
+    $state.features.delete(type);
+    $emit("state-changed");
+  };
+  const registerAnnotation = (render) => {
+    const id = generateAnnotationId();
+    $state.annotations.set(id, render);
+    $emit("state-changed");
+    return id;
+  };
+  const unregisterAnnotation = (id) => {
+    $state.annotations.delete(id);
+    $emit("state-changed");
+  };
+  const toggleDatasetVisibility = (datasetId) => {
+    const current = $state.datasetVisibility.get(datasetId) ?? true;
+    $state.datasetVisibility.set(datasetId, !current);
+    $emit("state-changed");
+  };
+  const setDatasetVisibility = (datasetId, visible) => {
+    if (($state.datasetVisibility.get(datasetId) ?? true) === visible) return;
+    $state.datasetVisibility.set(datasetId, visible);
+    $emit("state-changed");
+  };
+  const toggleItemVisibility = (datasetId, index) => {
+    const existing = $state.hiddenItems.get(datasetId);
+    const hiddenSet = new Set(existing || []);
+    if (hiddenSet.has(index)) {
+      hiddenSet.delete(index);
+    } else {
+      hiddenSet.add(index);
+    }
+    $state.hiddenItems.set(datasetId, hiddenSet);
+    $emit("state-changed");
+  };
+  const setRendererHint = (hint) => {
+    if ($state.rendererHint === hint) return;
+    $state.rendererHint = hint;
+    $emit("state-changed");
+  };
+  return {
+    onMouseMove,
+    onMouseLeave,
+    onClick,
+    onLegendClick,
+    onLegendHover,
+    onSyncedResult,
+    registerDataset,
+    unregisterDataset,
+    updateDataset,
+    registerXAxis,
+    updateXAxis,
+    unregisterXAxis,
+    registerYAxis,
+    updateYAxis,
+    unregisterYAxis,
+    registerCustomization,
+    unregisterCustomization,
+    registerAnnotation,
+    unregisterAnnotation,
+    toggleDatasetVisibility,
+    setDatasetVisibility,
+    toggleItemVisibility,
+    setRendererHint
+  };
+}
+
+// src/chart.props.ts
+var defaultChartCoreProps = {
+  width: 0,
+  height: 0,
+  dir: "ltr",
+  theme: {},
+  rendererDelegate: null,
+  syncInfo: null,
+  onClickCb: void 0,
+  onLegendClickCb: void 0,
+  drilldownEnabled: false
+};
+
+// src/chart.refs.ts
+var defaultChartCoreRefs = {
+  container: null
+};
+
+// src/chart.state.ts
+function createDefaultChartCoreState() {
+  return {
+    tooltip: null,
+    lastHover: { datasetId: null, index: null },
+    cursor: "default",
+    datasets: /* @__PURE__ */ new Map(),
+    datasetVisibility: /* @__PURE__ */ new Map(),
+    hiddenItems: /* @__PURE__ */ new Map(),
+    axes: { x: /* @__PURE__ */ new Map(), y: /* @__PURE__ */ new Map() },
+    features: /* @__PURE__ */ new Map(),
+    annotations: /* @__PURE__ */ new Map(),
+    orderCounter: 0,
+    rendererHint: null
+  };
+}
+
+// src/createChart.ts
+var createChart = defineComponent("Chart", ({ getCurrentInstance, defineRefs, defineProps, defineState, defineEmits, defineExpose }) => {
+  defineRefs(defaultChartCoreRefs);
+  defineProps(defaultChartCoreProps);
+  defineState(createDefaultChartCoreState());
+  defineEmits(["tooltip-change", "hover-change", "cursor-change", "sync-broadcast", "rect-hover-update", "click-callback", "dataset-toggle", "item-toggle", "items-toggle", "drilldown", "legend-callback", "legend-hover", "state-changed"]);
+  const currentInstance = getCurrentInstance();
+  const expose = useChartLogic(currentInstance);
+  defineExpose(expose);
+});
+
+// src/series/pie/controller/data-labels.ts
+function buildDataLabelDatasetProps(pieEntries) {
+  const map = /* @__PURE__ */ new Map();
+  for (const entry of pieEntries) {
+    map.set(entry.order, {
+      label: entry.props.categoryField,
+      data: entry.props.data
+    });
+  }
+  return map;
+}
+function buildPieLabelConfigs(layout, labelConfig, theme) {
+  const configs = [];
+  const total = layout.visibleSlices.reduce((sum, s) => sum + Math.abs(s.value), 0);
+  for (const slice of layout.visibleSlices) {
+    const percentage = total > 0 ? Math.abs(slice.value) / total * 100 : 0;
+    const midAngle = (slice.rotation + slice.endAngle) / 2;
+    const text = formatDataLabelText(slice.value, percentage, labelConfig.display) ?? String(slice.value);
+    const colorIdx = slice.dataIndex;
+    const sliceColor = typeof layout.colors[colorIdx] === "string" ? layout.colors[colorIdx] : getDefaultColor(colorIdx, theme ?? defaultLightTheme);
+    configs.push({ text, angle: midAngle, index: slice.dataIndex, value: slice.value, percentage, color: sliceColor });
+  }
+  return configs;
+}
+function renderSvgDataLabels(lg, frame, labelConfig, input, datasetPropsMap) {
+  const built = buildPieDataLabelLayout(frame, labelConfig, { width: input.width, height: input.height }, datasetPropsMap);
+  if (!built) return;
+  const { labelLayout, configsByIndex } = built;
+  const textColor = labelConfig.color;
+  const center = frame.center;
+  const renderFn = input.features.get("dataLabels")?.props?.render;
+  const fontSize = labelConfig.fontSize ?? 11;
+  const fontFamily = labelConfig.fontFamily ?? "sans-serif";
+  const fontWeight = labelConfig.fontWeight ?? "normal";
+  const textOffset = labelConfig.textOffset ?? 0;
+  const lineHeight = labelConfig.lineHeight ?? 1.2;
+  const lineStyle = labelConfig.lineStyle ?? "elbow";
+  for (const labelItem of labelLayout.labels) {
+    const { leaderLine, lines, side, color: lineColor } = labelItem;
+    const g = createSvgElement("g");
+    g.setAttribute("style", "pointer-events: none");
+    if (renderFn) {
+      const originalConfig = configsByIndex.get(labelItem.index);
+      const absLeaderLine = {
+        x1: center.x + leaderLine.x1,
+        y1: center.y + leaderLine.y1,
+        x2: center.x + leaderLine.x2,
+        y2: center.y + leaderLine.y2,
+        x3: center.x + leaderLine.x3,
+        y3: center.y + leaderLine.y3
+      };
+      const textX = center.x + labelItem.x + (side === "right" ? textOffset : -textOffset);
+      const textY = center.y + labelItem.y;
+      void renderFn({
+        index: labelItem.index,
+        value: labelItem.value,
+        percentage: labelItem.percentage,
+        formattedText: labelItem.text,
+        label: originalConfig?.label ?? "",
+        // Per-label color override wins over the leader-line/slice color in the custom render context.
+        color: labelItem.textColor ?? textColor ?? lineColor,
+        x: textX,
+        y: textY,
+        side,
+        leaderLine: absLeaderLine,
+        center: { x: center.x, y: center.y }
+      });
+    } else {
+      if (lineStyle !== "none") {
+        const lineEl = createSvgElement("polyline");
+        if (lineStyle === "straight") {
+          lineEl.setAttribute("points", `${center.x + leaderLine.x1},${center.y + leaderLine.y1} ${center.x + leaderLine.x3},${center.y + leaderLine.y3}`);
+        } else {
+          lineEl.setAttribute("points", `${center.x + leaderLine.x1},${center.y + leaderLine.y1} ${center.x + leaderLine.x2},${center.y + leaderLine.y2} ${center.x + leaderLine.x3},${center.y + leaderLine.y3}`);
+        }
+        lineEl.setAttribute("fill", "none");
+        lineEl.setAttribute("stroke", labelItem.connectorColor ?? lineColor);
+        lineEl.setAttribute("stroke-width", String(labelItem.connectorWidth ?? 1));
+        g.appendChild(lineEl);
+      }
+      const isNone = lineStyle === "none";
+      const textX = isNone ? center.x + labelItem.x : center.x + labelItem.x + (side === "right" ? textOffset : -textOffset);
+      const textY = center.y + labelItem.y;
+      const itemFontSize = labelItem.fontSize ?? fontSize;
+      const itemTextColor = labelItem.textColor ?? textColor;
+      for (let li = 0; li < lines.length; li++) {
+        const lineY = textY - (lines.length - 1) * itemFontSize * lineHeight / 2 + li * itemFontSize * lineHeight;
+        const textEl = createSvgElement("text");
+        textEl.setAttribute("x", String(textX));
+        textEl.setAttribute("y", String(lineY));
+        textEl.setAttribute("text-anchor", isNone ? "middle" : side === "right" ? "start" : "end");
+        textEl.setAttribute("dominant-baseline", "central");
+        textEl.setAttribute("font-size", String(itemFontSize));
+        textEl.setAttribute("font-family", fontFamily);
+        textEl.setAttribute("font-weight", fontWeight);
+        textEl.setAttribute("class", "p-chart-data-label");
+        if (itemTextColor) textEl.setAttribute("style", `fill: ${itemTextColor}`);
+        textEl.textContent = lines[li];
+        g.appendChild(textEl);
+      }
+    }
+    lg.appendChild(g);
+  }
+}
+
+// src/series/pie/controller/sort-animation.ts
+function detectSortOrderChange(prevVisibleOrder, newVisibleOrder) {
+  const old = prevVisibleOrder;
+  if (old.length !== newVisibleOrder.length) return false;
+  if (old.length === 0) return false;
+  const toRingMap = (ids) => {
+    const m = /* @__PURE__ */ new Map();
+    for (const id of ids) {
+      const dsIdx = parseInt(id.split("-")[0]);
+      if (!m.has(dsIdx)) m.set(dsIdx, []);
+      m.get(dsIdx).push(id);
+    }
+    return m;
+  };
+  const oldByRing = toRingMap(old);
+  const newByRing = toRingMap(newVisibleOrder);
+  for (const [dsIdx, newOrder] of newByRing) {
+    const oldOrder = oldByRing.get(dsIdx) ?? [];
+    if (oldOrder.length !== newOrder.length) return false;
+    const oldSet = new Set(oldOrder);
+    for (const id of newOrder) {
+      if (!oldSet.has(id)) return false;
+    }
+  }
+  for (const [dsIdx, newOrder] of newByRing) {
+    const oldOrder = oldByRing.get(dsIdx);
+    for (let i = 0; i < newOrder.length; i++) {
+      if (oldOrder[i] !== newOrder[i]) return true;
+    }
+  }
+  return false;
+}
+
+// src/series/pie/controller/types.ts
+var PIE_SLICE_SCENE_REGISTRY = {
+  number: ["rotation", "endAngle", "radiusRatio", "value", "percentage", "innerRadius", "outerRadius"],
+  color: []
+};
+
+// src/series/pie/controller/render.ts
+function renderFrame(ctx, slices, renderer, input) {
+  if (!ctx._animationLayout) return;
+  ctx._lastRenderedSlices = slices;
+  ctx._hitTestStates = buildHitTestStates(slices);
+  const { center, outerRadius, innerRadius, sweepAngle, borderAlign, borderJoinStyle } = ctx._animationLayout;
+  const visibleSliceCount = slices.filter((s) => s.targetAngle > 1).length;
+  const frame = {
+    slices,
+    center,
+    outerRadius,
+    innerRadius,
+    baseRotation: ctx._baseRotation,
+    fullCircle: isFullCircle(sweepAngle),
+    willBeSingleSlice: visibleSliceCount <= 1,
+    currentRingRadii: ctx._currentRingRadii,
+    // Hover comes from the controller-owned `hoverState` field (written by
+    // applyHover), NOT `input.hover` — so the anim tick paints live hover and
+    // hover-during-animation deferral stays correct. The datasetId→datasetIndex
+    // mapping is preserved (same as the previous `input.hover` derivation).
+    hoverState: { datasetId: ctx.hoverState.datasetId, index: ctx.hoverState.index, datasetIndex: ctx.hoverState.datasetId != null ? ctx._pieEntries.find((e) => e.id === ctx.hoverState.datasetId)?.order ?? null : null },
+    hoverOffset: ctx._hoverOffset,
+    hoverScale: ctx._hoverScale,
+    borderAlign,
+    borderJoinStyle
+  };
+  const hoverConfig = input.hoverConfig;
+  if (renderer === "canvas" && ctx._canvasEl) {
+    const canvasCtx = ctx._canvasEl.getContext("2d");
+    if (canvasCtx) {
+      canvasCtx.clearRect(0, 0, ctx._canvasEl.width, ctx._canvasEl.height);
+      ctx._paint.renderCanvasSlices(canvasCtx, frame, hoverConfig, input.theme);
+      const dlProps = input.features.get("dataLabels")?.props;
+      const labelConfig = normalizeDataLabelConfig(dlProps, input.adaptiveDataLabelFontSize, void 0, input.globalFont);
+      if (labelConfig) {
+        const datasetPropsMap = buildDataLabelDatasetProps(ctx._pieEntries);
+        const onImageLoad = () => {
+          if (ctx._imageRepaintRaf !== null) return;
+          ctx._imageRepaintRaf = raf(() => {
+            ctx._imageRepaintRaf = null;
+            if (ctx._lastRenderedSlices.length > 0 && ctx._lastInput) {
+              renderFrame(ctx, ctx._lastRenderedSlices, renderer, ctx._lastInput);
+              ctx.onFrame?.();
+            }
+          });
+        };
+        ctx._paint.renderCanvasDataLabels(canvasCtx, frame, { x: 0, y: 0, width: input.width, height: input.height }, labelConfig, labelConfig.color ?? input.theme.dataLabel, datasetPropsMap, hoverConfig, input.theme, onImageLoad);
+      }
+      if (ctx._sliceRenderFns.size > 0) {
+        const onImageLoad = () => {
+          if (ctx._imageRepaintRaf !== null) return;
+          ctx._imageRepaintRaf = raf(() => {
+            ctx._imageRepaintRaf = null;
+            if (ctx._lastRenderedSlices.length > 0 && ctx._lastInput) {
+              renderFrame(ctx, ctx._lastRenderedSlices, renderer, ctx._lastInput);
+              ctx.onFrame?.();
+            }
+          });
+        };
+        ctx._paint.renderCanvasContent(canvasCtx, frame, ctx._sliceRenderFns, onImageLoad, input.theme, input.globalFont?.family);
+      }
+    }
+  }
+  if (renderer === "svg" && ctx._svgGroup) {
+    const chartGroup = ctx._svgGroup;
+    ctx._pathElements.clear();
+    ctx._sliceGroups.clear();
+    ctx._contentSlots.clear();
+    for (const pieEntry of ctx._pieEntries) {
+      const datasetGroup = chartGroup.querySelector(`[data-dataset="${pieEntry.id}"]`);
+      if (!datasetGroup) continue;
+      reconcileSvgChildren(datasetGroup, ctx._paint.buildSvgChildren(frame, hoverConfig, input.theme, input.chartId, pieEntry.order));
+      registerSvgSliceElements(ctx, datasetGroup, pieEntry.order);
+    }
+    ctx._paint.updateCustomContent(frame, { customContent: ctx._customContent, renderFns: ctx._sliceRenderFns }, input.theme, input.globalFont?.family);
+    const lg = ctx._labelGroup;
+    if (lg) {
+      while (lg.firstChild) lg.removeChild(lg.firstChild);
+      const dlProps = input.features.get("dataLabels")?.props;
+      const labelConfig = normalizeDataLabelConfig(dlProps, input.adaptiveDataLabelFontSize, void 0, input.globalFont);
+      if (labelConfig) {
+        renderSvgDataLabels(lg, frame, labelConfig, input, buildDataLabelDatasetProps(ctx._pieEntries));
+      }
+    }
+  }
+}
+function registerSvgSliceElements(ctx, renderedGroup, datasetIndex) {
+  renderedGroup.querySelectorAll("[data-slice-index]").forEach((el) => {
+    const sliceIndex = el.getAttribute("data-slice-index");
+    if (sliceIndex !== null) {
+      const key = `${datasetIndex}-${sliceIndex}`;
+      ctx._sliceGroups.set(key, el);
+      const pathEl = el.querySelector("path");
+      if (pathEl) ctx._pathElements.set(key, pathEl);
+      const contentSlot = el.querySelector(".slice-content");
+      if (contentSlot) ctx._contentSlots.set(key, contentSlot);
+    }
+  });
+}
+
+// src/series/pie/controller/scene.ts
+function startAnimLoop(ctx) {
+  if (ctx._animRafId !== null) {
+    cancelRaf(ctx._animRafId);
+  }
+  const tick = (now) => {
+    ctx._animRafId = null;
+    const { allIdle } = ctx._scene.tick(now);
+    if (ctx._lastInput) {
+      const slices = buildSlicesFromScene(ctx);
+      renderFrame(ctx, slices, ctx._lastInput.renderer, ctx._lastInput);
+      ctx.onFrame?.();
+    }
+    if (!allIdle) {
+      ctx._animRafId = raf(tick);
+    } else {
+      ctx._orderChanged = false;
+    }
+  };
+  ctx._animRafId = raf(tick);
+}
+function snapshotAccumulatedPositions(ctx) {
+  const ringOrder = /* @__PURE__ */ new Map();
+  for (const id of ctx._sceneTargetOrder) {
+    const dsIdx = parseInt(id.split("-")[0]);
+    if (!ringOrder.has(dsIdx)) ringOrder.set(dsIdx, []);
+    ringOrder.get(dsIdx).push(id);
+  }
+  for (const el of ctx._scene.getElements()) {
+    if (el.phase !== "exit") continue;
+    const dsIdx = parseInt(el.id.split("-")[0]);
+    if (!ringOrder.has(dsIdx)) ringOrder.set(dsIdx, []);
+    ringOrder.get(dsIdx).push(el.id);
+  }
+  for (const [, ids] of ringOrder) {
+    let currentRotation = ctx._baseRotation;
+    for (const id of ids) {
+      const el = ctx._scene.getElement(id);
+      if (!el) continue;
+      const span = el.current.endAngle - el.current.rotation;
+      if (span < 1e-3) continue;
+      el.current.rotation = currentRotation;
+      el.current.endAngle = currentRotation + span;
+      currentRotation = el.current.endAngle;
+    }
+  }
+}
+function buildSlicesFromScene(ctx) {
+  const result = [];
+  const ringOrder = /* @__PURE__ */ new Map();
+  for (const id of ctx._sceneTargetOrder) {
+    const dsIdx = parseInt(id.split("-")[0]);
+    if (!ringOrder.has(dsIdx)) ringOrder.set(dsIdx, []);
+    ringOrder.get(dsIdx).push(id);
+  }
+  for (const el of ctx._scene.getElements()) {
+    if (el.phase !== "exit") continue;
+    const dsIdx = parseInt(el.id.split("-")[0]);
+    if (!ringOrder.has(dsIdx)) ringOrder.set(dsIdx, []);
+    ringOrder.get(dsIdx).push(el.id);
+  }
+  for (const [, ids] of ringOrder) {
+    let currentRotation = ctx._baseRotation;
+    for (const id of ids) {
+      const el = ctx._scene.getElement(id);
+      if (!el) continue;
+      const { value, percentage, radiusRatio, innerRadius, outerRadius } = el.current;
+      let rotation;
+      let endAngle;
+      if (ctx._orderChanged) {
+        rotation = el.current.rotation;
+        endAngle = el.current.endAngle;
+        if (endAngle - rotation < 1e-3) continue;
+      } else {
+        const span = el.current.endAngle - el.current.rotation;
+        if (span < 1e-3) continue;
+        rotation = currentRotation;
+        endAngle = currentRotation + span;
+        currentRotation = endAngle;
+      }
+      const parts = id.split("-");
+      const datasetIndex = parseInt(parts[0]);
+      const style = ctx._styleData.get(id) ?? ctx._prevStyleData.get(id);
+      const targetState = ctx._sceneTargetMap.get(id);
+      const isExiting = el.phase === "exit";
+      const pieEntry = ctx._pieEntries.find((e) => e.order === datasetIndex);
+      const overrides = pieEntry ? ctx._propertyOverrides.get(pieEntry.id) : void 0;
+      const effectiveInner = overrides && typeof overrides.innerRadius === "number" ? overrides.innerRadius : innerRadius;
+      const effectiveOuter = overrides && typeof overrides.outerRadius === "number" ? overrides.outerRadius : outerRadius;
+      ctx._currentRingRadii.set(parts[0], { inner: effectiveInner, outer: effectiveOuter });
+      const originalIndex = parseInt(parts[1]);
+      const entryData = pieEntry?.props?.data ?? [];
+      const rawOffsetProp = pieEntry?.props?.offset;
+      const baseOffsetResolved = rawOffsetProp != null ? resolveAccessor(rawOffsetProp, makeItemContext(entryData[originalIndex], originalIndex), { arrayMode: "clip", fallback: 0 }) ?? 0 : 0;
+      const rawOpacityProp = pieEntry?.props?.opacity;
+      const userOpacityResolved = rawOpacityProp != null ? resolveAccessor(rawOpacityProp, makeItemContext(entryData[originalIndex], originalIndex), { arrayMode: "clip", fallback: 1 }) ?? 1 : 1;
+      const effectiveBaseOffset = overrides && typeof overrides.offset === "number" ? overrides.offset : baseOffsetResolved;
+      const effectiveUserOpacity = overrides && typeof overrides.opacity === "number" ? overrides.opacity : userOpacityResolved;
+      const effectiveBorderStrokeWidth = overrides && typeof overrides.borderStrokeWidth === "number" ? overrides.borderStrokeWidth : style?.borderStrokeWidth;
+      const effectiveSpacing = overrides && typeof overrides.spacing === "number" ? overrides.spacing : style?.spacing;
+      const effectiveBorderRadius = overrides && typeof overrides.cornerRadius === "number" ? overrides.cornerRadius : style?.borderRadius;
+      result.push({
+        originalIndex,
+        datasetIndex,
+        value,
+        percentage,
+        targetPercentage: isExiting ? 0 : targetState?.percentage ?? percentage,
+        rotation,
+        endAngle,
+        radiusRatio,
+        color: style?.color,
+        colorValue: style?.colorValue,
+        borderStrokeWidth: effectiveBorderStrokeWidth,
+        borderColor: style?.borderColor,
+        borderRadius: effectiveBorderRadius,
+        borderDash: style?.borderDash,
+        borderDashOffset: style?.borderDashOffset,
+        spacing: effectiveSpacing,
+        targetAngle: isExiting ? 0 : style?.targetAngle ?? (targetState ? targetState.endAngle - targetState.rotation : endAngle - rotation),
+        baseOffset: effectiveBaseOffset !== 0 ? effectiveBaseOffset : void 0,
+        userOpacity: effectiveUserOpacity !== 1 ? effectiveUserOpacity : void 0,
+        hoverColor: style?.hoverColor,
+        hoverBorderColor: style?.hoverBorderColor
+      });
+    }
+  }
+  if (ctx._propertyOverrides.size > 0) {
+    for (const entry of ctx._pieEntries) {
+      const overrides = ctx._propertyOverrides.get(entry.id);
+      if (!overrides) continue;
+      const hasStart = typeof overrides.startAngle === "number";
+      const hasEnd = typeof overrides.endAngle === "number";
+      if (!hasStart && !hasEnd) continue;
+      const datasetIndex = entry.order;
+      const datasetSlices = result.filter((s) => s.datasetIndex === datasetIndex);
+      if (datasetSlices.length === 0) continue;
+      let minRotation = datasetSlices[0].rotation;
+      let maxEndAngle = datasetSlices[0].endAngle;
+      for (const s of datasetSlices) {
+        if (s.rotation < minRotation) minRotation = s.rotation;
+        if (s.endAngle > maxEndAngle) maxEndAngle = s.endAngle;
+      }
+      const baseStart = minRotation;
+      const baseSweep = Math.max(1e-3, maxEndAngle - minRotation);
+      const targetStart = hasStart ? overrides.startAngle : baseStart;
+      const targetSweep = hasEnd ? Math.max(0, overrides.endAngle - targetStart) : baseSweep;
+      const sweepScale = targetSweep / baseSweep;
+      for (const s of datasetSlices) {
+        const sliceStart = targetStart + (s.rotation - baseStart) * sweepScale;
+        const sliceSweep = (s.endAngle - s.rotation) * sweepScale;
+        s.rotation = sliceStart;
+        s.endAngle = sliceStart + sliceSweep;
+      }
+    }
+  }
+  return result;
+}
+function renderSceneFrame(ctx) {
+  if (!ctx._lastInput || !ctx._animationLayout || ctx._ringTargets.length === 0) return;
+  const slices = buildSlicesFromScene(ctx);
+  renderFrame(ctx, slices, ctx._lastInput.renderer, ctx._lastInput);
+  ctx.onFrame?.();
+}
+
+// src/series/pie/controller/index.ts
+var PieRendererController = class {
+  constructor(paint) {
+    this._sceneTargetMap = /* @__PURE__ */ new Map();
+    this._sceneTargetOrder = [];
+    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:
+     *   - `_buildSlicesFromScene` — slice-level fields (opacity, borderStrokeWidth,
+     *     spacing, offset, cornerRadius) get merged onto each slice belonging
+     *     to the dataset.
+     *   - `_renderFrame` — frame-level geometry (innerRadius, outerRadius,
+     *     startAngle, endAngle) overrides the per-dataset ring radii in
+     *     `_currentRingRadii` and the rotation/sweep applied to slices.
+     *
+     * Per-slice granularity (e.g. hover one slice and animate just its
+     * `outerRadius`) is deferred to Step 14 — Step 10 keeps per-dataset only.
+     */
+    this._propertyOverrides = /* @__PURE__ */ new Map();
+    // Layout caches
+    this._layoutData = /* @__PURE__ */ new Map();
+    this._renderPropsMap = /* @__PURE__ */ new Map();
+    this._pieEntries = [];
+    this._hasPieData = false;
+    this._center = null;
+    // Per-dataset computed data
+    this._visibilityMaps = /* @__PURE__ */ new Map();
+    this._ringLayouts = [];
+    this._ringTargets = [];
+    this._styleData = /* @__PURE__ */ new Map();
+    this._prevStyleData = /* @__PURE__ */ new Map();
+    this._baseRotation = -90;
+    // Sort animation state
+    this._prevVisibleOrder = [];
+    this._orderChanged = false;
+    // Hover state
+    this._hoverOffset = 0;
+    this._hoverScale = 1;
+    /**
+     * Current hovered slice, written ONLY by `applyHover` (mirrors polar). The 2D
+     * SVG/canvas frame build derives its per-dataset `hoverState` from this field
+     * so the animation tick reads live hover (not stale `_lastInput.hover`), which
+     * makes hover-during-animation deferral safe.
+     */
+    this.hoverState = { datasetId: null, index: null };
+    // SVG element maps (owned by controller, same as Bar)
+    this._pathElements = /* @__PURE__ */ new Map();
+    this._sliceGroups = /* @__PURE__ */ new Map();
+    this._contentSlots = /* @__PURE__ */ new Map();
+    this._customContent = /* @__PURE__ */ new Map();
+    this._sliceRenderFns = /* @__PURE__ */ new Map();
+    this._labelGroup = null;
+    // Hit test state (updated on every frame)
+    this._hitTestStates = /* @__PURE__ */ new Map();
+    this._currentRingRadii = /* @__PURE__ */ new Map();
+    this._lastRenderedSlices = [];
+    this._animationLayout = null;
+    // DOM targets
+    this._svgGroup = null;
+    this._canvasEl = null;
+    // Input cache
+    this._lastInput = null;
+    // Image-load repaint
+    this._imageRepaintRaf = null;
+    /**
+     * Called after each animation frame — wrappers use this to trigger
+     * framework-specific repaint (e.g. setLayoutVersion / triggerRepaint).
+     */
+    this.onFrame = null;
+    this._paint = paint;
+    this._scene = new AnimatedScene({
+      // ENTER: all slices sweep in from the chart start angle (classic clock sweep).
+      // _baseRotation is set in Phase 1 before diff() is called.
+      emptyState: (target) => ({
+        rotation: this._baseRotation,
+        endAngle: this._baseRotation,
+        radiusRatio: target.radiusRatio,
+        value: 0,
+        percentage: 0,
+        innerRadius: target.innerRadius,
+        outerRadius: target.outerRadius
+      }),
+      // EXIT: slice shrinks to zero span at its own position.
+      // rotation is fixed so the slice collapses inward, not toward the chart start angle.
+      exitEmptyState: (target) => ({
+        rotation: target.rotation,
+        endAngle: target.rotation,
+        radiusRatio: target.radiusRatio,
+        value: target.value,
+        percentage: target.percentage,
+        innerRadius: target.innerRadius,
+        outerRadius: target.outerRadius
+      }),
+      registry: PIE_SLICE_SCENE_REGISTRY
+    });
+  }
+  // ================================================================
+  // PUBLIC API
+  // ================================================================
+  /**
+   * Full update — computes layouts, visibility, ring targets, drives SVG DOM
+   * mutations and starts the animation. Mirrors BarRendererController.update().
+   */
+  update(input) {
+    this._lastInput = input;
+    this._svgGroup = input.svgGroup ?? null;
+    this._canvasEl = input.canvasEl ?? null;
+    this.hoverState = { datasetId: input.hover.datasetId, index: input.hover.index };
+    const { datasets, datasetVisibility, hiddenItems, chartArea, renderer, features, hoverConfig, globalFont, adaptiveDataLabelFontSize, width, height } = input;
+    const sortedDatasets = Array.from(datasets.entries()).sort(([, a], [, b]) => a.order - b.order);
+    const collected = collectItems(sortedDatasets, datasetVisibility);
+    this._pieEntries = collected.pie;
+    this._hasPieData = this._pieEntries.length > 0;
+    if (!this._hasPieData) {
+      this._layoutData.clear();
+      this._renderPropsMap.clear();
+      this._center = null;
+      this._ringTargets = [];
+      if (renderer === "svg" && this._svgGroup) {
+        while (this._svgGroup.firstChild) this._svgGroup.removeChild(this._svgGroup.firstChild);
+      }
+      return;
+    }
+    this._hoverOffset = hoverConfig?.offset ?? 0;
+    this._hoverScale = hoverConfig?.scale ?? 1;
+    const dlProps = features.get("dataLabels")?.props;
+    const dlConfig = normalizeDataLabelConfig(dlProps, adaptiveDataLabelFontSize, void 0, globalFont);
+    const isDatasetVisible = (id) => datasetVisibility.get(id) ?? true;
+    const isItemVisible = (dsId, idx) => !(hiddenItems.get(dsId)?.has(idx) ?? false);
+    const stackingProps = features.get("stacking")?.props;
+    const ringGap = (stackingProps?.gap ?? 0) / 100;
+    const hasStackedPies = this._pieEntries.length > 1 || this._pieEntries.some((e) => e.props.stackId !== void 0);
+    this._ringLayouts = hasStackedPies ? calculateRingLayouts(datasets, isDatasetVisible, isItemVisible, 0, ringGap) : [];
+    this._layoutData.clear();
+    this._renderPropsMap.clear();
+    this._sliceRenderFns.clear();
+    this._prevStyleData = this._styleData;
+    this._styleData = /* @__PURE__ */ new Map();
+    const ringTargets = [];
+    const visibilityMaps = /* @__PURE__ */ new Map();
+    for (const pieEntry of this._pieEntries) {
+      const datasetId = pieEntry.id;
+      const datasetIndex = pieEntry.order;
+      const props = pieEntry.props;
+      const data = props.data ?? [];
+      const vis = buildPieVisibilityMap(data, datasetId, isDatasetVisible, isItemVisible);
+      visibilityMaps.set(datasetId, vis);
+      const ringResult = applyRingLayout(
+        chartArea,
+        this._ringLayouts.find((r) => r.datasetId === datasetId),
+        props
+      );
+      const renderProps = {
+        ...props,
+        innerRadius: ringResult.effectiveInnerRadius,
+        visibility: vis,
+        interaction: {
+          hoveredIndex: input.hover.datasetId === datasetId ? input.hover.index : null
+        },
+        effects: {
+          hoverBrightness: hoverConfig?.brightness ?? DEFAULT_HOVER_BRIGHTNESS,
+          hoverOffset: this._hoverOffset,
+          hoverScale: this._hoverScale,
+          dimOpacity: hoverConfig?.dimOpacity ?? 1,
+          hoverBackgroundColor: hoverConfig?.backgroundColor,
+          hoverBorderColor: hoverConfig?.borderColor,
+          hoverBorderStrokeWidth: hoverConfig?.borderStrokeWidth,
+          hoverBorderDash: hoverConfig?.borderDash,
+          hoverBorderDashOffset: hoverConfig?.borderDashOffset
+        }
+      };
+      this._renderPropsMap.set(datasetId, renderProps);
+      let layout = calculatePieLayout(renderProps, ringResult.effectiveChartArea);
+      if (dlConfig) {
+        const labelConfigs = buildPieLabelConfigs(layout, dlConfig, this._lastInput?.theme);
+        if (labelConfigs.length > 0) {
+          const bounds = { ...boxAreaToBounds({ x: 0, y: 0, width, height }), centerX: layout.center.x, centerY: layout.center.y };
+          const shrunkRadius = computeLabelAwareRadius(labelConfigs, layout.outerRadius, bounds, {
+            fontSize: dlConfig.fontSize,
+            fontWeight: dlConfig.fontWeight,
+            fontFamily: dlConfig.fontFamily,
+            leaderOffset: dlConfig.leaderOffset,
+            horizontalOffset: dlConfig.horizontalOffset,
+            textOffset: dlConfig.textOffset,
+            lineStyle: dlConfig.lineStyle,
+            alignTo: dlConfig.alignTo
+          });
+          if (shrunkRadius < layout.outerRadius) {
+            const appliedRatio = (() => {
+              const r = renderProps.outerRadius;
+              return r != null && r > 0 && r <= 1 ? r : 1;
+            })();
+            const naturalRadius = layout.outerRadius / appliedRatio;
+            const shrunkRatio = shrunkRadius / naturalRadius;
+            layout = calculatePieLayout({ ...renderProps, outerRadius: shrunkRatio }, ringResult.effectiveChartArea);
+          }
+        }
+      }
+      const pieLayout = { ...layout, datasetIndex };
+      this._layoutData.set(datasetId, pieLayout);
+      this._animationLayout = {
+        center: pieLayout.center,
+        outerRadius: pieLayout.outerRadius,
+        innerRadius: pieLayout.innerRadius,
+        startAngle: pieLayout.startAngle,
+        sweepAngle: pieLayout.sweepAngle,
+        borderAlign: props.borderAlign,
+        borderJoinStyle: props.borderJoinStyle
+      };
+      const ratioField = props.sliceRadiusValue;
+      const radiusRatios = ratioField ? computeSliceRadiusRatios(data, ratioField, vis) : null;
+      const categoryAccessor = props.categoryField ?? props.labelField ?? FIELD_DEFAULTS.categoryField;
+      const sliceSeriesIndex = props.order ?? datasetIndex;
+      const sliceSeriesId = props.id ?? datasetId;
+      const slices = pieLayout.slices.map((s) => {
+        const i = s.originalIndex;
+        const item = data[i];
+        const angle = s.endAngle - s.rotation;
+        const styleKey = `${datasetIndex}-${i}`;
+        const category = categoryAccessor ? resolveAccessor(categoryAccessor, makeItemContext(item, i)) ?? void 0 : void 0;
+        const categoryStr = category != null ? String(category) : void 0;
+        this._styleData.set(styleKey, buildSliceStyleData(props, item, i, angle, radiusRatios ? radiusRatios[i] : 1, input.theme, s.value, categoryStr, sliceSeriesIndex, sliceSeriesId));
+        return {
+          originalIndex: i,
+          value: s.value,
+          percentage: s.percentage,
+          rotation: s.rotation,
+          endAngle: s.endAngle,
+          radiusRatio: radiusRatios ? radiusRatios[i] : 1
+        };
+      });
+      ringTargets.push(buildRingTarget(chartArea, datasetIndex, slices, this._ringLayouts, datasetId, props, pieLayout.innerRadius, pieLayout.outerRadius));
+      const pieProps = props;
+      if (pieProps.renderContent && pieProps.data) {
+        this._sliceRenderFns.set(datasetId, {
+          fn: pieProps.renderContent,
+          data: pieProps.data,
+          props,
+          datasetIndex
+        });
+      }
+    }
+    this._visibilityMaps = visibilityMaps;
+    this._ringTargets = ringTargets;
+    this._baseRotation = this._pieEntries[0]?.props ? this._pieEntries[0].props.startAngle ?? -90 : -90;
+    const firstLayout = this._layoutData.values().next().value;
+    this._center = firstLayout?.center ?? null;
+    if (ringTargets.length > 0) {
+      const animConfig = features.get("animation")?.props;
+      const { enabled, duration, easing } = parseAnimationConfig(animConfig);
+      const sortState = this._pieEntries[0]?.props?.sort ?? "";
+      const hiddenStr = [...hiddenItems.entries()].map(([k, v]) => `${k}:[${[...v].sort()}]`).join(";");
+      const fingerprint = ringTargets.map((r) => `${r.datasetIndex}:${r.slices.map((s) => `${s.originalIndex}:${s.value}:${s.percentage}`).join(",")}`).join("|") + `|sort:${sortState}|hidden:${hiddenStr}`;
+      const dataChanged = fingerprint !== this._lastFingerprint;
+      const shouldAnimate = enabled && duration > 0 && dataChanged;
+      const isFirstRender = this._sceneTargetOrder.length === 0;
+      const targets = /* @__PURE__ */ new Map();
+      const sortedRings = [...ringTargets].sort((a, b) => a.datasetIndex - b.datasetIndex);
+      for (let ri = 0; ri < sortedRings.length; ri++) {
+        const ring = sortedRings[ri];
+        const isHiddenRing = ring.outerRadius < 1e-3;
+        let targetInner = ring.innerRadius;
+        let targetOuter = ring.outerRadius;
+        if (isHiddenRing) {
+          let innerNeighbor;
+          for (let j = ri + 1; j < sortedRings.length; j++) {
+            if (sortedRings[j].outerRadius > 1e-3) {
+              innerNeighbor = sortedRings[j];
+              break;
+            }
+          }
+          if (innerNeighbor) {
+            targetInner = innerNeighbor.outerRadius;
+            targetOuter = innerNeighbor.outerRadius;
+          } else {
+            let holeRadius = 0;
+            for (const r of sortedRings) {
+              if (r.outerRadius > 1e-3) holeRadius = r.innerRadius;
+            }
+            targetInner = holeRadius;
+            targetOuter = holeRadius;
+          }
+        }
+        for (const slice of ring.slices) {
+          const id = `${ring.datasetIndex}-${slice.originalIndex}`;
+          targets.set(id, {
+            rotation: slice.rotation,
+            endAngle: slice.endAngle,
+            radiusRatio: slice.radiusRatio ?? 1,
+            value: slice.value,
+            percentage: slice.percentage,
+            innerRadius: targetInner,
+            outerRadius: targetOuter
+          });
+        }
+      }
+      if (dataChanged) {
+        if (this._animRafId !== null) {
+          cancelRaf(this._animRafId);
+          this._animRafId = null;
+        }
+      }
+      const currentVisibleOrder = [...targets.entries()].filter(([, state]) => state.endAngle - state.rotation > 1e-3).map(([id]) => id);
+      this._orderChanged = shouldAnimate && !isFirstRender && detectSortOrderChange(this._prevVisibleOrder, currentVisibleOrder);
+      this._prevVisibleOrder = currentVisibleOrder;
+      if (this._orderChanged) {
+        this._snapshotAccumulatedPositions();
+      }
+      const opts = { numbers: { duration: shouldAnimate ? duration : 0, easing } };
+      this._scene.diff(targets, opts);
+      this._sceneTargetOrder = [...targets.keys()];
+      this._sceneTargetMap = new Map(targets);
+      if (dataChanged) {
+        this._lastFingerprint = fingerprint;
+        if (!shouldAnimate) {
+          this._scene.tick(performance.now());
+        }
+      }
+      if (dataChanged && renderer === "svg" && this._svgGroup) {
+        const chartGroup = this._svgGroup;
+        const centerTransform = this._animationLayout ? `translate(${this._animationLayout.center.x}, ${this._animationLayout.center.y})` : void 0;
+        const a11y = buildAccessibilityRenderContext(input.features);
+        for (const pieEntry of this._pieEntries) {
+          let datasetGroup = chartGroup.querySelector(`[data-dataset="${pieEntry.id}"]`);
+          if (!datasetGroup) {
+            datasetGroup = document.createElementNS("http://www.w3.org/2000/svg", "g");
+            datasetGroup.setAttribute("data-dataset", pieEntry.id);
+            if (centerTransform) datasetGroup.setAttribute("transform", centerTransform);
+            if (a11y?.enabled && a11y.landmarkVerbosity === "all") {
+              datasetGroup.setAttribute("role", "region");
+              datasetGroup.setAttribute("aria-label", generateSeriesDescription(pieEntry.props?.name ?? pieEntry.id, "pie", this._layoutData.get(pieEntry.id)?.visibleSlices.length ?? 0));
+            }
+            chartGroup.appendChild(datasetGroup);
+          }
+        }
+      }
+      if (!isFirstRender && renderer === "svg" && this._svgGroup && this._animationLayout) {
+        for (const pieEntry of this._pieEntries) {
+          const group = this._svgGroup.querySelector(`[data-dataset="${pieEntry.id}"]`);
+          if (group) {
+            group.setAttribute("transform", `translate(${this._animationLayout.center.x}, ${this._animationLayout.center.y})`);
+          }
+        }
+      }
+      if (shouldAnimate) {
+        this._startAnimLoop();
+      }
+    }
+    if (renderer === "svg" && this._svgGroup) {
+      const liveDatasetIds = new Set(this._pieEntries.map((e) => e.id));
+      this._svgGroup.querySelectorAll("[data-dataset]").forEach((group) => {
+        const id = group.getAttribute("data-dataset");
+        if (id !== null && !liveDatasetIds.has(id)) group.remove();
+      });
+    }
+    if (this._animRafId === null && this._ringTargets.length > 0) {
+      const staticSlices = this._buildSlicesFromScene();
+      this._renderFrame(staticSlices, renderer, input);
+      this.onFrame?.();
+    }
+  }
+  /**
+   * Lightweight hover repaint — does not recompute layouts.
+   */
+  applyHover(hover) {
+    if (!this._lastInput || !this._animationLayout) return;
+    const renderer = this._lastInput.renderer;
+    this.hoverState = hover;
+    if (this._animRafId === null && this._lastRenderedSlices.length > 0) {
+      this._renderFrame(this._lastRenderedSlices, renderer, this._lastInput);
+    }
+    this.onFrame?.();
+  }
+  /**
+   * Called by framework wrappers on canvas repaint (e.g. resize).
+   * Redraws the current frame to the provided context.
+   */
+  renderCanvasContent() {
+    if (!this._lastInput || this._lastRenderedSlices.length === 0 || !this._animationLayout) return;
+    this._renderFrame(this._lastRenderedSlices, "canvas", this._lastInput);
+  }
+  /**
+   * Register a custom content SVG element (from framework ref callbacks).
+   * key format: `${datasetIndex}-${sliceIndex}`
+   */
+  registerCustomContent(key, el) {
+    if (el) {
+      this._customContent.set(key, el);
+    } else {
+      this._customContent.delete(key);
+    }
+  }
+  /**
+   * Register the label group element (for imperative SVG data label rendering).
+   */
+  registerLabelGroup(el) {
+    this._labelGroup = el;
+  }
+  /**
+   * Hit test at pixel coordinates.
+   */
+  hitTest(x, y) {
+    for (const [dsIdx, sliceStates] of this._hitTestStates) {
+      const pieEntry = this._pieEntries.find((e) => String(e.order) === dsIdx);
+      if (!pieEntry) continue;
+      const layout = this._layoutData.get(pieEntry.id);
+      if (!layout) continue;
+      const ringRadii = this._currentRingRadii.get(dsIdx);
+      for (const ss of sliceStates) {
+        if (!ss.visible) continue;
+        const inner = ringRadii?.inner ?? layout.innerRadius;
+        const outer = ringRadii?.outer ?? layout.outerRadius;
+        const sliceAngles = [{ rotation: ss.rotation, endAngle: ss.endAngle }];
+        const hitIdx = findSliceAtPoint(x - layout.center.x, y - layout.center.y, sliceAngles, outer, inner);
+        if (hitIdx === 0) {
+          const data = pieEntry.props.data ?? [];
+          const item = data[ss.originalIndex];
+          const propsWithLabel = pieEntry.props;
+          const labelAccessor = propsWithLabel.categoryField ?? propsWithLabel.labelField ?? FIELD_DEFAULTS.categoryField;
+          const label = item ? String(resolveAccessor(labelAccessor, makeItemContext(item, ss.originalIndex))) : "";
+          const colorExtras = {
+            value: ss.value,
+            category: label,
+            seriesIndex: pieEntry.props.order ?? Number(dsIdx),
+            seriesId: pieEntry.props.id ?? pieEntry.id
+          };
+          const colorValue = getColorValue(pieEntry.props, ss.originalIndex, item, this._lastInput?.theme, colorExtras);
+          return {
+            datasetId: pieEntry.id,
+            index: ss.originalIndex,
+            label,
+            value: ss.value,
+            // Renormalized share (0-100) over the visible slices, so the
+            // tooltip (auto-percentage + ctx.percentage) tracks legend toggles.
+            percentage: ss.percentage,
+            // Default tooltip readout: route the raw value through the shared
+            // compact formatter so a mid-animation tween float (e.g.
+            // 61.31423044588703) renders cleanly ("61.3"), matching axes/labels.
+            formattedValue: formatCompactValue(ss.value),
+            color: ss.color ?? "#000",
+            colorGradient: asGradient(colorValue),
+            swatchColor: resolveSwatchColor(pieEntry.props, ss.originalIndex, item, this._lastInput?.theme, colorExtras)
+          };
+        }
+      }
+    }
+    return null;
+  }
+  /**
+   * Get the pixel position of a slice's midpoint (for tooltip positioning).
+   */
+  getSlicePosition(datasetId, index) {
+    const layout = this._layoutData.get(datasetId);
+    if (!layout?.visibleSlices) return null;
+    const slice = layout.visibleSlices.find((s) => s.dataIndex === index);
+    if (!slice) return null;
+    const midAngle = (slice.rotation + slice.endAngle) / 2;
+    const midRadius = (layout.innerRadius + layout.outerRadius) / 2;
+    const rad = midAngle * Math.PI / 180;
+    return {
+      x: layout.center.x + Math.cos(rad) * midRadius,
+      y: layout.center.y + Math.sin(rad) * midRadius
+    };
+  }
+  // ================================================================
+  // GETTERS
+  // ================================================================
+  get hasPieData() {
+    return this._hasPieData;
+  }
+  get center() {
+    return this._center;
+  }
+  get layouts() {
+    return this._layoutData;
+  }
+  get entries() {
+    return this._pieEntries;
+  }
+  get ringLayouts() {
+    return this._ringLayouts;
+  }
+  get ringTargets() {
+    return this._ringTargets;
+  }
+  get visibilityMaps() {
+    return this._visibilityMaps;
+  }
+  get ringRadii() {
+    return this._currentRingRadii;
+  }
+  get hoverOffset() {
+    return this._hoverOffset;
+  }
+  get hoverScale() {
+    return this._hoverScale;
+  }
+  get baseRotation() {
+    return this._baseRotation;
+  }
+  get animationLayout() {
+    return this._animationLayout;
+  }
+  get lastRenderedSlices() {
+    return this._lastRenderedSlices;
+  }
+  get sliceRenderFns() {
+    return this._sliceRenderFns;
+  }
+  destroy() {
+    if (this._animRafId !== null) {
+      cancelRaf(this._animRafId);
+      this._animRafId = null;
+    }
+    this._scene.reset();
+    if (this._imageRepaintRaf !== null) {
+      cancelRaf(this._imageRepaintRaf);
+      this._imageRepaintRaf = 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 `_buildSlicesFromScene` + `_renderFrame` re-merge into the
+   * rendered slices and frame geometry.
+   *
+   * SVG: re-renders imperatively via `_renderSceneFrame`. Canvas: the same
+   * call clears + repaints the canvas in place.
+   */
+  applyPropertyAnimations(store) {
+    if (!this._lastInput || !this._hasPieData) return;
+    let appliedAny = false;
+    for (const entry of this._pieEntries) {
+      const overrides = resolveAnimatedProps(store, "pie", entry.id, PIE_ANIMATABLE_PROPS);
+      if (Object.keys(overrides).length === 0) {
+        if (this._propertyOverrides.delete(entry.id)) appliedAny = true;
+        continue;
+      }
+      appliedAny = true;
+      this._propertyOverrides.set(entry.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,
+   * `renderFrameCycle()` rebuilds slices from the `_propertyOverrides`-
+   * cleared base values so SVG attributes snap back to the layout-derived
+   * defaults (which can drift during in-place patches).
+   */
+  renderFrameCycle() {
+    this._renderSceneFrame();
+  }
+  /** Rebuild + render the current scene state (delegates to `scene.renderSceneFrame`). */
+  _renderSceneFrame() {
+    renderSceneFrame(this);
+  }
+  /** Animation raf loop (delegates to `scene.startAnimLoop`). */
+  _startAnimLoop() {
+    startAnimLoop(this);
+  }
+  /** Snapshot accumulated visual positions before a sort tween (delegates to `scene`). */
+  _snapshotAccumulatedPositions() {
+    snapshotAccumulatedPositions(this);
+  }
+  /** Project the scene to RadialSliceState[] (delegates to `scene.buildSlicesFromScene`). */
+  _buildSlicesFromScene() {
+    return buildSlicesFromScene(this);
+  }
+  /** Render one frame to the active renderer (delegates to `render.renderFrame`). */
+  _renderFrame(slices, renderer, input) {
+    renderFrame(this, slices, renderer, input);
+  }
+};
+
+export { AxisRegistrationController, CartesianLayoutController, ChartStateController, DatasetRegistrationController, DrilldownStateController, KeyboardNavigationController, PieRendererController, ResponsiveDimensionsController, createChart };