scichart-engine 1.0.1 → 1.1.2

package/dist/analysis/fft.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Fast Fourier Transform (FFT) Implementation
+ *
+ * Provides:
+ * - FFT for spectral analysis
+ * - Inverse FFT
+ * - Power spectrum
+ * - Frequency bins calculation
+ */
+/** Complex number representation */
+export interface Complex {
+    re: number;
+    im: number;
+}
+/** FFT Result */
+export interface FFTResult {
+    /** Frequency bins in Hz (if sample rate provided) or normalized */
+    frequency: Float32Array;
+    /** Magnitude spectrum */
+    magnitude: Float32Array;
+    /** Phase spectrum in radians */
+    phase: Float32Array;
+    /** Full complex spectrum */
+    complex: Complex[];
+}
+/** Power spectrum result */
+export interface PowerSpectrumResult {
+    /** Frequency bins */
+    frequency: Float32Array;
+    /** Power values (magnitude squared) */
+    power: Float32Array;
+    /** Power in dB */
+    powerDb: Float32Array;
+}
+/**
+ * Compute FFT using Cooley-Tukey algorithm
+ * Input length must be a power of 2
+ */
+export declare function fft(input: Float32Array | Float64Array | number[]): Complex[];
+/**
+ * Compute inverse FFT
+ */
+export declare function ifft(spectrum: Complex[]): Float32Array;
+/**
+ * Find next power of 2
+ */
+export declare function nextPowerOf2(n: number): number;
+/**
+ * Compute full FFT analysis with frequencies and magnitudes
+ */
+export declare function analyzeSpectrum(data: Float32Array | Float64Array | number[], sampleRate?: number): FFTResult;
+/**
+ * Compute power spectrum
+ */
+export declare function powerSpectrum(data: Float32Array | Float64Array | number[], sampleRate?: number): PowerSpectrumResult;
+/**
+ * Find dominant frequency in signal
+ */
+export declare function dominantFrequency(data: Float32Array | Float64Array | number[], sampleRate?: number, minFrequency?: number): {
+    frequency: number;
+    magnitude: number;
+};
+/**
+ * Apply Hanning window to data
+ */
+export declare function hanningWindow(data: Float32Array | Float64Array): Float32Array;
+/**
+ * Apply Hamming window to data
+ */
+export declare function hammingWindow(data: Float32Array | Float64Array): Float32Array;
+/**
+ * Apply Blackman window to data
+ */
+export declare function blackmanWindow(data: Float32Array | Float64Array): Float32Array;

package/dist/analysis/filters.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Digital Filters Implementation
+ *
+ * Provides:
+ * - Low-pass filter
+ * - High-pass filter
+ * - Band-pass filter
+ * - Band-stop (notch) filter
+ * - Butterworth filter
+ * - Moving average (for smoothing)
+ * - Savitzky-Golay filter
+ */
+export type FilterType = 'lowpass' | 'highpass' | 'bandpass' | 'bandstop';
+export interface FilterOptions {
+    /** Cutoff frequency in Hz (or normalized 0-1) */
+    cutoff: number;
+    /** Second cutoff for bandpass/bandstop filters */
+    cutoffHigh?: number;
+    /** Sample rate in Hz (default: 1.0 for normalized) */
+    sampleRate?: number;
+    /** Filter order (default: 2) */
+    order?: number;
+}
+export interface ButterworthOptions extends FilterOptions {
+    /** Filter type */
+    type: FilterType;
+}
+/**
+ * Apply a simple low-pass FIR filter
+ */
+export declare function lowPassFilter(data: Float32Array | Float64Array, cutoffHz: number, sampleRate: number, order?: number): Float32Array;
+/**
+ * Apply a simple high-pass FIR filter
+ */
+export declare function highPassFilter(data: Float32Array | Float64Array, cutoffHz: number, sampleRate: number, order?: number): Float32Array;
+/**
+ * Apply a band-pass FIR filter
+ */
+export declare function bandPassFilter(data: Float32Array | Float64Array, lowCutoffHz: number, highCutoffHz: number, sampleRate: number, order?: number): Float32Array;
+/**
+ * Apply a band-stop (notch) FIR filter
+ */
+export declare function bandStopFilter(data: Float32Array | Float64Array, lowCutoffHz: number, highCutoffHz: number, sampleRate: number, order?: number): Float32Array;
+/**
+ * Apply Butterworth filter (IIR)
+ */
+export declare function butterworth(data: Float32Array | Float64Array, options: ButterworthOptions): Float32Array;
+/**
+ * Exponential moving average filter
+ */
+export declare function exponentialMovingAverage(data: Float32Array | Float64Array, alpha?: number): Float32Array;
+/**
+ * Gaussian smoothing filter
+ */
+export declare function gaussianSmooth(data: Float32Array | Float64Array, sigma?: number): Float32Array;
+/**
+ * Savitzky-Golay smoothing filter
+ */
+export declare function savitzkyGolay(data: Float32Array | Float64Array, windowSize?: number, polynomialOrder?: number): Float32Array;
+/**
+ * Median filter (good for spike removal)
+ */
+export declare function medianFilter(data: Float32Array | Float64Array, windowSize?: number): Float32Array;

