@itssumitrai/fin-charter 0.2.0

package/README.md

@@ -0,0 +1,96 @@
+<p align="center">
+  <img src="public/logo.svg" alt="fin-charter" width="128" height="128" />
+</p>
+
+<h1 align="center">fin-charter</h1>
+
+<p align="center">Ultra-fast, tree-shakeable financial charting library for the browser.</p>
+
+**[Live Storybook Documentation & Examples](https://itssumitrai.github.io/fin-charter/)**
+
+## Key Features
+
+- **Ultra-fast canvas rendering** — direct 2D canvas drawing, no virtual DOM
+- **Tiny bundle** — core is under 15 KB gzipped; unused chart types tree-shake away
+- **Tree-shakeable** — `"sideEffects": false` ES module package
+- **8 chart types** — Candlestick, Line, Area, Bar (OHLC), Baseline, Hollow Candle, Histogram, Heikin-Ashi
+- **30 built-in indicators** — SMA, EMA, Bollinger Bands, RSI, MACD, VWAP, Stochastic, ATR, ADX, OBV, Williams %R, Volume, Ichimoku Cloud, Parabolic SAR, Keltner Channel, Donchian Channel, CCI, Pivot Points, Aroon, Awesome Oscillator, Chaikin MF, Coppock, Elder Force, TRIX, Supertrend, VWMA, Choppiness, MFI, ROC, Linear Regression
+- **Chart-managed indicators** — `chart.addIndicator('rsi', { source: series })` with auto-compute and auto-pane creation
+- **Multi-pane layout** — indicator panes with draggable dividers and independent price scales
+- **Interactive HUD** — series/indicator management with visibility toggle, settings editor, and remove
+- **TV-style global HUD collapse** — chevron button collapses all indicator rows at once
+- **Context menu** — right-click drawings for Edit/Duplicate/Remove/Z-order; right-click chart for Reset Zoom/Scroll to Latest; right-click indicator pane for Settings/Hide/Remove
+- **TradingView-compatible plugin system** — `ISeriesPrimitive` / `IPanePrimitive` interfaces
+- **Real-time data** — `series.update(bar)` appends or overwrites the last bar in O(1)
+- **Drawing tools** — 16 built-in types (horizontal line, vertical line, trendline, fibonacci, rectangle, text, ray, arrow, channel, ellipse, pitchfork, fib projection, fib arc, fib fan, crossline, measurement); extensible via `registerDrawingType()`
+- **Comparison mode** — normalise multiple series to percentage change for side-by-side performance comparison
+- **Heikin-Ashi** — `chart.addHeikinAshiSeries()` with automatic OHLC-to-HA transform
+- **Market sessions** — define pre/post-market windows with background highlights; filter bars by session
+- **Chart state save/restore** — `exportState()` / `importState()` round-trips the full chart configuration
+- **Data pagination** — `series.prependData()` + `barsInLogicalRange()` + `subscribeVisibleRangeChange()` for infinite-history scrolling
+- **Event markers** — `series.setEvents()` places interactive earnings/dividend/news markers on bars
+- **Periodicity model** — `setPeriodicity()` / `subscribePeriodicityChange()` for interval switching with data-reload hooks
+- **OHLC aggregation** — `aggregateOHLC(store, intervalSec)` for client-side timeframe resampling
+- **Screenshot export** — `chart.takeScreenshot()` composites all panes to a canvas
+- **TypeScript-first** — full type definitions included
+
+## Installation
+
+```bash
+npm install fin-charter
+```
+
+## Quick Start
+
+```ts
+import { createChart } from 'fin-charter';
+
+const chart = createChart(document.getElementById('chart')!, {
+  width: 800,
+  height: 400,
+});
+
+const series = chart.addSeries({ type: 'candlestick' });
+
+series.setData([
+  { time: 1700000000, open: 100, high: 110, low: 95,  close: 107 },
+  { time: 1700086400, open: 107, high: 115, low: 104, close: 112 },
+  { time: 1700172800, open: 112, high: 118, low: 108, close: 109 },
+]);
+```
+
+## Chart Types
+
+| Type | Method | Description |
+|---|---|---|
+| Candlestick | `addSeries({ type: 'candlestick' })` | OHLC candles with filled body and wick |
+| Line | `addSeries({ type: 'line' })` | Close-price polyline |
+| Area | `addSeries({ type: 'area' })` | Close-price line with gradient fill below |
+| Bar (OHLC) | `addSeries({ type: 'bar' })` | Traditional OHLC tick bars |
+| Baseline | `addSeries({ type: 'baseline' })` | Two-color fill above/below a base price |
+| Hollow Candle | `addSeries({ type: 'hollow-candle' })` | Up candles hollow (outline only), down candles filled |
+| Histogram | `addSeries({ type: 'histogram' })` | Vertical bars from the bottom; useful for volume |
+| Heikin-Ashi | `addSeries({ type: 'heikin-ashi' })` | Smoothed OHLC candles with automatic HA transform |
+
+> **Note:** The individual `addCandlestickSeries()`, `addLineSeries()`, etc. methods still work but are deprecated. Prefer the unified `addSeries({ type })` API.
+
+## Bundle Size (measured)
+
+| Entry point | Size (gzip) |
+|---|---|
+| `fin-charter` (core, main chunk) | ~13.8 KB |
+| Full bundle (all chart types + indicators) | ~35.9 KB |
+
+## Documentation
+
+- [Getting Started](docs/getting-started.md)
+- [API Reference](docs/api-reference.md)
+- [Indicators](docs/indicators.md)
+- [Drawing Tools](docs/drawings.md)
+- [Data Integration](docs/data-integration.md)
+- [Plugins](docs/plugins.md)
+- [Performance](docs/performance.md)
+
+## License
+
+MIT

package/dist/api/chart-api.d.ts

@@ -0,0 +1,173 @@
+import { Bar, DeepPartial, SeriesType, ISeriesPrimitive } from '../core/types';
+import { TimeScale } from '../core/time-scale';
+import { PriceScale } from '../core/price-scale';
+import { CrosshairState } from '../core/crosshair';
+import { ChartState } from '../core/chart-state';
+import { AnchorPoint, DrawingOptions, SerializedDrawing, DrawingPrimitive } from '../drawings/index';
+import { ISeriesApi } from './series-api';
+import { IPaneApi } from './pane-api';
+import { IIndicatorApi } from './indicator-api';
+import { ChartOptions, PaneOptions, SeriesOptions, IndicatorType, IndicatorOptions } from './options';
+import { Periodicity } from '../core/periodicity';
+import { MarketSession } from '../core/market-session';
+export type CrosshairMoveCallback = (state: CrosshairState | null) => void;
+export type ClickCallback = (state: {
+    x: number;
+    y: number;
+    time: number;
+    price: number;
+}) => void;
+export type DblClickCallback = (state: {
+    x: number;
+    y: number;
+    time: number;
+    price: number;
+}) => void;
+export type VisibleRangeChangeCallback = (range: {
+    from: number;
+    to: number;
+} | null) => void;
+export type DrawingEventType = 'created' | 'modified' | 'removed';
+export type DrawingEventCallback = (event: {
+    type: DrawingEventType;
+    drawingId: string;
+    drawingType: string;
+}) => void;
+export type IndicatorEventType = 'added' | 'removed';
+export type IndicatorEventCallback = (event: {
+    type: IndicatorEventType;
+    indicatorId: string;
+    indicatorType: string;
+    paneId: string;
+}) => void;
+export type ResizeCallback = (size: {
+    width: number;
+    height: number;
+}) => void;
+export type SymbolChangeCallback = (symbol: {
+    previous: string;
+    current: string;
+}) => void;
+export type ChartTypeChangeCallback = (chartType: {
+    seriesType: SeriesType;
+}) => void;
+export type PreferencesChangeCallback = (options: DeepPartial<ChartOptions>) => void;
+export type LayoutChangeAction = 'pane-added' | 'pane-removed';
+export type LayoutChangeCallback = (event: {
+    action: LayoutChangeAction;
+    paneId: string;
+}) => void;
+export interface IDrawingApi {
+    readonly id: string;
+    drawingType(): string;
+    points(): AnchorPoint[];
+    applyOptions(options: Partial<DrawingOptions>): void;
+    options(): DrawingOptions;
+    remove(): void;
+}
+export interface IChartApi {
+    /** Add a series using a unified options object with a `type` discriminator. */
+    addSeries(options: SeriesOptions): ISeriesApi<SeriesType>;
+    removeSeries(series: ISeriesApi<SeriesType>): void;
+    addPane(options?: PaneOptions): IPaneApi;
+    removePane(pane: IPaneApi): void;
+    timeScale(): TimeScale;
+    priceScale(id?: string): PriceScale;
+    applyOptions(options: DeepPartial<ChartOptions>): void;
+    options(): ChartOptions;
+    resize(width: number, height: number): void;
+    remove(): void;
+    subscribeCrosshairMove(callback: CrosshairMoveCallback): void;
+    unsubscribeCrosshairMove(callback: CrosshairMoveCallback): void;
+    subscribeClick(callback: ClickCallback): void;
+    unsubscribeClick(callback: ClickCallback): void;
+    /** Set the visible time range by Unix timestamps (seconds). Adjusts barSpacing and rightOffset. */
+    setVisibleRange(from: number, to: number): void;
+    /** Set the visible range by bar indices directly. */
+    setVisibleLogicalRange(from: number, to: number): void;
+    /** Reset the view so the latest bar is at the right edge. */
+    scrollToRealTime(): void;
+    subscribeVisibleRangeChange(callback: VisibleRangeChangeCallback): void;
+    unsubscribeVisibleRangeChange(callback: VisibleRangeChangeCallback): void;
+    fitContent(): void;
+    takeScreenshot(): HTMLCanvasElement;
+    addIndicator(type: IndicatorType, options: IndicatorOptions): IIndicatorApi;
+    removeIndicator(indicator: IIndicatorApi): void;
+    /** Enable/disable comparison mode. When on, the Y-axis shows percentage change from the first visible bar. */
+    setComparisonMode(enabled: boolean): void;
+    isComparisonMode(): boolean;
+    addDrawing(type: string, points: AnchorPoint[], options?: DrawingOptions): IDrawingApi;
+    removeDrawing(drawing: IDrawingApi): void;
+    getDrawings(): IDrawingApi[];
+    setActiveDrawingTool(type: string | null): void;
+    registerDrawingType(type: string, factory: (id: string, points: AnchorPoint[], options: DrawingOptions) => ISeriesPrimitive & DrawingPrimitive): void;
+    serializeDrawings(): SerializedDrawing[];
+    deserializeDrawings(data: SerializedDrawing[]): void;
+    /** Export the current chart configuration (no bar data) as a serializable state object. */
+    exportState(): ChartState;
+    /** Restore a previously exported chart state, loading bar data via the provided loader. */
+    importState(state: ChartState, dataLoader: (seriesId: string) => Promise<Bar[]>): Promise<void>;
+    setPeriodicity(periodicity: Periodicity): void;
+    getPeriodicity(): Periodicity;
+    subscribePeriodicityChange(handler: (p: Periodicity) => void): void;
+    unsubscribePeriodicityChange(handler: (p: Periodicity) => void): void;
+    subscribeDblClick(callback: DblClickCallback): void;
+    unsubscribeDblClick(callback: DblClickCallback): void;
+    subscribeDrawingEvent(callback: DrawingEventCallback): void;
+    unsubscribeDrawingEvent(callback: DrawingEventCallback): void;
+    subscribeIndicatorEvent(callback: IndicatorEventCallback): void;
+    unsubscribeIndicatorEvent(callback: IndicatorEventCallback): void;
+    subscribeResize(callback: ResizeCallback): void;
+    unsubscribeResize(callback: ResizeCallback): void;
+    subscribeSymbolChange(callback: SymbolChangeCallback): void;
+    unsubscribeSymbolChange(callback: SymbolChangeCallback): void;
+    subscribeChartTypeChange(callback: ChartTypeChangeCallback): void;
+    unsubscribeChartTypeChange(callback: ChartTypeChangeCallback): void;
+    subscribePreferencesChange(callback: PreferencesChangeCallback): void;
+    unsubscribePreferencesChange(callback: PreferencesChangeCallback): void;
+    subscribeLayoutChange(callback: LayoutChangeCallback): void;
+    unsubscribeLayoutChange(callback: LayoutChangeCallback): void;
+    setMarketSessions(sessions: MarketSession[]): void;
+    getMarketSessions(): MarketSession[];
+    setSessionFilter(filter: 'regular' | 'extended' | 'all'): void;
+    getSessionFilter(): string;
+    /** Export visible OHLCV data (and optionally indicator values) as a CSV string. */
+    exportCSV(options?: import('./export').CSVExportOptions): string;
+    /** Export the current chart view as an SVG string (PNG image embedded in SVG wrapper). */
+    exportSVG(): string;
+    /** Export the current chart view as a PDF Blob. */
+    exportPDF(options?: import('./export').PDFExportOptions): Blob;
+    /** Undo the last drawing/chart modification. */
+    undo(): boolean;
+    /** Redo the last undone modification. */
+    redo(): boolean;
+    /** Whether undo is available. */
+    canUndo(): boolean;
+    /** Whether redo is available. */
+    canRedo(): boolean;
+    /** Activate the range selection mode (drag to highlight a time range). */
+    setRangeSelectionActive(active: boolean): void;
+    /** Subscribe to range selection results. */
+    onRangeSelected(callback: import('../interactions/range-selection').RangeSelectionCallback): void;
+    /** Unsubscribe from range selection results. */
+    offRangeSelected(callback: import('../interactions/range-selection').RangeSelectionCallback): void;
+    /** Activate the measure tool (click two points to see stats). */
+    setMeasureActive(active: boolean): void;
+    /** Subscribe to measure results. */
+    onMeasure(callback: import('../interactions/range-selection').MeasureCallback): void;
+    /** Unsubscribe from measure results. */
+    offMeasure(callback: import('../interactions/range-selection').MeasureCallback): void;
+    /** Add an alert line at the given price level. */
+    addAlertLine(price: number, options?: Partial<import('../core/alert-line').AlertLineOptions>): import('../core/alert-line').AlertLine;
+    /** Remove an alert line. */
+    removeAlertLine(alert: import('../core/alert-line').AlertLine): void;
+    /** Get all alert lines. */
+    getAlertLines(): import('../core/alert-line').AlertLine[];
+    /** Add a text label anchored to a bar index and price. Use DataLayer.findIndex(timestamp) to convert a timestamp to a bar index. */
+    addTextLabel(barIndex: number, price: number, text: string, options?: Partial<import('../core/text-label').TextLabelOptions>): import('../core/text-label').TextLabel;
+    /** Remove a text label. */
+    removeTextLabel(label: import('../core/text-label').TextLabel): void;
+    /** Get all text labels. */
+    getTextLabels(): import('../core/text-label').TextLabel[];
+}
+export declare function createChart(container: HTMLElement, options?: DeepPartial<ChartOptions>): IChartApi;

package/dist/api/export.d.ts

@@ -0,0 +1,46 @@
+import { ColumnStore, VisibleRange } from '../core/types';
+export interface CSVExportOptions {
+    /** Include only bars within this date range (Unix timestamps in seconds). */
+    from?: number;
+    /** Include only bars within this date range (Unix timestamps in seconds). */
+    to?: number;
+    /** Column separator (default: ','). */
+    separator?: string;
+    /** Include indicator columns. */
+    includeIndicators?: boolean;
+}
+export interface SeriesInfo {
+    label: string;
+    store: ColumnStore;
+}
+export interface IndicatorInfo {
+    label: string;
+    /** Map of output name -> Float64Array values aligned with source series. */
+    outputs: Map<string, Float64Array>;
+}
+/**
+ * Export visible OHLCV data as a CSV string.
+ */
+export declare function exportCSV(series: SeriesInfo[], indicators: IndicatorInfo[], range: VisibleRange | null, options?: CSVExportOptions): string;
+/**
+ * Generate an SVG string from a screenshot canvas.
+ * The canvas pixel data is embedded as a base64 PNG <image> element within
+ * an SVG wrapper, preserving the exact chart appearance including themes
+ * and annotations.
+ */
+export declare function exportSVG(screenshotCanvas: HTMLCanvasElement): string;
+export interface PDFExportOptions {
+    /** Paper size (default: 'letter'). */
+    pageSize?: 'letter' | 'a4';
+    /** Page orientation (default: 'landscape'). */
+    orientation?: 'portrait' | 'landscape';
+    /** Optional title text at top of page. */
+    title?: string;
+}
+/**
+ * Generate a minimal PDF document containing the chart image.
+ *
+ * Uses a minimal PDF 1.4 generator (no external dependencies) that embeds
+ * the chart as a JPEG image stream.
+ */
+export declare function exportPDF(screenshotCanvas: HTMLCanvasElement, options?: PDFExportOptions): Blob;

package/dist/api/indicator-api.d.ts

@@ -0,0 +1,38 @@
+import { SeriesType } from '../core/types';
+import { ISeriesApi } from './series-api';
+import { IndicatorType, IndicatorOptions } from './options';
+export interface IIndicatorApi {
+    readonly id: string;
+    indicatorType(): IndicatorType;
+    applyOptions(options: Partial<IndicatorOptions>): void;
+    options(): IndicatorOptions;
+    paneId(): string;
+    isVisible(): boolean;
+    remove(): void;
+    label(): string;
+}
+export declare class IndicatorApi implements IIndicatorApi {
+    readonly id: string;
+    private _type;
+    private _options;
+    private _paneId;
+    private _visible;
+    private _label;
+    /** The line/histogram series created internally for this indicator. */
+    internalSeries: ISeriesApi<SeriesType>[];
+    /** If we auto-created a pane for this indicator, track it for cleanup. */
+    autoCreatedPaneId: string | null;
+    /** Called by remove() to clean up via ChartApi. */
+    _removeCallback: () => void;
+    /** Subscription callback for source dataChanged, stored for unsubscribe. */
+    _dataChangedCallback: (() => void) | null;
+    constructor(id: string, type: IndicatorType, options: IndicatorOptions, paneId: string, removeCallback: () => void);
+    indicatorType(): IndicatorType;
+    applyOptions(options: Partial<IndicatorOptions>): void;
+    options(): IndicatorOptions;
+    paneId(): string;
+    isVisible(): boolean;
+    remove(): void;
+    label(): string;
+    private _autoLabel;
+}

package/dist/api/options.d.ts

@@ -0,0 +1,226 @@
+import { Bar, ColumnData, DeepPartial } from '../core/types';
+import { CandlestickRendererOptions } from '../renderers/candlestick';
+import { LineRendererOptions } from '../renderers/line';
+import { AreaRendererOptions } from '../renderers/area';
+import { BarOHLCRendererOptions } from '../renderers/bar-ohlc';
+import { BaselineRendererOptions } from '../renderers/baseline';
+import { HollowCandleRendererOptions } from '../renderers/hollow-candle';
+import { HistogramRendererOptions } from '../renderers/histogram';
+import { StepLineRendererOptions } from '../renderers/step-line';
+import { ColoredLineRendererOptions } from '../renderers/colored-line';
+import { ColoredMountainRendererOptions } from '../renderers/colored-mountain';
+import { HLCAreaRendererOptions } from '../renderers/hlc-area';
+import { HighLowRendererOptions } from '../renderers/high-low';
+import { ColumnRendererOptions } from '../renderers/column';
+import { VolumeCandleRendererOptions } from '../renderers/volume-candle';
+import { BaselineDeltaMountainRendererOptions } from '../renderers/baseline-delta-mountain';
+import { RenkoRendererOptions } from '../renderers/renko';
+import { KagiRendererOptions } from '../renderers/kagi';
+import { LineBreakRendererOptions } from '../renderers/line-break';
+import { PointFigureRendererOptions } from '../renderers/point-figure';
+export interface LayoutOptions {
+    backgroundColor: string;
+    textColor: string;
+    fontSize: number;
+    fontFamily: string;
+}
+export interface TimeScaleApiOptions {
+    barSpacing: number;
+    rightOffset: number;
+    minBarSpacing: number;
+    maxBarSpacing: number;
+    tickMarkFormatter?: (time: number, tickType: 'year' | 'month' | 'day' | 'time') => string;
+}
+export interface CrosshairOptions {
+    vertLineColor: string;
+    vertLineWidth: number;
+    vertLineDash: number[];
+    horzLineColor: string;
+    horzLineWidth: number;
+    horzLineDash: number[];
+}
+export interface GridOptions {
+    vertLinesVisible: boolean;
+    vertLinesColor: string;
+    horzLinesVisible: boolean;
+    horzLinesColor: string;
+}
+export interface LastPriceLineOptions {
+    visible: boolean;
+}
+export interface TooltipOptions {
+    enabled: boolean;
+}
+export interface WatermarkOptions {
+    visible: boolean;
+    text: string;
+    color: string;
+    fontSize: number;
+    horzAlign: 'left' | 'center' | 'right';
+    vertAlign: 'top' | 'center' | 'bottom';
+}
+export interface VolumeOverlayOptions {
+    visible: boolean;
+    upColor: string;
+    downColor: string;
+    scaleMarginTop: number;
+}
+export interface PriceScaleOptions {
+    visible: boolean;
+    /** Scale mode: 'linear' (default) or 'logarithmic'. */
+    mode?: import('../core/price-scale').PriceScaleMode;
+}
+export interface TimeGapsOptions {
+    visible: boolean;
+}
+export type RendererType = 'canvas2d' | 'webgl';
+export interface ChartOptions {
+    symbol?: string;
+    width: number;
+    height: number;
+    autoSize: boolean;
+    layout: LayoutOptions;
+    timeScale: TimeScaleApiOptions;
+    crosshair: CrosshairOptions;
+    grid: GridOptions;
+    lastPriceLine: LastPriceLineOptions;
+    tooltip: TooltipOptions;
+    watermark: WatermarkOptions;
+    volume: VolumeOverlayOptions;
+    rightPriceScale: PriceScaleOptions;
+    leftPriceScale: PriceScaleOptions;
+    timeGaps: TimeGapsOptions;
+    priceFormatter?: (price: number) => string;
+    theme?: 'dark' | 'light' | 'colorful';
+    locale?: string;
+    timezone?: string;
+    currency?: string;
+    /** Text direction: 'ltr' (default) or 'rtl'. Set to 'auto' to detect from locale. */
+    direction?: import('../core/rtl').TextDirection | 'auto';
+    /**
+     * Rendering backend. `'webgl'` uses WebGL2 for supported series types
+     * (candlestick, line, area) and falls back to Canvas 2D for the rest.
+     * Automatically falls back to `'canvas2d'` when WebGL is unavailable.
+     *
+     * **Note:** Only honored at chart creation time; cannot be changed via
+     * `applyOptions()` after the chart is created.
+     */
+    renderer?: RendererType;
+}
+export declare const DARK_THEME: DeepPartial<ChartOptions>;
+export declare const COLORFUL_THEME: DeepPartial<ChartOptions>;
+export declare const LIGHT_THEME: DeepPartial<ChartOptions>;
+export declare const DEFAULT_CHART_OPTIONS: ChartOptions;
+export interface BaseSeriesOptions {
+    data?: Bar[] | ColumnData;
+    priceScaleId?: string;
+    visible?: boolean;
+    paneId?: string;
+    label?: string;
+}
+export type CandlestickSeriesOptions = BaseSeriesOptions & Partial<CandlestickRendererOptions>;
+export type LineSeriesOptions = BaseSeriesOptions & Partial<LineRendererOptions>;
+export type AreaSeriesOptions = BaseSeriesOptions & Partial<AreaRendererOptions>;
+export type BarSeriesOptions = BaseSeriesOptions & Partial<BarOHLCRendererOptions>;
+export type BaselineSeriesOptions = BaseSeriesOptions & Partial<BaselineRendererOptions>;
+export type HollowCandleSeriesOptions = BaseSeriesOptions & Partial<HollowCandleRendererOptions>;
+export type HistogramSeriesOptions = BaseSeriesOptions & Partial<HistogramRendererOptions>;
+export type StepLineSeriesOptions = BaseSeriesOptions & Partial<StepLineRendererOptions>;
+export type ColoredLineSeriesOptions = BaseSeriesOptions & Partial<ColoredLineRendererOptions>;
+export type ColoredMountainSeriesOptions = BaseSeriesOptions & Partial<ColoredMountainRendererOptions>;
+export type HLCAreaSeriesOptions = BaseSeriesOptions & Partial<HLCAreaRendererOptions>;
+export type HighLowSeriesOptions = BaseSeriesOptions & Partial<HighLowRendererOptions>;
+export type ColumnSeriesOptions = BaseSeriesOptions & Partial<ColumnRendererOptions>;
+export type VolumeCandleSeriesOptions = BaseSeriesOptions & Partial<VolumeCandleRendererOptions>;
+export type BaselineDeltaMountainSeriesOptions = BaseSeriesOptions & Partial<BaselineDeltaMountainRendererOptions>;
+export type RenkoSeriesOptions = BaseSeriesOptions & Partial<RenkoRendererOptions>;
+export type KagiSeriesOptions = BaseSeriesOptions & Partial<KagiRendererOptions>;
+export type LineBreakSeriesOptions = BaseSeriesOptions & Partial<LineBreakRendererOptions>;
+export type PointFigureSeriesOptions = BaseSeriesOptions & Partial<PointFigureRendererOptions>;
+export interface PaneOptions {
+    height?: number;
+}
+export interface SeriesOptionsMap {
+    candlestick: CandlestickSeriesOptions;
+    bar: BarSeriesOptions;
+    line: LineSeriesOptions;
+    area: AreaSeriesOptions;
+    histogram: HistogramSeriesOptions;
+    baseline: BaselineSeriesOptions;
+    'hollow-candle': HollowCandleSeriesOptions;
+    'heikin-ashi': CandlestickSeriesOptions;
+    'step-line': StepLineSeriesOptions;
+    'colored-line': ColoredLineSeriesOptions;
+    'colored-mountain': ColoredMountainSeriesOptions;
+    'hlc-area': HLCAreaSeriesOptions;
+    'high-low': HighLowSeriesOptions;
+    column: ColumnSeriesOptions;
+    'volume-candle': VolumeCandleSeriesOptions;
+    'baseline-delta-mountain': BaselineDeltaMountainSeriesOptions;
+    renko: RenkoSeriesOptions;
+    kagi: KagiSeriesOptions;
+    'line-break': LineBreakSeriesOptions;
+    'point-figure': PointFigureSeriesOptions;
+}
+/** Discriminated union for the unified addSeries() API. */
+export type SeriesOptions = ({
+    type: 'candlestick';
+} & Partial<CandlestickSeriesOptions>) | ({
+    type: 'line';
+} & Partial<LineSeriesOptions>) | ({
+    type: 'area';
+} & Partial<AreaSeriesOptions>) | ({
+    type: 'bar';
+} & Partial<BarSeriesOptions>) | ({
+    type: 'baseline';
+} & Partial<BaselineSeriesOptions>) | ({
+    type: 'hollow-candle';
+} & Partial<HollowCandleSeriesOptions>) | ({
+    type: 'histogram';
+} & Partial<HistogramSeriesOptions>) | ({
+    type: 'heikin-ashi';
+} & Partial<CandlestickSeriesOptions>) | ({
+    type: 'step-line';
+} & Partial<StepLineSeriesOptions>) | ({
+    type: 'colored-line';
+} & Partial<ColoredLineSeriesOptions>) | ({
+    type: 'colored-mountain';
+} & Partial<ColoredMountainSeriesOptions>) | ({
+    type: 'hlc-area';
+} & Partial<HLCAreaSeriesOptions>) | ({
+    type: 'high-low';
+} & Partial<HighLowSeriesOptions>) | ({
+    type: 'column';
+} & Partial<ColumnSeriesOptions>) | ({
+    type: 'volume-candle';
+} & Partial<VolumeCandleSeriesOptions>) | ({
+    type: 'baseline-delta-mountain';
+} & Partial<BaselineDeltaMountainSeriesOptions>) | ({
+    type: 'renko';
+} & Partial<RenkoSeriesOptions>) | ({
+    type: 'kagi';
+} & Partial<KagiSeriesOptions>) | ({
+    type: 'line-break';
+} & Partial<LineBreakSeriesOptions>) | ({
+    type: 'point-figure';
+} & Partial<PointFigureSeriesOptions>);
+export type IndicatorType = 'sma' | 'ema' | 'rsi' | 'macd' | 'bollinger' | 'vwap' | 'stochastic' | 'atr' | 'adx' | 'obv' | 'williams-r' | 'ichimoku' | 'parabolic-sar' | 'keltner' | 'donchian' | 'cci' | 'pivot-points' | 'aroon' | 'awesome-oscillator' | 'chaikin-mf' | 'coppock' | 'elder-force' | 'trix' | 'supertrend' | 'vwma' | 'choppiness' | 'mfi' | 'roc' | 'linear-regression';
+export interface IndicatorOptions {
+    source: import('./series-api').ISeriesApi<import('../core/types').SeriesType>;
+    params?: Record<string, number>;
+    paneId?: string;
+    color?: string;
+    lineWidth?: number;
+    visible?: boolean;
+    label?: string;
+    /** Per-output color overrides, e.g. { upper: '#ff0', middle: '#0f0', lower: '#ff0' }. */
+    colors?: Record<string, string>;
+    /** Histogram up-bar color override (default: green). */
+    histogramUpColor?: string;
+    /** Histogram down-bar color override (default: red). */
+    histogramDownColor?: string;
+}
+export declare const OVERLAY_INDICATORS: Set<IndicatorType>;
+export declare const DEFAULT_INDICATOR_PARAMS: Record<IndicatorType, Record<string, number>>;
+/** Deep merge `overrides` into a copy of `defaults`. */
+export declare function mergeOptions<T extends object>(defaults: T, overrides: DeepPartial<T>): T;

package/dist/api/pane-api.d.ts

@@ -0,0 +1,28 @@
+import { IPanePrimitive } from '../core/types';
+import { Pane } from '../core/pane';
+export interface IPaneApi {
+    /** Unique pane identifier. */
+    readonly id: string;
+    /** Set the pane height in CSS pixels. */
+    setHeight(height: number): void;
+    /** Get the pane height in CSS pixels. */
+    getHeight(): number;
+    /** Attach a pane primitive (plugin). */
+    attachPrimitive(primitive: IPanePrimitive): void;
+    /** Detach a pane primitive. */
+    detachPrimitive(primitive: IPanePrimitive): void;
+}
+export declare class PaneApi implements IPaneApi {
+    readonly id: string;
+    private _pane;
+    private _primitives;
+    private _requestRepaint;
+    constructor(id: string, pane: Pane, requestRepaint: () => void);
+    setHeight(height: number): void;
+    getHeight(): number;
+    /** Get the internal Pane instance. */
+    getPane(): Pane;
+    attachPrimitive(primitive: IPanePrimitive): void;
+    detachPrimitive(primitive: IPanePrimitive): void;
+    getPrimitives(): readonly IPanePrimitive[];
+}