katucharts.js 0.2.1

package/dist/export/ChartExporter.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Owns the chart's export/output concern: image/SVG/PDF/CSV/XLS downloads, the
+ * data-table view, print, the external-options snapshot, and full-screen
+ * toggling. Extracted from `Chart` so the orchestrator no longer carries this
+ * ~250-line subsystem. The exporter reaches back into the chart through a narrow
+ * host interface (live getters + a few bound callbacks) so it always sees the
+ * chart's current options/series and never captures stale references.
+ */
+import type { SVGRenderer } from '../core/SVGRenderer';
+import type { InternalConfig, KatuChartsOptions, ExportingOptions } from '../types/options';
+import type { BaseSeries } from '../series/BaseSeries';
+export interface ExporterHost {
+    getRenderer(): SVGRenderer;
+    getOptions(): InternalConfig;
+    getContainer(): HTMLElement;
+    getSeriesInstances(): BaseSeries[];
+    setSize(width: number, height: number): void;
+    fireEvent(name: string, ...args: any[]): void;
+    getDefaultHeightAspectRatio(): number;
+    disconnectResizeObserver(): void;
+    observeResizeObserver(): void;
+    getViewportSize(): {
+        width: number;
+        height: number;
+    };
+    fitToViewport(width: number, height: number): void;
+}
+export declare class ChartExporter {
+    private host;
+    constructor(host: ExporterHost);
+    getSVG(): string;
+    getInlinedSVG(): string;
+    handleExportAction(type: string): void;
+    toggleFullScreen(): void;
+    getSeriesDataForExport(): {
+        name: string;
+        data: {
+            x?: any;
+            y?: any;
+            name?: string;
+        }[];
+    }[];
+    exportXLS(filename: string): void;
+    getCSV(): string;
+    getTable(): string;
+    getDataRows(): (string | number | null)[][];
+    exportChart(exportingOptions?: Partial<ExportingOptions>): void;
+    print(): void;
+    optionsToExternal(): KatuChartsOptions;
+}

package/dist/export/Export.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Export engine: SVG, PNG, JPEG, PDF, CSV, and print support.
+ */
+export declare class ExportModule {
+    private static readonly INLINE_PROPS;
+    /**
+     * Clone the SVG node, inline computed styles on every element, strip the
+     * export button group, and return a self-contained SVG string.
+     */
+    static inlineStyles(svgNode: SVGSVGElement): string;
+    /** Append a guaranteed, render-safe attribution watermark to an export clone. */
+    private static stampWatermark;
+    /**
+     * Shared helper: render an SVG string to a canvas at a given scale with
+     * an optional background colour fill.
+     */
+    static svgToCanvas(svgString: string, scale: number, bgColor?: string): Promise<HTMLCanvasElement>;
+    static exportSVG(svgString: string, filename?: string): void;
+    static exportPNG(svgString: string, filename?: string, scale?: number): Promise<void>;
+    static exportJPEG(svgString: string, filename?: string, scale?: number, quality?: number): Promise<void>;
+    static exportPDF(svgString: string, filename?: string, scale?: number): Promise<void>;
+    static print(svgString: string, maxWidth?: number): void;
+    static exportCSV(seriesData: {
+        name: string;
+        data: {
+            x?: any;
+            y?: any;
+            name?: string;
+        }[];
+    }[], filename?: string, csvOptions?: {
+        columnHeaderFormatter?: (item: any, key?: string, keyLength?: number) => string | false;
+        dateFormat?: string;
+        itemDelimiter?: string;
+        lineDelimiter?: string;
+        decimalPoint?: string;
+    }): void;
+    static getCSV(seriesData: {
+        name: string;
+        data: {
+            x?: any;
+            y?: any;
+            name?: string;
+        }[];
+    }[], csvOptions?: {
+        columnHeaderFormatter?: (item: any, key?: string, keyLength?: number) => string | false;
+        dateFormat?: string;
+        itemDelimiter?: string;
+        lineDelimiter?: string;
+        decimalPoint?: string;
+    }): string;
+    static getDataRows(seriesData: {
+        name: string;
+        data: {
+            x?: any;
+            y?: any;
+            name?: string;
+        }[];
+    }[]): (string | number | null)[][];
+    static getTable(seriesData: {
+        name: string;
+        data: {
+            x?: any;
+            y?: any;
+            name?: string;
+        }[];
+    }[], tableCaption?: string | boolean): string;
+    static viewDataTable(seriesData: {
+        name: string;
+        data: {
+            x?: any;
+            y?: any;
+            name?: string;
+        }[];
+    }[], container: HTMLElement, tableCaption?: string | boolean): HTMLDivElement;
+    static downloadBlob(blob: Blob, filename: string): void;
+}

