@vninvestcharts/widget 0.0.0-stage → 0.2.0

package/dist/dts/lib/core/IndicatorLegend.d.ts

@@ -0,0 +1,47 @@
+import type { CSSProperties, ReactNode } from "react";
+import type { PaneDescriptor, SeriesTypeId } from "./types/pane-descriptor";
+export interface IndicatorLegendProps {
+    pane: PaneDescriptor;
+    onToggleSeries: (seriesType: SeriesTypeId, seriesIndex?: number) => void;
+    onRemoveSeries: (seriesType: SeriesTypeId, seriesIndex?: number) => void;
+    /** Optional: open per-series settings (gear button). Omitted = no gear button. */
+    onEditSeries?: (seriesType: SeriesTypeId, seriesIndex?: number) => void;
+    /** Optional vector glyphs (widget layer passes Icons.tsx). Defaults preserve legacy glyphs. */
+    icons?: {
+        eye?: ReactNode;
+        eyeOff?: ReactNode;
+        edit?: ReactNode;
+        remove?: ReactNode;
+    };
+    className?: string;
+    style?: CSSProperties;
+    labels?: {
+        seriesLabel?: (seriesType: SeriesTypeId, params?: Record<string, unknown>) => string;
+        showIndicatorTitle?: string;
+        hideIndicatorTitle?: string;
+        removeIndicatorTitle?: string;
+        editIndicatorTitle?: string;
+        showIndicatorAriaLabel?: (seriesLabel: string) => string;
+        hideIndicatorAriaLabel?: (seriesLabel: string) => string;
+        removeIndicatorAriaLabel?: (seriesLabel: string) => string;
+        editIndicatorAriaLabel?: (seriesLabel: string) => string;
+    };
+    /** Per-series suffix appended after the label (e.g. "+2.34%"). Indexed by position in pane.series. */
+    seriesSuffix?: (seriesIndex: number) => string | undefined;
+    /** UI-P3: live value shown after the label (e.g. "204.22K"). Indexed by position in pane.series. */
+    seriesValue?: (seriesType: SeriesTypeId, seriesIndex: number) => {
+        text: string;
+        color?: string;
+    } | undefined;
+    /** When true, render inline inside the pane header row (rsc-pane-header__legend) instead of the separate below-header row. */
+    embedded?: boolean;
+    /**
+     * DECLUTTER_V4: render-only series filter. `visibleTypes` allowlists and
+     * `hiddenTypes` denylists chip rendering WITHOUT touching `pane.series`,
+     * so `seriesSuffix`/`seriesValue` indices (position in pane.series) stay
+     * exact. Used to relocate compare chips between header and statusline.
+     */
+    visibleTypes?: readonly string[];
+    hiddenTypes?: readonly string[];
+}
+export declare function IndicatorLegend({ pane, onToggleSeries, onRemoveSeries, onEditSeries, icons, className, style, labels, seriesSuffix, seriesValue, embedded, visibleTypes, hiddenTypes }: IndicatorLegendProps): import("react").JSX.Element | null;

package/dist/dts/lib/core/PaneHeader.d.ts

@@ -0,0 +1,24 @@
+import type { CSSProperties, ReactNode, RefObject, DragEvent as ReactDragEvent } from "react";
+import type { PaneDescriptor } from "./types/pane-descriptor";
+export interface PaneHeaderProps {
+    pane: PaneDescriptor;
+    onToggleVisible: () => void;
+    onRemove: () => void;
+    onAddSeries?: () => void;
+    onDragStart?: (event: ReactDragEvent<HTMLButtonElement>) => void;
+    addButtonRef?: RefObject<HTMLButtonElement | null>;
+    className?: string;
+    children?: ReactNode;
+    style?: CSSProperties;
+    labels?: {
+        dragAriaLabel?: (paneLabel: string) => string;
+        dragTitle?: (pane: PaneDescriptor) => string;
+        addSeriesAriaLabel?: (paneLabel: string) => string;
+        addSeriesTitle?: string;
+        toggleVisibleAriaLabel?: (paneLabel: string, visible: boolean) => string;
+        toggleVisibleTitle?: (pane: PaneDescriptor) => string;
+        removeAriaLabel?: (paneLabel: string) => string;
+        removeTitle?: string;
+    };
+}
+export declare function PaneHeader({ pane, onToggleVisible, onRemove, onAddSeries, onDragStart, addButtonRef, className, children, labels, style: externalStyle }: PaneHeaderProps): import("react").JSX.Element;

