velo-plot 1.11.1

package/dist/react/useSciPlot.d.ts

@@ -0,0 +1,56 @@
+import { RefObject } from 'react';
+import { Chart, ChartOptions } from '../core/Chart';
+import { SeriesOptions, SeriesUpdateData, ZoomOptions, Bounds } from '../types';
+
+export interface UseSciPlotOptions extends Omit<ChartOptions, "container"> {
+    /** Auto-resize on container changes */
+    autoResize?: boolean;
+}
+export interface UseSciPlotReturn {
+    /** Chart instance (null until initialized) */
+    chart: Chart | null;
+    /** Whether the chart is ready */
+    isReady: boolean;
+    /** Error during initialization */
+    error: Error | null;
+    /** Current view bounds */
+    bounds: Bounds | null;
+    /** Add a series */
+    addSeries: (options: SeriesOptions) => void;
+    /** Update series data */
+    updateSeries: (id: string, data: SeriesUpdateData) => void;
+    /** Remove a series */
+    removeSeries: (id: string) => void;
+    /** Set zoom range */
+    zoom: (options: ZoomOptions) => void;
+    /** Reset zoom to show all data */
+    resetZoom: () => void;
+}
+/**
+ * React hook for using Sci Plot
+ *
+ * @example
+ * ```tsx
+ * function MyChart() {
+ *   const canvasRef = useRef<HTMLCanvasElement>(null);
+ *   const { chart, isReady, addSeries, zoom } = useSciPlot(canvasRef, {
+ *     xAxis: { label: 'E / V' },
+ *     yAxis: { label: 'I / A' }
+ *   });
+ *
+ *   useEffect(() => {
+ *     if (isReady) {
+ *       addSeries({
+ *         id: 'cv-1',
+ *         type: 'line',
+ *         data: { x: xData, y: yData },
+ *         style: { color: '#ff0055' }
+ *       });
+ *     }
+ *   }, [isReady]);
+ *
+ *   return <canvas ref={canvasRef} />;
+ * }
+ * ```
+ */
+export declare function useSciPlot(containerRef: RefObject<HTMLDivElement>, options?: UseSciPlotOptions): UseSciPlotReturn;

package/dist/renderer/BarRenderer.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Prepare bar chart data for WebGL rendering
+ * Creates rectangle vertices for each bar (2 triangles per bar = 6 vertices)
+ *
+ * @param x - X positions of bar centers
+ * @param y - Y heights of bars
+ * @param barWidth - Width of each bar in data units
+ * @returns Interleaved vertex data ready for gl.TRIANGLES
+ */
+export declare function interleaveBarData(x: Float32Array | Float64Array | number[], y: Float32Array | Float64Array | number[], barWidth: number): Float32Array;
+/**
+ * Calculate automatic bar width based on data spacing
+ */
+export declare function calculateBarWidth(x: Float32Array | Float64Array | number[]): number;

package/dist/renderer/CandlestickRenderer.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Candlestick Renderer Utilities
+ */
+/**
+ * Interleave data for candlestick rendering
+ * Each candle is represented by a body (box) and a wick (line/thin box)
+ * Returns a Float32Array of interleaved [x, y] coordinates for TRIANGLES
+ */
+export declare function interleaveCandlestickData(x: Float32Array | Float64Array, open: Float32Array | Float64Array, high: Float32Array | Float64Array, low: Float32Array | Float64Array, close: Float32Array | Float64Array, width: number): {
+    bullish: Float32Array;
+    bearish: Float32Array;
+};

package/dist/renderer/GaugeRenderer.d.ts

@@ -0,0 +1,3 @@
+import { GaugeData, GaugeStyle, PlotArea } from '../types';
+
+export declare function drawGauge(ctx: CanvasRenderingContext2D, data: GaugeData, style: GaugeStyle, plotArea: PlotArea): void;

package/dist/renderer/HeatmapRenderer.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Prepare Heatmap data for WebGL rendering
+ * Creates a mesh of triangles for the grid.
+ *
+ * @param x - X coordinates of grid columns
+ * @param y - Y coordinates of grid rows
+ * @param z - Z values (matrix flattened in row-major order: width=x.length, height=y.length)
+ * @returns Interleaved data [x, y, value, ...] ready for gl.TRIANGLES
+ */
+export declare function interleaveHeatmapData(x: Float32Array | Float64Array | number[], y: Float32Array | Float64Array | number[], z: Float32Array | Float64Array | number[]): Float32Array;
+/**
+ * Generates a colormap texture data
+ * Viridis approximation
+ */
+export declare function getColormap(name?: string): Uint8Array;

