velo-plot 1.11.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 jigonzalez930209
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,119 @@
+# Sci Plot 🚀
+
+A high-performance, WebGL-powered scientific charting engine built for precision, speed, and deep interactivity. Optimized for electrochemical and scientific data visualization.
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![NPM Version](https://img.shields.io/npm/v/velo-plot.svg)](https://www.npmjs.com/package/velo-plot)
+
+
+## ✨ Features
+
+-   **🚀 High Performance**: Render millions of data points at 60 FPS using a specialized raw WebGL renderer.
+-   **📈 Advanced Analysis**: Built-in peak detection, integration, baseline correction, and customizable curve fitting (linear/poly/exp).
+-   **📊 Specialized Series**: Support for Lines, Scatter (SDF symbols), Step charts, Band series, Area charts, **Candlesticks** (OHLC), and **Stacked Charts**.
+-   **↕️ Multi-Axis Engine**: Independent scales and units with axis-specific scrolling and zooming.
+-   **📏 Professional Tooling**: Real-time Statistics panel, Annotations (Lines/Shapes/Text), and **high-fidelity SVG/PNG export**.
+-   **🎨 Color Schemes**: **5 professional palettes** with 20 colors each for multi-series charts, auto-assigned when colors aren't specified.
+-   **✨ Interactive Legend**: Hover over series in legend to **bring to front** and highlight with distinct color.
+-   **🔌 Extensible**: **Plugin System** with lifecycle hooks for custom drawing and data analysis.
+-   **⚛️ Framework First**: Native React support via hooks and high-level components.
+-   **🎨 Dynamic Theming**: Sleek built-in themes (Light/Midnight) with support for custom CSS-based skins.
+-   **🏗️ Modular Core**: Built on a modern, decoupled architecture for maximum extendability.
+
+## 🛠️ Installation
+
+```bash
+npm install velo-plot
+# or
+pnpm add velo-plot
+```
+
+## 🚀 Quick Examples
+
+### React (Recommended)
+
+```tsx
+import { SciPlot } from 'velo-plot/react';
+
+function App() {
+  const data = {
+    x: new Float32Array([0, 1, 2, 3]),
+    y: new Float32Array([10, 20, 15, 25])
+  };
+
+  return (
+    <div style={{ width: '800px', height: '400px' }}>
+      <SciPlot 
+        series={[{ id: 's1', ...data, color: '#00f2ff' }]}
+        xAxis={{ label: 'Time (s)' }}
+        yAxis={{ label: 'Voltage (V)' }}
+        showControls
+      />
+    </div>
+  );
+}
+```
+
+### Vanilla JavaScript
+
+```typescript
+import { createChart } from 'velo-plot';
+
+const chart = createChart({
+  container: document.getElementById('chart-container'),
+  theme: 'dark',
+  colorScheme: 'vibrant', // Auto-assigns colors from vibrant palette
+  showLegend: true
+});
+
+// Series without explicit colors get auto-assigned from the scheme
+chart.addSeries({
+  id: 'signal1',
+  type: 'line',
+  data: { x: [...], y: [...] }
+});
+
+chart.addSeries({
+  id: 'signal2',
+  type: 'line',
+  data: { x: [...], y: [...] }
+});
+
+// Change color scheme at runtime
+chart.setColorScheme('ocean');
+```
+
+### Multi-Series with Color Schemes
+
+```typescript
+// Create chart with 20+ series - colors auto-cycle
+const chart = createChart({
+  container: document.getElementById('chart'),
+  colorScheme: 'neon', // 'vibrant', 'pastel', 'neon', 'earth', 'ocean'
+  showLegend: true
+});
+
+// Add multiple series - colors assigned automatically
+for (let i = 0; i < 20; i++) {
+  chart.addSeries({
+    id: `series${i}`,
+    name: `Dataset ${i + 1}`,
+    type: 'line',
+    data: generateData(i)
+  });
+}
+
+// Hover over series in legend → brings to front + highlights! ✨
+```
+
+## 📖 Documentation
+
+Visit [Sci Plot Docs](https://jigonzalez930209.github.io/velo-plot/) for:
+-   [Getting Started Guide](https://jigonzalez930209.github.io/velo-plot/guide/)
+-   [Core Concepts](https://jigonzalez930209.github.io/velo-plot/guide/concepts)
+-   [API Reference](https://jigonzalez930209.github.io/velo-plot/api/chart)
+-   [Interactive Examples](https://jigonzalez930209.github.io/velo-plot/examples/)
+
+## 📄 License
+
+MIT © [jigonzalez930209](https://github.com/jigonzalez930209)

package/dist/EventEmitter-DAbs2K1C.js

@@ -0,0 +1,60 @@
+var o = Object.defineProperty;
+var h = (r, e, s) => e in r ? o(r, e, { enumerable: !0, configurable: !0, writable: !0, value: s }) : r[e] = s;
+var n = (r, e, s) => h(r, typeof e != "symbol" ? e + "" : e, s);
+class c {
+  constructor() {
+    n(this, "listeners", /* @__PURE__ */ new Map());
+  }
+  /**
+   * Subscribe to an event
+   */
+  on(e, s) {
+    this.listeners.has(e) || this.listeners.set(e, /* @__PURE__ */ new Set()), this.listeners.get(e).add(s);
+  }
+  /**
+   * Unsubscribe from an event
+   */
+  off(e, s) {
+    const t = this.listeners.get(e);
+    t && t.delete(s);
+  }
+  /**
+   * Emit an event with data
+   */
+  emit(e, s) {
+    const t = this.listeners.get(e);
+    t && t.forEach((i) => {
+      try {
+        i(s);
+      } catch (l) {
+        console.error(`[EventEmitter] Error in handler for "${String(e)}":`, l);
+      }
+    });
+  }
+  /**
+   * Subscribe to an event once
+   */
+  once(e, s) {
+    const t = (i) => {
+      this.off(e, t), s(i);
+    };
+    this.on(e, t);
+  }
+  /**
+   * Remove all listeners
+   */
+  clear() {
+    this.listeners.clear();
+  }
+  /**
+   * Get listener count for an event
+   */
+  listenerCount(e) {
+    var s;
+    return ((s = this.listeners.get(e)) == null ? void 0 : s.size) ?? 0;
+  }
+}
+export {
+  c as E
+};
+//# sourceMappingURL=EventEmitter-DAbs2K1C.js.map

package/dist/EventEmitter-DAbs2K1C.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EventEmitter-DAbs2K1C.js","sources":["../src/core/EventEmitter.ts"],"sourcesContent":["/**\n * Type-safe event emitter for chart events\n */\n\nexport class EventEmitter<EventMap extends object> {\n  private listeners: Map<keyof EventMap, Set<(data: unknown) => void>> =\n    new Map();\n\n  /**\n   * Subscribe to an event\n   */\n  on<K extends keyof EventMap>(\n    event: K,\n    handler: (data: EventMap[K]) => void\n  ): void {\n    if (!this.listeners.has(event)) {\n      this.listeners.set(event, new Set());\n    }\n    this.listeners.get(event)!.add(handler as (data: unknown) => void);\n  }\n\n  /**\n   * Unsubscribe from an event\n   */\n  off<K extends keyof EventMap>(\n    event: K,\n    handler: (data: EventMap[K]) => void\n  ): void {\n    const handlers = this.listeners.get(event);\n    if (handlers) {\n      handlers.delete(handler as (data: unknown) => void);\n    }\n  }\n\n  /**\n   * Emit an event with data\n   */\n  emit<K extends keyof EventMap>(event: K, data: EventMap[K]): void {\n    const handlers = this.listeners.get(event);\n    if (handlers) {\n      handlers.forEach((handler) => {\n        try {\n          handler(data);\n        } catch (error) {\n          console.error(`[EventEmitter] Error in handler for \"${String(event)}\":`, error);\n        }\n      });\n    }\n  }\n\n  /**\n   * Subscribe to an event once\n   */\n  once<K extends keyof EventMap>(\n    event: K,\n    handler: (data: EventMap[K]) => void\n  ): void {\n    const wrappedHandler = (data: EventMap[K]) => {\n      this.off(event, wrappedHandler);\n      handler(data);\n    };\n    this.on(event, wrappedHandler);\n  }\n\n  /**\n   * Remove all listeners\n   */\n  clear(): void {\n    this.listeners.clear();\n  }\n\n  /**\n   * Get listener count for an event\n   */\n  listenerCount(event: keyof EventMap): number {\n    return this.listeners.get(event)?.size ?? 0;\n  }\n}\n"],"names":["EventEmitter","__publicField","event","handler","handlers","data","error","wrappedHandler","_a"],"mappings":";;;AAIO,MAAMA,EAAsC;AAAA,EAA5C;AACG,IAAAC,EAAA,uCACF,IAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAKN,GACEC,GACAC,GACM;AACN,IAAK,KAAK,UAAU,IAAID,CAAK,KAC3B,KAAK,UAAU,IAAIA,GAAO,oBAAI,KAAK,GAErC,KAAK,UAAU,IAAIA,CAAK,EAAG,IAAIC,CAAkC;AAAA,EACnE;AAAA;AAAA;AAAA;AAAA,EAKA,IACED,GACAC,GACM;AACN,UAAMC,IAAW,KAAK,UAAU,IAAIF,CAAK;AACzC,IAAIE,KACFA,EAAS,OAAOD,CAAkC;AAAA,EAEtD;AAAA;AAAA;AAAA;AAAA,EAKA,KAA+BD,GAAUG,GAAyB;AAChE,UAAMD,IAAW,KAAK,UAAU,IAAIF,CAAK;AACzC,IAAIE,KACFA,EAAS,QAAQ,CAACD,MAAY;AAC5B,UAAI;AACF,QAAAA,EAAQE,CAAI;AAAA,MACd,SAASC,GAAO;AACd,gBAAQ,MAAM,wCAAwC,OAAOJ,CAAK,CAAC,MAAMI,CAAK;AAAA,MAChF;AAAA,IACF,CAAC;AAAA,EAEL;AAAA;AAAA;AAAA;AAAA,EAKA,KACEJ,GACAC,GACM;AACN,UAAMI,IAAiB,CAACF,MAAsB;AAC5C,WAAK,IAAIH,GAAOK,CAAc,GAC9BJ,EAAQE,CAAI;AAAA,IACd;AACA,SAAK,GAAGH,GAAOK,CAAc;AAAA,EAC/B;AAAA;AAAA;AAAA;AAAA,EAKA,QAAc;AACZ,SAAK,UAAU,MAAA;AAAA,EACjB;AAAA;AAAA;AAAA;AAAA,EAKA,cAAcL,GAA+B;AAtExC,QAAAM;AAuEH,aAAOA,IAAA,KAAK,UAAU,IAAIN,CAAK,MAAxB,gBAAAM,EAA2B,SAAQ;AAAA,EAC5C;AACF;"}

package/dist/core/Chart.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Chart - Main Sci Plot Entry Point
+ *
+ * This file re-exports the chart API from the modular implementation.
+ * For the core implementation, see ./chart/ChartCore.ts
+ */
+export type { Chart, ExportOptions } from './chart/types';
+export { MARGINS } from './chart/types';
+export { createChart, ChartImpl } from './chart/ChartCore';
+export { exportToCSV, exportToJSON, exportToImage } from './chart/ChartExporter';
+export { applyZoom, applyPan } from './chart/ChartNavigation';
+export { autoScaleAll, handleBoxZoom } from './chart/ChartScaling';
+export type { NavigationContext } from './chart/ChartNavigation';
+export type { RenderContext } from './chart/ChartRenderer';
+export type { ChartOptions } from '../types';

package/dist/core/ChartControls.d.ts

@@ -0,0 +1,41 @@
+import { ChartTheme } from '../theme';
+import { InteractionMode } from './InteractionManager';
+import { ToolbarOptions } from '../types';
+
+export interface ChartControlsCallbacks {
+    onResetZoom: () => void;
+    onSetType: (type: "line" | "scatter" | "line+scatter") => void;
+    onToggleSmoothing: () => void;
+    onTogglePan: (active: boolean) => void;
+    onSetMode: (mode: InteractionMode) => void;
+    onExport: () => void;
+    onAutoScale: () => void;
+    onToggleLegend: (visible: boolean) => void;
+    onHoverStart: () => void;
+    onHoverEnd: () => void;
+}
+export declare class ChartControls {
+    private container;
+    private toolbar;
+    private buttonsWrapper;
+    private callbacks;
+    private theme;
+    private options;
+    private isSmoothing;
+    private currentMode;
+    private isLegendVisible;
+    private currentType;
+    private isPinned;
+    private isExpanded;
+    constructor(parent: HTMLElement, theme: ChartTheme, callbacks: ChartControlsCallbacks, options?: ToolbarOptions);
+    private isDarkTheme;
+    private updateToolbarStyle;
+    private updateVisibility;
+    private createButtons;
+    private createPinButton;
+    private enforceSVGVisibility;
+    private createButton;
+    private updateButtonStates;
+    updateTheme(theme: ChartTheme): void;
+    destroy(): void;
+}

package/dist/core/ChartInitQueue.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Chart Initialization Queue
+ *
+ * Internal system that manages sequential initialization of multiple charts.
+ * This is automatically integrated into createChart - no external usage needed.
+ */
+/**
+ * Internal: Wait for turn in initialization queue
+ * Returns the assigned chart ID
+ */
+export declare function waitForInitTurn(): Promise<string>;
+/**
+ * Internal: Mark chart initialization as complete
+ */
+export declare function markInitComplete(id: string): void;
+/**
+ * Get queue status (for debugging)
+ */
+export declare function getInitQueueStatus(): {
+    pending: number;
+    completed: number;
+    currentId: string | null;
+    isProcessing: boolean;
+};
+/**
+ * Reset the queue (call on page navigation if needed)
+ */
+export declare function resetInitQueue(): void;
+export declare class ChartInitQueue {
+    private static instance;
+    static getStatus(): {
+        pending: number;
+        completed: number;
+        currentId: string | null;
+        isProcessing: boolean;
+    };
+    static reset(): void;
+}
+export declare function getChartInitQueue(): {
+    getStatus: () => {
+        pending: number;
+        completed: number;
+        currentId: string | null;
+        isProcessing: boolean;
+    };
+    reset: () => void;
+};
+export declare function queueChartInit(_id: string, fn: () => Promise<void>): Promise<void>;
+export declare function waitForAnimations(durationMs?: number): Promise<void>;
+export declare function resetChartQueue(): void;

package/dist/core/ChartLegend.d.ts

@@ -0,0 +1,74 @@
+import { ChartTheme } from '../theme';
+import { Series } from './Series';
+
+export interface ChartLegendCallbacks {
+    onMove: (x: number, y: number) => void;
+    onResize?: (width: number) => void;
+    onInteractionStart?: () => void;
+    onInteractionEnd?: () => void;
+    onHoverStart?: () => void;
+    onHoverEnd?: () => void;
+    /**
+     * Called when mouse enters a series item in legend
+     * @param series - The series being hovered
+     * @param highlightColor - Whether to apply color highlighting (from options)
+     */
+    onSeriesHoverStart?: (series: Series, highlightColor: boolean) => void;
+    /**
+     * Called when mouse leaves a series item in legend
+     * @param series - The series that was hovered
+     * @param highlightColor - Whether color highlighting was applied
+     */
+    onSeriesHoverEnd?: (series: Series, highlightColor: boolean) => void;
+    onToggleVisibility?: (series: Series) => void;
+}
+/** Options for ChartLegend component */
+export interface ChartLegendOptions {
+    x?: number;
+    y?: number;
+    width?: number;
+    /**
+     * Highlight series color on hover (default: false)
+     * When false, series still comes to foreground but color doesn't change
+     */
+    highlightOnHover?: boolean;
+    /**
+     * Bring series to foreground (z-index) on hover (default: true)
+     */
+    bringToFrontOnHover?: boolean;
+    /** Allow dragging the legend (default: true) */
+    draggable?: boolean;
+    /** Allow resizing the legend (default: true) */
+    resizable?: boolean;
+}
+export declare class ChartLegend {
+    private container;
+    private visualContainer;
+    private header;
+    private content;
+    private theme;
+    private series;
+    private callbacks;
+    private swatchCanvases;
+    private options;
+    private isDragging;
+    private isResizing;
+    private dragOffsetX;
+    private dragOffsetY;
+    constructor(parent: HTMLElement, theme: ChartTheme, options: ChartLegendOptions, callbacks: ChartLegendCallbacks);
+    private updateStyle;
+    private initDragging;
+    update(series: Series[]): void;
+    private render;
+    updateSeriesStyle(s: Series): void;
+    private paintSwatch;
+    /**
+     * Internal symbol drawing logic (shared with canvas export)
+     */
+    private drawSymbol;
+    draw(ctx: CanvasRenderingContext2D, dpr: number): void;
+    updateTheme(theme: ChartTheme): void;
+    setWidth(width: number): void;
+    setVisible(visible: boolean): void;
+    destroy(): void;
+}

package/dist/core/ChartStatistics.d.ts

@@ -0,0 +1,18 @@
+import { ChartTheme } from '../theme';
+import { Series } from './Series';
+import { Bounds } from '../types';
+
+export declare class ChartStatistics {
+    private container;
+    private content;
+    private theme;
+    private series;
+    private isExpanded;
+    constructor(parent: HTMLElement, theme: ChartTheme, series: Map<string, Series>);
+    private isDarkTheme;
+    private updateContainerStyle;
+    update(viewBounds: Bounds): void;
+    toggle(): void;
+    updateTheme(theme: ChartTheme): void;
+    destroy(): void;
+}

package/dist/core/EventEmitter.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Type-safe event emitter for chart events
+ */
+export declare class EventEmitter<EventMap extends object> {
+    private listeners;
+    /**
+     * Subscribe to an event
+     */
+    on<K extends keyof EventMap>(event: K, handler: (data: EventMap[K]) => void): void;
+    /**
+     * Unsubscribe from an event
+     */
+    off<K extends keyof EventMap>(event: K, handler: (data: EventMap[K]) => void): void;
+    /**
+     * Emit an event with data
+     */
+    emit<K extends keyof EventMap>(event: K, data: EventMap[K]): void;
+    /**
+     * Subscribe to an event once
+     */
+    once<K extends keyof EventMap>(event: K, handler: (data: EventMap[K]) => void): void;
+    /**
+     * Remove all listeners
+     */
+    clear(): void;
+    /**
+     * Get listener count for an event
+     */
+    listenerCount(event: keyof EventMap): number;
+}

package/dist/core/InteractionManager.d.ts

@@ -0,0 +1,96 @@
+import { Bounds } from '../types';
+
+export interface AxisLayout {
+    id: string;
+    position: "left" | "right";
+    offset: number;
+}
+export interface InteractionCallbacks {
+    onZoom: (bounds: Bounds, axisId?: string) => void;
+    onPan: (deltaX: number, deltaY: number, axisId?: string) => void;
+    onBoxZoom: (rect: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    } | null) => void;
+    onCursorMove: (x: number, y: number) => void;
+    onCursorLeave: () => void;
+    onPointClick?: (pixelX: number, pixelY: number, ctrlKey: boolean, shiftKey: boolean) => void;
+    onBoxSelect?: (rect: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    } | null, additive: boolean) => void;
+    onBoxSelectUpdate?: (pixelX: number, pixelY: number) => void;
+    onBoxSelectStart?: (pixelX: number, pixelY: number) => void;
+    /** Called when any drag operation starts (pan, box zoom, box select) */
+    onDragStart?: () => void;
+    /** Called when any drag operation ends */
+    onDragEnd?: () => void;
+    /** Called for all raw interaction events for plugin processing */
+    onInteraction?: (event: import('../plugins/types').InteractionEvent) => void;
+}
+export interface PlotAreaGetter {
+    (): {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+}
+export interface BoundsGetter {
+    (axisId?: string): Bounds;
+}
+export interface AxisLayoutGetter {
+    (): AxisLayout[];
+}
+export type InteractionMode = 'pan' | 'boxZoom' | 'select' | 'delta' | 'peak';
+export declare class InteractionManager {
+    private container;
+    private callbacks;
+    private getPlotArea;
+    private getBounds;
+    private getAxesLayout;
+    private isDragging;
+    private panningAxisId?;
+    private isBoxSelecting;
+    private isBoxZooming;
+    private selectionStart;
+    private lastMousePos;
+    private mode;
+    private boundWheel;
+    private boundMouseDown;
+    private boundMouseMove;
+    private boundMouseUp;
+    private boundMouseLeave;
+    private boundTouchStart;
+    private boundTouchMove;
+    private boundTouchEnd;
+    constructor(container: HTMLElement, callbacks: InteractionCallbacks, getPlotArea: PlotAreaGetter, getBounds: BoundsGetter, getAxesLayout: AxisLayoutGetter);
+    private attachListeners;
+    private detachListeners;
+    /**
+     * Set the interaction mode
+     * @deprecated Use setMode instead
+     */
+    setPanMode(enabled: boolean): void;
+    /**
+     * Set the interaction mode: 'pan', 'boxZoom', or 'select'
+     */
+    setMode(mode: InteractionMode): void;
+    /**
+     * Get the current interaction mode
+     */
+    getMode(): InteractionMode;
+    private handleWheel;
+    private handleMouseDown;
+    private handleMouseMove;
+    private handleMouseUp;
+    private handleMouseLeave;
+    private handleTouchStart;
+    private handleTouchMove;
+    private handleTouchEnd;
+    destroy(): void;
+}

package/dist/core/OverlayRenderer.d.ts

@@ -0,0 +1,89 @@
+import { Scale } from '../scales';
+import { ChartTheme } from '../theme';
+import { Series } from './Series';
+import { PlotArea, CursorState, AxisOptions } from '../types';
+import { ChartTitleOptions, AxisLayoutOptions } from './layout/types';
+
+export declare class OverlayRenderer {
+    private ctx;
+    private theme;
+    private latexAPI;
+    constructor(ctx: CanvasRenderingContext2D, theme: ChartTheme);
+    /**
+     * Set LaTeX API for rendering mathematical expressions
+     */
+    setLatexAPI(api: any): void;
+    /**
+     * Helper to draw text or LaTeX
+     */
+    private drawLatexOrText;
+    /**
+     * Update the theme
+     */
+    setTheme(theme: ChartTheme): void;
+    /**
+     * Clear the overlay
+     */
+    clear(): void;
+    /**
+     * Draw the grid
+     */
+    drawGrid(plotArea: PlotArea, xScale: Scale, yScale: Scale): void;
+    /**
+     * Draw polar grid (radial circles and angular spokes)
+     */
+    drawPolarGrid(plotArea: PlotArea, xScale: Scale, yScale: Scale, radialDivisions?: number, angularDivisions?: number, angleMode?: 'degrees' | 'radians'): void;
+    /**
+     * Draw X axis with ticks and labels
+     */
+    drawXAxis(plotArea: PlotArea, xScale: Scale, options?: AxisOptions, layout?: AxisLayoutOptions): void;
+    /**
+     * Draw Y axis with ticks and labels
+     */
+    drawYAxis(plotArea: PlotArea, yScale: Scale, options?: AxisOptions, position?: "left" | "right", offset?: number, layout?: AxisLayoutOptions): void;
+    /**
+     * Draw plot area border
+     */
+    drawPlotBorder(plotArea: PlotArea): void;
+    /**
+     * Draw chart title
+     */
+    drawChartTitle(plotArea: PlotArea, options: ChartTitleOptions): void;
+    /**
+     * Draw legend
+     */
+    drawLegend(plotArea: PlotArea, series: Series[]): void;
+    /**
+     * Helper to draw a symbol in the legend
+     */
+    private drawLegendSymbol;
+    /**
+     * Draw cursor/crosshair
+     */
+    drawCursor(plotArea: PlotArea, cursor: CursorState, lineStyle?: 'solid' | 'dashed' | 'dotted'): void;
+    /**
+     * Draw tooltip
+     */
+    private drawTooltip;
+    /**
+     * Draw tooltip in a fixed corner position
+     */
+    private drawCornerTooltip;
+    /**
+     * Draw selection rectangle (Box Zoom)
+     */
+    drawSelectionRect(rect: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }): void;
+    /**
+     * Draw error bars for a series
+     */
+    drawErrorBars(plotArea: PlotArea, series: Series, xScale: Scale, yScale: Scale): void;
+    private generateMinorTicks;
+    private formatXTick;
+    private formatYTick;
+    private toScientificUnicode;
+}

package/dist/core/Series.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Series Redirect
+ */
+export { Series } from './series/Series';