scichart-engine 1.2.0 → 1.4.0

package/dist/analysis/index.d.ts

@@ -16,3 +16,5 @@ export { lowPassFilter, highPassFilter, bandPassFilter, bandStopFilter, butterwo
 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';
+export { sma, ema, wma, dema, tema, rsi, macd, stochastic, roc, momentum, bollingerBands, atr, standardDeviation, vwap, obv, adx, aroon, percentChange, cumsum, normalize, } from './indicators';
+export type { IndicatorResult, OHLCData, } from './indicators';

package/dist/analysis/indicators.d.ts

@@ -0,0 +1,148 @@
+/**
+ * SciChart Engine - Financial/Technical Indicators Module
+ *
+ * Provides common financial and technical analysis indicators:
+ * - Moving Averages (SMA, EMA, WMA)
+ * - Momentum Indicators (RSI, MACD, Stochastic)
+ * - Volatility (Bollinger Bands, ATR)
+ * - Volume (VWAP, OBV)
+ * - Trend (ADX, Aroon)
+ *
+ * @module indicators
+ */
+export interface IndicatorResult {
+    /** Indicator values (NaN for insufficient data) */
+    values: Float32Array;
+    /** Additional line (e.g., signal line for MACD) */
+    signal?: Float32Array;
+    /** Upper band (e.g., Bollinger upper) */
+    upper?: Float32Array;
+    /** Lower band (e.g., Bollinger lower) */
+    lower?: Float32Array;
+    /** Histogram (e.g., MACD histogram) */
+    histogram?: Float32Array;
+}
+export interface OHLCData {
+    open: Float32Array | Float64Array;
+    high: Float32Array | Float64Array;
+    low: Float32Array | Float64Array;
+    close: Float32Array | Float64Array;
+    volume?: Float32Array | Float64Array;
+}
+/**
+ * Simple Moving Average (SMA)
+ * @param data Input data array
+ * @param period Number of periods
+ */
+export declare function sma(data: Float32Array | Float64Array | number[], period: number): Float32Array;
+/**
+ * Exponential Moving Average (EMA)
+ * @param data Input data array
+ * @param period Number of periods
+ */
+export declare function ema(data: Float32Array | Float64Array | number[], period: number): Float32Array;
+/**
+ * Weighted Moving Average (WMA)
+ * @param data Input data array
+ * @param period Number of periods
+ */
+export declare function wma(data: Float32Array | Float64Array | number[], period: number): Float32Array;
+/**
+ * Double Exponential Moving Average (DEMA)
+ * @param data Input data array
+ * @param period Number of periods
+ */
+export declare function dema(data: Float32Array | Float64Array | number[], period: number): Float32Array;
+/**
+ * Triple Exponential Moving Average (TEMA)
+ * @param data Input data array
+ * @param period Number of periods
+ */
+export declare function tema(data: Float32Array | Float64Array | number[], period: number): Float32Array;
+/**
+ * Relative Strength Index (RSI)
+ * @param data Close prices
+ * @param period RSI period (default: 14)
+ */
+export declare function rsi(data: Float32Array | Float64Array | number[], period?: number): Float32Array;
+/**
+ * Moving Average Convergence Divergence (MACD)
+ * @param data Close prices
+ * @param fastPeriod Fast EMA period (default: 12)
+ * @param slowPeriod Slow EMA period (default: 26)
+ * @param signalPeriod Signal line period (default: 9)
+ */
+export declare function macd(data: Float32Array | Float64Array | number[], fastPeriod?: number, slowPeriod?: number, signalPeriod?: number): IndicatorResult;
+/**
+ * Stochastic Oscillator
+ * @param ohlc OHLC data
+ * @param kPeriod %K period (default: 14)
+ * @param dPeriod %D smoothing period (default: 3)
+ */
+export declare function stochastic(ohlc: OHLCData, kPeriod?: number, dPeriod?: number): IndicatorResult;
+/**
+ * Rate of Change (ROC)
+ * @param data Close prices
+ * @param period ROC period (default: 10)
+ */
+export declare function roc(data: Float32Array | Float64Array | number[], period?: number): Float32Array;
+/**
+ * Momentum
+ * @param data Close prices
+ * @param period Momentum period (default: 10)
+ */
+export declare function momentum(data: Float32Array | Float64Array | number[], period?: number): Float32Array;
+/**
+ * Bollinger Bands
+ * @param data Close prices
+ * @param period SMA period (default: 20)
+ * @param stdDev Standard deviation multiplier (default: 2)
+ */
+export declare function bollingerBands(data: Float32Array | Float64Array | number[], period?: number, stdDev?: number): IndicatorResult;
+/**
+ * Average True Range (ATR)
+ * @param ohlc OHLC data
+ * @param period ATR period (default: 14)
+ */
+export declare function atr(ohlc: OHLCData, period?: number): Float32Array;
+/**
+ * Standard Deviation
+ * @param data Input data
+ * @param period Period for calculation (default: 20)
+ */
+export declare function standardDeviation(data: Float32Array | Float64Array | number[], period?: number): Float32Array;
+/**
+ * Volume Weighted Average Price (VWAP)
+ * @param ohlc OHLC data with volume
+ */
+export declare function vwap(ohlc: OHLCData): Float32Array;
+/**
+ * On-Balance Volume (OBV)
+ * @param close Close prices
+ * @param volume Volume data
+ */
+export declare function obv(close: Float32Array | Float64Array | number[], volume: Float32Array | Float64Array | number[]): Float32Array;
+/**
+ * Average Directional Index (ADX)
+ * @param ohlc OHLC data
+ * @param period ADX period (default: 14)
+ */
+export declare function adx(ohlc: OHLCData, period?: number): IndicatorResult;
+/**
+ * Aroon Indicator
+ * @param ohlc OHLC data
+ * @param period Aroon period (default: 25)
+ */
+export declare function aroon(ohlc: OHLCData, period?: number): IndicatorResult;
+/**
+ * Calculate percentage change
+ */
+export declare function percentChange(data: Float32Array | Float64Array | number[], period?: number): Float32Array;
+/**
+ * Calculate cumulative sum
+ */
+export declare function cumsum(data: Float32Array | Float64Array | number[]): Float32Array;
+/**
+ * Normalize data to 0-100 range
+ */
+export declare function normalize(data: Float32Array | Float64Array | number[]): Float32Array;

package/dist/core/InteractionManager.d.ts

@@ -44,7 +44,7 @@ export interface BoundsGetter {
 export interface AxisLayoutGetter {
     (): AxisLayout[];
 }
-export type InteractionMode = 'pan' | 'boxZoom' | 'select';
+export type InteractionMode = 'pan' | 'boxZoom' | 'select' | 'delta' | 'peak';
 export declare class InteractionManager {
     private container;
     private callbacks;

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

@@ -9,6 +9,8 @@ import { ResponsiveConfig, ResponsiveState } from '../responsive';
 import { ChartState, SerializeOptions, DeserializeOptions } from '../../serialization';
 import { Chart, ExportOptions } from './types';
 import { ChartAnimationConfig } from '../animation';
+import { DeltaTool } from '../delta-tool';
+import { PeakTool } from '../peak-tool';
 
 import * as analysis from "../../analysis";
 export declare class ChartImpl implements Chart {
@@ -59,6 +61,8 @@ export declare class ChartImpl implements Chart {
     private animationConfig;
     private selectionManager;
     private responsiveManager;
+    private deltaTool;
+    private peakTool;
     constructor(options: ChartOptions);
     /**
      * Start the chart initialization (called by queue system)
@@ -201,13 +205,21 @@ export declare class ChartImpl implements Chart {
     setPanMode(enabled: boolean): void;
     /**
      * Set the interaction mode
-     * @param mode - 'pan' for pan/drag, 'boxZoom' for rectangle zoom, 'select' for point selection
+     * @param mode - 'pan' for pan/drag, 'boxZoom' for rectangle zoom, 'select' for point selection, 'delta' for measurements
      */
-    setMode(mode: 'pan' | 'boxZoom' | 'select'): void;
+    setMode(mode: 'pan' | 'boxZoom' | 'select' | 'delta' | 'peak'): void;
     /**
      * Get the current interaction mode
      */
-    getMode(): 'pan' | 'boxZoom' | 'select';
+    getMode(): 'pan' | 'boxZoom' | 'select' | 'delta' | 'peak';
+    /**
+     * Get the Delta Tool instance for advanced measurements
+     */
+    getDeltaTool(): DeltaTool | null;
+    /**
+     * Get the Peak Tool instance for peak integration
+     */
+    getPeakTool(): PeakTool | null;
     /**
      * Handle responsive state changes
      */

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

@@ -98,11 +98,19 @@ export interface Chart {
      * Set the interaction mode
      * @param mode - 'pan' for pan/drag, 'boxZoom' for rectangle zoom, 'select' for point selection
      */
-    setMode(mode: 'pan' | 'boxZoom' | 'select'): void;
+    setMode(mode: 'pan' | 'boxZoom' | 'select' | 'delta' | 'peak'): void;
     /**
      * Get the current interaction mode
      */
-    getMode(): 'pan' | 'boxZoom' | 'select';
+    getMode(): 'pan' | 'boxZoom' | 'select' | 'delta' | 'peak';
+    /**
+     * Get the Delta Tool instance for advanced measurements
+     */
+    getDeltaTool(): import('../delta-tool').DeltaTool | null;
+    /**
+     * Get the Peak Tool instance for peak integration
+     */
+    getPeakTool(): import('../peak-tool').PeakTool | null;
     /** Get current responsive state */
     getResponsiveState(): import('../responsive').ResponsiveState;
     /** Configure responsive behavior */

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

@@ -0,0 +1,137 @@
+/**
+ * SciChart Engine - Clipboard Module
+ *
+ * Provides clipboard operations for copying chart data to various formats.
+ * Supports copying selected points, visible data, or all data.
+ *
+ * @module clipboard
+ */
+export type ClipboardFormat = 'tsv' | 'csv' | 'json' | 'markdown';
+export interface ClipboardOptions {
+    /** Output format (default: 'tsv' - Excel compatible) */
+    format?: ClipboardFormat;
+    /** Include column headers (default: true) */
+    includeHeaders?: boolean;
+    /** Decimal precision (default: 6) */
+    precision?: number;
+    /** Use scientific notation for very large/small numbers (default: true) */
+    scientific?: boolean;
+    /** Scientific notation threshold (default: 1e6) */
+    scientificThreshold?: number;
+    /** Custom column separator (overrides format default) */
+    separator?: string;
+    /** Custom line separator (default: '\n') */
+    lineSeparator?: string;
+    /** Include series name in output (default: true for multi-series) */
+    includeSeriesName?: boolean;
+    /** Custom header names */
+    headers?: {
+        x?: string;
+        y?: string;
+        series?: string;
+    };
+}
+export interface ClipboardDataPoint {
+    x: number;
+    y: number;
+    seriesId?: string;
+    seriesName?: string;
+    index?: number;
+}
+export interface ClipboardResult {
+    /** Whether the copy was successful */
+    success: boolean;
+    /** Number of points copied */
+    pointCount: number;
+    /** Number of series included */
+    seriesCount: number;
+    /** The formatted text that was copied */
+    text?: string;
+    /** Error message if failed */
+    error?: string;
+}
+export declare class ClipboardManager {
+    private defaultOptions;
+    constructor(options?: Partial<ClipboardOptions>);
+    /**
+     * Copy data points to clipboard
+     */
+    copyPoints(points: ClipboardDataPoint[], options?: Partial<ClipboardOptions>): Promise<ClipboardResult>;
+    /**
+     * Copy series data to clipboard
+     */
+    copySeries(seriesData: {
+        id: string;
+        name?: string;
+        x: Float32Array | Float64Array;
+        y: Float32Array | Float64Array;
+    }[], options?: Partial<ClipboardOptions>): Promise<ClipboardResult>;
+    /**
+     * Format data points to string
+     */
+    formatPoints(points: ClipboardDataPoint[], options: ClipboardOptions): string;
+    /**
+     * Format as delimited text (TSV/CSV)
+     */
+    private formatAsDelimited;
+    /**
+     * Format as JSON
+     */
+    private formatAsJson;
+    /**
+     * Format as Markdown table
+     */
+    private formatAsMarkdown;
+    /**
+     * Format a number for output
+     */
+    private formatNumber;
+    /**
+     * Round a number to specified precision
+     */
+    private roundNumber;
+    /**
+     * Write text to system clipboard
+     */
+    private writeToClipboard;
+    /**
+     * Fallback clipboard copy using hidden textarea
+     */
+    private fallbackCopyToClipboard;
+    /**
+     * Read from clipboard (for paste functionality)
+     */
+    readFromClipboard(): Promise<string | null>;
+    /**
+     * Parse clipboard text to data points
+     */
+    parseClipboardData(text: string, format?: ClipboardFormat): ClipboardDataPoint[];
+    /**
+     * Detect format from text content
+     */
+    private detectFormat;
+    /**
+     * Parse JSON data
+     */
+    private parseJson;
+    /**
+     * Set default options
+     */
+    setDefaults(options: Partial<ClipboardOptions>): void;
+    /**
+     * Get current default options
+     */
+    getDefaults(): ClipboardOptions;
+}
+/**
+ * Get the global clipboard manager instance
+ */
+export declare function getClipboardManager(): ClipboardManager;
+/**
+ * Copy data points to clipboard (convenience function)
+ */
+export declare function copyToClipboard(points: ClipboardDataPoint[], options?: Partial<ClipboardOptions>): Promise<ClipboardResult>;
+/**
+ * Format data as delimited string (without copying)
+ */
+export declare function formatData(points: ClipboardDataPoint[], options?: Partial<ClipboardOptions>): string;

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

@@ -0,0 +1,143 @@
+/**
+ * SciChart Engine - Debug Overlay Module
+ *
+ * Provides a visual debug overlay showing performance metrics,
+ * rendering info, and chart state for development and debugging.
+ *
+ * @module debug
+ */
+export interface DebugStats {
+    /** Current frames per second */
+    fps: number;
+    /** Average frame time in ms */
+    frameTime: number;
+    /** Total number of points being rendered */
+    pointCount: number;
+    /** Number of visible series */
+    seriesCount: number;
+    /** Current view bounds */
+    viewBounds: {
+        xMin: number;
+        xMax: number;
+        yMin: number;
+        yMax: number;
+    };
+    /** WebGL/WebGPU renderer info */
+    rendererInfo: {
+        type: 'webgl' | 'webgpu' | 'unknown';
+        vendor?: string;
+        renderer?: string;
+    };
+    /** Memory usage estimate (bytes) */
+    memoryEstimate: number;
+    /** Number of draw calls per frame */
+    drawCalls: number;
+    /** Whether GPU downsampling is active */
+    downsamplingActive: boolean;
+    /** Device pixel ratio */
+    devicePixelRatio: number;
+    /** Canvas dimensions */
+    canvasSize: {
+        width: number;
+        height: number;
+    };
+    /** Plot area dimensions */
+    plotArea: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+}
+export interface DebugOverlayOptions {
+    /** Show FPS counter (default: true) */
+    showFps?: boolean;
+    /** Show point count (default: true) */
+    showPointCount?: boolean;
+    /** Show view bounds (default: true) */
+    showBounds?: boolean;
+    /** Show renderer info (default: true) */
+    showRendererInfo?: boolean;
+    /** Show memory estimate (default: true) */
+    showMemory?: boolean;
+    /** Show draw calls (default: true) */
+    showDrawCalls?: boolean;
+    /** Position: 'top-left', 'top-right', 'bottom-left', 'bottom-right' */
+    position?: 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
+    /** Background opacity (0-1, default: 0.8) */
+    opacity?: number;
+    /** Font size in pixels (default: 11) */
+    fontSize?: number;
+    /** Update interval in ms (default: 250) */
+    updateInterval?: number;
+    /** Custom CSS class name */
+    className?: string;
+}
+export declare class DebugOverlay {
+    private container;
+    private element;
+    private options;
+    private visible;
+    private updateIntervalId;
+    private statsProvider;
+    private lastStats;
+    private frameCount;
+    private lastFpsUpdate;
+    private currentFps;
+    private frameTimes;
+    constructor(container: HTMLElement, options?: DebugOverlayOptions);
+    /**
+     * Set the stats provider function
+     */
+    setStatsProvider(provider: () => Partial<DebugStats>): void;
+    /**
+     * Record a frame for FPS calculation
+     */
+    recordFrame(frameTime?: number): void;
+    /**
+     * Show the debug overlay
+     */
+    show(): void;
+    /**
+     * Hide the debug overlay
+     */
+    hide(): void;
+    /**
+     * Toggle visibility
+     */
+    toggle(): void;
+    /**
+     * Check if visible
+     */
+    isVisible(): boolean;
+    /**
+     * Update the display with new stats
+     */
+    update(stats?: Partial<DebugStats>): void;
+    /**
+     * Get current stats
+     */
+    getStats(): Partial<DebugStats>;
+    /**
+     * Destroy the overlay
+     */
+    destroy(): void;
+    private createElement;
+    private destroyElement;
+    private getPositionStyles;
+    private startUpdates;
+    private stopUpdates;
+    private getAverageFrameTime;
+    private renderStats;
+    private formatNumber;
+    private formatBytes;
+    private formatValue;
+}
+/**
+ * Create a debug overlay for a chart container
+ */
+export declare function createDebugOverlay(container: HTMLElement, options?: DebugOverlayOptions): DebugOverlay;
+/**
+ * Quick enable debug mode (attaches to first chart container found)
+ */
+export declare function enableDebugMode(options?: DebugOverlayOptions): DebugOverlay | null;

package/dist/core/delta-tool/index.d.ts

@@ -0,0 +1,146 @@
+import { DeltaMeasurement, Bounds } from '../../types';
+
+export interface DeltaToolOptions {
+    /** Line color for measurement (default: '#ff6b6b') */
+    lineColor?: string;
+    /** Line width in pixels (default: 2) */
+    lineWidth?: number;
+    /** Show labels at measurement points (default: true) */
+    showLabels?: boolean;
+    /** Label font size (default: 12) */
+    labelFontSize?: number;
+    /** Label background color (default: 'rgba(0,0,0,0.8)') */
+    labelBackground?: string;
+    /** Label text color (default: '#ffffff') */
+    labelColor?: string;
+    /** Show delta values inline (default: true) */
+    showDelta?: boolean;
+    /** Number precision for values (default: 4) */
+    precision?: number;
+    /** Show slope value (default: true) */
+    showSlope?: boolean;
+    /** Show distance value (default: true) */
+    showDistance?: boolean;
+    /** Custom CSS class for overlay elements */
+    className?: string;
+    /** Point highlight size when hovering (default: 10) */
+    highlightSize?: number;
+    /** Point highlight color (default: '#00f2ff') */
+    highlightColor?: string;
+    /** Snap radius in pixels for detecting nearby points (default: 20) */
+    snapRadius?: number;
+}
+/** Data point with series information */
+export interface DataPoint {
+    x: number;
+    y: number;
+    seriesId: string;
+    index: number;
+    pixelX: number;
+    pixelY: number;
+}
+export interface DeltaToolState {
+    /** Whether the tool is enabled */
+    enabled: boolean;
+    /** Selection state: 'idle' | 'waitingSecond' | 'complete' */
+    selectionState: 'idle' | 'waitingSecond' | 'complete';
+    /** First selected point */
+    point1: DataPoint | null;
+    /** Second selected point */
+    point2: DataPoint | null;
+    /** Currently hovered point (for highlighting) */
+    hoveredPoint: DataPoint | null;
+    /** Last completed measurement */
+    lastMeasurement: DeltaMeasurement | null;
+}
+export interface SeriesData {
+    id: string;
+    x: Float32Array | Float64Array | number[];
+    y: Float32Array | Float64Array | number[];
+}
+export interface DeltaToolContext {
+    container: HTMLElement;
+    getPlotArea: () => {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    getViewBounds: () => Bounds;
+    requestRender: () => void;
+    getSeries?: () => SeriesData[];
+    onMeasure?: (measurement: DeltaMeasurement) => void;
+}
+export declare class DeltaTool {
+    private ctx;
+    private options;
+    private state;
+    private overlayCanvas;
+    private overlayCtx;
+    private labelOffset;
+    private isDraggingLabel;
+    private labelBounds;
+    private dragStart;
+    private boundMouseMove;
+    private boundClick;
+    private boundKeyDown;
+    private boundMouseDown;
+    private boundMouseUp;
+    private boundResize;
+    constructor(context: DeltaToolContext, options?: DeltaToolOptions);
+    /**
+     * Enable the delta measurement tool
+     */
+    enable(): void;
+    /**
+     * Disable the delta measurement tool
+     */
+    disable(): void;
+    /**
+     * Toggle the tool on/off
+     */
+    toggle(): void;
+    /**
+     * Check if tool is enabled
+     */
+    isEnabled(): boolean;
+    /**
+     * Get the current state
+     */
+    getState(): DeltaToolState;
+    /**
+     * Get the last completed measurement
+     */
+    getMeasurement(): DeltaMeasurement | null;
+    /**
+     * Clear the current measurement
+     */
+    clear(): void;
+    /**
+     * Destroy the tool and cleanup
+     */
+    destroy(): void;
+    private createOverlay;
+    private resizeOverlay;
+    private destroyOverlay;
+    private attachListeners;
+    private detachListeners;
+    private handleMouseMove;
+    private handleLabelMouseDown;
+    private handleLabelMouseUp;
+    private handleClick;
+    private handleKeyDown;
+    private findNearestPoint;
+    private calculateMeasurement;
+    private renderOverlay;
+    private drawPointTooltip;
+    private drawPointLabel;
+    private drawMeasurementLabel;
+    private drawStatusIndicator;
+    private roundRect;
+    private formatValue;
+}
+/**
+ * Create a delta tool for a chart context
+ */
+export declare function createDeltaTool(context: DeltaToolContext, options?: DeltaToolOptions): DeltaTool;

package/dist/core/index.d.ts

@@ -9,3 +9,10 @@ export { InteractionManager, type InteractionMode } from './InteractionManager';
 export * from './annotations';
 export * from './selection';
 export * from './responsive';
+export * from './delta-tool';
+export * from './loading';
+export * from './locale';
+export * from './keybindings';
+export * from './debug';
+export * from './clipboard';
+export * from './sync';