velo-plot 1.11.1

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

@@ -0,0 +1,54 @@
+import { Annotation } from '../annotations';
+import { Series } from '../Series';
+import { AxisOptions } from '../../types';
+import { Scale } from '../../scales';
+import { PluginManagerImpl } from '../../plugins';
+import { ChartState, SerializeOptions, DeserializeOptions } from '../../serialization';
+
+export interface StateManagerContext {
+    viewBounds: {
+        xMin: number;
+        xMax: number;
+        yMin: number;
+        yMax: number;
+    };
+    xAxisOptions: AxisOptions;
+    xScale: Scale;
+    yAxisOptionsMap: Map<string, AxisOptions>;
+    yScales: Map<string, Scale>;
+    primaryYAxisId: string;
+    series: Map<string, Series>;
+    pluginManager: PluginManagerImpl;
+    showLegend: boolean;
+    showControls: boolean;
+    showStatistics: boolean;
+    autoScroll: boolean;
+    getAnnotations: () => Annotation[];
+    clearAnnotations: () => void;
+    addAnnotation: (annotation: Annotation) => void;
+    updateXAxis: (options: Partial<AxisOptions>) => void;
+    updateYAxis: (id: string, options: Partial<AxisOptions>) => void;
+    removeSeries: (id: string) => void;
+    addSeries: (options: any) => void;
+    requestRender: () => void;
+}
+export declare class ChartStateManager {
+    private ctx;
+    constructor(ctx: StateManagerContext);
+    /**
+     * Export complete chart state
+     */
+    serialize(options?: SerializeOptions): ChartState;
+    /**
+     * Restore chart from saved state
+     */
+    deserialize(state: ChartState, options?: DeserializeOptions): void;
+    /**
+     * Convert current state to URL-safe hash
+     */
+    toUrlHash(compress?: boolean): string;
+    /**
+     * Load state from URL hash
+     */
+    fromUrlHash(hash: string, compressed?: boolean): void;
+}

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

@@ -0,0 +1,40 @@
+import { ChartControls } from '../ChartControls';
+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;
+    theme: ChartTheme;
+    showControls: boolean;
+    toolbar?: import('../../types').ToolbarOptions;
+    showLegend: boolean;
+    /** Legend behavior options */
+    legendOptions?: {
+        highlightOnHover?: boolean;
+        bringToFrontOnHover?: boolean;
+    };
+    series: Map<string, Series>;
+    autoScale: () => void;
+    resetZoom: () => void;
+    requestRender: () => void;
+    exportImage: () => string;
+    setPanMode: (active: boolean) => void;
+    setMode: (mode: InteractionMode) => void;
+    onLegendMove: (x: number, y: number) => void;
+    onToggleSmoothing: () => void;
+    toggleLegend: () => void;
+    onInteractionStart?: () => void;
+    onInteractionEnd?: () => void;
+    onHoverStart?: () => void;
+    onHoverEnd?: () => void;
+    /** @param highlightColor - Whether to apply color highlighting */
+    onSeriesHoverStart?: (series: Series, highlightColor: boolean) => void;
+    /** @param highlightColor - Whether color highlighting was applied */
+    onSeriesHoverEnd?: (series: Series, highlightColor: boolean) => void;
+    onToggleVisibility?: (series: Series) => void;
+}
+export declare function initControls(ctx: UIContext): ChartControls | null;
+export declare function initLegend(ctx: UIContext, options: ChartOptions): ChartLegend | null;

package/dist/core/chart/exporter/SVGExporter.d.ts

@@ -0,0 +1,6 @@
+import { Series } from '../../Series';
+import { Bounds, PlotArea } from '../../../types';
+import { Scale } from '../../../scales';
+import { ChartTheme } from '../../../theme';
+
+export declare function exportToSVG(series: Series[], _viewBounds: Bounds, plotArea: PlotArea, xAxis: Scale, yAxes: Map<string, Scale>, theme: ChartTheme, width: number, height: number): string;

package/dist/core/chart/exporter/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Chart Exporter Modular Logic
+ */
+export * from '../ChartExporter';
+export * from './SVGExporter';

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

@@ -0,0 +1,14 @@
+/**
+ * Chart barrel export
+ *
+ * Re-exports all chart submodules for clean imports.
+ */
+export type { Chart, ExportOptions } from './types';
+export { MARGINS } from './types';
+export { exportToCSV, exportToJSON, exportToImage } from './ChartExporter';
+export { applyZoom, applyPan, } from './ChartNavigation';
+export { autoScaleAll, autoScaleYOnly, handleBoxZoom } from './ChartScaling';
+export type { NavigationContext } from './ChartNavigation';
+export { prepareSeriesData, renderOverlay } from './ChartRenderer';
+export type { RenderContext } from './ChartRenderer';
+export { ChartImpl, createChart } from './ChartCore';

package/dist/core/chart/series/SeriesActions.d.ts