package/dist/analysis/index.d.ts

@@ -2,7 +2,7 @@
  * Data Analysis module exports
  *
  * General-purpose utilities for data formatting, cycle detection,
- * peak detection, and data validation.
+ * peak detection, data validation, FFT, filters, and statistics.
  */
 export { formatWithPrefix, formatValue, formatScientific, getBestPrefix, detectCycles, generateCycleColors, detectPeaks, validateData, calculateStats, movingAverage, downsampleLTTB, subtractBaseline, } from './utils';
 export { solveLinearSystem, calculateR2, integrate, derivative, cumulativeIntegral, } from './math';
@@ -10,3 +10,9 @@ export { fitData, } from './fitting';
 export type { CycleInfo, Peak, PrefixInfo, ValidationResult, DataStats, } from './utils';
 export type { FitType, FitOptions, FitResult, } from './fitting';
 export * from './contours';
+export { fft, ifft, analyzeSpectrum, powerSpectrum, dominantFrequency, hanningWindow, hammingWindow, blackmanWindow, nextPowerOf2, } from './fft';
+export type { Complex, FFTResult, PowerSpectrumResult, } from './fft';
+export { lowPassFilter, highPassFilter, bandPassFilter, bandStopFilter, butterworth, exponentialMovingAverage, gaussianSmooth, savitzkyGolay, medianFilter, } from './filters';
+export type { FilterType, FilterOptions, ButterworthOptions, } from './filters';
+export { crossCorrelation, autoCorrelation, detectAnomalies, trapezoidalIntegration, simpsonsIntegration, cumulativeIntegration as cumulativeIntegral2, tTest, } from './statistics';
+export type { CorrelationResult, AnomalyResult, AnomalyOptions, TTestResult, } from './statistics';

package/dist/analysis/statistics.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Advanced Statistical Analysis
+ *
+ * Provides:
+ * - Cross-correlation
+ * - Auto-correlation
+ * - Anomaly detection
+ * - Statistical tests
+ * - Numerical integration (Simpson, trapezoidal)
+ */
+/** Cross-correlation result */
+export interface CorrelationResult {
+    /** Correlation values at each lag */
+    correlation: Float32Array;
+    /** Lag values */
+    lags: Float32Array;
+    /** Maximum correlation value */
+    maxCorrelation: number;
+    /** Lag at maximum correlation */
+    lagAtMax: number;
+}
+/**
+ * Compute cross-correlation between two signals
+ */
+export declare function crossCorrelation(signal1: Float32Array | Float64Array, signal2: Float32Array | Float64Array, maxLag?: number): CorrelationResult;
+/**
+ * Compute auto-correlation of a signal
+ */
+export declare function autoCorrelation(signal: Float32Array | Float64Array, maxLag?: number): CorrelationResult;
+/** Anomaly detection result */
+export interface AnomalyResult {
+    /** Indices of anomalous points */
+    indices: number[];
+    /** Anomaly scores for all points */
+    scores: Float32Array;
+    /** Threshold used for detection */
+    threshold: number;
+}
+/** Anomaly detection options */
+export interface AnomalyOptions {
+    /** Detection method */
+    method?: 'zscore' | 'mad' | 'iqr' | 'isolation';
+    /** Threshold multiplier (default: 3 for zscore, 2.5 for mad, 1.5 for iqr) */
+    threshold?: number;
+    /** Window size for local anomaly detection (default: use global) */
+    windowSize?: number;
+}
+/**
+ * Detect anomalies in a signal
+ */
+export declare function detectAnomalies(data: Float32Array | Float64Array, options?: AnomalyOptions): AnomalyResult;
+/**
+ * Trapezoidal integration
+ */
+export declare function trapezoidalIntegration(y: Float32Array | Float64Array, x?: Float32Array | Float64Array | number): number;
+/**
+ * Simpson's rule integration (requires odd number of points)
+ */
+export declare function simpsonsIntegration(y: Float32Array | Float64Array, x?: Float32Array | Float64Array | number): number;
+/**
+ * Cumulative integration (returns running integral)
+ */
+export declare function cumulativeIntegration(y: Float32Array | Float64Array, x?: Float32Array | Float64Array | number): Float32Array;
+/** T-test result */
+export interface TTestResult {
+    /** T-statistic */
+    tStatistic: number;
+    /** Degrees of freedom */
+    degreesOfFreedom: number;
+    /** Approximate p-value (two-tailed) */
+    pValue: number;
+    /** Whether the difference is significant at 0.05 level */
+    significant: boolean;
+}
+/**
+ * Two-sample t-test (Welch's t-test)
+ */
+export declare function tTest(sample1: Float32Array | Float64Array | number[], sample2: Float32Array | Float64Array | number[]): TTestResult;

