@forgecharts/sdk 1.1.27 → 1.1.29

package/src/tscript/TScriptIndicator.ts

@@ -1,54 +0,0 @@
-/**
- * TScriptIndicator — compiles and executes a TScript program, exposing its
- * plot() outputs as IndicatorPoint arrays compatible with the DAG DAGResult format.
- *
- * @example
- * ```ts
- * const ind = new TScriptIndicator(`
- *   indicator("My SMA")
- *   length = input(14)
- *   value = sma(close, length)
- *   plot(value)
- * `);
- *
- * const plots = ind.run(bars);
- * // plots[0] → IndicatorPoint[] for the first plot() call
- * ```
- */
-
-import type { OHLCV } from '@forgecharts/types';
-import { TScriptRuntime } from './runtime';
-import type { IndicatorPoint } from '../core/IndicatorEngine';
-
-export class TScriptIndicator {
-  private readonly _runtime: TScriptRuntime;
-
-  /** Title from the `indicator("...")` declaration, or `'Script'` if absent. */
-  readonly title: string;
-
-  constructor(src: string) {
-    this._runtime = new TScriptRuntime(src);
-    this.title    = this._runtime.title;
-  }
-
-  /**
-   * Execute the script over the full bar history.
-   *
-   * Each call resets internal state and replays every bar from scratch,
-   * ensuring the output is deterministic regardless of prior calls.
-   *
-   * @returns array of plot series — `plots[0]` corresponds to the first
-   *          `plot()` call in source, `plots[1]` to the second, etc.
-   */
-  run(bars: readonly OHLCV[]): IndicatorPoint[][] {
-    return this._runtime.run(bars);
-  }
-
-  /**
-   * Reset all persistent series state (ring buffers) without re-parsing.
-   * Call when the chart symbol or timeframe changes.
-   */
-  reset(): void {
-    this._runtime.reset();
-  }
-}

package/src/tscript/ast.ts

@@ -1,105 +0,0 @@
-/**
- * TScript Abstract Syntax Tree node types.
- *
- * Grammar (simplified):
- *   program       → stmt*
- *   stmt          → indicator_decl | assign | expr_stmt
- *   assign        → IDENT '=' expr
- *   indicator     → 'indicator' '(' STRING ')'
- *   expr          → ternary
- *   ternary       → or ('?' expr ':' expr)?
- *   or            → and ('or' and)*
- *   and           → not ('and' not)*
- *   not           → 'not' comparison | comparison
- *   comparison    → addition (('<'|'>'|'<='|'>='|'=='|'!=') addition)*
- *   addition      → multiplication (('+' | '-') multiplication)*
- *   multiplication→ unary (('*' | '/' | '%') unary)*
- *   unary         → '-' unary | primary
- *   primary       → NUMBER | STRING | BOOL | IDENT ('[' expr ']')? | call | '(' expr ')'
- *   call          → IDENT '(' args ')'
- */
-
-// ─── Literal / leaf nodes ─────────────────────────────────────────────────────
-
-export type NumberLit  = { kind: 'NumberLit';  value: number };
-export type StringLit  = { kind: 'StringLit';  value: string };
-export type BoolLit    = { kind: 'BoolLit';    value: boolean };
-export type Identifier = { kind: 'Identifier'; name: string };
-
-// ─── Expression nodes ─────────────────────────────────────────────────────────
-
-export type IndexExpr = {
-  kind:   'IndexExpr';
-  series: Expr;   // the base series (usually an Identifier)
-  index:  Expr;   // bar-lookback, e.g. close[1]
-};
-
-export type CallExpr = {
-  kind:  'CallExpr';
-  callee: string;
-  args:   Expr[];
-};
-
-export type BinaryExpr = {
-  kind:  'BinaryExpr';
-  op:    '+' | '-' | '*' | '/' | '%' | '<' | '>' | '<=' | '>=' | '==' | '!=';
-  left:  Expr;
-  right: Expr;
-};
-
-export type UnaryExpr = {
-  kind:   'UnaryExpr';
-  op:     '-' | 'not';
-  operand: Expr;
-};
-
-export type TernaryExpr = {
-  kind:       'TernaryExpr';
-  condition:  Expr;
-  consequent: Expr;
-  alternate:  Expr;
-};
-
-export type LogicalExpr = {
-  kind:  'LogicalExpr';
-  op:    'and' | 'or';
-  left:  Expr;
-  right: Expr;
-};
-
-export type Expr =
-  | NumberLit
-  | StringLit
-  | BoolLit
-  | Identifier
-  | IndexExpr
-  | CallExpr
-  | BinaryExpr
-  | UnaryExpr
-  | TernaryExpr
-  | LogicalExpr;
-
-// ─── Statement nodes ──────────────────────────────────────────────────────────
-
-export type IndicatorDecl = {
-  kind:  'IndicatorDecl';
-  title: string;
-};
-
-export type AssignStmt = {
-  kind:  'AssignStmt';
-  name:  string;
-  value: Expr;
-};
-
-export type ExprStmt = {
-  kind: 'ExprStmt';
-  expr: Expr;
-};
-
-export type Stmt = IndicatorDecl | AssignStmt | ExprStmt;
-
-export type Program = {
-  kind:  'Program';
-  stmts: Stmt[];
-};

