velo-plot 1.11.1

package/dist/renderer/shaders.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Line Vertex Shader
+ *
+ * Transforms 2D points from data space to clip space using uniforms.
+ * This allows zoom/pan without recreating vertex buffers.
+ */
+export declare const lineVertexShader = "\nprecision highp float;\n\n// Attributes (per-vertex data)\nattribute vec2 position;\n\n// Uniforms (constant across all vertices)\nuniform vec2 uScale;       // Zoom factor [scaleX, scaleY]\nuniform vec2 uTranslate;   // Pan offset [translateX, translateY]\nuniform vec2 uResolution;  // Canvas size in pixels\n\n// Varying (passed to fragment shader)\nvarying float vAlpha;\n\nvoid main() {\n  // Transform position: apply scale and translate\n  vec2 pos = position * uScale + uTranslate;\n\n  // pos is now in normalized device coordinates (-1 to 1)\n  gl_Position = vec4(pos, 0.0, 1.0);\n\n  // Pass alpha for potential fading effects\n  vAlpha = 1.0;\n}\n";
+/**
+ * Line Fragment Shader
+ *
+ * Simple solid color output with configurable opacity.
+ */
+export declare const lineFragmentShader = "\nprecision highp float;\n\n// Uniforms\nuniform vec4 uColor;  // RGBA color\n\n// Varying from vertex shader\nvarying float vAlpha;\n\nvoid main() {\n  gl_FragColor = vec4(uColor.rgb, uColor.a * vAlpha);\n}\n";
+/**
+ * Antialiased Line Vertex Shader
+ *
+ * For thick lines with proper antialiasing, we need to expand
+ * lines into quads and compute distance from line center.
+ */
+export declare const lineAAVertexShader = "\nprecision highp float;\n\nattribute vec2 position;\nattribute vec2 normal;     // Perpendicular to line direction\nattribute float miter;     // Miter length for joins\n\nuniform vec2 uScale;\nuniform vec2 uTranslate;\nuniform vec2 uResolution;\nuniform float uLineWidth;\n\nvarying vec2 vNormal;\nvarying float vLineWidth;\n\nvoid main() {\n  // Transform position\n  vec2 pos = position * uScale + uTranslate;\n\n  // Convert to screen space for line width calculation\n  vec2 screenPos = (pos * 0.5 + 0.5) * uResolution;\n\n  // Offset by line width in screen space\n  float halfWidth = uLineWidth * 0.5;\n  screenPos += normal * halfWidth * miter;\n\n  // Convert back to clip space\n  pos = (screenPos / uResolution) * 2.0 - 1.0;\n\n  gl_Position = vec4(pos, 0.0, 1.0);\n\n  vNormal = normal;\n  vLineWidth = uLineWidth;\n}\n";
+/**
+ * Antialiased Line Fragment Shader
+ *
+ * Uses distance-based antialiasing for smooth edges.
+ */
+export declare const lineAAFragmentShader = "\nprecision highp float;\n\nuniform vec4 uColor;\nuniform float uLineWidth;\n\nvarying vec2 vNormal;\nvarying float vLineWidth;\n\nvoid main() {\n  // Distance from line center (0 at center, 1 at edge)\n  float dist = length(vNormal);\n\n  // Smooth step for antialiasing\n  float aa = 1.0 / uLineWidth;\n  float alpha = 1.0 - smoothstep(1.0 - aa, 1.0, dist);\n\n  gl_FragColor = vec4(uColor.rgb, uColor.a * alpha);\n}\n";
+/**
+ * Point/Scatter Vertex Shader
+ *
+ * Renders data points as squares/circles.
+ */
+export declare const pointVertexShader = "\nprecision highp float;\n\nattribute vec2 position;\n\nuniform vec2 uScale;\nuniform vec2 uTranslate;\nuniform float uPointSize;\n\nvoid main() {\n  vec2 pos = position * uScale + uTranslate;\n  gl_Position = vec4(pos, 0.0, 1.0);\n  gl_PointSize = uPointSize;\n}\n";
+/**
+ * Point/Scatter Fragment Shader
+ *
+ * Renders circular points with smooth edges.
+ */
+export declare const pointFragmentShader = "\nprecision highp float;\n\nuniform vec4 uColor;\n\nvoid main() {\n  // Distance from point center\n  vec2 coord = gl_PointCoord - vec2(0.5);\n  float dist = length(coord);\n\n  // Discard outside circle\n  if (dist > 0.5) discard;\n\n  // Smooth edge\n  float alpha = 1.0 - smoothstep(0.4, 0.5, dist);\n\n  gl_FragColor = vec4(uColor.rgb, uColor.a * alpha);\n}\n";
+/**
+ * Heatmap Vertex Shader (for future density plots)
+ */
+export declare const heatmapVertexShader = "\nprecision highp float;\n\nattribute vec2 position;\nattribute float value;\n\nuniform vec2 uScale;\nuniform vec2 uTranslate;\n\nvarying float vValue;\n\nvoid main() {\n  vec2 pos = position * uScale + uTranslate;\n  gl_Position = vec4(pos, 0.0, 1.0);\n  vValue = value;\n}\n";
+/**
+ * Heatmap Fragment Shader
+ *
+ * Maps values to colors using a colormap.
+ */
+export declare const heatmapFragmentShader = "\nprecision highp float;\n\nuniform float uMinValue;\nuniform float uMaxValue;\nuniform sampler2D uColormap;\n\nvarying float vValue;\n\nvoid main() {\n  float normalized = (vValue - uMinValue) / (uMaxValue - uMinValue);\n  normalized = clamp(normalized, 0.0, 1.0);\n\n  vec4 color = texture2D(uColormap, vec2(normalized, 0.5));\n  gl_FragColor = color;\n}\n";
+/**
+ * Bar Chart Vertex Shader
+ *
+ * Renders rectangular bars using quad primitives.
+ */
+export declare const barVertexShader = "\nprecision highp float;\n\n// Attributes\nattribute vec2 position;  // Corner position of bar quad [x, y]\nattribute vec2 barData;   // [barX, barY] - center and height of bar\n\n// Uniforms\nuniform vec2 uScale;\nuniform vec2 uTranslate;\nuniform float uBarWidth;  // Width of bars in data units\n\nvoid main() {\n  // Calculate bar corner in data space\n  float halfWidth = uBarWidth * 0.5;\n  vec2 dataPos = vec2(\n    barData.x + position.x * halfWidth,  // X: center \u00B1 halfWidth\n    position.y * barData.y                // Y: 0 to barY\n  );\n  \n  // Transform to clip space\n  vec2 clipPos = dataPos * uScale + uTranslate;\n  gl_Position = vec4(clipPos, 0.0, 1.0);\n}\n";
+export declare const barFragmentShader = "\nprecision highp float;\n\nuniform vec4 uColor;\n\nvoid main() {\n  gl_FragColor = uColor;\n}\n";
+export declare const Shaders: {
+    line: {
+        vertex: string;
+        fragment: string;
+    };
+    lineAA: {
+        vertex: string;
+        fragment: string;
+    };
+    point: {
+        vertex: string;
+        fragment: string;
+    };
+    bar: {
+        vertex: string;
+        fragment: string;
+    };
+    heatmap: {
+        vertex: string;
+        fragment: string;
+    };
+};

