@vninvestcharts/widget 0.0.0-stage → 0.2.0

package/dist/dts/lib/core/calculators/indicatorComputationTypes.d.ts

@@ -0,0 +1,249 @@
+/**
+ * Kiểu dữ liệu của `indicatorComputation` — SSOT cho cả plan lẫn result.
+ *
+ * Tách ra khỏi `indicatorComputation.ts` (split 2026-09-30) vì cả
+ * `buildIndicatorComputationPlan`, `computeIndicatorComputationResult` và
+ * `materializeIndicatorValues` đều cần đúng những kiểu này, và chúng đã vượt
+ * budget 800 dòng khi nằm chung. Module này chỉ khai báo kiểu + import kiểu, nên
+ * không tạo cạnh runtime nào trong đồ thị phụ thuộc.
+ */
+import type { SeriesConfig } from "../types/pane-descriptor";
+import type { calcCVDApprox } from "./calcCVDApprox";
+import type { calcStrengthElder } from "./calcStrengthElder";
+import type { IndicatorAcValue, IndicatorAlligatorValue, IndicatorBandValue, IndicatorBrarValue, IndicatorCrValue, IndicatorDmaValue, IndicatorDmiValue, IndicatorDonchianValue, IndicatorEmvValue, IndicatorFractalValue, IndicatorGatorValue, IndicatorIchimokuValue, IndicatorKdjValue, IndicatorKeltnerValue, IndicatorMacdValue, IndicatorMARibbonValue, IndicatorMtmValue, IndicatorPivotValue, IndicatorPsyValue, IndicatorSupertrendValue, IndicatorTrixValue, IndicatorVwapValue, IndicatorWhaleValue, IndicatorWyckoffValue, MarketProfileData, VolumeProfileData, FootprintBar, DeltaProfileData, RawOHLCV } from "./types";
+export interface MacdConfig {
+    fast: number;
+    slow: number;
+    signal: number;
+}
+export interface BollingerConfig {
+    period: number;
+    stdDev: number;
+}
+export interface KdjConfig {
+    period: number;
+    m1: number;
+    m2: number;
+}
+export interface PeriodSignalConfig {
+    period: number;
+    signalPeriod: number;
+}
+export interface DmaConfig {
+    fastPeriod: number;
+    slowPeriod: number;
+    signalPeriod: number;
+}
+export interface CrConfig {
+    period: number;
+    m1: number;
+    m2: number;
+    m3: number;
+    m4: number;
+}
+/** Đầu vào tuỳ chọn của `computeIndicatorComputationResult` (ngoài `raw` + `plan`). */
+export interface IndicatorComputationOptions {
+    compareBarsBySymbol?: Record<string, readonly RawOHLCV[]>;
+    mtfBars?: Record<string, readonly RawOHLCV[]>;
+    asyncVolumeProfiles?: Record<string, VolumeProfileData>;
+}
+export interface IndicatorComputationPlan {
+    emaPeriods: Set<number>;
+    smaPeriods: Set<number>;
+    rsiPeriods: Set<number>;
+    macdConfigs: Map<string, MacdConfig>;
+    bollingerConfigs: Map<string, BollingerConfig>;
+    whaleThresholds: Set<number>;
+    bbiEnabled: boolean;
+    sarByKey: Map<string, {
+        afStep: number;
+        afMax: number;
+    }>;
+    obvEnabled: boolean;
+    wrPeriods: Set<number>;
+    vrPeriods: Set<number>;
+    kdjConfigs: Map<string, KdjConfig>;
+    cciPeriods: Set<number>;
+    dmiPeriods: Set<number>;
+    biasPeriods: Set<number>;
+    brarPeriods: Set<number>;
+    mtmConfigs: Map<string, PeriodSignalConfig>;
+    emvPeriods: Set<number>;
+    aoEnabled: boolean;
+    rocPeriods: Set<number>;
+    trixConfigs: Map<string, PeriodSignalConfig>;
+    dmaConfigs: Map<string, DmaConfig>;
+    pvtEnabled: boolean;
+    psyConfigs: Map<string, PeriodSignalConfig>;
+    crConfigs: Map<string, CrConfig>;
+    defaultMacdKey: string;
+    defaultBollingerKey: string;
+    defaultWhaleKey: string;
+    wmaPeriods: Set<number>;
+    vwmaPeriods: Set<number>;
+    hmaPeriods: Set<number>;
+    demaPeriods: Set<number>;
+    temaPeriods: Set<number>;
+    maRibbonConfigs: Map<string, {
+        type: "SMA" | "EMA";
+        periods: number[];
+    }>;
+    ichimokuConfigs: Map<string, {
+        tenkan: number;
+        kijun: number;
+        senkouB: number;
+        displacement: number;
+    }>;
+    supertrendConfigs: Map<string, {
+        period: number;
+        multiplier: number;
+    }>;
+    keltnerConfigs: Map<string, {
+        period: number;
+        atrPeriod: number;
+        multiplier: number;
+    }>;
+    donchianPeriods: Set<number>;
+    chaikinVolPeriods: Set<number>;
+    stdDevPeriods: Set<number>;
+    hvConfigs: Map<string, {
+        period: number;
+        annualize: boolean;
+    }>;
+    ciPeriods: Set<number>;
+    cmfPeriods: Set<number>;
+    mfiPeriods: Set<number>;
+    volOscConfigs: Map<string, {
+        shortPeriod: number;
+        longPeriod: number;
+    }>;
+    chaikinOscConfigs: Map<string, {
+        fast: number;
+        slow: number;
+    }>;
+    vwapConfigs: Map<string, {
+        anchor: "session" | "week" | "month";
+        showBands: boolean;
+        multiplier: number;
+    }>;
+    anchoredVwapConfigs: Map<string, {
+        anchorTime: number;
+        showBands: boolean;
+        multiplier: number;
+    }>;
+    alligatorConfigs: Map<string, {
+        jawPeriod: number;
+        jawShift: number;
+        teethPeriod: number;
+        teethShift: number;
+        lipsPeriod: number;
+        lipsShift: number;
+    }>;
+    fractalsEnabled: boolean;
+    gatorConfigs: Map<string, {
+        jawPeriod: number;
+        jawShift: number;
+        teethPeriod: number;
+        teethShift: number;
+        lipsPeriod: number;
+        lipsShift: number;
+    }>;
+    acEnabled: boolean;
+    pivotStandardConfigs: Map<string, {
+        pivotType: number;
+    }>;
+    pivotHighLowConfigs: Map<string, {
+        lookback: number;
+        pivotType: number;
+    }>;
+    marketProfileConfigs: Map<string, {
+        sessionStart?: number;
+        sessionEnd?: number;
+        tickSize: number;
+        tpoPeriodMinutes: number;
+    }>;
+    volumeProfileConfigs: Map<string, {
+        priceTickSize: number;
+    }>;
+    footprintConfigs: Map<string, {
+        barIntervalMs: number;
+        priceTickSize: number;
+    }>;
+    deltaProfileConfigs: Map<string, {
+        barIntervalMs: number;
+        priceTickSize: number;
+        smaPeriod: number;
+    }>;
+    strengthRelativeConfigs: Map<string, {
+        compareSymbol: string;
+        period: number;
+    }>;
+    smfiEnabled: boolean;
+    wyckoffWaveConfigs: Map<string, {
+        thresholdPercent: number;
+    }>;
+    orderedSeries: readonly SeriesConfig[];
+}
+export interface IndicatorComputationResult {
+    valuesByKey: Map<string, Array<any>>;
+    emaByPeriod: Map<number, Array<number | undefined>>;
+    smaByPeriod: Map<number, Array<number | undefined>>;
+    rsiByPeriod: Map<number, Array<number | undefined>>;
+    macdByKey: Map<string, Array<IndicatorMacdValue | undefined>>;
+    bollingerByKey: Map<string, Array<IndicatorBandValue | undefined>>;
+    whaleByKey: Map<string, Array<IndicatorWhaleValue | undefined>>;
+    bbi: Array<number | undefined>;
+    sarByKey: Map<string, Array<number | undefined>>;
+    obv: Array<number | undefined>;
+    wrByPeriod: Map<number, Array<number | undefined>>;
+    vrByPeriod: Map<number, Array<number | undefined>>;
+    kdjByKey: Map<string, Array<IndicatorKdjValue | undefined>>;
+    cciByPeriod: Map<number, Array<number | undefined>>;
+    dmiByPeriod: Map<number, Array<IndicatorDmiValue | undefined>>;
+    biasByPeriod: Map<number, Array<number | undefined>>;
+    brarByPeriod: Map<number, Array<IndicatorBrarValue | undefined>>;
+    mtmByKey: Map<string, Array<IndicatorMtmValue | undefined>>;
+    emvByPeriod: Map<number, Array<IndicatorEmvValue | undefined>>;
+    ao: Array<number | undefined>;
+    rocByPeriod: Map<number, Array<number | undefined>>;
+    trixByKey: Map<string, Array<IndicatorTrixValue | undefined>>;
+    dmaByKey: Map<string, Array<IndicatorDmaValue | undefined>>;
+    pvt: Array<number | undefined>;
+    psyByKey: Map<string, Array<IndicatorPsyValue | undefined>>;
+    crByKey: Map<string, Array<IndicatorCrValue | undefined>>;
+    cvd: ReturnType<typeof calcCVDApprox>;
+    strength: ReturnType<typeof calcStrengthElder>;
+    wmaByPeriod: Map<number, Array<number | undefined>>;
+    vwmaByPeriod: Map<number, Array<number | undefined>>;
+    hmaByPeriod: Map<number, Array<number | undefined>>;
+    demaByPeriod: Map<number, Array<number | undefined>>;
+    temaByPeriod: Map<number, Array<number | undefined>>;
+    maRibbonByKey: Map<string, Array<IndicatorMARibbonValue | undefined>>;
+    ichimokuByKey: Map<string, Array<IndicatorIchimokuValue | undefined>>;
+    supertrendByKey: Map<string, Array<IndicatorSupertrendValue | undefined>>;
+    keltnerByKey: Map<string, Array<IndicatorKeltnerValue | undefined>>;
+    donchianByPeriod: Map<number, Array<IndicatorDonchianValue | undefined>>;
+    chaikinVolByPeriod: Map<number, Array<number | undefined>>;
+    stdDevByPeriod: Map<number, Array<number | undefined>>;
+    hvByKey: Map<string, Array<number | undefined>>;
+    ciByPeriod: Map<number, Array<number | undefined>>;
+    cmfByPeriod: Map<number, Array<number | undefined>>;
+    mfiByPeriod: Map<number, Array<number | undefined>>;
+    volOscByKey: Map<string, Array<number | undefined>>;
+    chaikinOscByKey: Map<string, Array<number | undefined>>;
+    vwapByKey: Map<string, Array<IndicatorVwapValue | undefined>>;
+    anchoredVwapByKey: Map<string, Array<IndicatorVwapValue | undefined>>;
+    alligatorByKey: Map<string, Array<IndicatorAlligatorValue | undefined>>;
+    fractals: Array<IndicatorFractalValue | undefined>;
+    gatorByKey: Map<string, Array<IndicatorGatorValue | undefined>>;
+    ac: Array<IndicatorAcValue | undefined>;
+    pivotStandardByKey: Map<string, Array<IndicatorPivotValue | undefined>>;
+    pivotHighLowByKey: Map<string, Array<IndicatorPivotValue | undefined>>;
+    marketProfileByKey: Map<string, MarketProfileData>;
+    volumeProfileByKey: Map<string, VolumeProfileData>;
+    footprintByKey: Map<string, FootprintBar[]>;
+    deltaProfileByKey: Map<string, DeltaProfileData>;
+    strengthRelativeByKey: Map<string, Array<number | undefined>>;
+    smfi: Array<number | undefined>;
+    wyckoffWaveByKey: Map<string, Array<IndicatorWyckoffValue | undefined>>;
+}