@@ -0,0 +1,7 @@
+import { SeriesOptions, HeatmapOptions, SeriesUpdateData } from '../../../types';
+
+export declare function addSeries(ctx: any, options: SeriesOptions | HeatmapOptions): void;
+export declare function removeSeries(ctx: any, id: string): void;
+export declare function updateSeries(ctx: any, id: string, data: SeriesUpdateData): void;
+export declare function appendData(ctx: any, id: string, x: number[] | Float32Array, y: number[] | Float32Array): void;
+export declare function setMaxPoints(ctx: any, id: string, maxPoints: number): void;

package/dist/core/chart/series/SeriesBuffer.d.ts

@@ -0,0 +1,4 @@
+import { Series } from '../../Series';
+
+export declare function updateSeriesBuffer(ctx: any, s: Series): void;
+export declare function refreshStack(ctx: any, stackId: string): void;

package/dist/core/chart/series/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Chart Series Barrel Export
+ */
+export * from './SeriesActions';
+export * from './SeriesBuffer';
+export * from './types';

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

@@ -0,0 +1,22 @@
+import { Series } from '../../Series';
+import { NativeWebGLRenderer } from '../../../renderer';
+import { Bounds } from '../../../types';
+import { Annotation } from '../../annotations';
+
+export interface SeriesManagerContext {
+    series: Map<string, Series>;
+    renderer: NativeWebGLRenderer;
+    viewBounds: Bounds;
+    autoScale: () => void;
+    requestRender: () => void;
+    addAnnotation: (annotation: Annotation) => string;
+    xAxisOptions: {
+        auto?: boolean;
+    };
+    yAxisOptionsMap: Map<string, {
+        auto?: boolean;
+    }>;
+    autoScrollEnabled: boolean;
+    updateLegend?: () => void;
+    addSeries: (options: any) => void;
+}

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

