velo-plot 1.11.1

package/dist/plugins/index.d.ts

@@ -0,0 +1,110 @@
+/**
+ * Sci Plot - Plugin System
+ *
+ * Comprehensive plugin architecture for extending chart functionality.
+ *
+ * Features:
+ * - Complete lifecycle hooks (init, render, data, view, interaction, destroy)
+ * - Rich plugin context with access to all chart internals
+ * - Plugin storage for persistent state
+ * - Dependency management between plugins
+ * - Global registry for third-party plugins
+ * - Built-in plugins for common use cases
+ *
+ * @packageDocumentation
+ * @module plugins
+ */
+export type { PluginVersion, PluginCapability, PluginManifest, PluginContext, RenderContext, CoordinateContext, DataContext, UIContext, EventContext, PluginStorage, PluginLogger, OverlayOptions, NotificationOptions, PickResult, BeforeRenderEvent, AfterRenderEvent, InteractionEvent, ViewChangeEvent, SeriesChangeEvent, DataUpdateEvent, ChartPlugin, PluginFactory, TypedPlugin, PluginManager, PluginRegistry, PluginRegistryEntry, } from './types';
+export { createPluginContext } from './PluginContext';
+export type { ContextDependencies } from './PluginContext';
+export { PluginManagerImpl } from './PluginManager';
+export { getPluginRegistry, registerPlugin, definePlugin, defineAndRegister, loadPlugin, listPluginsByCategory, validateManifest, checkPluginCompatibility, } from './PluginRegistry';
+export { CrosshairPlugin, StatsPlugin, WatermarkPlugin, GridHighlightPlugin, DataLoggerPlugin, DirectionIndicatorPlugin, BuiltinPlugins, type CrosshairPluginConfig, type StatsPluginConfig, type WatermarkPluginConfig, type GridHighlightConfig, type DataLoggerConfig, type DirectionIndicatorConfig, } from './builtins';
+export { Plugin3D, type Plugin3DConfig } from './3d';
+export { PluginGpu, type PluginGpuConfig } from './gpu';
+export { PluginAnalysis, type PluginAnalysisConfig } from './analysis';
+export { PluginTools, type PluginToolsConfig } from './tools';
+export { PluginAnnotations, type PluginAnnotationsConfig } from './annotations';
+export { PluginStreaming, type PluginStreamingConfig } from './streaming';
+export { PluginThemeEditor, type PluginThemeEditorConfig } from './theme-editor';
+export { PluginI18n, type PluginI18nConfig } from './i18n';
+export { PluginKeyboard, type PluginKeyboardConfig } from './keyboard';
+export { PluginClipboard, type PluginClipboardConfig } from './clipboard';
+export { PluginSync, type PluginSyncConfig } from './sync';
+export { PluginDebug, type PluginDebugConfig } from './debug';
+export { PluginLoading, type PluginLoadingConfig } from './loading';
+export { PluginDataExport, type PluginDataExportConfig } from './data-export';
+export { PluginContextMenu, type PluginContextMenuConfig } from './context-menu';
+export { PluginAnomalyDetection, type PluginAnomalyDetectionConfig, type AnomalyDetectionResult, type AnomalyPoint, type AnomalyMethod } from './anomaly-detection';
+export { PluginMLIntegration, type PluginMLIntegrationConfig, type MLIntegrationAPI, type MLModelAPI, type PredictionResult, type VisualizationConfig } from './ml-integration';
+export { PluginPatternRecognition, type PluginPatternRecognitionConfig, type PatternRecognitionAPI, type PatternMatch, type PatternDetectionResult } from './pattern-recognition';
+export { PluginRegression, type PluginRegressionConfig, type RegressionAPI, type RegressionResult, type RegressionData } from './regression';
+export { PluginRadar, type PluginRadarConfig, type RadarAPI, type RadarSeriesData, type RadarPoint } from './radar';
+export { PluginSnapshot, type PluginSnapshotConfig, type SnapshotExportAPI, type SnapshotExportOptions, type SnapshotResolution, type SnapshotFormat } from './snapshot';
+export { PluginDataTransform, type PluginDataTransformConfig, type DataTransformAPI, type TransformOp, type TransformType } from './data-transform';
+export { PluginLaTeX, type PluginLaTeXConfig, type LaTeXPluginAPI, type LaTeXDimensions } from './latex';
+export * from './forecasting';
+export { PluginDragEdit, type PluginDragEditConfig, type DragEditAPI, type DragEditEvent } from './drag-edit';
+export { PluginCaching, type PluginCachingConfig, type CachingAPI, type CacheStats } from './caching';
+export { PluginLazyLoad, type PluginLazyLoadConfig, type LazyLoadAPI, type DataProvider } from './lazy-load';
+export { PluginBrokenAxis, type PluginBrokenAxisConfig, type BrokenAxisAPI, type AxisBreak } from './broken-axis';
+export { PluginVideoRecorder, type PluginVideoRecorderConfig, type VideoRecorderAPI, type VideoRecorderOptions } from './video-recorder';
+export { PluginOffscreen, type PluginOffscreenConfig, type OffscreenAPI, type OffscreenStats, type OffscreenMode, type OffscreenTransferMode, type OffscreenFallbackMode } from './offscreen';
+export { PluginVirtualization, type PluginVirtualizationConfig, type VirtualizationAPI, type VirtualizationStats, type VirtualizationMode, type VirtualizationStrategy } from './virtualization';
+export { PluginROI, type PluginROIConfig, type RoiAPI, type RoiRegion, type RoiPoint, type RoiMaskResult, type RoiTool, type RoiEvent, type RoiSelectedEvent } from './roi';
+/**
+ * Helper function to create a plugin with proper typing
+ *
+ * @example
+ * ```typescript
+ * const MyPlugin = createPlugin({
+ *   manifest: {
+ *     name: 'my-plugin',
+ *     version: '1.0.0',
+ *     provides: ['analysis'],
+ *   },
+ *   onInit(ctx) {
+ *     ctx.log.info('Plugin initialized!');
+ *   },
+ *   onAfterRender(ctx, event) {
+ *     // Custom rendering
+ *   },
+ *   api: {
+ *     doSomething() { return 'done'; }
+ *   }
+ * });
+ *
+ * chart.use(MyPlugin);
+ * ```
+ */
+export declare function createPlugin<TConfig = void, TApi extends Record<string, unknown> = {}>(definition: import('./types').ChartPlugin<TConfig> & {
+    api?: TApi;
+}): import('./types').ChartPlugin<TConfig> & {
+    api: TApi;
+};
+/**
+ * Helper function to create a configurable plugin factory
+ *
+ * @example
+ * ```typescript
+ * interface MyConfig {
+ *   color: string;
+ *   enabled: boolean;
+ * }
+ *
+ * const MyPlugin = createConfigurablePlugin<MyConfig>(
+ *   {
+ *     name: 'my-plugin',
+ *     version: '1.0.0',
+ *   },
+ *   (config) => ({
+ *     onInit(ctx) {
+ *       ctx.log.info(`Color: ${config?.color}`);
+ *     }
+ *   })
+ * );
+ *
+ * chart.use(MyPlugin({ color: 'red', enabled: true }));
+ * ```
+ */
+export declare function createConfigurablePlugin<TConfig = void>(manifest: import('./types').PluginManifest, factory: (config?: TConfig) => Omit<import('./types').ChartPlugin<TConfig>, "manifest">): import('./types').PluginFactory<TConfig>;

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

