velo-plot 1.11.1

package/dist/plugins/3d/SurfaceMesh3DRenderer.d.ts

@@ -0,0 +1,130 @@
+import { OrbitCamera, OrbitCameraOptions } from './camera/OrbitCamera';
+import { OrbitControllerOptions } from './controls/OrbitController';
+import { Axes3DOptions } from './Axes3D';
+import { Tooltip3DOptions } from './Tooltip3D';
+import { SurfaceMesh3DData } from './series/types';
+import { Renderer3DOptions, RenderStats3D, Renderer3DEventCallback } from './types';
+
+export interface SurfaceMesh3DRendererOptions extends Renderer3DOptions {
+    camera?: OrbitCameraOptions;
+    controls?: OrbitControllerOptions;
+    axes?: Axes3DOptions;
+    showAxes?: boolean;
+    wireframe?: boolean;
+    opacity?: number;
+    enableLighting?: boolean;
+    ambient?: number;
+    lightDirection?: [number, number, number];
+    /** Enable tooltips on hover (default: true) */
+    enableTooltip?: boolean;
+    /** Tooltip configuration */
+    tooltip?: Tooltip3DOptions;
+}
+export declare class SurfaceMesh3DRenderer {
+    private canvas;
+    private gl;
+    private dpr;
+    private programs;
+    private mesh;
+    private camera;
+    private controller;
+    private axes;
+    private backgroundColor;
+    private showAxes;
+    private wireframe;
+    private opacity;
+    private enableLighting;
+    private ambient;
+    private lightDirection;
+    private bounds;
+    private vertexCount;
+    private animationFrameId;
+    private needsRender;
+    private eventListeners;
+    private tooltip;
+    private enableTooltipOption;
+    private meshData;
+    private boundHandleMouseMove;
+    private boundHandleMouseLeave;
+    private lastFrameTime;
+    private frameCount;
+    private fps;
+    private lastFpsUpdate;
+    constructor(options: SurfaceMesh3DRendererOptions);
+    private handleMouseMove;
+    private handleMouseLeave;
+    private handleResize;
+    resize(): void;
+    /**
+     * Set surface mesh data
+     */
+    setData(data: SurfaceMesh3DData): void;
+    private calculateBounds;
+    /**
+     * Fit camera to show all data
+     */
+    fitToData(): void;
+    /**
+     * Render a single frame
+     */
+    render(): void;
+    startRenderLoop(): void;
+    stopRenderLoop(): void;
+    /**
+     * Set wireframe mode
+     */
+    setWireframe(enabled: boolean): void;
+    /**
+     * Set background color
+     */
+    setBackgroundColor(color: [number, number, number, number]): void;
+    /**
+     * Get rendering stats
+     */
+    getStats(): RenderStats3D;
+    /**
+     * Get the camera
+     */
+    getCamera(): OrbitCamera;
+    /**
+     * Get axis labels for 2D text overlay
+     */
+    getAxisLabels(): {
+        text: string;
+        worldPosition: [number, number, number];
+        axis: string;
+        color: [number, number, number];
+    }[];
+    /**
+     * Project world coordinates to screen coordinates
+     */
+    projectToScreen(worldPos: [number, number, number]): {
+        x: number;
+        y: number;
+        visible: boolean;
+    };
+    /**
+     * Get the current view-projection matrix
+     */
+    getViewProjectionMatrix(): Float32Array;
+    /**
+     * Get canvas dimensions
+     */
+    getCanvasSize(): {
+        width: number;
+        height: number;
+    };
+    /**
+     * Add event listener
+     */
+    on(event: string, callback: Renderer3DEventCallback): void;
+    /**
+     * Remove event listener
+     */
+    off(event: string, callback: Renderer3DEventCallback): void;
+    private emitEvent;
+    /**
+     * Clean up all resources
+     */
+    destroy(): void;
+}

package/dist/plugins/3d/Tooltip3D.d.ts

