velo-plot 1.11.1

package/dist/plugins/offscreen/pool.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @fileoverview Worker Pool Manager for Offscreen Rendering
+ * @module plugins/offscreen/pool
+ */
+export interface WorkerTask {
+    id: string;
+    priority: number;
+    timestamp: number;
+    resolve: (value: ImageBitmap) => void;
+    reject: (error: Error) => void;
+}
+export declare class WorkerPool {
+    private size;
+    private workers;
+    private availableWorkers;
+    private taskQueue;
+    private activeJobs;
+    constructor(size: number);
+    private initialize;
+    private handleWorkerMessage;
+    private handleWorkerError;
+    private findTask;
+    private processQueue;
+    submit(priority?: number): Promise<ImageBitmap>;
+    getStats(): {
+        total: number;
+        active: number;
+        idle: number;
+        queued: number;
+    };
+    destroy(): void;
+}

package/dist/plugins/offscreen/types.d.ts

@@ -0,0 +1,35 @@
+/**
+ * @fileoverview Types for Offscreen rendering plugin
+ * @module plugins/offscreen/types
+ */
+export type OffscreenMode = "auto" | "webgl-only" | "all-layers";
+export type OffscreenTransferMode = "offscreen" | "image-bitmap";
+export type OffscreenFallbackMode = "main-thread" | "disable";
+export interface PluginOffscreenConfig {
+    /** Enable offscreen rendering (default: false) */
+    enabled?: boolean;
+    /** Rendering mode (default: "auto") */
+    mode?: OffscreenMode;
+    /** Number of workers in pool (default: 1) */
+    workerPool?: number;
+    /** Transfer strategy (default: "offscreen") */
+    transfer?: OffscreenTransferMode;
+    /** Fallback if offscreen unavailable (default: "main-thread") */
+    fallback?: OffscreenFallbackMode;
+    /** Enable debug logs (default: false) */
+    debug?: boolean;
+}
+export interface OffscreenStats {
+    enabled: boolean;
+    frames: number;
+    lastFrameTime: number;
+    lastFrameTimestamp: number;
+}
+export interface OffscreenAPI {
+    enable(): void;
+    disable(): void;
+    isEnabled(): boolean;
+    updateConfig(config: Partial<PluginOffscreenConfig>): void;
+    getStats(): OffscreenStats;
+    flush(): void;
+}

package/dist/plugins/pattern-recognition/index.d.ts

@@ -0,0 +1,6 @@
+import { ChartPlugin } from '../types';
+import { PluginPatternRecognitionConfig } from './types';
+
+export declare function PluginPatternRecognition(userConfig?: Partial<PluginPatternRecognitionConfig>): ChartPlugin<PluginPatternRecognitionConfig>;
+export default PluginPatternRecognition;
+export type { PatternType, PatternDefinition, PatternPoint, PatternSegment, PatternValidationResult, PatternMeasurements, PatternMatch, PatternDetectionResult, PatternDetectionParameters, CustomPatternConfig, PluginPatternRecognitionConfig, PatternDetectedEvent, PatternCompletedEvent, PatternFailedEvent, PatternRecognitionAPI } from './types';

package/dist/plugins/pattern-recognition/patterns.d.ts

@@ -0,0 +1,3 @@
+import { PatternDefinition, PatternType } from './types';
+
+export declare const BUILTIN_PATTERNS: Record<PatternType, PatternDefinition>;

package/dist/plugins/pattern-recognition/types.d.ts

