oakscriptjs 0.11.5 → 0.11.7

package/src/runtime/inputs.ts

@@ -8,6 +8,7 @@
 
 import type { InputConfig, InputOptions } from './types.js';
 import { getContext, recalculate } from './runtime.js';
+import { externalSource } from '../utils/source-resolver.js';
 
 // Track registered inputs for idempotent registration
 const registeredInputs = new Map<string, boolean>();
@@ -403,7 +404,11 @@ function getSourceData(
         const c = ohlcv.close[i];
         return h !== undefined && l !== undefined && c !== undefined ? (o + h + l + c) / 4 : NaN;
       });
-    default:
-      return ohlcv.close;
+    default: {
+      // Another source (study on study), else close.
+      const ext = externalSource(sourceName);
+      if (!ext) return ohlcv.close;
+      return ohlcv.close.map((_, i) => (ext as ArrayLike<number>)[i] ?? NaN);
+    }
   }
 }

package/src/script/index.ts

@@ -78,6 +78,7 @@ import * as taSeries from '../ta-series.js';
 import * as colorCore from '../color/index.js';
 import { inputColorDefault } from '../color/parse.js';
 import { fixnan as fixnanValues, isNA, nz } from '../utils/index.js';
+import { externalSource } from '../utils/source-resolver.js';
 import * as lineCore from '../line/index.js';
 import * as labelCore from '../label/index.js';
 import * as boxCore from '../box/index.js';