package/dist/finance.d.ts

@@ -0,0 +1,49 @@
+/**
+ * KatuCharts — Finance charts plugin.
+ *
+ * Import this module to register all finance series types:
+ *   import 'katucharts/finance';
+ *
+ * Or import named exports for manual control:
+ *   import { registerFinanceSeriesTypes, HeikinAshiChart, SMA } from 'katucharts/finance';
+ */
+export { registerFinanceSeriesTypes } from './core/registerFinance';
+export { CandlestickChart, OHLCChart } from './series/financial/CandlestickChart';
+export { HeikinAshiChart } from './series/financial/HeikinAshiChart';
+export { HollowCandlestickChart } from './series/financial/HollowCandlestickChart';
+export { VolumeChart } from './series/financial/VolumeChart';
+export { AreaRangeChart, AreaSplineRangeChart } from './series/financial/AreaRangeChart';
+export { ColumnRangeChart } from './series/financial/ColumnRangeChart';
+export { VBPChart } from './series/financial/VBPChart';
+export { BaselineChart } from './series/financial/BaselineChart';
+export { FlagsChart } from './series/financial/FlagsChart';
+export { RenkoChart } from './series/financial/RenkoChart';
+export { KagiChart } from './series/financial/KagiChart';
+export { PointAndFigureChart } from './series/financial/PointAndFigureChart';
+export { LineBreakChart } from './series/financial/LineBreakChart';
+export { Indicator } from './indicators/Indicator';
+export type { OHLCVPoint, IndicatorResult } from './indicators/Indicator';
+export { IndicatorRegistry } from './indicators/registry';
+export { SMA, SMAIndicator } from './indicators/moving-averages/SMA';
+export { EMA, EMAIndicator } from './indicators/moving-averages/EMA';
+export { WMA, WMAIndicator } from './indicators/moving-averages/WMA';
+export { DEMA, DEMAIndicator } from './indicators/moving-averages/DEMA';
+export { TEMA, TEMAIndicator } from './indicators/moving-averages/TEMA';
+export { RSI, RSIIndicator } from './indicators/oscillators/RSI';
+export { Stochastic, StochasticIndicator } from './indicators/oscillators/Stochastic';
+export { MACD, MACDIndicator } from './indicators/oscillators/MACD';
+export { CCI, CCIIndicator } from './indicators/oscillators/CCI';
+export { ROC, ROCIndicator } from './indicators/oscillators/ROC';
+export { Momentum, MomentumIndicator } from './indicators/oscillators/Momentum';
+export { BollingerBands, BollingerBandsIndicator } from './indicators/volatility/BollingerBands';
+export { ATR, ATRIndicator } from './indicators/volatility/ATR';
+export { VWAP, VWAPIndicator } from './indicators/volume/VWAP';
+export { OBV, OBVIndicator } from './indicators/volume/OBV';
+export { VBP, VBPIndicator } from './indicators/volume/VBP';
+export { IchimokuCloud, IchimokuCloudIndicator } from './indicators/trend/IchimokuCloud';
+export { ADX, ADXIndicator } from './indicators/trend/ADX';
+export { PSAR, PSARIndicator } from './indicators/trend/PSAR';
+export { StreamAdapter } from './streaming/StreamAdapter';
+export type { StreamSubscription } from './streaming/StreamAdapter';
+export { CircularBuffer } from './utils/CircularBuffer';
+export { UpdateScheduler, UpdateBatch } from './core/UpdateScheduler';

package/dist/index.d.ts

