velo-plot 1.11.1

package/dist/core/selection/SelectionManager.d.ts

@@ -0,0 +1,165 @@
+import { Bounds, PlotArea } from '../../types';
+import { Scale } from '../../scales';
+import { Series } from '../series/Series';
+import { EventEmitter } from '../EventEmitter';
+
+/** Represents a single selected data point */
+export interface SelectedPoint {
+    seriesId: string;
+    index: number;
+    x: number;
+    y: number;
+}
+/** Selection mode for multi-select operations */
+export type SelectionMode = 'single' | 'add' | 'remove' | 'toggle';
+/** Event data for point selection changes */
+export interface PointSelectEvent {
+    points: SelectedPoint[];
+    mode: SelectionMode;
+    source: 'click' | 'box' | 'api';
+}
+/** Event data for region/box selection */
+export interface RegionSelectEvent {
+    bounds: Bounds;
+    containedPoints: SelectedPoint[];
+}
+/** Selection event map */
+export interface SelectionEventMap {
+    pointSelect: PointSelectEvent;
+    regionSelect: RegionSelectEvent;
+    selectionChange: {
+        selected: SelectedPoint[];
+        previous: SelectedPoint[];
+    };
+    selectionClear: undefined;
+}
+/** Hit-test result for a single point */
+export interface HitTestResult {
+    seriesId: string;
+    index: number;
+    x: number;
+    y: number;
+    distance: number;
+    pixelX: number;
+    pixelY: number;
+}
+/** Selection manager configuration */
+export interface SelectionConfig {
+    /** Enable selection (default: true) */
+    enabled?: boolean;
+    /** Maximum distance in pixels for hit-testing (default: 20) */
+    hitRadius?: number;
+    /** Allow multi-selection with Ctrl+click (default: true) */
+    multiSelect?: boolean;
+    /** Enable box selection with Shift+drag (default: true) */
+    boxSelect?: boolean;
+    /** Highlight style for selected points */
+    highlightStyle?: {
+        color?: string;
+        size?: number;
+        ringWidth?: number;
+    };
+}
+/** Context for selection operations */
+export interface SelectionContext {
+    getSeries: () => Map<string, Series>;
+    getPlotArea: () => PlotArea;
+    getXScale: () => Scale;
+    getYScales: () => Map<string, Scale>;
+    getPrimaryYAxisId: () => string;
+    events: EventEmitter<SelectionEventMap>;
+    requestRender: () => void;
+}
+export declare class SelectionManager {
+    private ctx;
+    private config;
+    private selected;
+    private isBoxSelecting;
+    private boxStart;
+    private boxEnd;
+    constructor(ctx: SelectionContext, config?: SelectionConfig);
+    configure(config: Partial<SelectionConfig>): void;
+    getConfig(): SelectionConfig;
+    setEnabled(enabled: boolean): void;
+    isEnabled(): boolean;
+    /**
+     * Hit-test at a pixel coordinate to find the nearest data point
+     */
+    hitTest(pixelX: number, pixelY: number, radius?: number): HitTestResult | null;
+    /**
+     * Hit-test all points within a rectangular region
+     */
+    hitTestRegion(bounds: Bounds): HitTestResult[];
+    /**
+     * Select specific points programmatically
+     */
+    selectPoints(points: Array<{
+        seriesId: string;
+        indices: number[];
+    }>, mode?: SelectionMode): void;
+    /**
+     * Get all currently selected points
+     */
+    getSelectedPoints(): SelectedPoint[];
+    /**
+     * Check if a specific point is selected
+     */
+    isPointSelected(seriesId: string, index: number): boolean;
+    /**
+     * Get selected points for a specific series
+     */
+    getSelectedForSeries(seriesId: string): number[];
+    /**
+     * Clear all selections
+     */
+    clearSelection(): void;
+    /**
+     * Get selection count
+     */
+    getSelectionCount(): number;
+    /**
+     * Handle click event for selection
+     */
+    handleClick(pixelX: number, pixelY: number, ctrlKey: boolean, shiftKey: boolean): void;
+    /**
+     * Start box selection
+     */
+    startBoxSelection(pixelX: number, pixelY: number): void;
+    /**
+     * Update box selection during drag
+     */
+    updateBoxSelection(pixelX: number, pixelY: number): void;
+    /**
+     * Complete box selection
+     */
+    completeBoxSelection(additive?: boolean): void;
+    /**
+     * Cancel box selection
+     */
+    cancelBoxSelection(): void;
+    /**
+     * Check if box selection is active
+     */
+    isBoxSelectActive(): boolean;
+    /**
+     * Get current box selection rectangle (for rendering)
+     */
+    getBoxSelectionRect(): {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    } | null;
+    /**
+     * Render selected point highlights
+     */
+    render(ctx: CanvasRenderingContext2D, plotArea: PlotArea): void;
+    /**
+     * Binary search to find nearest index in sorted array
+     */
+    private findNearestIndex;
+    /**
+     * Destroy the selection manager
+     */
+    destroy(): void;
+}

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

