@forgecharts/sdk 1.1.27 → 1.1.28

package/src/pine/pine-transpiler.ts

@@ -1,301 +0,0 @@
-/**
- * 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

@@ -1,35 +0,0 @@
-/**
- * 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

@@ -1,125 +0,0 @@
-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;
-  }
-}