@vninvestcharts/widget 0.0.0-stage → 0.2.0

package/dist/dts/lib/pinescript/pineParse.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Cache parser DUY NHẤT mỗi realm. `pine.worker.ts` import hàm này thay vì giữ
+ * một bản sao riêng — trước đây hai bản sao lệch nhau theo thời gian.
+ */
+export declare function getParser(): any;
+export interface CompileError {
+    message: string;
+    line?: number;
+    column?: number;
+}
+/**
+ * W-01 (PINE Stage 3): grammar trả về **dòng phẳng** (`indent` + `node`), còn
+ * `buildBlocks` lồng khoá theo thụt lẽ. Trước đây grammar tự lồng khoá bằng
+ * `ifBlock = Statement+`, và vì `Statement` không biết "hết khoá ở đâu" nên nó
+ * nuốt **mọi** statement còn lại — script `if/else` + `plot` cho `output = {}`
+ * mà `errors = []`.
+ *
+ * Vì sao tách hai tầng thay vì làm trong grammar: peggy 5 không có rule có tham
+ * số, `startRule` phải là rule đầu tiên, và action luôn chạy sau khi match — ba
+ * ràng buộc đo được ở `scripts/probe-grammar-caps.mjs`.
+ */
+export declare function parseScript(source: string): {
+    ast: any;
+    errors: CompileError[];
+};

package/dist/dts/lib/pinescript/pineStrings.d.ts

@@ -0,0 +1,50 @@
+/**
+ * F1 — runtime `str.*` của Pine.
+ *
+ * NGỒI GỐC ĐỊNH NGHĨA: tài liệu Pine Script "Concepts / Strings" (tham chiếu ở
+ * từng hàm bên dưới). Không có hàm nào ở đây là do tôi tự chế ra nghĩa.
+ *
+ * Mọi hàm đều theo cùng một quy tắc lan-Na: đối số `na` cho kết quả `na`
+ * (kênh số = `NaN`, kênh chuỗi = `null`). Không hàm nào bịa `0` cho kết quả chưa
+ * xác định — `0` là giá trị thật và sẽ vẽ ra đường bằng 0 (Rule 15).
+ */
+import { type Series } from './series-value';
+/**
+ * Format số MẶC ĐỊNH của `str.tostring`.
+ *
+ * Tài liệu Pine: "The default numeric format is `"#.########"`, which rounds
+ * fractional digits to eight decimal places without trailing zeros." Ta chọn
+ * đúng con số này, KHÔNG chọn 0 chữ số thập phân — xem `pineStrings.test.ts`
+ * (mục "quyết định format") để biết lý do.
+ */
+export declare const DEFAULT_NUMBER_FORMAT = "#.########";
+/**
+ * Định dạng một số theo pattern của Pine. Trả `null` (= `na`) khi không thể định
+ * dạng — KHÔNG bao giờ trả một chuỗi bịa ra.
+ */
+export declare function formatNumber(value: number, pattern?: string): string | null;
+export declare function parsePineNumber(text: string): number | null;
+/**
+ * Dispatcher `str.*`. Trả `Series` (kênh số + kênh phụ) — `str.tostring`/`str.upper`
+ * … là series CHUỖI (kênh số toàn NaN), còn `str.length`/`str.pos`/`str.tonumber`
+ * là series SỐ thật (0/1/NaN), đúng như Pine.
+ *
+ * Không nhận được kênh chuỗi ở tham số nguồn (ví dụ `str.upper(close)`) thì mọi
+ * bar là `na`: Pine chặn ở tầng kiểu, ta không có tầng kiểu nên KHÔNG tự ép kiểu
+ * (ép sẽ bịa dữ liệu). `str.tostring` là ngoại lệ duy nhất được phép ép, vì đó
+ * đúng là việc của nó.
+ */
+export declare function callStrFunction(name: string, args: Series[], length: number): Series;
+/** Các tên `str.*` mà dispatcher trên thực sự nhận — nguồn sự thật cho Monaco. */
+export declare const STR_BUILTINS: readonly ["str.tostring", "str.tonumber", "str.upper", "str.lower", "str.trim", "str.length", "str.substring", "str.contains", "str.startswith", "str.endswith", "str.pos", "str.replace", "str.replace_all"];
+/**
+ * Đánh giá phép nhị phân khi CÓ MỘT BÊN mang kênh chuỗi.
+ *
+ * Pine: `+` là phép NỐI chuỗi, `==`/`!=` so sánh chuỗi. Trả `null` nếu phép toán
+ * không thuộc tập trên — khi đó `compile.ts` chạy đúng nhánh số cũ.
+ *
+ * Cố ý KHÔNG tự ép kiểu: `str.tostring(x) + 1` là lỗi kiểu ở Pine và ở đây trả
+ * `na` chứ không phải "…1" được chuỗi hoá ngầm. `parseFloat` trên một chuỗi bất
+ * kỳ chính là thứ đã làm `"11" + 1` ra 12.
+ */
+export declare function evalStringBinary(left: Series, op: string, right: Series, length: number): Series | null;

