@jigonzalez930209/scichart-engine 0.1.0 → 0.2.0

package/dist/core/chart/ChartExporter.d.ts

@@ -0,0 +1,18 @@
+import { Series } from '../Series';
+import { Bounds } from '../../types';
+import { ExportOptions } from './types';
+
+/**
+ * Export series data to CSV format
+ */
+export declare function exportToCSV(series: Series[], options?: ExportOptions): string;
+/**
+ * Export series data to JSON format
+ */
+export declare function exportToJSON(series: Series[], viewBounds: Bounds, options?: ExportOptions): string;
+/**
+ * Export chart to image
+ */
+export declare function exportToImage(webglCanvas: HTMLCanvasElement, overlayCanvas: HTMLCanvasElement, backgroundColor: [number, number, number, number], legend: {
+    draw: (ctx: CanvasRenderingContext2D, dpr: number) => void;
+} | null, showLegend: boolean, dpr: number, type?: "png" | "jpeg"): string;

package/dist/core/chart/ChartNavigation.d.ts

@@ -0,0 +1,55 @@
+import { Bounds, ZoomOptions, AxisOptions, ChartEventMap } from '../../types';
+import { Scale } from '../../scales';
+import { EventEmitter } from '../EventEmitter';
+
+export interface NavigationContext {
+    viewBounds: Bounds;
+    yScales: Map<string, Scale>;
+    yAxisOptionsMap: Map<string, AxisOptions>;
+    xAxisOptions: AxisOptions;
+    primaryYAxisId: string;
+    getPlotArea: () => {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    events: EventEmitter<ChartEventMap>;
+    requestRender: () => void;
+    series: Map<string, {
+        isVisible(): boolean;
+        getBounds(): Bounds | null;
+        getYAxisId(): string | undefined;
+    }>;
+}
+/**
+ * Apply zoom to the chart
+ */
+export declare function applyZoom(ctx: NavigationContext, options: ZoomOptions): void;
+/**
+ * Apply pan to the chart
+ */
+export declare function applyPan(ctx: NavigationContext, deltaX: number, deltaY: number, axisId?: string): void;
+/**
+ * Auto-scale all axes to fit data
+ */
+export declare function autoScaleAll(ctx: NavigationContext): void;
+/**
+ * Handle box zoom selection
+ */
+export declare function handleBoxZoom(ctx: NavigationContext, selectionRect: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+} | null, currentRect: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+} | null, zoom: (options: ZoomOptions) => void): {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+} | null;

package/dist/core/chart/ChartRenderer.d.ts

@@ -0,0 +1,67 @@
+import { Bounds, CursorOptions, AxisOptions, ChartEventMap } from '../../types';
+import { Series } from '../Series';
+import { Scale } from '../../scales';
+import { NativeWebGLRenderer, NativeSeriesRenderData as SeriesRenderData } from '../../renderer/NativeWebGLRenderer';
+import { OverlayRenderer } from '../OverlayRenderer';
+import { AnnotationManager } from '../annotations';
+import { ChartStatistics } from '../ChartStatistics';
+import { EventEmitter } from '../EventEmitter';
+
+export interface RenderContext {
+    webglCanvas: HTMLCanvasElement;
+    overlayCanvas: HTMLCanvasElement;
+    overlayCtx: CanvasRenderingContext2D;
+    container: HTMLDivElement;
+    series: Map<string, Series>;
+    viewBounds: Bounds;
+    xScale: Scale;
+    yScales: Map<string, Scale>;
+    yAxisOptionsMap: Map<string, AxisOptions>;
+    xAxisOptions: AxisOptions;
+    primaryYAxisId: string;
+    renderer: NativeWebGLRenderer;
+    overlay: OverlayRenderer;
+    annotationManager: AnnotationManager;
+    backgroundColor: [number, number, number, number];
+    cursorOptions: CursorOptions | null;
+    cursorPosition: {
+        x: number;
+        y: number;
+    } | null;
+    selectionRect: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    } | null;
+    stats: ChartStatistics | null;
+    showStatistics: boolean;
+    events: EventEmitter<ChartEventMap>;
+    updateSeriesBuffer: (s: Series) => void;
+    getPlotArea: () => {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    pixelToDataX: (px: number) => number;
+    pixelToDataY: (py: number) => number;
+}
+/**
+ * Prepare series data for WebGL rendering
+ */
+export declare function prepareSeriesData(ctx: RenderContext, plotArea: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}): SeriesRenderData[];
+/**
+ * Render overlay elements (axes, grid, annotations, etc.)
+ */
+export declare function renderOverlay(ctx: RenderContext, plotArea: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}, primaryYScale: Scale): void;