package/dist/core/ChartControls.d.ts

@@ -1,10 +1,12 @@
 import { ChartTheme } from '../theme';
+import { InteractionMode } from './InteractionManager';
 
 export interface ChartControlsCallbacks {
     onResetZoom: () => void;
     onSetType: (type: "line" | "scatter" | "line+scatter") => void;
     onToggleSmoothing: () => void;
     onTogglePan: (active: boolean) => void;
+    onSetMode: (mode: InteractionMode) => void;
     onExport: () => void;
     onAutoScale: () => void;
     onToggleLegend: (visible: boolean) => void;
@@ -15,7 +17,7 @@ export declare class ChartControls {
     private callbacks;
     private theme;
     private isSmoothing;
-    private isPanMode;
+    private currentMode;
     private isLegendVisible;
     private currentType;
     constructor(parent: HTMLElement, theme: ChartTheme, callbacks: ChartControlsCallbacks);

package/dist/core/InteractionManager.d.ts

@@ -2,7 +2,7 @@ import { Bounds } from '../types';
 
 export interface AxisLayout {
     id: string;
-    position: 'left' | 'right';
+    position: "left" | "right";
     offset: number;
 }
 export interface InteractionCallbacks {
@@ -16,6 +16,19 @@ export interface InteractionCallbacks {
     } | null) => void;
     onCursorMove: (x: number, y: number) => void;
     onCursorLeave: () => void;
+    onPointClick?: (pixelX: number, pixelY: number, ctrlKey: boolean, shiftKey: boolean) => void;
+    onBoxSelect?: (rect: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    } | null, additive: boolean) => void;
+    onBoxSelectUpdate?: (pixelX: number, pixelY: number) => void;
+    onBoxSelectStart?: (pixelX: number, pixelY: number) => void;
+    /** Called when any drag operation starts (pan, box zoom, box select) */
+    onDragStart?: () => void;
+    /** Called when any drag operation ends */
+    onDragEnd?: () => void;
 }
 export interface PlotAreaGetter {
     (): {
@@ -31,6 +44,7 @@ export interface BoundsGetter {
 export interface AxisLayoutGetter {
     (): AxisLayout[];
 }
+export type InteractionMode = 'pan' | 'boxZoom' | 'select';
 export declare class InteractionManager {
     private container;
     private callbacks;
@@ -40,9 +54,10 @@ export declare class InteractionManager {
     private isDragging;
     private panningAxisId?;
     private isBoxSelecting;
+    private isBoxZooming;
     private selectionStart;
     private lastMousePos;
-    private isPanMode;
+    private mode;
     private boundWheel;
     private boundMouseDown;
     private boundMouseMove;
@@ -54,7 +69,19 @@ export declare class InteractionManager {
     constructor(container: HTMLElement, callbacks: InteractionCallbacks, getPlotArea: PlotAreaGetter, getBounds: BoundsGetter, getAxesLayout: AxisLayoutGetter);
     private attachListeners;
     private detachListeners;
+    /**
+     * Set the interaction mode
+     * @deprecated Use setMode instead
+     */
     setPanMode(enabled: boolean): void;
+    /**
+     * Set the interaction mode: 'pan', 'boxZoom', or 'select'
+     */
+    setMode(mode: InteractionMode): void;
+    /**
+     * Get the current interaction mode
+     */
+    getMode(): InteractionMode;
     private handleWheel;
     private handleMouseDown;
     private handleMouseMove;

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

@@ -0,0 +1,152 @@
+/**
+ * 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;
+    /**
+     * 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/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;