package/dist/dts/lib/core/calculators/materializeIndicatorValues.d.ts

@@ -0,0 +1,3 @@
+import type { IndicatorComputationPlan, IndicatorComputationResult } from "./indicatorComputationTypes";
+import type { IndicatorDatumValue, RawOHLCV } from "./types";
+export declare function materializeIndicatorValues(index: number, plan: IndicatorComputationPlan, result: IndicatorComputationResult, raw?: readonly RawOHLCV[]): Record<string, IndicatorDatumValue | undefined>;

package/dist/dts/lib/core/calculators/normalizePrices.d.ts

@@ -0,0 +1,36 @@
+export interface SymbolDataEntry {
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+    volume: number;
+}
+/**
+ * Compute % change for each overlay bar relative to a baseline price.
+ *
+ * @param overlayBars - Aligned overlay OHLCV bars (same length as primary)
+ * @param basePrice   - Baseline price (typically primary close at index 0)
+ * @param baselineIndex - Which bar index is the baseline anchor (default 0)
+ * @returns Normalized % values per bar index: ((close - basePrice) / basePrice) * 100
+ */
+export declare function computeNormalizedPrices(overlayBars: readonly SymbolDataEntry[], basePrice: number, baselineIndex?: number): number[];
+/**
+ * Takes the primary bars + overlay bars by symbol and produces
+ * per-index symbolData and normalizedPrices ready to merge into EnrichedDatum.
+ *
+ * @param primaryBars - Primary symbol OHLCV bars
+ * @param overlaysBySymbol - Overlay symbolId → aligned OHLCV bars
+ * @param baselineIndex - Bar index used as baseline anchor (default 0)
+ * @param primarySymbolKey - When set, the PRIMARY symbol also gets an entry in
+ *   `normalizedPrices` under this key (percent change from the anchor bar).
+ *   Without it the primary is only the DENOMINATOR (`basePrice`) and never
+ *   appears as a value — which is correct for a Comparison overlay, and wrong
+ *   for a Baseline chart, whose whole subject IS the primary series.
+ *   A3: this is the one knob that makes Baseline readable off the same,
+ *   already-proven writer instead of a second normaliser.
+ * @returns symbolData and normalizedPrices maps per index
+ */
+export declare function normalizePricesToBaseline(primaryBars: readonly SymbolDataEntry[], overlaysBySymbol: Record<string, readonly SymbolDataEntry[]>, baselineIndex?: number, filterSymbolIds?: Set<string>, primarySymbolKey?: string): {
+    symbolData: Record<string, SymbolDataEntry>[];
+    normalizedPrices: Record<string, number>[];
+};

