@forgecharts/sdk 1.1.23

package/src/pine/pine-transpiler.ts

@@ -0,0 +1,301 @@
+/**
+ * Pine Script → TScript transpiler.
+ *
+ * Walks a `PineProgram` AST and emits a TScript source string that is
+ * directly executable by the existing `TScriptRuntime`.
+ */
+
+import type {
+  PineProgram, PineStmt, PineExpr,
+  PineIndicatorDecl, PineVarDecl, PineAssign, PineExprStmt, PineIf,
+  PineNumberLit, PineStringLit, PineBoolLit, PineNa,
+  PineIdent, PineNsCall, PineCall, PineIndex,
+  PineBinary, PineUnary, PineTernary, PineMember,
+} from './pine-ast';
+import { DiagnosticBag } from './diagnostics';
+
+// ─── Namespace → TScript function mappings ───────────────────────────────────
+
+const TA_MAP: Record<string, string> = {
+  sma:        'sma',
+  ema:        'ema',
+  rsi:        'rsi',
+  wma:        'wma',
+  rma:        'rma',
+  stdev:      'stdev',
+  highest:    'highest',
+  lowest:     'lowest',
+  change:     'change',
+  mom:        'mom',
+  atr:        'atr',
+  crossover:  'crossover',
+  crossunder: 'crossunder',
+  barssince:  'barssince',
+};
+
+const MATH_MAP: Record<string, string> = {
+  abs:   'abs',
+  max:   'max',
+  min:   'min',
+  round: 'round',
+  floor: 'floor',
+  ceil:  'ceil',
+  sqrt:  'sqrt',
+  log:   'log',
+  pow:   'pow',
+  sign:  'sign',
+  exp:   'exp',
+};
+
+const COLOR_MAP: Record<string, string> = {
+  red:    '"#f23645"',
+  green:  '"#26a69a"',
+  blue:   '"#2196f3"',
+  white:  '"#ffffff"',
+  black:  '"#000000"',
+  yellow: '"#ffeb3b"',
+  orange: '"#ff9800"',
+  purple: '"#9c27b0"',
+  aqua:   '"#00bcd4"',
+  gray:   '"#787b86"',
+  silver: '"#b2b5be"',
+  lime:   '"#4caf50"',
+  maroon: '"#880000"',
+  navy:   '"#000080"',
+  olive:  '"#808000"',
+  teal:   '"#008080"',
+  fuchsia:'"#ff00ff"',
+};
+
+/** Functions that produce no useful TScript equivalent — emit a warning. */
+const UNSUPPORTED_FN = new Set([
+  'plotshape', 'plotarrow', 'plotbar', 'plotcandle',
+  'barcolor', 'bgcolor', 'alertcondition', 'alert',
+  'strategy', 'label', 'line', 'box', 'table',
+  'request',
+]);
+
+export class PineTranspiler {
+  private _diag: DiagnosticBag;
+  private _indent = 0;
+  private _out: string[] = [];
+
+  constructor(diag: DiagnosticBag) {
+    this._diag = diag;
+  }
+
+  transpile(prog: PineProgram): string {
+    this._out   = [];
+    this._indent = 0;
+    for (const stmt of prog.stmts) {
+      this._stmt(stmt);
+    }
+    return this._out.join('');
+  }
+
+  // ─── Statements ─────────────────────────────────────────────────────────────
+
+  private _stmt(s: PineStmt): void {
+    switch (s.kind) {
+      case 'PineIndicatorDecl':  return this._indicatorDecl(s);
+      case 'PineVarDecl':        return this._varDecl(s);
+      case 'PineAssign':         return this._assign(s);
+      case 'PineExprStmt':       return this._exprStmt(s);
+      case 'PineIf':             return this._ifStmt(s);
+    }
+  }
+
+  private _indicatorDecl(s: PineIndicatorDecl): void {
+    // indicator("Title", overlay=true) → indicator("Title")
+    const title = s.args[0];
+    const titleStr = title ? this._expr(title) : '"Script"';
+    this._line(`indicator(${titleStr})`);
+  }
+
+  private _varDecl(s: PineVarDecl): void {
+    // var x = expr  →  x = expr  (TScript vars persist by default)
+    this._line(`${s.name} = ${this._expr(s.value)}`);
+  }
+
+  private _assign(s: PineAssign): void {
+    // := and = both map to = in TScript
+    this._line(`${s.name} = ${this._expr(s.value)}`);
+  }
+
+  private _exprStmt(s: PineExprStmt): void {
+    const expr = s.expr;
+    // Check for unsupported top-level calls before emitting
+    if (
+      (expr.kind === 'PineCall' || expr.kind === 'PineNsCall') &&
+      UNSUPPORTED_FN.has(expr.kind === 'PineCall' ? expr.fn : expr.fn)
+    ) {
+      const name = expr.kind === 'PineCall' ? expr.fn : `${expr.namespace}.${expr.fn}`;
+      this._diag.add('warning', `'${name}()' is not supported and will be ignored`, s.loc, 'PINE_UNSUPPORTED_FN');
+      this._line(`// ${name}() not supported`);
+      return;
+    }
+    this._line(this._expr(expr));
+  }
+
+  private _ifStmt(s: PineIf): void {
+    this._line(`if ${this._expr(s.condition)}`);
+    this._indent++;
+    for (const st of s.then) this._stmt(st);
+    if (s.then.length === 0) this._line('0'); // empty block guard
+    this._indent--;
+    if (s.else_.length > 0) {
+      this._line('else');
+      this._indent++;
+      for (const st of s.else_) this._stmt(st);
+      this._indent--;
+    }
+  }
+
+  // ─── Expressions ────────────────────────────────────────────────────────────
+
+  private _expr(e: PineExpr): string {
+    switch (e.kind) {
+      case 'PineNumberLit': return this._numLit(e);
+      case 'PineStringLit': return `"${e.value.replace(/\\/g,'\\\\').replace(/"/g,'\\"')}"`;
+      case 'PineBoolLit':   return e.value ? 'true' : 'false';
+      case 'PineNa':        return 'na';
+      case 'PineIdent':     return e.name;
+      case 'PineNsCall':    return this._nsCall(e);
+      case 'PineCall':      return this._call(e);
+      case 'PineIndex':     return `${this._expr(e.series)}[${this._expr(e.index)}]`;
+      case 'PineBinary':    return this._binary(e);
+      case 'PineUnary':     return this._unary(e);
+      case 'PineTernary':   return `${this._expr(e.condition)} ? ${this._expr(e.consequent)} : ${this._expr(e.alternate)}`;
+      case 'PineMember':    return this._member(e);
+      // PineColorLit is resolved via PineMember for color.red etc
+      default:              return '0';
+    }
+  }
+
+  private _numLit(e: PineNumberLit): string {
+    // Preserve integer formatting when possible
+    return Number.isInteger(e.value) ? String(e.value) : String(e.value);
+  }
+
+  private _nsCall(e: PineNsCall): string {
+    const { namespace: ns, fn } = e;
+
+    if (ns === 'ta') {
+      const mapped = TA_MAP[fn];
+      if (mapped) {
+        const args = this._positionalArgs(e.args);
+        return `${mapped}(${args})`;
+      }
+      this._diag.add('warning', `'ta.${fn}()' is not supported`, e.loc, 'PINE_UNSUPPORTED_FN');
+      return `/* ta.${fn} not supported */ 0`;
+    }
+
+    if (ns === 'math') {
+      const mapped = MATH_MAP[fn];
+      if (mapped) {
+        const args = this._positionalArgs(e.args);
+        return `${mapped}(${args})`;
+      }
+      this._diag.add('warning', `'math.${fn}()' is not supported`, e.loc, 'PINE_UNSUPPORTED_FN');
+      return `/* math.${fn} not supported */ 0`;
+    }
+
+    if (ns === 'input') {
+      return this._inputNsCall(e);
+    }
+
+    if (ns === 'strategy' || ns === 'label' || ns === 'line' || ns === 'box' || ns === 'table' || ns === 'request') {
+      this._diag.add('warning', `'${ns}.${fn}()' is not supported`, e.loc, 'PINE_UNSUPPORTED_FN');
+      return `/* ${ns}.${fn} not supported */ 0`;
+    }
+
+    // Generic fallthrough
+    this._diag.add('warning', `'${ns}.${fn}()' is not supported`, e.loc, 'PINE_UNSUPPORTED_FN');
+    return `/* ${ns}.${fn} not supported */ 0`;
+  }
+
+  private _inputNsCall(e: PineNsCall): string {
+    // input.int(v, ...) / input.float(v, ...) / input.bool(v, ...) → input(v)
+    // input.source(close) → the source arg value
+    if (e.fn === 'source') {
+      return e.args[0] ? this._expr(e.args[0]) : 'close';
+    }
+    const defVal = e.args[0] ?? e.namedArgs.get('defval');
+    return defVal ? `input(${this._expr(defVal)})` : 'input(0)';
+  }
+
+  private _call(e: PineCall): string {
+    if (UNSUPPORTED_FN.has(e.fn)) {
+      this._diag.add('warning', `'${e.fn}()' is not supported and will be ignored`, e.loc, 'PINE_UNSUPPORTED_FN');
+      return `/* ${e.fn} not supported */ 0`;
+    }
+
+    if (e.fn === 'input') {
+      const defVal = e.args[0] ?? e.namedArgs.get('defval');
+      return defVal ? `input(${this._expr(defVal)})` : 'input(0)';
+    }
+
+    if (e.fn === 'plot') {
+      return this._plotCall(e);
+    }
+
+    if (e.fn === 'indicator') {
+      const title = e.args[0];
+      const titleStr = title ? this._expr(title) : '"Script"';
+      return `indicator(${titleStr})`;
+    }
+
+    // Generic call — drop unsupported named args, keep positional
+    const args = this._positionalArgs(e.args);
+    return `${e.fn}(${args})`;
+  }
+
+  private _plotCall(e: PineCall): string {
+    // plot(series, title="...", color=..., linewidth=...) → plot(series)
+    // We only pass the first positional arg; named args are cosmetic only
+    const series = e.args[0];
+    if (!series) return '/* plot() missing series */';
+    return `plot(${this._expr(series)})`;
+  }
+
+  private _member(e: PineMember): string {
+    if (e.object === 'color') {
+      const hex = COLOR_MAP[e.prop];
+      if (hex) return hex;
+      this._diag.add('info', `'color.${e.prop}' is not a known color`, e.loc, 'PINE_UNKNOWN_COLOR');
+      return '"#888888"';
+    }
+    if (e.object === 'line' || e.object === 'label' || e.object === 'box') {
+      // style constants — just return as string
+      return `"${e.prop}"`;
+    }
+    // bar_index, time, etc. are plain idents
+    if (e.object === 'timeframe' || e.object === 'syminfo' || e.object === 'session') {
+      this._diag.add('info', `'${e.object}.${e.prop}' is not supported`, e.loc, 'PINE_UNSUPPORTED_FN');
+      return '0';
+    }
+    return `${e.object}_${e.prop}`; // fallback
+  }
+
+  private _binary(e: PineBinary): string {
+    const l = this._expr(e.left);
+    const r = this._expr(e.right);
+    return `(${l} ${e.op} ${r})`;
+  }
+
+  private _unary(e: PineUnary): string {
+    if (e.op === 'not') return `not ${this._expr(e.operand)}`;
+    return `${e.op}${this._expr(e.operand)}`;
+  }
+
+  private _positionalArgs(args: PineExpr[]): string {
+    return args.map(a => this._expr(a)).join(', ');
+  }
+
+  // ─── Output helpers ─────────────────────────────────────────────────────────
+
+  private _line(code: string): void {
+    const pad = '  '.repeat(this._indent);
+    this._out.push(`${pad}${code}\n`);
+  }
+}