@@ -0,0 +1,15 @@
+import { KeyBindingManager, DEFAULT_KEY_BINDINGS, KeyBinding, KeyBindingManagerOptions } from '../../core/keybindings';
+import { ChartPlugin } from '../types';
+
+export interface PluginKeyboardConfig extends Partial<KeyBindingManagerOptions> {
+    /** Additional shortcuts to register */
+    extraShortcuts?: KeyBinding[];
+}
+/**
+ * SciPlot Keyboard Plugin
+ *
+ * Adds support for keyboard shortcuts and hotkeys.
+ */
+export declare function PluginKeyboard(_config?: PluginKeyboardConfig): ChartPlugin<PluginKeyboardConfig>;
+export { KeyBindingManager, DEFAULT_KEY_BINDINGS };
+export default PluginKeyboard;

package/dist/plugins/keyboard.d.ts

@@ -0,0 +1,3 @@
+export * from './keyboard/index'
+import SciPlot from './keyboard/index'
+export default SciPlot

package/dist/plugins/keyboard.js

@@ -0,0 +1,8 @@
+import { D as n, K as r, P as s, P as K } from "../index-Ce2JgkH_.js";
+export {
+  n as DEFAULT_KEY_BINDINGS,
+  r as KeyBindingManager,
+  s as PluginKeyboard,
+  K as default
+};
+//# sourceMappingURL=keyboard.js.map

package/dist/plugins/keyboard.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyboard.js","sources":[],"sourcesContent":[],"names":[],"mappings":";"}

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

