scichart-engine 1.1.1 → 1.2.0

package/dist/analysis/fft.d.ts

@@ -20,8 +20,29 @@ export interface FFTResult {
     magnitude: Float32Array;
     /** Phase spectrum in radians */
     phase: Float32Array;
-    /** Full complex spectrum */
+    /** Full complex spectrum as Complex[] array */
     complex: Complex[];
+    /** Real part of full spectrum as Float32Array */
+    real: Float32Array;
+    /** Imaginary part of full spectrum as Float32Array */
+    imag: Float32Array;
+}
+/** Complex FFT Result - full spectrum with separate real/imag arrays */
+export interface ComplexFFTResult {
+    /** Real part of spectrum */
+    real: Float32Array;
+    /** Imaginary part of spectrum */
+    imag: Float32Array;
+    /** Frequency bins in Hz (if sample rate provided) */
+    frequency: Float32Array;
+    /** Magnitude spectrum (sqrt(real² + imag²)) */
+    magnitude: Float32Array;
+    /** Phase spectrum in radians (atan2(imag, real)) */
+    phase: Float32Array;
+    /** Original spectrum length (power of 2) */
+    length: number;
+    /** Nyquist index (length / 2) */
+    nyquist: number;
 }
 /** Power spectrum result */
 export interface PowerSpectrumResult {
@@ -72,3 +93,46 @@ export declare function hammingWindow(data: Float32Array | Float64Array): Float3
  * Apply Blackman window to data
  */
 export declare function blackmanWindow(data: Float32Array | Float64Array): Float32Array;
+/**
+ * Compute full complex FFT analysis with separate real and imaginary arrays
+ * This is useful when you need direct access to real/imag components
+ */
+export declare function analyzeComplexSpectrum(data: Float32Array | Float64Array | number[], sampleRate?: number): ComplexFFTResult;
+/**
+ * Compute FFT from complex input (real + imaginary arrays)
+ * Useful for processing complex signals or chaining FFT operations
+ */
+export declare function fftFromComplexInput(real: Float32Array | Float64Array | number[], imag: Float32Array | Float64Array | number[]): ComplexFFTResult;
+/**
+ * Convert Complex[] array to separate real and imaginary Float32Arrays
+ */
+export declare function complexToArrays(complex: Complex[]): {
+    real: Float32Array;
+    imag: Float32Array;
+};
+/**
+ * Convert separate real and imaginary arrays to Complex[] array
+ */
+export declare function arraysToComplex(real: Float32Array | Float64Array | number[], imag: Float32Array | Float64Array | number[]): Complex[];
+/**
+ * Compute inverse FFT from separate real and imaginary arrays
+ * Returns the real part of the inverse transform
+ */
+export declare function ifftFromArrays(real: Float32Array | Float64Array | number[], imag: Float32Array | Float64Array | number[]): Float32Array;
+/**
+ * Compute inverse FFT returning complex result (both real and imaginary parts)
+ */
+export declare function ifftComplex(spectrum: Complex[]): {
+    real: Float32Array;
+    imag: Float32Array;
+};
+/**
+ * Get only positive frequencies (up to Nyquist) from complex spectrum
+ */
+export declare function getPositiveFrequencies(result: ComplexFFTResult): {
+    real: Float32Array;
+    imag: Float32Array;
+    frequency: Float32Array;
+    magnitude: Float32Array;
+    phase: Float32Array;
+};

package/dist/analysis/index.d.ts

@@ -10,8 +10,8 @@ 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 { fft, ifft, analyzeSpectrum, powerSpectrum, dominantFrequency, hanningWindow, hammingWindow, blackmanWindow, nextPowerOf2, analyzeComplexSpectrum, fftFromComplexInput, complexToArrays, arraysToComplex, ifftFromArrays, ifftComplex, getPositiveFrequencies, } from './fft';
+export type { Complex, FFTResult, ComplexFFTResult, 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';

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/ChartInitQueue.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Chart Initialization Queue
+ *
+ * Internal system that manages sequential initialization of multiple charts.
+ * This is automatically integrated into createChart - no external usage needed.
+ */
+/**
+ * Internal: Wait for turn in initialization queue
+ * Returns the assigned chart ID
+ */
+export declare function waitForInitTurn(): Promise<string>;
+/**
+ * Internal: Mark chart initialization as complete
+ */
+export declare function markInitComplete(id: string): void;
+/**
+ * Get queue status (for debugging)
+ */
+export declare function getInitQueueStatus(): {
+    pending: number;
+    completed: number;
+    currentId: string | null;
+    isProcessing: boolean;
+};
+/**
+ * Reset the queue (call on page navigation if needed)
+ */
+export declare function resetInitQueue(): void;
+export declare class ChartInitQueue {
+    private static instance;
+    static getStatus(): {
+        pending: number;
+        completed: number;
+        currentId: string | null;
+        isProcessing: boolean;
+    };
+    static reset(): void;
+}
+export declare function getChartInitQueue(): {
+    getStatus: () => {
+        pending: number;
+        completed: number;
+        currentId: string | null;
+        isProcessing: boolean;
+    };
+    reset: () => void;
+};
+export declare function queueChartInit(_id: string, fn: () => Promise<void>): Promise<void>;
+export declare function waitForAnimations(durationMs?: number): Promise<void>;
+export declare function resetChartQueue(): void;

package/dist/core/InteractionManager.d.ts

@@ -25,6 +25,10 @@ export interface InteractionCallbacks {
     } | 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 {
     (): {
@@ -40,6 +44,7 @@ export interface BoundsGetter {
 export interface AxisLayoutGetter {
     (): AxisLayout[];
 }
+export type InteractionMode = 'pan' | 'boxZoom' | 'select';
 export declare class InteractionManager {
     private container;
     private callbacks;
@@ -49,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;
@@ -63,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

@@ -99,6 +99,10 @@ export declare class AnimationEngine {
      * 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
      */

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

@@ -40,10 +40,15 @@ export declare class ChartImpl implements Chart {
     private animationFrameId;
     private needsFullRender;
     private needsOverlayRender;
-    private isDestroyed;
+    private _isDestroyed;
     private autoScroll;
     private showStatistics;
     private stats;
+    private initQueueId;
+    private initStarted;
+    private commandQueue;
+    /** Whether the chart has been destroyed */
+    get isDestroyed(): boolean;
     private selectionRect;
     private annotationManager;
     readonly tooltip: TooltipManager;
@@ -55,6 +60,20 @@ export declare class ChartImpl implements Chart {
     private selectionManager;
     private responsiveManager;
     constructor(options: ChartOptions);
+    /**
+     * Start the chart initialization (called by queue system)
+     * This performs the actual render startup that was deferred from constructor
+     */
+    startInit(): void;
+    /**
+     * Mark this chart's initialization as complete in the queue
+     */
+    completeInit(): Promise<void>;
+    private executeOrQueue;
+    /**
+     * Set the initialization queue ID (internal use)
+     */
+    setInitQueueId(id: string): void;
     private initControls;
     private toggleLegend;
     private initLegend;
@@ -177,8 +196,18 @@ export declare class ChartImpl implements Chart {
     configureSelection(config: Partial<SelectionConfig>): void;
     /**
      * Set pan mode (true = pan, false = selection)
+     * @deprecated Use setMode('pan') or setMode('select') instead
      */
     setPanMode(enabled: boolean): void;
+    /**
+     * Set the interaction mode
+     * @param mode - 'pan' for pan/drag, 'boxZoom' for rectangle zoom, 'select' for point selection
+     */
+    setMode(mode: 'pan' | 'boxZoom' | 'select'): void;
+    /**
+     * Get the current interaction mode
+     */
+    getMode(): 'pan' | 'boxZoom' | 'select';
     /**
      * Handle responsive state changes
      */
@@ -219,8 +248,13 @@ export declare class ChartImpl implements Chart {
     private pixelToDataX;
     private pixelToDataY;
     private startRenderLoop;
+    private scheduleRenderFrame;
     on<K extends keyof ChartEventMap>(e: K, h: (d: ChartEventMap[K]) => void): void;
     off<K extends keyof ChartEventMap>(e: K, h: (d: ChartEventMap[K]) => void): void;
     destroy(): void;
 }
+/**
+ * Create a new chart. Charts are automatically queued for sequential
+ * initialization when multiple charts are created on the same page.
+ */
 export declare function createChart(options: ChartOptions): Chart;

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

@@ -3,6 +3,7 @@ import { ChartLegend } from '../ChartLegend';
 import { ChartTheme } from '../../theme';
 import { ChartOptions } from '../../types';
 import { Series } from '../Series';
+import { InteractionMode } from '../InteractionManager';
 
 export interface UIContext {
     container: HTMLDivElement;
@@ -15,6 +16,7 @@ export interface UIContext {
     requestRender: () => void;
     exportImage: () => string;
     setPanMode: (active: boolean) => void;
+    setMode: (mode: InteractionMode) => void;
     onLegendMove: (x: number, y: number) => void;
     toggleLegend: () => void;
 }

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

@@ -89,8 +89,20 @@ export interface Chart {
     getSelectionCount(): number;
     /** Configure selection behavior */
     configureSelection(config: Partial<import('../selection').SelectionConfig>): void;
-    /** Set pan mode (true = pan, false = selection) */
+    /**
+     * Set pan mode (true = pan, false = selection)
+     * @deprecated Use setMode('pan') or setMode('select') instead
+     */
     setPanMode(enabled: boolean): void;
+    /**
+     * Set the interaction mode
+     * @param mode - 'pan' for pan/drag, 'boxZoom' for rectangle zoom, 'select' for point selection
+     */
+    setMode(mode: 'pan' | 'boxZoom' | 'select'): void;
+    /**
+     * Get the current interaction mode
+     */
+    getMode(): 'pan' | 'boxZoom' | 'select';
     /** Get current responsive state */
     getResponsiveState(): import('../responsive').ResponsiveState;
     /** Configure responsive behavior */

package/dist/core/index.d.ts

@@ -5,7 +5,7 @@ export { createChart, type Chart, type ChartOptions, type ExportOptions } from '
 export { Series } from './Series';
 export { EventEmitter } from './EventEmitter';
 export { OverlayRenderer } from './OverlayRenderer';
-export { InteractionManager } from './InteractionManager';
+export { InteractionManager, type InteractionMode } from './InteractionManager';
 export * from './annotations';
 export * from './selection';
 export * from './responsive';

package/dist/core/tooltip/TooltipManager.d.ts

@@ -53,6 +53,7 @@ export declare class TooltipManager {
     private largeDatasetThreshold;
     private lastKnownDataSize;
     private hysteresisRatio;
+    private suspended;
     constructor(config: TooltipManagerConfig);
     /**
      * Register built-in templates
@@ -74,6 +75,15 @@ export declare class TooltipManager {
      * Check if tooltips are enabled
      */
     isEnabled(): boolean;
+    /**
+     * Suspend tooltip display (used during drag operations)
+     * When suspended, tooltips are immediately hidden and cursor movements are ignored
+     */
+    setSuspended(suspended: boolean): void;
+    /**
+     * Check if tooltips are suspended
+     */
+    isSuspended(): boolean;
     /**
      * Set tooltip theme
      */

package/dist/examples.d.ts

@@ -4,6 +4,12 @@ import { createChart } from './index';
  * Example: Basic CV Plot
  */
 export declare function exampleBasicCV(): import('./index').Chart;
+/**
+ * Example: FFT of sine, square, and mixed waves
+ */
+export declare function exampleFFTWaveforms(target?: HTMLDivElement): {
+    destroy(): void;
+};
 /**
  * Example: Streaming data (real-time)
  */

package/dist/index.d.ts

@@ -18,6 +18,7 @@ export { EventEmitter } from './core/EventEmitter';
 export type { Chart, ChartOptions, ExportOptions } from './core/Chart';
 export { AnimationEngine, easings, DEFAULT_ANIMATION_CONFIG, mergeAnimationConfig, getSharedAnimationEngine, } from './core/animation';
 export type { AnimationOptions, AnimationHandle, BoundsAnimation, ChartAnimationConfig, EasingFunction, EasingName, } from './core/animation';
+export { ChartInitQueue, getChartInitQueue, queueChartInit, waitForAnimations, resetChartQueue, } from './core/ChartInitQueue';
 export { AnnotationManager } from './core/annotations';
 export type { Annotation, AnnotationType, HorizontalLineAnnotation, VerticalLineAnnotation, RectangleAnnotation, BandAnnotation, TextAnnotation, ArrowAnnotation, } from './core/annotations';
 export type { AxisOptions, SeriesOptions, SeriesData, SeriesStyle, SeriesUpdateData, ZoomOptions, CursorOptions, ChartEventMap, Point, Bounds, Range, ScaleType, SeriesType, StepMode, ErrorBarStyle, ErrorBarDirection, ScatterSymbol, } from './types';