@@ -0,0 +1,67 @@
+/**
+ * KatuCharts — D3.js charting library.
+ */
+import { Chart } from './core/Chart';
+import { type ModuleDefinition } from './core/Registry';
+import { type LicenseConfig } from './license/LicenseManager';
+import { dateFormat, numberFormat, templateFormat, stripHtmlTags } from './utils/format';
+import type { KatuChartsOptions } from './types/options';
+export declare const KatuCharts: {
+    chart(containerOrId: string | HTMLElement, options: KatuChartsOptions): Chart;
+    setOptions(options: Partial<KatuChartsOptions>): void;
+    getOptions(): Partial<KatuChartsOptions>;
+    dateFormat: typeof dateFormat;
+    numberFormat: typeof numberFormat;
+    templateFormat: typeof templateFormat;
+    stripHtmlTags: typeof stripHtmlTags;
+    color(input: string): import("./utils").KatuChartsColor;
+    palettes: Record<string, string[]>;
+    getPalette(name: string): string[];
+    themes: Record<string, any>;
+    themeNames: string[];
+    getTheme(name: string): any;
+    setTheme(name: string): void;
+    use(module: ModuleDefinition): void;
+    setLicenseKey(key: string): boolean;
+    isLicensed(): boolean;
+    configureLicensing(config: LicenseConfig): void;
+    ChartRegistry: {
+        types: Map<string, import("./core/Registry").SeriesConstructor>;
+        registerType(name: import(".").SeriesType | string, constructor: import("./core/Registry").SeriesConstructor): void;
+        getType(name: string): import("./core/Registry").SeriesConstructor | undefined;
+        hasType(name: string): boolean;
+        getRegisteredTypes(): string[];
+    };
+};
+export default KatuCharts;
+export { Chart } from './core/Chart';
+export { EventBus } from './core/EventBus';
+export { SVGRenderer } from './core/SVGRenderer';
+export { OptionsParser, setGlobalOptions, getGlobalOptions } from './core/OptionsParser';
+export { ChartRegistry, ModuleRegistry } from './core/Registry';
+export { BaseSeries } from './series/BaseSeries';
+export { ExportModule } from './export/Export';
+export { ResponsiveEngine } from './responsive/ResponsiveEngine';
+export { A11yModule } from './accessibility/A11yModule';
+export { Drilldown } from './interaction/Drilldown';
+export { Zoom } from './interaction/Zoom';
+export { Tooltip } from './components/Tooltip';
+export { Legend } from './components/Legend';
+export { DataLabels } from './components/DataLabels';
+export { Crosshair } from './components/Crosshair';
+export { ExportButton } from './components/ExportButton';
+export { LicenseManager } from './license/LicenseManager';
+export { Navigator } from './stock/Navigator';
+export { RangeSelector } from './stock/RangeSelector';
+export { DataGrouping } from './stock/DataGrouping';
+export { registerCoreSeriesTypes } from './core/registerCore';
+export { registerGeneralSeriesTypes } from './core/registerGeneral';
+export { registerFinancialSeriesTypes } from './core/registerFinancial';
+export { registerFlowSeriesTypes } from './core/registerFlow';
+export { lttbDecimate, minMaxDecimate } from './utils/decimation';
+export { CircularBuffer } from './utils/CircularBuffer';
+export { UpdateScheduler, UpdateBatch } from './core/UpdateScheduler';
+export { StreamAdapter } from './streaming/StreamAdapter';
+export type { StreamSubscription } from './streaming/StreamAdapter';
+export type { UpdateType, UpdateEntry } from './core/UpdateScheduler';
+export type { KatuChartsOptions, ChartOptions, SeriesOptions, AxisOptions, TooltipOptions, LegendOptions, PlotOptions, PointOptions, MarkerOptions, DataLabelOptions, SeriesType, PlotArea, InternalConfig, ExportingOptions, StreamingOptions, } from './types/options';

package/dist/indicators/Indicator.d.ts

@@ -0,0 +1,23 @@
+import type { PointOptions } from '../types/options';
+export interface OHLCVPoint {
+    x: number;
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+    volume?: number;
+}
+export interface IndicatorResult {
+    values: PointOptions[];
+    bands?: {
+        upper: PointOptions[];
+        lower: PointOptions[];
+        middle?: PointOptions[];
+    };
+    histogram?: PointOptions[];
+    signal?: PointOptions[];
+}
+export declare abstract class Indicator {
+    abstract readonly name: string;
+    abstract calculate(data: OHLCVPoint[], params: Record<string, number>): IndicatorResult;
+}