@@ -0,0 +1,71 @@
+/**
+ * 3D Tooltip for displaying information on hover.
+ * Creates a DOM element that follows the mouse and shows data.
+ */
+export interface Tooltip3DOptions {
+    /** CSS class for the tooltip container */
+    className?: string;
+    /** Offset from cursor in pixels */
+    offsetX?: number;
+    offsetY?: number;
+    /** Custom formatter function */
+    formatter?: (data: Tooltip3DData) => string;
+    /** Show position coordinates */
+    showPosition?: boolean;
+    /** Show value/scale */
+    showScale?: boolean;
+    /** Show index */
+    showIndex?: boolean;
+    /** Decimal places for numbers */
+    decimals?: number;
+}
+export interface Tooltip3DData {
+    index: number;
+    position: [number, number, number];
+    color?: [number, number, number];
+    scale?: number;
+    customData?: Record<string, any>;
+}
+export declare class Tooltip3D {
+    private container;
+    private element;
+    private options;
+    private visible;
+    constructor(container: HTMLElement, options?: Tooltip3DOptions);
+    /**
+     * Show tooltip with data at screen position.
+     */
+    show(data: Tooltip3DData, screenX: number, screenY: number): void;
+    /**
+     * Hide the tooltip.
+     */
+    hide(): void;
+    /**
+     * Check if tooltip is visible.
+     */
+    isVisible(): boolean;
+    /**
+     * Default formatting for tooltip content.
+     */
+    private defaultFormat;
+    /**
+     * Update tooltip position (for mouse move without data change).
+     */
+    updatePosition(screenX: number, screenY: number): void;
+    /**
+     * Destroy the tooltip.
+     */
+    destroy(): void;
+}
+/**
+ * Create a hover handler for bubble charts.
+ * Returns a function to attach to mouse move events.
+ */
+export declare function createHoverHandler(renderer: any, // Bubble3DRenderer
+tooltip: Tooltip3D, options?: {
+    debounceMs?: number;
+    onHover?: (hit: {
+        index: number;
+        data: any;
+    } | null) => void;
+}): (event: MouseEvent) => void;

package/dist/plugins/3d/VectorField3DRenderer.d.ts

@@ -0,0 +1,86 @@
+import { OrbitCameraOptions } from './camera/OrbitCamera';
+import { OrbitControllerOptions } from './controls/OrbitController';
+import { Axes3DOptions } from './Axes3D';
+import { Renderer3DOptions, Renderer3DEventCallback } from './types';
+import { CustomThemeOptions } from './colorThemes';
+
+export interface VectorFieldData {
+    /** Origin positions [x0, y0, z0, x1, y1, z1, ...] */
+    positions: Float32Array;
+    /** Direction vectors [dx0, dy0, dz0, dx1, dy1, dz1, ...] */
+    directions: Float32Array;
+    /** Colors per vector [r0, g0, b0, ...] (optional) */
+    colors?: Float32Array;
+    /** Single color for all vectors (default: [0.3, 0.8, 1.0]) */
+    color?: [number, number, number];
+}
+export interface VectorField3DRendererOptions extends Renderer3DOptions {
+    camera?: OrbitCameraOptions;
+    controls?: OrbitControllerOptions;
+    axes?: Axes3DOptions;
+    showAxes?: boolean;
+    /** Arrow scale multiplier (default: 1.0) */
+    scaleMultiplier?: number;
+    /** Opacity for arrows (default: 0.9) */
+    opacity?: number;
+    /** Color theme options */
+    theme?: CustomThemeOptions;
+    /** Enable tooltips */
+    enableTooltip?: boolean;
+}
+export declare class VectorField3DRenderer {
+    private canvas;
+    private gl;
+    private dpr;
+    private programs;
+    private camera;
+    private controller;
+    private axes;
+    private vao;
+    private positionBuffer;
+    private normalBuffer;
+    private indexBuffer;
+    private indexCount;
+    private instancePosBuffer;
+    private instanceDirBuffer;
+    private instanceColorBuffer;
+    private vectorCount;
+    private backgroundColor;
+    private scaleMultiplier;
+    private opacity;
+    private vectorData;
+    private bounds;
+    private animationFrameId;
+    private needsRender;
+    private eventListeners;
+    private tooltip;
+    private lastHitIndex;
+    private boundHandleMouseMove?;
+    private boundHandleMouseLeave?;
+    private colorTheme;
+    constructor(options: VectorField3DRendererOptions);
+    private initArrowGeometry;
+    setData(data: VectorFieldData): void;
+    private updateBounds;
+    render(): void;
+    private startRenderLoop;
+    fitToData(): void;
+    private handleMouseMove;
+    private handleMouseLeave;
+    private handleResize;
+    private resize;
+    getCanvasSize(): {
+        width: number;
+        height: number;
+    };
+    getAxisLabels(): import('./Axes3D').AxisLabel3D[];
+    getViewProjectionMatrix(): import('./math').Mat4Type;
+    projectToScreen(worldPos: [number, number, number]): {
+        x: number;
+        y: number;
+        visible: boolean;
+    };
+    on(event: string, callback: Renderer3DEventCallback): void;
+    private emitEvent;
+    destroy(): void;
+}