package/src/pixi/LayerName.ts

@@ -0,0 +1,35 @@
+/**
+ * LayerName — ordered Z-index identifiers for the seven render layers.
+ *
+ * Layers are sorted ascending: lowest = farthest back, highest = topmost.
+ * The numeric values are used directly as PixiJS Container `zIndex` values.
+ */
+export const enum LayerName {
+  Background   = 0,
+  PriceSeries  = 1,
+  Indicator    = 2,
+  Drawing      = 3,
+  TradingOverlay = 4,
+  Interaction  = 5,
+  UIOverlay    = 6,
+}
+
+export const LAYER_NAMES = [
+  LayerName.Background,
+  LayerName.PriceSeries,
+  LayerName.Indicator,
+  LayerName.Drawing,
+  LayerName.TradingOverlay,
+  LayerName.Interaction,
+  LayerName.UIOverlay,
+] as const;
+
+export const LAYER_LABEL: Record<LayerName, string> = {
+  [LayerName.Background]:     'background',
+  [LayerName.PriceSeries]:    'priceSeries',
+  [LayerName.Indicator]:      'indicator',
+  [LayerName.Drawing]:        'drawing',
+  [LayerName.TradingOverlay]: 'tradingOverlay',
+  [LayerName.Interaction]:    'interaction',
+  [LayerName.UIOverlay]:      'uiOverlay',
+};