package/dist/indicators/expandIndicators.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Expands declarative technical-indicator series (the
+ * `{ type: 'sma', linkedTo: 'id', params: { period } }`) into concrete
+ * line / arearange / column series, computed from the linked series' data.
+ *
+ * This keeps the indicator math in the existing IndicatorRegistry calculators
+ * and reuses the standard renderers, so an indicator is just a derived series.
+ * Runs after option normalization, so the linked series' OHLC data is available.
+ */
+import type { InternalSeriesConfig } from '../types/options';
+export declare const INDICATOR_TYPES: Set<string>;
+export declare function isIndicatorType(type: string | undefined): boolean;
+/**
+ * Replaces indicator series in-place with their computed concrete series.
+ * Non-indicator series pass through untouched. Indices are reassigned so the
+ * downstream color/clip logic stays consistent after fan-out.
+ */
+export declare function expandIndicatorSeries(seriesList: InternalSeriesConfig[]): InternalSeriesConfig[];

package/dist/indicators/moving-averages/DEMA.d.ts

@@ -0,0 +1,10 @@
+import { Indicator, IndicatorResult, OHLCVPoint } from '../Indicator';
+export declare class DEMAIndicator extends Indicator {
+    readonly name = "dema";
+    /**
+     * Double Exponential Moving Average: 2*EMA - EMA(EMA). Reduces the lag of a
+     * single EMA while keeping smoothing.
+     */
+    calculate(data: OHLCVPoint[], params: Record<string, number>): IndicatorResult;
+}
+export declare const DEMA: DEMAIndicator;

package/dist/indicators/moving-averages/EMA.d.ts

@@ -0,0 +1,12 @@
+import { Indicator, IndicatorResult, OHLCVPoint } from '../Indicator';
+export declare class EMAIndicator extends Indicator {
+    readonly name = "ema";
+    /**
+     * Calculates the Exponential Moving Average over closing prices.
+     * Uses multiplier k = 2 / (period + 1). The first EMA value is
+     * seeded with the SMA of the first `period` points.
+     * Points with insufficient history produce y: null.
+     */
+    calculate(data: OHLCVPoint[], params: Record<string, number>): IndicatorResult;
+}
+export declare const EMA: EMAIndicator;

package/dist/indicators/moving-averages/SMA.d.ts

@@ -0,0 +1,11 @@
+import { Indicator, IndicatorResult, OHLCVPoint } from '../Indicator';
+export declare class SMAIndicator extends Indicator {
+    readonly name = "sma";
+    /**
+     * Calculates the Simple Moving Average over closing prices.
+     * SMA = sum of last `period` closes / period.
+     * Points with insufficient history produce y: null.
+     */
+    calculate(data: OHLCVPoint[], params: Record<string, number>): IndicatorResult;
+}
+export declare const SMA: SMAIndicator;

package/dist/indicators/moving-averages/TEMA.d.ts

@@ -0,0 +1,10 @@
+import { Indicator, IndicatorResult, OHLCVPoint } from '../Indicator';
+export declare class TEMAIndicator extends Indicator {
+    readonly name = "tema";
+    /**
+     * Triple Exponential Moving Average: 3*EMA - 3*EMA(EMA) + EMA(EMA(EMA)).
+     * Lower lag than DEMA for the same period.
+     */
+    calculate(data: OHLCVPoint[], params: Record<string, number>): IndicatorResult;
+}
+export declare const TEMA: TEMAIndicator;

package/dist/indicators/moving-averages/WMA.d.ts

@@ -0,0 +1,12 @@
+import { Indicator, IndicatorResult, OHLCVPoint } from '../Indicator';
+export declare class WMAIndicator extends Indicator {
+    readonly name = "wma";
+    /**
+     * Calculates the Weighted Moving Average over closing prices.
+     * Uses linear weighting where the most recent price in the window
+     * receives the highest weight: weight_i = i + 1.
+     * Points with insufficient history produce y: null.
+     */
+    calculate(data: OHLCVPoint[], params: Record<string, number>): IndicatorResult;
+}
+export declare const WMA: WMAIndicator;

package/dist/indicators/oscillators/CCI.d.ts

