velo-plot 1.15.0 → 2.0.0

package/dist/core/indicator/addIndicator.d.ts

@@ -0,0 +1,36 @@
+import { Chart } from '../chart/types';
+import { StackedPaneConfig } from '../stacked/types';
+import { BuildIndicatorPaneOptions } from './buildIndicatorPane';
+import { ComputedIndicatorPreset, IndicatorPresetName, IndicatorPresetOptions } from './indicatorPresets';
+
+export interface AddIndicatorOptions extends IndicatorPresetOptions {
+    /** Series to derive prices from (default: first line/candlestick/bar) */
+    sourceSeriesId?: string;
+    /** Y axis for overlay lines (default: same as source series) */
+    yAxisId?: string;
+    /** For stacked charts — build a new pane config instead of mutating chart */
+    pane?: "inline" | "new";
+    /** Pane flex ratio when pane: 'new' (default 0.25) */
+    paneHeight?: number | string;
+    showXAxis?: boolean;
+}
+export interface AddIndicatorResult {
+    id: string;
+    preset: IndicatorPresetName;
+    placement: "overlay" | "oscillator";
+    seriesIds: string[];
+}
+type ChartIndicatorHost = Pick<Chart, "getSeries" | "getAllSeries" | "addSeries" | "removeSeries">;
+/**
+ * Calculate indicator preset from a source series (no render).
+ */
+export declare function computeIndicatorFromSeries(chart: ChartIndicatorHost, preset: IndicatorPresetName, options?: AddIndicatorOptions): Promise<ComputedIndicatorPreset>;
+/**
+ * Add a trading indicator to an existing chart (overlay or inline oscillator layers).
+ */
+export declare function addIndicatorToChart(chart: ChartIndicatorHost, preset: IndicatorPresetName, options?: AddIndicatorOptions): Promise<AddIndicatorResult>;
+/**
+ * Build a stacked pane config for an indicator (use when creating or extending stacks).
+ */
+export declare function buildIndicatorPaneFromPreset(preset: IndicatorPresetName, x: Float32Array | Float64Array, prices: Float32Array | Float64Array, options: IndicatorPresetOptions & Pick<BuildIndicatorPaneOptions, "id" | "height" | "label" | "yRange" | "tickCount" | "showXAxis" | "seriesId" | "style">, source?: import('../Series').Series): Promise<StackedPaneConfig>;
+export type { IndicatorPresetName, IndicatorPresetOptions, ComputedIndicatorPreset };

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

@@ -1,3 +1,5 @@
 export type { IndicatorData, IndicatorFillLayer, IndicatorHistogramLayer, IndicatorLineColorZones, IndicatorLineLayer, IndicatorMarker, IndicatorMarkerKind, IndicatorReferenceLine, IndicatorSeriesOptions, IndicatorStyle, } from './types';
 export { buildIndicatorSeries, createIndicatorSeries, detectIndicatorMarkers, } from './buildIndicatorSeries';
 export { buildIndicatorPane, type BuildIndicatorPaneOptions } from './buildIndicatorPane';
+export { addIndicatorToChart, buildIndicatorPaneFromPreset, computeIndicatorFromSeries, type AddIndicatorOptions, type AddIndicatorResult, type IndicatorPresetName, type IndicatorPresetOptions, } from './addIndicator';
+export { computeIndicatorPreset, extractPriceSeries, resolveSourceSeries, isOverlayPreset, type ComputedIndicatorPreset, } from './indicatorPresets';

package/dist/core/indicator/indicatorPresets.d.ts

@@ -0,0 +1,45 @@
+import { IndicatorData } from './types';
+import { Series } from '../Series';
+
+export type IndicatorPresetName = "rsi" | "macd" | "bollinger" | "bollingerBands" | "ema" | "sma" | "stochastic";
+export interface IndicatorPresetOptions {
+    period?: number;
+    fastPeriod?: number;
+    slowPeriod?: number;
+    signalPeriod?: number;
+    stdDev?: number;
+    /** Root id for generated series (default: preset name) */
+    id?: string;
+    label?: string;
+}
+export interface ComputedIndicatorPreset {
+    id: string;
+    preset: IndicatorPresetName;
+    /** overlay = price chart bands/lines; oscillator = separate pane layers */
+    placement: "overlay" | "oscillator";
+    yRange?: [number, number];
+    data: IndicatorData;
+}
+/** Extract X and close/price array from a source series. */
+export declare function extractPriceSeries(source: Series): {
+    x: Float32Array | Float64Array;
+    prices: Float32Array | Float64Array;
+};
+/** Extract OHLC from candlestick series for stochastic and similar presets. */
+export declare function extractOhlcSeries(source: Series): {
+    x: Float32Array | Float64Array;
+    open: Float32Array | Float64Array;
+    high: Float32Array | Float64Array;
+    low: Float32Array | Float64Array;
+    close: Float32Array | Float64Array;
+};
+/** Resolve source series from chart API surface. */
+export declare function resolveSourceSeries(chart: {
+    getSeries(id: string): Series | undefined;
+    getAllSeries(): Series[];
+}, sourceSeriesId?: string): Series;
+/**
+ * Compute composite indicator layers for a preset (async worker path when available).
+ */
+export declare function computeIndicatorPreset(preset: IndicatorPresetName, x: Float32Array | Float64Array, prices: Float32Array | Float64Array, options?: IndicatorPresetOptions, source?: Series): Promise<ComputedIndicatorPreset>;
+export declare function isOverlayPreset(preset: IndicatorPresetName): boolean;