package/src/pixi/PixiCandlestickRenderer.ts

@@ -0,0 +1,125 @@
+import { Graphics } from 'pixi.js';
+import type { Container } from 'pixi.js';
+import type { OHLCV } from '@forgecharts/types';
+import type { CoordTransform } from '../core/CoordTransform';
+
+const UP_COLOR   = 0x26a641; // green
+const DOWN_COLOR = 0xf85149; // red
+const MIN_BODY_H = 1;
+const MAX_BAR_W  = 20;
+const MIN_BAR_W  = 1;
+
+/**
+ * PixiCandlestickRenderer — renders OHLCV data as GPU-batched candlesticks.
+ *
+ * Uses a single re-used `Graphics` object that is fully cleared and redrawn
+ * on each invalidation, taking advantage of PixiJS's WebGL batching for
+ * high-performance rendering of large datasets.
+ */
+export class PixiCandlestickRenderer {
+  private readonly _gfx: Graphics;
+
+  constructor(
+    layer: Container,
+    private readonly _upColor: number = UP_COLOR,
+    private readonly _downColor: number = DOWN_COLOR,
+  ) {
+    this._gfx = new Graphics();
+    layer.addChild(this._gfx);
+  }
+
+  draw(
+    bars: readonly OHLCV[],
+    transform: CoordTransform,
+  ): void {
+    const gfx = this._gfx;
+    gfx.clear();
+
+    if (bars.length === 0) return;
+
+    const { plotWidth: pw, plotHeight: ph } = transform;
+    const { from, to } = transform.timeRange;
+
+    // Infer candle interval from median gap between consecutive bars (seconds)
+    let candleInterval = 0;
+    if (bars.length >= 2) {
+      const deltas: number[] = [];
+      for (let i = 1; i < Math.min(bars.length, 20); i++) {
+        const d = bars[i]!.time - bars[i - 1]!.time;
+        if (d > 0) deltas.push(d);
+      }
+      if (deltas.length > 0) {
+        deltas.sort((a, b) => a - b);
+        candleInterval = deltas[Math.floor(deltas.length / 2)]!;
+      }
+    }
+    const visibleSpan = to - from;
+    const pps = visibleSpan > 0 ? pw / visibleSpan : 1;
+    const barPitch = candleInterval > 0
+      ? candleInterval * pps
+      : pw / Math.max(1, bars.length);
+
+    const gap = Math.max(1, Math.round(barPitch * 0.15));
+    const barW = Math.min(MAX_BAR_W, Math.max(MIN_BAR_W, Math.floor(barPitch) - gap));
+    const halfW = Math.max(0.5, barW / 2);
+
+    for (const bar of bars) {
+      const x = transform.timeToX(bar.time);
+
+      // Skip entirely off-screen bars
+      if (x < -barW || x > pw + barW) continue;
+
+      const yOpen  = transform.priceToY(bar.open);
+      const yClose = transform.priceToY(bar.close);
+      const yHigh  = transform.priceToY(bar.high);
+      const yLow   = transform.priceToY(bar.low);
+
+      const bullish  = bar.close >= bar.open;
+      const color    = bullish ? this._upColor : this._downColor;
+      const bodyTop  = Math.min(yOpen, yClose);
+      const bodyH    = Math.max(MIN_BODY_H, Math.abs(yClose - yOpen));
+
+      // Clip to plot area
+      if (bodyTop > ph || bodyTop + bodyH < 0) continue;
+
+      // Wick
+      gfx
+        .moveTo(x, yHigh)
+        .lineTo(x, bodyTop)
+        .moveTo(x, bodyTop + bodyH)
+        .lineTo(x, yLow)
+        .stroke({ color, width: 1 });
+
+      // Body
+      gfx
+        .rect(x - halfW, bodyTop, barW, bodyH)
+        .fill({ color });
+    }
+  }
+
+  /**
+   * Converts OHLCV bars to Heikin-Ashi values before drawing.
+   */
+  drawHeikinAshi(bars: readonly OHLCV[], transform: CoordTransform): void {
+    this.draw(this._toHeikinAshi(bars), transform);
+  }
+
+  private _toHeikinAshi(bars: readonly OHLCV[]): OHLCV[] {
+    const result: OHLCV[] = [];
+    for (let i = 0; i < bars.length; i++) {
+      const bar  = bars[i]!;
+      const prev = result[i - 1] ?? bar;
+      const haClose = (bar.open + bar.high + bar.low + bar.close) / 4;
+      const haOpen  = (prev.open + prev.close) / 2;
+      result.push({
+        time:   bar.time,
+        open:   haOpen,
+        high:   Math.max(bar.high, haOpen, haClose),
+        low:    Math.min(bar.low,  haOpen, haClose),
+        close:  haClose,
+        volume: bar.volume,
+      });
+    }
+    return result;
+  }
+}