package/dist/plugins/3d/Voxel3DRenderer.d.ts

@@ -0,0 +1,89 @@
+import { OrbitCameraOptions } from './camera/OrbitCamera';
+import { OrbitControllerOptions } from './controls/OrbitController';
+import { Axes3DOptions } from './Axes3D';
+import { Renderer3DOptions, Renderer3DEventCallback } from './types';
+import { CustomThemeOptions } from './colorThemes';
+
+export interface VoxelData {
+    /** Dimensions of the 3D grid [nx, ny, nz] */
+    dimensions: [number, number, number];
+    /** Voxel values [v000, v100, ..., v(nx-1)(ny-1)(nz-1)] */
+    values: Float32Array;
+    /** Voxel positions [x0, y0, z0, ...] if not a regular grid (optional) */
+    positions?: Float32Array;
+    /** Origin point of the grid [x, y, z] (default [0,0,0]) */
+    origin?: [number, number, number];
+    /** Spacing between voxels [dx, dy, dz] (default [1,1,1]) */
+    spacing?: [number, number, number];
+}
+export interface Voxel3DRendererOptions extends Renderer3DOptions {
+    camera?: OrbitCameraOptions;
+    controls?: OrbitControllerOptions;
+    axes?: Axes3DOptions;
+    showAxes?: boolean;
+    /** Size scale for each voxel cube (0.0 to 1.0, default 1.0) */
+    voxelScale?: number;
+    /** Threshold value: voxels below this won't be rendered (default 0.1) */
+    threshold?: number;
+    /** Global opacity (default: 1.0) */
+    opacity?: number;
+    /** Enable tooltips */
+    enableTooltip?: boolean;
+    /** Color theme options */
+    theme?: CustomThemeOptions;
+}
+export declare class Voxel3DRenderer {
+    private canvas;
+    private gl;
+    private dpr;
+    private programs;
+    private camera;
+    private controller;
+    private axes;
+    private vao;
+    private positionBuffer;
+    private indexBuffer;
+    private indexCount;
+    private instancePosBuffer;
+    private instanceValueBuffer;
+    private voxelCount;
+    private backgroundColor;
+    private voxelSize;
+    private voxelScale;
+    private threshold;
+    private opacity;
+    private data;
+    private bounds;
+    private animationFrameId;
+    private needsRender;
+    private eventListeners;
+    private tooltip;
+    private lastHitIndex;
+    private boundHandleMouseMove?;
+    private boundHandleMouseLeave?;
+    constructor(options: Voxel3DRendererOptions);
+    private initCubeGeometry;
+    setData(data: VoxelData): void;
+    private updateBounds;
+    render(): void;
+    private startRenderLoop;
+    fitToData(): void;
+    private handleMouseMove;
+    private handleMouseLeave;
+    private handleResize;
+    private resize;
+    getCanvasSize(): {
+        width: number;
+        height: number;
+    };
+    getAxisLabels(): import('./Axes3D').AxisLabel3D[];
+    getViewProjectionMatrix(): import('./math').Mat4Type;
+    projectToScreen(worldPos: [number, number, number]): {
+        x: number;
+        y: number;
+        visible: boolean;
+    };
+    on(event: string, callback: Renderer3DEventCallback): void;
+    private emitEvent;
+    destroy(): void;
+}

package/dist/plugins/3d/Waterfall3DRenderer.d.ts