package/dist/renderer/ternary/TernaryRenderer.d.ts

@@ -0,0 +1,39 @@
+import { TernaryData, TernaryOptions, CartesianPoint } from './types';
+
+/**
+ * Convert ternary coordinates (a, b, c) to Cartesian (x, y)
+ *
+ * The triangle is positioned with:
+ * - A (top vertex) at (0.5, sqrt(3)/2)
+ * - B (bottom-left) at (0, 0)
+ * - C (bottom-right) at (1, 0)
+ *
+ * Formula:
+ * x = c + b/2
+ * y = b * sqrt(3)/2
+ */
+export declare function ternaryToCartesian(a: number, b: number, c: number): CartesianPoint;
+/**
+ * Convert arrays of ternary coordinates to Cartesian
+ */
+export declare function convertTernaryData(data: TernaryData): CartesianPoint[];
+/**
+ * Draw ternary grid lines
+ */
+export declare function drawTernaryGrid(ctx: CanvasRenderingContext2D, centerX: number, centerY: number, size: number, divisions?: number, gridColor?: string, gridWidth?: number): void;
+/**
+ * Draw ternary triangle outline
+ */
+export declare function drawTernaryOutline(ctx: CanvasRenderingContext2D, centerX: number, centerY: number, size: number, color?: string, lineWidth?: number): void;
+/**
+ * Draw ternary component labels
+ */
+export declare function drawTernaryLabels(ctx: CanvasRenderingContext2D, centerX: number, centerY: number, size: number, labelA?: string, labelB?: string, labelC?: string, fontSize?: number, color?: string): void;
+/**
+ * Render ternary scatter points
+ */
+export declare function renderTernaryPoints(ctx: CanvasRenderingContext2D, data: TernaryData, centerX: number, centerY: number, size: number, pointSize?: number, color?: string): void;
+/**
+ * Complete ternary plot renderer
+ */
+export declare function renderTernaryPlot(ctx: CanvasRenderingContext2D, data: TernaryData, options?: TernaryOptions): void;