package/dist/dts/lib/core/PaneLabel.d.ts

@@ -0,0 +1,8 @@
+export interface PaneLabelProps {
+    label: string;
+    top: number;
+    height: number;
+    isDark?: boolean;
+    className?: string;
+}
+export declare function PaneLabel({ label, top, height, className }: PaneLabelProps): import("react").JSX.Element;

package/dist/dts/lib/core/PaneSplitter.d.ts

@@ -0,0 +1,9 @@
+import type { CSSProperties } from "react";
+export interface PaneSplitterProps {
+    onResize: (topPaneNewHeightPx: number) => void;
+    minTopHeight?: number;
+    minBottomHeight?: number;
+    className?: string;
+    style?: CSSProperties;
+}
+export declare function PaneSplitter({ onResize, minTopHeight, minBottomHeight, className, style }: PaneSplitterProps): import("react").JSX.Element;

package/dist/dts/lib/core/SeriesPicker.d.ts

@@ -0,0 +1,10 @@
+import type { RefObject } from "react";
+import type { PaneDescriptor, SeriesConfig, SeriesTypeId } from "./types/pane-descriptor";
+export interface SeriesPickerProps {
+    pane: PaneDescriptor;
+    onAddSeries: (series: SeriesConfig) => void;
+    onRemoveSeries: (type: SeriesTypeId) => void;
+    anchorRef: RefObject<HTMLButtonElement | null>;
+    onClose?: () => void;
+}
+export declare function SeriesPicker({ pane, onAddSeries, onRemoveSeries, anchorRef, onClose }: SeriesPickerProps): import("react").JSX.Element;

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

@@ -0,0 +1,38 @@
+export interface AlignedBarData {
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+    volume: number;
+}
+export declare function formatDateInTimezone(date: Date, timezone: string): string;
+export declare function estimateTimeframeMs(bars: readonly {
+    date: Date;
+}[]): number;
+export declare function isDailyOrLarger(ms: number): boolean;
+/**
+ * Align overlay bars to primary bars by date, timezone-aware.
+ *
+ * - Daily+: Match by date string (YYYY-MM-DD in configured timezone)
+ * - Intraday: Match by nearest bar within timeframeMs tolerance (binary search)
+ *
+ * @param primaryBars - Primary symbol bars
+ * @param overlayBars - Overlay symbol bars
+ * @param timezone    - Timezone for date formatting (default: from global SSOT)
+ * @returns Array of AlignedBarData | undefined (aligned to primary bar index)
+ */
+export declare function alignBarsByDate(primaryBars: readonly {
+    date: Date;
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+    volume: number;
+}[], overlayBars: readonly {
+    date: Date;
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+    volume: number;
+}[], timezone?: string): (AlignedBarData | undefined)[];

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

@@ -0,0 +1,16 @@
+/**
+ * Tầng 1/2: đọc danh sách series của pane và gom thành `IndicatorComputationPlan`.
+ *
+ * Plan là BẢNG TRA CỨU trước khi tính: "với mọi bar này, tôi cần EMA bao nhiêu kỳ,
+ * MACD nào theo khoá nào". Tách plan khỏi compute (split 2026-09-30) vì nó là
+ * một hàm duy nhất với một `switch` 60+ nhánh: giữ nguyên khối lớn này trong một
+ * file (thay vì nhặt case rải rác) giữ nguyên khả năng đọc theo thứ tự lịch sử, và
+ * 540 dòng vẫn dưới trần mặc định 800 — điểm cần nới là file 1933 dòng trước đây.
+ *
+ * Thuần diễn dịch: `switch (normalizeSeriesTypeId(type))` là toàn bộ "ngôn ngữ" của
+ * hàm này. Thêm một nhánh = thêm một `case`; không có bảng tra cứu thứ hai phải
+ * đồng bộ.
+ */
+import { type SeriesConfig } from "../types/pane-descriptor";
+import type { IndicatorComputationPlan } from "./indicatorComputationTypes";
+export declare function buildIndicatorComputationPlan(series: readonly SeriesConfig[], whaleThreshold: number): IndicatorComputationPlan;

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

@@ -0,0 +1,6 @@
+import type { RawOHLCV } from "./types";
+export interface CVDApproxPoint {
+    cvdApprox?: number;
+    cvdDelta?: number;
+}
+export declare function calcCVDApprox(raw: readonly RawOHLCV[]): CVDApproxPoint[];

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