@@ -0,0 +1,94 @@
+import { OrbitCameraOptions } from './camera/OrbitCamera';
+import { OrbitControllerOptions } from './controls/OrbitController';
+import { Axes3DOptions } from './Axes3D';
+import { Renderer3DOptions, Renderer3DEventCallback } from './types';
+import { CustomThemeOptions } from './colorThemes';
+
+export interface WaterfallSeriesData {
+    /** Y values for this slice */
+    yValues: Float32Array;
+    /** Fixed Z coordinate for this slice */
+    z: number;
+    /** Color for this slice */
+    color?: [number, number, number];
+}
+export interface Waterfall3DRendererOptions extends Renderer3DOptions {
+    camera?: OrbitCameraOptions;
+    controls?: OrbitControllerOptions;
+    axes?: Axes3DOptions;
+    showAxes?: boolean;
+    /** X values shared by all slices */
+    xValues: Float32Array;
+    /** Visual style: 'line' or 'area' (curtain) */
+    sliceStyle?: 'line' | 'area';
+    /** Base Y value (if sliceStyle is 'area') */
+    baseY?: number;
+    /** Global opacity */
+    opacity?: number;
+    /** Enable tooltips */
+    enableTooltip?: boolean;
+    /** Color theme options */
+    theme?: CustomThemeOptions;
+}
+export declare class Waterfall3DRenderer {
+    private canvas;
+    private gl;
+    private dpr;
+    private programs;
+    private camera;
+    private controller;
+    private axes;
+    private vao;
+    private positionBuffer;
+    private normalBuffer;
+    private colorBuffer;
+    private indexBuffer;
+    private indexCount;
+    private backgroundColor;
+    private sliceStyle;
+    private baseY;
+    private opacity;
+    private xValues;
+    private slices;
+    private bounds;
+    private animationFrameId;
+    private needsRender;
+    private eventListeners;
+    private hoveredSeriesIndex;
+    private colorTheme;
+    private tooltip;
+    private lastHitIndex;
+    private boundHandleMouseMove?;
+    private boundHandleMouseLeave?;
+    constructor(options: Waterfall3DRendererOptions);
+    setData(slices: WaterfallSeriesData[]): void;
+    private updateBounds;
+    private updateGeometry;
+    render(): void;
+    private startRenderLoop;
+    fitToData(): void;
+    private handleMouseMove;
+    private handleMouseLeave;
+    pickAtScreen(screenX: number, screenY: number): {
+        seriesIndex: number;
+        pointIndex: number;
+        distance: number;
+        point: [number, number, number];
+    } | null;
+    private handleResize;
+    private resize;
+    getCanvasSize(): {
+        width: number;
+        height: number;
+    };
+    getAxisLabels(): import('./Axes3D').AxisLabel3D[];
+    getViewProjectionMatrix(): import('./math').Mat4Type;
+    projectToScreen(worldPos: [number, number, number]): {
+        x: number;
+        y: number;
+        visible: boolean;
+    };
+    on(event: string, callback: Renderer3DEventCallback): void;
+    private emitEvent;
+    destroy(): void;
+}

package/dist/plugins/3d/camera/OrbitCamera.d.ts

@@ -0,0 +1,99 @@
+import { Vec3 } from '../math/Mat4';
+/**
+ * Orbit camera for 3D scene navigation.
+ * Uses spherical coordinates (theta, phi, radius) around a target point.
+ */
+import * as Mat4 from '../math/Mat4';
+export interface OrbitCameraOptions {
+    target?: Vec3;
+    radius?: number;
+    theta?: number;
+    phi?: number;
+    fov?: number;
+    near?: number;
+    far?: number;
+    minRadius?: number;
+    maxRadius?: number;
+    minPhi?: number;
+    maxPhi?: number;
+}
+export declare class OrbitCamera {
+    target: Vec3;
+    radius: number;
+    theta: number;
+    phi: number;
+    fov: number;
+    aspect: number;
+    near: number;
+    far: number;
+    minRadius: number;
+    maxRadius: number;
+    minPhi: number;
+    maxPhi: number;
+    private viewMatrix;
+    private projMatrix;
+    private viewProjMatrix;
+    private dirty;
+    private eye;
+    constructor(options?: OrbitCameraOptions);
+    /**
+     * Set aspect ratio (width / height).
+     */
+    setAspect(aspect: number): void;
+    /**
+     * Rotate camera by delta angles.
+     */
+    rotate(deltaTheta: number, deltaPhi: number): void;
+    /**
+     * Zoom camera by delta radius (positive = zoom out).
+     */
+    zoom(delta: number): void;
+    /**
+     * Zoom by factor (1 = no change, <1 = zoom in, >1 = zoom out).
+     */
+    zoomFactor(factor: number): void;
+    /**
+     * Pan camera target by world-space delta.
+     */
+    pan(deltaX: number, deltaY: number): void;
+    /**
+     * Set target position directly.
+     */
+    setTarget(x: number, y: number, z: number): void;
+    /**
+     * Set camera position from spherical coordinates.
+     */
+    setSpherical(theta: number, phi: number, radius: number): void;
+    /**
+     * Update matrices if dirty.
+     */
+    private updateMatrices;
+    /**
+     * Get view matrix.
+     */
+    getViewMatrix(): Mat4.Mat4;
+    /**
+     * Get projection matrix.
+     */
+    getProjectionMatrix(): Mat4.Mat4;
+    /**
+     * Get combined view-projection matrix.
+     */
+    getViewProjectionMatrix(): Mat4.Mat4;
+    /**
+     * Get current eye position.
+     */
+    getEyePosition(): Vec3;
+    /**
+     * Get forward direction (normalized).
+     */
+    getForwardDirection(): Vec3;
+    /**
+     * Reset camera to default position.
+     */
+    reset(): void;
+    /**
+     * Fit camera to view a bounding box.
+     */
+    fitToBounds(minX: number, minY: number, minZ: number, maxX: number, maxY: number, maxZ: number): void;
+}