package/dist/dts/lib/pinescript/runtime.d.ts

@@ -0,0 +1,5 @@
+export declare class PineRuntime {
+    static sma(values: number[], period: number): number[];
+    static ema(values: number[], period: number): number[];
+    static rsi(values: number[], period: number): number[];
+}

package/dist/dts/lib/pinescript/scriptRegistry.d.ts

@@ -0,0 +1,40 @@
+import { type IndicatorPlugin } from "./PineCompiler";
+import type { SeriesTier } from "../core/registry/registryCore";
+/** Test-only: forget a script. Not used by production code. */
+export declare function __resetPineScriptRegistry(): void;
+export declare function getPineScriptSource(scriptId: string): string | undefined;
+export declare function hasPineScript(scriptId: string): boolean;
+export interface RegisterPineScriptOptions {
+    /** Defaults to `pro`; the Pine capability is Pro-gated. */
+    tier?: SeriesTier;
+}
+/**
+ * Compiles `source` and registers the resulting plugin + series under the stable type
+ * `pine_<scriptId>`.
+ *
+ * IDEMPOTENT BY CONSTRUCTION: both `registerPinePlugin` and `registerSeries` write into Maps.
+ * Calling this twice for the same id — which StrictMode guarantees on mount — leaves exactly one
+ * entry, so no duplicate line, no duplicate legend row, and no index-ambiguous `removeSeries`
+ * (`useDynamicPanes.ts:442-447` appends without dedup, so anything that dispatches `addSeries`
+ * from an effect would duplicate).
+ *
+ * Returns `null` when the script does not compile, so a caller can report the error instead of
+ * registering a series that will always resolve to nothing.
+ */
+export declare function registerPineScript(scriptId: string, source: string, options?: RegisterPineScriptOptions): IndicatorPlugin | null;
+/**
+ * Restores every saved script whose Pine type is already present on the chart.
+ *
+ * The `wantedTypes` filter is the whole design. A pane layout cannot record "the user removed this
+ * series", so a restore-everything pass would resurrect deleted series on every mount. Restoring
+ * only what the chart already references makes it:
+ *   - idempotent, because nothing is added to the pane here at all;
+ *   - safe under StrictMode, because re-registering is a Map write;
+ *   - and free of orphaned registrations, because a type nobody references is skipped.
+ *
+ * Returns the script ids actually restored, which makes the effect directly assertable.
+ */
+export declare function restorePineScripts(scripts: readonly {
+    id: string;
+    source: string;
+}[], wantedTypes: readonly string[] | undefined): string[];

package/dist/dts/lib/pinescript/series-value.d.ts