@@ -0,0 +1,7 @@
+import type { RawOHLCV } from "./types";
+export interface StrengthElderPoint {
+    ema13?: number;
+    bullPower?: number;
+    bearPower?: number;
+}
+export declare function calcStrengthElder(raw: readonly RawOHLCV[]): StrengthElderPoint[];

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

@@ -0,0 +1,6 @@
+import type { RawOHLCV } from "./types";
+export interface WhaleApproxPoint {
+    whaleBuyVol?: number;
+    whaleSellVol?: number;
+}
+export declare function calcWhaleApprox(raw: readonly RawOHLCV[], threshold?: number): WhaleApproxPoint[];

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

@@ -0,0 +1,12 @@
+import type { SeriesConfig } from "../types/pane-descriptor";
+import type { IndicatorBandValue } from "./types";
+/** Trả về mảng `undefined` cho `startIndex` phần tử đầu (warmup của các bộ lọc). */
+export declare function blankUntil<T>(values: readonly T[], startIndex: number): Array<T | undefined>;
+/** Ghép 3 dải của Bollinger/Keltner thành một record `{top, middle, bottom}`. */
+export declare function mergeBand(upper: readonly number[], middle: readonly number[], lower: readonly number[], startIndex: number): Array<IndicatorBandValue | undefined>;
+/** Đọc một tham số số; rơi về `fallback` khi thiếu, không phải số, hoặc NaN/Infinity. */
+export declare function numberParam(series: SeriesConfig, key: string, fallback: number): number;
+/** Khoá chuỗi của một series; `undefined` khi type không có trong `buildIndicatorSeriesKey`. */
+export declare function indicatorKey(series: SeriesConfig): string | undefined;
+/** Series "ảo" chỉ dùng để sinh khoá cho chỉ báo không có tham số (AO, BBI, OBV, PVT…). */
+export declare function defaultSeries(type: SeriesConfig["type"], params?: Record<string, number>): SeriesConfig;

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

@@ -0,0 +1,3 @@
+import type { IndicatorComputationOptions, IndicatorComputationPlan, IndicatorComputationResult } from "./indicatorComputationTypes";
+import type { RawOHLCV } from "./types";
+export declare function computeIndicatorComputationResult(raw: readonly RawOHLCV[], plan: IndicatorComputationPlan, options?: IndicatorComputationOptions): IndicatorComputationResult;

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

@@ -0,0 +1,8 @@
+import type { IndicatorComputationPlan } from "./indicatorComputationTypes";
+import type { IndicatorPivotValue, IndicatorWyckoffValue, RawOHLCV } from "./types";
+export interface MarketStructureBlocks {
+    pivotStandardByKey: Map<string, Array<IndicatorPivotValue | undefined>>;
+    pivotHighLowByKey: Map<string, Array<IndicatorPivotValue | undefined>>;
+    wyckoffWaveByKey: Map<string, Array<IndicatorWyckoffValue | undefined>>;
+}
+export declare function computeMarketStructureBlocks(raw: readonly RawOHLCV[], plan: IndicatorComputationPlan): MarketStructureBlocks;

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

@@ -0,0 +1,22 @@
+import type { IndicatorComputationPlan } from "./indicatorComputationTypes";
+import type { IndicatorAcValue, IndicatorBrarValue, IndicatorCrValue, IndicatorDmiValue, IndicatorEmvValue, IndicatorKdjValue, IndicatorMtmValue, IndicatorPsyValue, IndicatorTrixValue, RawOHLCV } from "./types";
+export interface MomentumBlocks {
+    rsiByPeriod: Map<number, 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>>;
+    psyByKey: Map<string, Array<IndicatorPsyValue | undefined>>;
+    crByKey: Map<string, Array<IndicatorCrValue | undefined>>;
+    ac: Array<IndicatorAcValue | undefined>;
+    smfi: Array<number | undefined>;
+}
+export declare function computeMomentumBlocks(raw: readonly RawOHLCV[], closes: readonly number[], plan: IndicatorComputationPlan): MomentumBlocks;

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