package/dist/plugins/3d/camera/index.d.ts

@@ -0,0 +1 @@
+export * from './OrbitCamera';

package/dist/plugins/3d/colorThemes.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Color palettes and themes for 3D charts
+ * Provides optimized color schemes for both dark and light backgrounds
+ */
+export type ColorPalette = Array<[number, number, number]>;
+export interface ColorTheme {
+    /** Series color palette */
+    seriesPalette: ColorPalette;
+    /** Highlight color for hover states */
+    highlightColor: [number, number, number];
+    /** Default background color */
+    backgroundColor?: [number, number, number, number];
+}
+/**
+ * Dark theme - optimized for dark backgrounds
+ * Uses vibrant, saturated colors that pop against dark backgrounds
+ */
+export declare const DARK_THEME: ColorTheme;
+/**
+ * Light theme - optimized for light backgrounds
+ * Uses deeper, more saturated colors that stand out against white/light backgrounds
+ */
+export declare const LIGHT_THEME: ColorTheme;
+/**
+ * Auto-detect theme based on background color luminance
+ */
+export declare function getThemeFromBackground(backgroundColor: [number, number, number, number]): ColorTheme;
+/**
+ * Create a custom theme or merge with defaults
+ */
+export interface CustomThemeOptions {
+    /** Custom series palette (overrides default) */
+    seriesPalette?: ColorPalette;
+    /** Custom highlight color (overrides default) */
+    highlightColor?: [number, number, number];
+    /** Base theme to use ('dark' | 'light' | 'auto') */
+    baseTheme?: 'dark' | 'light' | 'auto';
+}
+export declare function createTheme(options: CustomThemeOptions, backgroundColor?: [number, number, number, number]): ColorTheme;

package/dist/plugins/3d/controls/OrbitController.d.ts

@@ -0,0 +1,69 @@
+import { OrbitCamera } from '../camera/OrbitCamera';
+
+export interface OrbitControllerOptions {
+    rotateSpeed?: number;
+    zoomSpeed?: number;
+    panSpeed?: number;
+    enableRotate?: boolean;
+    enableZoom?: boolean;
+    enablePan?: boolean;
+    rotateButton?: number;
+    panButton?: number;
+    dampingFactor?: number;
+}
+export declare class OrbitController {
+    private camera;
+    private element;
+    rotateSpeed: number;
+    zoomSpeed: number;
+    panSpeed: number;
+    enableRotate: boolean;
+    enableZoom: boolean;
+    enablePan: boolean;
+    rotateButton: number;
+    panButton: number;
+    dampingFactor: number;
+    private isRotating;
+    private isPanning;
+    private lastX;
+    private lastY;
+    private pointers;
+    private lastPinchDistance;
+    private velocityTheta;
+    private velocityPhi;
+    private velocityRadius;
+    private onChangeCallback?;
+    private boundHandlers;
+    constructor(camera: OrbitCamera, element: HTMLElement, options?: OrbitControllerOptions);
+    /**
+     * Attach event listeners to element.
+     */
+    private attach;
+    /**
+     * Detach event listeners.
+     */
+    detach(): void;
+    /**
+     * Set callback for camera changes.
+     */
+    onChange(callback: () => void): void;
+    private notifyChange;
+    private onPointerDown;
+    private onPointerMove;
+    private onPointerUp;
+    private onWheel;
+    private getPinchDistance;
+    /**
+     * Update damping (call each frame for smooth deceleration).
+     * Returns true if camera is still moving.
+     */
+    update(): boolean;
+    /**
+     * Stop all momentum.
+     */
+    stopMomentum(): void;
+    /**
+     * Clean up resources.
+     */
+    destroy(): void;
+}

package/dist/plugins/3d/controls/index.d.ts

@@ -0,0 +1 @@
+export * from './OrbitController';