@@ -0,0 +1,245 @@
+/**
+ * Pattern Recognition Plugin Types
+ *
+ * Provides types for technical pattern recognition in financial and scientific data.
+ * Supports common chart patterns like head-shoulders, double tops, triangles.
+ *
+ * @packageDocumentation
+ * @module plugins/pattern-recognition
+ */
+export type PatternType = 'head-shoulders' | 'inverse-head-shoulders' | 'double-top' | 'double-bottom' | 'triple-top' | 'triple-bottom' | 'ascending-triangle' | 'descending-triangle' | 'symmetrical-triangle' | 'rising-wedge' | 'falling-wedge' | 'rectangle' | 'flag' | 'pennant' | 'custom';
+export interface PatternDefinition {
+    /** Pattern identifier */
+    id: string;
+    /** Pattern type */
+    type: PatternType;
+    /** Pattern name for display */
+    name: string;
+    /** Pattern description */
+    description?: string;
+    /** Minimum number of points required */
+    minPoints: number;
+    /** Maximum number of points allowed */
+    maxPoints?: number;
+    /** Pattern validation function */
+    validator: (points: PatternPoint[]) => PatternValidationResult;
+    /** Pattern confidence calculator */
+    confidenceCalculator?: (points: PatternPoint[], validation: PatternValidationResult) => number;
+}
+export interface PatternPoint {
+    /** X coordinate (time/index) */
+    x: number;
+    /** Y coordinate (price/value) */
+    y: number;
+    /** Point type in pattern context */
+    type?: 'peak' | 'valley' | 'start' | 'end';
+    /** Volume at this point (optional) */
+    volume?: number;
+}
+export interface PatternSegment {
+    /** Start point */
+    start: PatternPoint;
+    /** End point */
+    end: PatternPoint;
+    /** Segment type */
+    type: 'support' | 'resistance' | 'trendline';
+    /** Segment strength (0-1) */
+    strength?: number;
+}
+export interface PatternValidationResult {
+    /** Whether pattern is valid */
+    valid: boolean;
+    /** Confidence score (0-1) */
+    confidence: number;
+    /** Pattern segments */
+    segments: PatternSegment[];
+    /** Key points in pattern */
+    keyPoints: PatternPoint[];
+    /** Pattern measurements */
+    measurements?: PatternMeasurements;
+    /** Validation errors */
+    errors?: string[];
+}
+export interface PatternMeasurements {
+    /** Pattern height (high - low) */
+    height: number;
+    /** Pattern width (duration) */
+    width: number;
+    /** Pattern slope */
+    slope: number;
+    /** Volume profile */
+    volumeProfile?: {
+        increasing: number;
+        decreasing: number;
+        neutral: number;
+    };
+    /** Breakout target */
+    breakoutTarget?: number;
+    /** Stop loss level */
+    stopLoss?: number;
+}
+export interface PatternMatch {
+    /** Pattern definition */
+    pattern: PatternDefinition;
+    /** Match confidence (0-1) */
+    confidence: number;
+    /** Pattern location */
+    location: {
+        startIndex: number;
+        endIndex: number;
+        startPoint: PatternPoint;
+        endPoint: PatternPoint;
+    };
+    /** Validation result */
+    validation: PatternValidationResult;
+    /** Detection timestamp */
+    timestamp: number;
+    /** Series ID where pattern was found */
+    seriesId: string;
+}
+export interface PatternDetectionResult {
+    /** All pattern matches found */
+    matches: PatternMatch[];
+    /** Detection summary */
+    summary: {
+        totalPatterns: number;
+        patternsByType: Record<PatternType, number>;
+        averageConfidence: number;
+        detectionTime: number;
+    };
+    /** Processed data points */
+    processedPoints: number;
+    /** Detection parameters used */
+    parameters: PatternDetectionParameters;
+}
+export interface PatternDetectionParameters {
+    /** Minimum pattern confidence threshold */
+    minConfidence: number;
+    /** Maximum patterns to detect */
+    maxPatterns?: number;
+    /** Pattern types to detect */
+    patternTypes: PatternType[];
+    /** Sensitivity for peak/valley detection */
+    sensitivity: number;
+    /** Minimum pattern size (points) */
+    minPatternSize: number;
+    /** Maximum pattern size (points) */
+    maxPatternSize: number;
+    /** Overlap tolerance between patterns */
+    overlapTolerance: number;
+    /** Enable volume confirmation */
+    enableVolumeConfirmation: boolean;
+    /** Enable trend confirmation */
+    enableTrendConfirmation: boolean;
+}
+export interface CustomPatternConfig {
+    /** Pattern identifier */
+    id: string;
+    /** Pattern name */
+    name: string;
+    /** Point sequence definition */
+    pointSequence: {
+        type: 'peak' | 'valley' | 'any';
+        relativePosition: number;
+        constraints?: {
+            higherThanPrevious?: boolean;
+            lowerThanPrevious?: boolean;
+            withinRange?: [number, number];
+        };
+    }[];
+    /** Validation rules */
+    validationRules: {
+        slopeConstraints?: {
+            minSlope?: number;
+            maxSlope?: number;
+        };
+        ratioConstraints?: {
+            heightToWidthRatio?: [number, number];
+            symmetryRatio?: [number, number];
+        };
+        volumeConstraints?: {
+            increasingVolume?: boolean;
+            volumeConfirmation?: boolean;
+        };
+    };
+}
+export interface PluginPatternRecognitionConfig {
+    /** Default detection parameters */
+    defaultParameters: PatternDetectionParameters;
+    /** Custom patterns to register */
+    customPatterns?: CustomPatternConfig[];
+    /** Enable real-time detection */
+    enableRealtime: boolean;
+    /** Detection debounce time (ms) */
+    debounceTime: number;
+    /** Maximum patterns to store in memory */
+    maxStoredPatterns: number;
+    /** Pattern visualization settings */
+    visualization: {
+        showPatterns: boolean;
+        showLabels: boolean;
+        showTargets: boolean;
+        colorScheme: Record<PatternType, string>;
+        opacity: number;
+        lineWidth: number;
+    };
+    /** Notification settings */
+    notifications: {
+        enableAlerts: boolean;
+        minAlertConfidence: number;
+        alertTypes: PatternType[];
+    };
+}
+export interface PatternDetectedEvent {
+    match: PatternMatch;
+    seriesId: string;
+    timestamp: number;
+}
+export interface PatternCompletedEvent {
+    match: PatternMatch;
+    breakoutConfirmed: boolean;
+    breakoutDirection: 'upward' | 'downward' | 'none';
+    seriesId: string;
+    timestamp: number;
+}
+export interface PatternFailedEvent {
+    patternType: PatternType;
+    reason: string;
+    location: {
+        startIndex: number;
+        endIndex: number;
+    };
+    seriesId: string;
+    timestamp: number;
+}
+export interface PatternRecognitionAPI {
+    /** Detect patterns in series data */
+    detectPatterns(seriesId: string, data: PatternPoint[], parameters?: Partial<PatternDetectionParameters>): Promise<PatternDetectionResult>;
+    /** Register a custom pattern */
+    registerCustomPattern(config: CustomPatternConfig): void;
+    /** Get all registered patterns */
+    getRegisteredPatterns(): PatternDefinition[];
+    /** Get pattern matches for a series */
+    getPatternMatches(seriesId: string): PatternMatch[];
+    /** Clear pattern matches for a series */
+    clearPatternMatches(seriesId: string): void;
+    /** Enable real-time pattern detection for series */
+    enableRealtimeDetection(seriesId: string, parameters?: Partial<PatternDetectionParameters>): void;
+    /** Disable real-time pattern detection for series */
+    disableRealtimeDetection(seriesId: string): void;
+    /** Get pattern statistics */
+    getStatistics(seriesId?: string): {
+        totalDetections: number;
+        patternsByType: Record<PatternType, number>;
+        averageConfidence: number;
+        detectionRate: number;
+    };
+    /** Update plugin configuration */
+    updateConfig(config: Partial<PluginPatternRecognitionConfig>): void;
+    /** Get current configuration */
+    getConfig(): PluginPatternRecognitionConfig;
+    /** Visualize patterns on chart */
+    visualizePatterns(seriesId: string, showTypes?: PatternType[]): void;
+    /** Hide pattern visualizations */
+    hidePatterns(seriesId: string): void;
+}