package/dist/renderer/NativeWebGLRenderer.d.ts

@@ -0,0 +1,16 @@
+/**
+ * NativeWebGLRenderer - Zero-dependency WebGL renderer
+ *
+ * This renderer uses raw WebGL APIs without any external libraries.
+ * Performance is identical (or slightly better) than regl since
+ * we eliminate the abstraction layer overhead.
+ *
+ * Key optimizations:
+ * - Pre-compiled shaders (compiled once, reused)
+ * - Uniform updates via GPU (no buffer recreation for zoom/pan)
+ * - Buffer pooling for dynamic data
+ * - Minimal state changes per frame
+ */
+export { NativeWebGLRenderer } from './native/NativeWebGLRenderer';
+export { interleaveBandData, interleaveData, interleaveStepData, interleaveErrorData, interleaveBoxPlotData, interleaveWaterfallData, parseColor, brightenColor, } from './native/utils';
+export type { NativeRenderOptions, NativeSeriesRenderData } from './native/types';

package/dist/renderer/PolarRenderer.d.ts

@@ -0,0 +1,64 @@
+import { PolarData, PolarMode } from '../types';
+
+/**
+ * Convert polar coordinates to Cartesian coordinates
+ *
+ * @param r - Radial values (distance from origin)
+ * @param theta - Angular values
+ * @param angleMode - 'degrees' or 'radians'
+ * @returns Interleaved [x, y] vertex data
+ */
+export declare function polarToCartesian(r: Float32Array | Float64Array | number[], theta: Float32Array | Float64Array | number[], angleMode?: PolarMode): Float32Array;
+/**
+ * Prepare polar data for line rendering with optional path closing
+ *
+ * @param data - Polar coordinate data
+ * @param angleMode - Angular unit mode
+ * @param closePath - Whether to connect last point to first
+ * @returns Cartesian vertex data
+ */
+export declare function interleavePolarLineData(data: PolarData, angleMode?: PolarMode, closePath?: boolean): Float32Array;
+/**
+ * Prepare polar data for filled area rendering
+ * Creates triangles from origin to each line segment
+ *
+ * @param data - Polar coordinate data
+ * @param angleMode - Angular unit mode
+ * @param closePath - Whether to close the path
+ * @returns Triangle vertex data for gl.TRIANGLES
+ */
+export declare function interleavePolarFillData(data: PolarData, angleMode?: PolarMode, closePath?: boolean): Float32Array;
+/**
+ * Generate polar grid lines (radial and angular)
+ *
+ * @param maxRadius - Maximum radial value
+ * @param radialDivisions - Number of concentric circles
+ * @param angularDivisions - Number of radial lines (spokes)
+ * @param angleMode - Angular unit mode
+ * @returns Object with radial and angular grid line data
+ */
+export declare function generatePolarGrid(maxRadius: number, radialDivisions?: number, angularDivisions?: number, angleMode?: PolarMode): {
+    radialLines: Float32Array;
+    angularLines: Float32Array;
+};
+/**
+ * Calculate bounds for polar data
+ *
+ * @param data - Polar coordinate data
+ * @returns Cartesian bounds {xMin, xMax, yMin, yMax}
+ */
+export declare function calculatePolarBounds(data: PolarData): {
+    xMin: number;
+    xMax: number;
+    yMin: number;
+    yMax: number;
+    maxRadius: number;
+};
+/**
+ * Normalize angular values to [0, 360) degrees or [0, 2π) radians
+ *
+ * @param theta - Angular values
+ * @param angleMode - Angular unit mode
+ * @returns Normalized angles
+ */
+export declare function normalizeAngles(theta: Float32Array | Float64Array | number[], angleMode?: PolarMode): Float32Array;

package/dist/renderer/RendererInterface.d.ts