@@ -0,0 +1,11 @@
+import { Indicator, IndicatorResult, OHLCVPoint } from '../Indicator';
+export declare class CCIIndicator extends Indicator {
+    readonly name = "cci";
+    /**
+     * Commodity Channel Index. Measures deviation of the typical price
+     * ((high+low+close)/3) from its SMA, scaled by mean absolute deviation:
+     * CCI = (TP - SMA(TP)) / (0.015 * meanDeviation).
+     */
+    calculate(data: OHLCVPoint[], params: Record<string, number>): IndicatorResult;
+}
+export declare const CCI: CCIIndicator;

package/dist/indicators/oscillators/MACD.d.ts

@@ -0,0 +1,20 @@
+import { Indicator, OHLCVPoint, IndicatorResult } from '../Indicator';
+export declare class MACDIndicator extends Indicator {
+    readonly name = "macd";
+    /**
+     * Calculates MACD (Moving Average Convergence Divergence).
+     * Returns the MACD line (fast EMA - slow EMA), a signal line
+     * (EMA of MACD), and a histogram (MACD - signal).
+     */
+    calculate(data: OHLCVPoint[], params: Record<string, number>): IndicatorResult;
+    /**
+     * Calculates Exponential Moving Average.
+     * Uses SMA for the seed value, then applies the recursive EMA formula.
+     */
+    private ema;
+    /**
+     * Extracts non-null values and their original indices from a sparse array.
+     */
+    private extractNonNull;
+}
+export declare const MACD: MACDIndicator;

package/dist/indicators/oscillators/Momentum.d.ts

@@ -0,0 +1,10 @@
+import { Indicator, IndicatorResult, OHLCVPoint } from '../Indicator';
+export declare class MomentumIndicator extends Indicator {
+    readonly name = "momentum";
+    /**
+     * Momentum: the absolute price change over `period` bars
+     * (close - close[i-period]).
+     */
+    calculate(data: OHLCVPoint[], params: Record<string, number>): IndicatorResult;
+}
+export declare const Momentum: MomentumIndicator;

package/dist/indicators/oscillators/ROC.d.ts

@@ -0,0 +1,10 @@
+import { Indicator, IndicatorResult, OHLCVPoint } from '../Indicator';
+export declare class ROCIndicator extends Indicator {
+    readonly name = "roc";
+    /**
+     * Rate of Change: percentage change of close versus the close `period` bars
+     * ago. ROC = 100 * (close - close[i-period]) / close[i-period].
+     */
+    calculate(data: OHLCVPoint[], params: Record<string, number>): IndicatorResult;
+}
+export declare const ROC: ROCIndicator;

package/dist/indicators/oscillators/RSI.d.ts

@@ -0,0 +1,11 @@
+import { Indicator, OHLCVPoint, IndicatorResult } from '../Indicator';
+export declare class RSIIndicator extends Indicator {
+    readonly name = "rsi";
+    /**
+     * Calculates the Relative Strength Index using Wilder's smoothing method.
+     * RSI oscillates between 0 and 100; values above 70 suggest overbought,
+     * below 30 suggest oversold conditions.
+     */
+    calculate(data: OHLCVPoint[], params: Record<string, number>): IndicatorResult;
+}
+export declare const RSI: RSIIndicator;

package/dist/indicators/oscillators/Stochastic.d.ts

@@ -0,0 +1,20 @@
+import { Indicator, OHLCVPoint, IndicatorResult } from '../Indicator';
+export declare class StochasticIndicator extends Indicator {
+    readonly name = "stochastic";
+    /**
+     * Calculates the Stochastic Oscillator (%K and %D lines).
+     * %K measures momentum by comparing the close to the high-low range
+     * over kPeriod, smoothed by smoothK. %D is the SMA signal of %K.
+     */
+    calculate(data: OHLCVPoint[], params: Record<string, number>): IndicatorResult;
+    /**
+     * Computes raw %K values: 100 * (close - lowestLow) / (highestHigh - lowestLow).
+     */
+    private computeRawK;
+    /**
+     * Computes a Simple Moving Average over a nullable numeric array,
+     * returning null for positions with insufficient non-null predecessors.
+     */
+    private sma;
+}
+export declare const Stochastic: StochasticIndicator;

package/dist/indicators/registry.d.ts

@@ -0,0 +1,9 @@
+import { Indicator } from './Indicator';
+declare class IndicatorRegistryClass {
+    private indicators;
+    register(indicator: Indicator): void;
+    get(name: string): Indicator | undefined;
+    getAll(): Map<string, Indicator>;
+}
+export declare const IndicatorRegistry: IndicatorRegistryClass;
+export {};

