oakscriptjs 0.12.2 → 0.13.0

package/dist/cjs/script/index.js

@@ -34,6 +34,7 @@ __export(script_exports, {
   MissingSymbolDataError: () => MissingSymbolDataError,
   STRATEGY_DEFAULTS: () => import_strategy2.STRATEGY_DEFAULTS,
   Series: () => import_series.Series,
+  StrategyRecorder: () => StrategyRecorder,
   alert: () => alert,
   alertcondition: () => alertcondition,
   barcolor: () => barcolor,
@@ -48,6 +49,7 @@ __export(script_exports, {
   dayofmonth: () => dayofmonth,
   dayofweek: () => dayofweek,
   eachBar: () => eachBar,
+  executeIntrabar: () => executeIntrabar,
   executeScript: () => executeScript,
   fill: () => fill,
   fixnan: () => fixnan,
@@ -100,6 +102,7 @@ __export(script_exports, {
   timenow: () => timenow,
   timestamp: () => timestamp,
   varDrawing: () => import_registry2.varDrawing,
+  varip: () => varip,
   volume: () => volume,
   weekofyear: () => weekofyear,
   year: () => year
@@ -187,12 +190,55 @@ function slugId(title, fallback, taken) {
   return id;
 }
 let scriptOptions = {};
+let intrabarRun = null;
+class StrategyRecorder {
+  /** Per bar: the values the engine returned to the strategy.eachBar() callback (strategy.*, trades...), in order. */
+  answers = [];
+  /** Per bar: the `varip` values when the bar's strategy.eachBar() callback started in the main run. */
+  varipStarts = [];
+  /** Current `varip` values: kept through the intrabar runs (no rollback). */
+  varip = [];
+}
+function saveRunState() {
+  return {
+    bars: ctxBars.bars,
+    ctx,
+    chartCtx,
+    runNow,
+    scriptOptions,
+    currentBar,
+    missingSymbols,
+    sessionCache,
+    intrabarRun,
+    varip: varipRun,
+    drawings: (0, import_registry.saveDrawingState)(),
+    random: mathCore.saveRandom()
+  };
+}
+function restoreRunState(st) {
+  ctxBars.setAll(st.bars);
+  ctx = st.ctx;
+  chartCtx = st.chartCtx;
+  runNow = st.runNow;
+  scriptOptions = st.scriptOptions;
+  currentBar = st.currentBar;
+  missingSymbols = st.missingSymbols;
+  sessionCache = st.sessionCache;
+  intrabarRun = st.intrabarRun;
+  varipRun = st.varip;
+  (0, import_registry.restoreDrawingState)(st.drawings);
+  mathCore.restoreRandom(st.random);
+}
 function executeScript(body, barsInput, inputs = {}, chart2 = {}, options = {}) {
+  const outer = ctx ? saveRunState() : null;
   ctxBars.setAll(barsInput);
   chartCtx = { ...chart2 };
   runNow = chart2.now ?? Date.now();
   scriptOptions = options;
   ctx = freshCollector(inputs);
+  intrabarRun = null;
+  varipRun = { slot: 0, recorder: options.recorder ?? null, mode: "live", scratch: null };
+  currentBar = -1;
   (0, import_registry.resetDrawings)();
   mathCore.resetRandom();
   missingSymbols = [];
@@ -240,7 +286,56 @@ function executeScript(body, barsInput, inputs = {}, chart2 = {}, options = {})
     };
   } finally {
     ctx = null;
+    if (outer) restoreRunState(outer);
+  }
+}
+function executeIntrabar(body, bars2, inputs, chart2, options) {
+  const run = {
+    bar: options.bar,
+    lastBarIndex: options.lastBarIndex,
+    engine: options.engine,
+    recorder: options.recorder
+  };
+  executeScript(
+    () => {
+      intrabarRun = run;
+      varipRun = { slot: 0, recorder: options.recorder, mode: "live", scratch: null };
+      body();
+    },
+    bars2,
+    inputs,
+    // History bars are confirmed, also on their ticks (the reference app: a barstate.isconfirmed entry fills on them).
+    { ...chart2, lastBarConfirmed: true, realtime: false },
+    { strategyEngine: () => options.engine }
+  );
+}
+let varipRun = { slot: 0, recorder: null, mode: "live", scratch: null };
+function varip(initial) {
+  collector();
+  const slot = varipRun.slot++;
+  const state = varipRun;
+  const rec = state.recorder;
+  if (!rec) {
+    let current = initial;
+    return {
+      get value() {
+        return current;
+      },
+      set value(v) {
+        current = v;
+      }
+    };
   }
+  if (rec.varip.length <= slot) rec.varip[slot] = initial;
+  const store = () => state.mode === "replay" && state.scratch ? state.scratch : rec.varip;
+  return {
+    get value() {
+      return store()[slot];
+    },
+    set value(v) {
+      store()[slot] = v;
+    }
+  };
 }
 function indicator(title, options = {}) {
   const c = collector();
@@ -418,10 +513,21 @@ const ta = {
   wvad: barsSeries(taSeries.wvad)
 };
 function fixnan(source) {
-  return source instanceof import_series.Series ? import_series.Series.fromArray(ctxBars, (0, import_utils.fixnan)(source.toArray())) : (0, import_utils.fixnan)(source);
+  if (source instanceof import_series.Series) return import_series.Series.fromArray(ctxBars, (0, import_utils.fixnan)(source.toArray()));
+  return withPalette((0, import_utils.fixnan)(source), colorPalettes.get(source));
+}
+const colorPalettes = /* @__PURE__ */ new WeakMap();
+function withPalette(colors, palette) {
+  if (palette?.length) colorPalettes.set(colors, palette);
+  return colors;
+}
+function paletteOfColors(col) {
+  return typeof col === "object" && col !== null ? colorPalettes.get(col) : void 0;
 }
 function colorWhen(cond, colorTrue, colorFalse) {
-  return cond.toArray().map((v) => !(0, import_utils.isNA)(v) && v !== 0 ? colorTrue : colorFalse);
+  const colors = cond.toArray().map((v) => !(0, import_utils.isNA)(v) && v !== 0 ? colorTrue : colorFalse);
+  const palette = [colorTrue, ...colorFalse !== void 0 && colorFalse !== colorTrue ? [colorFalse] : []];
+  return withPalette(colors, palette);
 }
 const color = {
   ...colorCore,
@@ -456,7 +562,8 @@ function plotImpl(series, title = DEFAULT_OUTPUT_TITLES.plot, options = {}) {
     display: options.display,
     histbase: options.histbase,
     forceOverlay: options.force_overlay,
-    ...options.editable === false ? { editable: false } : {}
+    ...options.editable === false ? { editable: false } : {},
+    ...paletteOfColors(perBar2) ? { palette: paletteOfColors(perBar2) } : {}
   });
   c.outputs.push({ kind: "plot", id, title });
   const values = series.toArray();
@@ -524,6 +631,7 @@ function fill(a, b, ...args) {
   let title;
   let gradient;
   let editable;
+  let perBarArg;
   if (typeof third === "number" || third instanceof import_series.Series) {
     const n = ctxBars.bars.length;
     gradient = {
@@ -537,12 +645,14 @@ function fill(a, b, ...args) {
   } else if (third !== null && typeof third === "object" && !Array.isArray(third)) {
     const options = third;
     perBar2 = Array.isArray(options.color) ? options.color : void 0;
+    perBarArg = perBar2;
     staticColor2 = typeof options.color === "string" ? options.color : void 0;
     title = options.title;
     editable = options.editable;
   } else {
     const color2 = third;
     perBar2 = Array.isArray(color2) ? color2.map((x) => x ?? "") : void 0;
+    perBarArg = Array.isArray(color2) ? color2 : void 0;
     staticColor2 = typeof color2 === "string" ? color2 : void 0;
     title = args[1];
     editable = args[2];
@@ -562,7 +672,8 @@ function fill(a, b, ...args) {
     title,
     ...topColor ? { topColor } : {},
     ...bottomColor ? { bottomColor } : {},
-    ...editable === false ? { editable: false } : {}
+    ...editable === false ? { editable: false } : {},
+    ...paletteOfColors(perBarArg) ? { palette: paletteOfColors(perBarArg) } : {}
   });
   if (hlines) return;
   c.fills.push({
@@ -710,8 +821,8 @@ function emitBarColors(kind, colors, options) {
     title: options.title ?? DEFAULT_OUTPUT_TITLES[kind],
     offset: options.offset,
     forceOverlay: options.force_overlay,
-    // a constant colour is a palette of one colour (PineScript)
-    ...typeof colors === "string" ? { palette: [colors] } : {},
+    // a constant colour is a palette of one colour (PineScript); per-bar colours from constants keep theirs
+    ...typeof colors === "string" ? { palette: [colors] } : paletteOfColors(colors) ? { palette: paletteOfColors(colors) } : {},
     ...options.editable === false ? { editable: false } : {},
     outputIndex: c.outputs.length
   });
@@ -751,6 +862,14 @@ function ohlcRows(o, h, l, cl) {
 }
 const staticColor = (col) => typeof col === "string" ? col : void 0;
 const DEFAULT_CANDLE_COLORS = { color: "#2962FF", wickColor: "#737375", borderColor: "#000000" };
+function candlePalettes(cols) {
+  const palettes = {};
+  for (const k of ["color", "wickColor", "borderColor"]) {
+    const pal = paletteOfColors(cols[k]);
+    if (pal) palettes[k] = pal;
+  }
+  return Object.keys(palettes).length ? { palettes } : {};
+}
 const orDefault = (col, fallback) => col === void 0 ? fallback : col;
 function plotcandle(open2, high2, low2, close2, title, options = {}) {
   const c = collector();
@@ -766,6 +885,7 @@ function plotcandle(open2, high2, low2, close2, title, options = {}) {
     color: staticColor(color2),
     wickColor: staticColor(wickcolor),
     borderColor: staticColor(bordercolor),
+    ...candlePalettes({ color: color2, wickColor: wickcolor, borderColor: bordercolor }),
     display: options.display,
     forceOverlay: options.force_overlay,
     ...options.editable === false ? { editable: false } : {}
@@ -794,6 +914,7 @@ function plotbar(open2, high2, low2, close2, title, options = {}) {
     kind: "bar",
     title,
     color: staticColor(barColor),
+    ...candlePalettes({ color: barColor }),
     display: options.display,
     forceOverlay: options.force_overlay,
     ...options.editable === false ? { editable: false } : {}
@@ -813,6 +934,7 @@ const HISTORY_GROWTH = 1.618034;
 function eachBar(fn) {
   collector();
   const b = bars();
+  const lastIndex = intrabarRun ? intrabarRun.lastBarIndex : b.length - 1;
   const out = new Array(b.length).fill(NaN);
   const cache = /* @__PURE__ */ new Map();
   const buffers = /* @__PURE__ */ new Map();
@@ -822,7 +944,7 @@ function eachBar(fn) {
     get i() {
       return idx;
     },
-    n: b.length,
+    n: lastIndex + 1,
     get time() {
       return b[idx].time;
     },
@@ -867,7 +989,7 @@ function eachBar(fn) {
     for (idx = 0; idx < b.length; idx++) {
       if (pendingError && pendingError.bar === idx) throw new Error((0, import_series.historyError)(idx, pendingError.barsBack));
       currentBar = idx;
-      (0, import_registry.setDrawingBar)(idx, idx === b.length - 1, b.length - 1);
+      (0, import_registry.setDrawingBar)(idx, idx === lastIndex, lastIndex);
       const r = fn(ctx2);
       out[idx] = typeof r === "number" ? r : typeof r === "boolean" ? r ? 1 : 0 : NaN;
       for (const buffer of buffers.values()) {
@@ -929,6 +1051,7 @@ function strategyVariable(name) {
   return value;
 }
 function riskRule(rule) {
+  if (intrabarRun) return;
   const engine = strategyEngine(`strategy.risk.${rule.rule}()`);
   if (!engine.risk) throw new Error(`strategy.risk.${rule.rule}() is not provided by the strategy engine.`);
   engine.risk(rule);
@@ -966,17 +1089,95 @@ function strategyEachBar(fn) {
   const engine = strategyEngine("strategy.eachBar()");
   if (run.looped) throw new Error("strategy.eachBar() runs once per script run.");
   run.looped = true;
+  const intrabar = intrabarRun;
+  if (intrabar) {
+    const varipState = varipRun;
+    return eachBar((c) => {
+      const replay = c.i < intrabar.bar;
+      run.engine = replay ? replayEngine(intrabar.recorder.answers[c.i] ?? []) : intrabar.engine;
+      varipState.mode = replay ? "replay" : "live";
+      varipState.scratch = replay ? [...intrabar.recorder.varipStarts[c.i] ?? intrabar.recorder.varip] : null;
+      run.inLoop = true;
+      try {
+        return fn(c);
+      } finally {
+        run.inLoop = false;
+        run.engine = intrabar.engine;
+        varipState.mode = "live";
+        varipState.scratch = null;
+      }
+    });
+  }
+  const recorder = scriptOptions.recorder;
   return eachBar((c) => {
     engine.processBar(c.i);
+    if (recorder) {
+      recorder.varipStarts[c.i] = [...recorder.varip];
+      run.engine = recordingEngine(engine, recorder.answers[c.i] = []);
+    }
     run.inLoop = true;
     try {
       return fn(c);
     } finally {
       run.inLoop = false;
+      run.engine = engine;
       engine.processClose(c.i);
     }
   });
 }
+function recordingEngine(engine, log) {
+  const keep = (v) => {
+    log.push(v);
+    return v;
+  };
+  return {
+    ...forward(engine),
+    get: (name) => keep(engine.get(name)),
+    openTrade: (index) => keep(engine.openTrade(index)),
+    closedTrade: (index) => keep(engine.closedTrade(index)),
+    defaultEntryQty: engine.defaultEntryQty ? (price) => keep(engine.defaultEntryQty(price)) : void 0
+  };
+}
+function replayEngine(log) {
+  let k = 0;
+  const next = () => log[k++];
+  const none = () => {
+  };
+  return {
+    processBar: none,
+    processClose: none,
+    entry: none,
+    order: none,
+    exit: none,
+    close: none,
+    close_all: none,
+    cancel: none,
+    cancel_all: none,
+    risk: none,
+    get: () => next(),
+    openTrade: () => next(),
+    closedTrade: () => next(),
+    defaultEntryQty: () => next()
+  };
+}
+function forward(engine) {
+  return {
+    processBar: (bar) => engine.processBar(bar),
+    processClose: (bar) => engine.processClose(bar),
+    entry: (id, direction, options) => engine.entry(id, direction, options),
+    order: (id, direction, options) => engine.order(id, direction, options),
+    exit: (id, options) => engine.exit(id, options),
+    close: (id, options) => engine.close(id, options),
+    close_all: (options) => engine.close_all(options),
+    cancel: (id) => engine.cancel(id),
+    cancel_all: () => engine.cancel_all(),
+    risk: engine.risk ? (rule) => engine.risk(rule) : void 0,
+    get: (name) => engine.get(name),
+    openTrade: (index) => engine.openTrade(index),
+    closedTrade: (index) => engine.closedTrade(index),
+    defaultEntryQty: engine.defaultEntryQty ? (price) => engine.defaultEntryQty(price) : void 0
+  };
+}
 const strategyMembers = {
   ...import_strategy.STRATEGY_CONSTANTS,
   eachBar: strategyEachBar,
@@ -1288,13 +1489,14 @@ function barFlag(test) {
   const n = ctxBars.bars.length;
   return import_series.Series.fromArray(ctxBars, Array.from({ length: n }, (_, i) => test(i, n) ? 1 : 0));
 }
+const chartBarCount = (n) => intrabarRun ? intrabarRun.lastBarIndex + 1 : n;
 const lastRealtime = (i, n) => i === n - 1 && chartCtx.realtime === true;
 const barstate = {
   get isfirst() {
     return barFlag((i) => i === 0);
   },
   get islast() {
-    return barFlag((i, n) => i === n - 1);
+    return barFlag((i, n) => i === chartBarCount(n) - 1);
   },
   get isconfirmed() {
     return barFlag((i, n) => i < n - 1 || chartCtx.lastBarConfirmed === true);
@@ -1311,7 +1513,8 @@ const barstate = {
   get islastconfirmedhistory() {
     return barFlag((i, n) => {
       const lastConfirmed = chartCtx.lastBarConfirmed === true && chartCtx.realtime !== true;
-      return i === (lastConfirmed ? n - 1 : n - 2);
+      const count = chartBarCount(n);
+      return i === (lastConfirmed ? count - 1 : count - 2);
     });
   }
 };
@@ -1600,8 +1803,11 @@ const alert = Object.assign(alertImpl, {
   freq_once_per_bar: "once_per_bar",
   freq_once_per_bar_close: "once_per_bar_close"
 });
+const { saveRandom: _saveRandom, restoreRandom: _restoreRandom, ...mathScript } = mathCore;
+void _saveRandom;
+void _restoreRandom;
 const math = {
-  ...mathCore,
+  ...mathScript,
   round_to_mintick: ((number, mintick) => {
     const tick = mintick ?? syminfo.mintick;
     return number instanceof import_series.Series ? mathCore.round_to_mintick(number, tick) : mathCore.round_to_mintick(number, tick);