@@ -0,0 +1,70 @@
+import { Bounds } from '../types';
+
+export interface SeriesRenderData {
+    id: string;
+    buffer: WebGLBuffer;
+    count: number;
+    style: any;
+    visible: boolean;
+    type: string;
+    zBounds?: {
+        min: number;
+        max: number;
+    };
+    colormapTexture?: WebGLTexture;
+}
+export interface RenderOptions {
+    bounds: Bounds;
+    backgroundColor?: [number, number, number, number];
+}
+/**
+ * Common interface for all WebGL renderer implementations
+ */
+export interface IWebGLRenderer {
+    /** Check if WebGL is available and initialized */
+    readonly available: boolean;
+    /**
+     * Create or update a GPU buffer with interleaved X,Y data
+     * @param id - Unique buffer identifier
+     * @param data - Interleaved Float32Array [x0, y0, x1, y1, ...]
+     */
+    createBuffer(id: string, data: Float32Array): void;
+    /**
+     * Get a buffer by ID
+     */
+    getBuffer(id: string): WebGLBuffer | undefined;
+    /**
+     * Delete a buffer and free GPU memory
+     */
+    deleteBuffer(id: string): void;
+    /**
+     * Create a 1D texture for heatmaps
+     */
+    createColormapTexture(id: string, data: Uint8Array): WebGLTexture;
+    /**
+     * Render a frame with all visible series
+     */
+    render(series: SeriesRenderData[], options: RenderOptions): void;
+    /**
+     * Handle canvas resize
+     */
+    resize(): void;
+    /**
+     * Get WebGL capabilities/limits
+     */
+    getLimits(): Record<string, unknown>;
+    /**
+     * Cleanup and destroy all GPU resources
+     */
+    destroy(): void;
+}
+/**
+ * Create a WebGL renderer (Native WebGL)
+ *
+ * @param canvas - Target canvas element
+ */
+export declare function createRenderer(canvas: HTMLCanvasElement): IWebGLRenderer;
+/**
+ * Create a renderer synchronously (native only)
+ */
+export { NativeWebGLRenderer as createNativeRenderer } from './NativeWebGLRenderer';

package/dist/renderer/SankeyRenderer.d.ts

@@ -0,0 +1,3 @@
+import { SankeyData, SankeyStyle, PlotArea } from '../types';
+
+export declare function drawSankey(ctx: CanvasRenderingContext2D, data: SankeyData, style: SankeyStyle, plotArea: PlotArea): void;

package/dist/renderer/WebGPURenderer.d.ts

@@ -0,0 +1,16 @@
+export interface WebGPURendererOptions {
+    powerPreference?: "low-power" | "high-performance";
+    preferredFormat?: string;
+    antialias?: boolean;
+}
+export declare class WebGPURenderer {
+    readonly available: boolean;
+    private canvas;
+    private adapter;
+    private device;
+    private context;
+    constructor(canvas: HTMLCanvasElement, opts?: WebGPURendererOptions);
+    static isSupported(): boolean;
+    init(opts?: WebGPURendererOptions): Promise<void>;
+    destroy(): void;
+}

package/dist/renderer/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Renderer module exports
+ */
+export { NativeWebGLRenderer, interleaveData, interleaveStepData, interleaveBandData, interleaveErrorData, interleaveBoxPlotData, interleaveWaterfallData, parseColor, type NativeSeriesRenderData, type NativeRenderOptions, } from './NativeWebGLRenderer';
+export { type IWebGLRenderer, type SeriesRenderData, type RenderOptions, createRenderer, createNativeRenderer, } from './RendererInterface';
+export { WebGPURenderer, type WebGPURendererOptions } from './WebGPURenderer';
+export * from './shaders';
+export * from './radar';
+export { interleaveBarData, calculateBarWidth } from './BarRenderer';
+export { interleaveHeatmapData, getColormap } from './HeatmapRenderer';
+export { interleaveCandlestickData } from './CandlestickRenderer';
+export { polarToCartesian, interleavePolarLineData, interleavePolarFillData, generatePolarGrid, calculatePolarBounds, normalizeAngles, } from './PolarRenderer';
+export * from './ternary';

package/dist/renderer/native/NativeWebGLRenderer.d.ts