package/dist/dts/lib/core/calculators/resolveCalculationOrder.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Sắp series theo thứ tự phụ thuộc (indicator-on-indicator).
+ *
+ * Tách riêng (split 2026-09-30) vì nó là hàm thuần tuý không phụ thuộc gì, và
+ * `buildIndicatorComputationPlan` chỉ gọi nó đúng một lần ở cuối — giữ riêng
+ * giúp thứ tự luôn là hợp đồng: thứ tự này quyết định thứ tự ghi `valuesByKey`
+ * (lần lượt: series gốc trước, rồi series con), không phải thứ tự khai báo.
+ */
+import type { SeriesConfig } from "../types/pane-descriptor";
+/**
+ * Trả về `indicators` đã sắp lại sao cho mọi series cha luôn nằm trước series con.
+ *
+ * Duyệt theo `forEach` nên thứ tự vào giữ nguyên với thứ tự đã sắp; chỉ chuỗi hậu
+ * duyệt là đảo chiều khi phụ thuộc. `visited` chống hồi quy vô hạn khi ba series
+ * trỏ vòng lại nhau.
+ */
+export declare function resolveCalculationOrder(indicators: readonly SeriesConfig[]): SeriesConfig[];

package/dist/dts/lib/core/calculators/types.d.ts

@@ -0,0 +1,269 @@
+export interface RawOHLCV {
+    date: Date;
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+    volume: number;
+}
+export interface IndicatorBandValue {
+    top: number;
+    middle: number;
+    bottom: number;
+}
+export interface IndicatorMacdValue {
+    macd: number;
+    signal: number;
+    divergence: number;
+}
+export interface IndicatorWhaleValue {
+    whaleBuyVol?: number;
+    whaleSellVol?: number;
+}
+export interface IndicatorKdjValue {
+    k: number;
+    d: number;
+    j: number;
+}
+export interface IndicatorDmiValue {
+    plusDI: number;
+    minusDI: number;
+    adx: number;
+}
+export interface IndicatorBrarValue {
+    ar: number;
+    br: number;
+}
+export interface IndicatorMtmValue {
+    mtm: number;
+    signal: number;
+}
+export interface IndicatorEmvValue {
+    emv: number;
+    signal: number;
+}
+export interface IndicatorTrixValue {
+    trix: number;
+    signal: number;
+}
+export interface IndicatorDmaValue {
+    ddd: number;
+    ama: number;
+}
+export interface IndicatorPsyValue {
+    psy: number;
+    signal: number;
+}
+export interface IndicatorCrValue {
+    cr: number;
+    ma1: number;
+    ma2: number;
+    ma3: number;
+    ma4: number;
+}
+export interface IndicatorStrengthElderValue {
+    bullPower: number;
+    bearPower: number;
+}
+export interface IndicatorIchimokuValue {
+    tenkan: number;
+    kijun: number;
+    senkouA: number;
+    senkouB: number;
+    chikou: number;
+}
+export interface IndicatorSupertrendValue {
+    supertrend: number;
+    direction: number;
+    upperBand: number;
+    lowerBand: number;
+}
+export interface IndicatorKeltnerValue {
+    upper: number;
+    middle: number;
+    lower: number;
+}
+export interface IndicatorDonchianValue {
+    upper: number;
+    middle: number;
+    lower: number;
+}
+export type IndicatorMARibbonValue = Record<string, number>;
+export interface IndicatorAlligatorValue {
+    jaw: number;
+    teeth: number;
+    lips: number;
+}
+export interface IndicatorFractalValue {
+    bearish: number;
+    bullish: number;
+}
+export interface IndicatorGatorValue {
+    upper: number;
+    lower: number;
+}
+export interface IndicatorPivotValue {
+    pp: number;
+    r1: number;
+    s1: number;
+    r2: number;
+    s2: number;
+    r3: number;
+    s3: number;
+}
+export interface IndicatorVwapValue {
+    vwap: number;
+    upper1: number;
+    lower1: number;
+    upper2: number;
+    lower2: number;
+    upper3: number;
+    lower3: number;
+}
+export interface IndicatorAcValue {
+    ac: number;
+    color: string;
+}
+export interface TPOBlock {
+    price: number;
+    letter: string;
+    volume: number;
+    timeStart: number;
+    timeEnd: number;
+}
+export interface MarketProfileData {
+    tpoBlocks: TPOBlock[];
+    poc: number;
+    valueAreaHigh: number;
+    valueAreaLow: number;
+    initialBalanceHigh: number;
+    initialBalanceLow: number;
+    profileHigh: number;
+    profileLow: number;
+}
+export interface VolumeProfileLevel {
+    price: number;
+    volume: number;
+    buyVolume: number;
+    sellVolume: number;
+}
+export interface VolumeProfileData {
+    priceLevels: VolumeProfileLevel[];
+    poc: number;
+    valueAreaHigh: number;
+    valueAreaLow: number;
+    highVolumeNodes: number[];
+    lowVolumeNodes: number[];
+}
+export interface FootprintLevel {
+    price: number;
+    bidVolume: number;
+    askVolume: number;
+    delta: number;
+    deltaPercent: number;
+    totalVolume: number;
+}
+export interface FootprintBar {
+    timestamp: number;
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+    priceLevels: FootprintLevel[];
+}
+export interface DeltaProfileData {
+    cumulativeDelta: number[];
+    barDelta: number[];
+    deltaSMA: number[];
+    divergenceSignals: Array<{
+        index: number;
+        type: "bullish" | "bearish";
+    }>;
+}
+export interface IndicatorDeltaProfileValue {
+    cumulativeDelta: number;
+    barDelta: number;
+    deltaSMA: number;
+    divergence?: "bullish" | "bearish";
+}
+export interface IndicatorWyckoffValue {
+    direction: number;
+    zigzag: number;
+    waveVolume: number;
+    waveDuration: number;
+    isPivot: boolean;
+}
+export type IndicatorDatumValue = number | IndicatorBandValue | IndicatorMacdValue | IndicatorWhaleValue | IndicatorKdjValue | IndicatorDmiValue | IndicatorBrarValue | IndicatorMtmValue | IndicatorEmvValue | IndicatorTrixValue | IndicatorDmaValue | IndicatorPsyValue | IndicatorCrValue | IndicatorStrengthElderValue | IndicatorIchimokuValue | IndicatorSupertrendValue | IndicatorKeltnerValue | IndicatorDonchianValue | IndicatorMARibbonValue | IndicatorAlligatorValue | IndicatorFractalValue | IndicatorGatorValue | IndicatorPivotValue | IndicatorVwapValue | IndicatorAcValue | MarketProfileData | VolumeProfileData | FootprintBar | DeltaProfileData | IndicatorDeltaProfileValue | IndicatorWyckoffValue;
+/** Hướng của một nhánh kagi. `yang` = đang tăng, `yin` = đang giảm. */
+export type KagiDirection = "yang" | "yin";
+/** Hướng của một cột Point & Figure. `up` = cột đi lên. */
+export type PnfDirection = "up" | "down";
+/**
+ * Một box của cột Point & Figure. Cao đúng MỘT bậc giá (`boxSize`), nên `open`
+ * và `close` là hai mép kề nhau — cột là một thang box liền nhau, không phải
+ * các hộp rời.
+ */
+export interface PnfBox {
+    open: number;
+    close: number;
+}
+export interface EnrichedDatum extends RawOHLCV {
+    aoColor?: string;
+    indicatorValues?: Record<string, IndicatorDatumValue | undefined>;
+    symbolData?: Record<string, {
+        open: number;
+        high: number;
+        low: number;
+        close: number;
+        volume: number;
+    }>;
+    normalizedPrices?: Record<string, number>;
+    /** Giá mở của viên gạch renko tạo ra trong bar này. */
+    renkoOpen?: number;
+    /** Giá đóng (đầu trên) của viên gạch renko — giá trị engine vẽ. */
+    renkoClose?: number;
+    /** `true` = gạch tăng. */
+    renkoUp?: boolean;
+    /**
+     * `false` = gạch dang dở (giá chưa đủ một bậc). Engine tô màu trung tính để
+     * không ai đọc nhầm là giá đóng. `RenkoSeries` cũng đọc field này.
+     */
+    fullyFormed?: boolean;
+    /** Hướng của nhánh kagi đang chạy tại bar này. */
+    startAs?: KagiDirection;
+    /** Hướng sau khi đảo chiều tại bar này (vắng = không đảo). */
+    changeTo?: KagiDirection;
+    /** Giá tại đó nhánh đảo chiều. */
+    changePoint?: number;
+    /** Mức giá mà nhánh hiện tại bắt đầu. */
+    reverseAt?: number;
+    /** Mức giá kagi đang sống — hằng cho tới lần đảo kế tiếp. */
+    current?: number;
+    /** Các box cột P&F tạo ra tại bar này. Bar không tạo box thì KHÔNG ghi field này. */
+    boxes?: readonly PnfBox[];
+    /** Chỉ số bar MỞ ĐẦU cột hiện tại ( tuyệt đối trong `enrichedData`) — đó là x của cả cột. */
+    pnfColumnStart?: number;
+    /** Hướng của cột, để engine chọn màu tăng/giảm. */
+    pnfDirection?: PnfDirection;
+    /** Mức mở của đường line break đang chạy. */
+    lineBreakOpen?: number;
+    /** Mức đóng (đầu bậc thang) của đường line break — giá trị engine vẽ. */
+    lineBreakClose?: number;
+    /** Hướng của đường đang chạy. */
+    lineBreakUp?: boolean;
+    /**
+     * Nến khung thời gian CAO hơn tương ứng với bar LTF này, do
+     * `useWidgetData` gán khi `overlayTimeframe` khác khung chart.
+     * Trước khi field này tồn tại, `HTFOverlay` bị đọc dưới kiểu `any`
+     * (`(d: any) => d.htf?.close`) trong khi `resolveSeriesValue` không có
+     * case → tooltip/legend đọc nhầm `close` của khung hiện tại.
+     */
+    htf?: {
+        open: number;
+        high: number;
+        low: number;
+        close: number;
+        periodStart: number;
+        isClosed: boolean;
+    };
+}

