@primeui/chart-core 0.0.1-alpha.1

package/dist/chunk-Y3L3D4GQ.mjs

@@ -0,0 +1,685 @@
+import { barHitTest, barFindNearest, barFindAllNearest } from './chunk-JGOVWSKH.mjs';
+import { animatableBarToComputedBar } from './chunk-FRST55HY.mjs';
+import { registerDatasetLayers, triggerCompositorRepaint } from './chunk-Q6PPVIHU.mjs';
+import { resolveBarLabels } from './chunk-66T4MRC5.mjs';
+import { renderResolvedLabels } from './chunk-QQBXUDM4.mjs';
+import { computeBarVisualLayout } from './chunk-7QQ6ETB4.mjs';
+import { AnimatedScene, resolveAnimatedProps, BAR_ANIMATABLE_PROPS } from './chunk-VN7CKCSE.mjs';
+import { reconcileSvgChildren } from './chunk-KP2TWD4Z.mjs';
+import { parseAnimationConfig } from './chunk-3WEMHXZI.mjs';
+import { cancelRaf, raf } from './chunk-EDAKJLNA.mjs';
+import { hoverConfigToFullEffect } from './chunk-BZN2QHGP.mjs';
+import { generateSeriesDescription } from './chunk-OGJ6IIBW.mjs';
+import { collectItems } from './chunk-FFMT6OCO.mjs';
+import { defaultLightTheme } from './chunk-O2X6FF45.mjs';
+import { setAttr, createSvgGroup, svgNode, appendChild, createSvgRect, materializeSvgNode } from './chunk-SSLTFJ3U.mjs';
+
+// src/series/bar/controller/types.ts
+var BAR_SCENE_REGISTRY = {
+  number: ["x", "y", "width", "height"],
+  color: []
+};
+
+// src/series/bar/controller/paint.ts
+function groupAnimatedBarsByDataset(animatedBars) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const b of animatedBars) {
+    let arr = grouped.get(b.datasetId);
+    if (!arr) {
+      arr = [];
+      grouped.set(b.datasetId, arr);
+    }
+    arr.push(animatableBarToComputedBar(b));
+  }
+  return grouped;
+}
+function barHoverInteraction(base, dsId, hover, flags) {
+  const isAnyHover = hover.datasetId !== null;
+  const isAxisHover = hover.axisIndex != null;
+  const isThisSeriesHovered = hover.datasetId === dsId;
+  const { isWaterfall, isStacked, isGrouped } = flags;
+  return {
+    ...base,
+    hoveredIndex: isAxisHover ? hover.axisIndex ?? null : isThisSeriesHovered ? hover.index : null,
+    isSeriesHovered: isAxisHover || isWaterfall ? false : (isStacked || isGrouped) && isAnyHover && isThisSeriesHovered,
+    isSeriesDimmed: isAxisHover || isWaterfall ? false : isAnyHover && !isThisSeriesHovered
+  };
+}
+function buildBarSvgChildren(params) {
+  const { paint, layouts, renderProps, propertyOverrides, context, orientation, hover, labelConfig, onImageLoad, isZoomed, chartArea, chartId, isPercentStacked, isWaterfall, isStacked, isGrouped, datasetTotals, datasetVisibility } = params;
+  const flags = { isWaterfall, isStacked, isGrouped };
+  const datasetNodes = [];
+  for (const [dsId, layout] of layouts) {
+    const props = renderProps.get(dsId);
+    if (!props) continue;
+    const propsWithHover = {
+      ...props,
+      interaction: barHoverInteraction(props.interaction, dsId, hover, flags)
+    };
+    const barNode = paint.renderSvg(propsWithHover, layout, context);
+    setAttr(barNode, "data-dataset", dsId);
+    if (context.accessibility?.enabled && context.accessibility.landmarkVerbosity === "all") {
+      setAttr(barNode, "role", "region");
+      setAttr(barNode, "aria-label", generateSeriesDescription(props.name ?? dsId, "bar", layout.visibleBars.length));
+    }
+    const ov = propertyOverrides.get(dsId);
+    if (ov && ov.opacity != null) setAttr(barNode, "opacity", String(ov.opacity));
+    datasetNodes.push(barNode);
+  }
+  let labelsNode = null;
+  if (labelConfig && !labelConfig.render) {
+    const labelGroup = createSvgGroup();
+    setAttr(labelGroup, "data-layer", "labels");
+    for (const [dsId, layout] of layouts) {
+      if (datasetVisibility?.get(dsId) === false) continue;
+      const dsTotal = datasetTotals.get(dsId) ?? 0;
+      renderResolvedLabels(resolveBarLabels(layout.visibleBars, layout.colors, dsTotal, orientation, labelConfig, isPercentStacked, renderProps.get(dsId)?.name, renderProps.get(dsId)?.data), labelConfig, {
+        renderer: "svg",
+        svgGroup: labelGroup,
+        onImageLoad,
+        theme: context.theme
+      });
+    }
+    labelsNode = labelGroup;
+  }
+  if (isZoomed && chartArea) {
+    const clipId = `bar-zoom-clip-${chartId}`;
+    const clipPath = svgNode("clipPath", { id: clipId });
+    appendChild(clipPath, createSvgRect(chartArea.x, chartArea.y, chartArea.width, chartArea.height));
+    const dataTarget = createSvgGroup();
+    setAttr(dataTarget, "data-layer", "clipwrap");
+    setAttr(dataTarget, "clip-path", `url(#${clipId})`);
+    for (const n of datasetNodes) appendChild(dataTarget, n);
+    if (labelsNode) appendChild(dataTarget, labelsNode);
+    return [clipPath, dataTarget];
+  }
+  return labelsNode ? [...datasetNodes, labelsNode] : datasetNodes;
+}
+function renderBarsFrame(params) {
+  const {
+    paint,
+    renderer,
+    group,
+    canvas,
+    layouts,
+    renderProps,
+    propertyOverrides,
+    context,
+    orientation,
+    hover,
+    labelConfig,
+    onImageLoad,
+    isZoomed,
+    chartArea,
+    chartId,
+    isPercentStacked,
+    isWaterfall,
+    isStacked,
+    isGrouped,
+    datasetTotals,
+    datasetVisibility
+  } = params;
+  if (renderer === "svg" && group) {
+    const children = buildBarSvgChildren({
+      paint,
+      layouts,
+      renderProps,
+      propertyOverrides,
+      context,
+      orientation,
+      hover,
+      labelConfig,
+      onImageLoad,
+      isZoomed,
+      chartArea,
+      chartId,
+      isPercentStacked,
+      isWaterfall,
+      isStacked,
+      isGrouped,
+      datasetTotals,
+      datasetVisibility
+    });
+    group.replaceChildren(...children.map(materializeSvgNode));
+  }
+  if (renderer === "canvas") {
+    const ctx = canvas?.getContext("2d");
+    if (!ctx) return;
+    if (isZoomed && chartArea) {
+      ctx.save();
+      ctx.beginPath();
+      ctx.rect(chartArea.x, chartArea.y, chartArea.width, chartArea.height);
+      ctx.clip();
+    }
+    for (const [dsId, layout] of layouts) {
+      const props = renderProps.get(dsId);
+      if (!props) continue;
+      const propsWithHover = {
+        ...props,
+        interaction: barHoverInteraction(props.interaction, dsId, hover, { isWaterfall, isStacked, isGrouped })
+      };
+      paint.renderCanvas(propsWithHover, layout, ctx, context);
+    }
+    if (labelConfig) {
+      for (const [dsId, layout] of layouts) {
+        if (datasetVisibility?.get(dsId) === false) continue;
+        const dsTotal = datasetTotals.get(dsId) ?? 0;
+        renderResolvedLabels(resolveBarLabels(layout.visibleBars, layout.colors, dsTotal, orientation, labelConfig, isPercentStacked, renderProps.get(dsId)?.name, renderProps.get(dsId)?.data), labelConfig, {
+          renderer: "canvas",
+          ctx,
+          onImageLoad,
+          theme: context.theme
+        });
+      }
+    }
+    if (isZoomed && chartArea) {
+      ctx.restore();
+    }
+  }
+}
+function applyHover(ctx, hover) {
+  ctx.hover = hover;
+  if (!ctx.lastRenderedLayouts || !ctx.lastInput?.layoutData) return;
+  const input = ctx.lastInput;
+  const layoutData = input.layoutData;
+  if (triggerCompositorRepaint(input.renderer, ctx.canvasEl, input.compositor)) {
+    return;
+  }
+  if (ctx._animRafId !== null) {
+    ctx.hover = hover;
+    return;
+  }
+  if (input.renderer === "svg" && ctx.svgGroup) {
+    const children = buildBarSvgChildren({
+      paint: ctx._paint,
+      layouts: ctx.lastRenderedLayouts,
+      renderProps: ctx.renderPropsCache,
+      propertyOverrides: ctx._propertyOverrides,
+      context: layoutData.context,
+      orientation: layoutData.orientation,
+      hover,
+      labelConfig: ctx.labelConfig,
+      onImageLoad: ctx.onImageLoad,
+      isZoomed: input.isZoomed,
+      chartArea: layoutData.cartesianArea,
+      chartId: input.chartId,
+      isPercentStacked: layoutData.isPercentStacked,
+      isWaterfall: layoutData.isWaterfall,
+      isStacked: layoutData.isStacked,
+      isGrouped: layoutData.isGrouped,
+      datasetTotals: layoutData.datasetTotals,
+      datasetVisibility: input.datasetVisibility
+    });
+    reconcileSvgChildren(ctx.svgGroup, children);
+    return;
+  }
+  renderBarsFrame({
+    paint: ctx._paint,
+    renderer: input.renderer,
+    group: ctx.svgGroup,
+    canvas: ctx.canvasEl,
+    layouts: ctx.lastRenderedLayouts,
+    renderProps: ctx.renderPropsCache,
+    propertyOverrides: ctx._propertyOverrides,
+    context: layoutData.context,
+    orientation: layoutData.orientation,
+    hover,
+    labelConfig: ctx.labelConfig,
+    onImageLoad: ctx.onImageLoad,
+    isZoomed: input.isZoomed,
+    chartArea: layoutData.cartesianArea,
+    chartId: input.chartId,
+    isPercentStacked: layoutData.isPercentStacked,
+    isWaterfall: layoutData.isWaterfall,
+    isStacked: layoutData.isStacked,
+    isGrouped: layoutData.isGrouped,
+    datasetTotals: layoutData.datasetTotals,
+    dir: ctx.dir,
+    datasetVisibility: input.datasetVisibility
+  });
+}
+
+// src/series/bar/controller/scene.ts
+function buildBarsFromScene(ctx) {
+  const result = [];
+  for (const el of ctx._scene.getElements()) {
+    const s = el.current;
+    result.push({
+      dataIndex: s.dataIndex,
+      datasetId: s.datasetId,
+      x: s.x,
+      y: s.y,
+      width: s.width,
+      height: s.height,
+      value: s.value,
+      category: s.category,
+      isNegative: s.isNegative,
+      baseX: s.baseX,
+      baseY: s.baseY,
+      orientation: s.orientation,
+      barKey: el.id
+    });
+  }
+  return result;
+}
+function buildLayoutsFromScene(ctx, animBars) {
+  const barsByDataset = groupAnimatedBarsByDataset(animBars);
+  const animated = /* @__PURE__ */ new Map();
+  for (const [dsId, computedBars] of barsByDataset) {
+    const template = ctx.layoutCache.get(dsId) ?? ctx.exitingBarLayouts.get(dsId);
+    if (!template) continue;
+    animated.set(dsId, { ...template, bars: computedBars, visibleBars: computedBars });
+  }
+  return animated;
+}
+function renderSceneFrame(ctx, layoutData, isFinalFrame = false) {
+  const animBars = buildBarsFromScene(ctx);
+  const frameLayouts = buildLayoutsFromScene(ctx, animBars);
+  ctx.lastRenderedLayouts = frameLayouts;
+  if (isFinalFrame) {
+    const liveDatasetIds = /* @__PURE__ */ new Set();
+    for (const b of animBars) liveDatasetIds.add(b.datasetId);
+    for (const dsId of [...ctx.exitingBarLayouts.keys()]) {
+      if (!liveDatasetIds.has(dsId)) {
+        ctx.exitingBarLayouts.delete(dsId);
+        ctx.exitingBarRenderProps.delete(dsId);
+        ctx.renderPropsCache.delete(dsId);
+      }
+    }
+  }
+  const input = ctx.lastInput;
+  if (triggerCompositorRepaint(input?.renderer ?? "svg", ctx.canvasEl, input?.compositor)) {
+    return;
+  }
+  renderBarsFrame({
+    paint: ctx._paint,
+    renderer: input?.renderer ?? "svg",
+    group: ctx.svgGroup,
+    canvas: ctx.canvasEl,
+    layouts: frameLayouts,
+    renderProps: ctx.renderPropsCache,
+    propertyOverrides: ctx._propertyOverrides,
+    context: layoutData.context,
+    orientation: layoutData.orientation,
+    hover: ctx.hover,
+    labelConfig: ctx.labelConfig,
+    onImageLoad: ctx.onImageLoad,
+    isZoomed: input?.isZoomed,
+    chartArea: layoutData.cartesianArea,
+    chartId: input?.chartId ?? "",
+    isPercentStacked: layoutData.isPercentStacked,
+    isWaterfall: layoutData.isWaterfall,
+    isStacked: layoutData.isStacked,
+    isGrouped: layoutData.isGrouped,
+    datasetTotals: layoutData.datasetTotals,
+    dir: ctx.dir,
+    datasetVisibility: input?.datasetVisibility
+  });
+}
+function startAnimLoop(ctx, layoutData) {
+  if (ctx._animRafId !== null) {
+    cancelRaf(ctx._animRafId);
+  }
+  const tick = (now) => {
+    ctx._animRafId = null;
+    const { allIdle } = ctx._scene.tick(now);
+    renderSceneFrame(ctx, layoutData, allIdle);
+    ctx.onFrame?.();
+    if (!allIdle) {
+      ctx._animRafId = raf(tick);
+    }
+  };
+  ctx._animRafId = raf(tick);
+}
+
+// src/series/bar/controller/index.ts
+var BarRendererController = class {
+  constructor(paint) {
+    this._animRafId = null;
+    this._lastFingerprint = "";
+    this.lastRenderedLayouts = null;
+    // Toggle animation — layouts/props for datasets being hidden so they can shrink out
+    this.exitingBarLayouts = /* @__PURE__ */ new Map();
+    this.exitingBarRenderProps = /* @__PURE__ */ new Map();
+    // Layout caches (exposed for external consumers via getters)
+    this.layoutCache = /* @__PURE__ */ new Map();
+    this.renderPropsCache = /* @__PURE__ */ new Map();
+    this.barDatasets = [];
+    /**
+     * Per-dataset property-animation overrides. Layered onto layout-derived renderProps
+     * each `update()` and each `applyPropertyAnimations()` call. Property animations write
+     * here; layout/scene never touches it. Cleared in destroy().
+     */
+    this._propertyOverrides = /* @__PURE__ */ new Map();
+    // Current state.
+    // Single source of truth for the current hover. Written ONLY by applyHover (never
+    // re-seeded from input.hover), read by update()'s layout pass, the compositor paint
+    // callback, and _renderSceneFrame. Hover is event-driven and always arrives via
+    // applyHover, so re-seeding from the swappable input would let a stale input.hover
+    // clobber the live hover. Mirrors candlestick/heatmap/radar/polar.
+    this.hover = { datasetId: null, index: null };
+    this.labelConfig = null;
+    this.dir = "ltr";
+    this.lastInput = null;
+    // DOM targets (provided by framework wrapper)
+    this.svgGroup = null;
+    this.canvasEl = null;
+    /** Animation frame notification — framework registers this to trigger re-render/repaint */
+    this.onFrame = null;
+    this._paint = paint;
+    this._scene = new AnimatedScene({
+      // ENTER: bar grows from baseline (height/width = 0, position at base axis).
+      emptyState: (target) => {
+        if (target.orientation === "horizontal") {
+          return { ...target, x: target.baseX, width: 0 };
+        }
+        return { ...target, y: target.baseY, height: 0 };
+      },
+      // EXIT: bar shrinks back to baseline at its own position. Same shape as enter.
+      exitEmptyState: (target) => {
+        if (target.orientation === "horizontal") {
+          return { ...target, x: target.baseX, width: 0 };
+        }
+        return { ...target, y: target.baseY, height: 0 };
+      },
+      registry: BAR_SCENE_REGISTRY
+    });
+  }
+  // ================================================================
+  // PUBLIC API
+  // ================================================================
+  /**
+   * Full update — layout + animation start.
+   * Called by framework wrapper when data/config/layout changes.
+   */
+  update(input) {
+    this.lastInput = input;
+    this.labelConfig = input.labelConfig;
+    this.onImageLoad = input.onImageLoad;
+    this.svgGroup = input.svgGroup ?? null;
+    this.canvasEl = input.canvasEl ?? null;
+    const { datasets, datasetVisibility, layoutData, features, compositor, isZoomed } = input;
+    const sortedDatasets = Array.from(datasets.entries()).sort(([, a], [, b]) => a.order - b.order);
+    this.barDatasets = collectItems(sortedDatasets, datasetVisibility).bar;
+    const barVisual = layoutData?.barIntermediate ? computeBarVisualLayout({
+      intermediate: layoutData.barIntermediate,
+      sharedCategoryScale: layoutData.sharedCategoryScale,
+      valueScales: layoutData.valueScales,
+      valueDomains: layoutData.valueDomains,
+      cartesianArea: layoutData.cartesianArea,
+      orientation: layoutData.orientation,
+      axisLayouts: layoutData.axisLayouts,
+      hover: this.hover,
+      hoverConfig: input.hoverConfig ? hoverConfigToFullEffect(input.hoverConfig) : void 0,
+      theme: input.theme
+    }) : null;
+    const prevLayoutCache = this.layoutCache;
+    const prevRenderPropsCache = this.renderPropsCache;
+    if (barVisual) {
+      this.layoutCache = barVisual.layouts;
+      this.renderPropsCache = barVisual.renderProps;
+    } else {
+      this.layoutCache = /* @__PURE__ */ new Map();
+      this.renderPropsCache = /* @__PURE__ */ new Map();
+    }
+    if (!layoutData || !barVisual || barVisual.layouts.size === 0) {
+      this.lastRenderedLayouts = null;
+      if (this._animRafId !== null) {
+        cancelRaf(this._animRafId);
+        this._animRafId = null;
+      }
+      this._scene.reset();
+      this._lastFingerprint = "";
+      if (input.renderer === "svg" && this.svgGroup) {
+        while (this.svgGroup.firstChild) this.svgGroup.removeChild(this.svgGroup.firstChild);
+      }
+      return;
+    }
+    if (input.renderer === "svg" && !this.svgGroup) return;
+    const { layouts, allTargets } = barVisual;
+    const { context, orientation } = layoutData;
+    if (input.renderer === "canvas" && compositor) {
+      registerDatasetLayers(
+        compositor,
+        "bar",
+        layouts.keys(),
+        (dsId) => datasets.get(dsId)?.order ?? 0,
+        (dsId) => (ctx) => {
+          const layout = this.lastRenderedLayouts?.get(dsId);
+          if (!layout) return;
+          const props = this.renderPropsCache.get(dsId);
+          if (!props) return;
+          if (isZoomed && layoutData.cartesianArea) {
+            ctx.save();
+            ctx.beginPath();
+            ctx.rect(layoutData.cartesianArea.x, layoutData.cartesianArea.y, layoutData.cartesianArea.width, layoutData.cartesianArea.height);
+            ctx.clip();
+          }
+          const isAnyHoverCompositor = this.hover.datasetId !== null;
+          const isAxisHoverCompositor = this.hover.axisIndex != null;
+          const isThisSeriesHoveredCompositor = this.hover.datasetId === dsId;
+          const propsWithHover = {
+            ...props,
+            interaction: {
+              ...props.interaction,
+              hoveredIndex: isAxisHoverCompositor ? this.hover.axisIndex ?? null : isThisSeriesHoveredCompositor ? this.hover.index : null,
+              isSeriesHovered: isAxisHoverCompositor ? false : (layoutData.isStacked || layoutData.isGrouped) && isAnyHoverCompositor && isThisSeriesHoveredCompositor,
+              isSeriesDimmed: isAxisHoverCompositor ? false : isAnyHoverCompositor && !isThisSeriesHoveredCompositor
+            }
+          };
+          this._paint.renderCanvas(propsWithHover, layout, ctx, context);
+          if (this.labelConfig && this.lastInput?.datasetVisibility?.get(dsId) !== false) {
+            const dsTotal = layoutData.datasetTotals.get(dsId) ?? 0;
+            renderResolvedLabels(resolveBarLabels(layout.visibleBars, layout.colors, dsTotal, orientation, this.labelConfig, layoutData.isPercentStacked, props.name, props.data), this.labelConfig, {
+              renderer: "canvas",
+              ctx,
+              onImageLoad: this.onImageLoad,
+              theme: this.lastInput?.theme ?? defaultLightTheme
+            });
+          }
+          if (isZoomed && layoutData.cartesianArea) {
+            ctx.restore();
+          }
+        }
+      );
+    }
+    this.exitingBarLayouts.clear();
+    this.exitingBarRenderProps.clear();
+    for (const [dsId, prevLayout] of prevLayoutCache) {
+      if (!layouts.has(dsId)) {
+        this.exitingBarLayouts.set(dsId, prevLayout);
+        const pp = prevRenderPropsCache.get(dsId);
+        if (pp) this.exitingBarRenderProps.set(dsId, pp);
+      }
+    }
+    if (this.exitingBarRenderProps.size > 0) {
+      const merged = new Map(this.renderPropsCache);
+      for (const [dsId, pp] of this.exitingBarRenderProps) merged.set(dsId, pp);
+      this.renderPropsCache = merged;
+    }
+    if (this._propertyOverrides.size > 0) {
+      for (const [dsId, overrides] of this._propertyOverrides) {
+        const base = this.renderPropsCache.get(dsId);
+        if (base) this.renderPropsCache.set(dsId, { ...base, ...overrides });
+      }
+    }
+    const animConfig = features.get("animation")?.props;
+    const { enabled: animEnabled, duration, easing } = parseAnimationConfig(animConfig);
+    const limit = animConfig?.limit ?? 5e3;
+    const fingerprint = `${allTargets.map((t) => `${t.datasetId}:${t.dataIndex}:${t.value}:${Math.round(t.x)}`).join(";")}|${orientation}`;
+    const dataChanged = fingerprint !== this._lastFingerprint;
+    const shouldAnimate = animEnabled && duration > 0 && allTargets.length <= limit && allTargets.length > 0 && dataChanged;
+    const sceneTargets = /* @__PURE__ */ new Map();
+    for (const t of allTargets) {
+      sceneTargets.set(`${t.datasetId}-${t.dataIndex}`, {
+        x: t.x,
+        y: t.y,
+        width: t.width,
+        height: t.height,
+        value: t.value,
+        baseX: t.baseX,
+        baseY: t.baseY,
+        dataIndex: t.dataIndex,
+        datasetId: t.datasetId,
+        category: t.category,
+        isNegative: t.isNegative,
+        orientation: t.orientation
+      });
+    }
+    if (dataChanged && this._animRafId !== null) {
+      cancelRaf(this._animRafId);
+      this._animRafId = null;
+    }
+    const opts = { numbers: { duration: shouldAnimate ? duration : 0, easing } };
+    this._scene.diff(sceneTargets, opts);
+    if (dataChanged) {
+      this._lastFingerprint = fingerprint;
+    }
+    if (shouldAnimate) {
+      this._renderSceneFrame(layoutData);
+      this._startAnimLoop(layoutData);
+    } else {
+      this._scene.tick(performance.now());
+      this._renderSceneFrame(layoutData, true);
+    }
+  }
+  /**
+   * Lightweight hover repaint — re-renders current frame with updated hover state.
+   * Never cancels or restarts animations.
+   */
+  applyHover(hover) {
+    applyHover(this, hover);
+  }
+  /**
+   * Hit test at pixel coordinates.
+   */
+  hitTest(x, y) {
+    if (!this.lastInput?.layoutData) return null;
+    return barHitTest(x, y, { layouts: this.layoutCache, renderPropsCache: this.renderPropsCache, datasets: this.lastInput.datasets, layoutData: this.lastInput.layoutData, theme: this.lastInput.theme });
+  }
+  /**
+   * Find the nearest data point by category axis proximity (for crosshair mode).
+   */
+  findNearest(x, y) {
+    if (!this.lastInput?.layoutData) return null;
+    return barFindNearest(x, y, { layouts: this.layoutCache, renderPropsCache: this.renderPropsCache, datasets: this.lastInput.datasets, layoutData: this.lastInput.layoutData, theme: this.lastInput.theme });
+  }
+  /**
+   * Find ALL dataset hits at the nearest category (for multi-series crosshair badges).
+   */
+  findAllNearest(x, y) {
+    if (!this.lastInput?.layoutData) return null;
+    return barFindAllNearest(x, y, { layouts: this.layoutCache, renderPropsCache: this.renderPropsCache, datasets: this.lastInput.datasets, layoutData: this.lastInput.layoutData, theme: this.lastInput.theme });
+  }
+  /**
+   * Not used for bar (renders directly to DOM). Provided for interface compliance.
+   */
+  getSvgOutput() {
+    return null;
+  }
+  /** Whether any bar datasets exist */
+  get hasData() {
+    return this.barDatasets.length > 0;
+  }
+  /** Current bar layouts (for external consumers like CartesianRenderer) */
+  get layouts() {
+    return this.layoutCache;
+  }
+  /** Current bar render props (for external consumers) */
+  get renderProps() {
+    return this.renderPropsCache;
+  }
+  /**
+   * Cleanup — cancel animation loop, clear scene, remove compositor layers.
+   */
+  destroy() {
+    if (this._animRafId !== null) {
+      cancelRaf(this._animRafId);
+      this._animRafId = null;
+    }
+    this._scene.reset();
+    this._propertyOverrides.clear();
+    this.lastInput?.compositor?.removeLayersByPrefix("bar:");
+  }
+  /**
+   * Apply animated property values without triggering a full layout+render cycle.
+   * Called directly from the animation registry's repaint callback each frame.
+   *
+   * SVG: `opacity` animates via a cheap in-place attribute patch on the dataset group;
+   *      any other prop (`borderStrokeWidth` → stroke-width, `borderRadius` → rx) needs a
+   *      geometry rebuild — rx isn't an inheritable attr, so it can't be patched on the group.
+   *      Those merge into the cache and trigger a full frame render, keeping SVG at parity with
+   *      canvas (and consistent with the other renderers) for every BAR_ANIMATABLE_PROPS.
+   * Canvas: updates renderPropsCache then triggers a compositor repaint.
+   */
+  applyPropertyAnimations(store) {
+    const input = this.lastInput;
+    if (!input) return;
+    if (input.renderer === "svg" && this.svgGroup) {
+      const resolved = /* @__PURE__ */ new Map();
+      let needsFullRender = false;
+      for (const [dsId] of this.renderPropsCache) {
+        const overrides = resolveAnimatedProps(store, "bar", dsId, BAR_ANIMATABLE_PROPS);
+        if (Object.keys(overrides).length === 0) {
+          this._propertyOverrides.delete(dsId);
+          continue;
+        }
+        this._propertyOverrides.set(dsId, overrides);
+        resolved.set(dsId, overrides);
+        if (Object.keys(overrides).some((k) => k !== "opacity")) needsFullRender = true;
+      }
+      if (needsFullRender) {
+        for (const [dsId, overrides] of resolved) {
+          const base = this.renderPropsCache.get(dsId);
+          if (base) this.renderPropsCache.set(dsId, { ...base, ...overrides });
+        }
+        this.renderFrameCycle();
+      } else {
+        for (const [dsId, overrides] of resolved) {
+          if ("opacity" in overrides) {
+            this.svgGroup.querySelector(`[data-dataset="${dsId}"]`)?.setAttribute("opacity", String(overrides.opacity));
+          }
+        }
+      }
+      return;
+    }
+    if (input.renderer === "canvas") {
+      for (const [dsId, rp] of this.renderPropsCache) {
+        const overrides = resolveAnimatedProps(store, "bar", dsId, BAR_ANIMATABLE_PROPS);
+        if (Object.keys(overrides).length === 0) {
+          this._propertyOverrides.delete(dsId);
+          continue;
+        }
+        this._propertyOverrides.set(dsId, overrides);
+        this.renderPropsCache.set(dsId, { ...rp, ...overrides });
+      }
+      triggerCompositorRepaint(input.renderer, this.canvasEl, input.compositor);
+    }
+  }
+  /**
+   * 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, in-place
+   * SVG attribute patches (set during `applyPropertyAnimations`) leave
+   * attributes pointing at the last animated value. This method rebuilds the
+   * frame from `_propertyOverrides`-cleared base props so SVG attributes
+   * snap back to their base values.
+   */
+  renderFrameCycle() {
+    const layoutData = this.lastInput?.layoutData;
+    if (!layoutData) return;
+    this._renderSceneFrame(layoutData);
+  }
+  // ================================================================
+  // PRIVATE HELPERS
+  // ================================================================
+  _renderSceneFrame(layoutData, isFinalFrame = false) {
+    renderSceneFrame(this, layoutData, isFinalFrame);
+  }
+  _startAnimLoop(layoutData) {
+    startAnimLoop(this, layoutData);
+  }
+};
+
+export { BarRendererController };