package/dist/indicators/trend/ADX.d.ts

@@ -0,0 +1,11 @@
+import { Indicator, IndicatorResult, OHLCVPoint } from '../Indicator';
+export declare class ADXIndicator extends Indicator {
+    readonly name = "adx";
+    /**
+     * Average Directional Index (Wilder). Quantifies trend strength from the
+     * smoothed directional movement (+DM/-DM) relative to true range. Returns the
+     * ADX line; values below the first valid window are null.
+     */
+    calculate(data: OHLCVPoint[], params: Record<string, number>): IndicatorResult;
+}
+export declare const ADX: ADXIndicator;

package/dist/indicators/trend/IchimokuCloud.d.ts

@@ -0,0 +1,14 @@
+import { Indicator, OHLCVPoint, IndicatorResult } from '../Indicator';
+export declare class IchimokuCloudIndicator extends Indicator {
+    readonly name = "ichimoku";
+    /**
+     * Calculates the full Ichimoku Cloud system: Tenkan-sen, Kijun-sen,
+     * Senkou Span A/B (displaced forward), and Chikou Span (displaced backward).
+     */
+    calculate(data: OHLCVPoint[], params: Record<string, number>): IndicatorResult;
+    /**
+     * Returns (highest high + lowest low) / 2 over a contiguous range of data.
+     */
+    private midpoint;
+}
+export declare const IchimokuCloud: IchimokuCloudIndicator;

package/dist/indicators/trend/PSAR.d.ts

@@ -0,0 +1,11 @@
+import { Indicator, IndicatorResult, OHLCVPoint } from '../Indicator';
+export declare class PSARIndicator extends Indicator {
+    readonly name = "psar";
+    /**
+     * Parabolic SAR (stop-and-reverse). Tracks a trailing stop that accelerates
+     * toward price as a trend extends. `increment` steps the acceleration factor
+     * up to `maximum` each time a new extreme point is made.
+     */
+    calculate(data: OHLCVPoint[], params: Record<string, number>): IndicatorResult;
+}
+export declare const PSAR: PSARIndicator;

package/dist/indicators/util.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Shared helpers for indicator calculators.
+ */
+/**
+ * Exponential moving average over a numeric source, seeded with the SMA of the
+ * first `period` values. Positions with insufficient history are `null`.
+ */
+export declare function emaArray(source: (number | null)[], period: number): (number | null)[];

package/dist/indicators/volatility/ATR.d.ts

@@ -0,0 +1,11 @@
+import { Indicator, OHLCVPoint, IndicatorResult } from '../Indicator';
+export declare class ATRIndicator extends Indicator {
+    readonly name = "atr";
+    /**
+     * Calculates Average True Range using Wilder's smoothing.
+     * ATR measures market volatility by decomposing the full range
+     * of a bar including gap openings.
+     */
+    calculate(data: OHLCVPoint[], params: Record<string, number>): IndicatorResult;
+}
+export declare const ATR: ATRIndicator;

package/dist/indicators/volatility/BollingerBands.d.ts

@@ -0,0 +1,11 @@
+import { Indicator, OHLCVPoint, IndicatorResult } from '../Indicator';
+export declare class BollingerBandsIndicator extends Indicator {
+    readonly name = "bollingerbands";
+    /**
+     * Calculates Bollinger Bands: a middle SMA band with upper and lower bands
+     * offset by a configurable number of standard deviations. Useful for
+     * identifying volatility and potential price breakouts.
+     */
+    calculate(data: OHLCVPoint[], params: Record<string, number>): IndicatorResult;
+}
+export declare const BollingerBands: BollingerBandsIndicator;

package/dist/indicators/volume/OBV.d.ts

@@ -0,0 +1,11 @@
+import { Indicator, OHLCVPoint, IndicatorResult } from '../Indicator';
+export declare class OBVIndicator extends Indicator {
+    readonly name = "obv";
+    /**
+     * Calculates On Balance Volume.
+     * Accumulates volume on up-closes and subtracts on down-closes.
+     * Unchanged closes carry the previous OBV forward.
+     */
+    calculate(data: OHLCVPoint[], _params: Record<string, number>): IndicatorResult;
+}
+export declare const OBV: OBVIndicator;

package/dist/indicators/volume/VBP.d.ts

