velo-plot 1.11.1

package/dist/core/animation/AnimationEngine.d.ts

@@ -0,0 +1,156 @@
+/**
+ * Animation Engine
+ *
+ * Provides smooth, performant animations for chart transitions
+ * including zoom, pan, data updates, and custom animations.
+ */
+export type EasingFunction = (t: number) => number;
+export declare const easings: {
+    /** Linear easing - constant speed */
+    readonly linear: (t: number) => number;
+    /** Ease in - starts slow, accelerates */
+    readonly easeIn: (t: number) => number;
+    /** Ease out - starts fast, decelerates */
+    readonly easeOut: (t: number) => number;
+    /** Ease in-out - slow start and end */
+    readonly easeInOut: (t: number) => number;
+    /** Cubic ease out - smoother deceleration */
+    readonly easeOutCubic: (t: number) => number;
+    /** Cubic ease in-out */
+    readonly easeInOutCubic: (t: number) => number;
+    /** Spring-like bounce at the end */
+    readonly spring: (t: number) => number;
+    /** Elastic overshoot */
+    readonly elastic: (t: number) => number;
+    /** Bounce effect */
+    readonly bounce: (t: number) => number;
+};
+export type EasingName = keyof typeof easings;
+export interface AnimationOptions {
+    /** Duration in milliseconds */
+    duration: number;
+    /** Easing function name or custom function */
+    easing?: EasingName | EasingFunction;
+    /** Callback on each frame with progress 0-1 */
+    onUpdate: (progress: number) => void;
+    /** Callback when animation completes */
+    onComplete?: () => void;
+    /** Callback if animation is cancelled */
+    onCancel?: () => void;
+}
+export interface AnimationHandle {
+    /** Unique animation ID */
+    id: string;
+    /** Cancel the animation */
+    cancel: () => void;
+    /** Promise that resolves when animation completes */
+    promise: Promise<void>;
+    /** Whether animation is currently running */
+    isRunning: () => boolean;
+}
+export interface BoundsAnimation {
+    /** Target X range [min, max] */
+    xRange?: [number, number];
+    /** Target Y range [min, max] */
+    yRange?: [number, number];
+    /** Duration in ms (default: 300) */
+    duration?: number;
+    /** Easing function (default: 'easeOutCubic') */
+    easing?: EasingName | EasingFunction;
+}
+export declare class AnimationEngine {
+    private animations;
+    private frameId;
+    private idCounter;
+    private isDestroyed;
+    /**
+     * Start a new animation
+     */
+    animate(options: AnimationOptions): AnimationHandle;
+    /**
+     * Animate numeric value interpolation
+     */
+    interpolate(from: number, to: number, options: Omit<AnimationOptions, 'onUpdate'> & {
+        onUpdate: (value: number) => void;
+    }): AnimationHandle;
+    /**
+     * Animate bounds transition
+     */
+    animateBounds(current: {
+        xMin: number;
+        xMax: number;
+        yMin: number;
+        yMax: number;
+    }, target: BoundsAnimation, onUpdate: (bounds: {
+        xMin: number;
+        xMax: number;
+        yMin: number;
+        yMax: number;
+    }) => void, onComplete?: () => void): AnimationHandle;
+    /**
+     * Cancel a specific animation
+     */
+    cancel(id: string): void;
+    /**
+     * Cancel all running animations
+     */
+    cancelAll(): void;
+    /**
+     * Check if any animations are running
+     */
+    isAnimating(): boolean;
+    /**
+     * Returns a promise that resolves when all current animations are complete
+     */
+    waitForIdle(): Promise<void>;
+    /**
+     * Get number of active animations
+     */
+    getActiveCount(): number;
+    /**
+     * Destroy the animation engine
+     */
+    destroy(): void;
+    private ensureLoop;
+    private tick;
+}
+export interface ChartAnimationConfig {
+    /** Enable all animations */
+    enabled: boolean;
+    /** Zoom animation settings */
+    zoom: {
+        enabled: boolean;
+        duration: number;
+        easing: EasingName;
+    };
+    /** Pan animation settings */
+    pan: {
+        enabled: boolean;
+        duration: number;
+        easing: EasingName;
+    };
+    /** Data update animation settings */
+    dataUpdate: {
+        enabled: boolean;
+        duration: number;
+        easing: EasingName;
+    };
+    /** Series entry animation */
+    seriesEntry: {
+        enabled: boolean;
+        duration: number;
+        easing: EasingName;
+    };
+    /** Auto-scale animation */
+    autoScale: {
+        enabled: boolean;
+        duration: number;
+        easing: EasingName;
+    };
+}
+export declare const DEFAULT_ANIMATION_CONFIG: ChartAnimationConfig;
+/**
+ * Merge user config with defaults
+ */
+export declare function mergeAnimationConfig(config?: Partial<ChartAnimationConfig>): ChartAnimationConfig;
+export declare function getSharedAnimationEngine(): AnimationEngine;