package/dist/core/series/Series.d.ts

@@ -11,6 +11,7 @@ export declare class Series {
     private stackId?;
     private cycle?;
     private maxPoints?;
+    private markers;
     bullishCount: number;
     bearishCount: number;
     waterfallCounts?: {
@@ -42,6 +43,8 @@ export declare class Series {
     getVisible: () => boolean;
     isVisible: () => boolean;
     getStyle: () => SeriesStyle;
+    getMarkers: () => import('../..').CandlestickMarker[];
+    setMarkers: (markers: import('../chart/candlestickMarkers').CandlestickMarker[]) => void;
     getHeatmapData: () => HeatmapData | undefined;
     getHeatmapStyle: () => HeatmapStyle | undefined;
     getPolarData: () => PolarData | undefined;

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

@@ -2,6 +2,7 @@ import { Chart } from '../chart/types';
 import { ChartGroup, SyncAxis, SyncOptions } from '../sync';
 import { ChartOptions as RootChartOptions, Range, SeriesOptions } from '../../types';
 import { LayoutOptions } from '../layout';
+import { AddIndicatorResult } from '../indicator/addIndicator';
 
 /** Stack layout direction */
 export type StackDirection = "vertical" | "horizontal";
@@ -83,6 +84,13 @@ export interface StackedChart {
     setSyncOptions(options: Partial<StackedSyncOptions>): void;
     /** Resolves when all pane charts have started rendering */
     whenReady(): Promise<void>;
+    /** Append a pane at runtime (max 5 panes) */
+    addPane(pane: StackedPaneConfig): Chart;
+    /** Calculate + mount indicator pane or overlay on master price chart */
+    addIndicator(preset: import('../indicator/addIndicator').IndicatorPresetName, options?: import('../indicator/addIndicator').AddIndicatorOptions): Promise<AddIndicatorResult & {
+        paneId?: string;
+        chart?: Chart;
+    }>;
     /** Export the entire stack as one PNG/JPEG/WebP image (WYSIWYG layout) */
     exportImage(options?: StackSnapshotOptions): Promise<string>;
     /** Alias for exportImage */

package/dist/core/time/TimeScale.d.ts

@@ -0,0 +1,31 @@
+/**
+ * TimeScale — business-day / session-aware X mapping for trading charts.
+ * Stage 2.1–2.3
+ */
+export type TimeScaleCalendar = "continuous" | "business-day";
+export type MarketSession = "24x7" | "NYSE";
+export interface TimeScaleOptions {
+    calendar?: TimeScaleCalendar;
+    session?: MarketSession;
+    /** IANA timezone (reserved for future session-hour filtering) */
+    timezone?: string;
+}
+export interface BusinessDayMapping {
+    /** X values for chart (consecutive indices on business days) */
+    scaledX: Float64Array;
+    /** Original timestamp per scaled index (for tooltips / ticks) */
+    timeByIndex: Float64Array;
+    /** Original index → scaled index (-1 if skipped) */
+    sourceToScaled: Int32Array;
+}
+/** Weekend check (NYSE calendar MVP — UTC weekends). */
+export declare function isBusinessDay(ts: number, _opts?: TimeScaleOptions): boolean;
+/**
+ * Map timestamp series to consecutive business-day indices (skips Sat/Sun bars).
+ * NaN in scaledX marks non-business bars (hidden gap).
+ */
+export declare function mapToBusinessDayScale(times: Float32Array | Float64Array, opts?: TimeScaleOptions): BusinessDayMapping;
+/** Resolve timestamp at a scaled business-day index (for axis ticks). */
+export declare function timeAtBusinessIndex(mapping: BusinessDayMapping, index: number): number | undefined;
+/** Visible span in ms using business-day mapping. */
+export declare function businessDaySpanMs(mapping: BusinessDayMapping, xMin: number, xMax: number): number;

package/dist/core/time/applyTimeScale.d.ts

@@ -0,0 +1,10 @@
+import { AxisOptions } from '../../types';
+import { BusinessDayMapping, TimeScaleOptions } from './TimeScale';
+
+export declare function isBusinessDayScaleActive(xAxis: AxisOptions): boolean;
+export declare function resolveTimeScaleOpts(xAxis: AxisOptions): TimeScaleOptions;
+export declare function applyBusinessDayX(x: Float32Array | Float64Array, xAxis: AxisOptions): {
+    displayX: Float64Array;
+    mapping: BusinessDayMapping;
+};
+export declare function formatBusinessDayTick(logicalIndex: number, mapping: BusinessDayMapping): string | null;