@@ -0,0 +1,31 @@
+import { NativeRenderOptions, NativeSeriesRenderData } from './types';
+
+export declare class NativeWebGLRenderer {
+    private canvas;
+    private gl;
+    private dpr;
+    private programs;
+    private buffers;
+    private textures;
+    private isInitialized;
+    setDPR(dpr: number): void;
+    constructor(canvas: HTMLCanvasElement);
+    get available(): boolean;
+    createBuffer(id: string, data: Float32Array): void;
+    updateBuffer(id: string, data: Float32Array, offsetInBytes: number): boolean;
+    getGL(): WebGLRenderingContext;
+    getBuffer(id: string): WebGLBuffer | undefined;
+    deleteBuffer(id: string): void;
+    createColormapTexture(id: string, data: Uint8Array): WebGLTexture;
+    getTexture(id: string): WebGLTexture | undefined;
+    render(series: NativeSeriesRenderData[], options: NativeRenderOptions): void;
+    resize(): void;
+    getLimits(): {
+        maxTextureSize: any;
+        maxViewportDims: any;
+        renderer: any;
+        vendor: any;
+    };
+    destroy(): void;
+}
+export type { NativeSeriesRenderData, NativeRenderOptions } from './types';

package/dist/renderer/native/bufferStore.d.ts

@@ -0,0 +1,11 @@
+export declare class BufferStore {
+    private gl;
+    private buffers;
+    private bufferSizes;
+    constructor(gl: WebGLRenderingContext);
+    createBuffer(id: string, data: Float32Array): void;
+    updateBuffer(id: string, data: Float32Array, offsetInBytes: number): boolean;
+    getBuffer(id: string): WebGLBuffer | undefined;
+    deleteBuffer(id: string): void;
+    destroy(): void;
+}

package/dist/renderer/native/draw.d.ts

@@ -0,0 +1,47 @@
+import { Bounds } from '../../types';
+import { ShaderProgram } from './types';
+
+export declare function calculateUniforms(bounds: Bounds, invertX?: boolean): {
+    scale: [number, number];
+    translate: [number, number];
+};
+export declare function renderLine(gl: WebGLRenderingContext, prog: ShaderProgram, buffer: WebGLBuffer, count: number, uniforms: {
+    scale: [number, number];
+    translate: [number, number];
+}, color: [number, number, number, number], width?: number): void;
+export declare function renderBand(gl: WebGLRenderingContext, prog: ShaderProgram, buffer: WebGLBuffer, count: number, uniforms: {
+    scale: [number, number];
+    translate: [number, number];
+}, color: [number, number, number, number]): void;
+export declare function renderPoints(gl: WebGLRenderingContext, prog: ShaderProgram, buffer: WebGLBuffer, count: number, uniforms: {
+    scale: [number, number];
+    translate: [number, number];
+}, color: [number, number, number, number], pointSize: number, symbol?: string): void;
+export declare function renderHeatmap(gl: WebGLRenderingContext, prog: ShaderProgram, buffer: WebGLBuffer, count: number, uniforms: {
+    scale: [number, number];
+    translate: [number, number];
+}, zBounds?: {
+    min: number;
+    max: number;
+}, texture?: WebGLTexture): void;
+export declare function renderBar(gl: WebGLRenderingContext, prog: ShaderProgram, buffer: WebGLBuffer, count: number, uniforms: {
+    scale: [number, number];
+    translate: [number, number];
+}, color: [number, number, number, number]): void;
+export declare function renderErrorBars(gl: WebGLRenderingContext, prog: ShaderProgram, buffer: WebGLBuffer, count: number, uniforms: {
+    scale: [number, number];
+    translate: [number, number];
+}, color: [number, number, number, number], width?: number): void;
+export declare function renderBoxPlot(gl: WebGLRenderingContext, programs: {
+    line: ShaderProgram;
+    point: ShaderProgram;
+}, data: {
+    boxBuffer: WebGLBuffer;
+    boxCount: number;
+    linesBuffer: WebGLBuffer;
+    linesCount: number;
+}, uniforms: {
+    scale: [number, number];
+    translate: [number, number];
+}, style: any): void;
+export declare function computeSeriesColor(style: any): [number, number, number, number];

package/dist/renderer/native/programFactory.d.ts

@@ -0,0 +1,3 @@
+import { ProgramBundle } from './types';
+
+export declare function createProgramBundle(gl: WebGLRenderingContext): ProgramBundle;

package/dist/renderer/native/renderFrame.d.ts

