scichart-engine 1.1.2 → 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/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/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;
@@ -229,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/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';