@@ -0,0 +1,64 @@
+/**
+ * F1 — MÔ HÌNH GIÁ TRỊ của evaluator VnScript.
+ *
+ * Bối cảnh: cho tới `e3-pine-builtins` (A9) evaluator CHỈ mang `number`. `str.*`
+ * bị chặn đúng lý do: `evalExpr` rút `Literal` qua `parseFloat`, env là
+ * `Map<string, number[]>`, `callFunction` trả `number[]`. `str.upper` không có
+ * miền để tác động — đó là kết luận đúng, không phải lười.
+ *
+ * Mô hình đã chọn: **kênh số là chính series, kênh chuỗi là kênh phụ tùy chọn.**
+ *
+ * ```ts
+ * type Series = number[]                       // không đổi
+ * interface WithStrChannel { __str?: (string|null)[] }   // kênh phụ
+ * ```
+ *
+ * Ba lý do (thay cho một):
+ *  1. Kênh số vẫn là `Array<number>` thật nên 51 builtin sẵn có giữ nguyên kiểu,
+ *     nguyên phép tính và nguyên lan-NaN — **không sửa dòng nào bên trong chúng**.
+ *     Đó là cách duy nhất để chứng minh "byte-identical" bằng bằng chứng thay vì
+ *     bằng hy vọng.
+ *  2. `str.*` là một *lớp nhìn* lên kênh phụ: builtin sinh chuỗi trả về kênh số
+ *     toàn `NaN` (**không bao giờ `0`** — đó là thứ giữ cho
+ *     `plot(str.upper(sym))` không vẽ ra đường bằng 0) cộng kênh phụ `__str`.
+ *     Ngược lại builtin chuỗi→số đọc kênh phụ của đối số và bỏ qua kênh số, nên
+ *     vòng đi-về là toàn vẹn.
+ *  3. Tính *tùy chọn* giữ bán kính nổ 0 cho code số: thuộc tính đơn giản là
+ *     `undefined` trên mọi series mà 51 builtin sinh ra, nên chúng không thể
+ *     quan sát thấy nó; còn một series chuỗi hạ xuống thành "toàn NaN" với mọi
+ *     consumer chỉ hiểu số (lượt validate, `postMessage` của worker, `LineSeries`).
+ *
+ * GIÁ THẾ PHẢI TRẢ: `__str` là mô hình cấu trúc mà TypeScript không canh được
+ * hoàn toàn. Đổi lại `series-value.ts` là nơi duy nhất được phép chạm vào nó, và
+ * mọi điểm ghi/đọc đều qua helper dưới đây.
+ */
+/** Series số. Series chuỗi vẫn là `number[]` — kênh chuỗi nằm ở kênh phụ. */
+export type Series = number[];
+/** `null` trong kênh chuỗi = Pine `na` (chuỗi chưa có giá trị). */
+export type StrValue = string | null;
+/** Series có kênh chuỗi đi kèm. */
+export interface WithStrChannel {
+    __str?: StrValue[];
+}
+/**
+ * Đọc kênh chuỗi. Trả `undefined` cho MỌI series mà 51 builtin sẵn có sinh ra —
+ * đó là bất biến mà `pineBuiltins.test.ts` khoá lại, không chỉ là quy ước.
+ */
+export declare function strChannel(value: unknown): StrValue[] | undefined;
+/** Series toàn `NaN`: "chưa xác định", KHÔNG phải 0 (0 là giá trị thật — Rule 15). */
+export declare function naSeries(length: number): Series;
+/**
+ * Dựng một series chuỗi: kênh số toàn `NaN` + kênh phụ `__str`.
+ * Thiếu phần tử ở cuối được đệm `null` (na) chứ không phải `""` — `""` là một
+ * chuỗi hợp lệ và sẽ khác `na` trong `str.contains` / `str.length`.
+ */
+export declare function makeStrSeries(values: StrValue[], length: number): Series;
+/** Lấy chuỗi tại bar `i`, hoặc `null` (na) nếu bar đó ngoài độ dài kênh. */
+export declare function strAt(channel: StrValue[] | undefined, i: number): StrValue;
+/**
+ * Cởi kênh chuỗi trước khi series đi ra ngoài thế giới số — dùng ở biên `plot()`.
+ * `slice()` KHÔNG mang theo thuộc tính riêng ngoài chỉ số, nên kênh phụ bị bỏ.
+ * Đây là cách "series chuỗi không được vẽ thành đường" được bảo đảm bằng cấu trúc
+ * chứ không phải bằng kỳ vọng.
+ */
+export declare function stripStrChannel(series: Series): Series;

package/dist/dts/lib/pinescript/vnscript-completion.d.ts

@@ -0,0 +1 @@
+export declare function registerVnScriptCompletion(monaco: any): void;

package/dist/dts/lib/pinescript/vnscript-grammar.d.ts