@@ -0,0 +1,15 @@
+import type { IndicatorComputationPlan } from "./indicatorComputationTypes";
+import type { IndicatorBandValue, IndicatorMacdValue, IndicatorMARibbonValue, RawOHLCV } from "./types";
+export interface MovingAverageBlocks {
+    emaByPeriod: Map<number, Array<number | undefined>>;
+    smaByPeriod: Map<number, Array<number | undefined>>;
+    macdByKey: Map<string, Array<IndicatorMacdValue | undefined>>;
+    bollingerByKey: Map<string, Array<IndicatorBandValue | undefined>>;
+    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>>;
+}
+export declare function computeMovingAverageBlocks(raw: readonly RawOHLCV[], closes: readonly number[], plan: IndicatorComputationPlan): MovingAverageBlocks;

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

@@ -0,0 +1,9 @@
+import type { IndicatorComputationOptions, IndicatorComputationPlan } from "./indicatorComputationTypes";
+import type { DeltaProfileData, FootprintBar, MarketProfileData, RawOHLCV, VolumeProfileData } from "./types";
+export interface ProfileBlocks {
+    marketProfileByKey: Map<string, MarketProfileData>;
+    volumeProfileByKey: Map<string, VolumeProfileData>;
+    footprintByKey: Map<string, FootprintBar[]>;
+    deltaProfileByKey: Map<string, DeltaProfileData>;
+}
+export declare function computeProfileBlocks(raw: readonly RawOHLCV[], plan: IndicatorComputationPlan, options?: IndicatorComputationOptions): ProfileBlocks;

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

@@ -0,0 +1,10 @@
+import type { IndicatorComputationPlan } from "./indicatorComputationTypes";
+import type { IndicatorAlligatorValue, IndicatorDmaValue, IndicatorFractalValue, IndicatorGatorValue, IndicatorIchimokuValue, RawOHLCV } from "./types";
+export interface TrendBlocks {
+    dmaByKey: Map<string, Array<IndicatorDmaValue | undefined>>;
+    ichimokuByKey: Map<string, Array<IndicatorIchimokuValue | undefined>>;
+    alligatorByKey: Map<string, Array<IndicatorAlligatorValue | undefined>>;
+    fractals: Array<IndicatorFractalValue | undefined>;
+    gatorByKey: Map<string, Array<IndicatorGatorValue | undefined>>;
+}
+export declare function computeTrendBlocks(raw: readonly RawOHLCV[], plan: IndicatorComputationPlan): TrendBlocks;

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

@@ -0,0 +1,14 @@
+import type { IndicatorComputationPlan } from "./indicatorComputationTypes";
+import type { IndicatorDonchianValue, IndicatorKeltnerValue, IndicatorSupertrendValue, RawOHLCV } from "./types";
+export interface VolatilityBlocks {
+    bbi: Array<number | undefined>;
+    sarByKey: Map<string, Array<number | 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>>;
+    supertrendByKey: Map<string, Array<IndicatorSupertrendValue | undefined>>;
+}
+export declare function computeVolatilityBlocks(raw: readonly RawOHLCV[], closes: readonly number[], plan: IndicatorComputationPlan): VolatilityBlocks;

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

@@ -0,0 +1,19 @@
+import { calcCVDApprox } from "./calcCVDApprox";
+import { calcStrengthElder } from "./calcStrengthElder";
+import type { IndicatorComputationOptions, IndicatorComputationPlan } from "./indicatorComputationTypes";
+import type { IndicatorVwapValue, IndicatorWhaleValue, RawOHLCV } from "./types";
+export interface VolumeFlowBlocks {
+    obv: Array<number | undefined>;
+    pvt: 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>>;
+    cvd: ReturnType<typeof calcCVDApprox>;
+    strength: ReturnType<typeof calcStrengthElder>;
+    strengthRelativeByKey: Map<string, Array<number | undefined>>;
+    whaleByKey: Map<string, Array<IndicatorWhaleValue | undefined>>;
+}
+export declare function computeVolumeFlowBlocks(raw: readonly RawOHLCV[], plan: IndicatorComputationPlan, options?: IndicatorComputationOptions): VolumeFlowBlocks;

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

@@ -0,0 +1,7 @@
+import type { SeriesConfig } from "../types/pane-descriptor";
+import type { EnrichedDatum, RawOHLCV } from "./types";
+export interface EnrichDataOptions {
+    series?: readonly SeriesConfig[];
+    whaleThreshold?: number;
+}
+export declare function enrichData(raw: readonly RawOHLCV[], optionsOrWhaleThreshold?: EnrichDataOptions | number): EnrichedDatum[];

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