package/dist/renderer/ternary/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @fileoverview Ternary plot renderer exports
+ * @module renderer/ternary
+ */
+export { ternaryToCartesian, convertTernaryData, drawTernaryGrid, drawTernaryOutline, drawTernaryLabels, renderTernaryPoints, renderTernaryPlot, } from './TernaryRenderer';
+export type { TernaryData, TernaryStyle, TernaryOptions, CartesianPoint, } from './types';

package/dist/renderer/ternary/types.d.ts

@@ -0,0 +1,56 @@
+/**
+ * @fileoverview Types for ternary plots
+ * @module renderer/ternary/types
+ */
+/**
+ * Ternary data structure (3 components that sum to 1)
+ */
+export interface TernaryData {
+    /** Component A values (0-1) */
+    a: number[];
+    /** Component B values (0-1) */
+    b: number[];
+    /** Component C values (0-1) */
+    c: number[];
+}
+/**
+ * Ternary plot style options
+ */
+export interface TernaryStyle {
+    /** Point size for scatter mode */
+    pointSize?: number;
+    /** Point color */
+    color?: string;
+    /** Fill opacity for regions */
+    fillOpacity?: number;
+    /** Grid line color */
+    gridColor?: string;
+    /** Grid line width */
+    gridWidth?: number;
+    /** Number of grid divisions */
+    gridDivisions?: number;
+}
+/**
+ * Ternary plot configuration
+ */
+export interface TernaryOptions {
+    /** Label for component A (top vertex) */
+    labelA?: string;
+    /** Label for component B (bottom-left vertex) */
+    labelB?: string;
+    /** Label for component C (bottom-right vertex) */
+    labelC?: string;
+    /** Style options */
+    style?: TernaryStyle;
+    /** Show grid lines */
+    showGrid?: boolean;
+    /** Show labels */
+    showLabels?: boolean;
+}
+/**
+ * Cartesian coordinates (result of ternary → cartesian conversion)
+ */
+export interface CartesianPoint {
+    x: number;
+    y: number;
+}

package/dist/scales/index.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Scale interface and implementations
+ *
+ * Scales transform data values to pixel coordinates and vice versa.
+ */
+export interface Scale {
+    /** Data domain [min, max] */
+    domain: [number, number];
+    /** Pixel range [min, max] */
+    range: [number, number];
+    /** Scale type identifier */
+    type: "linear" | "log";
+    /** Set the domain */
+    setDomain(min: number, max: number): void;
+    /** Set the range */
+    setRange(min: number, max: number): void;
+    /** Transform data value to pixel */
+    transform(value: number): number;
+    /** Transform pixel to data value */
+    invert(pixel: number): number;
+    /** Generate nice tick values */
+    ticks(count?: number): number[];
+}
+/**
+ * Linear scale - proportional mapping
+ */
+export declare class LinearScale implements Scale {
+    domain: [number, number];
+    range: [number, number];
+    readonly type: "linear";
+    setDomain(min: number, max: number): void;
+    setRange(min: number, max: number): void;
+    transform(value: number): number;
+    invert(pixel: number): number;
+    ticks(count?: number): number[];
+}
+/**
+ * Logarithmic scale - for exponential data
+ */
+export declare class LogScale implements Scale {
+    domain: [number, number];
+    range: [number, number];
+    readonly type: "log";
+    private base;
+    setDomain(min: number, max: number): void;
+    setRange(min: number, max: number): void;
+    transform(value: number): number;
+    invert(pixel: number): number;
+    ticks(count?: number): number[];
+}
+/**
+ * Factory function to create scale by type
+ */
+export declare function createScale(type: "linear" | "log"): Scale;

package/dist/serialization/index.d.ts