package/dist/plugins/radar/index.d.ts

@@ -0,0 +1,6 @@
+import { PluginRadarConfig } from './types';
+import { ChartPlugin } from '../types';
+
+export declare function PluginRadar(userConfig?: Partial<PluginRadarConfig>): ChartPlugin<PluginRadarConfig>;
+export default PluginRadar;
+export type { PluginRadarConfig, RadarAPI, RadarSeriesData, RadarPoint } from './types';

package/dist/plugins/radar/types.d.ts

@@ -0,0 +1,40 @@
+export interface RadarPoint {
+    category: string;
+    value: number;
+}
+export interface RadarSeriesData {
+    id: string;
+    name: string;
+    points: RadarPoint[];
+    style?: {
+        color?: string;
+        fillColor?: string;
+        width?: number;
+        opacity?: number;
+        pointSize?: number;
+    };
+}
+export interface PluginRadarConfig {
+    categories: string[];
+    maxValue?: number;
+    minValue?: number;
+    gridLevels?: number;
+    showLabels?: boolean;
+    labelStyle?: {
+        fontSize?: number;
+        color?: string;
+        fontFamily?: string;
+    };
+    gridStyle?: {
+        color?: string;
+        width?: number;
+        lineDash?: number[];
+    };
+}
+export interface RadarAPI {
+    addSeries(data: RadarSeriesData): string;
+    removeSeries(id: string): boolean;
+    updateSeries(id: string, points: RadarPoint[]): boolean;
+    setCategories(categories: string[]): void;
+    setMaxValue(value: number): void;
+}