@@ -0,0 +1,19 @@
+/**
+ * W1.2: chỉ liệt kê từ khoá mà PARSER THẬT SỰ chấp nhận. Trước đây `while`/`not`
+ * được tô màu nhưng grammar từ chối ⇒ editor hứa một thứ rồi báo lỗi. Đã bỏ cho
+ * tới khi parser hỗ trợ. `indicator`/`strategy` thì nay ĐÃ hỗ trợ (alias của study).
+ *
+ * W-04 (PINE Stage 3): parser ĐÃ hỗ trợ `while`, `not`, `na` (grammar.ts) nên
+ * chúng được trả lại danh sách này. Trước W-04, chúng **không** được tô màu
+ * dù chạy được — thiếu sót ngược lại với lỗi đã ghi ở trên.
+ *
+ * `=>` không nằm ở đây vì nó không phải từ khoá mà là toán tử UDF; Monaco tô
+ * màu qua `builtinFuncRe`/toán tử chung.
+ *
+ * Export ra để test khoá được hợp đồng này (`pineDefaultTemplate.test.ts`).
+ */
+export declare const VNSCRIPT_KEYWORDS: readonly ["study", "indicator", "strategy", "if", "else", "for", "to", "while", "true", "false", "na", "and", "or", "not", "var", "const"];
+export declare const VNSCRIPT_BUILTIN_FUNCTIONS: string[];
+export declare class VnScriptLanguage {
+    static register(monaco: any): void;
+}

package/dist/dts/lib/scale/discontinuousTimeScaleProvider.d.ts

@@ -0,0 +1,3 @@
+export declare function discontinuousTimeScaleProviderBuilder(): any;
+declare const _default: any;
+export default _default;

package/dist/dts/lib/scale/financeDiscontinuousScale.d.ts

@@ -0,0 +1,15 @@
+export default function financeDiscontinuousScale(index: any, futureProvider?: any, backingLinearScale?: any): {
+    (x: any): any;
+    invert(x: any): number;
+    domain(x?: any): any;
+    range(x?: any): any;
+    rangeRound(x: any): any;
+    clamp(x?: any): any;
+    interpolate(x?: any): any;
+    ticks(m: any, flexTicks?: any): any[];
+    tickFormat(): (x: any) => any;
+    value(x: any): any;
+    nice(m: any): /*elided*/ any;
+    index(x?: any): any;
+    copy(): /*elided*/ any;
+};

package/dist/dts/lib/scale/index.d.ts

@@ -0,0 +1 @@
+export { default as discontinuousTimeScaleProvider, discontinuousTimeScaleProviderBuilder } from "./discontinuousTimeScaleProvider";

package/dist/dts/lib/scale/levels.d.ts

@@ -0,0 +1,12 @@
+export declare const defaultFormatters: {
+    yearFormat: string;
+    quarterFormat: string;
+    monthFormat: string;
+    weekFormat: string;
+    dayFormat: string;
+    hourFormat: string;
+    minuteFormat: string;
+    secondFormat: string;
+    milliSecondFormat: string;
+};
+export declare const levelDefinition: ((d: any, date: any, i: any) => any)[];

package/dist/dts/lib/series/AlternatingFillAreaSeries.d.ts

@@ -0,0 +1,13 @@
+import React, { Component } from "react";
+declare class AlternatingFillAreaSeries extends Component<any, any> {
+    static defaultProps: any;
+    clipPathId1: string;
+    clipPathId2: string;
+    constructor(props: any);
+    topClip(ctx: any, moreProps: any): void;
+    bottomClip(ctx: any, moreProps: any): void;
+    renderClip(moreProps: any): React.JSX.Element;
+    baseAt(yScale: any): any;
+    render(): React.JSX.Element;
+}
+export default AlternatingFillAreaSeries;

package/dist/dts/lib/series/AreaOnlySeries.d.ts

@@ -0,0 +1,10 @@
+import React, { Component } from "react";
+declare class AreaOnlySeries extends Component<any, any> {
+    static defaultProps: any;
+    gradientId: string;
+    constructor(props: any);
+    drawOnCanvas(ctx: any, moreProps: any): void;
+    renderSVG(moreProps: any): React.JSX.Element;
+    render(): React.JSX.Element;
+}
+export default AreaOnlySeries;

package/dist/dts/lib/series/AreaSeries.d.ts