@@ -0,0 +1,188 @@
+import { SeriesOptions, HeatmapOptions, SeriesUpdateData, ZoomOptions, CursorOptions, ChartEventMap, Bounds, AxisOptions } from '../../types';
+import { Series } from '../Series';
+import { Annotation } from '../annotations';
+import { ChartAnimationConfig } from '../animation';
+import { EventEmitter } from '../EventEmitter';
+import { ChartPlugin } from '../../plugins/types';
+
+export interface Chart {
+    readonly events: EventEmitter<ChartEventMap>;
+    addSeries(options: SeriesOptions | HeatmapOptions): void;
+    addBar(options: Omit<SeriesOptions, "type">): void;
+    addHeatmap(options: Omit<HeatmapOptions, "type">): void;
+    removeSeries(id: string): void;
+    updateSeries(id: string, data: SeriesUpdateData): void;
+    getSeries(id: string): Series | undefined;
+    getAllSeries(): Series[];
+    appendData(id: string, x: number[] | Float32Array, y: number[] | Float32Array): void;
+    setAutoScroll(enabled: boolean): void;
+    setMaxPoints(id: string, maxPoints: number): void;
+    addFitLine(seriesId: string, type: any, options?: any): string;
+    zoom(options: ZoomOptions & {
+        animate?: boolean;
+    }): void;
+    pan(deltaX: number, deltaY: number): void;
+    resetZoom(): void;
+    getViewBounds(): Bounds;
+    enableCursor(options: CursorOptions): void;
+    disableCursor(): void;
+    resize(width?: number, height?: number): void;
+    /** Get current device pixel ratio used for rendering */
+    getDPR(): number;
+    /** Set device pixel ratio and trigger re-render */
+    setDPR(dpr: number): void;
+    render(): void;
+    on<K extends keyof ChartEventMap>(event: K, handler: (data: ChartEventMap[K]) => void): void;
+    off<K extends keyof ChartEventMap>(event: K, handler: (data: ChartEventMap[K]) => void): void;
+    destroy(): void;
+    exportImage(type?: "png" | "jpeg"): string;
+    autoScale(animate?: boolean): void;
+    setTheme(theme: string | object): void;
+    /** Access to data analysis utilities */
+    /** Access to the current active theme (scaled for responsiveness) */
+    readonly theme: any;
+    /** Access to the base theme (unscaled) */
+    readonly baseTheme: any;
+    readonly analysis: any;
+    readonly animations: any;
+    readonly regression: any;
+    readonly radar: any;
+    readonly ml: any;
+    readonly snapshot: any;
+    readonly dataExport: any;
+    readonly roi: any;
+    readonly videoRecorder: any;
+    readonly offscreen: any;
+    readonly virtualization: any;
+    readonly themeEditor: any;
+    readonly sync: any;
+    readonly brokenAxis: any;
+    readonly forecasting: any;
+    addAnnotation(annotation: Annotation): string;
+    removeAnnotation(id: string): boolean;
+    updateAnnotation(id: string, updates: Partial<Annotation>): void;
+    getAnnotation(id: string): Annotation | undefined;
+    getAnnotations(): Annotation[];
+    clearAnnotations(): void;
+    exportCSV(options?: ExportOptions): string;
+    exportJSON(options?: ExportOptions): string;
+    /** Attach a plugin to extend chart functionality */
+    use(plugin: ChartPlugin): void;
+    /** Access to the tooltip system if the plugin is loaded */
+    readonly tooltip?: any;
+    /** Animate view bounds to specific target */
+    animateTo(options: {
+        xRange?: [number, number];
+        yRange?: [number, number];
+        duration?: number;
+        easing?: string;
+    }): void;
+    /** Get current animation configuration */
+    getAnimationConfig(): ChartAnimationConfig;
+    /** Update animation configuration */
+    setAnimationConfig(config: Partial<ChartAnimationConfig>): void;
+    /** Check if any animations are currently running */
+    isAnimating(): boolean;
+    /** Add a new Y axis dynamically */
+    addYAxis(options: AxisOptions): string;
+    /** Remove a Y axis by ID */
+    removeYAxis(id: string): boolean;
+    /** Update Y axis configuration */
+    updateYAxis(id: string, options: Partial<AxisOptions>): void;
+    /** Update X axis configuration */
+    updateXAxis(options: Partial<AxisOptions>): void;
+    /** Get Y axis configuration by ID */
+    getYAxis(id: string): AxisOptions | undefined;
+    /** Get all Y axes configurations */
+    getAllYAxes(): AxisOptions[];
+    /** Get the primary Y axis ID */
+    getPrimaryYAxisId(): string;
+    /** Update unified layout configuration */
+    updateLayout(options: Partial<import('../layout').LayoutOptions>): void;
+    /** Select data points programmatically */
+    selectPoints(points: Array<{
+        seriesId: string;
+        indices: number[];
+    }>, mode?: any): void;
+    /** Get all currently selected points */
+    getSelectedPoints(): any[];
+    /** Clear all selections */
+    clearSelection(): void;
+    /** Hit-test at a pixel coordinate */
+    hitTest(pixelX: number, pixelY: number): any | null;
+    /** Check if a specific point is selected */
+    isPointSelected(seriesId: string, index: number): boolean;
+    /** Get selection count */
+    getSelectionCount(): number;
+    /** Configure selection behavior */
+    configureSelection(config: any): 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' | 'delta' | 'peak'): void;
+    /**
+     * Get the current interaction mode
+     */
+    getMode(): 'pan' | 'boxZoom' | 'select' | 'delta' | 'peak';
+    /**
+     * Get the Delta Tool instance for advanced measurements
+     */
+    getDeltaTool(): any | null;
+    /**
+     * Get the Peak Tool instance for peak integration
+     */
+    getPeakTool(): any | null;
+    /**
+     * Get a plugin API by name
+     */
+    getPlugin<T = any>(name: string): T | null;
+    /**
+     * Get names of all registered plugins
+     */
+    getPluginNames(): string[];
+    /** Get current responsive state */
+    getResponsiveState(): import('../responsive').ResponsiveState;
+    /** Configure responsive behavior */
+    configureResponsive(config: Partial<import('../responsive').ResponsiveConfig>): void;
+    /** Check if responsive mode is enabled */
+    isResponsiveEnabled(): boolean;
+    /** Export complete chart state */
+    serialize(options?: import('../../serialization').SerializeOptions): import('../../serialization').ChartState;
+    /** Restore chart from saved state */
+    deserialize(state: import('../../serialization').ChartState, options?: import('../../serialization').DeserializeOptions): void;
+    /** Convert current state to URL-safe hash */
+    toUrlHash(compress?: boolean): string;
+    /** Load state from URL hash */
+    fromUrlHash(hash: string, compressed?: boolean): void;
+    /** Set custom scales (e.g. for Broken Axis support) */
+    setXScale(scale: any): void;
+    setYScale(yAxisId: string, scale: any): void;
+    /** Use a plugin */
+    use(plugin: ChartPlugin | any): Promise<void>;
+    /** Destroy the chart and cleanup resources */
+    destroy(): void;
+}
+export type { ChartPlugin };
+/** Options for data export */
+export interface ExportOptions {
+    /** Series IDs to export (default: all) */
+    seriesIds?: string[];
+    /** Include headers in CSV (default: true) */
+    includeHeaders?: boolean;
+    /** Decimal precision (default: 6) */
+    precision?: number;
+    /** CSV delimiter (default: ',') */
+    delimiter?: string;
+}
+export declare const MARGINS: {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+};

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

@@ -0,0 +1,137 @@
+/**
+ * Sci Plot - 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 @@
+/**
+ * Sci Plot - 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/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Core module exports
+ */
+export { createChart, type Chart, type ChartOptions, type ExportOptions } from './Chart';
+export { Series } from './Series';
+export { EventEmitter } from './EventEmitter';
+export { OverlayRenderer } from './OverlayRenderer';
+export { InteractionManager, type InteractionMode } from './InteractionManager';
+export * from './annotations';
+export * from './selection';
+export * from './responsive';
+export * from './loading';
+export * from './locale';
+export * from './keybindings';
+export * from './debug';
+export * from './clipboard';
+export * from './sync';