@@ -0,0 +1,4 @@
+/**
+ * Selection module exports
+ */
+export { SelectionManager, type SelectedPoint, type SelectionMode, type PointSelectEvent, type RegionSelectEvent, type SelectionEventMap, type HitTestResult, type SelectionConfig, type SelectionContext, } from './SelectionManager';

package/dist/core/series/Series.d.ts

@@ -0,0 +1,73 @@
+import { SeriesOptions, SeriesData, SeriesStyle, SeriesUpdateData, Bounds, SeriesType, HeatmapOptions, HeatmapData, HeatmapStyle, PolarOptions, PolarData, GaugeOptions, GaugeData, GaugeStyle, SankeyOptions, SankeyData, SankeyStyle } from '../../types';
+
+export declare class Series {
+    private id;
+    private type;
+    private yAxisId?;
+    private data;
+    private style;
+    private visible;
+    private name?;
+    private stackId?;
+    private cycle?;
+    private maxPoints?;
+    bullishCount: number;
+    bearishCount: number;
+    waterfallCounts?: {
+        positive: number;
+        negative: number;
+        subtotal: number;
+        connectors: number;
+    };
+    private heatmapData?;
+    private heatmapStyle?;
+    private polarData?;
+    private gaugeData?;
+    private gaugeStyle?;
+    private sankeyData?;
+    private sankeyStyle?;
+    private lastAppendCount;
+    private cachedBounds;
+    private boundsNeedsUpdate;
+    private _needsBufferUpdate;
+    private smoothedData;
+    private smoothingNeedsUpdate;
+    constructor(options: SeriesOptions | HeatmapOptions | PolarOptions | GaugeOptions | SankeyOptions);
+    getId: () => string;
+    getName: () => string;
+    getType: () => SeriesType;
+    getYAxisId: () => string | undefined;
+    setYAxisId: (id: string) => void;
+    getStackId: () => string | undefined;
+    getVisible: () => boolean;
+    isVisible: () => boolean;
+    getStyle: () => SeriesStyle;
+    getHeatmapData: () => HeatmapData | undefined;
+    getHeatmapStyle: () => HeatmapStyle | undefined;
+    getPolarData: () => PolarData | undefined;
+    getGaugeData: () => GaugeData | undefined;
+    getGaugeStyle: () => GaugeStyle | undefined;
+    getSankeyData: () => SankeyData | undefined;
+    getSankeyStyle: () => SankeyStyle | undefined;
+    getCycle: () => number | undefined;
+    getPointCount: () => number;
+    getLastAppendCount: () => number;
+    resetLastAppendCount: () => void;
+    hasErrorData: () => boolean;
+    getYError: (i: number) => [number, number] | null;
+    getXError: (i: number) => [number, number] | null;
+    getData(): SeriesData;
+    getBounds(): Bounds | null;
+    updateData(update: SeriesUpdateData): void;
+    setStyle(style: Partial<SeriesStyle>): void;
+    setType(type: SeriesType): void;
+    /**
+     * Invalidate buffers - call this after modifying data directly
+     */
+    invalidateBuffers(): void;
+    setVisible(visible: boolean): void;
+    get needsBufferUpdate(): boolean;
+    set needsBufferUpdate(val: boolean);
+    setMaxPoints(maxPoints: number | undefined): void;
+    destroy(): void;
+}

package/dist/core/series/SeriesBounds.d.ts

@@ -0,0 +1,3 @@
+import { SeriesData, Bounds, SeriesType, HeatmapData, PolarData } from '../../types';
+
+export declare function calculateSeriesBounds(type: SeriesType, data: SeriesData, heatmapData?: HeatmapData, polarData?: PolarData): Bounds;

package/dist/core/series/SeriesDataUtils.d.ts

@@ -0,0 +1,7 @@
+import { SeriesData } from '../../types';
+
+export declare function ensureTypedArray(data: Float32Array | Float64Array | number[] | undefined): Float32Array | Float64Array;
+export declare function appendTypedArray(existing: Float32Array | Float64Array, newData: Float32Array | Float64Array): Float32Array | Float64Array;
+export declare function applySmoothing(data: SeriesData, windowSize: number): SeriesData;
+export declare function getYError(data: SeriesData, i: number): [number, number] | null;
+export declare function getXError(data: SeriesData, i: number): [number, number] | null;

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

@@ -0,0 +1,6 @@
+/**
+ * Series Barrel Export
+ */
+export * from './Series';
+export * from './SeriesBounds';
+export * from './SeriesDataUtils';

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