@@ -0,0 +1,153 @@
+import { Bounds, SeriesType, SeriesStyle } from '../types';
+import { Annotation } from '../core/annotations';
+
+/** Version of the serialization format */
+export declare const SERIALIZATION_VERSION = 1;
+/** Serialized axis configuration */
+export interface SerializedAxis {
+    id: string;
+    position?: 'left' | 'right' | 'top' | 'bottom';
+    label?: string;
+    scale?: 'linear' | 'log';
+    min?: number;
+    max?: number;
+    auto?: boolean;
+    invertAxis?: boolean;
+}
+/** Serialized series data */
+export interface SerializedSeries {
+    id: string;
+    name?: string;
+    type: SeriesType;
+    yAxisId?: string;
+    style?: SeriesStyle;
+    visible?: boolean;
+    /** Data is stored as base64 encoded Float32Array for compactness */
+    data: {
+        x: string;
+        y: string;
+        y2?: string;
+    };
+}
+/** Complete serialized chart state */
+export interface ChartState {
+    /** Serialization format version */
+    version: number;
+    /** Timestamp when state was saved */
+    timestamp: number;
+    /** Current view bounds */
+    viewBounds: Bounds;
+    /** X-axis configuration */
+    xAxis: SerializedAxis;
+    /** Y-axes configurations */
+    yAxes: SerializedAxis[];
+    /** Primary Y axis ID */
+    primaryYAxisId: string;
+    /** Series data and configuration */
+    series: SerializedSeries[];
+    /** Annotations */
+    annotations: Annotation[];
+    /** Active theme name (if applicable) */
+    themeName?: string;
+    options?: {
+        showLegend?: boolean;
+        showControls?: boolean;
+        showStatistics?: boolean;
+        autoScroll?: boolean;
+    };
+    /** Plugin-specific data */
+    plugins?: Record<string, any>;
+}
+/** Options for serialization */
+export interface SerializeOptions {
+    /** Include series data (default: true) */
+    includeData?: boolean;
+    /** Include annotations (default: true) */
+    includeAnnotations?: boolean;
+    /** Compress output (default: false) */
+    compress?: boolean;
+}
+/** Options for deserialization */
+export interface DeserializeOptions {
+    /** Merge with existing state instead of replacing (default: false) */
+    merge?: boolean;
+    /** Skip data loading (default: false) */
+    skipData?: boolean;
+    /** Skip annotations (default: false) */
+    skipAnnotations?: boolean;
+}
+/**
+ * Encode Float32Array to base64 string
+ */
+export declare function encodeFloat32Array(arr: Float32Array | Float64Array): string;
+/**
+ * Decode base64 string to Float32Array
+ */
+export declare function decodeFloat32Array(base64: string): Float32Array;
+/**
+ * Compress string using simple LZ-based compression
+ */
+export declare function compressString(str: string): string;
+/**
+ * Decompress string
+ */
+export declare function decompressString(compressed: string): string;
+/**
+ * Convert chart state to URL-safe hash
+ */
+export declare function stateToUrlHash(state: ChartState, compress?: boolean): string;
+/**
+ * Parse chart state from URL hash
+ */
+export declare function urlHashToState(hash: string, compressed?: boolean): ChartState | null;
+/**
+ * Validate a chart state object
+ */
+export declare function validateChartState(state: unknown): state is ChartState;
+/** State snapshot for undo/redo */
+export interface StateSnapshot {
+    timestamp: number;
+    viewBounds: Bounds;
+    label?: string;
+}
+/**
+ * Simple state history manager for undo/redo
+ */
+export declare class StateHistory {
+    private history;
+    private currentIndex;
+    private maxSize;
+    constructor(maxSize?: number);
+    /**
+     * Push a new state to history
+     */
+    push(snapshot: StateSnapshot): void;
+    /**
+     * Undo to previous state
+     */
+    undo(): StateSnapshot | null;
+    /**
+     * Redo to next state
+     */
+    redo(): StateSnapshot | null;
+    /**
+     * Check if undo is available
+     */
+    canUndo(): boolean;
+    /**
+     * Check if redo is available
+     */
+    canRedo(): boolean;
+    /**
+     * Get current state
+     */
+    current(): StateSnapshot | null;
+    /**
+     * Clear history
+     */
+    clear(): void;
+    /**
+     * Get history length
+     */
+    get length(): number;
+}

package/dist/streaming/backpressure.d.ts