@@ -0,0 +1,33 @@
+import { type CanonicalSeriesStore } from "@vninvestcharts/engine-core";
+import type { SeriesConfig } from "../types/pane-descriptor";
+import { buildIndicatorComputationPlan, computeIndicatorComputationResult } from "./indicatorComputation";
+import type { EnrichedDatum, RawOHLCV, VolumeProfileData } from "./types";
+/**
+ * Extended EnrichDataOptions for canonical store integration.
+ * Allows passing a store to cache indicator computation results by canonical key.
+ */
+export interface EnrichDataWithStoreOptions {
+    series?: readonly SeriesConfig[];
+    whaleThreshold?: number;
+    canonicalStore?: CanonicalSeriesStore<{
+        plan: ReturnType<typeof buildIndicatorComputationPlan>;
+        result: ReturnType<typeof computeIndicatorComputationResult>;
+        aoColors: (string | undefined)[];
+    }>;
+    sourceId?: string;
+    timeframe?: string;
+    mtfBars?: Record<string, readonly RawOHLCV[]>;
+    compareBarsBySymbol?: Record<string, readonly RawOHLCV[]>;
+    asyncVolumeProfiles?: Record<string, VolumeProfileData>;
+}
+/**
+ * Enrich OHLCV bars with indicator values using a canonical series store.
+ *
+ * If a `canonicalStore` is provided and hit, the computation result is reused.
+ * If store is not provided or miss, falls back to regular enrichData.
+ *
+ * @param raw Raw OHLCV bars
+ * @param options Enrichment options including canonical store
+ * @returns Enriched data with computed indicator values
+ */
+export declare function enrichDataWithCanonicalStore(raw: readonly RawOHLCV[], options?: EnrichDataWithStoreOptions): EnrichedDatum[];

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