@@ -0,0 +1,147 @@
+import { Bounds, Range } from '../../types';
+
+export type SyncAxis = 'x' | 'y' | 'xy' | 'none';
+export interface SyncOptions {
+    /** Synchronize axis (default: 'x') */
+    axis?: SyncAxis;
+    /** Synchronize cursor position (default: true) */
+    syncCursor?: boolean;
+    /** Synchronize selection state (default: false) */
+    syncSelection?: boolean;
+    /** Synchronize zoom level (default: true) */
+    syncZoom?: boolean;
+    /** Synchronize pan (default: true) */
+    syncPan?: boolean;
+    /** Debounce time for sync events in ms (default: 0) */
+    debounce?: number;
+    /** Enable bidirectional sync (default: true) */
+    bidirectional?: boolean;
+}
+export interface ChartLike {
+    /** Unique identifier for the chart */
+    getId(): string;
+    /** Get current view bounds */
+    getViewBounds(): Bounds;
+    /** Set view bounds (zoom) */
+    zoom(options: {
+        x?: Range;
+        y?: Range;
+        animate?: boolean;
+    }): void;
+    /** Pan the chart */
+    pan(dx: number, dy: number): void;
+    /** Get cursor position */
+    getCursorPosition?(): {
+        x: number;
+        y: number;
+    } | null;
+    /** Set external cursor position */
+    setExternalCursor?(x: number, y: number): void;
+    /** Clear external cursor */
+    clearExternalCursor?(): void;
+    /** Get selected points */
+    getSelectedPoints?(): {
+        seriesId: string;
+        indices: number[];
+    }[];
+    /** Set selection */
+    selectPoints?(points: {
+        seriesId: string;
+        indices: number[];
+    }[]): void;
+    /** Clear selection */
+    clearSelection?(): void;
+    /** Subscribe to events */
+    on(event: string, callback: (...args: unknown[]) => void): void;
+    /** Unsubscribe from events */
+    off(event: string, callback: (...args: unknown[]) => void): void;
+}
+export interface SyncEvent {
+    /** Source chart ID */
+    sourceId: string;
+    /** Event type */
+    type: 'zoom' | 'pan' | 'cursor' | 'selection' | 'bounds';
+    /** Event data */
+    data: unknown;
+}
+export declare class ChartGroup {
+    private charts;
+    private options;
+    private eventHandlers;
+    private isUpdating;
+    private debounceTimers;
+    constructor(options?: SyncOptions);
+    /**
+     * Add a chart to the group
+     */
+    add(chart: ChartLike): this;
+    /**
+     * Add multiple charts at once
+     */
+    addAll(...charts: ChartLike[]): this;
+    /**
+     * Remove a chart from the group
+     */
+    remove(chart: ChartLike): this;
+    /**
+     * Get all charts in the group
+     */
+    getCharts(): ChartLike[];
+    /**
+     * Get chart count
+     */
+    size(): number;
+    /**
+     * Check if a chart is in the group
+     */
+    has(chart: ChartLike): boolean;
+    /**
+     * Set synchronization axis
+     */
+    syncAxis(axis: SyncAxis): this;
+    /**
+     * Enable/disable cursor synchronization
+     */
+    syncCursor(enabled: boolean): this;
+    /**
+     * Enable/disable selection synchronization
+     */
+    syncSelection(enabled: boolean): this;
+    /**
+     * Synchronize all charts to a specific view
+     */
+    syncTo(bounds: Partial<Bounds>, excludeChartId?: string): void;
+    /**
+     * Reset all charts to auto-scale
+     */
+    resetAll(): void;
+    /**
+     * Clear all selections in the group
+     */
+    clearAllSelections(): void;
+    /**
+     * Destroy the group and cleanup
+     */
+    destroy(): void;
+    private attachEventHandlers;
+    private detachEventHandlers;
+    private handleZoom;
+    private handlePan;
+    private handleCursor;
+    private handleSelection;
+    private propagateZoom;
+    private propagatePan;
+    private debounceAction;
+}
+/**
+ * Create a chart group with specified charts
+ */
+export declare function createChartGroup(charts: ChartLike[], options?: SyncOptions): ChartGroup;
+/**
+ * Link two charts for synchronized viewing
+ */
+export declare function linkCharts(chart1: ChartLike, chart2: ChartLike, options?: SyncOptions): ChartGroup;
+/**
+ * Create a master-slave relationship (master controls slave)
+ */
+export declare function createMasterSlave(master: ChartLike, slave: ChartLike, axis?: SyncAxis): ChartGroup;

package/dist/core/theme-editor/index.d.ts