@@ -0,0 +1,30 @@
+import React from "react";
+import PropTypes from "prop-types";
+declare function AreaSeries(props: any): React.JSX.Element;
+declare namespace AreaSeries {
+    var propTypes: {
+        stroke: PropTypes.Requireable<string>;
+        strokeWidth: PropTypes.Requireable<number>;
+        canvasGradient: PropTypes.Requireable<(...args: any[]) => any>;
+        fill: PropTypes.Validator<string>;
+        strokeOpacity: PropTypes.Validator<number>;
+        opacity: PropTypes.Validator<number>;
+        className: PropTypes.Requireable<string>;
+        yAccessor: PropTypes.Validator<(...args: any[]) => any>;
+        baseAt: PropTypes.Requireable<(...args: any[]) => any>;
+        interpolation: PropTypes.Requireable<(...args: any[]) => any>;
+        canvasClip: PropTypes.Requireable<(...args: any[]) => any>;
+        style: PropTypes.Requireable<object>;
+        strokeDasharray: PropTypes.Requireable<string>;
+    };
+    var defaultProps: {
+        stroke: string;
+        strokeWidth: number;
+        strokeOpacity: number;
+        strokeDasharray: string;
+        opacity: number;
+        fill: string;
+        className: string;
+    };
+}
+export default AreaSeries;

package/dist/dts/lib/series/BarSeries.d.ts

@@ -0,0 +1,40 @@
+import { Component } from "react";
+import PropTypes from "prop-types";
+import { plotDataLengthBarWidth } from "../utils";
+import type { ChartAccessor, ChartDatum } from "../types";
+export interface BarSeriesProps {
+    baseAt?: number | ((xScale: any, yScale: any, datum?: ChartDatum) => number);
+    stroke?: boolean;
+    width?: number | ((props: BarSeriesProps, moreProps: any) => number);
+    widthRatio?: number;
+    yAccessor: ChartAccessor;
+    opacity?: number;
+    fill?: string | ((datum: ChartDatum) => string);
+    className?: string | ((datum: ChartDatum) => string);
+    clip?: boolean;
+}
+declare class BarSeries extends Component<BarSeriesProps> {
+    static propTypes: {
+        baseAt: PropTypes.Requireable<NonNullable<number | ((...args: any[]) => any) | null | undefined>>;
+        stroke: PropTypes.Requireable<boolean>;
+        width: PropTypes.Requireable<NonNullable<number | ((...args: any[]) => any) | null | undefined>>;
+        yAccessor: PropTypes.Validator<(...args: any[]) => any>;
+        opacity: PropTypes.Requireable<number>;
+        fill: PropTypes.Requireable<NonNullable<string | ((...args: any[]) => any) | null | undefined>>;
+        className: PropTypes.Requireable<NonNullable<string | ((...args: any[]) => any) | null | undefined>>;
+        clip: PropTypes.Requireable<boolean>;
+    };
+    static defaultProps: {
+        baseAt: (xScale: any, yScale: any) => any;
+        fill: string;
+        stroke: boolean;
+        width: typeof plotDataLengthBarWidth;
+        opacity: number;
+        clip: boolean;
+    };
+    constructor(props: BarSeriesProps);
+    drawOnCanvas(ctx: CanvasRenderingContext2D, moreProps: any): void;
+    renderSVG(moreProps: any): import("react").JSX.Element;
+    render(): import("react").JSX.Element;
+}
+export default BarSeries;

package/dist/dts/lib/series/BollingerSeries.d.ts

@@ -0,0 +1,11 @@
+import React, { Component } from "react";
+declare class BollingerSeries extends Component<any, any> {
+    static defaultProps: any;
+    constructor(props: any);
+    yAccessorForTop(d: any): any;
+    yAccessorForMiddle(d: any): any;
+    yAccessorForBottom(d: any): any;
+    yAccessorForScalledBottom(scale: any, d: any): any;
+    render(): React.JSX.Element;
+}
+export default BollingerSeries;

package/dist/dts/lib/series/CandlestickSeries.d.ts