@@ -0,0 +1,6 @@
+/**
+ * @fileoverview LaTeX rendering plugin exports
+ * @module plugins/latex/exports
+ */
+export { PluginLaTeX } from './index';
+export type { PluginLaTeXConfig, LaTeXPluginAPI, LaTeXDimensions } from './types';

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

@@ -0,0 +1,8 @@
+import { ChartPlugin } from '../types';
+import { PluginLaTeXConfig, LaTeXPluginAPI, LaTeXDimensions } from './types';
+
+/**
+ * LaTeX rendering plugin
+ */
+export declare function PluginLaTeX(config?: PluginLaTeXConfig): ChartPlugin<PluginLaTeXConfig>;
+export type { PluginLaTeXConfig, LaTeXPluginAPI, LaTeXDimensions };

package/dist/plugins/latex/parser.d.ts

@@ -0,0 +1,6 @@
+import { LaTeXNode } from './types';
+
+/**
+ * Parse LaTeX string into an abstract syntax tree
+ */
+export declare function parseLaTeX(latex: string): LaTeXNode[];

package/dist/plugins/latex/renderer.d.ts

@@ -0,0 +1,6 @@
+import { LaTeXNode, LaTeXRenderContext, LaTeXDimensions } from './types';
+
+/**
+ * Render a list of LaTeX nodes to canvas
+ */
+export declare function renderNodes(nodes: LaTeXNode[], ctx: LaTeXRenderContext): LaTeXDimensions;

package/dist/plugins/latex/symbols.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @fileoverview Greek letters and mathematical symbols for LaTeX rendering
+ * @module plugins/latex/symbols
+ */
+/**
+ * Greek letters mapping (lowercase)
+ */
+export declare const GREEK_LOWERCASE: Record<string, string>;
+/**
+ * Greek letters mapping (uppercase)
+ */
+export declare const GREEK_UPPERCASE: Record<string, string>;
+/**
+ * Mathematical operators
+ */
+export declare const MATH_OPERATORS: Record<string, string>;
+/**
+ * All symbols combined
+ */
+export declare const ALL_SYMBOLS: Record<string, string>;
+/**
+ * Get Unicode symbol for a LaTeX command
+ */
+export declare function getSymbol(command: string): string | undefined;
+/**
+ * Check if a command is a known symbol
+ */
+export declare function isSymbol(command: string): boolean;

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

@@ -0,0 +1,88 @@
+/**
+ * @fileoverview Types for the LaTeX rendering plugin
+ * @module plugins/latex/types
+ */
+/**
+ * Configuration for the LaTeX plugin
+ */
+export interface PluginLaTeXConfig {
+    /**
+     * Default font size for LaTeX text (in pixels)
+     * @default 14
+     */
+    fontSize?: number;
+    /**
+     * Default font family
+     * @default 'serif'
+     */
+    fontFamily?: string;
+    /**
+     * Default text color
+     * @default '#000000'
+     */
+    color?: string;
+    /**
+     * Enable caching of rendered LaTeX
+     * @default true
+     */
+    enableCache?: boolean;
+    /**
+     * Custom symbol mappings
+     */
+    customSymbols?: Record<string, string>;
+}
+/**
+ * LaTeX node types in the abstract syntax tree
+ */
+export type LaTeXNodeType = 'text' | 'textgroup' | 'superscript' | 'subscript' | 'fraction' | 'sqrt' | 'symbol' | 'operator' | 'group';
+/**
+ * Base LaTeX node in the AST
+ */
+export interface LaTeXNode {
+    type: LaTeXNodeType;
+    content?: string;
+    children?: LaTeXNode[];
+    numerator?: LaTeXNode[];
+    denominator?: LaTeXNode[];
+}
+/**
+ * Rendering context for LaTeX
+ */
+export interface LaTeXRenderContext {
+    ctx: CanvasRenderingContext2D;
+    x: number;
+    y: number;
+    fontSize: number;
+    fontFamily: string;
+    color: string;
+    scale: number;
+}
+/**
+ * Measured dimensions of rendered LaTeX
+ */
+export interface LaTeXDimensions {
+    width: number;
+    height: number;
+    baseline: number;
+}
+/**
+ * API exposed by the LaTeX plugin
+ */
+export interface LaTeXPluginAPI {
+    /**
+     * Render LaTeX string to canvas at specified position
+     */
+    render(latex: string, ctx: CanvasRenderingContext2D, x: number, y: number, options?: Partial<PluginLaTeXConfig>): LaTeXDimensions;
+    /**
+     * Measure LaTeX string dimensions without rendering
+     */
+    measure(latex: string, options?: Partial<PluginLaTeXConfig>): LaTeXDimensions;
+    /**
+     * Clear the rendering cache
+     */
+    clearCache(): void;
+    /**
+     * Index signature for compatibility
+     */
+    [key: string]: any;
+}