@@ -136,6 +137,11 @@ export interface ScriptRunResult {
   barColorConfig: BarColorConfig[];
   /** plotcandle() / plotbar() declarations */
   candleConfig: CandleConfig[];
+  /**
+   * The plot(), plotshape(), plotchar(), plotarrow(), plotcandle() and plotbar() declarations in the order the
+   * script made them (the id of each in its own config). PineScript numbers a script's outputs in this order.
+   */
+  outputs: ScriptOutput[];
   defaultInputs: Record<string, unknown>;
   alertConfig: AlertConditionConfig[];
   /** Strategy properties (declared values, else the PineScript defaults) when the script declares strategy(). */
@@ -143,9 +149,10 @@ export interface ScriptRunResult {
   /**
    * The renderable output: plots keyed by plotConfig ids, plot-pair fills, markers, arrows, background and bar
    * colours, candles and bars, and the drawings (labels, lines, boxes, linefills, polylines, tables) alive after the
-   * last bar.
+   * last bar. `outputValues`: per plotshape() / plotchar() / plotarrow() id, the value of its series on each bar where
+   * it is not na (a condition gives 1 or 0), at the bar it was computed on (the offset not applied).
    */
-  result: IndicatorResult & { alerts?: AlertState[]; alertCalls?: AlertCall[] };
+  result: IndicatorResult & { alerts?: AlertState[]; alertCalls?: AlertCall[]; outputValues?: Record<string, TimeValue[]> };
   /** The script called alert() during the run (PineScript `hasAlertFunction` is known at compile time: a host that
    *  needs it before any bar runs reads the source). */
   hasAlertFunction: boolean;
@@ -177,6 +184,14 @@ export interface AlertCall {
   freq: AlertFrequency;
 }
 
+/** One output declaration of a script: plot(), plotshape() ('shape'), plotchar() ('char'), plotarrow() ('arrow'),
+ *  plotcandle() ('candle') or plotbar() ('bar'), with its id in plotConfig / shapeConfig / arrowConfig / candleConfig. */
+export interface ScriptOutput {
+  kind: 'plot' | 'shape' | 'char' | 'arrow' | 'candle' | 'bar';
+  id: string;
+  title?: string;
+}
+
 /** Handle returned by plot()/hline() so fill() can reference them. */
 export interface PlotHandle {
   id: string;
@@ -201,6 +216,7 @@ interface Collector {
   fillConfig: FillConfig[];
   shapeConfig: ShapeConfig[];
   markers: MarkerData[];
+  outputValues: Record<string, TimeValue[]>;
   arrowConfig: ArrowConfig[];
   arrows: ArrowData[];
   barColorConfig: BarColorConfig[];
@@ -209,6 +225,7 @@ interface Collector {
   candleConfig: CandleConfig[];
   plotCandles: Record<string, PlotCandleData[]>;
   plotBars: Record<string, PlotBarData[]>;
+  outputs: ScriptOutput[];
   alertConfig: AlertConditionConfig[];
   alerts: AlertState[];
   alertCalls: AlertCall[];
@@ -257,6 +274,7 @@ function freshCollector(inputValues: Record<string, unknown>): Collector {
     fillConfig: [],
     shapeConfig: [],
     markers: [],
+    outputValues: {},
     arrowConfig: [],
     arrows: [],
     barColorConfig: [],
@@ -265,6 +283,7 @@ function freshCollector(inputValues: Record<string, unknown>): Collector {
     candleConfig: [],
     plotCandles: {},
     plotBars: {},
+    outputs: [],
     alertConfig: [],
     alerts: [],
     alertCalls: [],
@@ -343,6 +362,7 @@ export function executeScript(
       arrowConfig: c.arrowConfig,
       barColorConfig: c.barColorConfig,
       candleConfig: c.candleConfig,
+      outputs: c.outputs,
       defaultInputs: c.defaultInputs,
       alertConfig: c.alertConfig,
       strategyConfig: c.strategy?.properties,
@@ -351,6 +371,7 @@ export function executeScript(
         plots: c.plots,
         fills: c.fills.length ? c.fills : undefined,
         markers: c.markers.length ? c.markers : undefined,
+        outputValues: Object.keys(c.outputValues).length ? c.outputValues : undefined,
         arrows: c.arrows.length ? c.arrows : undefined,
         bgColors: c.bgColors.length ? c.bgColors : undefined,
         barColors: c.barColors.length ? c.barColors : undefined,
@@ -537,7 +558,13 @@ for (const s of [hl2, hlc3, ohlc4, hlcc4]) s.fullHistory = true;
 const SOURCES: Record<string, Series> = { open, high, low, close, volume, hl2, hlc3, ohlc4, hlcc4 };
 
 function sourceSeries(name: string): Series {
-  return SOURCES[name] ?? close;
+  const builtin = SOURCES[name];
+  if (builtin) return builtin;
+  // Another source (study on study): its values as the host gives them now, aligned with the bars.
+  const ext = externalSource(name);
+  if (!ext) return close;
+  const values = Array.from(ext);
+  return new Series(ctxBars, (_bar, i) => values[i] ?? NaN);
 }
 
 // ── Bound ta namespace ───────────────────────────────────────────────────────
@@ -690,6 +717,7 @@ function plotImpl(series: Series, title?: string, options: ScriptPlotOptions = {
     histbase: options.histbase,
     forceOverlay: options.force_overlay,
   });
+  c.outputs.push({ kind: 'plot', id, title: title ?? id });
   const values = series.toArray();
   const b = bars();
   const data: TimeValue[] = [];
@@ -899,6 +927,18 @@ function markerPosition(location: MarkerLocation, shape: ShapeStyle | undefined)
 /** Default colour of plotshape / plotchar markers. */
 const MARKER_COLOR = '#2962FF';
 
+/** The value of an output's series on each bar where it is not na (a condition: 1 or 0), at the bar it was computed
+ *  on: what PineScript gives for the output in an alert message. */
+function outputSeries(values: ArrayLike<unknown>, b: readonly Bar[]): TimeValue[] {
+  const series: TimeValue[] = [];
+  for (let i = 0; i < b.length; i++) {
+    const v = values[i];
+    if (typeof v === 'number' && Number.isFinite(v)) series.push({ time: b[i]!.time, value: v });
+    else if (typeof v === 'boolean') series.push({ time: b[i]!.time, value: v ? 1 : 0 });
+  }
+  return series;
+}
+
 /** Shared emitter for plotshape()/plotchar(). Emits one marker per bar where
  *  the condition is truthy (not na, not 0). A plotchar marker has the shape 'circle' and its character in `char`. */
 function emitMarkers(
@@ -926,6 +966,7 @@ function emitMarkers(
     offset: options.offset,
     forceOverlay: options.force_overlay,
   });
+  c.outputs.push({ kind, id, title });
   const shapeStyle = kind === 'shape' ? (style as ShapeStyle) : undefined;
   const template: Omit<MarkerData, 'time'> = {
     position: markerPosition(location, shapeStyle),
@@ -942,6 +983,7 @@ function emitMarkers(
   const values = condition.toArray();
   const b = bars();
   const off = options.offset ?? 0;
+  c.outputValues[id] = outputSeries(values, b);
   for (let i = 0; i < b.length; i++) {
     const v = values[i];
     if (v === undefined || Number.isNaN(v) || v === 0) continue;
@@ -1001,9 +1043,11 @@ export function plotarrow(series: Series, title?: string, options: PlotArrowOpti
     display: options.display,
     forceOverlay: options.force_overlay,
   });
+  c.outputs.push({ kind: 'arrow', id, title });
   const values = series.toArray();
   const b = bars();
   const off = options.offset ?? 0;
+  c.outputValues[id] = outputSeries(values, b);
   for (let i = 0; i < b.length; i++) {
     const v = values[i];
     if (v === undefined || Number.isNaN(v) || v === 0) continue;
@@ -1135,6 +1179,7 @@ export function plotcandle(
     display: options.display,
     forceOverlay: options.force_overlay,
   });
+  c.outputs.push({ kind: 'candle', id, title });
   const b = bars();
   c.plotCandles[id] = ohlcRows(open, high, low, close).map(({ i, ...ohlc }) => {
     const candle: PlotCandleData = { time: b[i]!.time, ...ohlc };
@@ -1171,6 +1216,7 @@ export function plotbar(
     display: options.display,
     forceOverlay: options.force_overlay,
   });
+  c.outputs.push({ kind: 'bar', id, title });
   const b = bars();
   c.plotBars[id] = ohlcRows(open, high, low, close).map(({ i, ...ohlc }) => {
     const bar: PlotBarData = { time: b[i]!.time, ...ohlc };

package/src/utils/index.ts

@@ -8,6 +8,7 @@ import { sma, ema, wma, rma } from '../ta/index.js';
 import { Series } from '../runtime/series.js';
 import type { SourceType } from '../input.js';
 import { isDeleted } from '../drawing/registry.js';
+import { externalSource } from './source-resolver.js';
 
 /**
  * Validates that a series has sufficient data for a given length
@@ -197,6 +198,9 @@ export function getSource(
       case 'hlcc4': return ohlc.high.map((h, i) => (h + ohlc.low[i]! + ohlc.close[i]! + ohlc.close[i]!) / 4);
       case 'volume': return ohlc.volume ?? ohlc.close.map(() => NaN);
     }
+    const ext = externalSource(source);
+    if (!ext) return ohlc.close;
+    return ohlc.close.map((_, i) => (ext as ArrayLike<number>)[i] ?? NaN);
   } else {
     const bars = data as Bar[];
     switch (source) {
@@ -210,6 +214,10 @@ export function getSource(
       case 'hlcc4': return bars.map(b => (b.high + b.low + b.close + b.close) / 4);
       case 'volume': return bars.map(b => b.volume ?? NaN);
     }
+    // Another source (study on study), else close.
+    const ext = externalSource(source);
+    if (!ext) return bars.map(b => b.close);
+    return bars.map((_, i) => (ext as ArrayLike<number>)[i] ?? NaN);
   }
 }
 
@@ -248,7 +256,13 @@ export function getSourceSeries(
     case 'ohlc4': return open.add(high).add(low).add(close).div(4);
     case 'hlcc4': return high.add(low).add(close).add(close).div(4);
     case 'volume': return Series.fromBars(bars, 'volume');
-    default: return close;
+    default: {
+      // Another source (study on study), else close.
+      const ext = externalSource(source);
+      if (!ext) return close;
+      const values = Array.from({ length: bars.length }, (_, i) => ext[i] ?? NaN);
+      return new Series(bars, (_bar, i) => values[i] ?? NaN);
+    }
   }
 }
 

package/src/utils/source-resolver.ts

@@ -0,0 +1,29 @@
+/**
+ * Sources other than the bar fields: a study calculated on another study's output (PineScript hosts call it "study
+ * on study"). A source input then holds a host name such as `"<sourceId>$<plotIndex>"`; the host resolves it to
+ * values aligned with the bars it passes to the calculation (`NaN` where there is no value).
+ *
+ * The host sets the resolver around a calculation and clears it after; a name it does not know falls back to
+ * `close`, as before.
+ */
+
+/** Values of a source by name, aligned with the bars of the calculation; null/undefined = unknown name. */
+export type SourceResolver = (name: string) => ArrayLike<number> | null | undefined;
+
+let resolver: SourceResolver | null = null;
+
+/** Built-in sources (bar fields and their averages). */
+export const BUILTIN_SOURCES: ReadonlySet<string> = new Set([
+  'open', 'high', 'low', 'close', 'hl2', 'hlc3', 'ohlc4', 'hlcc4', 'volume',
+]);
+
+/** Set (or clear with null) how source names other than the built-ins are read. */
+export function setSourceResolver(fn: SourceResolver | null): void {
+  resolver = fn;
+}
+
+/** Values of a non built-in source name, or null when no resolver knows it. */
+export function externalSource(name: string): ArrayLike<number> | null {
+  if (!resolver || BUILTIN_SOURCES.has(name)) return null;
+  return resolver(name) ?? null;
+}