@@ -0,0 +1,56 @@
+import { Component } from "react";
+import PropTypes from "prop-types";
+import { plotDataLengthBarWidth } from "../utils";
+import type { OHLCV, ChartDatum } from "../types";
+interface CandleSeriesProps {
+    className?: string;
+    wickClassName?: string;
+    candleClassName?: string;
+    widthRatio?: number;
+    width?: number | ((props: CandleSeriesProps, moreProps: any) => number);
+    fill?: string | ((datum: OHLCV) => string);
+    stroke?: string | ((datum: OHLCV) => string);
+    wickStroke?: string | ((datum: OHLCV) => string);
+    yAccessor: (datum: ChartDatum) => OHLCV;
+    clip?: boolean;
+    candleStrokeWidth?: number;
+    opacity?: number;
+}
+declare class CandlestickSeries extends Component<CandleSeriesProps> {
+    static propTypes: {
+        className: PropTypes.Requireable<string>;
+        wickClassName: PropTypes.Requireable<string>;
+        candleClassName: PropTypes.Requireable<string>;
+        widthRatio: PropTypes.Requireable<number>;
+        width: PropTypes.Requireable<NonNullable<number | ((...args: any[]) => any) | null | undefined>>;
+        fill: PropTypes.Requireable<NonNullable<string | ((...args: any[]) => any) | null | undefined>>;
+        stroke: PropTypes.Requireable<NonNullable<string | ((...args: any[]) => any) | null | undefined>>;
+        wickStroke: PropTypes.Requireable<NonNullable<string | ((...args: any[]) => any) | null | undefined>>;
+        yAccessor: PropTypes.Requireable<(...args: any[]) => any>;
+        clip: PropTypes.Requireable<boolean>;
+    };
+    static defaultProps: {
+        className: string;
+        wickClassName: string;
+        candleClassName: string;
+        yAccessor: (d: OHLCV) => {
+            open: number;
+            high: number;
+            low: number;
+            close: number;
+        };
+        width: typeof plotDataLengthBarWidth;
+        wickStroke: string;
+        fill: (d: OHLCV) => "#6BA583" | "#FF0000";
+        stroke: string;
+        candleStrokeWidth: number;
+        widthRatio: number;
+        opacity: number;
+        clip: boolean;
+    };
+    constructor(props: CandleSeriesProps);
+    drawOnCanvas(ctx: CanvasRenderingContext2D, moreProps: any): void;
+    renderSVG(moreProps: any): import("react").JSX.Element;
+    render(): import("react").JSX.Element;
+}
+export default CandlestickSeries;

package/dist/dts/lib/series/CircleMarker.d.ts

@@ -0,0 +1,28 @@
+import React from "react";
+import PropTypes from "prop-types";
+declare function Circle(props: any): React.JSX.Element;
+declare namespace Circle {
+    var propTypes: {
+        stroke: PropTypes.Requireable<string>;
+        fill: PropTypes.Validator<string>;
+        opacity: PropTypes.Validator<number>;
+        point: PropTypes.Validator<NonNullable<PropTypes.InferProps<{
+            x: PropTypes.Validator<number>;
+            y: PropTypes.Validator<number>;
+            datum: PropTypes.Validator<object>;
+        }>>>;
+        className: PropTypes.Requireable<string>;
+        strokeWidth: PropTypes.Requireable<number>;
+        r: PropTypes.Validator<NonNullable<NonNullable<number | ((...args: any[]) => any) | null | undefined>>>;
+    };
+    var defaultProps: {
+        stroke: string;
+        strokeWidth: number;
+        opacity: number;
+        fill: string;
+        className: string;
+    };
+    var drawOnCanvas: (props: any, point: any, ctx: any) => void;
+    var drawOnCanvasWithNoStateChange: (props: any, point: any, ctx: any) => void;
+}
+export default Circle;

package/dist/dts/lib/series/ElderRaySeries.d.ts

@@ -0,0 +1,14 @@
+import React, { Component } from "react";
+declare class ElderRaySeries extends Component<any, any> {
+    static defaultProps: any;
+    constructor(props: any);
+    yAccessorTop(d: any): any;
+    yAccessorBullTop(d: any): any;
+    yAccessorBearTop(d: any): any;
+    yAccessorBullBottom(d: any): any;
+    yAccessorBearBottom(d: any): any;
+    yAccessorForBarBase(xScale: any, yScale: any, d: any): any;
+    fillForEachBar(d: any, yAccessorNumber: number): any;
+    render(): React.JSX.Element;
+}
+export default ElderRaySeries;