package/dist/dts/lib/core/canvas/ChartRenderContext.d.ts

@@ -0,0 +1,14 @@
+import type { VisibleRange } from "../types/chart";
+export interface ChartRenderContextValue {
+    xScale: (value: Date) => number;
+    xScaleByIndex?: (index: number) => number;
+    yScale: (value: number) => number;
+    plotData: readonly Record<string, unknown>[];
+    candleWidth: number;
+    devicePixelRatio: number;
+    visibleRange: VisibleRange | null;
+    width: number;
+    height: number;
+}
+export declare const ChartRenderContext: import("react").Context<ChartRenderContextValue | null>;
+export declare function useChartRenderContext(): ChartRenderContextValue;

package/dist/dts/lib/core/canvas/OverlayCanvas.d.ts

@@ -0,0 +1,19 @@
+import type { ChartRenderContextValue } from "./ChartRenderContext";
+export interface OverlayDrawContext {
+    ctx: CanvasRenderingContext2D;
+    xScale: ChartRenderContextValue["xScale"];
+    xScaleByIndex: ChartRenderContextValue["xScaleByIndex"];
+    yScale: ChartRenderContextValue["yScale"];
+    plotData: ChartRenderContextValue["plotData"];
+    candleWidth: ChartRenderContextValue["candleWidth"];
+    devicePixelRatio: ChartRenderContextValue["devicePixelRatio"];
+    visibleRange: ChartRenderContextValue["visibleRange"];
+    width: ChartRenderContextValue["width"];
+    height: ChartRenderContextValue["height"];
+}
+export interface OverlayCanvasProps {
+    draw: (context: OverlayDrawContext) => void;
+    zIndex?: number;
+    className?: string;
+}
+export declare function OverlayCanvas({ draw, zIndex, className }: OverlayCanvasProps): import("react").JSX.Element;

