@simahfud/pine-to-kline 0.1.1 → 0.1.3

package/dist/index.d.ts

@@ -1,21 +1,696 @@
-/**
- * pine-to-kline — Public API
- * PineScript v5/v6 interpreter for KlineChart registerIndicator
- * @license Apache-2.0
- */
-export { PineInterpreter } from './PineInterpreter';
-export { createPinePlugin } from './plugin/KlineChartProPlugin';
-export type { PineAPI, PinePluginOptions } from './plugin/KlineChartProPlugin';
-export { Lexer } from './lexer/Lexer';
-export { Token } from './lexer/Token';
-export { TokenType } from './lexer/TokenType';
-export { Parser } from './parser/Parser';
-export { PineRuntime } from './runtime/PineRuntime';
-export { KlineAdapter } from './adapter/KlineAdapter';
-export { SeriesEmulator } from './runtime/SeriesEmulator';
-export { BarContext } from './runtime/BarContext';
-export { TA_REGISTRY } from './builtins/ta/index';
-export { ALL_BUILTINS, ALL_CONSTANTS } from './builtins/index';
-export type { PineInterpreterOptions, CompileResult, ValidationResult, IndicatorConfig, IndicatorFigure, KlineData, PineInput, PinePlot, PineHline, PineMeta, PineIR, } from './types';
-export { PineError, LexerError, ParseError, RuntimeError, AdapterError } from './utils/errors';
-//# sourceMappingURL=index.d.ts.map
+export declare class AdapterError extends PineError {
+    constructor(message: string);
+}
+
+/** Combined registry of ALL built-in functions */
+export declare const ALL_BUILTINS: Record<string, Function>;
+
+/** Combined registry of ALL built-in constants */
+export declare const ALL_CONSTANTS: Record<string, any>;
+
+declare interface AnnotationNode {
+    type: 'Annotation';
+    value: string;
+    line: number;
+}
+
+declare interface ArrayLiteral {
+    type: 'ArrayLiteral';
+    elements: ExprNode[];
+    line: number;
+}
+
+declare interface AssignNode {
+    type: 'Assign';
+    target: string;
+    operator: '=' | ':=' | '+=' | '-=' | '*=' | '/=' | '%=';
+    value: ExprNode;
+    line: number;
+}
+
+/**
+ * pine-to-kline — AST Node Definitions
+ * All node types for the PineScript Abstract Syntax Tree
+ * @license Apache-2.0
+ */
+declare type ASTNode = ProgramNode | AnnotationNode | IndicatorNode | VarDeclNode | AssignNode | IfNode | ForNode | ForInNode | WhileNode | SwitchNode | FunctionDefNode | ReturnNode | BreakNode | ContinueNode | ExpressionStatement | PlotCallNode | HlineCallNode | ExprNode;
+
+export declare class BarContext {
+    readonly dataList: KlineData[];
+    readonly open: number[];
+    readonly high: number[];
+    readonly low: number[];
+    readonly close: number[];
+    readonly volume: number[];
+    readonly hl2: number[];
+    readonly hlc3: number[];
+    readonly ohlc4: number[];
+    readonly time: number[];
+    readonly barCount: number;
+    constructor(dataList: KlineData[]);
+    /** Resolve a Pine source name to the data array */
+    resolveSource(name: string): number[];
+}
+
+declare interface BinaryExpr {
+    type: 'BinaryExpr';
+    operator: string;
+    left: ExprNode;
+    right: ExprNode;
+    line: number;
+}
+
+declare interface BoolLiteral {
+    type: 'BoolLiteral';
+    value: boolean;
+    line: number;
+}
+
+declare interface BreakNode {
+    type: 'Break';
+    line: number;
+}
+
+declare interface ColorLiteral {
+    type: 'ColorLiteral';
+    value: string;
+    line: number;
+}
+
+export declare interface CompileResult {
+    success: boolean;
+    indicatorConfig: IndicatorConfig;
+    name: string;
+    warnings: string[];
+    errors: Error[];
+}
+
+declare interface ContinueNode {
+    type: 'Continue';
+    line: number;
+}
+
+/**
+ * Create a Pine interpreter plugin for KlineChartPro.
+ *
+ * @example
+ * ```ts
+ * import { createPinePlugin } from 'pine-to-kline/plugin'
+ * import { registerCustomIndicator } from '@simahfud/klinecharts-pro'
+ *
+ * const pine = createPinePlugin()
+ *
+ * // Compile and register a Pine indicator
+ * const name = pine.run(`
+ *   //@version=5
+ *   indicator("RSI", overlay=false)
+ *   length = input.int(14, "Length")
+ *   plot(ta.rsi(close, length), "RSI", color=color.purple)
+ *   hline(70, "OB", color=color.red)
+ *   hline(30, "OS", color=color.green)
+ * `)
+ *
+ * // The indicator is now registered and can be added to a chart
+ * ```
+ */
+export declare function createPinePlugin(options?: PinePluginOptions): PineAPI;
+
+declare interface ExpressionStatement {
+    type: 'ExpressionStatement';
+    expression: ExprNode;
+    line: number;
+}
+
+declare type ExprNode = NumberLiteral | StringLiteral | BoolLiteral | ColorLiteral | NaLiteral | Identifier | BinaryExpr | UnaryExpr | TernaryExpr | FunctionCallExpr | MemberExpr | SeriesAccessExpr | TupleExpr | ArrayLiteral;
+
+declare interface ForInNode {
+    type: 'ForIn';
+    variable: string;
+    iterable: ExprNode;
+    body: ASTNode[];
+    line: number;
+}
+
+declare interface ForNode {
+    type: 'For';
+    variable: string;
+    start: ExprNode;
+    end: ExprNode;
+    step: ExprNode | null;
+    body: ASTNode[];
+    line: number;
+}
+
+declare interface FunctionCallExpr {
+    type: 'FunctionCall';
+    callee: string;
+    args: ExprNode[];
+    kwargs: {
+        key: string;
+        value: ExprNode;
+    }[];
+    line: number;
+}
+
+declare interface FunctionDefNode {
+    type: 'FunctionDef';
+    name: string;
+    params: {
+        name: string;
+        defaultValue: ExprNode | null;
+    }[];
+    body: ASTNode[];
+    line: number;
+}
+
+declare interface HlineCallNode {
+    type: 'HlineCall';
+    price: ExprNode;
+    args: ExprNode[];
+    kwargs: {
+        key: string;
+        value: ExprNode;
+    }[];
+    line: number;
+}
+
+declare interface Identifier {
+    type: 'Identifier';
+    name: string;
+    line: number;
+}
+
+declare interface IfNode {
+    type: 'If';
+    condition: ExprNode;
+    body: ASTNode[];
+    elseIf: {
+        condition: ExprNode;
+        body: ASTNode[];
+    }[];
+    elseBody: ASTNode[] | null;
+    line: number;
+}
+
+export declare interface IndicatorConfig {
+    name: string;
+    shortName: string;
+    series?: string;
+    calcParams: any[];
+    figures: IndicatorFigure[];
+    regenerateFigures?: (params: any[]) => IndicatorFigure[];
+    calc: (dataList: KlineData[], indicator: any) => Record<string, any>[];
+    draw?: (params: any) => boolean;
+    createTooltipDataSource?: (params: any) => any;
+    extendData?: any;
+}
+
+export declare interface IndicatorFigure {
+    key: string;
+    title: string;
+    type: 'line' | 'bar' | 'circle';
+    styles?: (data: any, indicator: any, defaultStyles: any) => any;
+}
+
+declare interface IndicatorNode {
+    type: 'Indicator';
+    name: ExprNode;
+    args: {
+        key: string;
+        value: ExprNode;
+    }[];
+    line: number;
+}
+
+export declare class KlineAdapter {
+    toIndicatorTemplate(ir: PineIR): IndicatorConfig;
+    private mapFigures;
+}
+
+/**
+ * pine-to-kline — Core Type Definitions
+ * @license Apache-2.0
+ */
+export declare interface KlineData {
+    timestamp: number;
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+    volume?: number;
+    turnover?: number;
+}
+
+export declare class Lexer {
+    private source;
+    private tokens;
+    private pos;
+    private line;
+    private column;
+    private indentStack;
+    private atLineStart;
+    constructor(source: string);
+    tokenize(): Token[];
+    private handleIndentation;
+    private emitNewline;
+    private readComment;
+    private readNumber;
+    private readString;
+    private readColor;
+    private readIdentifier;
+    private readOperator;
+    /**
+     * Filter out meaningless tokens and handle line continuation.
+     * Pine uses implicit line continuation after certain tokens:
+     * binary operators, commas, opening brackets/parens.
+     */
+    private filterTokens;
+    private current;
+    private peek;
+    private advance;
+    private isDigit;
+    private isAlpha;
+    private isAlphaNumeric;
+    private isHexDigit;
+}
+
+export declare class LexerError extends PineError {
+    constructor(message: string, line?: number, column?: number);
+}
+
+declare interface MemberExpr {
+    type: 'MemberExpr';
+    object: ExprNode;
+    property: string;
+    line: number;
+}
+
+declare interface NaLiteral {
+    type: 'NaLiteral';
+    line: number;
+}
+
+declare interface NumberLiteral {
+    type: 'NumberLiteral';
+    value: number;
+    line: number;
+}
+
+export declare class ParseError extends PineError {
+    constructor(message: string, line?: number, column?: number);
+}
+
+export declare class Parser {
+    private tokens;
+    private pos;
+    constructor(tokens: Token[]);
+    parse(): ProgramNode;
+    private parseStatement;
+    private parseIdentifierStatement;
+    private parseIndicator;
+    private parseVarDecl;
+    private parseTypedDecl;
+    private parseAssignment;
+    private parseTupleAssign;
+    private parseIf;
+    private parseFor;
+    private parseWhile;
+    private parseSwitch;
+    private parseReturn;
+    private isFunctionDef;
+    private parseFunctionDef;
+    private parsePlotCall;
+    private parseHlineCall;
+    private parseExpression;
+    private parseTernary;
+    private parseOr;
+    private parseAnd;
+    private parseComparison;
+    private parseAddition;
+    private parseMultiplication;
+    private parsePower;
+    private parseUnary;
+    private parsePostfix;
+    private parsePrimary;
+    private parseCallArgs;
+    private parseBlock;
+    private parseBlockOrExpr;
+    private buildCalleeName;
+    private peek;
+    private peekAt;
+    private previous;
+    private isAtEnd;
+    private advance;
+    private check;
+    private checkAny;
+    private match;
+    private expect;
+    private skipNewlines;
+}
+
+export declare interface PineAPI {
+    /** Compile + register + return indicator name */
+    run: (pineCode: string) => string;
+    /** Validate syntax only */
+    validate: (pineCode: string) => ValidationResult;
+    /** Compile without adding to chart */
+    compile: (pineCode: string) => CompileResult;
+}
+
+/**
+ * pine-to-kline — Error Classes
+ * @license Apache-2.0
+ */
+export declare class PineError extends Error {
+    readonly line?: number | undefined;
+    readonly column?: number | undefined;
+    readonly source?: string | undefined;
+    constructor(message: string, line?: number | undefined, column?: number | undefined, source?: string | undefined);
+    toString(): string;
+}
+
+export declare interface PineHline {
+    price: number;
+    title: string | null;
+    color: string | null;
+    linestyle: string | null;
+    linewidth: number;
+}
+
+export declare interface PineInput {
+    id: string;
+    type: 'int' | 'float' | 'bool' | 'string' | 'color' | 'source';
+    title: string | null;
+    defaultValue: any;
+    minval?: number;
+    maxval?: number;
+    step?: number;
+    options?: any[];
+}
+
+export declare class PineInterpreter {
+    private options;
+    constructor(options?: PineInterpreterOptions);
+    /** Full compile: PineScript source → IndicatorConfig (IndicatorTemplate) */
+    compile(source: string): CompileResult;
+    /** Validate syntax only (no execution) */
+    validate(source: string): ValidationResult;
+    /** Compile + register to KlineChart (global or instance) */
+    register(source: string, registerFn?: (config: any) => void): string;
+    /** Execute directly with data (for testing/preview) */
+    execute(source: string, dataList: KlineData[], params?: any[]): Record<string, any>[];
+}
+
+export declare interface PineInterpreterOptions {
+    /** Target Pine Script version */
+    version?: 'v5' | 'v6';
+    /** Strict mode — error on unsupported features */
+    strict?: boolean;
+    /** Enable sandbox isolation */
+    sandbox?: boolean;
+    /** Warning callback */
+    onWarning?: (msg: string) => void;
+    /** Error callback */
+    onError?: (err: Error) => void;
+}
+
+export declare interface PineIR {
+    meta: PineMeta;
+    inputs: PineInput[];
+    plots: PinePlot[];
+    hlines: PineHline[];
+    calcFn: (dataList: KlineData[], params: any[]) => Record<string, any>[];
+    warnings: string[];
+    errors: Error[];
+}
+
+export declare interface PineMeta {
+    name: string;
+    shortName: string | null;
+    overlay: boolean;
+    format: string | null;
+    precision: number | null;
+    scale: string | null;
+    max_bars_back: number | null;
+}
+
+export declare interface PinePlot {
+    id: string;
+    title: string | null;
+    color: string | null;
+    linewidth: number;
+    style: string | null;
+    editable?: boolean;
+}
+
+export declare interface PinePluginOptions extends PineInterpreterOptions {
+    /** Persist Pine scripts in layout JSON */
+    persistToLayout?: boolean;
+}
+
+export declare class PineRuntime {
+    private ctx;
+    private vars;
+    private scope;
+    private functions;
+    private meta;
+    private inputs;
+    private plots;
+    private hlines;
+    private plotResults;
+    private warnings;
+    private inputIndex;
+    execute(ast: ProgramNode, dataList: KlineData[], params?: any[]): RuntimeResult;
+    private firstPass;
+    private runCalc;
+    private runOnce;
+    private evalNode;
+    private evalIndicator;
+    private evalVarDecl;
+    private evalAssign;
+    private evalIf;
+    private evalFor;
+    private evalWhile;
+    private evalPlot;
+    private evalHline;
+    evalExpr(node: ExprNode, sources?: Record<string, number[]>, params?: any[], inputs?: PineInput[]): any;
+    private evalFunctionCall;
+    private callUserFunction;
+    private evalBinary;
+    private scalarBinary;
+    private resolveColor;
+    private buildMemberName;
+}
+
+declare interface PlotCallNode {
+    type: 'PlotCall';
+    function: string;
+    args: ExprNode[];
+    kwargs: {
+        key: string;
+        value: ExprNode;
+    }[];
+    line: number;
+}
+
+declare interface ProgramNode {
+    type: 'Program';
+    body: ASTNode[];
+    annotations: AnnotationNode[];
+}
+
+declare interface ReturnNode {
+    type: 'Return';
+    value: ExprNode | null;
+    line: number;
+}
+
+export declare class RuntimeError extends PineError {
+    constructor(message: string, line?: number, column?: number);
+}
+
+declare interface RuntimeResult {
+    meta: PineMeta;
+    inputs: PineInput[];
+    plots: PinePlot[];
+    hlines: PineHline[];
+    calcFn: (dataList: KlineData[], params: any[]) => Record<string, any>[];
+    warnings: string[];
+    errors: Error[];
+}
+
+declare interface SeriesAccessExpr {
+    type: 'SeriesAccess';
+    series: ExprNode;
+    offset: ExprNode;
+    line: number;
+}
+
+/**
+ * pine-to-kline — Series Emulator
+ * Emulates Pine's bar-by-bar series model using cursor-indexed arrays
+ * @license Apache-2.0
+ */
+export declare class SeriesEmulator<T = number> {
+    private _data;
+    private _cursor;
+    constructor(data: T[]);
+    setCursor(index: number): void;
+    /** Access value with lookback: series[0] = current, series[1] = previous */
+    get(lookback?: number): T;
+    /** Set value at current cursor */
+    set(value: T): void;
+    get length(): number;
+    get current(): T;
+    get all(): T[];
+    /** Get the full underlying array */
+    toArray(): T[];
+}
+
+declare interface StringLiteral {
+    type: 'StringLiteral';
+    value: string;
+    line: number;
+}
+
+declare interface SwitchNode {
+    type: 'Switch';
+    expression: ExprNode | null;
+    cases: {
+        condition: ExprNode | null;
+        body: ASTNode[];
+    }[];
+    defaultBody: ASTNode[] | null;
+    line: number;
+}
+
+/** Registry map: 'ta.sma' → implementation function */
+export declare const TA_REGISTRY: Record<string, Function>;
+
+declare interface TernaryExpr {
+    type: 'TernaryExpr';
+    condition: ExprNode;
+    consequent: ExprNode;
+    alternate: ExprNode;
+    line: number;
+}
+
+export declare class Token {
+    readonly type: TokenType;
+    readonly value: string;
+    readonly line: number;
+    readonly column: number;
+    constructor(type: TokenType, value: string, line: number, column: number);
+    is(type: TokenType): boolean;
+    isAny(...types: TokenType[]): boolean;
+    toString(): string;
+}
+
+/**
+ * pine-to-kline — Token Types
+ * All PineScript v5/v6 token categories
+ * @license Apache-2.0
+ */
+export declare enum TokenType {
+    NUMBER = "NUMBER",
+    STRING = "STRING",
+    COLOR_LITERAL = "COLOR_LITERAL",// #RRGGBB or #RRGGBBAA
+    IDENTIFIER = "IDENTIFIER",
+    IF = "IF",
+    ELSE = "ELSE",
+    FOR = "FOR",
+    TO = "TO",
+    BY = "BY",
+    IN = "IN",
+    WHILE = "WHILE",
+    SWITCH = "SWITCH",
+    VAR = "VAR",
+    VARIP = "VARIP",
+    TRUE = "TRUE",
+    FALSE = "FALSE",
+    NA = "NA",
+    AND = "AND",
+    OR = "OR",
+    NOT = "NOT",
+    IMPORT = "IMPORT",
+    EXPORT = "EXPORT",
+    TYPE = "TYPE",
+    METHOD = "METHOD",
+    BREAK = "BREAK",
+    CONTINUE = "CONTINUE",
+    RETURN = "RETURN",
+    INDICATOR = "INDICATOR",
+    STRATEGY = "STRATEGY",
+    LIBRARY = "LIBRARY",
+    PLUS = "PLUS",// +
+    MINUS = "MINUS",// -
+    STAR = "STAR",// *
+    SLASH = "SLASH",// /
+    PERCENT = "PERCENT",// %
+    POWER = "POWER",// **  (NEW in Pine — not ^)
+    EQ = "EQ",// ==
+    NEQ = "NEQ",// !=
+    LT = "LT",// <
+    GT = "GT",// >
+    LTE = "LTE",// <=
+    GTE = "GTE",// >=
+    ASSIGN = "ASSIGN",// =
+    REASSIGN = "REASSIGN",// :=
+    PLUS_ASSIGN = "PLUS_ASSIGN",// +=
+    MINUS_ASSIGN = "MINUS_ASSIGN",// -=
+    STAR_ASSIGN = "STAR_ASSIGN",// *=
+    SLASH_ASSIGN = "SLASH_ASSIGN",// /=
+    PERCENT_ASSIGN = "PERCENT_ASSIGN",// %=
+    LPAREN = "LPAREN",// (
+    RPAREN = "RPAREN",// )
+    LBRACKET = "LBRACKET",// [
+    RBRACKET = "RBRACKET",// ]
+    COMMA = "COMMA",// ,
+    DOT = "DOT",// .
+    COLON = "COLON",// :
+    QUESTION = "QUESTION",// ?
+    ARROW = "ARROW",// =>
+    NEWLINE = "NEWLINE",
+    INDENT = "INDENT",
+    DEDENT = "DEDENT",
+    EOF = "EOF",
+    COMMENT = "COMMENT",
+    COMPILER_ANNOTATION = "COMPILER_ANNOTATION"
+}
+
+declare interface TupleExpr {
+    type: 'TupleExpr';
+    elements: ExprNode[];
+    line: number;
+}
+
+declare interface UnaryExpr {
+    type: 'UnaryExpr';
+    operator: string;
+    operand: ExprNode;
+    line: number;
+}
+
+export declare interface ValidationResult {
+    valid: boolean;
+    errors: Error[];
+}
+
+declare interface VarDeclNode {
+    type: 'VarDecl';
+    persistent: boolean;
+    persistentTick: boolean;
+    name: string | string[];
+    typeAnnotation: string | null;
+    value: ExprNode;
+    line: number;
+}
+
+declare interface WhileNode {
+    type: 'While';
+    condition: ExprNode;
+    body: ASTNode[];
+    line: number;
+}
+
+export { }