package/dist/plugins/regression/algorithms.d.ts

@@ -0,0 +1,6 @@
+import { RegressionData, RegressionResult, LinearRegressionConfig, PolynomialRegressionConfig, ExponentialRegressionConfig, GaussianRegressionConfig } from './types';
+
+export declare function linearRegression(data: RegressionData, config?: LinearRegressionConfig): RegressionResult;
+export declare function polynomialRegression(data: RegressionData, config: PolynomialRegressionConfig): RegressionResult;
+export declare function exponentialRegression(data: RegressionData, _config?: ExponentialRegressionConfig): RegressionResult;
+export declare function gaussianRegression(data: RegressionData, _config?: GaussianRegressionConfig): RegressionResult;

package/dist/plugins/regression/index.d.ts

@@ -0,0 +1,6 @@
+import { ChartPlugin } from '../types';
+import { PluginRegressionConfig } from './types';
+
+export declare function PluginRegression(userConfig?: Partial<PluginRegressionConfig>): ChartPlugin<PluginRegressionConfig>;
+export default PluginRegression;
+export type { RegressionMethod, RegressionData, RegressionParameters, RegressionStatistics, RegressionResult, LinearRegressionConfig, PolynomialRegressionConfig, ExponentialRegressionConfig, LogarithmicRegressionConfig, PowerRegressionConfig, GaussianRegressionConfig, LorentzianRegressionConfig, SigmoidRegressionConfig, CustomRegressionConfig, PluginRegressionConfig, RegressionCompletedEvent, RegressionFailedEvent, ModelSelectedEvent, RegressionAPI } from './types';

package/dist/plugins/regression/types.d.ts