package/dist/core/animation/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Animation Module
+ *
+ * Exports animation utilities for smooth chart transitions.
+ */
+export { AnimationEngine, easings, DEFAULT_ANIMATION_CONFIG, mergeAnimationConfig, getSharedAnimationEngine, type AnimationOptions, type AnimationHandle, type BoundsAnimation, type ChartAnimationConfig, type EasingFunction, type EasingName, } from './AnimationEngine';

package/dist/core/annotations/AnnotationManager.d.ts

@@ -0,0 +1,61 @@
+import { Bounds } from '../../types';
+import { Annotation } from './types';
+
+export interface PlotArea {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export declare class AnnotationManager {
+    private annotations;
+    private idCounter;
+    /**
+     * Add a new annotation
+     * @returns The annotation ID
+     */
+    add(annotation: Annotation): string;
+    /**
+     * Remove an annotation by ID
+     */
+    remove(id: string): boolean;
+    /**
+     * Update an annotation
+     */
+    update(id: string, updates: Partial<Annotation>): void;
+    /**
+     * Get an annotation by ID
+     */
+    get(id: string): Annotation | undefined;
+    /**
+     * Get all annotations
+     */
+    getAll(): Annotation[];
+    /**
+     * Clear all annotations
+     */
+    clear(): void;
+    /**
+     * Get count of annotations
+     */
+    get count(): number;
+    /**
+     * Render all annotations
+     */
+    render(ctx: CanvasRenderingContext2D, plotArea: PlotArea, bounds: Bounds, latexAPI?: any): void;
+    /**
+     * Helper to draw text or LaTeX
+     */
+    private drawLatexOrText;
+    private renderAnnotation;
+    private dataToPixelX;
+    private dataToPixelY;
+    private renderHorizontalLine;
+    private renderVerticalLine;
+    private renderRectangle;
+    private renderBand;
+    private renderText;
+    private renderArrow;
+    private renderLineLabel;
+    private renderCenteredLabel;
+}

package/dist/core/annotations/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Annotations module exports
+ */
+export { AnnotationManager, type PlotArea } from './AnnotationManager';
+export type { Annotation, AnnotationType, BaseAnnotation, HorizontalLineAnnotation, VerticalLineAnnotation, RectangleAnnotation, BandAnnotation, TextAnnotation, ArrowAnnotation, AnnotationEvent, AnnotationDragEvent, } from './types';

package/dist/core/annotations/types.d.ts

@@ -0,0 +1,159 @@
+/**
+ * Annotation Types
+ *
+ * Type definitions for all annotation types supported by Sci Plot.
+ */
+export type AnnotationType = 'horizontal-line' | 'vertical-line' | 'rectangle' | 'band' | 'text' | 'arrow';
+export interface BaseAnnotation {
+    /** Unique identifier (auto-generated if not provided) */
+    id?: string;
+    /** Annotation type */
+    type: AnnotationType;
+    /** Visibility */
+    visible?: boolean;
+    /** Allow user interaction (dragging) */
+    interactive?: boolean;
+    /** Z-index for layering */
+    zIndex?: number;
+    /** Tooltip text or configuration */
+    tooltip?: string | any;
+    /** Use LaTeX rendering for labels/text (default: auto-detect) */
+    latex?: boolean;
+}
+export interface HorizontalLineAnnotation extends BaseAnnotation {
+    type: 'horizontal-line';
+    /** Y value in data coordinates */
+    y: number;
+    /** Optional: limit line extent to X range */
+    xMin?: number;
+    xMax?: number;
+    /** Line color (hex or rgba) */
+    color?: string;
+    /** Line width in pixels */
+    lineWidth?: number;
+    /** Dash pattern [dash, gap] - empty for solid */
+    lineDash?: number[];
+    /** Label text */
+    label?: string;
+    /** Label position along the line */
+    labelPosition?: 'left' | 'right' | 'center';
+    /** Label background color */
+    labelBackground?: string;
+}
+export interface VerticalLineAnnotation extends BaseAnnotation {
+    type: 'vertical-line';
+    /** X value in data coordinates */
+    x: number;
+    /** Optional: limit line extent to Y range */
+    yMin?: number;
+    yMax?: number;
+    /** Line color */
+    color?: string;
+    /** Line width in pixels */
+    lineWidth?: number;
+    /** Dash pattern */
+    lineDash?: number[];
+    /** Label text */
+    label?: string;
+    /** Label position */
+    labelPosition?: 'top' | 'bottom' | 'center';
+    /** Label background color */
+    labelBackground?: string;
+}
+export interface RectangleAnnotation extends BaseAnnotation {
+    type: 'rectangle';
+    /** Rectangle bounds in data coordinates */
+    xMin: number;
+    xMax: number;
+    yMin: number;
+    yMax: number;
+    /** Fill color (use alpha for transparency) */
+    fillColor?: string;
+    /** Border color */
+    strokeColor?: string;
+    /** Border width */
+    strokeWidth?: number;
+    /** Border dash pattern */
+    strokeDash?: number[];
+    /** Label text */
+    label?: string;
+}
+export interface BandAnnotation extends BaseAnnotation {
+    type: 'band';
+    /** Band bounds - vertical band if only x specified, horizontal if only y */
+    xMin?: number;
+    xMax?: number;
+    yMin?: number;
+    yMax?: number;
+    /** Fill color */
+    fillColor?: string;
+    /** Border color */
+    strokeColor?: string;
+    /** Border width */
+    strokeWidth?: number;
+    /** Label text */
+    label?: string;
+    /** Label position */
+    labelPosition?: 'center' | 'top' | 'bottom' | 'left' | 'right';
+}
+export interface TextAnnotation extends BaseAnnotation {
+    type: 'text';
+    /** Position in data coordinates */
+    x: number;
+    y: number;
+    /** Text content */
+    text: string;
+    /** Font size in pixels */
+    fontSize?: number;
+    /** Font family */
+    fontFamily?: string;
+    /** Font weight */
+    fontWeight?: 'normal' | 'bold';
+    /** Text color */
+    color?: string;
+    /** Background color */
+    backgroundColor?: string;
+    /** Background padding */
+    padding?: number;
+    /** Rotation in degrees */
+    rotation?: number;
+    /** Anchor point for positioning */
+    anchor?: 'center' | 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right' | 'top-center' | 'bottom-center' | 'left-center' | 'right-center';
+}
+export interface ArrowAnnotation extends BaseAnnotation {
+    type: 'arrow';
+    /** Start point in data coordinates */
+    x1: number;
+    y1: number;
+    /** End point (arrow head) in data coordinates */
+    x2: number;
+    y2: number;
+    /** Line color */
+    color?: string;
+    /** Line width */
+    lineWidth?: number;
+    /** Arrow head size in pixels */
+    headSize?: number;
+    /** Arrow head style */
+    headStyle?: 'filled' | 'open' | 'none';
+    /** Show tail arrow */
+    showTail?: boolean;
+    /** Label text */
+    label?: string;
+}
+export type Annotation = HorizontalLineAnnotation | VerticalLineAnnotation | RectangleAnnotation | BandAnnotation | TextAnnotation | ArrowAnnotation;
+export interface ResolvedAnnotation extends BaseAnnotation {
+    id: string;
+}
+export interface AnnotationEvent {
+    annotation: Annotation;
+    originalEvent?: MouseEvent;
+}
+export interface AnnotationDragEvent extends AnnotationEvent {
+    deltaX: number;
+    deltaY: number;
+    newPosition: {
+        x: number;
+        y: number;
+    };
+}

package/dist/core/chart/ChartAnimatedNavigation.d.ts

@@ -0,0 +1,53 @@
+import { Bounds, ZoomOptions, AxisOptions, ChartEventMap } from '../../types';
+import { Scale } from '../../scales';
+import { EventEmitter } from '../EventEmitter';
+import { AnimationEngine, ChartAnimationConfig, AnimationHandle } from '../animation';
+
+export interface AnimatedNavigationContext {
+    viewBounds: Bounds;
+    yScales: Map<string, Scale>;
+    yAxisOptionsMap: Map<string, AxisOptions>;
+    xAxisOptions: AxisOptions;
+    primaryYAxisId: string;
+    getPlotArea: () => {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    events: EventEmitter<ChartEventMap>;
+    requestRender: () => void;
+    series: Map<string, {
+        isVisible(): boolean;
+        getBounds(): Bounds | null;
+        getYAxisId(): string | undefined;
+        getType(): string;
+    }>;
+    animationEngine: AnimationEngine;
+    animationConfig: ChartAnimationConfig;
+}
+/**
+ * Apply animated zoom to the chart
+ */
+export declare function applyAnimatedZoom(ctx: AnimatedNavigationContext, options: ZoomOptions & {
+    animate?: boolean;
+}): AnimationHandle | null;
+/**
+ * Apply animated auto-scale to fit all data
+ */
+export declare function applyAnimatedAutoScale(ctx: AnimatedNavigationContext, animate?: boolean): AnimationHandle | null;
+/**
+ * Animate to specific bounds
+ */
+export declare function animateToBounds(ctx: AnimatedNavigationContext, targetBounds: Partial<Bounds>, options?: {
+    duration?: number;
+    easing?: string;
+}): AnimationHandle;
+/**
+ * Check if any navigation animation is running
+ */
+export declare function isNavigationAnimating(): boolean;
+/**
+ * Cancel all navigation animations
+ */
+export declare function cancelNavigationAnimations(): void;

package/dist/core/chart/ChartAxisManager.d.ts

@@ -0,0 +1,61 @@
+import { Scale } from '../../scales';
+import { AxisOptions } from '../../types';
+import { Series } from '../Series';
+
+export interface AxisManagerContext {
+    xAxisOptions: AxisOptions;
+    xScale: Scale;
+    yAxisOptionsMap: Map<string, AxisOptions>;
+    yScales: Map<string, Scale>;
+    primaryYAxisId: string;
+    series: Map<string, Series>;
+    requestRender: () => void;
+}
+export declare class ChartAxisManager {
+    private ctx;
+    constructor(ctx: AxisManagerContext);
+    /**
+     * Add a new Y axis dynamically
+     */
+    addYAxis(options: AxisOptions): string;
+    /**
+     * Remove a Y axis by ID
+     */
+    removeYAxis(id: string): boolean;
+    /**
+     * Update Y axis configuration
+     */
+    updateYAxis(id: string, options: Partial<AxisOptions>): void;
+    /**
+     * Update X axis configuration
+     */
+    updateXAxis(options: Partial<AxisOptions>): void;
+    /**
+     * Get Y axis configuration by ID
+     */
+    getYAxis(id: string): AxisOptions | undefined;
+    /**
+     * Get all Y axes configurations
+     */
+    getAllYAxes(): AxisOptions[];
+    /**
+     * Get the primary Y axis ID
+     */
+    getPrimaryYAxisId(): string;
+    /**
+     * Get X axis configuration
+     */
+    getXAxis(): AxisOptions;
+    /**
+     * Get X scale
+     */
+    getXScale(): Scale;
+    /**
+     * Get Y scale by axis ID
+     */
+    getYScale(axisId?: string): Scale | undefined;
+    /**
+     * Get all Y scales
+     */
+    getAllYScales(): Map<string, Scale>;
+}