@@ -0,0 +1,179 @@
+import { DataPoint } from './types';
+
+export type OverflowStrategy = 'drop-oldest' | 'drop-newest' | 'pause' | 'sample' | 'block';
+export interface BackpressureConfig {
+    /** Maximum buffer size before triggering backpressure (default: 10000) */
+    maxBuffer: number;
+    /** Warning threshold as fraction of maxBuffer (default: 0.7) */
+    warningThreshold?: number;
+    /** Critical threshold as fraction of maxBuffer (default: 0.9) */
+    criticalThreshold?: number;
+    /** Overflow handling strategy (default: 'drop-oldest') */
+    strategy: OverflowStrategy;
+    /** For 'sample' strategy: keep every Nth point (default: 2) */
+    sampleRate?: number;
+    /** Callback when pressure level changes */
+    onPressure?: (stats: PressureStats) => void;
+    /** Callback when buffer overflows */
+    onOverflow?: (droppedCount: number) => void;
+    /** Callback when back to normal */
+    onRecovery?: () => void;
+}
+export interface PressureStats {
+    /** Current buffer fill level (0-1) */
+    fillLevel: number;
+    /** Pressure state */
+    state: 'normal' | 'warning' | 'critical' | 'overflow';
+    /** Current buffer size */
+    bufferSize: number;
+    /** Maximum buffer size */
+    maxBuffer: number;
+    /** Points dropped due to overflow */
+    droppedCount: number;
+    /** Points sampled/skipped */
+    sampledCount: number;
+    /** Incoming rate (points per second) */
+    incomingRate: number;
+    /** Outgoing rate (points per second) */
+    outgoingRate: number;
+    /** Whether stream is paused due to backpressure */
+    isPaused: boolean;
+}
+export interface BufferHealth {
+    /** Overall health score (0-100) */
+    score: number;
+    /** Health status */
+    status: 'healthy' | 'degraded' | 'critical';
+    /** Recommendations */
+    recommendations: string[];
+}
+export declare class CircularBuffer<T> {
+    private buffer;
+    private head;
+    private tail;
+    private count;
+    private readonly capacity;
+    constructor(capacity: number);
+    /**
+     * Add item to buffer
+     * @returns true if item was added, false if buffer was full
+     */
+    push(item: T): boolean;
+    /**
+     * Add item, overwriting oldest if full
+     * @returns the overwritten item, or undefined
+     */
+    pushOverwrite(item: T): T | undefined;
+    /**
+     * Remove and return oldest item
+     */
+    shift(): T | undefined;
+    /**
+     * Remove and return multiple items
+     */
+    shiftMany(n: number): T[];
+    /**
+     * Peek at oldest item without removing
+     */
+    peek(): T | undefined;
+    /**
+     * Get all items as array
+     */
+    toArray(): T[];
+    /**
+     * Clear the buffer
+     */
+    clear(): void;
+    /**
+     * Get current size
+     */
+    size(): number;
+    /**
+     * Check if buffer is full
+     */
+    isFull(): boolean;
+    /**
+     * Check if buffer is empty
+     */
+    isEmpty(): boolean;
+    /**
+     * Get fill level (0-1)
+     */
+    fillLevel(): number;
+    /**
+     * Get capacity
+     */
+    getCapacity(): number;
+}
+export declare class BackpressureManager {
+    private config;
+    private buffers;
+    private stats;
+    private paused;
+    private sampleCounter;
+    private incomingHistory;
+    private outgoingHistory;
+    private lastRateUpdate;
+    private currentIncoming;
+    private currentOutgoing;
+    constructor(config: BackpressureConfig);
+    /**
+     * Add points to the buffer with backpressure handling
+     */
+    push(seriesId: string, points: DataPoint[]): number;
+    /**
+     * Consume points from buffer
+     */
+    consume(seriesId: string, count?: number): DataPoint[];
+    /**
+     * Consume all points from buffer
+     */
+    consumeAll(seriesId: string): DataPoint[];
+    /**
+     * Get current pressure stats for a series
+     */
+    getPressureStats(seriesId: string): PressureStats;
+    /**
+     * Get aggregate stats for all series
+     */
+    getGlobalStats(): PressureStats;
+    /**
+     * Get buffer health assessment
+     */
+    getHealth(): BufferHealth;
+    /**
+     * Check if paused due to backpressure
+     */
+    isPaused(): boolean;
+    /**
+     * Resume if paused
+     */
+    resume(): void;
+    /**
+     * Clear all buffers
+     */
+    clear(seriesId?: string): void;
+    /**
+     * Update configuration
+     */
+    updateConfig(config: Partial<BackpressureConfig>): void;
+    /**
+     * Get current configuration
+     */
+    getConfig(): BackpressureConfig;
+    private checkPressure;
+    private updateRates;
+    private getAverageRate;
+}
+/**
+ * Create a backpressure manager with default settings
+ */
+export declare function createBackpressureManager(maxBuffer?: number, strategy?: OverflowStrategy): BackpressureManager;
+/**
+ * Create a high-performance backpressure manager optimized for real-time
+ */
+export declare function createRealtimeBackpressure(maxBuffer?: number): BackpressureManager;
+/**
+ * Create a lossless backpressure manager (for when data loss is unacceptable)
+ */
+export declare function createLosslessBackpressure(maxBuffer?: number): BackpressureManager;

