scichart-engine 0.4.1

package/dist/react/SciChart.d.ts

@@ -0,0 +1,60 @@
+import { CSSProperties } from 'react';
+import { UseSciChartOptions } from './useSciChart';
+import { ZoomOptions, CursorOptions, Bounds } from '../types';
+import { Chart } from '../core/Chart';
+
+export interface SciChartSeries {
+    id: string;
+    x: Float32Array | Float64Array;
+    y: Float32Array | Float64Array;
+    color?: string;
+    width?: number;
+    visible?: boolean;
+}
+export interface SciChartProps extends UseSciChartOptions {
+    /** Series data to display */
+    series?: SciChartSeries[];
+    /** Zoom state (controlled) */
+    zoom?: ZoomOptions;
+    /** Callback when zoom changes */
+    onZoomChange?: (bounds: Bounds) => void;
+    /** Cursor configuration */
+    cursor?: CursorOptions;
+    /** Container width */
+    width?: number | string;
+    /** Container height */
+    height?: number | string;
+    /** Additional class name */
+    className?: string;
+    /** Additional styles */
+    style?: CSSProperties;
+    /** Debug mode - shows FPS counter */
+    debug?: boolean;
+}
+export interface SciChartRef {
+    /** Get the chart instance */
+    getChart: () => Chart | null;
+    /** Reset zoom to show all data */
+    resetZoom: () => void;
+    /** Get current bounds */
+    getBounds: () => Bounds | null;
+}
+/**
+ * SciChart React Component
+ *
+ * @example
+ * ```tsx
+ * <SciChart
+ *   series={[
+ *     { id: 'cv-1', x: potentialData, y: currentData, color: '#ff0055' }
+ *   ]}
+ *   xAxis={{ label: 'E / V' }}
+ *   yAxis={{ label: 'I / A' }}
+ *   height={400}
+ *   cursor={{ enabled: true, snap: true }}
+ *   onZoomChange={(bounds) => console.log('Zoom:', bounds)}
+ * />
+ * ```
+ */
+export declare const SciChart: import('react').ForwardRefExoticComponent<SciChartProps & import('react').RefAttributes<SciChartRef>>;
+export default SciChart;

package/dist/react/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * React bindings for SciChart Engine
+ */
+export { SciChart, type SciChartProps, type SciChartRef, type SciChartSeries } from './SciChart';
+export { useSciChart, type UseSciChartOptions, type UseSciChartReturn } from './useSciChart';

package/dist/react/useSciChart.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 UseSciChartOptions extends Omit<ChartOptions, "container"> {
+    /** Auto-resize on container changes */
+    autoResize?: boolean;
+}
+export interface UseSciChartReturn {
+    /** 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 SciChart Engine
+ *
+ * @example
+ * ```tsx
+ * function MyChart() {
+ *   const canvasRef = useRef<HTMLCanvasElement>(null);
+ *   const { chart, isReady, addSeries, zoom } = useSciChart(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 useSciChart(containerRef: RefObject<HTMLDivElement>, options?: UseSciChartOptions): UseSciChartReturn;

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/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, parseColor, } from './native/utils';
+export type { NativeRenderOptions, NativeSeriesRenderData } from './native/types';

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/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,10 @@
+/**
+ * Renderer module exports
+ */
+export { NativeWebGLRenderer, interleaveData, interleaveStepData, interleaveBandData, 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 { interleaveBarData, calculateBarWidth } from './BarRenderer';
+export { interleaveHeatmapData, getColormap } from './HeatmapRenderer';
+export { interleaveCandlestickData } from './CandlestickRenderer';

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

@@ -0,0 +1,30 @@
+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;
+    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,31 @@
+import { Bounds } from '../../types';
+import { ShaderProgram } from './types';
+
+export declare function calculateUniforms(bounds: Bounds): {
+    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]): 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 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,58 @@
+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";
+    /** 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;
+}
+export interface NativeRenderOptions {
+    bounds: Bounds;
+    backgroundColor?: [number, number, number, number];
+    plotArea?: {
+        x: number;
+        y: number;
+        width: number;
+        height: 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,4 @@
+export declare function parseColor(color: string): [number, number, number, number];
+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;

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/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;