package/dist/dts/lib/core/context/ChartSyncContext.d.ts

@@ -0,0 +1,21 @@
+import type { ReactNode } from "react";
+import type { ScaleLinear } from "d3-scale";
+import type { OHLCVBar } from "../../types/ohlcv";
+import type { PaneConfig } from "../../types/pane";
+export interface ChartSyncState {
+    pane: PaneConfig;
+    data: readonly OHLCVBar[];
+    visibleData: readonly OHLCVBar[];
+    width: number;
+    height: number;
+    leftScale: ScaleLinear<number, number>;
+    rightScale?: ScaleLinear<number, number>;
+}
+declare const ChartSyncContext: import("react").Context<ChartSyncState | undefined>;
+export interface ChartSyncProviderProps {
+    value: ChartSyncState;
+    children: ReactNode;
+}
+export declare function ChartSyncProvider({ value, children }: ChartSyncProviderProps): import("react").FunctionComponentElement<import("react").ProviderProps<ChartSyncState | undefined>>;
+export declare function useChartSync(): ChartSyncState;
+export { ChartSyncContext };

package/dist/dts/lib/core/context/DataContext.d.ts

@@ -0,0 +1,15 @@
+import type { ReactNode } from "react";
+import type { StockDataAdapter } from "../../types/adapter";
+import type { OHLCVBar } from "../../types/ohlcv";
+export interface DataContextValue {
+    data: readonly OHLCVBar[];
+    adapter?: StockDataAdapter;
+}
+declare const DataContext: import("react").Context<DataContextValue | undefined>;
+export interface DataProviderProps {
+    value: DataContextValue;
+    children: ReactNode;
+}
+export declare function DataProvider({ value, children }: DataProviderProps): import("react").FunctionComponentElement<import("react").ProviderProps<DataContextValue | undefined>>;
+export declare function useDataContext(): DataContextValue;
+export { DataContext };