package/dist/plugins/lazy-load/exports.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @fileoverview Lazy loading plugin exports
+ * @module plugins/lazy-load
+ */
+export { PluginLazyLoad, default } from './index';
+export type { PluginLazyLoadConfig, LazyLoadAPI, DataProvider, DataChunk, LoadProgressEvent, LazyLoadedSeries, } from './types';

package/dist/plugins/lazy-load/index.d.ts

@@ -0,0 +1,6 @@
+import { PluginLazyLoadConfig } from './types';
+import { ChartPlugin } from '../types';
+
+export declare function PluginLazyLoad(userConfig?: Partial<PluginLazyLoadConfig>): ChartPlugin<PluginLazyLoadConfig>;
+export default PluginLazyLoad;
+export type { PluginLazyLoadConfig, LazyLoadAPI, DataProvider, DataChunk, LoadProgressEvent, } from './types';

package/dist/plugins/lazy-load/types.d.ts

@@ -0,0 +1,121 @@
+/**
+ * @fileoverview Types for lazy loading plugin
+ * @module plugins/lazy-load/types
+ */
+/**
+ * Data chunk for lazy loading
+ */
+export interface DataChunk {
+    /** Start index in full dataset */
+    startIndex: number;
+    /** End index in full dataset */
+    endIndex: number;
+    /** X data */
+    x: Float32Array | Float64Array;
+    /** Y data */
+    y: Float32Array | Float64Array;
+    /** Chunk loaded timestamp */
+    loadedAt: number;
+}
+/**
+ * Data provider interface
+ */
+export interface DataProvider {
+    /** Total number of points */
+    getTotalCount(): number;
+    /** Load data chunk */
+    loadChunk(startIndex: number, endIndex: number): Promise<DataChunk>;
+    /** Optional: Get data range for optimization */
+    getRange?(): {
+        xMin: number;
+        xMax: number;
+        yMin: number;
+        yMax: number;
+    };
+}
+/**
+ * Loading progress event
+ */
+export interface LoadProgressEvent {
+    /** Series ID */
+    seriesId: string;
+    /** Loaded points so far */
+    loadedPoints: number;
+    /** Total points */
+    totalPoints: number;
+    /** Progress 0-1 */
+    progress: number;
+    /** Current chunk being loaded */
+    currentChunk: number;
+    /** Total chunks */
+    totalChunks: number;
+}
+/**
+ * Plugin configuration
+ */
+export interface PluginLazyLoadConfig {
+    /** Enable lazy loading (default: true) */
+    enabled?: boolean;
+    /** Chunk size in points (default: 10000) */
+    chunkSize?: number;
+    /** Viewport buffer multiplier (default: 2) - load 2x viewport */
+    viewportBuffer?: number;
+    /** Auto-load on zoom/pan (default: true) */
+    autoLoad?: boolean;
+    /** Unload distant chunks to save memory (default: true) */
+    autoUnload?: boolean;
+    /** Distance threshold for unloading (in viewports, default: 5) */
+    unloadThreshold?: number;
+    /** Preload adjacent chunks (default: true) */
+    preloadAdjacent?: boolean;
+    /** Maximum loaded chunks (default: 100) */
+    maxLoadedChunks?: number;
+    /** Callbacks */
+    onLoadStart?: (event: LoadProgressEvent) => void;
+    onLoadProgress?: (event: LoadProgressEvent) => void;
+    onLoadComplete?: (event: LoadProgressEvent) => void;
+    onLoadError?: (error: Error, seriesId: string) => void;
+    /** Enable debug logging (default: false) */
+    debug?: boolean;
+}
+/**
+ * Registered series info
+ */
+export interface LazyLoadedSeries {
+    /** Series ID */
+    id: string;
+    /** Data provider */
+    provider: DataProvider;
+    /** Loaded chunks */
+    chunks: Map<number, DataChunk>;
+    /** Currently loading chunks */
+    loading: Set<number>;
+    /** Total points */
+    totalPoints: number;
+}
+/**
+ * Plugin API
+ */
+export interface LazyLoadAPI {
+    /** Register a series for lazy loading */
+    registerSeries(seriesId: string, provider: DataProvider): void;
+    /** Unregister a series */
+    unregisterSeries(seriesId: string): void;
+    /** Force load specific range */
+    loadRange(seriesId: string, startIndex: number, endIndex: number): Promise<void>;
+    /** Load visible data for all series */
+    loadVisible(): Promise<void>;
+    /** Unload distant chunks */
+    unloadDistant(): number;
+    /** Get loading status */
+    getLoadingStatus(seriesId: string): {
+        loadedPoints: number;
+        totalPoints: number;
+        loadedChunks: number;
+        totalChunks: number;
+    } | null;
+    /** Clear all loaded data */
+    clear(): void;
+    /** Update configuration */
+    updateConfig(config: Partial<PluginLazyLoadConfig>): void;
+}

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