package/dist/dts/lib/series/FootprintSeries.d.ts

@@ -0,0 +1,21 @@
+import React, { Component } from "react";
+interface FootprintSeriesProps {
+    yAccessor: (d: any) => any;
+    width?: number | ((props: FootprintSeriesProps, moreProps: any) => number);
+    opacity?: number;
+    fontSize?: number;
+    fontFamily?: string;
+    textColor?: string;
+    upColor?: string;
+    downColor?: string;
+    neutralColor?: string;
+    pocBorderColor?: string;
+    viewMode?: "bidAsk" | "delta" | "deltaPercent" | "volume" | "profile";
+}
+export declare class FootprintSeries extends Component<FootprintSeriesProps> {
+    static defaultProps: any;
+    constructor(props: FootprintSeriesProps);
+    drawOnCanvas(ctx: CanvasRenderingContext2D, moreProps: any): void;
+    render(): React.JSX.Element;
+}
+export default FootprintSeries;

package/dist/dts/lib/series/GroupedBarSeries.d.ts

@@ -0,0 +1,9 @@
+import React, { Component } from "react";
+declare class GroupedBarSeries extends Component<any, any> {
+    static defaultProps: any;
+    constructor(props: any);
+    drawOnCanvas(ctx: any, moreProps: any): void;
+    renderSVG(moreProps: any): React.JSX.Element;
+    render(): React.JSX.Element;
+}
+export default GroupedBarSeries;

package/dist/dts/lib/series/HTFOverlaySeries.d.ts

@@ -0,0 +1,32 @@
+import { Component } from "react";
+import PropTypes from "prop-types";
+import { plotDataLengthBarWidth } from "../utils";
+import type { ChartDatum } from "../types";
+export interface HTFOverlaySeriesProps {
+    className?: string;
+    overlayStyle?: "hollow" | "step" | "area" | "candle";
+    width?: number | ((props: HTFOverlaySeriesProps, moreProps: any) => number);
+    opacity?: number;
+    yAccessor?: (datum: ChartDatum) => any;
+}
+declare class HTFOverlaySeries extends Component<HTFOverlaySeriesProps> {
+    static propTypes: {
+        className: PropTypes.Requireable<string>;
+        overlayStyle: PropTypes.Requireable<string>;
+        width: PropTypes.Requireable<NonNullable<number | ((...args: any[]) => any) | null | undefined>>;
+        opacity: PropTypes.Requireable<number>;
+        yAccessor: PropTypes.Requireable<(...args: any[]) => any>;
+    };
+    static defaultProps: {
+        className: string;
+        overlayStyle: string;
+        width: typeof plotDataLengthBarWidth;
+        opacity: number;
+        yAccessor: (d: any) => any;
+    };
+    constructor(props: HTFOverlaySeriesProps);
+    drawOnCanvas(ctx: CanvasRenderingContext2D, moreProps: any): void;
+    renderSVG(moreProps: any): import("react").JSX.Element | null;
+    render(): import("react").JSX.Element;
+}
+export default HTFOverlaySeries;

package/dist/dts/lib/series/HistogramSeries.d.ts