@@ -0,0 +1,3 @@
+import { NativeRenderOptions, NativeSeriesRenderData, ProgramBundle } from './types';
+
+export declare function renderFrame(gl: WebGLRenderingContext, canvas: HTMLCanvasElement, dpr: number, programs: ProgramBundle, series: NativeSeriesRenderData[], options: NativeRenderOptions): void;

package/dist/renderer/native/shaderSources.d.ts

@@ -0,0 +1,6 @@
+export declare const LINE_VERT = "\nprecision highp float;\nattribute vec2 position;\nuniform vec2 uScale;\nuniform vec2 uTranslate;\n\nvoid main() {\n  vec2 pos = position * uScale + uTranslate;\n  gl_Position = vec4(pos, 0.0, 1.0);\n}\n";
+export declare const LINE_FRAG = "\nprecision highp float;\nuniform vec4 uColor;\n\nvoid main() {\n  gl_FragColor = uColor;\n}\n";
+export declare const POINT_VERT = "\nprecision highp float;\nattribute vec2 position;\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";
+export declare const POINT_FRAG = "\nprecision highp float;\nuniform vec4 uColor;\nuniform int uSymbol;\n\nfloat sdCircle(vec2 p, float r) {\n  return length(p) - r;\n}\n\nfloat sdBox(vec2 p, vec2 b) {\n  vec2 d = abs(p) - b;\n  return length(max(d, 0.0)) + min(max(d.x, d.y), 0.0);\n}\n\nfloat sdTriangle(vec2 p, float r) {\n  const float k = sqrt(3.0);\n  p.x = abs(p.x) - r;\n  p.y = p.y + r / k;\n  if (p.x + k * p.y > 0.0) p = vec2(p.x - k * p.y, -k * p.x - p.y) / 2.0;\n  p.x -= clamp(p.x, -2.0 * r, 0.0);\n  return -length(p) * sign(p.y);\n}\n\nfloat sdDiamond(vec2 p, float r) {\n  return (abs(p.x) + abs(p.y)) - r;\n}\n\nfloat sdCross(vec2 p, float r, float thickness) {\n  vec2 d = abs(p);\n  float s1 = sdBox(d, vec2(r, thickness));\n  float s2 = sdBox(d, vec2(thickness, r));\n  return min(s1, s2);\n}\n\nfloat sdX(vec2 p, float r, float thickness) {\n  float c = cos(0.785398);\n  float s = sin(0.785398);\n  mat2 m = mat2(c, -s, s, c);\n  return sdCross(m * p, r, thickness);\n}\n\nfloat sdStar(vec2 p, float r, float rf) {\n  const vec2 k1 = vec2(0.80901699, -0.58778525);\n  const vec2 k2 = vec2(-k1.x, k1.y);\n  p.x = abs(p.x);\n  p -= 2.0 * max(dot(k1, p), 0.0) * k1;\n  p -= 2.0 * max(dot(k2, p), 0.0) * k2;\n  p.x = abs(p.x);\n  p.y -= r;\n  vec2 ba = rf * vec2(-k1.y, k1.x) - vec2(0, 1);\n  float h = clamp(dot(p, ba) / dot(ba, ba), 0.0, r);\n  return length(p - ba * h) * sign(p.y * ba.x - p.x * ba.y);\n}\n\nvoid main() {\n  vec2 p = gl_PointCoord - vec2(0.5);\n  float d = 0.0;\n\n  if (uSymbol == 0) {\n    d = sdCircle(p, 0.45);\n  } else if (uSymbol == 1) {\n    d = sdBox(p, vec2(0.35));\n  } else if (uSymbol == 2) {\n    d = sdDiamond(p, 0.45);\n  } else if (uSymbol == 3) {\n    d = sdTriangle(vec2(p.x, p.y + 0.1), 0.4);\n  } else if (uSymbol == 4) {\n    d = sdTriangle(vec2(p.x, -p.y + 0.1), 0.4);\n  } else if (uSymbol == 5) {\n    d = sdCross(p, 0.45, 0.15);\n  } else if (uSymbol == 6) {\n    d = sdX(p, 0.45, 0.15);\n  } else if (uSymbol == 7) {\n    d = sdStar(p, 0.45, 0.4);\n  }\n\n  if (d > 0.02) discard;\n\n  float alpha = 1.0 - smoothstep(0.0, 0.02, d);\n  gl_FragColor = vec4(uColor.rgb, uColor.a * alpha);\n}\n";
+export declare const HEATMAP_VERT = "\nprecision highp float;\nattribute vec2 aPosition;\nattribute float aValue;\nuniform vec2 uScale;\nuniform vec2 uTranslate;\nvarying float vValue;\n\nvoid main() {\n  gl_Position = vec4(aPosition * uScale + uTranslate, 0.0, 1.0);\n  vValue = aValue;\n}\n";
+export declare const HEATMAP_FRAG = "\nprecision highp float;\nvarying float vValue;\nuniform float uMinValue;\nuniform float uMaxValue;\nuniform sampler2D uColormap;\n\nvoid main() {\n  float range = uMaxValue - uMinValue;\n  float t = (vValue - uMinValue) / (range != 0.0 ? range : 1.0);\n  t = clamp(t, 0.0, 1.0);\n  gl_FragColor = texture2D(uColormap, vec2(t, 0.5));\n}\n";

