@primeui/chart-core 0.0.1-alpha.1

package/dist/property-animations-D433wXzz.d.mts

@@ -0,0 +1,580 @@
+import { EasingFunction, AnimatableBar, AxisOpacity, AxisLayoutInfo as AxisLayoutInfo$1, ComputedTick, AnimationRegistryLike, AnimationEntryConfig, AnimationSnapshot, BoxArea, ZoomTransform, HeatmapRenderData, CandlestickRenderData, LineRenderData, LineUpdateKind, AnimatedElementLike, AnimatableRegistry, PerGroupOptions, CanvasCompositorLike, CanvasLayer, CanvasPainter, NamedAnimationSpec, PropertyAnimationConfig, AnimatedPropertyStoreLike } from '@primeui/chart-types';
+import { LinearScale, BandScale } from '@primeui/chart-types/axes';
+import { AxisLayoutInfo } from '@primeui/chart-types/layout';
+import { PolarRenderData } from '@primeui/chart-types/polar';
+import { RadarRenderData, RadialGridConfig } from '@primeui/chart-types/radar';
+
+/** Linear - no acceleration */
+declare const linear: EasingFunction;
+/** Ease out quad - light deceleration */
+declare const easeOutQuad: EasingFunction;
+/** Ease out cubic - moderate deceleration */
+declare const easeOutCubic: EasingFunction;
+/** Ease out quart - strong deceleration */
+declare const easeOutQuart: EasingFunction;
+/** Ease out quint - very strong deceleration */
+declare const easeOutQuint: EasingFunction;
+/** Ease out expo - exponential deceleration */
+declare const easeOutExpo: EasingFunction;
+/** Ease in out cubic - acceleration then deceleration */
+declare const easeInOutCubic: EasingFunction;
+/** Ease in out quart */
+declare const easeInOutQuart: EasingFunction;
+/**
+ * Ease out back - subtle overshoot then settle
+ */
+declare const easeOutBack: EasingFunction;
+/**
+ * Ease out elastic - spring/bounce effect
+ */
+declare const easeOutElastic: EasingFunction;
+/**
+ * Ease out bounce - ball-drop bounce effect
+ */
+declare const easeOutBounce: EasingFunction;
+/**
+ * Ease in bounce
+ */
+declare const easeInBounce: EasingFunction;
+/**
+ * Ease in out bounce
+ */
+declare const easeInOutBounce: EasingFunction;
+/**
+ * Register a custom easing function
+ * @param name - Unique name for the easing
+ * @param fn - Easing function
+ */
+declare function registerEasing(name: string, fn: EasingFunction): void;
+/**
+ * Get easing function by name
+ * @param name - Easing function name
+ * @returns Easing function (defaults to easeOutQuart if not found)
+ */
+declare function getEasing(name: string): EasingFunction;
+/**
+ * Check if easing exists
+ */
+declare function hasEasing(name: string): boolean;
+/**
+ * Get all registered easing names
+ */
+declare function getEasingNames(): string[];
+/**
+ * Convenience object for accessing all built-in easings
+ */
+declare const easings: {
+    readonly linear: EasingFunction;
+    readonly easeOutQuad: EasingFunction;
+    readonly easeOutCubic: EasingFunction;
+    readonly easeOutQuart: EasingFunction;
+    readonly easeOutQuint: EasingFunction;
+    readonly easeOutExpo: EasingFunction;
+    readonly easeInOutCubic: EasingFunction;
+    readonly easeInOutQuart: EasingFunction;
+    readonly easeOutBack: EasingFunction;
+    readonly easeOutElastic: EasingFunction;
+    readonly easeOutBounce: EasingFunction;
+    readonly easeInBounce: EasingFunction;
+    readonly easeInOutBounce: EasingFunction;
+};
+
+/**
+ * Linear interpolation between two values
+ * @param start - Starting value
+ * @param end - Ending value
+ * @param t - Progress (0-1)
+ */
+declare function lerp(start: number, end: number, t: number): number;
+/**
+ * Element-wise linear interpolation between two number arrays.
+ *
+ * Handles mismatched lengths by defaulting missing elements to the other side
+ * (or 0 if both are missing). Used by value-series controllers for snapshot-
+ * and-lerp animations (interrupt-safe: reconcile captures the lerped snapshot
+ * and writes it back as the new start).
+ */
+declare function lerpValues(start: number[], target: number[], progress: number): number[];
+/**
+ * Interpolate between two colors.
+ * Uses the shared parseColorToRGB from color.utils (single canvas singleton).
+ *
+ * @param startColor - Starting color (hex or CSS color)
+ * @param endColor - Ending color (hex or CSS color)
+ * @param t - Progress (0-1)
+ * @returns Hex color string
+ */
+declare function lerpColor(startColor: string, endColor: string, t: number): string;
+/**
+ * Interpolate the radial grid between two domain states.
+ *
+ * Keeps the TARGET's tick VALUES fixed (so the count and labels stay stable —
+ * no per-frame re-nicing) and only slides their RADII through the interpolated
+ * domain. The rings glide continuously from their previous-scale positions to
+ * the target ones — a smooth zoom. The target tick set is domain-aligned
+ * (largest tick maps to the domain max), so the outer perimeter stays pinned at
+ * `radius` at rest; mid-flight radii are clamped to `[0, radius]`.
+ */
+declare function interpolateRadialGrid(prevDomain: [number, number], targetDomain: [number, number], target: RadialGridConfig, radius: number, progress: number): RadialGridConfig;
+/**
+ * Re-map a settled axis layout's tick positions through an intermediate scale,
+ * without regenerating the tick set. Used during time-domain lerps to preserve
+ * tick stability — the label set is frozen at the settled state; only pixel
+ * positions tween between frames.
+ *
+ * Mirrors `interpolateRadialGrid` above: the tick VALUES and LABELS stay fixed
+ * (no per-frame re-nicing, no formatter re-runs, no density/collision/rotation
+ * cascade), only their pixel positions slide through the interpolated scale.
+ *
+ * Ticks whose `rawValue` falls outside the intermediate scale's pixel range are
+ * filtered out (they would render outside the plot area). Ticks without a
+ * `rawValue` (band/categorical) pass through unchanged — they have no numeric
+ * value to re-map.
+ *
+ * @param settledLayout - the axis layout produced at the timed animation's settled state
+ * @param intermediateScale - the scale at the current lerp frame (interpolated from prev to current)
+ * @returns an AxisLayoutInfo with the same ticks + labels, at new pixel positions
+ */
+declare function interpolateCartesianAxisLayout(settledLayout: AxisLayoutInfo, intermediateScale: LinearScale | BandScale): AxisLayoutInfo;
+/**
+ * Create a "zero" radar layout for entrance animation — all points at center.
+ */
+declare function createRadarEntranceLayout(target: RadarRenderData): RadarRenderData;
+/**
+ * Interpolate polar layout between two states (entrance or update animation).
+ * Matches bars by dataKey (from keyField) when available, otherwise by datasetId + category label.
+ */
+declare function interpolatePolarLayout(prev: PolarRenderData, target: PolarRenderData, progress: number): PolarRenderData;
+/**
+ * Create a "zero" polar layout for entrance animation — all bars have zero height.
+ */
+declare function createPolarEntranceLayout(target: PolarRenderData): PolarRenderData;
+
+/**
+ * Convert an AnimatableBar to the format expected by bar renderers (ComputedBar).
+ */
+declare function animatableBarToComputedBar(bar: AnimatableBar): {
+    dataIndex: number;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    value: number;
+    category: string;
+    visible: boolean;
+    isNegative: boolean;
+};
+
+/**
+ * Exponential decay factor for axis opacity tweens.
+ *
+ * Tuned for 1 tick per frame (Step 9). Each tick advances opacity by
+ * `current += (target - current) * AXIS_SMOOTHING`.
+ *
+ * Visual fade speed equivalence:
+ *   1 tick at 0.225 ≈ 2 ticks at 0.12 (pre-Step-9 double-tick regime)
+ *
+ * Derivation: `(1 - 0.12)² = 0.7744` per frame → `1 - 0.7744 = 0.2256`,
+ * rounded to 0.225 for clean numerics. See Step 9 plan for context.
+ */
+declare const AXIS_SMOOTHING = 0.225;
+/** Below this threshold, opacity is considered fully settled */
+declare const AXIS_SETTLED_THRESHOLD = 0.005;
+/**
+ * Manages smooth opacity transitions for axis show/hide.
+ *
+ * One plain {current, target} value per axis key. When an axis becomes hidden,
+ * opacity decays toward 0; when visible, toward 1.
+ *
+ * During fade-out (opacity > threshold but axis hidden), the visibleLayout
+ * is swapped in so ticks/line remain visible while fading.
+ *
+ * Framework wrappers hold this as a ref and delegate directly.
+ */
+declare class AxisTransitionState {
+    readonly opacities: Map<string, AxisOpacity>;
+    /**
+     * 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.
+     */
+    readonly tickOpacities: Map<string, Map<string | number, AxisOpacity>>;
+    /**
+     * 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`.
+     */
+    readonly rotations: Map<string, AxisOpacity>;
+    /**
+     * Set opacity targets from axis layout isHidden flags.
+     * Call this whenever layoutData changes.
+     */
+    setTargets(axisLayouts: Map<string, AxisLayoutInfo$1>): void;
+    /**
+     * 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(): boolean;
+    /**
+     * 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: Map<string, AxisLayoutInfo$1>): Map<string, AxisLayoutInfo$1>;
+    /**
+     * 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: string, ticks: {
+        value: number | string;
+        isEntering: boolean;
+        isExiting: boolean;
+    }[]): void;
+    /**
+     * 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: string, ticks: ComputedTick[]): ComputedTick[];
+    /**
+     * 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: string, value: number | string): boolean;
+    /**
+     * 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: string, targetAngle: number, currentAngle?: number): void;
+    /**
+     * 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: string, fallback: number): number;
+}
+
+declare class AnimationRegistry implements AnimationRegistryLike {
+    private entries;
+    private rafId;
+    private onRepaint;
+    private ticking;
+    /** True when the scheduler calls tick synchronously (detected on first raf call). Tests only. */
+    private _isSyncScheduler;
+    /** Set to true just before calling raf(); if tick fires while this is true, scheduler is sync. */
+    private _detectingSync;
+    /**
+     * Set the repaint callback. Called after all entries are ticked each frame.
+     * Typically triggers a full canvas clear + redraw.
+     */
+    setRepaintCallback(callback: () => void): void;
+    /**
+     * Register a new animation. If an animation with the same ID exists,
+     * it is replaced (restarted). Returns an unregister function.
+     */
+    register(config: AnimationEntryConfig): () => void;
+    /**
+     * Unregister an animation by ID.
+     */
+    unregister(id: string): void;
+    /**
+     * Check if an animation with the given ID is active.
+     */
+    has(id: string): boolean;
+    /**
+     * Get the current interpolated value for an animation.
+     * Returns undefined if the animation is not registered.
+     */
+    getValue(id: string): number | undefined;
+    /**
+     * Get snapshots of all active animations.
+     */
+    getSnapshots(): AnimationSnapshot[];
+    /**
+     * Number of active animations.
+     */
+    get size(): number;
+    /**
+     * Stop all animations and cancel the RAF loop.
+     */
+    clear(): void;
+    /**
+     * Full cleanup — clear all animations and remove the repaint callback.
+     */
+    destroy(): void;
+    /**
+     * 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.
+     */
+    private boundTick;
+    private ensureLoop;
+    private stopLoop;
+}
+
+/**
+ * Compute a 2D transform that interpolates content from one rect to another.
+ *
+ * The content is laid out in `target` coordinates. At progress=0 it appears
+ * squeezed into `origin`; at progress=1 it fills `target` at identity scale.
+ *
+ * @param origin  - The starting rect (e.g. clicked cell bounds)
+ * @param target  - The destination rect (e.g. full chart area)
+ * @param progress - Animation progress 0→1
+ */
+declare function computeZoomTransform(origin: BoxArea, target: BoxArea, progress: number): ZoomTransform;
+/**
+ * Compute a centered shrink rect for drill-out animation.
+ * Returns a rect inset by `ratio` from each side of the given area.
+ *
+ * @param area  - The chart area to shrink from
+ * @param ratio - How much to shrink (0.25 = 25% inset from each side → 50% size)
+ */
+declare function computeDrillOutOrigin(area: BoxArea, ratio?: number): BoxArea;
+
+/**
+ * Build a stable fingerprint of the heatmap layouts (non-empty cells, keyed by
+ * xLabel|yLabel:value) so the controller can detect data changes between updates.
+ */
+declare function buildHeatmapFingerprint(layouts: Map<string, HeatmapRenderData>): string;
+
+/**
+ * Build a fingerprint string from candlestick layouts for phase detection.
+ * Trades precision for speed — see spec Risks for the known limitation
+ * (a middle-candle OHLC change with stable count / edges / y-extremes won't fire).
+ */
+declare function buildCandlestickFingerprint(layouts: Map<string, CandlestickRenderData>): string;
+
+/**
+ * Detect the type of data change for a single series.
+ *
+ * - `'append'`: one new point added at the end, existing values unchanged
+ * - `'scroll'`: rolling shift — same length, values shifted by one position
+ * - `'update'`: general value change (needs full value lerp)
+ *
+ * Used to choose the right animation strategy:
+ * - append → extend clip path to reveal new point
+ * - scroll → tip-extension + time-domain lerp together
+ * - update → per-point value interpolation
+ */
+declare function detectLineUpdateKind(startVals: number[] | undefined, targetVals: number[]): LineUpdateKind;
+/**
+ * Build a fingerprint from line layouts for animation phase detection.
+ * Includes dataset IDs + point values to detect data changes.
+ *
+ * Used by the orchestrator's `detect(fingerprint)` to classify:
+ * same fingerprint → static (skip animation), different → update.
+ */
+declare function buildLineFingerprint(layouts: Map<string, LineRenderData>): string;
+
+type Phase = 'idle' | 'enter' | 'update' | 'exit';
+declare class AnimatedElement<T> implements AnimatedElementLike<T> {
+    readonly id: string;
+    current: T;
+    target: T;
+    phase: Phase;
+    private readonly tweens;
+    private readonly overrides;
+    private readonly registry;
+    /** Most recent PerGroupOptions — retained so releaseOverride can restart tweens. */
+    private _lastOpts;
+    /** Set to true when exit() completes, signalling scene to remove this element. */
+    private _readyForRemoval;
+    constructor(id: string, initial: T, registry: AnimatableRegistry);
+    /**
+     * Target-write path. For each changed field in newTarget:
+     *   - if overridden: target is updated but no tween starts
+     *   - otherwise: tween captures current[field] as start, animates over the group's duration
+     */
+    setTarget(newTarget: Partial<T>, opts: PerGroupOptions): void;
+    /** Direct-write path for explicit looping animations. */
+    overrideCurrent<K extends keyof T>(prop: K, value: T[K]): void;
+    /** Release the override; tween (if any) resumes toward latest target. */
+    releaseOverride<K extends keyof T>(prop: K): void;
+    /** Enter animation: emptyState → target. */
+    enter(target: T, emptyState: T, opts: PerGroupOptions): void;
+    /** Exit animation: current → emptyState. After tick completes, marks ready for removal. */
+    exit(emptyState: T, opts: PerGroupOptions): void;
+    /** Advance one frame. Returns true if any property is still tweening. */
+    tick(now: number): boolean;
+    /** True if exit() has completed and this element should be removed from the scene. */
+    isReadyForRemoval(): boolean;
+    /**
+     * Cancel an in-progress exit. Called by AnimatedScene when an exit-phase element
+     * reappears in targets (e.g. quick legend toggle off → on).
+     */
+    resurrect(): void;
+    private _groupOptsFor;
+}
+
+interface AnimatedSceneOptions<T> {
+    emptyState: (target: T) => T;
+    /**
+     * Optional separate state used for exit animations. When provided, exiting elements
+     * animate toward this state instead of `emptyState`. Useful when enter and exit
+     * should behave differently — e.g. pie slices enter from the chart start angle but
+     * exit by shrinking to zero span at their own position.
+     */
+    exitEmptyState?: (target: T) => T;
+    registry: AnimatableRegistry;
+    /** Default: true. When OS sets prefers-reduced-motion, snap to target instead of tweening. */
+    respectReducedMotion?: boolean;
+}
+declare class AnimatedScene<T> {
+    private readonly elements;
+    private readonly activeElements;
+    private readonly emptyState;
+    private readonly exitEmptyState;
+    private readonly registry;
+    private readonly reducedMotion;
+    constructor(opts: AnimatedSceneOptions<T>);
+    /**
+     * D3-style data join. For each id in `targets`:
+     *   - not in scene → create element, enter from emptyState
+     *   - already in scene → setTarget (interrupts any in-flight tween)
+     * For each id in scene but not in targets:
+     *   - exit toward emptyState; pruned by tick() after completion
+     */
+    diff(targets: Map<string, T>, opts: PerGroupOptions): void;
+    /**
+     * Advance all active elements one frame. Auto-removes elements whose
+     * exit animation has completed.
+     */
+    tick(now: number): {
+        allIdle: boolean;
+    };
+    getElements(): ReadonlyArray<AnimatedElement<T>>;
+    getElement(id: string): AnimatedElement<T> | undefined;
+    /** Clear all elements. Used by StrictMode reset / unmount. */
+    reset(): void;
+    private _zeroDurationOpts;
+}
+
+declare class CanvasCompositor implements CanvasCompositorLike {
+    private _layers;
+    private _sortedLayers;
+    private _sortDirty;
+    private _bgPainter;
+    private _fgPainter;
+    /**
+     * 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: CanvasLayer): void;
+    /** Remove a canvas paint layer by id. */
+    removeLayer(id: string): void;
+    /**
+     * Remove all canvas paint layers whose id starts with the given prefix.
+     * Used for per-dataset cleanup (e.g., removeLayersByPrefix('bar:')).
+     */
+    removeLayersByPrefix(prefix: string): void;
+    /** Check if a layer is registered. */
+    hasLayer(id: string): boolean;
+    /** Check if compositor has any layers registered. */
+    hasLayers(): boolean;
+    /** Set the background painter (grid, fills, beforeData references, zoom clip). */
+    setBackground(painter: CanvasPainter | null): void;
+    /** Set the foreground painter (afterData references, axes, brackets, annotations). */
+    setForeground(painter: CanvasPainter | null): void;
+    /**
+     * 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: CanvasRenderingContext2D): void;
+}
+
+interface FrameSchedulerAPI {
+    raf(callback: FrameRequestCallback): number;
+    cancelRaf(id: number): void;
+}
+/**
+ * Override the RAF scheduler.
+ * Call this to inject a no-op for SSR, a synchronous scheduler for tests,
+ * or a priority-aware scheduler for framework integration.
+ *
+ * @example
+ * // SSR / Node: no-op animations
+ * setFrameScheduler({ raf: () => 0, cancelRaf: () => {} });
+ *
+ * // Tests: synchronous, deterministic frames
+ * setFrameScheduler({ raf: (cb) => { cb(0); return 0; }, cancelRaf: () => {} });
+ *
+ * // Reset to browser default
+ * setFrameScheduler(null);
+ */
+declare function setFrameScheduler(api: FrameSchedulerAPI | null): void;
+
+declare const LINE_ANIMATABLE_PROPS: AnimatableRegistry;
+declare const BAR_ANIMATABLE_PROPS: AnimatableRegistry;
+declare function setupPropertyAnimations(configs: PropertyAnimationConfig[], registry: AnimationRegistry, store: AnimatedPropertyStoreLike, 
+/**
+ * Called when a non-looping property animation completes. The store entry
+ * is already deleted before this fires. Framework wrappers use this to
+ * trigger `renderFrameCycle()` on each controller, restoring base SVG
+ * attribute values that drifted during in-place property patching.
+ */
+onPropertyComplete?: (storeKey: string) => void): () => void;
+declare function resolveAnimatedProps(store: AnimatedPropertyStoreLike, chartType: string, datasetId: string, registry: AnimatableRegistry | readonly string[]): Record<string, number>;
+/**
+ * Flatten the public `animations: { name: { properties: [...], ... } }` map shape
+ * into the existing internal `PropertyAnimationConfig[]` array.
+ *
+ * Each entry in `properties` produces one config row, sharing the entry's
+ * timing/from/to/loop/alternate/easing/delay values.
+ *
+ * `scope` attaches `datasetId` (for per-dataset entries) or `chartType` (when
+ * the caller wants to scope a chart-level entry to a chart kind, though
+ * Phase 1a does not use the chartType path).
+ */
+declare function normalizeAnimationsMap(map: Record<string, NamedAnimationSpec> | undefined, scope?: {
+    datasetId?: string;
+    chartType?: 'line' | 'bar';
+}): PropertyAnimationConfig[];
+
+export { AXIS_SETTLED_THRESHOLD as A, BAR_ANIMATABLE_PROPS as B, CanvasCompositor as C, easings as D, getEasing as E, type FrameSchedulerAPI as F, getEasingNames as G, hasEasing as H, interpolateCartesianAxisLayout as I, interpolatePolarLayout as J, interpolateRadialGrid as K, LINE_ANIMATABLE_PROPS as L, lerp as M, lerpColor as N, lerpValues as O, linear as P, normalizeAnimationsMap as Q, registerEasing as R, resolveAnimatedProps as S, setFrameScheduler as T, setupPropertyAnimations as U, AXIS_SMOOTHING as a, AnimatedElement as b, AnimatedScene as c, AnimationRegistry as d, AxisTransitionState as e, animatableBarToComputedBar as f, buildCandlestickFingerprint as g, buildHeatmapFingerprint as h, buildLineFingerprint as i, computeDrillOutOrigin as j, computeZoomTransform as k, createPolarEntranceLayout as l, createRadarEntranceLayout as m, detectLineUpdateKind as n, easeInBounce as o, easeInOutBounce as p, easeInOutCubic as q, easeInOutQuart as r, easeOutBack as s, easeOutBounce as t, easeOutCubic as u, easeOutElastic as v, easeOutExpo as w, easeOutQuad as x, easeOutQuart as y, easeOutQuint as z };

package/dist/property-store-NORUWFND.d.mts

@@ -0,0 +1,17 @@
+import { AnimatedPropertyStoreLike } from '@primeui/chart-types';
+
+declare class AnimatedPropertyStore implements AnimatedPropertyStoreLike {
+    private values;
+    set(key: string, value: number): void;
+    get(key: string): number | undefined;
+    /**
+     * 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: string): boolean;
+    clear(): void;
+    destroy(): void;
+}
+
+export { AnimatedPropertyStore as A };

package/dist/radial/index.d.mts

@@ -0,0 +1,14 @@
+import { PolarBarData, Point, DataLabelConfig, ResolvedLabel, RadarPoint } from '@primeui/chart-types';
+
+/**
+ * Resolve data labels for polar bar segments.
+ * Labels are positioned radially outward from the bar's outer edge at its mid-angle.
+ */
+declare function resolvePolarLabels(bars: PolarBarData[], datasetTotal: number, center: Point, config: DataLabelConfig, data?: unknown[]): ResolvedLabel[];
+/**
+ * Resolve data labels for radar vertex points.
+ * Labels are positioned slightly outward from each data point along the spoke direction.
+ */
+declare function resolveRadarLabels(points: RadarPoint[], categories: string[], seriesColor: string, datasetTotal: number, center: Point, config: DataLabelConfig, data?: unknown[]): ResolvedLabel[];
+
+export { resolvePolarLabels, resolveRadarLabels };

package/dist/radial/index.mjs

@@ -0,0 +1,37 @@
+import '../chunk-WS64BZXT.mjs';
+export { resolvePolarLabels, resolveRadarLabels } from '../chunk-UPRXABX5.mjs';
+import '../chunk-66T4MRC5.mjs';
+import '../chunk-7QQ6ETB4.mjs';
+import '../chunk-X7T34OLW.mjs';
+import '../chunk-SALTGZFR.mjs';
+import '../chunk-AUF4CHDP.mjs';
+import '../chunk-VGLSBZDN.mjs';
+import '../chunk-ZT2Z7ERM.mjs';
+import '../chunk-KP2TWD4Z.mjs';
+import '../chunk-3WEMHXZI.mjs';
+import '../chunk-KVDEROP6.mjs';
+import '../chunk-YBJ56XJS.mjs';
+import '../chunk-NPDZLYIF.mjs';
+import '../chunk-EDAKJLNA.mjs';
+import '../chunk-JWFBOPM6.mjs';
+import '../chunk-5JCI2DEB.mjs';
+import '../chunk-BZN2QHGP.mjs';
+import '../chunk-OGJ6IIBW.mjs';
+import '../chunk-ARRGOEFX.mjs';
+import '../chunk-22ST6YPP.mjs';
+import '../chunk-FFMT6OCO.mjs';
+import '../chunk-7CMVDIOU.mjs';
+import '../chunk-ADKLH73T.mjs';
+import '../chunk-OXTFAWSK.mjs';
+import '../chunk-R6Y3R7EW.mjs';
+import '../chunk-XTVE4P3L.mjs';
+import '../chunk-NKUYIWAP.mjs';
+import '../chunk-OWW3K55O.mjs';
+import '../chunk-WA3OVISZ.mjs';
+import '../chunk-C36VWQ7A.mjs';
+import '../chunk-BETFQBM2.mjs';
+import '../chunk-WRULPWHD.mjs';
+import '../chunk-QS76E3TD.mjs';
+import '../chunk-O2X6FF45.mjs';
+import '../chunk-SSLTFJ3U.mjs';
+import '../chunk-RQ3CKQOX.mjs';