@@ -0,0 +1,51 @@
+import type { BarSeriesProps } from "./BarSeries";
+/**
+ * W1.2/A2 — Histogram series: cột tô màu theo dấu so với đường cơ sở.
+ *
+ * Dùng cho MACD histogram, RSI bars, OBV, Chaikin oscillator — những chỉ báo mà
+ * dạng cột trực quan hơn đường. Engine đã map mọi type chứa "histogram" sang
+ * mode `"bar"` (`KernelEngine.resolveSeriesMode:3256-3261`) nên không cần sửa
+ * render loop — chỉ cần một series type ở phía widget.
+ *
+ * Vì sao không dùng thẳng `BarSeries`: nó lấy `fill` từ prop, không biết dấu của
+ * giá trị. Ở đây `fill` là hàm bọc quanh `yAccessor` để chọn màu theo vế trên/dưới
+ * `baseAt`, đúng như TradingView hiển thị MACD histogram.
+ *
+ * `baseAt` mặc định là 0 (đường zero của chỉ báo), không phải `yScale(0)` — cùng
+ * kết quả với giá trị 0 nhưng rõ ràng hơn khi pane không có 0 trong domain.
+ */
+export interface HistogramSeriesProps extends Omit<BarSeriesProps, "fill" | "baseAt"> {
+    /** Giá trị cơ sở để so dấu. Mặc định 0 — đường zero của chỉ báo. */
+    baseAt?: number | ((xScale: any, yScale: any, datum?: any) => number);
+    /** Màu khi giá trị > baseAt. */
+    upColor?: string;
+    /** Màu khi giá trị < baseAt. */
+    downColor?: string;
+    /** Màu khi bằng đúng baseAt (mặc định lấy `upColor` để không tạo cột ba màu). */
+    flatColor?: string;
+    /** Độ đậm. Histogram đặc hơn volume nên mặc định đậm hơn BarSeries. */
+    opacity?: number;
+}
+export interface HistogramColors {
+    baseAt: number;
+    upColor: string;
+    downColor: string;
+    flatColor?: string;
+}
+export declare const HISTOGRAM_DEFAULTS: {
+    readonly baseAt: 0;
+    readonly upColor: "#26a69a";
+    readonly downColor: "#ef5350";
+    readonly opacity: 0.9;
+};
+/**
+ * Chọn màu cột theo dấu so với đường cơ sở. Tách thành hàm thuần để test được
+ * mà không cần dựng chart — logic này là toàn bộ giá trị của histogram.
+ *
+ * Giá trị không hợp lệ (NaN/undefined/không phải số) trả `upColor` **không phải**
+ * `downColor`: một cột không có dữ liệu tô màu "giảm" sẽ đọc thành tín hiệu xu hướng
+ * không tồn tại.
+ */
+export declare function resolveHistogramFill(value: unknown, colors: HistogramColors): string;
+export declare function HistogramSeries(props: HistogramSeriesProps): import("react").JSX.Element;
+export default HistogramSeries;

package/dist/dts/lib/series/KagiSeries.d.ts

@@ -0,0 +1,9 @@
+import React, { Component } from "react";
+declare class KagiSeries extends Component<any, any> {
+    static defaultProps: any;
+    constructor(props: any);
+    drawOnCanvas(ctx: any, moreProps: any): void;
+    render(): React.JSX.Element;
+    renderSVG(moreProps: any): React.JSX.Element;
+}
+export default KagiSeries;

package/dist/dts/lib/series/LineBreakSeries.d.ts

@@ -0,0 +1,28 @@
+import React, { Component } from "react";
+/**
+ * Line Break — một đường bậc thang qua mức đóng của từng đoạn.
+ *
+ * Hình học GIỐNG kagi: trong lòng một đoạn, mức HẰNG cho tới khi đoạn kết thúc, nên
+ * phải dùng `curveStepBefore` — một đoạn thẳng sẽ vẽ ra độ dốc giữa hai mức chưa
+ * bao giờ cùng tồn tại. Khác kagi ở quy tắc CHIA ĐOẠN (line break dùng một `n` cho
+ * cả bước lẫn đảo chiều, xem `calculators/exoticChartData.computeLineBreakLevels`),
+ * không khác ở hình học.
+ *
+ * `drawOn={["pan"]}`: giống kagi — mức chỉ đổi khi đường kết thúc nên không cần
+ * vẽ lại toàn bộ mỗi lần rê chuột, nhưng kéo ngang thì phải vẽ lại.
+ */
+declare class LineBreakSeries extends Component<any, any> {
+    static defaultProps: any;
+    constructor(props: any);
+    drawOnCanvas(ctx: any, moreProps: any): void;
+    render(): React.JSX.Element;
+    renderSVG(moreProps: any): React.JSX.Element;
+}
+/**
+ * Tách thành từng ĐOẠN theo lần đảo hướng, mỗi đoạn là một mảng `[x, level]`.
+ *
+ * Bar không có `lineBreakClose` (producer chưa chạy) bị BỎ QUA thay vì ném — cùng
+ * nguyên tắc fail-closed với `seriesValueResolver`.
+ */
+export declare function getLineBreakLegs(moreProps: any): any[];
+export default LineBreakSeries;