@@ -0,0 +1,140 @@
+/**
+ * A3 Baseline / A11 Renko / A11 Kagi / Point & Figure / Line Break — producers.
+ *
+ * Mỗi chart type loại "giá" cần một dữ liệu mà bar OHLCV thô KHÔNG mang:
+ * baseline cần phần trăm so với bar mốc, renko cần bậc giá gạch, kagi cần
+ * trạng thái hướng và mức đảo, P&F cần các box của một cột và bar mở cột,
+ * line break cần mức đóng của đường đang chạy. Không có producer thì mọi giá
+ * trị đều rơi về `default: return datum.close` và chart vẽ y hệt đường Line dưới
+ * nhãn khác.
+ *
+ * Module này thuần: không đụng DOM, không đọc engine, không giữ state giữa hai
+ * lần gọi. Toàn bộ state (bậc gạch, hướng kagi, cột P&F) là biến cục bộ trong
+ * một lần gọi ⇒ cùng đầu vào luôn cho cùng đầu ra, nên test được mà không cần
+ * fake timer.
+ */
+import type { SeriesConfig } from "../types/pane-descriptor";
+import type { EnrichedDatum, KagiDirection, PnfBox, PnfDirection, RawOHLCV } from "./types";
+/** Kiểu giá mà các calculator này chỉ cần. */
+type CloseSeries = readonly Pick<RawOHLCV, "close">[];
+export interface RenkoBrick {
+    /** Đầu dưới của gạch — baseline để engine vẽ hộp. */
+    open: number;
+    /** Đầu trên của gạch — giá trị engine đưa vào Y domain. */
+    close: number;
+    /** `true` = gạch tăng. */
+    up: boolean;
+    /** `false` = gạch dang dở ở cuối chuỗi. */
+    fullyFormed: boolean;
+}
+export interface KagiState {
+    /** Mức giá kagi đang sống. */
+    current: number;
+    /** Hướng của nhánh đang chạy tại bar này. */
+    startAs: KagiDirection;
+    /** Có đảo chiều tại bar này không. */
+    changeTo?: KagiDirection;
+    /** Giá tại đó nhánh đảo. */
+    changePoint?: number;
+    /** Mức giá mà nhánh hiện tại bắt đầu. */
+    reverseAt: number;
+}
+export interface PnfColumn {
+    /** Các box cột tạo ra tại bar này. Rỗng/undefined = bar này không tạo box. */
+    boxes: PnfBox[];
+    /** Chỉ số bar MỞ ĐẦU cột — đây là x của cả cột, không phải x của bar này. */
+    columnStart: number;
+    /** Hướng của cột, để engine chọn màu. */
+    direction: PnfDirection;
+}
+export interface LineBreakLevel {
+    /** Mức mở của đường đang chạy — đầu trái của đoạn ngang. */
+    open: number;
+    /** Mức đóng của đường đang chạy — giá trị engine đưa vào Y domain và vẽ. */
+    close: number;
+    /** `true` = đường đi lên. */
+    up: boolean;
+}
+/** Series type loại exotic mà module này sản xuất được. */
+export type ExoticChartType = "Baseline" | "Renko" | "Kagi" | "PointAndFigure" | "LineBreak";
+/**
+ * Bậc giá chuẩn, suy ra từ chính dữ liệu: trung vị |Δclose|.
+ *
+ * Vì sao không đặt hằng số: một renko 10 điểm trên cổng phiếu giá 30 là một
+ * gạch, còn trên BTC là 40 gạch. Trung vị |Δclose| là bước chuyển động điển
+ * hình của chính instrument đó, nên ra số gạch đọc được ở mọi mức giá mà không
+ * cần người dùng chỉnh tay. `params.brickSize` thắng nếu host truyền vào.
+ */
+export declare function resolveBrickStep(closes: readonly number[], override?: number): number;
+/**
+ * Bậc gạch renko.
+ *
+ * - Neo khởi đầu là `open` của bar đầu, đã quy về bậc gần nhất: giá thị trường
+ *   không nằm đúng trên bậc nào, neo lệch bậc thì cả chuỗi gạch lệch theo.
+ * - Một bar có thể tạo nhiều gạch (gap lớn). Trục X là THỜI GIAN nên các gạch
+ *   trong cùng một bar không có x khác nhau: chỉ gạch CUỐI được ghi nhận, và
+ *   chỉ gạch đó được vẽ. Gạch tạo ở bar nào thì dán ở bar đó.
+ * - Gạch cuối có thể chưa trọn vẹn (`fullyFormed: false`) để giá hiện tại vẫn
+ *   hiện; chỉ ghi khi bar cuối chưa có gạch nào, vì một bar chỉ vẽ được một ô.
+ */
+export declare function computeRenkoBricks(closes: readonly number[], brickSize: number): (RenkoBrick | undefined)[];
+/**
+ * Kagi level + direction.
+ *
+ * Rule (StockCharts standard): every time price moves `reversal` IN the current
+ * direction, kagi draws a new horizontal segment at the new level; when price
+ * moves `reversal` AGAINST it, the direction flips and a new segment starts.
+ * That is why a rising trend draws as a staircase going UP rather than one flat
+ * line, and why `changeTo` is set only on a real flip - setting it on a
+ * same-direction continuation makes `KagiSeries` draw two same-coloured legs
+ * back to back, i.e. a plain line chopped into meaningless pieces.
+ *
+ * `reverseAt` = level where the current horizontal segment STARTS.
+ * `current`   = level where it ENDS. The engine reads `current` and draws with
+ *               `stepBefore`, which is what makes the segment flat.
+ *
+ * `params.reversal` defaults to the very same brick step as renko: the
+ * conventional relationship between the two chart types (same instrument, same
+ * step), so it is a grounded default rather than an invented number.
+ */
+export declare function computeKagiStates(closes: readonly number[], reversal: number): (KagiState | undefined)[];
+/**
+ * Point & Figure — các box của từng cột, và bar MỞ ĐẦU cột.
+ *
+ * Quy tắc chuẩn: giá đi đủ `boxSize` cùng hướng thì cột đó thêm MỘT box ở đầu
+ * đang đi; giá đi ngược đủ `reversalBoxes × boxSize` thì hướng đảo và một cột
+ * MỚI bắt đầu tại bar đảo chiều. Đó là lý do `columnStart` là một trường
+ * riêng: x của cả cột là x của bar MỞ ĐẦU nó, và nó phải sống sót qua những
+ * bar không tạo box nào (giá đi ngang, hoặc đi chưa đủ một bậc).
+ *
+ * Một bar có thể tạo N box (gap lớn) — tất cả cùng một cột, cùng một x, xếp
+ * dọc. Đây chính là hình học mà `toBarPoints` không diễn đạt được, nên engine có
+ * `layoutPointAndFigure` riêng thay vì alias sang đường vẽ hộp của renko.
+ *
+ * @param boxSize      chiều cao một box (một bậc giá)
+ * @param reversalBoxes số box giá phải đi ngược mới đảo hướng (chuẩn: 3)
+ */
+export declare function computePointAndFigureColumns(closes: readonly number[], boxSize: number, reversalBoxes: number): (PnfColumn | undefined)[];
+/**
+ * Line Break — mức đóng của đường đang chạy.
+ *
+ * Quy tắc chuẩn (n-line): đường đi theo hướng hiện tại, mỗi lần giá đi đủ `n` thì
+ * đường kéo dài thêm một bước; giá đi ngược đủ `n` thì đường KẾT THÚC và một
+ * đường mới bắt đầu ở đúng mức đó, theo hướng ngược lại. `n` dùng cho CẢ bước
+ * lẫn đảo chiều — đó là điểm khác biệt với kagi (kagi có ngưỡng đảo riêng), và
+ * cũng là lý do đây là hai loại chart khác nhau chứ không phải một tên gọi khác.
+ *
+ * `open` là mức đầu đường, `close` là mức cuối. Engine vẽ polyline qua `close`
+ * với `stepBefore`: trong lòng một đường, mức là HẰNG, nên một đoạn thẳng sẽ vẽ
+ * ra một độ dốc giữa hai mức chưa bao giờ cùng tồn tại.
+ */
+export declare function computeLineBreakLevels(closes: readonly number[], lineSize: number): (LineBreakLevel | undefined)[];
+/**
+ * Ghi dữ liệu exotic lên `EnrichedDatum[]`, MUTATION-FREE (trả về mảng mới khi
+ * có việc phải làm, trả lại chính `enriched` khi không có chart type nào cần).
+ *
+ * Chỉ tính loại chart type nào thật sự đang được yêu cầu: renko với 10 nghìn
+ * bar là O(n) mỗi lần dữ liệu đổi, và phần lớn phiên không mở renko/kagi.
+ */
+export declare function applyExoticChartData(enriched: readonly EnrichedDatum[], raw: CloseSeries, series: readonly SeriesConfig[]): EnrichedDatum[];
+export {};