package/dist/core/chart/ChartSeries.d.ts

@@ -0,0 +1,52 @@
+import { SeriesOptions, SeriesUpdateData, Bounds } from '../../types';
+import { Series } from '../Series';
+import { FitType, FitOptions } from '../../analysis';
+import { NativeWebGLRenderer } from '../../renderer/NativeWebGLRenderer';
+import { Annotation } from '../annotations';
+
+export interface SeriesManagerContext {
+    series: Map<string, Series>;
+    renderer: NativeWebGLRenderer;
+    viewBounds: Bounds;
+    autoScale: () => void;
+    requestRender: () => void;
+    addAnnotation: (annotation: Annotation) => string;
+    xAxisOptions: {
+        auto?: boolean;
+    };
+    yAxisOptionsMap: Map<string, {
+        auto?: boolean;
+    }>;
+    autoScrollEnabled: boolean;
+    updateLegend?: () => void;
+}
+/**
+ * Add a new series to the chart
+ */
+export declare function addSeries(ctx: SeriesManagerContext, options: SeriesOptions): void;
+/**
+ * Remove a series from the chart
+ */
+export declare function removeSeries(ctx: SeriesManagerContext, id: string): void;
+/**
+ * Update series data
+ */
+export declare function updateSeries(ctx: SeriesManagerContext, id: string, data: SeriesUpdateData): void;
+/**
+ * Update series buffer for rendering
+ */
+export declare function updateSeriesBuffer(ctx: SeriesManagerContext, s: Series): void;
+/**
+ * Append data to existing series
+ */
+export declare function appendData(ctx: SeriesManagerContext, id: string, x: number[] | Float32Array, y: number[] | Float32Array): void;
+/**
+ * Set max points for rolling window
+ */
+export declare function setMaxPoints(ctx: SeriesManagerContext, id: string, maxPoints: number): void;
+/**
+ * Add a fit line (regression) to an existing series
+ */
+export declare function addFitLine(ctx: SeriesManagerContext & {
+    addSeries: (o: SeriesOptions) => void;
+}, seriesId: string, type: FitType, options?: FitOptions): string;

package/dist/core/chart/ChartSetup.d.ts