package/dist/renderer/native/textureStore.d.ts

@@ -0,0 +1,8 @@
+export declare class TextureStore {
+    private gl;
+    private textures;
+    constructor(gl: WebGLRenderingContext);
+    createColormapTexture(id: string, data: Uint8Array): WebGLTexture;
+    getTexture(id: string): WebGLTexture | undefined;
+    destroy(): void;
+}

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

@@ -0,0 +1,77 @@
+import { Bounds } from '../../types';
+
+export interface NativeSeriesRenderData {
+    id: string;
+    buffer: WebGLBuffer;
+    count: number;
+    style: any;
+    visible: boolean;
+    type: "line" | "scatter" | "line+scatter" | "step" | "step+scatter" | "band" | "bar" | "heatmap" | "candlestick" | "boxplot" | "waterfall";
+    /** For step types: pre-computed step buffer */
+    stepBuffer?: WebGLBuffer;
+    stepCount?: number;
+    /** Optional specific Y-bounds for this series (overrides global bounds) */
+    yBounds?: {
+        min: number;
+        max: number;
+    };
+    /** Heatmap specific */
+    zBounds?: {
+        min: number;
+        max: number;
+    };
+    colormap?: string;
+    colormapTexture?: WebGLTexture;
+    /** Error bars */
+    errorBuffer?: WebGLBuffer;
+    errorCount?: number;
+    /** Box plot specific */
+    boxBuffer?: WebGLBuffer;
+    boxCount?: number;
+    boxLinesBuffer?: WebGLBuffer;
+    boxLinesCount?: number;
+    /** Waterfall specific */
+    wfPositiveBuffer?: WebGLBuffer;
+    wfPositiveCount?: number;
+    wfNegativeBuffer?: WebGLBuffer;
+    wfNegativeCount?: number;
+    wfSubtotalBuffer?: WebGLBuffer;
+    wfSubtotalCount?: number;
+    wfConnectorBuffer?: WebGLBuffer;
+    wfConnectorCount?: number;
+}
+export interface NativeRenderOptions {
+    bounds: Bounds;
+    invertX?: boolean;
+    backgroundColor?: [number, number, number, number];
+    plotArea?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    plotAreaBackground?: [number, number, number, number];
+}
+export interface ShaderProgram {
+    program: WebGLProgram;
+    attributes: {
+        position: number;
+        value?: number;
+    };
+    uniforms: {
+        uScale: WebGLUniformLocation;
+        uTranslate: WebGLUniformLocation;
+        uColor: WebGLUniformLocation | null;
+        uPointSize: WebGLUniformLocation | null;
+        uSymbol: WebGLUniformLocation | null;
+        uMinValue: WebGLUniformLocation | null;
+        uMaxValue: WebGLUniformLocation | null;
+        uColormap: WebGLUniformLocation | null;
+    };
+}
+export type ProgramMode = "line" | "point" | "heatmap";
+export interface ProgramBundle {
+    lineProgram: ShaderProgram;
+    pointProgram: ShaderProgram;
+    heatmapProgram: ShaderProgram;
+}

package/dist/renderer/native/utils.d.ts