package/dist/streaming/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * WebSocket Streaming Barrel Export
+ */
+export * from './types';
+export * from './websocket';
+export * from './utils';
+export * from './mock';

package/dist/streaming/mock.d.ts

@@ -0,0 +1,12 @@
+import { DataPoint, WebSocketStream } from './types';
+
+/**
+ * Mock WebSocket stream for testing
+ */
+export declare function createMockStream(config: {
+    interval?: number;
+    generatePoint?: () => DataPoint;
+}): WebSocketStream & {
+    start: () => void;
+    stop: () => void;
+};

package/dist/streaming/types.d.ts

@@ -0,0 +1,57 @@
+/**
+ * WebSocket Streaming Types
+ */
+export interface WebSocketStreamConfig {
+    /** WebSocket URL */
+    url: string;
+    /** Reconnection attempts (default: 5) */
+    maxReconnectAttempts?: number;
+    /** Delay between reconnection attempts in ms (default: 1000) */
+    reconnectDelay?: number;
+    /** Buffer size before flushing to chart (default: 10) */
+    bufferSize?: number;
+    /** Throttle updates in ms (default: 16 for 60fps) */
+    throttleMs?: number;
+    /** Transform incoming message to data point */
+    parseMessage?: (data: unknown) => DataPoint | DataPoint[] | null;
+    /** Called on connection open */
+    onConnect?: () => void;
+    /** Called on connection close */
+    onDisconnect?: (event: CloseEvent) => void;
+    /** Called on error */
+    onError?: (error: Event) => void;
+    /** Called when reconnecting */
+    onReconnect?: (attempt: number) => void;
+}
+export interface DataPoint {
+    x: number;
+    y: number;
+    seriesId?: string;
+}
+export interface WebSocketStream {
+    /** Connect to the WebSocket server */
+    connect(): void;
+    /** Disconnect from the WebSocket server */
+    disconnect(): void;
+    /** Check if connected */
+    isConnected(): boolean;
+    /** Get connection state */
+    getState(): WebSocketState;
+    /** Subscribe to data for a specific series */
+    subscribe(seriesId: string, callback: (points: DataPoint[]) => void): () => void;
+    /** Unsubscribe all listeners */
+    unsubscribeAll(): void;
+    /** Send a message to the WebSocket server */
+    send(message: unknown): void;
+    /** Get statistics */
+    getStats(): StreamStats;
+}
+export interface StreamStats {
+    messagesReceived: number;
+    pointsProcessed: number;
+    reconnectCount: number;
+    lastMessageTime: number | null;
+    connectionUptime: number;
+    bufferSize: number;
+}
+export type WebSocketState = 'connecting' | 'connected' | 'disconnected' | 'reconnecting' | 'error';

package/dist/streaming/utils.d.ts

@@ -0,0 +1,19 @@
+import { DataPoint, WebSocketStream } from './types';
+
+/**
+ * Default message parser - expects { x, y, seriesId? } or array of same
+ */
+export declare function defaultParser(data: unknown): DataPoint | DataPoint[] | null;
+/**
+ * Helper to create a parser for custom message formats
+ */
+export declare function createMessageParser<T>(transform: (message: T) => DataPoint | DataPoint[] | null): (data: unknown) => DataPoint | DataPoint[] | null;
+/**
+ * Helper to connect a WebSocket stream to a chart
+ */
+export declare function connectStreamToChart(stream: WebSocketStream, chart: {
+    appendData: (seriesId: string, data: {
+        x: Float32Array;
+        y: Float32Array;
+    }) => void;
+}, seriesIds?: string[]): () => void;

package/dist/streaming/websocket.d.ts

@@ -0,0 +1,6 @@
+import { WebSocketStreamConfig, WebSocketStream } from './types';
+
+/**
+ * Create a WebSocket stream for real-time chart data
+ */
+export declare function createWebSocketStream(config: WebSocketStreamConfig): WebSocketStream;