@@ -0,0 +1,122 @@
+/**
+ * Sci Plot - Theme Editor Module
+ *
+ * Provides a visual theme editor for customizing chart appearance:
+ * - Color pickers for all theme elements
+ * - Live preview
+ * - Theme export/import
+ * - Preset theme gallery
+ *
+ * @module theme-editor
+ */
+export type EditorTheme = Record<string, unknown>;
+export interface ThemeEditorOptions {
+    /** Base theme to start from */
+    baseTheme?: EditorTheme | string;
+    /** Enable live preview (default: true) */
+    livePreview?: boolean;
+    /** Show advanced options (default: false) */
+    showAdvanced?: boolean;
+    /** Custom CSS class for the editor */
+    className?: string;
+    /** Callback when theme changes */
+    onChange?: (theme: EditorTheme) => void;
+    /** Callback when export is requested */
+    onExport?: (theme: EditorTheme, json: string) => void;
+}
+export interface ThemePreset {
+    /** Preset name */
+    name: string;
+    /** Description */
+    description?: string;
+    /** Theme configuration */
+    theme: EditorTheme;
+    /** Preview colors (for UI) */
+    previewColors?: string[];
+    /** Tags for filtering */
+    tags?: string[];
+}
+export interface ColorGroup {
+    /** Group label */
+    label: string;
+    /** Group description */
+    description?: string;
+    /** Color properties in this group */
+    colors: ColorProperty[];
+}
+export interface ColorProperty {
+    /** Property key path (e.g., 'background', 'axis.color') */
+    key: string;
+    /** Display label */
+    label: string;
+    /** Description/tooltip */
+    description?: string;
+    /** Current value */
+    value: string;
+    /** Default value */
+    defaultValue?: string;
+}
+export declare const THEME_PRESETS: ThemePreset[];
+export declare class ThemeEditor {
+    private container;
+    private options;
+    private currentTheme;
+    private element;
+    constructor(container: HTMLElement, options?: ThemeEditorOptions);
+    /**
+     * Get current theme
+     */
+    getTheme(): EditorTheme;
+    /**
+     * Set theme
+     */
+    setTheme(theme: EditorTheme | string): void;
+    /**
+     * Update a specific theme property
+     */
+    updateProperty(key: string, value: string): void;
+    /**
+     * Export theme as JSON
+     */
+    exportTheme(): string;
+    /**
+     * Import theme from JSON
+     */
+    importTheme(json: string): void;
+    /**
+     * Get theme preset by name
+     */
+    getPreset(name: string): ThemePreset | undefined;
+    /**
+     * Apply a preset
+     */
+    applyPreset(name: string): void;
+    /**
+     * Get all available presets
+     */
+    getPresets(): ThemePreset[];
+    /**
+     * Destroy the editor
+     */
+    destroy(): void;
+    private resolveTheme;
+    private setNestedValue;
+    private getNestedValue;
+    private notifyChange;
+    private render;
+    private generateHTML;
+    private normalizeColor;
+    private attachEventListeners;
+}
+/**
+ * Create a theme editor instance
+ */
+export declare function createThemeEditor(container: HTMLElement, options?: ThemeEditorOptions): ThemeEditor;
+/**
+ * Get a preset theme by name
+ */
+export declare function getPresetTheme(name: string): EditorTheme | undefined;
+/**
+ * Get all preset names
+ */
+export declare function getPresetNames(): string[];

package/dist/examples/PluginDemonstration.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Sci Plot - Plugin Demonstration Examples
+ *
+ * This file contains 3 comprehensive examples of how to use the mới modular plugin architecture.
+ */
+/**
+ * Demonstrates how to combine the Debug plugin for performance metrics
+ * and the Analysis plugin for real-time signal processing.
+ */
+export declare function examplePerformanceAndAnalysis(container: HTMLDivElement): Promise<import('..').Chart>;
+/**
+ * Demonstrates the Streaming plugin capabilities, including WebSocket
+ * integration and backpressure management for high-frequency data.
+ */
+export declare function exampleAdvancedStreaming(container: HTMLDivElement): Promise<import('..').Chart>;
+/**
+ * Demonstrates how to use the i18n plugin for multiple languages
+ * and the ThemeEditor for visual customization.
+ */
+export declare function exampleCustomization(container: HTMLDivElement): Promise<import('..').Chart>;

package/dist/examples.d.ts

@@ -0,0 +1,25 @@
+import { createChart } from './index';
+
+/**
+ * Example: Basic CV Plot
+ */
+export declare function exampleBasicCV(): import('./index.core').Chart;
+/**
+ * Example: FFT of sine, square, and mixed waves
+ */
+export declare function exampleFFTWaveforms(target?: HTMLDivElement): {
+    destroy(): void;
+};
+/**
+ * Example: Streaming data (real-time)
+ */
+export declare function exampleStreaming(): () => void;
+/**
+ * Example: Multi-cycle CV with cycle detection
+ */
+export declare function exampleMultiCycle(): import('./index.core').Chart;
+/**
+ * Example: Zoom controls
+ */
+export declare function exampleZoomControls(chart: ReturnType<typeof createChart>): void;
+export { createChart };