package/src/tscript/lexer.ts

@@ -1,190 +0,0 @@
-/**
- * TScript Lexer — converts source text into a flat token stream.
- *
- * Token types:
- *  NUMBER  — 42, 3.14, .5
- *  STRING  — "hello" or 'hello'
- *  BOOL    — true / false
- *  IDENT   — identifier or keyword
- *  OP      — single/double-char operator
- *  LPAREN, RPAREN, LBRACKET, RBRACKET, COMMA, EQ, NEWLINE
- *  EOF
- */
-
-export type TokenKind =
-  | 'NUMBER' | 'STRING' | 'BOOL' | 'IDENT'
-  | 'PLUS' | 'MINUS' | 'STAR' | 'SLASH' | 'PERCENT'
-  | 'LT' | 'GT' | 'LTE' | 'GTE' | 'EQEQ' | 'NEQ'
-  | 'QMARK' | 'COLON'
-  | 'LPAREN' | 'RPAREN' | 'LBRACKET' | 'RBRACKET'
-  | 'COMMA' | 'EQ'
-  | 'NEWLINE' | 'EOF';
-
-export type Token = {
-  kind:   TokenKind;
-  value:  string;   // raw matched text
-  line:   number;
-  col:    number;
-};
-
-// Keywords that are NOT identifiers
-const KEYWORDS = new Set(['true', 'false', 'and', 'or', 'not', 'indicator', 'input', 'plot', 'na']);
-
-export class Lexer {
-  private _src:  string;
-  private _pos:  number = 0;
-  private _line: number = 1;
-  private _col:  number = 1;
-
-  constructor(src: string) {
-    this._src = src;
-  }
-
-  tokenize(): Token[] {
-    const tokens: Token[] = [];
-    while (this._pos < this._src.length) {
-      this._skipWhitespaceAndComments();
-      if (this._pos >= this._src.length) break;
-
-      const ch = this._src[this._pos]!;
-
-      // Newline as statement separator
-      if (ch === '\n') {
-        tokens.push(this._make('NEWLINE', '\n'));
-        this._pos++;
-        this._line++;
-        this._col = 1;
-        continue;
-      }
-
-      // Numbers
-      if (ch >= '0' && ch <= '9' || (ch === '.' && this._peek(1) >= '0' && this._peek(1) <= '9')) {
-        tokens.push(this._readNumber());
-        continue;
-      }
-
-      // Strings
-      if (ch === '"' || ch === "'") {
-        tokens.push(this._readString(ch));
-        continue;
-      }
-
-      // Identifiers / keywords
-      if (this._isAlpha(ch)) {
-        tokens.push(this._readIdent());
-        continue;
-      }
-
-      // Two-char operators first
-      const two = this._src.slice(this._pos, this._pos + 2);
-      if (two === '<=' ) { tokens.push(this._make('LTE',  two)); this._pos += 2; this._col += 2; continue; }
-      if (two === '>=' ) { tokens.push(this._make('GTE',  two)); this._pos += 2; this._col += 2; continue; }
-      if (two === '==' ) { tokens.push(this._make('EQEQ', two)); this._pos += 2; this._col += 2; continue; }
-      if (two === '!=' ) { tokens.push(this._make('NEQ',  two)); this._pos += 2; this._col += 2; continue; }
-
-      // Single-char operators
-      const ops: Record<string, TokenKind> = {
-        '+': 'PLUS', '-': 'MINUS', '*': 'STAR', '/': 'SLASH', '%': 'PERCENT',
-        '<': 'LT',   '>': 'GT',
-        '?': 'QMARK', ':': 'COLON',
-        '(': 'LPAREN', ')': 'RPAREN',
-        '[': 'LBRACKET', ']': 'RBRACKET',
-        ',': 'COMMA',
-        '=': 'EQ',
-      };
-      if (ch in ops) {
-        tokens.push(this._make(ops[ch]!, ch));
-        this._pos++;
-        this._col++;
-        continue;
-      }
-
-      throw new SyntaxError(`[TScript] Unexpected character '${ch}' at ${this._line}:${this._col}`);
-    }
-    tokens.push(this._make('EOF', ''));
-    return tokens;
-  }
-
-  // ─── Private helpers ────────────────────────────────────────────────────────
-
-  private _make(kind: TokenKind, value: string): Token {
-    return { kind, value, line: this._line, col: this._col };
-  }
-
-  private _peek(offset: number): string {
-    return this._src[this._pos + offset] ?? '';
-  }
-
-  private _isAlpha(ch: string): boolean {
-    return (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || ch === '_';
-  }
-
-  private _isAlphaNum(ch: string): boolean {
-    return this._isAlpha(ch) || (ch >= '0' && ch <= '9');
-  }
-
-  private _skipWhitespaceAndComments(): void {
-    while (this._pos < this._src.length) {
-      const ch = this._src[this._pos]!;
-      // Skip spaces/tabs/carriage-returns but NOT newlines (they are tokens)
-      if (ch === ' ' || ch === '\t' || ch === '\r') {
-        this._pos++; this._col++;
-        continue;
-      }
-      // Line comment: // ... to end of line
-      if (ch === '/' && this._peek(1) === '/') {
-        while (this._pos < this._src.length && this._src[this._pos] !== '\n') {
-          this._pos++; this._col++;
-        }
-        continue;
-      }
-      break;
-    }
-  }
-
-  private _readNumber(): Token {
-    const start = this._pos;
-    const startCol = this._col;
-    while (this._pos < this._src.length) {
-      const c = this._src[this._pos]!;
-      if ((c >= '0' && c <= '9') || c === '.') { this._pos++; this._col++; }
-      else break;
-    }
-    const raw = this._src.slice(start, this._pos);
-    return { kind: 'NUMBER', value: raw, line: this._line, col: startCol };
-  }
-
-  private _readString(quote: string): Token {
-    const startCol = this._col;
-    this._pos++; this._col++; // skip opening quote
-    let result = '';
-    while (this._pos < this._src.length && this._src[this._pos] !== quote) {
-      if (this._src[this._pos] === '\\') {
-        this._pos++; this._col++;
-        const esc = this._src[this._pos] ?? '';
-        result += esc === 'n' ? '\n' : esc === 't' ? '\t' : esc;
-      } else {
-        result += this._src[this._pos];
-      }
-      this._pos++; this._col++;
-    }
-    this._pos++; this._col++; // skip closing quote
-    return { kind: 'STRING', value: result, line: this._line, col: startCol };
-  }
-
-  private _readIdent(): Token {
-    const start = this._pos;
-    const startCol = this._col;
-    while (this._pos < this._src.length && this._isAlphaNum(this._src[this._pos]!)) {
-      this._pos++; this._col++;
-    }
-    const name = this._src.slice(start, this._pos);
-    if (name === 'true' || name === 'false') {
-      return { kind: 'BOOL', value: name, line: this._line, col: startCol };
-    }
-    // Keywords like 'and', 'or', 'not', 'indicator' stay as IDENT so parser can
-    // recognise them by value rather than needing dedicated token kinds.
-    void KEYWORDS; // referenced for documentation only
-    return { kind: 'IDENT', value: name, line: this._line, col: startCol };
-  }
-}

package/src/tscript/parser.ts

@@ -1,334 +0,0 @@
-/**
- * TScript Parser — recursive-descent, produces a typed AST.
- *
- * Precedence (low → high):
- *   ternary   ? :
- *   or
- *   and
- *   not
- *   comparison  < > <= >= == !=
- *   addition    + -
- *   multiply    * / %
- *   unary       - (prefix)
- *   primary     literals, identifiers, index [], call()
- */
-
-import type {
-  Program, Stmt, Expr,
-  IndicatorDecl, AssignStmt, ExprStmt,
-  NumberLit, StringLit, BoolLit, Identifier,
-  IndexExpr, CallExpr, BinaryExpr, UnaryExpr,
-  TernaryExpr, LogicalExpr,
-} from './ast';
-import { Lexer } from './lexer';
-import type { Token, TokenKind } from './lexer';
-
-export class Parser {
-  private _tokens: Token[];
-  private _pos: number = 0;
-
-  constructor(src: string) {
-    this._tokens = new Lexer(src).tokenize().filter((t) => t.kind !== 'NEWLINE' || this._isStatementBoundary(t));
-    // Re-filter: keep NEWLINEs as statement separators but collapse runs
-    this._tokens = this._collapseNewlines(new Lexer(src).tokenize());
-  }
-
-  parse(): Program {
-    const stmts: Stmt[] = [];
-    this._skipNewlines();
-    while (!this._check('EOF')) {
-      stmts.push(this._stmt());
-      this._skipNewlines();
-    }
-    return { kind: 'Program', stmts };
-  }
-
-  // ─── Statements ─────────────────────────────────────────────────────────────
-
-  private _stmt(): Stmt {
-    // indicator("title")
-    if (this._checkIdent('indicator')) {
-      return this._indicatorDecl();
-    }
-
-    // assignment: IDENT = expr  (but not IDENT == ...)
-    if (this._check('IDENT') && this._peekKind(1) === 'EQ') {
-      return this._assign();
-    }
-
-    return this._exprStmt();
-  }
-
-  private _indicatorDecl(): IndicatorDecl {
-    this._consumeIdent('indicator');
-    this._consume('LPAREN', "Expected '(' after 'indicator'");
-    const title = this._consume('STRING', "Expected string title in indicator()").value;
-    this._consume('RPAREN', "Expected ')' after indicator title");
-    this._consumeNewlineOrEOF();
-    return { kind: 'IndicatorDecl', title };
-  }
-
-  private _assign(): AssignStmt {
-    const name = this._consume('IDENT', 'Expected identifier').value;
-    this._consume('EQ', "Expected '='");
-    const value = this._expr();
-    this._consumeNewlineOrEOF();
-    return { kind: 'AssignStmt', name, value };
-  }
-
-  private _exprStmt(): ExprStmt {
-    const expr = this._expr();
-    this._consumeNewlineOrEOF();
-    return { kind: 'ExprStmt', expr };
-  }
-
-  // ─── Expressions ────────────────────────────────────────────────────────────
-
-  private _expr(): Expr {
-    return this._ternary();
-  }
-
-  private _ternary(): Expr {
-    let left = this._or();
-    if (this._match('QMARK')) {
-      const consequent = this._expr();
-      this._consume('COLON', "Expected ':' in ternary expression");
-      const alternate = this._expr();
-      const node: TernaryExpr = { kind: 'TernaryExpr', condition: left, consequent, alternate };
-      left = node;
-    }
-    return left;
-  }
-
-  private _or(): Expr {
-    let left = this._and();
-    while (this._checkIdent('or')) {
-      this._advance();
-      const right = this._and();
-      const node: LogicalExpr = { kind: 'LogicalExpr', op: 'or', left, right };
-      left = node;
-    }
-    return left;
-  }
-
-  private _and(): Expr {
-    let left = this._not();
-    while (this._checkIdent('and')) {
-      this._advance();
-      const right = this._not();
-      const node: LogicalExpr = { kind: 'LogicalExpr', op: 'and', left, right };
-      left = node;
-    }
-    return left;
-  }
-
-  private _not(): Expr {
-    if (this._checkIdent('not')) {
-      this._advance();
-      const operand = this._comparison();
-      const node: UnaryExpr = { kind: 'UnaryExpr', op: 'not', operand };
-      return node;
-    }
-    return this._comparison();
-  }
-
-  private _comparison(): Expr {
-    let left = this._addition();
-    while (true) {
-      if (this._match('LTE'))  { left = this._binop('<=', left, this._addition()); continue; }
-      if (this._match('GTE'))  { left = this._binop('>=', left, this._addition()); continue; }
-      if (this._match('EQEQ')) { left = this._binop('==', left, this._addition()); continue; }
-      if (this._match('NEQ'))  { left = this._binop('!=', left, this._addition()); continue; }
-      if (this._match('LT'))   { left = this._binop('<',  left, this._addition()); continue; }
-      if (this._match('GT'))   { left = this._binop('>',  left, this._addition()); continue; }
-      break;
-    }
-    return left;
-  }
-
-  private _addition(): Expr {
-    let left = this._multiplication();
-    while (true) {
-      if (this._match('PLUS'))  { left = this._binop('+', left, this._multiplication()); continue; }
-      if (this._match('MINUS')) { left = this._binop('-', left, this._multiplication()); continue; }
-      break;
-    }
-    return left;
-  }
-
-  private _multiplication(): Expr {
-    let left = this._unary();
-    while (true) {
-      if (this._match('STAR'))    { left = this._binop('*', left, this._unary()); continue; }
-      if (this._match('SLASH'))   { left = this._binop('/', left, this._unary()); continue; }
-      if (this._match('PERCENT')) { left = this._binop('%', left, this._unary()); continue; }
-      break;
-    }
-    return left;
-  }
-
-  private _unary(): Expr {
-    if (this._match('MINUS')) {
-      const operand = this._unary();
-      const node: UnaryExpr = { kind: 'UnaryExpr', op: '-', operand };
-      return node;
-    }
-    return this._primary();
-  }
-
-  private _primary(): Expr {
-    const tok = this._current();
-
-    // Number literal
-    if (tok.kind === 'NUMBER') {
-      this._advance();
-      const node: NumberLit = { kind: 'NumberLit', value: parseFloat(tok.value) };
-      return node;
-    }
-
-    // String literal
-    if (tok.kind === 'STRING') {
-      this._advance();
-      const node: StringLit = { kind: 'StringLit', value: tok.value };
-      return node;
-    }
-
-    // Bool literal
-    if (tok.kind === 'BOOL') {
-      this._advance();
-      const node: BoolLit = { kind: 'BoolLit', value: tok.value === 'true' };
-      return node;
-    }
-
-    // na (special NaN constant)
-    if (tok.kind === 'IDENT' && tok.value === 'na') {
-      this._advance();
-      const node: NumberLit = { kind: 'NumberLit', value: NaN };
-      return node;
-    }
-
-    // Function call: IDENT '(' args ')'
-    if (tok.kind === 'IDENT' && this._peekKind(1) === 'LPAREN') {
-      return this._callExpr();
-    }
-
-    // Identifier (and optional series index)
-    if (tok.kind === 'IDENT') {
-      this._advance();
-      let node: Expr = { kind: 'Identifier', name: tok.value } satisfies Identifier;
-      // Series index: ident[expr]
-      while (this._check('LBRACKET')) {
-        this._advance();
-        const index = this._expr();
-        this._consume('RBRACKET', "Expected ']'");
-        const indexNode: IndexExpr = { kind: 'IndexExpr', series: node, index };
-        node = indexNode;
-      }
-      return node;
-    }
-
-    // Grouped: '(' expr ')'
-    if (tok.kind === 'LPAREN') {
-      this._advance();
-      const inner = this._expr();
-      this._consume('RPAREN', "Expected ')'");
-      return inner;
-    }
-
-    throw new SyntaxError(
-      `[TScript] Unexpected token '${tok.value}' (${tok.kind}) at ${tok.line}:${tok.col}`,
-    );
-  }
-
-  private _callExpr(): CallExpr {
-    const callee = this._consume('IDENT', 'Expected function name').value;
-    this._consume('LPAREN', "Expected '('");
-    const args: Expr[] = [];
-    if (!this._check('RPAREN')) {
-      args.push(this._expr());
-      while (this._match('COMMA')) {
-        args.push(this._expr());
-      }
-    }
-    this._consume('RPAREN', "Expected ')'");
-    return { kind: 'CallExpr', callee, args };
-  }
-
-  // ─── Utility helpers ────────────────────────────────────────────────────────
-
-  private _binop(
-    op: BinaryExpr['op'],
-    left: Expr,
-    right: Expr,
-  ): BinaryExpr {
-    return { kind: 'BinaryExpr', op, left, right };
-  }
-
-  private _current(): Token {
-    return this._tokens[this._pos]!;
-  }
-
-  private _advance(): Token {
-    return this._tokens[this._pos++]!;
-  }
-
-  private _check(kind: TokenKind): boolean {
-    return this._current().kind === kind;
-  }
-
-  private _checkIdent(name: string): boolean {
-    const t = this._current();
-    return t.kind === 'IDENT' && t.value === name;
-  }
-
-  private _peekKind(offset: number): TokenKind {
-    return this._tokens[this._pos + offset]?.kind ?? 'EOF';
-  }
-
-  private _match(kind: TokenKind): boolean {
-    if (this._check(kind)) { this._advance(); return true; }
-    return false;
-  }
-
-  private _consume(kind: TokenKind, msg: string): Token {
-    if (this._check(kind)) return this._advance();
-    const t = this._current();
-    throw new SyntaxError(`[TScript] ${msg} — got '${t.value}' at ${t.line}:${t.col}`);
-  }
-
-  private _consumeIdent(name: string): Token {
-    if (this._checkIdent(name)) return this._advance();
-    const t = this._current();
-    throw new SyntaxError(`[TScript] Expected '${name}' — got '${t.value}' at ${t.line}:${t.col}`);
-  }
-
-  private _consumeNewlineOrEOF(): void {
-    // Silently accept NEWLINE or EOF; required at end of every statement.
-    if (this._check('NEWLINE') || this._check('EOF')) {
-      if (this._check('NEWLINE')) this._advance();
-    }
-    // If neither, we just continue (expression statements don't need semicolons)
-  }
-
-  private _skipNewlines(): void {
-    while (this._check('NEWLINE')) this._advance();
-  }
-
-  private _collapseNewlines(tokens: Token[]): Token[] {
-    const out: Token[] = [];
-    let lastWasNL = false;
-    for (const t of tokens) {
-      if (t.kind === 'NEWLINE') {
-        if (!lastWasNL) out.push(t);
-        lastWasNL = true;
-      } else {
-        lastWasNL = false;
-        out.push(t);
-      }
-    }
-    return out;
-  }
-
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  private _isStatementBoundary(_t: Token): boolean { return true; }
-}