package/dist/dts/lib/core/context/PaneManagerContext.d.ts

@@ -0,0 +1,10 @@
+import type { ReactNode } from "react";
+import type { PaneManagerState } from "../hooks/usePaneManager";
+declare const PaneManagerContext: import("react").Context<PaneManagerState | undefined>;
+export interface PaneManagerProviderProps {
+    value: PaneManagerState;
+    children: ReactNode;
+}
+export declare function PaneManagerProvider({ value, children }: PaneManagerProviderProps): import("react").FunctionComponentElement<import("react").ProviderProps<PaneManagerState | undefined>>;
+export declare function usePaneManagerContext(): PaneManagerState;
+export { PaneManagerContext };

package/dist/dts/lib/core/hooks/paneSizingHelpers.d.ts

@@ -0,0 +1,13 @@
+import type { PaneDescriptor } from "../types/pane-descriptor";
+export declare const MIN_PRICE_PANE_HEIGHT = 80;
+export declare const MIN_VOLUME_PANE_HEIGHT = 36;
+export declare const MIN_INDICATOR_PANE_HEIGHT = 48;
+export declare const MIN_GENERIC_PANE_HEIGHT = 40;
+export declare function getPaneMinHeight(pane: PaneDescriptor): number;
+export declare function calculatePaneHeights(panes: readonly PaneDescriptor[], available: number): number[];
+export declare function calculateSplitterBounds(topPane: PaneDescriptor, bottomPane: PaneDescriptor, topHeight: number, bottomHeight: number): {
+    minDeltaY: number;
+    maxDeltaY: number;
+};
+export declare function applySplitterDelta(heights: readonly number[], splitterIndex: number, deltaY: number, visiblePanes: readonly PaneDescriptor[]): number[];
+export declare function equalizePairHeights(heights: readonly number[], splitterIndex: number, visiblePanes: readonly PaneDescriptor[]): number[];

package/dist/dts/lib/core/hooks/useCanvasResize.d.ts

@@ -0,0 +1,8 @@
+export interface CanvasSize {
+    width: number;
+    height: number;
+}
+export declare function useCanvasResize<TElement extends HTMLElement = HTMLDivElement>(): {
+    ref: import("react").RefObject<TElement | null>;
+    size: CanvasSize;
+};