@@ -0,0 +1,261 @@
+/**
+ * Regression Plugin Types
+ *
+ * Provides types for advanced scientific regression and curve fitting.
+ * Supports linear, polynomial, exponential, logarithmic, and custom models.
+ *
+ * @packageDocumentation
+ * @module plugins/regression
+ */
+export type RegressionMethod = 'linear' | 'polynomial' | 'exponential' | 'logarithmic' | 'power' | 'gaussian' | 'lorentzian' | 'sigmoid' | 'custom';
+export interface RegressionData {
+    /** X values (independent variable) */
+    x: Float32Array | Float64Array | number[];
+    /** Y values (dependent variable) */
+    y: Float32Array | Float64Array | number[];
+    /** Weights for weighted regression (optional) */
+    weights?: Float32Array | Float64Array | number[];
+    /** Standard deviations for y values (for weighted fitting) */
+    yErrors?: Float32Array | Float64Array | number[];
+}
+export interface RegressionParameters {
+    /** Fitted parameters */
+    parameters: number[];
+    /** Parameter uncertainties (standard errors) */
+    uncertainties?: number[];
+    /** Parameter correlation matrix */
+    correlationMatrix?: number[][];
+    /** Covariance matrix */
+    covarianceMatrix?: number[][];
+}
+export interface RegressionStatistics {
+    /** Coefficient of determination (R²) */
+    rSquared: number;
+    /** Adjusted R² */
+    adjustedRSquared: number;
+    /** Root mean square error */
+    rmse: number;
+    /** Residual sum of squares */
+    rss: number;
+    /** Total sum of squares */
+    tss: number;
+    /** F-statistic */
+    fStatistic?: number;
+    /** p-value */
+    pValue?: number;
+    /** Akaike information criterion */
+    aic?: number;
+    /** Bayesian information criterion */
+    bic?: number;
+    /** Number of data points */
+    n: number;
+    /** Number of parameters */
+    k: number;
+}
+export interface RegressionResult {
+    /** Regression method used */
+    method: RegressionMethod;
+    /** Fitted parameters */
+    parameters: RegressionParameters;
+    /** Statistics */
+    statistics: RegressionStatistics;
+    /** Fitted values (predicted y) */
+    fittedValues: Float32Array;
+    /** Residuals (observed - fitted) */
+    residuals: Float32Array;
+    /** Confidence intervals for fitted values */
+    confidenceIntervals?: {
+        lower: Float32Array;
+        upper: Float32Array;
+        level: number;
+    };
+    /** Prediction intervals */
+    predictionIntervals?: {
+        lower: Float32Array;
+        upper: Float32Array;
+        level: number;
+    };
+    /** Goodness of fit assessment */
+    goodnessOfFit: 'excellent' | 'good' | 'fair' | 'poor';
+    /** Convergence status */
+    converged: boolean;
+    /** Number of iterations */
+    iterations: number;
+    /** Processing time in milliseconds */
+    processingTime: number;
+}
+export interface LinearRegressionConfig {
+    /** Force intercept through origin */
+    forceOrigin?: boolean;
+    /** Include confidence intervals */
+    includeConfidenceIntervals?: boolean;
+    /** Confidence level (0-1) */
+    confidenceLevel?: number;
+}
+export interface PolynomialRegressionConfig {
+    /** Polynomial degree */
+    degree: number;
+    /** Orthogonal polynomial fitting */
+    orthogonal?: boolean;
+    /** Regularization parameter (ridge regression) */
+    regularization?: number;
+}
+export interface ExponentialRegressionConfig {
+    /** Initial guess for amplitude */
+    initialAmplitude?: number;
+    /** Initial guess for rate */
+    initialRate?: number;
+    /** Initial guess for offset */
+    initialOffset?: number;
+    /** Constrain parameters to be positive */
+    constrainPositive?: boolean;
+}
+export interface LogarithmicRegressionConfig {
+    /** Base of logarithm (default: e) */
+    base?: number;
+    /** Include constant term */
+    includeConstant?: boolean;
+}
+export interface PowerRegressionConfig {
+    /** Initial guess for exponent */
+    initialExponent?: number;
+    /** Initial guess for coefficient */
+    initialCoefficient?: number;
+    /** Force zero intercept */
+    forceZeroIntercept?: boolean;
+}
+export interface GaussianRegressionConfig {
+    /** Initial guess for amplitude */
+    initialAmplitude?: number;
+    /** Initial guess for mean */
+    initialMean?: number;
+    /** Initial guess for standard deviation */
+    initialStd?: number;
+    /** Initial guess for offset */
+    initialOffset?: number;
+    /** Constrain std to be positive */
+    constrainStdPositive?: boolean;
+}
+export interface LorentzianRegressionConfig {
+    /** Initial guess for amplitude */
+    initialAmplitude?: number;
+    /** Initial guess for center */
+    initialCenter?: number;
+    /** Initial guess for width (FWHM) */
+    initialWidth?: number;
+    /** Initial guess for offset */
+    initialOffset?: number;
+}
+export interface SigmoidRegressionConfig {
+    /** Type of sigmoid function */
+    type?: 'logistic' | 'tanh' | 'arctan';
+    /** Initial guess for maximum value */
+    initialMax?: number;
+    /** Initial guess for minimum value */
+    initialMin?: number;
+    /** Initial guess for inflection point */
+    initialInflection?: number;
+    /** Initial guess for steepness */
+    initialSteepness?: number;
+}
+export interface CustomRegressionConfig {
+    /** Model function: f(x, parameters) */
+    modelFunction: (x: number, parameters: number[]) => number;
+    /** Jacobian function: ∂f/∂parameters */
+    jacobianFunction?: (x: number, parameters: number[]) => number[];
+    /** Initial parameter guesses */
+    initialParameters: number[];
+    /** Parameter bounds */
+    parameterBounds?: {
+        min: number[];
+        max: number[];
+    };
+    /** Optimization method */
+    optimizationMethod?: 'levenberg-marquardt' | 'gradient-descent' | 'newton';
+}
+export interface PluginRegressionConfig {
+    /** Default regression method */
+    defaultMethod: RegressionMethod;
+    /** Enable automatic model selection */
+    enableAutoSelection?: boolean;
+    /** Model selection criteria */
+    modelSelectionCriteria: 'aic' | 'bic' | 'adjusted-r2' | 'cross-validation';
+    /** Enable weighted regression */
+    enableWeightedRegression?: boolean;
+    /** Enable robust regression (outlier-resistant) */
+    enableRobustRegression?: boolean;
+    /** Robust regression method */
+    robustMethod?: 'huber' | 'tukey' | 'least-trimmed-squares';
+    /** Maximum number of iterations for non-linear fitting */
+    maxIterations: number;
+    /** Convergence tolerance */
+    convergenceTolerance: number;
+    /** Default confidence level */
+    defaultConfidenceLevel: number;
+    /** Enable parallel processing for large datasets */
+    enableParallelProcessing?: boolean;
+    /** Chunk size for parallel processing */
+    parallelChunkSize?: number;
+}
+export interface RegressionCompletedEvent {
+    result: RegressionResult;
+    seriesId: string;
+    method: RegressionMethod;
+    timestamp: number;
+}
+export interface RegressionFailedEvent {
+    error: Error | string;
+    seriesId: string;
+    method: RegressionMethod;
+    reason: string;
+    timestamp: number;
+}
+export interface ModelSelectedEvent {
+    selectedMethod: RegressionMethod;
+    candidateResults: RegressionResult[];
+    selectionCriteria: string;
+    seriesId: string;
+    timestamp: number;
+}
+export interface RegressionAPI {
+    /** Perform regression analysis */
+    fit(seriesId: string, data: RegressionData, method?: RegressionMethod, config?: any): Promise<RegressionResult>;
+    /** Fit multiple models and compare */
+    fitAndCompare(seriesId: string, data: RegressionData, methods: RegressionMethod[], configs?: any[]): Promise<RegressionResult[]>;
+    /** Automatic model selection */
+    autoFit(seriesId: string, data: RegressionData, candidateMethods?: RegressionMethod[]): Promise<RegressionResult>;
+    /** Get regression results for a series */
+    getResults(seriesId: string): RegressionResult[];
+    /** Clear regression results for a series */
+    clearResults(seriesId: string): void;
+    /** Predict values using fitted model */
+    predict(seriesId: string, xValues: Float32Array | Float64Array | number[], resultIndex?: number): Float32Array;
+    /** Get confidence intervals for predictions */
+    getConfidenceIntervals(seriesId: string, xValues: Float32Array | Float64Array | number[], level?: number, resultIndex?: number): {
+        lower: Float32Array;
+        upper: Float32Array;
+    };
+    /** Evaluate model on new data */
+    evaluate(seriesId: string, data: RegressionData, resultIndex?: number): RegressionStatistics;
+    /** Enable real-time fitting for series */
+    enableRealtimeFitting(seriesId: string, method?: RegressionMethod, config?: any): void;
+    /** Disable real-time fitting for series */
+    disableRealtimeFitting(seriesId: string): void;
+    /** Get regression statistics summary */
+    getStatistics(seriesId?: string): {
+        totalFittings: number;
+        methodsUsed: Record<RegressionMethod, number>;
+        averageRSquared: number;
+        averageProcessingTime: number;
+    };
+    /** Update plugin configuration */
+    updateConfig(config: Partial<PluginRegressionConfig>): void;
+    /** Get current configuration */
+    getConfig(): PluginRegressionConfig;
+    /** Visualize regression fit on chart */
+    visualizeFit(seriesId: string, resultIndex?: number): void;
+    /** Hide regression visualization */
+    hideVisualization(seriesId: string): void;
+    /** Export regression results */
+    exportResults(seriesId: string, format?: 'json' | 'csv' | 'matlab'): string;
+}

package/dist/plugins/roi/exports.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @fileoverview ROI plugin exports
+ * @module plugins/roi
+ */
+export { PluginROI } from './index';
+export type { PluginROIConfig, RoiAPI, RoiRegion, RoiPoint, RoiMaskResult, RoiTool, RoiEvent, RoiSelectedEvent, } from './index';