@primeui/chart-core 0.0.1-alpha.1

package/dist/chunk-OHGCZZPZ.mjs

@@ -0,0 +1,403 @@
+import { calculatePolarLayout, hitTestPolar } from './chunk-WCG35U6M.mjs';
+import { resolvePolarLabels } from './chunk-UPRXABX5.mjs';
+import { resolveSharedRadialGrid } from './chunk-TA4MVAEX.mjs';
+import { renderResolvedLabels } from './chunk-QQBXUDM4.mjs';
+import { AnimatedScene, resolveAnimatedProps, POLAR_ANIMATABLE_PROPS } from './chunk-VN7CKCSE.mjs';
+import { reconcileSvgChildren } from './chunk-KP2TWD4Z.mjs';
+import { parseAnimationConfig } from './chunk-3WEMHXZI.mjs';
+import { cancelRaf, raf } from './chunk-EDAKJLNA.mjs';
+import { 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 { defaultLightTheme, resolveSwatchColor, getDefaultColor } from './chunk-O2X6FF45.mjs';
+import { setAttr, createSvgGroup, materializeSvgNode } from './chunk-SSLTFJ3U.mjs';
+
+// src/series/polar/controller/index.ts
+var POLAR_BAR_REGISTRY = {
+  number: ["innerRadius", "outerRadius", "startAngle", "endAngle"],
+  color: []
+};
+function polarBarKey(b) {
+  return b.dataKey != null ? `${b.datasetId}:key:${b.dataKey}` : `${b.datasetId}:cat:${b.category}`;
+}
+var PolarRendererController = 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 each bar's rendered fields at scene-build time. Cleared by `destroy()`.
+     *
+     * Polar's animatable props (innerRadius, outerRadius, startAngle, endAngle,
+     * spacing, opacity, borderStrokeWidth, valueRadius) all sit on PolarBarData,
+     * so the merge is a shallow spread on each bar belonging to the dataset.
+     */
+    this._propertyOverrides = /* @__PURE__ */ new Map();
+    // Grid lerp (radial axis rings + tick labels). Separate from the bar scene
+    // because it's a layout-level lerp on `domain`, not per-element.
+    this._gridLerp = null;
+    // Last settled domain — start point for the next grid lerp.
+    this._lastSettledDomain = null;
+    // Target layout (computed each update; reference data for renders).
+    this._layout = null;
+    // Last frame's rendered layout (reused by hover, hit-testing, grid consumers).
+    this.lastRenderedLayout = null;
+    this.hoverState = { datasetId: null, index: null };
+    this.effectConfig = { hoverBrightness: 1, dimOpacity: 1 };
+    this.lastInput = null;
+    this.svgGroup = null;
+    this._hasPolarDatasets = false;
+    this.onFrame = null;
+    this._paint = paint;
+    this._scene = new AnimatedScene({
+      // ENTER: bar grows from its inner radius (zero radial height) at its final angles.
+      // Matches old createPolarEntranceLayout: outerRadius = innerRadius.
+      emptyState: (target) => ({ ...target, outerRadius: target.innerRadius }),
+      // EXIT: bar shrinks back to inner radius. Matches the exiting-bar branch of
+      // interpolatePolarLayout where outerRadius collapsed to innerRadius.
+      exitEmptyState: (target) => ({ ...target, outerRadius: target.innerRadius }),
+      registry: POLAR_BAR_REGISTRY
+    });
+  }
+  // ================================================================
+  // PUBLIC API
+  // ================================================================
+  update(input) {
+    this.lastInput = input;
+    this.svgGroup = input.svgGroup ?? null;
+    const { datasets, datasetVisibility, chartArea, features, globalFont, sharedContext, yAxes } = input;
+    this._hasPolarDatasets = Array.from(datasets.values()).some((ds) => ds.type === "polar");
+    if (!this._hasPolarDatasets) {
+      this._layout = null;
+      this.lastRenderedLayout = null;
+      return;
+    }
+    const sortedDatasets = Array.from(datasets.entries()).sort(([, a], [, b]) => a.order - b.order);
+    const polarEntries = collectItems(sortedDatasets, datasetVisibility).polar;
+    if (polarEntries.length === 0) {
+      this._layout = null;
+      return;
+    }
+    const anyVisible = polarEntries.some((e) => e.visible);
+    if (!anyVisible) {
+      const liveCount = this._scene.getElements().length;
+      if (liveCount === 0) {
+        this._layout = null;
+        this.lastRenderedLayout = null;
+        if (this._animRafId !== null) {
+          cancelRaf(this._animRafId);
+          this._animRafId = null;
+        }
+        this._gridLerp = null;
+        this._lastFingerprint = "|EMPTY";
+        return;
+      }
+      const animConfig2 = features.get("animation")?.props;
+      const { enabled: animEnabled2, duration: duration2, easing: easing2 } = parseAnimationConfig(animConfig2);
+      const shouldAnimate2 = animEnabled2 && duration2 > 0;
+      const fingerprint2 = "|EMPTY";
+      const dataChanged2 = fingerprint2 !== this._lastFingerprint;
+      if (!dataChanged2 && this._animRafId !== null) return;
+      if (!dataChanged2) return;
+      this._lastFingerprint = fingerprint2;
+      if (this._animRafId !== null) {
+        cancelRaf(this._animRafId);
+        this._animRafId = null;
+      }
+      const opts2 = { numbers: { duration: shouldAnimate2 ? duration2 : 0, easing: easing2 } };
+      this._scene.diff(/* @__PURE__ */ new Map(), opts2);
+      this._gridLerp = null;
+      if (shouldAnimate2) {
+        this._renderSceneFrame();
+        this._startAnimLoop();
+      } else {
+        this._scene.tick(performance.now());
+        if (this._scene.getElements().length === 0) {
+          this._layout = null;
+        }
+        this._renderSceneFrame();
+      }
+      return;
+    }
+    const isStacked = polarEntries.some((e) => e.props.stackId !== void 0);
+    const stackingFeature = features.get("stacking")?.props;
+    let stackConfig;
+    if (isStacked) {
+      stackConfig = { mode: stackingFeature?.mode === "percent" ? "percent" : "normal" };
+    }
+    const targetLayout = {
+      ...calculatePolarLayout(polarEntries, chartArea, stackConfig, globalFont, sharedContext?.categories, sharedContext?.domain),
+      datasetIndex: 0
+    };
+    this._layout = targetLayout;
+    const animConfig = features.get("animation")?.props;
+    const { enabled: animEnabled, duration, easing } = parseAnimationConfig(animConfig);
+    const fingerprint = targetLayout.bars.map((b) => `${polarBarKey(b)}:${b.value}:${Math.round(b.outerRadius)}:${Math.round(b.startAngle)}`).join("|") + `|dom:${targetLayout.domain[0]},${targetLayout.domain[1]}`;
+    const dataChanged = fingerprint !== this._lastFingerprint;
+    const shouldAnimate = animEnabled && duration > 0 && dataChanged;
+    if (!dataChanged) return;
+    const sceneTargets = /* @__PURE__ */ new Map();
+    for (const b of targetLayout.bars) {
+      sceneTargets.set(polarBarKey(b), b);
+    }
+    if (this._animRafId !== null) {
+      cancelRaf(this._animRafId);
+      this._animRafId = null;
+    }
+    const opts = { numbers: { duration: shouldAnimate ? duration : 0, easing } };
+    this._scene.diff(sceneTargets, opts);
+    this._lastFingerprint = fingerprint;
+    const tickCount = yAxes ? Array.from(yAxes.values())[0]?.props?.tickCount : void 0;
+    const resolved = resolveSharedRadialGrid(targetLayout.grid, targetLayout.domain, targetLayout.rawDataMax, targetLayout.maxRadius, tickCount);
+    const targetDomain = resolved.domain;
+    const prevSettled = this._lastSettledDomain;
+    const domainChanged = !prevSettled || prevSettled[0] !== targetDomain[0] || prevSettled[1] !== targetDomain[1];
+    if (shouldAnimate && domainChanged && prevSettled) {
+      const fromDomain = this._gridLerp ? this._currentGridDomain() : prevSettled;
+      this._gridLerp = {
+        fromDomain,
+        toDomain: targetDomain,
+        targetGrid: { ...targetLayout.grid, levels: resolved.levelValues.length, levelValues: resolved.levelValues, levelRadii: resolved.levelRadii },
+        targetRadius: targetLayout.maxRadius,
+        startTime: -1,
+        duration,
+        easing
+      };
+    } else {
+      this._gridLerp = null;
+      this._lastSettledDomain = targetDomain;
+    }
+    if (shouldAnimate) {
+      this._renderSceneFrame();
+      this._startAnimLoop();
+    } else {
+      this._scene.tick(performance.now());
+      this._renderSceneFrame();
+    }
+  }
+  applyHover(hover) {
+    const hoverConfig = this.lastInput?.hoverConfig;
+    this.hoverState = hoverConfig ? { datasetId: hover.datasetId, index: hover.index, axisIndex: hover.axisIndex ?? null } : { datasetId: null, index: null, 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.lastInput) return;
+    if (this.lastInput.renderer === "svg" && this.svgGroup) {
+      if (this._animRafId !== null) return;
+      reconcileSvgChildren(this.svgGroup, this.buildPolarSvgChildren(layout, this.lastInput));
+    } else if (this.lastInput.renderer === "canvas") {
+      this.lastInput.requestRedraw?.();
+    }
+  }
+  hitTest(x, y) {
+    if (!this._layout) return null;
+    return hitTestPolar(x, y, this._layout, this.lastInput?.theme ?? defaultLightTheme);
+  }
+  /**
+   * Shared-mode lookup: find the wedge under the cursor, then return all
+   * stacked bars that share its categoryIndex as `allSeries` (parity with
+   * cartesian bar/line shared tooltip).
+   */
+  findAllNearest(x, y) {
+    const layout = this.lastRenderedLayout ?? this._layout;
+    if (!layout) return null;
+    const primary = hitTestPolar(x, y, layout, this.lastInput?.theme ?? defaultLightTheme);
+    if (!primary) return null;
+    const label = layout.categories[primary.index] ?? primary.label;
+    const allSeries = [];
+    for (const bar of layout.bars) {
+      if (bar.categoryIndex !== primary.index) continue;
+      if (bar.hidden) continue;
+      const gradColor = layout.gradientColors.get(bar.datasetId);
+      allSeries.push({
+        datasetId: bar.datasetId,
+        name: bar.name,
+        label,
+        color: bar.color ?? getDefaultColor(bar.seriesIdx, this.lastInput?.theme ?? defaultLightTheme),
+        colorGradient: gradColor,
+        swatchColor: resolveSwatchColor({ color: bar.color ?? gradColor }, bar.seriesIdx, void 0, this.lastInput?.theme),
+        value: bar.value,
+        formattedValue: String(bar.value),
+        cursorFormattedValue: String(bar.value),
+        snapPixel: bar.outerRadius
+      });
+    }
+    return { primary: { ...primary, label }, allSeries };
+  }
+  renderCanvasContent(ctx) {
+    const layout = this.lastRenderedLayout ?? this._layout;
+    if (!layout) return;
+    this._paint.renderCanvas(ctx, layout, this.hoverState, this.effectConfig, this.lastInput?.theme ?? defaultLightTheme);
+    const lc = this.lastInput?.labelConfig;
+    if (lc) {
+      const dsTotal = layout.bars.reduce((sum, b) => sum + Math.abs(b.value), 0);
+      const labels = resolvePolarLabels(layout.bars, dsTotal, layout.center, lc);
+      renderResolvedLabels(labels, lc, { renderer: "canvas", ctx, theme: this.lastInput?.theme ?? defaultLightTheme });
+    }
+  }
+  get hasData() {
+    return this._hasPolarDatasets;
+  }
+  get layout() {
+    return this.lastRenderedLayout ?? this._layout;
+  }
+  get center() {
+    return this.lastRenderedLayout?.center ?? this._layout?.center ?? null;
+  }
+  destroy() {
+    if (this._animRafId !== null) {
+      cancelRaf(this._animRafId);
+      this._animRafId = null;
+    }
+    this._scene.reset();
+    this._gridLerp = null;
+    this._lastSettledDomain = null;
+    this._lastFingerprint = "";
+    this._propertyOverrides.clear();
+  }
+  /**
+   * Apply animated property values without triggering a full layout cycle.
+   * Called from the property-animation framework wrapper 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 bars.
+   *
+   * SVG: re-renders bars imperatively via `renderToSvg`. Canvas: calls
+   * `requestRedraw` so the canvas pipeline repaints with the merged props
+   * already baked into `lastRenderedLayout.bars`.
+   */
+  applyPropertyAnimations(store) {
+    const layout = this._layout;
+    const input = this.lastInput;
+    if (!layout || !input) return;
+    let appliedAny = false;
+    const seenDatasets = /* @__PURE__ */ new Set();
+    for (const bar of layout.bars) {
+      if (seenDatasets.has(bar.datasetId)) continue;
+      seenDatasets.add(bar.datasetId);
+      const overrides = resolveAnimatedProps(store, "polar", bar.datasetId, POLAR_ANIMATABLE_PROPS);
+      if (Object.keys(overrides).length === 0) {
+        if (this._propertyOverrides.delete(bar.datasetId)) appliedAny = true;
+        continue;
+      }
+      appliedAny = true;
+      this._propertyOverrides.set(bar.datasetId, 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 bars from `_propertyOverrides`-cleared
+   * base values so SVG attributes snap back to the layout-derived defaults.
+   */
+  renderFrameCycle() {
+    this._renderSceneFrame();
+  }
+  // ================================================================
+  // PRIVATE — ANIMATION HELPERS
+  // ================================================================
+  _currentGridDomain() {
+    if (!this._gridLerp) return this._lastSettledDomain ?? [0, 0];
+    const { fromDomain, toDomain, startTime, duration, easing } = this._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];
+  }
+  /**
+   * Build a PolarRenderData snapshot for the current frame: bars from scene
+   * elements, grid from in-flight lerp (or target).
+   */
+  _buildLayoutFromScene(now) {
+    if (!this._layout) return null;
+    const bars = [];
+    const hasOverrides = this._propertyOverrides.size > 0;
+    for (const el of this._scene.getElements()) {
+      const base = el.current;
+      const overrides = hasOverrides ? this._propertyOverrides.get(base.datasetId) : void 0;
+      bars.push(overrides ? { ...base, ...overrides } : { ...base });
+    }
+    let grid = this._layout.grid;
+    let gridAnimating = false;
+    if (this._gridLerp) {
+      if (this._gridLerp.startTime === -1) this._gridLerp.startTime = now;
+      const elapsed = now - this._gridLerp.startTime;
+      const raw = Math.max(0, Math.min(1, elapsed / this._gridLerp.duration));
+      const p = this._gridLerp.easing(raw);
+      grid = interpolateRadialGrid(this._gridLerp.fromDomain, this._gridLerp.toDomain, this._gridLerp.targetGrid, this._gridLerp.targetRadius, p);
+      gridAnimating = true;
+      if (raw >= 1) {
+        this._lastSettledDomain = this._gridLerp.toDomain;
+        this._gridLerp = null;
+      }
+    }
+    return { ...this._layout, bars, grid, gridAnimating };
+  }
+  _renderSceneFrame() {
+    const layout = this._buildLayoutFromScene(performance.now());
+    if (!layout || !this.lastInput) return;
+    this.lastRenderedLayout = layout;
+    if (this.lastInput.renderer === "svg" && this.svgGroup) {
+      this.renderToSvg(this.svgGroup, layout, this.lastInput);
+    } else if (this.lastInput.renderer === "canvas") {
+      this.lastInput.requestRedraw?.();
+    }
+  }
+  _startAnimLoop() {
+    if (this._animRafId !== null) {
+      cancelRaf(this._animRafId);
+    }
+    const tick = (now) => {
+      this._animRafId = null;
+      const { allIdle } = this._scene.tick(now);
+      this._renderSceneFrame();
+      this.onFrame?.();
+      if (!allIdle || this._gridLerp !== null) {
+        this._animRafId = raf(tick);
+      }
+    };
+    this._animRafId = raf(tick);
+  }
+  // ================================================================
+  // PRIVATE — RENDERING
+  // ================================================================
+  /**
+   * Build the keyed children of `svgGroup`: the bars group (`data-layer="bars"`)
+   * and the optional labels group (`data-layer="labels"`). Shared by the full
+   * render (materialize → replace) and hover (reconcile) so the two stay
+   * structurally identical and the reconciler can match nodes by key.
+   */
+  buildPolarSvgChildren(layout, input) {
+    const children = [];
+    const barsNode = this._paint.renderSvg(layout, this.hoverState, this.effectConfig, input.theme);
+    setAttr(barsNode, "data-layer", "bars");
+    const a11y = buildAccessibilityRenderContext(input.features);
+    if (a11y?.enabled && a11y.landmarkVerbosity === "all") {
+      setAttr(barsNode, "role", "region");
+      setAttr(barsNode, "aria-label", generateSeriesDescription(layout.bars[0]?.name ?? "Polar", "polar", layout.bars.length));
+    }
+    children.push(barsNode);
+    const lc = input.labelConfig;
+    if (lc) {
+      const dsTotal = layout.bars.reduce((sum, b) => sum + Math.abs(b.value), 0);
+      const labels = resolvePolarLabels(layout.bars, dsTotal, layout.center, lc);
+      const labelGroup = createSvgGroup();
+      renderResolvedLabels(labels, lc, { renderer: "svg", svgGroup: labelGroup, theme: input.theme });
+      setAttr(labelGroup, "data-layer", "labels");
+      children.push(labelGroup);
+    }
+    return children;
+  }
+  renderToSvg(group, layout, input) {
+    group.replaceChildren(...this.buildPolarSvgChildren(layout, input).map(materializeSvgNode));
+  }
+};
+
+export { PolarRendererController };