package/dist/dts/lib/core/calculators/fixtures/mockData.d.ts

@@ -0,0 +1,2 @@
+import type { RawOHLCV } from "../types";
+export declare const mockOHLCV300: RawOHLCV[];

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

@@ -0,0 +1,27 @@
+/**
+ * Barrel của `indicatorComputation` — điểm import duy nhất cho mọi consumer.
+ *
+ * File này trước đây dài 1933 dòng và ngồi sát trần budget 1940, nên thêm một slice
+ * chỉ báo mới là phải nộp đơn xin nới budget. Nay nó chỉ re-export (commit split
+ * 2026-09-30), đúng như `registry/SeriesRegistry.ts` đã làm cho registry.
+ *
+ * - `indicatorComputationTypes.ts` — `IndicatorComputationPlan` / `IndicatorComputationResult`.
+ * - `computationHelpers.ts` — `blankUntil` / `mergeBand` / `numberParam` / `indicatorKey` / `defaultSeries`.
+ * - `buildIndicatorComputationPlan.ts` — gom series thành plan (switch 60+ nhánh).
+ * - `resolveCalculationOrder.ts` — sắp series cha trước con.
+ * - `computeIndicatorComputationResult.ts` — điều phối + `valuesByKey`.
+ * - `compute{MovingAverage,Momentum,Volatility,Trend,VolumeFlow,MarketStructure,Profile}.ts`
+ *   — thân của 60 khối chỉ báo, chia theo nhóm.
+ * - `materializeIndicatorValues.ts` — gộp result thành record phẳng theo bar.
+ *
+ * Hướng phụ thuộc (một chiều, không cycle):
+ *   indicatorComputation → computeIndicatorComputationResult → {compute*} → computationHelpers → indicatorComputationTypes
+ *   computeIndicatorComputationResult → materializeIndicatorValues → computationHelpers
+ * `materializeIndicatorValues` KHÔNG import ngược lại orchestrator; hàm này chỉ cần
+ * kiểu `IndicatorComputationResult` của nó.
+ */
+export type { IndicatorComputationOptions, IndicatorComputationPlan, IndicatorComputationResult, } from "./indicatorComputationTypes";
+export { buildIndicatorComputationPlan } from "./buildIndicatorComputationPlan";
+export { resolveCalculationOrder } from "./resolveCalculationOrder";
+export { computeIndicatorComputationResult } from "./computeIndicatorComputationResult";
+export { materializeIndicatorValues } from "./materializeIndicatorValues";