@@ -0,0 +1,12 @@
+import { Indicator, IndicatorResult, OHLCVPoint } from '../Indicator';
+export declare class VBPIndicator extends Indicator {
+    readonly name = "vbp";
+    /**
+     * Volume by Price: splits the price range into `ranges` horizontal bins and
+     * sums the volume traded while the close fell in each bin. Each result point
+     * carries the bin's price band (low/high) and its total/up volume, consumed
+     * by the VBP renderer as horizontal bars.
+     */
+    calculate(data: OHLCVPoint[], params: Record<string, number>): IndicatorResult;
+}
+export declare const VBP: VBPIndicator;

package/dist/indicators/volume/VWAP.d.ts

@@ -0,0 +1,12 @@
+import { Indicator, OHLCVPoint, IndicatorResult } from '../Indicator';
+export declare class VWAPIndicator extends Indicator {
+    readonly name = "vwap";
+    /**
+     * Calculates Volume Weighted Average Price.
+     * Accumulates (Typical Price * Volume) / cumulative Volume
+     * from the first data point. Points with zero or missing volume
+     * carry forward the previous VWAP value.
+     */
+    calculate(data: OHLCVPoint[], _params: Record<string, number>): IndicatorResult;
+}
+export declare const VWAP: VWAPIndicator;

package/dist/interaction/Drilldown.d.ts

@@ -0,0 +1,29 @@
+import type { DrilldownOptions, SeriesOptions } from '../types/options';
+import { EventBus } from '../core/EventBus';
+export declare class Drilldown {
+    private config;
+    private events;
+    private stack;
+    private drilldownMap;
+    private breadcrumbsEl;
+    private container;
+    private pointClickHandler;
+    constructor(config: DrilldownOptions, events: EventBus, container?: HTMLElement);
+    addSeriesAsDrilldown(point: any, seriesOptions: SeriesOptions): void;
+    private drillDown;
+    drillUp(): void;
+    drillUpToLevel(targetLevel: number): void;
+    hasLevels(): boolean;
+    getCurrentLevel(): number;
+    private get breadcrumbsConfig();
+    private isBreadcrumbsEnabled;
+    /**
+     * Renders breadcrumb navigation trail for drilldown levels. Shown by default once
+     * a drill happens; suppress via `drilldown.breadcrumbs: false` or `{ enabled: false }`.
+     * Renders a back arrow and clickable path ("\u25C0 Root / Level"), or a single back button
+     * when `showFullPath` is false. Positioned as floating overlay to avoid layout shifts.
+     */
+    private updateBreadcrumbs;
+    private getCrumbLabel;
+    destroy(): void;
+}

package/dist/interaction/HoverManager.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Event delegation hover manager for cartesian series.
+ * Uses a single shared mousemove handler per SVG to coordinate across all series.
+ */
+import { Selection } from 'd3-selection';
+import 'd3-transition';
+import type { PointOptions, PlotArea } from '../types/options';
+import type { AxisInstance } from '../axis/Axis';
+import type { EventBus } from '../core/EventBus';
+import type { BaseSeries } from '../series/BaseSeries';
+export interface HoverManagerConfig {
+    series: BaseSeries;
+    group: Selection<SVGGElement, unknown, null, undefined>;
+    data: PointOptions[];
+    xAxis: AxisInstance;
+    yAxis: AxisInstance;
+    plotArea: PlotArea;
+    events: EventBus;
+    haloSize: number;
+    haloOpacity: number;
+    markerRadius: number;
+    hoverRadius: number;
+    hoverLineWidth: number;
+    cursor: string;
+    pathSelection?: Selection<SVGPathElement, any, any, any> | null;
+    lineWidthPlus: number;
+    baseLineWidth: number;
+    getColor: (d: PointOptions) => string;
+}
+export declare class HoverManager {
+    private config;
+    private hoverGroup;
+    private halo;
+    private hoverMarker;
+    private xPositions;
+    private validData;
+    currentIdx: number;
+    constructor(config: HoverManagerConfig);
+    findCandidate(mx: number, my: number): {
+        idx: number;
+        dist: number;
+    } | null;
+    handleClick(event: MouseEvent): void;
+    showHover(idx: number, event: MouseEvent): void;
+    hideHover(event: MouseEvent): void;
+    private findNearest;
+}