@primeui/chart-core 0.0.1-alpha.1

package/dist/chunk-KNDZP446.mjs

@@ -0,0 +1,895 @@
+import { calculateAxisLayout } from './chunk-ZTL2FQEW.mjs';
+import { getEasing, easeOutQuart } from './chunk-3WEMHXZI.mjs';
+import { raf, cancelRaf } from './chunk-EDAKJLNA.mjs';
+import { interpolateCartesianAxisLayout } from './chunk-WH3C3Y7P.mjs';
+import { createLinearScale, createOrdinalTimeScale, createOrdinalTimeBandAdapter, createTimeScale, createTimeBandAdapter } from './chunk-RQ3CKQOX.mjs';
+
+// src/animations/axis-transition.ts
+var AXIS_SMOOTHING = 0.225;
+var AXIS_SETTLED_THRESHOLD = 5e-3;
+var AxisTransitionState = class {
+  constructor() {
+    this.opacities = /* @__PURE__ */ new Map();
+    /**
+     * Per-axis per-tick opacities. Keyed by axisId, then by tick value
+     * (numeric `rawValue` for value axes, string `value` for category axes).
+     *
+     * Step 11 extension. Populated by `setTickTargets`, advanced by `tick`,
+     * read by `applyTicks`. When no entry exists for an axis, `applyTicks`
+     * passes ticks through unchanged so existing axes (no per-tick lerp)
+     * keep their current behavior.
+     */
+    this.tickOpacities = /* @__PURE__ */ new Map();
+    /**
+     * Per-axis rotation interpolation state. Populated by `setRotationTargets`,
+     * advanced by `tick`, read by `applyRotations`.
+     *
+     * Step 11 extension. Reuses `AxisOpacity` shape (`{ current, target }`)
+     * since the math is identical — exponential decay at `AXIS_SMOOTHING`.
+     */
+    this.rotations = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Set opacity targets from axis layout isHidden flags.
+   * Call this whenever layoutData changes.
+   */
+  setTargets(axisLayouts) {
+    const activeKeys = /* @__PURE__ */ new Set();
+    for (const [key, info] of axisLayouts) {
+      activeKeys.add(key);
+      const target = info.isHidden ? 0 : 1;
+      const existing = this.opacities.get(key);
+      if (existing) {
+        const previousTarget = existing.target;
+        existing.target = target;
+        if (target === 0 && previousTarget === 0) {
+          existing.current = 0;
+        }
+      } else {
+        this.opacities.set(key, { current: target, target });
+      }
+    }
+    for (const key of this.opacities.keys()) {
+      if (!activeKeys.has(key)) {
+        this.opacities.delete(key);
+      }
+    }
+  }
+  /**
+   * Advance all opacity values by one frame using exponential decay.
+   * Covers axis-level opacities, per-tick opacities, and per-axis rotations.
+   * Returns true if any value is still animating.
+   *
+   * Per-tick cleanup: an exiting tick (target = 0) that has settled is
+   * REMOVED from the per-axis map. This keeps the map size bounded across
+   * many domain lerps. Continuing/entering ticks (target = 1) simply snap.
+   */
+  tick() {
+    let anyAnimating = false;
+    for (const opacity of this.opacities.values()) {
+      const displacement = opacity.target - opacity.current;
+      if (Math.abs(displacement) > AXIS_SETTLED_THRESHOLD) {
+        opacity.current += displacement * AXIS_SMOOTHING;
+        anyAnimating = true;
+      } else {
+        opacity.current = opacity.target;
+      }
+    }
+    for (const tickMap of this.tickOpacities.values()) {
+      for (const [tickKey, opacity] of tickMap) {
+        const displacement = opacity.target - opacity.current;
+        if (Math.abs(displacement) > AXIS_SETTLED_THRESHOLD) {
+          opacity.current += displacement * AXIS_SMOOTHING;
+          anyAnimating = true;
+        } else {
+          opacity.current = opacity.target;
+          if (opacity.target === 0) {
+            tickMap.delete(tickKey);
+          }
+        }
+      }
+    }
+    for (const rotation of this.rotations.values()) {
+      const displacement = rotation.target - rotation.current;
+      if (Math.abs(displacement) > AXIS_SETTLED_THRESHOLD) {
+        rotation.current += displacement * AXIS_SMOOTHING;
+        anyAnimating = true;
+      } else {
+        rotation.current = rotation.target;
+      }
+    }
+    return anyAnimating;
+  }
+  /**
+   * Apply animated opacity to axis layouts.
+   *
+   * - Hidden axis with opacity > threshold: swap in visibleLayout with opacity (fade-out in progress)
+   * - Hidden axis settled at 0: use hidden layout as-is (fully invisible)
+   * - Visible axis: use layout with current opacity (handles fade-in)
+   */
+  apply(axisLayouts) {
+    const result = /* @__PURE__ */ new Map();
+    for (const [key, info] of axisLayouts) {
+      const opacityState = this.opacities.get(key);
+      if (!opacityState) {
+        result.set(key, info);
+        continue;
+      }
+      const opacity = opacityState.current;
+      if (info.isHidden && opacity > AXIS_SETTLED_THRESHOLD) {
+        result.set(key, {
+          ...info,
+          layout: { ...info.visibleLayout, opacity }
+        });
+      } else if (!info.isHidden && opacity < 1 - AXIS_SETTLED_THRESHOLD) {
+        result.set(key, {
+          ...info,
+          layout: { ...info.layout, opacity }
+        });
+      } else {
+        result.set(key, info);
+      }
+    }
+    return result;
+  }
+  // ========================================================================
+  // STEP 11: Per-tick opacity API
+  // ========================================================================
+  /**
+   * Set per-tick opacity targets for one axis from an enter/exit/continuing
+   * categorization. Idempotent within a frame — call once per domain lerp init.
+   *
+   * - Entering tick (new): target = 1, current = 0 if no prior entry exists
+   *   (animates IN). If a prior entry exists, keep current as-is to handle
+   *   rapid toggling without snapping.
+   * - Exiting tick (removed): target = 0, current = whatever it was last
+   *   (animates OUT). If no prior entry exists, assume it was visible —
+   *   start at 1.
+   * - Continuing tick (in both start + target): snap to current = target = 1.
+   *   No animation needed; position lerp via `interpolateCartesianAxisLayout`
+   *   covers the visible motion.
+   *
+   * Any tick previously tracked for this axis but NOT in the new `ticks`
+   * list is snapped to target 0 (cleanup — no longer part of the lerp).
+   * `tick()` will drop it once it settles.
+   */
+  setTickTargets(axisId, ticks) {
+    let tickMap = this.tickOpacities.get(axisId);
+    if (!tickMap) {
+      tickMap = /* @__PURE__ */ new Map();
+      this.tickOpacities.set(axisId, tickMap);
+    }
+    const activeKeys = /* @__PURE__ */ new Set();
+    for (const tick of ticks) {
+      activeKeys.add(tick.value);
+      const existing = tickMap.get(tick.value);
+      if (tick.isEntering) {
+        if (existing) {
+          existing.target = 1;
+        } else {
+          tickMap.set(tick.value, { current: 0, target: 1 });
+        }
+      } else if (tick.isExiting) {
+        if (existing) {
+          existing.target = 0;
+        } else {
+          tickMap.set(tick.value, { current: 1, target: 0 });
+        }
+      } else {
+        if (existing) {
+          existing.target = 1;
+        } else {
+          tickMap.set(tick.value, { current: 1, target: 1 });
+        }
+      }
+    }
+    for (const key of tickMap.keys()) {
+      if (!activeKeys.has(key)) {
+        tickMap.get(key).target = 0;
+      }
+    }
+  }
+  /**
+   * Apply animated per-tick opacities to a tick array. Returns the same
+   * array with each tick's `opacity` field set from the internal state.
+   *
+   * - Axis has no per-tick lerp entry: return ticks unchanged (preserves
+   *   existing behavior for axes that don't participate in tick fade).
+   * - Tick value not in the per-axis map: pass through with opacity 1.
+   */
+  applyTicks(axisId, ticks) {
+    const tickMap = this.tickOpacities.get(axisId);
+    if (!tickMap) {
+      return ticks;
+    }
+    return ticks.map((tick) => {
+      const key = tick.rawValue ?? tick.value;
+      const entry = tickMap.get(key);
+      return entry ? { ...tick, opacity: entry.current } : { ...tick, opacity: 1 };
+    });
+  }
+  /**
+   * Probe: does this axis still have a per-tick entry for `value`? Returns
+   * false once `tick()` has cleaned up a settled exiting entry. Callers
+   * (e.g. `advanceDomainLerp`'s exiting-tick merge) use it to decide
+   * whether to keep synthesizing a faded-out tick or drop it entirely.
+   */
+  hasTickEntry(axisId, value) {
+    return this.tickOpacities.get(axisId)?.has(value) ?? false;
+  }
+  // ========================================================================
+  // STEP 11: Per-axis rotation interpolation API
+  // ========================================================================
+  /**
+   * Set the target rotation angle (radians or degrees — caller-defined) for
+   * one axis. Step 11 extension.
+   *
+   * - First call for an axis with no `currentAngle`: snap current to target
+   *   (no initial animation — there's nothing to animate FROM).
+   * - First call with `currentAngle` provided: initialize current to that
+   *   angle so the first lerp animates from layout-resolved rotation to
+   *   the new target.
+   * - Subsequent calls: leave `current` alone (state machine already knows
+   *   where the visible angle is); only re-target.
+   */
+  setRotationTargets(axisId, targetAngle, currentAngle) {
+    const existing = this.rotations.get(axisId);
+    if (!existing) {
+      const start = currentAngle ?? targetAngle;
+      this.rotations.set(axisId, { current: start, target: targetAngle });
+      return;
+    }
+    existing.target = targetAngle;
+  }
+  /**
+   * Return the interpolated rotation angle for an axis, or `fallback` when
+   * no entry exists. Use the renderer-resolved rotation as the fallback so
+   * axes with no active rotation lerp stay at whatever `calculateAxisLayout`
+   * resolved for them.
+   */
+  applyRotations(axisId, fallback) {
+    const entry = this.rotations.get(axisId);
+    return entry ? entry.current : fallback;
+  }
+};
+
+// src/animations/registry.ts
+var AnimationRegistry = class {
+  constructor() {
+    this.entries = /* @__PURE__ */ new Map();
+    this.rafId = null;
+    this.onRepaint = null;
+    this.ticking = false;
+    /** True when the scheduler calls tick synchronously (detected on first raf call). Tests only. */
+    this._isSyncScheduler = false;
+    /** Set to true just before calling raf(); if tick fires while this is true, scheduler is sync. */
+    this._detectingSync = false;
+    // -------------------------------------------------------------------------
+    // PRIVATE
+    // -------------------------------------------------------------------------
+    /**
+     * Persistent bound tick function. Using a class arrow ensures the same
+     * reference is passed to every raf() call, which enables auto-rescheduling
+     * from within the tick body for async (browser) schedulers.
+     */
+    this.boundTick = (now) => {
+      if (this._detectingSync) {
+        this._isSyncScheduler = true;
+      }
+      this.rafId = null;
+      this.ticking = true;
+      try {
+        const completed = [];
+        for (const [id, entry] of this.entries) {
+          if (entry.startTime === -1) {
+            entry.startTime = now + (entry.config.delay ?? 0);
+          }
+          const elapsed = Math.max(0, now - entry.startTime);
+          const { duration, loops = 1, alternate } = entry.config;
+          if (loops === Infinity) {
+            const cycleIndex = Math.floor(elapsed / duration);
+            const cycleElapsed = elapsed % duration;
+            const rawProgress = cycleElapsed / duration;
+            const directedProgress = alternate && cycleIndex % 2 === 1 ? 1 - rawProgress : rawProgress;
+            const easedProgress = entry.easingFn(directedProgress);
+            entry.currentValue = entry.config.from + (entry.config.to - entry.config.from) * easedProgress;
+            entry.config.onTick?.(entry.currentValue);
+          } else {
+            const totalDuration = duration * loops;
+            if (elapsed >= totalDuration) {
+              entry.currentValue = entry.config.to;
+              entry.config.onTick?.(entry.currentValue);
+              entry.config.onComplete?.();
+              completed.push(id);
+            } else {
+              const cycleElapsed = elapsed % duration;
+              const rawProgress = cycleElapsed / duration;
+              const easedProgress = entry.easingFn(rawProgress);
+              entry.currentValue = entry.config.from + (entry.config.to - entry.config.from) * easedProgress;
+              entry.config.onTick?.(entry.currentValue);
+            }
+          }
+        }
+        for (const id of completed) {
+          this.entries.delete(id);
+        }
+        if (this.entries.size > 0 || completed.length > 0) {
+          this.onRepaint?.();
+        }
+      } finally {
+        this.ticking = false;
+      }
+      if (this.entries.size > 0 && !this._isSyncScheduler) {
+        this.rafId = raf(this.boundTick);
+      }
+    };
+  }
+  /**
+   * Set the repaint callback. Called after all entries are ticked each frame.
+   * Typically triggers a full canvas clear + redraw.
+   */
+  setRepaintCallback(callback) {
+    this.onRepaint = callback;
+  }
+  /**
+   * Register a new animation. If an animation with the same ID exists,
+   * it is replaced (restarted). Returns an unregister function.
+   */
+  register(config) {
+    const easingFn = typeof config.easing === "string" ? getEasing(config.easing) : config.easing ?? easeOutQuart;
+    const entry = {
+      config,
+      easingFn,
+      startTime: -1,
+      // lazily initialized to RAF `now` on first tick
+      currentValue: config.from
+    };
+    this.entries.set(config.id, entry);
+    this.ensureLoop();
+    return () => this.unregister(config.id);
+  }
+  /**
+   * Unregister an animation by ID.
+   */
+  unregister(id) {
+    this.entries.delete(id);
+  }
+  /**
+   * Check if an animation with the given ID is active.
+   */
+  has(id) {
+    return this.entries.has(id);
+  }
+  /**
+   * Get the current interpolated value for an animation.
+   * Returns undefined if the animation is not registered.
+   */
+  getValue(id) {
+    return this.entries.get(id)?.currentValue;
+  }
+  /**
+   * Get snapshots of all active animations.
+   */
+  getSnapshots() {
+    const now = performance.now();
+    const snapshots = [];
+    for (const [, entry] of this.entries) {
+      const elapsed = entry.startTime === -1 ? 0 : Math.max(0, now - entry.startTime);
+      const rawProgress = Math.min(elapsed / entry.config.duration, 1);
+      snapshots.push({
+        id: entry.config.id,
+        key: entry.config.key,
+        value: entry.currentValue,
+        progress: rawProgress
+      });
+    }
+    return snapshots;
+  }
+  /**
+   * Number of active animations.
+   */
+  get size() {
+    return this.entries.size;
+  }
+  /**
+   * Stop all animations and cancel the RAF loop.
+   */
+  clear() {
+    this.entries.clear();
+    this.stopLoop();
+  }
+  /**
+   * Full cleanup — clear all animations and remove the repaint callback.
+   */
+  destroy() {
+    this.clear();
+    this.onRepaint = null;
+  }
+  ensureLoop() {
+    if (this.rafId !== null || this.ticking) return;
+    this._detectingSync = true;
+    this.rafId = raf(this.boundTick);
+    this._detectingSync = false;
+    if (this._isSyncScheduler) {
+      this.rafId = null;
+    }
+  }
+  stopLoop() {
+    if (this.rafId !== null) {
+      cancelRaf(this.rafId);
+      this.rafId = null;
+    }
+  }
+};
+
+// src/animations/domain-lerp.ts
+var TICK_VALUE_EPSILON = 1e-9;
+function initDomainLerp(existingLerp, targetDomains, options) {
+  const expansionStart = options?.expansionStart === true;
+  for (const [axisId, targetDomain] of targetDomains) {
+    const existing = existingLerp.get(axisId);
+    let currentMin;
+    let currentMax;
+    if (existing) {
+      currentMin = existing.minCurrent;
+      currentMax = existing.maxCurrent;
+    } else {
+      currentMin = targetDomain[0];
+      currentMax = targetDomain[1];
+    }
+    const bidirectionalExpansion = existing !== void 0 && targetDomain[0] < currentMin && targetDomain[1] > currentMax;
+    if (expansionStart && !bidirectionalExpansion) {
+      currentMin = Math.min(currentMin, targetDomain[0]);
+      currentMax = Math.max(currentMax, targetDomain[1]);
+    }
+    existingLerp.set(axisId, {
+      minStart: currentMin,
+      maxStart: currentMax,
+      minTarget: targetDomain[0],
+      maxTarget: targetDomain[1],
+      minCurrent: currentMin,
+      maxCurrent: currentMax
+    });
+  }
+  for (const id of existingLerp.keys()) {
+    if (!targetDomains.has(id)) existingLerp.delete(id);
+  }
+}
+function initDomainLerpTickFade(lerpStates, axisLayouts, valueScaleRange, cartesianArea, orientation, axisTransitionState, globalFont, locale) {
+  for (const [stateKey, lerp2] of lerpStates) {
+    const isXSide = stateKey.startsWith("x:");
+    const axisLayoutKey = isXSide ? stateKey : `${orientation === "vertical" ? "y" : "x"}:${stateKey}`;
+    const axisInfo = axisLayouts.get(axisLayoutKey);
+    if (!axisInfo) continue;
+    if (axisInfo.isHidden || axisInfo.props?.type === "logarithmic") {
+      lerp2.tickFade = void 0;
+      continue;
+    }
+    if (lerp2.minStart === lerp2.minTarget && lerp2.maxStart === lerp2.maxTarget) {
+      lerp2.tickFade = void 0;
+      continue;
+    }
+    const targetTicks = extractRawValues(axisInfo.layout.ticks);
+    const startDomain = [lerp2.minStart, lerp2.maxStart];
+    const startScale = createLinearScale(startDomain, isXSide ? axisInfo.scale.range() : valueScaleRange);
+    const startArea = axisInfo.offset > 0 ? computeOffsetArea(cartesianArea, axisInfo.position, axisInfo.offset) : cartesianArea;
+    const startLayout = calculateAxisLayout(startScale, axisInfo.position, startArea, axisInfo.props, axisInfo.extraTitleOffset, globalFont, locale);
+    const startTicks = extractRawValues(startLayout.ticks);
+    const { entering, exiting, continuing } = diffTickValues(startTicks, targetTicks);
+    lerp2.tickFade = { entering, exiting, continuing };
+    axisTransitionState.setTickTargets(axisLayoutKey, [
+      ...exiting.map((v) => ({ value: v, isEntering: false, isExiting: true })),
+      ...entering.map((v) => ({ value: v, isEntering: true, isExiting: false })),
+      ...continuing.map((v) => ({ value: v, isEntering: false, isExiting: false }))
+    ]);
+    const startRotation = extractRepresentativeRotation(startLayout.ticks);
+    const targetRotation = extractRepresentativeRotation(axisInfo.layout.ticks);
+    if (startRotation !== targetRotation) {
+      axisTransitionState.setRotationTargets(axisLayoutKey, targetRotation, startRotation);
+    }
+  }
+}
+function extractRepresentativeRotation(ticks) {
+  for (const t of ticks) {
+    if (typeof t.rotation === "number") return t.rotation;
+  }
+  return 0;
+}
+function extractRawValues(ticks) {
+  const out = [];
+  for (const t of ticks) {
+    if (typeof t.rawValue === "number" && Number.isFinite(t.rawValue)) {
+      out.push(t.rawValue);
+    }
+  }
+  return out;
+}
+function diffTickValues(start, target) {
+  const entering = [];
+  const exiting = [];
+  const continuing = [];
+  for (const t of target) {
+    if (start.some((s) => Math.abs(s - t) < TICK_VALUE_EPSILON)) {
+      continuing.push(t);
+    } else {
+      entering.push(t);
+    }
+  }
+  for (const s of start) {
+    if (!target.some((t) => Math.abs(t - s) < TICK_VALUE_EPSILON)) {
+      exiting.push(s);
+    }
+  }
+  return { entering, exiting, continuing };
+}
+function advanceDomainLerp(lerpStates, progress, axisLayouts, valueScaleRange, cartesianArea, orientation, baseValueScales, baseValueDomains, globalFont, locale, axisTransitionState) {
+  const animatedValueScales = new Map(baseValueScales);
+  const animatedValueDomains = new Map(baseValueDomains);
+  const animatedAxisLayouts = new Map(axisLayouts);
+  let animatedValueXScales;
+  for (const [stateKey, lerp2] of lerpStates) {
+    const isXSide = stateKey.startsWith("x:");
+    const axisLayoutKey = isXSide ? stateKey : `${orientation === "vertical" ? "y" : "x"}:${stateKey}`;
+    const axisId = isXSide ? stateKey.slice(2) : stateKey;
+    const axisInfo = axisLayouts.get(axisLayoutKey);
+    if (axisInfo?.isHidden || axisInfo?.props?.type === "logarithmic" || isXSide && !axisInfo) {
+      continue;
+    }
+    lerp2.minCurrent = lerp2.minStart + (lerp2.minTarget - lerp2.minStart) * progress;
+    lerp2.maxCurrent = lerp2.maxStart + (lerp2.maxTarget - lerp2.maxStart) * progress;
+    const domain = [lerp2.minCurrent, lerp2.maxCurrent];
+    const range = isXSide && axisInfo ? axisInfo.scale.range() : valueScaleRange;
+    const scale = createLinearScale(domain, range);
+    if (isXSide) {
+      (animatedValueXScales ?? (animatedValueXScales = /* @__PURE__ */ new Map())).set(axisId, scale);
+    } else {
+      animatedValueScales.set(axisId, scale);
+      animatedValueDomains.set(axisId, domain);
+    }
+    if (axisInfo) {
+      const area = axisInfo.offset > 0 ? computeOffsetArea(cartesianArea, axisInfo.position, axisInfo.offset) : cartesianArea;
+      const newLayout = calculateAxisLayout(scale, axisInfo.position, area, axisInfo.props, axisInfo.extraTitleOffset, globalFont, locale);
+      const hasEntry = axisTransitionState ? (v) => axisTransitionState.hasTickEntry(axisLayoutKey, v) : void 0;
+      const mergedTicks = lerp2.tickFade && lerp2.tickFade.exiting.length > 0 ? mergeWithExitingTicks(newLayout.ticks, lerp2.tickFade.exiting, scale, axisInfo, area, hasEntry) : newLayout.ticks;
+      const mergedGridLines = newLayout.gridLines.length > 0 ? buildGridLinesForTicks(mergedTicks, axisInfo.position, area) : [];
+      const opacityTicks = axisTransitionState ? axisTransitionState.applyTicks(axisLayoutKey, mergedTicks) : mergedTicks;
+      const rotatedTicks = axisTransitionState ? applyRotationToTicks(opacityTicks, axisTransitionState, axisLayoutKey) : opacityTicks;
+      const opacityGridLines = mergedGridLines.map((line, i) => {
+        const tickOpacity = rotatedTicks[i]?.opacity;
+        return tickOpacity === void 0 ? line : { ...line, opacity: tickOpacity };
+      });
+      animatedAxisLayouts.set(axisLayoutKey, {
+        ...axisInfo,
+        layout: { ...newLayout, ticks: rotatedTicks, gridLines: opacityGridLines },
+        scale,
+        domain
+      });
+    }
+  }
+  return {
+    valueScales: animatedValueScales,
+    valueDomains: animatedValueDomains,
+    axisLayouts: animatedAxisLayouts,
+    valueXScales: animatedValueXScales
+  };
+}
+function mergeWithExitingTicks(currentTicks, exitingValues, intermediateScale, axisInfo, area, hasEntry) {
+  const template = currentTicks[0];
+  if (!template) return currentTicks;
+  const isHorizontal = axisInfo.position === "top" || axisInfo.position === "bottom";
+  const [rangeStart, rangeEnd] = intermediateScale.range();
+  const rangeMin = Math.min(rangeStart, rangeEnd);
+  const rangeMax = Math.max(rangeStart, rangeEnd);
+  const exitingTicks = [];
+  for (const value of exitingValues) {
+    if (hasEntry && !hasEntry(value)) continue;
+    const pos = intermediateScale(value);
+    if (!Number.isFinite(pos) || pos < rangeMin || pos > rangeMax) continue;
+    const rounded = Math.round(pos);
+    if (isHorizontal) {
+      exitingTicks.push({
+        ...template,
+        value,
+        rawValue: value,
+        label: String(value),
+        position: pos,
+        x1: pos,
+        x2: pos,
+        y1: template.y1,
+        y2: template.y2,
+        labelX: rounded,
+        labelY: template.labelY
+      });
+    } else {
+      exitingTicks.push({
+        ...template,
+        value,
+        rawValue: value,
+        label: String(value),
+        position: pos,
+        x1: template.x1,
+        x2: template.x2,
+        y1: pos,
+        y2: pos,
+        labelX: template.labelX,
+        labelY: rounded
+      });
+    }
+  }
+  return [...currentTicks, ...exitingTicks];
+}
+function applyRotationToTicks(ticks, axisTransitionState, axisId) {
+  let layoutAngle;
+  for (const t of ticks) {
+    if (typeof t.rotation === "number") {
+      layoutAngle = t.rotation;
+      break;
+    }
+  }
+  const interpolated = axisTransitionState.applyRotations(axisId, layoutAngle ?? 0);
+  if (layoutAngle === void 0 && interpolated === 0) return ticks;
+  return ticks.map((t) => ({ ...t, rotation: interpolated !== 0 ? interpolated : void 0 }));
+}
+function buildGridLinesForTicks(ticks, position, area) {
+  const isHorizontal = position === "top" || position === "bottom";
+  return ticks.map((t) => isHorizontal ? { x1: t.position, y1: area.y, x2: t.position, y2: area.y + area.height } : { x1: area.x, y1: t.position, x2: area.x + area.width, y2: t.position });
+}
+function snapDomainLerp(lerpStates) {
+  for (const [, lerp2] of lerpStates) {
+    lerp2.minCurrent = lerp2.minTarget;
+    lerp2.maxCurrent = lerp2.maxTarget;
+    lerp2.minStart = lerp2.minTarget;
+    lerp2.maxStart = lerp2.maxTarget;
+    lerp2.tickFade = void 0;
+  }
+}
+function initTimeDomainLerp(existing, target, options) {
+  const expansionStart = options?.expansionStart === true;
+  if (existing) {
+    const startMin = expansionStart ? Math.min(existing.minCurrent, target[0]) : existing.minCurrent;
+    const startMax = expansionStart ? Math.max(existing.maxCurrent, target[1]) : existing.maxCurrent;
+    return {
+      minStart: startMin,
+      maxStart: startMax,
+      minTarget: target[0],
+      maxTarget: target[1],
+      minCurrent: startMin,
+      maxCurrent: startMax
+    };
+  }
+  return {
+    minStart: target[0],
+    maxStart: target[1],
+    minTarget: target[0],
+    maxTarget: target[1],
+    minCurrent: target[0],
+    maxCurrent: target[1]
+  };
+}
+function advanceTimeDomainLerp(lerp2, progress, axisLayouts, cached) {
+  lerp2.minCurrent = lerp2.minStart + (lerp2.minTarget - lerp2.minStart) * progress;
+  lerp2.maxCurrent = lerp2.maxStart + (lerp2.maxTarget - lerp2.maxStart) * progress;
+  const domain = [lerp2.minCurrent, lerp2.maxCurrent];
+  const area = cached.cartesianArea;
+  const catRange = cached.orientation === "vertical" ? [area.x, area.x + area.width] : [area.y, area.y + area.height];
+  const axisDir = cached.orientation === "vertical" ? "x" : "y";
+  let gaplessFlag = false;
+  let gaplessPadStart = 0;
+  let gaplessPadEnd = 0;
+  for (const [, info] of axisLayouts) {
+    if (info.axis === axisDir && info.domain) {
+      const props = info.props;
+      if (props?.gapless) {
+        gaplessFlag = true;
+        gaplessPadStart = props.chartPaddingMin ?? 0;
+        gaplessPadEnd = props.chartPaddingMax ?? 0;
+      }
+      break;
+    }
+  }
+  let timeScale;
+  let categoryScale;
+  if (gaplessFlag && cached.timestamps.length > 0) {
+    const sortedUnique = [...new Set(cached.timestamps)].sort((a, b) => a - b);
+    timeScale = createOrdinalTimeScale(sortedUnique, catRange, { visibleDomain: domain, padStart: gaplessPadStart, padEnd: gaplessPadEnd });
+    categoryScale = createOrdinalTimeBandAdapter(sortedUnique, timeScale);
+  } else {
+    timeScale = createTimeScale(domain, catRange);
+    categoryScale = createTimeBandAdapter(cached.timestamps, timeScale);
+  }
+  const updated = new Map(axisLayouts);
+  for (const [key, info] of axisLayouts) {
+    if (info.axis === axisDir && info.domain) {
+      const remapped = interpolateCartesianAxisLayout(info, timeScale);
+      updated.set(key, { ...remapped, scale: timeScale, domain });
+    }
+  }
+  return { categoryScale, axisLayouts: updated };
+}
+function snapTimeDomainLerp(lerp2) {
+  lerp2.minCurrent = lerp2.minTarget;
+  lerp2.maxCurrent = lerp2.maxTarget;
+  lerp2.minStart = lerp2.minTarget;
+  lerp2.maxStart = lerp2.maxTarget;
+}
+function computeOffsetArea(area, position, offset) {
+  switch (position) {
+    case "left":
+      return { ...area, x: area.x - offset, width: area.width + offset };
+    case "right":
+      return { ...area, width: area.width + offset };
+    case "top":
+      return { ...area, y: area.y - offset, height: area.height + offset };
+    case "bottom":
+      return { ...area, height: area.height + offset };
+    default:
+      return area;
+  }
+}
+
+// src/animations/category-lerp.ts
+function initCategoryLerp(axisLayouts, orientation) {
+  const result = /* @__PURE__ */ new Map();
+  const isXAxis = orientation === "vertical";
+  for (const info of axisLayouts.values()) {
+    if (info.axis !== (isXAxis ? "x" : "y")) continue;
+    for (const tick of info.layout.ticks) {
+      result.set(tick.label, isXAxis ? tick.labelX : tick.labelY);
+    }
+  }
+  return result;
+}
+function advanceCategoryLerp(axisLayouts, prevPositions, progress, orientation) {
+  if (prevPositions.size === 0) return axisLayouts;
+  const isXAxis = orientation === "vertical";
+  const result = new Map(axisLayouts);
+  for (const [key, info] of result) {
+    if (info.axis !== (isXAxis ? "x" : "y")) continue;
+    result.set(key, { ...info, layout: interpolateCategoryAxisLayout(info.layout, prevPositions, progress, isXAxis) });
+  }
+  return result;
+}
+function snapCategoryLerp(state) {
+  state.clear();
+}
+function interpolateCategoryAxisLayout(layout, prevPositions, progress, isXAxis) {
+  const deltaByPos = /* @__PURE__ */ new Map();
+  const newTicks = layout.ticks.map((tick) => {
+    const prevPos = prevPositions.get(tick.label);
+    if (prevPos === void 0) return { ...tick, opacity: progress };
+    if (isXAxis) {
+      const animX = prevPos + (tick.labelX - prevPos) * progress;
+      const delta = animX - tick.labelX;
+      deltaByPos.set(Math.round(tick.x1), delta);
+      return { ...tick, labelX: animX, x1: tick.x1 + delta, x2: tick.x2 + delta };
+    } else {
+      const animY = prevPos + (tick.labelY - prevPos) * progress;
+      const delta = animY - tick.labelY;
+      deltaByPos.set(Math.round(tick.y1), delta);
+      return { ...tick, labelY: animY, y1: tick.y1 + delta, y2: tick.y2 + delta };
+    }
+  });
+  const newGridLines = layout.gridLines.map((gl) => {
+    const key = Math.round(isXAxis ? gl.x1 : gl.y1);
+    const delta = deltaByPos.get(key) ?? 0;
+    if (delta === 0) return gl;
+    return isXAxis ? { ...gl, x1: gl.x1 + delta, x2: gl.x2 + delta } : { ...gl, y1: gl.y1 + delta, y2: gl.y2 + delta };
+  });
+  return { ...layout, ticks: newTicks, gridLines: newGridLines };
+}
+
+// src/animations/canvas-compositor.ts
+var CanvasCompositor = class {
+  constructor() {
+    this._layers = /* @__PURE__ */ new Map();
+    this._sortedLayers = [];
+    this._sortDirty = false;
+    this._bgPainter = null;
+    this._fgPainter = null;
+  }
+  // -------------------------------------------------------------------------
+  // Layer registry
+  // -------------------------------------------------------------------------
+  /**
+   * Register a canvas paint layer (e.g., bar, line, scatter).
+   * Layers are painted in `order` between background and foreground.
+   * Safe to call multiple times — replaces previous layer with same id.
+   */
+  registerLayer(layer) {
+    this._layers.set(layer.id, layer);
+    this._sortDirty = true;
+  }
+  /** Remove a canvas paint layer by id. */
+  removeLayer(id) {
+    this._layers.delete(id);
+    this._sortDirty = true;
+  }
+  /**
+   * Remove all canvas paint layers whose id starts with the given prefix.
+   * Used for per-dataset cleanup (e.g., removeLayersByPrefix('bar:')).
+   */
+  removeLayersByPrefix(prefix) {
+    let removed = false;
+    for (const id of this._layers.keys()) {
+      if (id.startsWith(prefix)) {
+        this._layers.delete(id);
+        removed = true;
+      }
+    }
+    if (removed) this._sortDirty = true;
+  }
+  /** Check if a layer is registered. */
+  hasLayer(id) {
+    return this._layers.has(id);
+  }
+  /** Check if compositor has any layers registered. */
+  hasLayers() {
+    return this._layers.size > 0;
+  }
+  // -------------------------------------------------------------------------
+  // Background / foreground painters
+  // -------------------------------------------------------------------------
+  /** Set the background painter (grid, fills, beforeData references, zoom clip). */
+  setBackground(painter) {
+    this._bgPainter = painter;
+  }
+  /** Set the foreground painter (afterData references, axes, brackets, annotations). */
+  setForeground(painter) {
+    this._fgPainter = painter;
+  }
+  // -------------------------------------------------------------------------
+  // Composited repaint
+  // -------------------------------------------------------------------------
+  /**
+   * Repaint the entire canvas in correct z-order:
+   *  1. Clear
+   *  2. Background
+   *  3. Data layers sorted by order
+   *  4. Foreground
+   * All painting is synchronous within this call (no interleaved repaints).
+   */
+  repaint(ctx) {
+    const canvas = ctx.canvas;
+    ctx.clearRect(0, 0, canvas.width, canvas.height);
+    if (this._bgPainter) this._bgPainter(ctx);
+    if (this._sortDirty) {
+      this._sortedLayers = Array.from(this._layers.values()).sort((a, b) => a.order - b.order);
+      this._sortDirty = false;
+    }
+    for (let i = 0; i < this._sortedLayers.length; i++) {
+      if (this._layers.has(this._sortedLayers[i].id)) {
+        this._sortedLayers[i].paint(ctx);
+      }
+    }
+    if (this._fgPainter) this._fgPainter(ctx);
+  }
+};
+
+// src/animations/property-store.ts
+var AnimatedPropertyStore = class {
+  constructor() {
+    this.values = /* @__PURE__ */ new Map();
+  }
+  set(key, value) {
+    this.values.set(key, value);
+  }
+  get(key) {
+    return this.values.get(key);
+  }
+  /**
+   * Remove a single key. Called by `setupPropertyAnimations`' `onComplete`
+   * hook so a finished animation stops contributing an override value.
+   * Returns true if the key existed.
+   */
+  delete(key) {
+    return this.values.delete(key);
+  }
+  clear() {
+    this.values.clear();
+  }
+  destroy() {
+    this.clear();
+  }
+};
+
+export { AXIS_SETTLED_THRESHOLD, AXIS_SMOOTHING, AnimatedPropertyStore, AnimationRegistry, AxisTransitionState, CanvasCompositor, advanceCategoryLerp, advanceDomainLerp, advanceTimeDomainLerp, initCategoryLerp, initDomainLerp, initDomainLerpTickFade, initTimeDomainLerp, snapCategoryLerp, snapDomainLerp, snapTimeDomainLerp };