@@ -0,0 +1,15 @@
+import { LoadingIndicator, LoadingIndicatorOptions } from '../../core/loading';
+import { ChartPlugin } from '../types';
+
+export interface PluginLoadingConfig extends Partial<LoadingIndicatorOptions> {
+    /** Auto-show on heavy data operations */
+    autoShow?: boolean;
+}
+/**
+ * SciPlot Loading Plugin
+ *
+ * Adds sleek loading indicators and progress trackers to the chart.
+ */
+export declare function PluginLoading(_config?: PluginLoadingConfig): ChartPlugin<PluginLoadingConfig>;
+export { LoadingIndicator };
+export default PluginLoading;

package/dist/plugins/loading.d.ts

@@ -0,0 +1,3 @@
+export * from './loading/index'
+import SciPlot from './loading/index'
+export default SciPlot

package/dist/plugins/loading.js

@@ -0,0 +1,7 @@
+import { L as d, P as i, P as n } from "../index-qhscKTDy.js";
+export {
+  d as LoadingIndicator,
+  i as PluginLoading,
+  n as default
+};
+//# sourceMappingURL=loading.js.map

package/dist/plugins/loading.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"loading.js","sources":[],"sourcesContent":[],"names":[],"mappings":";"}

package/dist/plugins/ml-integration/exports.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Native ML Integration Plugin - Exports
+ *
+ * Exports all types and functions for the native ML Integration plugin.
+ *
+ * @packageDocumentation
+ * @module plugins/ml-integration
+ */
+export { PluginMLIntegration, default } from './index';
+export type { MLRuntime, ModelConfig, PredictionInput, PredictionResult, VisualizationConfig, PluginMLIntegrationConfig, ModelLoadedEvent, PredictionEvent, ModelErrorEvent, MLModelAPI, MLIntegrationAPI, NativeStatsAPI } from './types';
+export { createNativeModel, nativeFFT, nativeMean, nativeStandardDeviation, nativeCorrelation } from './native-algorithms';

package/dist/plugins/ml-integration/index.d.ts

@@ -0,0 +1,6 @@
+import { PluginMLIntegrationConfig } from './types';
+import { ChartPlugin } from '../types';
+
+export declare function PluginMLIntegration(userConfig?: Partial<PluginMLIntegrationConfig>): ChartPlugin<PluginMLIntegrationConfig>;
+export default PluginMLIntegration;
+export type { PluginMLIntegrationConfig, MLIntegrationAPI, MLModelAPI, PredictionResult, VisualizationConfig } from './types';

package/dist/plugins/ml-integration/native-algorithms.d.ts