@@ -0,0 +1,31 @@
+export declare function parseColor(color: string): [number, number, number, number];
+export declare function brightenColor(color: string, isDarkTheme?: boolean): string;
+export declare function interleaveData(x: Float32Array | Float64Array | number[], y: Float32Array | Float64Array | number[]): Float32Array;
+export declare function interleaveStepData(x: Float32Array | Float64Array | number[], y: Float32Array | Float64Array | number[], mode?: "before" | "after" | "center"): Float32Array;
+export declare function interleaveBandData(x: Float32Array | Float64Array | number[], y1: Float32Array | Float64Array | number[], y2: Float32Array | Float64Array | number[]): Float32Array;
+export declare function interleaveErrorData(x: Float32Array | Float64Array | number[], y: Float32Array | Float64Array | number[], yErr?: {
+    yError?: Float32Array | Float64Array;
+    yErrorMinus?: Float32Array | Float64Array;
+    yErrorPlus?: Float32Array | Float64Array;
+}, xErr?: {
+    xError?: Float32Array | Float64Array;
+    xErrorMinus?: Float32Array | Float64Array;
+    xErrorPlus?: Float32Array | Float64Array;
+}): Float32Array;
+export declare function interleaveBoxPlotData(x: Float32Array | Float64Array | number[], min: Float32Array | Float64Array | number[], q1: Float32Array | Float64Array | number[], median: Float32Array | Float64Array | number[], q3: Float32Array | Float64Array | number[], max: Float32Array | Float64Array | number[], width: number): {
+    lines: Float32Array;
+    boxes: Float32Array;
+};
+/**
+ * Interleave data for Waterfall charts
+ * Creates rectangles that show cumulative changes from a running total
+ */
+export declare function interleaveWaterfallData(x: Float32Array | Float64Array | number[], y: Float32Array | Float64Array | number[], width: number, isSubtotal?: boolean[]): {
+    positiveData: Float32Array;
+    negativeData: Float32Array;
+    subtotalData: Float32Array;
+    connectorData: Float32Array;
+    positiveCount: number;
+    negativeCount: number;
+    subtotalCount: number;
+};

package/dist/renderer/radar/RadarRenderer.d.ts

@@ -0,0 +1,71 @@
+import { RadarData, RadarStyle } from '../../types';
+
+export interface RadarPoint {
+    x: number;
+    y: number;
+    axisIndex: number;
+    value: number;
+}
+export interface RadarGrid {
+    levels: number;
+    maxRadius: number;
+    center: {
+        x: number;
+        y: number;
+    };
+    startAngle: number;
+    angleStep: number;
+}
+export declare class RadarRenderer {
+    private ctx;
+    private width;
+    private height;
+    private grid;
+    constructor(ctx: CanvasRenderingContext2D, width: number, height: number);
+    /**
+     * Convert radar data to screen coordinates
+     */
+    private dataToPoints;
+    /**
+     * Draw radar grid (background circles and radial lines)
+     */
+    drawGrid(data: RadarData, style: RadarStyle): void;
+    /**
+     * Draw axis labels
+     */
+    drawLabels(data: RadarData, style: RadarStyle): void;
+    /**
+     * Draw radar chart
+     */
+    drawRadar(data: RadarData, style: RadarStyle): void;
+    /**
+     * Render complete radar chart
+     */
+    render(data: RadarData, style: RadarStyle): void;
+    /**
+     * Render multiple radar charts (for comparison)
+     */
+    renderMultiple(datasets: {
+        data: RadarData;
+        style: RadarStyle;
+    }[]): void;
+    /**
+     * Get screen coordinates for a specific axis
+     */
+    getAxisCoordinates(axisIndex: number, value: number, style: RadarStyle): {
+        x: number;
+        y: number;
+    };
+    /**
+     * Update canvas dimensions
+     */
+    updateDimensions(width: number, height: number): void;
+    /**
+     * Get grid configuration
+     */
+    getGrid(): RadarGrid;
+    /**
+     * Set grid configuration
+     */
+    setGrid(grid: Partial<RadarGrid>): void;
+}

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

@@ -0,0 +1,10 @@
+/**
+ * Radar Chart Renderer - Index
+ *
+ * Exports radar chart rendering utilities.
+ *
+ * @packageDocumentation
+ * @module renderer/radar
+ */
+export { RadarRenderer } from './RadarRenderer';
+export type { RadarPoint, RadarGrid } from './RadarRenderer';