velo-plot 1.11.1

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

@@ -0,0 +1,336 @@
+import { ChartOptions, AxisOptions, SeriesOptions, HeatmapOptions, SeriesUpdateData, ZoomOptions, CursorOptions, ChartEventMap, Bounds } from '../../types';
+import { EventEmitter } from '../EventEmitter';
+import { Series } from '../Series';
+import { Scale } from '../../scales';
+import { ChartTheme, ColorScheme } from '../../theme';
+import { Annotation } from '../annotations';
+import { SelectedPoint, SelectionMode, HitTestResult, SelectionConfig } from '../selection';
+import { ResponsiveConfig, ResponsiveState } from '../responsive';
+import { ChartState, SerializeOptions, DeserializeOptions } from '../../serialization';
+import { Chart, ExportOptions } from './types';
+import { ChartAnimationConfig } from '../animation';
+
+export declare class ChartImpl implements Chart {
+    private container;
+    private webglCanvas;
+    private overlayCanvas;
+    private overlayCtx;
+    series: Map<string, Series>;
+    events: EventEmitter<ChartEventMap>;
+    private viewBounds;
+    private xAxisOptions;
+    private yAxisOptionsMap;
+    private primaryYAxisId;
+    private dpr;
+    private backgroundColor;
+    private plotAreaBackground;
+    private renderer;
+    private overlay;
+    private interaction;
+    private xScale;
+    private yScales;
+    private get yScale();
+    theme: ChartTheme;
+    baseTheme: ChartTheme;
+    private colorScheme;
+    private cursorOptions;
+    private cursorPosition;
+    private showLegend;
+    private legend;
+    private originalSeriesStyles;
+    private hoveredSeriesId;
+    private showControls;
+    private toolbarOptions?;
+    private controls;
+    private layout;
+    private _isDestroyed;
+    private autoScroll;
+    private showStatistics;
+    private initQueueId;
+    private commandQueue;
+    private annotationQueue;
+    private annotationIdCounter;
+    private tooltipConfigQueue;
+    private fitLineQueue;
+    /** Whether the chart has been destroyed */
+    get isDestroyed(): boolean;
+    private selectionRect;
+    private pluginManager;
+    private initialOptions;
+    private pluginBridge;
+    private axisManager;
+    private stateManager;
+    private renderLoop;
+    setXScale(scale: Scale): void;
+    setYScale(yAxisId: string, scale: Scale): void;
+    get analysis(): any;
+    get tooltip(): any;
+    get loading(): any;
+    get deltaTool(): any;
+    get peakTool(): any;
+    get regression(): any;
+    get radar(): any;
+    get ml(): any;
+    get snapshot(): any;
+    get dataExport(): any;
+    get roi(): any;
+    get videoRecorder(): any;
+    get offscreen(): any;
+    get virtualization(): any;
+    get themeEditor(): any;
+    get sync(): any;
+    get brokenAxis(): any;
+    get forecasting(): any;
+    get latex(): any;
+    private animationEngine;
+    private animationConfig;
+    get animations(): ChartAnimationConfig;
+    private selectionManager;
+    private responsiveManager;
+    constructor(options: ChartOptions);
+    /**
+     * Start the chart initialization (called by queue system)
+     * This performs the actual render startup that was deferred from constructor
+     */
+    startInit(): void;
+    /**
+     * Mark this chart's initialization as complete in the queue
+     */
+    completeInit(): Promise<void>;
+    private executeOrQueue;
+    /**
+     * Set the initialization queue ID (internal use)
+     */
+    setInitQueueId(id: string): void;
+    private initControls;
+    private toggleLegend;
+    private initLegend;
+    setTheme(theme: string | ChartTheme): void;
+    /**
+     * Set the color scheme for multi-series charts
+     * @param scheme - Color scheme name ('vibrant', 'pastel', 'neon', 'earth', 'ocean') or ColorScheme object
+     */
+    setColorScheme(scheme: string | ColorScheme): void;
+    /**
+     * Get the current color scheme
+     */
+    getColorScheme(): ColorScheme;
+    getPlotArea(): {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    private getInteractedBounds;
+    exportImage(type?: "png" | "jpeg"): string;
+    private getSeriesContext;
+    addSeries(options: SeriesOptions | HeatmapOptions): void;
+    addBar(options: Omit<SeriesOptions, "type">): void;
+    addHeatmap(options: HeatmapOptions): void;
+    removeSeries(id: string): void;
+    updateSeries(id: string, data: SeriesUpdateData): void;
+    appendData(id: string, x: number[] | Float32Array, y: number[] | Float32Array): void;
+    setAutoScroll(enabled: boolean): void;
+    setMaxPoints(id: string, maxPoints: number): void;
+    /**
+     * Add a line of best fit to a series
+     */
+    addFitLine(seriesId: string, type: any, options?: any): string;
+    getSeries(id: string): Series | undefined;
+    getAllSeries(): Series[];
+    private getNavContext;
+    private getAnimatedNavContext;
+    zoom(options: ZoomOptions & {
+        animate?: boolean;
+    }): void;
+    pan(deltaX: number, deltaY: number, axisId?: string): void;
+    resetZoom(): void;
+    getViewBounds(): Bounds;
+    autoScale(animate?: boolean): void;
+    /**
+     * Auto-scale only Y-axes (keeps X-axis stable)
+     * Used during streaming to prevent X-axis shifting
+     */
+    autoScaleYOnly(): void;
+    /**
+     * Animate view bounds to specific target
+     */
+    animateTo(options: {
+        xRange?: [number, number];
+        yRange?: [number, number];
+        duration?: number;
+        easing?: string;
+    }): void;
+    /**
+     * Get animation configuration
+     */
+    getAnimationConfig(): ChartAnimationConfig;
+    /**
+     * Set animation configuration
+     */
+    setAnimationConfig(config: Partial<ChartAnimationConfig>): void;
+    /**
+     * Check if animations are currently running
+     */
+    isAnimating(): boolean;
+    private handleBoxZoom;
+    enableCursor(options: CursorOptions): void;
+    disableCursor(): void;
+    addAnnotation(annotation: any): string;
+    removeAnnotation(id: string): boolean;
+    updateAnnotation(id: string, updates: Partial<Annotation>): void;
+    getAnnotation(id: string): Annotation | undefined;
+    getAnnotations(): Annotation[];
+    clearAnnotations(): void;
+    /**
+     * Get a plugin API by name
+     */
+    getPlugin<T = any>(name: string): T | null;
+    getPluginNames(): string[];
+    private getPluginAPI;
+    exportCSV(options?: ExportOptions): string;
+    exportJSON(options?: ExportOptions): string;
+    /**
+     * 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;
+    /**
+     * Get current device pixel ratio
+     */
+    getDPR(): number;
+    /**
+     * Set device pixel ratio and re-render
+     */
+    setDPR(dpr: number): void;
+    /**
+     * Update X axis configuration
+     */
+    updateXAxis(options: Partial<AxisOptions>): void;
+    updateLayout(options: Partial<import('../layout').LayoutOptions>): 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;
+    /**
+     * Select data points programmatically
+     */
+    selectPoints(points: Array<{
+        seriesId: string;
+        indices: number[];
+    }>, mode?: SelectionMode): void;
+    /**
+     * Get all currently selected points
+     */
+    getSelectedPoints(): SelectedPoint[];
+    /**
+     * Clear all selections
+     */
+    clearSelection(): void;
+    /**
+     * Hit-test at a pixel coordinate
+     */
+    hitTest(pixelX: number, pixelY: number): HitTestResult | null;
+    /**
+     * Check if a specific point is selected
+     */
+    isPointSelected(seriesId: string, index: number): boolean;
+    /**
+     * Get selection count
+     */
+    getSelectionCount(): number;
+    /**
+     * Configure selection behavior
+     */
+    configureSelection(config: Partial<SelectionConfig>): 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, 'delta' for measurements
+     */
+    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;
+    /**
+     * Handle responsive state changes
+     */
+    private handleResponsiveChange;
+    /**
+     * Get current responsive state
+     */
+    getResponsiveState(): ResponsiveState;
+    /**
+     * Configure responsive behavior
+     */
+    configureResponsive(config: Partial<ResponsiveConfig>): void;
+    /**
+     * Check if responsive mode is enabled
+     */
+    isResponsiveEnabled(): boolean;
+    /**
+     * 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;
+    use(plugin: any): Promise<void>;
+    resize(): void;
+    requestRender(): void;
+    requestOverlayRender(): void;
+    /**
+     * Trigger an immediate full render (public API compatibility)
+     */
+    render(): void;
+    private pixelToDataX;
+    private pixelToDataY;
+    private startRenderLoop;
+    on<K extends keyof ChartEventMap>(e: K, h: (d: ChartEventMap[K]) => void): void;
+    off<K extends keyof ChartEventMap>(e: K, h: (d: ChartEventMap[K]) => void): void;
+    destroy(): void;
+    private toggleSmoothing;
+    private recalculateTools;
+}
+/**
+ * Create a new chart. Charts are automatically queued for sequential
+ * initialization when multiple charts are created on the same page.
+ */
+export declare function createChart(options: ChartOptions): Chart;

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

@@ -0,0 +1,18 @@
+import { Series } from '../Series';
+import { Bounds } from '../../types';
+import { ExportOptions } from './types';
+
+/**
+ * Export series data to CSV format
+ */
+export declare function exportToCSV(series: Series[], options?: ExportOptions): string;
+/**
+ * Export series data to JSON format
+ */
+export declare function exportToJSON(series: Series[], viewBounds: Bounds, options?: ExportOptions): string;
+/**
+ * Export chart to image
+ */
+export declare function exportToImage(webglCanvas: HTMLCanvasElement, overlayCanvas: HTMLCanvasElement, backgroundColor: [number, number, number, number], legend: {
+    draw: (ctx: CanvasRenderingContext2D, dpr: number) => void;
+} | null, showLegend: boolean, dpr: number, type?: "png" | "jpeg"): string;

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

@@ -0,0 +1,33 @@
+import { Bounds, ZoomOptions, AxisOptions, ChartEventMap } from '../../types';
+import { Scale } from '../../scales';
+import { EventEmitter } from '../EventEmitter';
+
+export interface NavigationContext {
+    viewBounds: Bounds;
+    yScales: Map<string, Scale>;
+    yAxisOptionsMap: Map<string, AxisOptions>;
+    xAxisOptions: AxisOptions;
+    primaryYAxisId: string;
+    getPlotArea: () => {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    events: EventEmitter<ChartEventMap>;
+    requestRender: () => void;
+    series: Map<string, {
+        isVisible(): boolean;
+        getBounds(): Bounds | null;
+        getYAxisId(): string | undefined;
+        getType(): string;
+    }>;
+}
+/**
+ * Apply zoom to the chart
+ */
+export declare function applyZoom(ctx: NavigationContext, options: ZoomOptions): void;
+/**
+ * Apply pan to the chart
+ */
+export declare function applyPan(ctx: NavigationContext, deltaX: number, deltaY: number, axisId?: string): void;

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

@@ -0,0 +1,34 @@
+import { PluginManagerImpl } from '../../plugins';
+
+export declare class ChartPluginBridge {
+    private pluginManager;
+    constructor(pluginManager: PluginManagerImpl);
+    private getAPI;
+    get analysis(): any;
+    get tooltip(): any;
+    get loading(): any;
+    get deltaTool(): any;
+    get peakTool(): any;
+    get regression(): any;
+    get radar(): any;
+    get ml(): any;
+    get snapshot(): any;
+    get dataExport(): any;
+    get roi(): any;
+    get videoRecorder(): any;
+    get offscreen(): any;
+    get virtualization(): any;
+    get themeEditor(): any;
+    get sync(): any;
+    get brokenAxis(): any;
+    get forecasting(): any;
+    get latex(): any;
+    /**
+     * Get a plugin API by name
+     */
+    getPlugin<T = any>(name: string): T | null;
+    /**
+     * Get all plugin names
+     */
+    getPluginNames(): string[];
+}

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

@@ -0,0 +1,100 @@
+import { NativeWebGLRenderer } from '../../renderer/NativeWebGLRenderer';
+import { OverlayRenderer } from '../OverlayRenderer';
+import { Series } from '../Series';
+import { Scale } from '../../scales';
+import { Bounds, AxisOptions, CursorOptions, PlotArea, ChartEventMap } from '../../types';
+import { EventEmitter } from '../EventEmitter';
+import { SelectionManager } from '../selection';
+import { PluginManagerImpl } from '../../plugins';
+
+export interface RenderLoopContext {
+    webglCanvas: HTMLCanvasElement;
+    overlayCanvas: HTMLCanvasElement;
+    overlayCtx: CanvasRenderingContext2D;
+    container: HTMLDivElement;
+    series: Map<string, Series>;
+    viewBounds: Bounds;
+    xScale: Scale;
+    yScales: Map<string, Scale>;
+    yAxisOptionsMap: Map<string, AxisOptions>;
+    xAxisOptions: AxisOptions;
+    primaryYAxisId: string;
+    renderer: NativeWebGLRenderer;
+    overlay: OverlayRenderer;
+    backgroundColor: [number, number, number, number];
+    plotAreaBackground: [number, number, number, number];
+    getCursorOptions: () => CursorOptions | null;
+    getCursorPosition: () => {
+        x: number;
+        y: number;
+    } | null;
+    selectionRect: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    } | null;
+    events: EventEmitter<ChartEventMap>;
+    selectionManager: SelectionManager;
+    getHoveredSeriesId: () => string | null;
+    pluginManager: PluginManagerImpl;
+    getLayout: () => import('../layout').LayoutOptions;
+    getLatex: () => any;
+    updateSeriesBuffer: (s: Series) => void;
+    getPlotArea: () => PlotArea;
+    pixelToDataX: (px: number) => number;
+    pixelToDataY: (py: number, yAxisId?: string) => number;
+    get yScale(): Scale;
+}
+export declare class ChartRenderLoop {
+    private ctx;
+    private animationFrameId;
+    private needsFullRender;
+    private needsOverlayRender;
+    private frameCount;
+    private lastRenderTime;
+    private initStarted;
+    constructor(ctx: RenderLoopContext);
+    /**
+     * Mark that initialization has started
+     */
+    startInit(): void;
+    /**
+     * Check if init has started
+     */
+    isInitStarted(): boolean;
+    /**
+     * Request a full render (WebGL + overlay)
+     */
+    requestRender(): void;
+    /**
+     * Request overlay-only render
+     */
+    requestOverlayRender(): void;
+    /**
+     * Schedule render on next animation frame
+     */
+    private scheduleRenderFrame;
+    /**
+     * Cancel any pending render
+     */
+    cancelPendingRender(): void;
+    /**
+     * Perform the actual rendering
+     */
+    private performRender;
+    /**
+     * Get render statistics
+     */
+    getStats(): {
+        frameCount: number;
+        lastRenderTime: number;
+        hasPendingRender: boolean;
+        needsFullRender: boolean;
+        needsOverlayRender: boolean;
+    };
+    /**
+     * Reset frame counter
+     */
+    resetFrameCount(): void;
+}

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

@@ -0,0 +1,52 @@
+import { Bounds, CursorOptions, AxisOptions, PlotArea, ChartEventMap } from '../../types';
+import { Series } from '../Series';
+import { Scale } from '../../scales';
+import { NativeWebGLRenderer, NativeSeriesRenderData as SeriesRenderData } from '../../renderer/NativeWebGLRenderer';
+import { OverlayRenderer } from '../OverlayRenderer';
+import { EventEmitter } from '../EventEmitter';
+import { SelectionManager } from '../selection';
+
+export interface RenderContext {
+    webglCanvas: HTMLCanvasElement;
+    overlayCanvas: HTMLCanvasElement;
+    overlayCtx: CanvasRenderingContext2D;
+    container: HTMLDivElement;
+    series: Map<string, Series>;
+    viewBounds: Bounds;
+    xScale: Scale;
+    yScales: Map<string, Scale>;
+    yAxisOptionsMap: Map<string, AxisOptions>;
+    xAxisOptions: AxisOptions;
+    primaryYAxisId: string;
+    renderer: NativeWebGLRenderer;
+    overlay: OverlayRenderer;
+    backgroundColor: [number, number, number, number];
+    cursorOptions: CursorOptions | null;
+    cursorPosition: {
+        x: number;
+        y: number;
+    } | null;
+    selectionRect: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    } | null;
+    events: EventEmitter<ChartEventMap>;
+    updateSeriesBuffer: (s: Series) => void;
+    getPlotArea: () => PlotArea;
+    pixelToDataX: (px: number) => number;
+    pixelToDataY: (py: number) => number;
+    selectionManager: SelectionManager;
+    hoveredSeriesId: string | null;
+    layout: import('../layout').LayoutOptions;
+    latexAPI?: any;
+}
+/**
+ * Prepare series data for WebGL rendering
+ */
+export declare function prepareSeriesData(ctx: RenderContext, plotArea: PlotArea): SeriesRenderData[];
+/**
+ * Render overlay elements (axes, grid, annotations, etc.)
+ */
+export declare function renderOverlay(ctx: RenderContext, plotArea: PlotArea, primaryYScale: Scale): void;

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