@@ -0,0 +1,69 @@
+import { MLModelAPI, ModelConfig, PredictionInput, PredictionResult } from './types';
+
+export declare class SimpleNeuralNetwork implements MLModelAPI {
+    private network;
+    private config;
+    private ready;
+    constructor(config: ModelConfig);
+    get id(): string;
+    get name(): string;
+    get type(): string;
+    predict(input: PredictionInput): Promise<PredictionResult>;
+    private forwardPass;
+    private denseLayer;
+    private applyActivation;
+    getInfo(): ModelConfig;
+    isReady(): boolean;
+    warmup(): Promise<void>;
+    dispose(): void;
+}
+export declare class NativeLinearRegression implements MLModelAPI {
+    private config;
+    private coefficients;
+    private intercept;
+    private ready;
+    constructor(config: ModelConfig);
+    get id(): string;
+    get name(): string;
+    get type(): string;
+    predict(input: PredictionInput): Promise<PredictionResult>;
+    train(data: {
+        x: number[][];
+        y: number[];
+    }): void;
+    private transpose;
+    private matrixMultiply;
+    private matrixInverse;
+    getInfo(): ModelConfig;
+    isReady(): boolean;
+    warmup(): Promise<void>;
+    dispose(): void;
+}
+export declare class NativeSignalProcessor implements MLModelAPI {
+    private config;
+    private filterType;
+    private cutoffFrequency;
+    private sampleRate;
+    private ready;
+    constructor(config: ModelConfig);
+    get id(): string;
+    get name(): string;
+    get type(): string;
+    predict(input: PredictionInput): Promise<PredictionResult>;
+    private applyFilter;
+    private lowpassFilter;
+    private highpassFilter;
+    private bandpassFilter;
+    getInfo(): ModelConfig;
+    isReady(): boolean;
+    warmup(): Promise<void>;
+    dispose(): void;
+}
+export declare function createNativeModel(config: ModelConfig): MLModelAPI;
+export declare function nativeFFT(data: number[]): {
+    real: number[];
+    imag: number[];
+};
+export declare function nativeMean(data: number[]): number;
+export declare function nativeStandardDeviation(data: number[]): number;
+export declare function nativeCorrelation(x: number[], y: number[]): number;

package/dist/plugins/ml-integration/types.d.ts

@@ -0,0 +1,74 @@
+export type MLRuntime = 'native' | 'web-worker' | 'wasm';
+export interface ModelConfig {
+    id: string;
+    name: string;
+    type: 'regression' | 'classification' | 'anomaly' | 'forecasting' | 'neural-network' | 'linear-regression' | 'signal-processor' | string;
+    metadata?: Record<string, any>;
+}
+export interface PredictionInput {
+    data: number[] | Float32Array;
+    metadata?: Record<string, any>;
+}
+export interface PredictionResult {
+    modelId: string;
+    output: Float32Array;
+    xValues?: Float32Array | Float64Array;
+    outputShape: number[];
+    timestamp: number;
+    processingTime: number;
+    confidence?: number[];
+    metadata?: Record<string, any>;
+}
+export interface MLModelAPI {
+    id: string;
+    name: string;
+    type: string;
+    predict(input: PredictionInput): Promise<PredictionResult>;
+    getInfo(): ModelConfig;
+    isReady(): boolean;
+    warmup(): Promise<void>;
+    dispose(): void;
+}
+export interface VisualizationConfig {
+    showConfidenceInterval?: boolean;
+    intervalOpacity?: number;
+    lineStyle?: {
+        color?: string;
+        width?: number;
+        dash?: number[];
+    };
+}
+export interface PluginMLIntegrationConfig {
+    runtime?: MLRuntime;
+    models?: ModelConfig[];
+    defaultVisualization?: VisualizationConfig;
+}
+export interface MLIntegrationAPI {
+    registerModel(model: MLModelAPI): void;
+    runInference(modelId: string, seriesId: string): Promise<PredictionResult>;
+    visualizeResults(result: PredictionResult, config?: VisualizationConfig): string;
+    clearResults(visualizationId?: string): void;
+    stats: NativeStatsAPI;
+}
+export interface NativeStatsAPI {
+    fft(data: number[]): {
+        real: number[];
+        imag: number[];
+    };
+    mean(data: number[]): number;
+    standardDeviation(data: number[]): number;
+    correlation(x: number[], y: number[]): number;
+}
+export interface ModelLoadedEvent {
+    modelId: string;
+    config: ModelConfig;
+}
+export interface PredictionEvent {
+    modelId: string;
+    input: PredictionInput;
+    result: PredictionResult;
+}
+export interface ModelErrorEvent {
+    modelId: string;
+    error: string;
+}

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

@@ -0,0 +1,6 @@
+/**
+ * @fileoverview Offscreen plugin exports
+ * @module plugins/offscreen
+ */
+export { PluginOffscreen, default } from './index';
+export type { PluginOffscreenConfig, OffscreenAPI, OffscreenStats, OffscreenMode, OffscreenTransferMode, OffscreenFallbackMode, } from './types';

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

@@ -0,0 +1,6 @@
+import { PluginOffscreenConfig } from './types';
+import { ChartPlugin } from '../types';
+
+export declare function PluginOffscreen(userConfig?: Partial<PluginOffscreenConfig>): ChartPlugin<PluginOffscreenConfig>;
+export default PluginOffscreen;
+export type { PluginOffscreenConfig, OffscreenAPI, OffscreenStats, OffscreenMode, OffscreenTransferMode, OffscreenFallbackMode, } from './types';