@@ -0,0 +1,50 @@
+import { ChartOptions, AxisOptions } from '../../types';
+import { Scale } from '../../scales';
+import { ChartTheme } from '../../theme';
+
+export interface SetupResult {
+    theme: ChartTheme;
+    backgroundColor: [number, number, number, number];
+    showLegend: boolean;
+    showControls: boolean;
+    autoScroll: boolean;
+    showStatistics: boolean;
+    dpr: number;
+    xAxisOptions: AxisOptions;
+    xScale: Scale;
+    yAxisOptionsMap: Map<string, AxisOptions>;
+    yScales: Map<string, Scale>;
+    primaryYAxisId: string;
+    webglCanvas: HTMLCanvasElement;
+    overlayCanvas: HTMLCanvasElement;
+    overlayCtx: CanvasRenderingContext2D;
+}
+/**
+ * Initialize chart configuration from options
+ */
+export declare function initializeChart(container: HTMLDivElement, options: ChartOptions): SetupResult;
+/**
+ * Create a canvas element
+ */
+export declare function createCanvas(type: "webgl" | "overlay"): HTMLCanvasElement;
+/**
+ * Calculate the plot area based on container size and margins
+ */
+export declare function getPlotArea(container: HTMLDivElement, yAxisOptionsMap: Map<string, AxisOptions>): {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+/**
+ * Get axes layout for interaction manager
+ */
+export declare function getAxesLayout(yAxisOptionsMap: Map<string, AxisOptions>): Array<{
+    id: string;
+    position: 'left' | 'right';
+    offset: number;
+}>;
+/**
+ * Resize canvases to match container
+ */
+export declare function resizeCanvases(container: HTMLDivElement, webglCanvas: HTMLCanvasElement, overlayCanvas: HTMLCanvasElement, overlayCtx: CanvasRenderingContext2D, dpr: number): boolean;

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

@@ -0,0 +1,13 @@
+/**
+ * Chart barrel export
+ *
+ * Re-exports all chart submodules for clean imports.
+ */
+export type { Chart, ExportOptions } from './types';
+export { MARGINS } from './types';
+export { exportToCSV, exportToJSON, exportToImage } from './ChartExporter';
+export { applyZoom, applyPan, autoScaleAll, handleBoxZoom } from './ChartNavigation';
+export type { NavigationContext } from './ChartNavigation';
+export { prepareSeriesData, renderOverlay } from './ChartRenderer';
+export type { RenderContext } from './ChartRenderer';
+export { ChartImpl, createChart } from './ChartCore';

package/dist/core/chart/types.d.ts

@@ -0,0 +1,58 @@
+import { SeriesOptions, SeriesUpdateData, ZoomOptions, CursorOptions, ChartEventMap, Bounds } from '../../types';
+import { Series } from '../Series';
+import { FitType, FitOptions } from '../../analysis';
+import { Annotation } from '../annotations';
+
+import * as analysis from "../../analysis";
+export interface Chart {
+    addSeries(options: SeriesOptions): void;
+    removeSeries(id: string): void;
+    updateSeries(id: string, data: SeriesUpdateData): void;
+    getSeries(id: string): Series | undefined;
+    getAllSeries(): Series[];
+    appendData(id: string, x: number[] | Float32Array, y: number[] | Float32Array): void;
+    setAutoScroll(enabled: boolean): void;
+    setMaxPoints(id: string, maxPoints: number): void;
+    addFitLine(seriesId: string, type: FitType, options?: FitOptions): string;
+    zoom(options: ZoomOptions): void;
+    pan(deltaX: number, deltaY: number): void;
+    resetZoom(): void;
+    getViewBounds(): Bounds;
+    enableCursor(options: CursorOptions): void;
+    disableCursor(): void;
+    resize(width?: number, height?: number): void;
+    render(): void;
+    on<K extends keyof ChartEventMap>(event: K, handler: (data: ChartEventMap[K]) => void): void;
+    off<K extends keyof ChartEventMap>(event: K, handler: (data: ChartEventMap[K]) => void): void;
+    destroy(): void;
+    exportImage(type?: "png" | "jpeg"): string;
+    autoScale(): void;
+    setTheme(theme: string | object): void;
+    /** Access to data analysis utilities */
+    readonly analysis: typeof analysis;
+    addAnnotation(annotation: Annotation): string;
+    removeAnnotation(id: string): boolean;
+    updateAnnotation(id: string, updates: Partial<Annotation>): void;
+    getAnnotation(id: string): Annotation | undefined;
+    getAnnotations(): Annotation[];
+    clearAnnotations(): void;
+    exportCSV(options?: ExportOptions): string;
+    exportJSON(options?: ExportOptions): string;
+}
+/** Options for data export */
+export interface ExportOptions {
+    /** Series IDs to export (default: all) */
+    seriesIds?: string[];
+    /** Include headers in CSV (default: true) */
+    includeHeaders?: boolean;
+    /** Decimal precision (default: 6) */
+    precision?: number;
+    /** CSV delimiter (default: ',') */
+    delimiter?: string;
+}
+export declare const MARGINS: {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+};

package/dist/core/index.d.ts

@@ -1,8 +1,9 @@
 /**
  * Core module exports
  */
-export { createChart, type Chart, type ChartOptions } from './Chart';
+export { createChart, type Chart, type ChartOptions, type ExportOptions } from './Chart';
 export { Series } from './Series';
 export { EventEmitter } from './EventEmitter';
 export { OverlayRenderer, type PlotArea, type CursorState } from './OverlayRenderer';
 export { InteractionManager } from './InteractionManager';
+export * from './annotations';

package/dist/index.d.ts

@@ -15,8 +15,10 @@
 export { createChart } from './core/Chart';
 export { Series } from './core/Series';
 export { EventEmitter } from './core/EventEmitter';
-export type { Chart, ChartOptions } from './core/Chart';
-export type { AxisOptions, SeriesOptions, SeriesData, SeriesStyle, SeriesUpdateData, ZoomOptions, CursorOptions, ChartEventMap, Point, Bounds, Range, ScaleType, SeriesType, } from './types';
+export type { Chart, ChartOptions, ExportOptions } from './core/Chart';
+export { AnnotationManager } from './core/annotations';
+export type { Annotation, AnnotationType, HorizontalLineAnnotation, VerticalLineAnnotation, RectangleAnnotation, BandAnnotation, TextAnnotation, ArrowAnnotation, } from './core/annotations';
+export type { AxisOptions, SeriesOptions, SeriesData, SeriesStyle, SeriesUpdateData, ZoomOptions, CursorOptions, ChartEventMap, Point, Bounds, Range, ScaleType, SeriesType, StepMode, ErrorBarStyle, ErrorBarDirection, ScatterSymbol, } from './types';
 export { LinearScale, LogScale, createScale, type Scale } from './scales';
 export { NativeWebGLRenderer, interleaveData, parseColor, createRenderer, createNativeRenderer, type IWebGLRenderer, type SeriesRenderData, type RenderOptions, } from './renderer';
 export { DARK_THEME, LIGHT_THEME, MIDNIGHT_THEME, ELECTROCHEM_THEME, DEFAULT_THEME, createTheme, getThemeByName, type ChartTheme, type GridTheme, type AxisTheme, type LegendTheme, type CursorTheme, } from './theme';

package/dist/renderer/NativeWebGLRenderer.d.ts

@@ -6,16 +6,31 @@ export interface NativeSeriesRenderData {
     count: number;
     style: SeriesStyle;
     visible: boolean;
-    type: "line" | "scatter" | "line+scatter";
+    type: "line" | "scatter" | "line+scatter" | "step" | "step+scatter" | "band";
+    /** 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;
+    };
 }
 export interface NativeRenderOptions {
     bounds: Bounds;
     backgroundColor?: [number, number, number, number];
+    plotArea?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
 }
 export declare class NativeWebGLRenderer {
     private canvas;
     private gl;
     private dpr;
+    setDPR(dpr: number): void;
     private lineProgram;
     private pointProgram;
     private buffers;
@@ -29,6 +44,11 @@ export declare class NativeWebGLRenderer {
      * Create or update a buffer with interleaved X,Y data
      */
     createBuffer(id: string, data: Float32Array): void;
+    /**
+     * Update a portion of an existing buffer (compatible with WebGL 1.0)
+     * Returns true if successful, false if buffer needs recreation
+     */
+    updateBuffer(id: string, data: Float32Array, offsetInBytes: number): boolean;
     /**
      * Get a buffer by ID
      */
@@ -45,6 +65,7 @@ export declare class NativeWebGLRenderer {
      * Render a frame
      */
     render(series: NativeSeriesRenderData[], options: NativeRenderOptions): void;
+    private renderBand;
     private renderLine;
     private renderPoints;
     /**
@@ -67,3 +88,23 @@ export declare class NativeWebGLRenderer {
 }
 export declare function parseColor(color: string): [number, number, number, number];
 export declare function interleaveData(x: Float32Array | Float64Array | number[], y: Float32Array | Float64Array | number[]): Float32Array;
+/**
+ * Create step chart vertices from X,Y data
+ *
+ * @param x X values
+ * @param y Y values
+ * @param mode Step mode: 'before', 'after', or 'center'
+ * @returns Interleaved Float32Array for step line rendering
+ *
+ * Step modes:
+ * - 'after': Step occurs after the point (horizontal then vertical)
+ * - 'before': Step occurs before the point (vertical then horizontal)
+ * - 'center': Step occurs at the midpoint between points
+ */
+export declare function interleaveStepData(x: Float32Array | Float64Array | number[], y: Float32Array | Float64Array | number[], mode?: 'before' | 'after' | 'center'): Float32Array;
+/**
+ * Interleaves data for band rendering
+ * Produces [x1, y1, x1, y2, x2, y1, x2, y2, ...]
+ * which is ready for gl.TRIANGLE_STRIP
+ */
+export declare function interleaveBandData(x: Float32Array | Float64Array | number[], y1: Float32Array | Float64Array | number[], y2: Float32Array | Float64Array | number[]): Float32Array;