@@ -0,0 +1,31 @@
+import { NavigationContext } from './ChartNavigation';
+import { ZoomOptions } from '../../types';
+
+/**
+ * Auto-scale all axes to fit data
+ */
+export declare function autoScaleAll(ctx: NavigationContext): void;
+/**
+ * Auto-scale only Y-axes to fit data (keeps X-axis stable)
+ * Used during streaming to prevent X-axis shifting
+ */
+export declare function autoScaleYOnly(ctx: NavigationContext): void;
+/**
+ * Handle box zoom selection
+ */
+export declare function handleBoxZoom(ctx: NavigationContext, selectionRect: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+} | null, currentRect: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+} | null, zoom: (options: ZoomOptions) => void): {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+} | null;

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

@@ -0,0 +1,4 @@
+/**
+ * Chart Series Redirect
+ */
+export * from './series/index';

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

@@ -0,0 +1,67 @@
+import { ChartOptions, AxisOptions } from '../../types';
+import { Scale } from '../../scales';
+import { ChartTheme } from '../../theme';
+import { LayoutOptions } from '../layout';
+
+export interface SetupResult {
+    theme: ChartTheme;
+    backgroundColor: [number, number, number, number];
+    plotAreaColor: [number, number, number, number];
+    showLegend: boolean;
+    showControls: boolean;
+    autoScroll: boolean;
+    showStatistics: boolean;
+    dpr: number;
+    xAxisOptions: AxisOptions;
+    xScale: Scale;
+    yAxisOptionsMap: Map<string, AxisOptions>;
+    yScales: Map<string, Scale>;
+    primaryYAxisId: string;
+    webglCanvas: HTMLCanvasElement;
+    overlayCanvas: HTMLCanvasElement;
+    overlayCtx: CanvasRenderingContext2D;
+    layout: LayoutOptions;
+}
+/**
+ * Initialize chart configuration from options
+ */
+export declare function initializeChart(container: HTMLDivElement, options: ChartOptions): SetupResult;
+/**
+ * Create a canvas element
+ */
+export declare function createCanvas(type: "webgl" | "overlay"): HTMLCanvasElement;
+/**
+ * Calculate the plot area based on container size and margins
+ */
+export declare function getPlotArea(container: HTMLDivElement, yAxisOptionsMap: Map<string, AxisOptions>, layout?: LayoutOptions): {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+/**
+ * Get axes layout for interaction manager
+ */
+export declare function getAxesLayout(yAxisOptionsMap: Map<string, AxisOptions>): Array<{
+    id: string;
+    position: 'left' | 'right';
+    offset: number;
+}>;
+/**
+ * Resize canvases to match container
+ */
+export declare function resizeCanvases(container: HTMLDivElement, webglCanvas: HTMLCanvasElement, overlayCanvas: HTMLCanvasElement, overlayCtx: CanvasRenderingContext2D, dpr: number): boolean;
+export declare function pixelToDataX(px: number, plotArea: {
+    x: number;
+    width: number;
+}, viewBounds: {
+    xMin: number;
+    xMax: number;
+}, invertAxis?: boolean): number;
+export declare function pixelToDataY(py: number, plotArea: {
+    y: number;
+    height: number;
+}, viewBounds: {
+    yMin: number;
+    yMax: number;
+}, invertAxis?: boolean): number;