oakscriptjs 0.10.0 → 0.11.0

package/src/drawing/registry.ts

@@ -8,6 +8,41 @@
  * - when a creation brings the count above `max_*_count + 5`, the oldest objects are deleted until
  *   `max_*_count` remain (default 50). Copies count as creations. Linefills follow the same rule with
  *   `max_lines_count`; lines deleted by this rule do not delete their linefills
+ * - the object that was just created is never deleted by this rule
+ * - an object that a `var` variable of the drawing type refers to is never deleted by this rule, and it still counts
+ *   (measured for lines, labels and boxes: with 9 held boxes and a maximum of 50, 9 held + 46 others stay; with 8
+ *   held lines and a maximum of 5, the 8 and the newest line stay). The protection starts on the bar after the
+ *   assignment: 12 `var` lines created on the first bar with a maximum of 5 lose the first 6. Only
+ *   the variable itself protects: an object in a `var` array, in a field of a user type or in a variable that got
+ *   another object or `na` later is deleted like any other. JavaScript has no `var` declaration to observe, so the
+ *   script says it: {@link varDrawing} (a variable), or {@link holdDrawing} / {@link releaseDrawing}
+ * - linefills have the limit of `max_lines_count` with another rule for the held ones (measured on one script, two
+ *   long runs): a fill is skipped when a `var` variable holds it or released it less than 5,000 bars ago (the bar
+ *   of {@link setDrawingBar}); when the count is still above the maximum + 5 after that, the oldest fills are
+ *   deleted until the maximum remain, the held ones too
+ * - the script deletes count (`line.delete`, `label.delete`, ...): each kind has a number `P` of deleted objects. A
+ *   delete adds 1; a creation first sets `P` to 0 when it is 5 or more (3 or more for polylines)
+ * - polylines use `P` on every bar: a creation cuts when the count is above `max_polylines_count + 5 + P`, down to
+ *   the maximum + `P`, and the polylines of the cut are added to `P`. A script that deletes and creates one polyline
+ *   per bar therefore sees the cut 0, 1 or 2 bars late
+ * - lines, labels and boxes use `P` on the last bar only, with its value at the start of that bar: there the cut is
+ *   above the maximum + 5 + `P`, down to the maximum + `P` (up to 4 more objects)
+ * - the last bar has rules of its own (measured from the count after each creation, on a closed and on an open last
+ *   bar): a cut deletes the objects of the bars before first, at most those (a line takes its linefills with it);
+ *   once none is left, a cut deletes objects of the last bar as on any bar. With 10 lines and a maximum of 10, 13
+ *   lines on the last bar leave these 13: the cut at the 16th line deletes the 10 old ones only. Lines, labels and
+ *   boxes: equal to PineScript, count after every operation and objects alive at the end, on 72 of 72 runs checked
+ *   after the rule was written (and 218 of 218 end states before)
+ * - polylines on the last bar: the `P` carried from the bar before is counted twice (the first creation adds it once
+ *   more, unless it sets `P` to 0), later creations do not set `P` to 0, and the polylines of the bars before that a
+ *   cut deletes are added to `P`. Once none is
+ *   left, a cut deletes polylines of the last bar and `P` becomes the number of polylines of the bars before deleted
+ *   on the last bar (by the count or by the script). Equal to PineScript for the polylines alive at the end on 271 of
+ *   281 probe runs; the count inside the bar can differ when the script deletes polylines of the last bar
+ *
+ * - a bar index (`xloc.bar_index`) more than 10,000 bars before the current bar stops the script (runtime error
+ *   RE10026) in `line.new`, `box.new`, `label.new`, `polyline.new` and the setters of x. The current bar is the one
+ *   of `eachBar` in a script run; a port with its own bar loop gives it with {@link setDrawingBar}
  *
  * The script API (`executeScript`) resets the registry at the start of every run and applies the
  * `max_*_count` values of `indicator()`. Outside a script run the registry is global to the module.
@@ -50,6 +85,150 @@ let limits: Required<DrawingLimits> = {
   polyline: DEFAULT_MAX_COUNT,
 };
 const deleted = new WeakSet<object>();
+/** Objects held by a `var` variable, with the number of variables that hold them. */
+let held = new WeakMap<object, number>();
+/** Bar on which the last `var` variable released an object (linefill rule). */
+let releasedAt = new WeakMap<object, number>();
+/** Bars during which a released linefill is still skipped by the maximum count. */
+const LINEFILL_RELEASE_BARS = 5000;
+/** Bar on which a `var` variable got an object: the maximum count skips it from the next bar on. */
+let heldAt = new WeakMap<object, number>();
+/** Kinds with a maximum count of their own. */
+type CountedKind = 'line' | 'label' | 'box' | 'polyline';
+const COUNTED_KINDS: readonly CountedKind[] = ['line', 'label', 'box', 'polyline'];
+const isCounted = (kind: DrawingKind): kind is CountedKind => (COUNTED_KINDS as readonly DrawingKind[]).includes(kind);
+/** `P` of the module notes: objects deleted by the script (for polylines also by the maximum count). */
+let pending: Record<CountedKind, number> = { line: 0, label: 0, box: 0, polyline: 0 };
+/** A creation sets `P` to 0 from this value on. */
+const PENDING_RESET: Record<CountedKind, number> = { line: 5, label: 5, box: 5, polyline: 3 };
+
+/**
+ * Marks an object as held by a `var` variable (PineScript `var line l = ...` or `l := line.new(...)` on a `var`
+ * variable): the maximum count never deletes it, and it still counts. Returns the object.
+ */
+export function holdDrawing<T extends object>(obj: T): T {
+  if (!held.has(obj)) {
+    if (currentBar === null) heldAt.delete(obj);
+    else heldAt.set(obj, currentBar);
+  }
+  held.set(obj, (held.get(obj) ?? 0) + 1);
+  return obj;
+}
+
+/** The `var` variable no longer refers to the object (it got another object or `na`). */
+export function releaseDrawing(obj: object | null | undefined): void {
+  if (!obj) return;
+  const count = held.get(obj) ?? 0;
+  if (count > 1) held.set(obj, count - 1);
+  else if (held.delete(obj) && currentBar !== null) releasedAt.set(obj, currentBar);
+}
+
+/** Held by a `var` variable since a bar before the current one (or outside a bar loop). */
+function heldBefore(obj: object): boolean {
+  if (!held.has(obj)) return false;
+  const bar = heldAt.get(obj);
+  return bar === undefined || currentBar === null || bar < currentBar;
+}
+
+/** Linefill rule: held, or released less than 5,000 bars ago. */
+function fillProtected(obj: object): boolean {
+  if (held.has(obj)) return true;
+  const bar = releasedAt.get(obj);
+  return bar !== undefined && currentBar !== null && currentBar - bar < LINEFILL_RELEASE_BARS;
+}
+
+/** A `var` variable of a drawing type: see {@link varDrawing}. */
+export interface DrawingVariable<T extends object> {
+  /** The object of the variable; setting it holds the new object and releases the one before */
+  value: T | undefined;
+}
+
+/**
+ * A PineScript `var` variable of a drawing type (`var line l = na`). The object it refers to is not deleted by the
+ * maximum count; assigning another object (or `undefined` for `na`) releases the one before.
+ *
+ * @example
+ * ```typescript
+ * // Pine:  var line level = na
+ * //        level := line.new(bar_index, close, bar_index + 1, close)
+ * const level = varDrawing<Line>();
+ * level.value = line.new(i, close, i + 1, close);
+ * ```
+ */
+export function varDrawing<T extends object>(initial?: T): DrawingVariable<T> {
+  let current: T | undefined = initial ? holdDrawing(initial) : undefined;
+  return {
+    get value() {
+      return current;
+    },
+    set value(next: T | undefined) {
+      if (next === current) return;
+      releaseDrawing(current);
+      current = next ? holdDrawing(next) : undefined;
+    },
+  };
+}
+
+/** Largest distance, in bars, of a bar index before the current bar (PineScript runtime error RE10026 above it). */
+export const MAX_DRAWING_BARS_BACK = 10000;
+let currentBar: number | null = null;
+
+/** Kinds whose allowance on the last bar is the `P` they had when the bar started. */
+type AllowanceKind = 'line' | 'label' | 'box';
+const isAllowanceKind = (kind: DrawingKind): kind is AllowanceKind => kind === 'line' || kind === 'label' || kind === 'box';
+
+/** State of the last bar (see the module notes). */
+interface LastBar {
+  bar: number;
+  /** The objects alive when the bar started (the objects of the bars before) */
+  old: Set<object>;
+  /** `P` of lines, labels and boxes when the bar started: their allowance for the whole bar */
+  allowance: Record<AllowanceKind, number>;
+  /** `P` of polylines when the bar started */
+  carried: number;
+  /** A polyline was created on this bar */
+  polyline: boolean;
+  /** Polylines of the bars before deleted on this bar (by the count or by the script) */
+  oldPolylinesGone: number;
+}
+let lastBar: LastBar | null = null;
+
+/**
+ * Tells the drawing functions which bar is being calculated (`bar_index`), so that a bar index more than 10,000
+ * bars back throws as in PineScript; `null` turns the check off. `eachBar` of the script API calls it.
+ *
+ * The bar also dates the objects held by a `var` variable (protected from the next bar on). `last` says that it is
+ * the last bar of the data, which has rules of its own for the maximum count.
+ */
+export function setDrawingBar(barIndex: number | null, last: boolean = false): void {
+  if (lastBar && !(last && barIndex === lastBar.bar)) lastBar = null;
+  currentBar = barIndex;
+  if (barIndex !== null && last && !lastBar) {
+    const start = (kind: AllowanceKind): number => (pending[kind] >= PENDING_RESET[kind] ? 0 : pending[kind]);
+    lastBar = {
+      bar: barIndex,
+      old: new Set<object>([...live.line, ...live.label, ...live.box, ...live.polyline]),
+      allowance: { line: start('line'), label: start('label'), box: start('box') },
+      carried: pending.polyline,
+      polyline: false,
+      oldPolylinesGone: 0,
+    };
+  }
+}
+
+/**
+ * Throws the PineScript runtime error RE10026 when `x` is a bar index more than 10,000 bars before the current bar.
+ * `method` and `variable` are the names of the PineScript message ("line.new", "x1").
+ */
+export function checkBarIndex(method: string, variable: string, x: number, xloc: string | undefined): void {
+  if (currentBar === null || (xloc ?? 'bar_index') !== 'bar_index') return;
+  if (currentBar - x > MAX_DRAWING_BARS_BACK) {
+    throw new Error(
+      `Error on bar ${currentBar}: Bar index value of the \`${variable}\` argument (${x}) in \`${method}()\` is too far ` +
+        'from the current bar index. Try using `time` instead.'
+    );
+  }
+}
 
 /** Numeric fields that become NaN when an object is deleted, so that its getters return `na`. */
 const COORDINATES: { [K in DrawingKind]: Array<keyof DrawingTypes[K]> } = {
@@ -69,14 +248,75 @@ function markDeleted<K extends DrawingKind>(kind: K, obj: DrawingTypes[K], expli
   }
 }
 
+/** Objects above the maximum that the rule allows for, besides the 5: `P` of the module notes. */
+function allowance(kind: DrawingKind): number {
+  if (kind === 'polyline') return pending.polyline;
+  return lastBar && isAllowanceKind(kind) ? lastBar.allowance[kind] : 0;
+}
+
+/**
+ * The maximum count after the creation of `obj`: removes the objects to delete from `list` (the oldest first; the new
+ * object and an object held by a `var` variable are skipped and still count) and returns them.
+ */
+function cutOldest<K extends DrawingKind>(
+  kind: K,
+  list: Array<DrawingTypes[K]>,
+  obj: DrawingTypes[K],
+  only?: (old: object) => boolean
+): Array<DrawingTypes[K]> {
+  if (kind === 'table') return []; // tables have no maximum count
+  const max = limits[kind === 'linefill' ? 'line' : (kind as keyof DrawingLimits)] + allowance(kind);
+  if (list.length <= max + SLACK) return [];
+  const kept: Array<DrawingTypes[K]> = [];
+  const cut: Array<DrawingTypes[K]> = [];
+  let excess = list.length - max;
+  for (const old of list) {
+    if (excess > 0 && old !== obj && (!only || only(old)) && !(kind === 'linefill' ? fillProtected(old) : heldBefore(old))) {
+      excess--;
+      cut.push(old);
+    } else kept.push(old);
+  }
+  // linefills: still above the maximum + 5, the oldest go, the held ones too
+  if (kind === 'linefill' && kept.length > max + SLACK) cut.push(...kept.splice(0, kept.length - max));
+  list.length = 0;
+  list.push(...kept);
+  return cut;
+}
+
 /** Records a new object and deletes the oldest objects of its kind when the count is too high. */
 export function register<K extends DrawingKind>(kind: K, obj: DrawingTypes[K]): DrawingTypes[K] {
+  const list = live[kind];
+  if (lastBar && isCounted(kind)) return registerLast(lastBar, kind, obj);
+  if (isCounted(kind) && pending[kind] >= PENDING_RESET[kind]) pending[kind] = 0;
+  list.push(obj);
+  const cut = cutOldest(kind, list, obj);
+  if (kind === 'polyline') pending.polyline += cut.length;
+  for (const old of cut) markDeleted(kind, old, false);
+  return obj;
+}
+
+/** An object created on the last bar (see the module notes). */
+function registerLast<K extends DrawingKind>(bar: LastBar, kind: K, obj: DrawingTypes[K]): DrawingTypes[K] {
+  if (kind === 'polyline' && !bar.polyline) {
+    bar.polyline = true;
+    if (pending.polyline >= PENDING_RESET.polyline) pending.polyline = 0;
+    else pending.polyline += bar.carried; // counted twice
+  }
   const list = live[kind];
   list.push(obj);
-  if (kind === 'table') return obj; // tables have no maximum count
-  const max = limits[kind === 'linefill' ? 'line' : (kind as keyof DrawingLimits)];
-  if (list.length > max + SLACK) {
-    for (const old of list.splice(0, list.length - max)) markDeleted(kind, old, false);
+  const isOld = (old: object): boolean => bar.old.has(old);
+  if (list.some((old) => old !== obj && isOld(old) && !heldBefore(old))) {
+    // the objects of the bars before only; a line takes its linefills with it
+    const cut = cutOldest(kind, list, obj, isOld);
+    if (kind === 'polyline') {
+      pending.polyline += cut.length;
+      bar.oldPolylinesGone += cut.length;
+    }
+    for (const old of cut) markDeleted(kind, old, true);
+  } else {
+    const cut = cutOldest(kind, list, obj);
+    if (kind === 'polyline' && cut.length > 0) pending.polyline = bar.oldPolylinesGone;
+    for (const old of cut) markDeleted(kind, old, false);
   }
   return obj;
 }
@@ -85,7 +325,11 @@ export function register<K extends DrawingKind>(kind: K, obj: DrawingTypes[K]):
 export function remove<K extends DrawingKind>(kind: K, obj: DrawingTypes[K]): void {
   const list = live[kind];
   const index = list.indexOf(obj);
-  if (index !== -1) list.splice(index, 1);
+  if (index !== -1) {
+    list.splice(index, 1);
+    if (isCounted(kind)) pending[kind]++;
+    if (kind === 'polyline' && lastBar?.old.has(obj)) lastBar.oldPolylinesGone++;
+  }
   if (!deleted.has(obj)) markDeleted(kind, obj, true);
 }
 
@@ -102,6 +346,12 @@ export function all<K extends DrawingKind>(kind: K): Array<DrawingTypes[K]> {
 /** Forgets all objects (without deleting them) and sets the maximum counts (default 50). */
 export function resetDrawings(newLimits: DrawingLimits = {}): void {
   for (const kind of Object.keys(live) as DrawingKind[]) live[kind].length = 0;
+  held = new WeakMap();
+  releasedAt = new WeakMap();
+  heldAt = new WeakMap();
+  pending = { line: 0, label: 0, box: 0, polyline: 0 };
+  currentBar = null;
+  lastBar = null;
   limits = {
     line: newLimits.line ?? DEFAULT_MAX_COUNT,
     label: newLimits.label ?? DEFAULT_MAX_COUNT,

package/src/index.ts

@@ -43,6 +43,39 @@ export { taCore, math, array, map, str, color, time, timeframe, matrix, line, bo
 export { drawingOutputs, type DrawingOutputs } from './drawing/output.js';
 export { barInterval, barTime } from './drawing/bar-time.js';
 
+// Drawing registry limits (PineScript indicator(max_lines_count / max_labels_count / max_boxes_count / max_polylines_count))
+export {
+  resetDrawings,
+  setDrawingLimits,
+  setDrawingBar,
+  holdDrawing,
+  releaseDrawing,
+  varDrawing,
+  type DrawingLimits,
+  type DrawingVariable,
+} from './drawing/registry.js';
+
+// The session of a chart context without a script run: time(tf), time_close(tf), time_tradingday, session.* flags,
+// request.security periods with the session and holidays, and bars after the last bar on the trading calendar
+export {
+  chartSessions,
+  periodTime,
+  periodClose,
+  tradingDayTime,
+  chartSessionFlags,
+  resampleSession,
+  barTimeAfter,
+  barsUntil,
+  type SessionContext,
+  type ChartSessions,
+  type SessionResample,
+} from './session/context.js';
+export { TradingCalendar, type SessionSpec } from './session/calendar.js';
+export { SessionBars, sessionFlags, type SessionFlags } from './session/bars.js';
+
+// Same-symbol request.security on a higher timeframe (completion and lookahead rules) and ticker.heikinashi
+export { resample, periodsOf, afterCompletion, mapToChart, heikinAshi, type Resampled } from './security/resample.js';
+
 // Export Series class (self-contained, no context)
 export { Series, BarData } from './runtime/series.js';
 export type { SeriesExtractor } from './runtime/series.js';
@@ -139,6 +172,7 @@ export {
   input_session,
   input_time,
 } from './runtime/inputs.js';
+export { isInputActive } from './runtime/input-active.js';
 
 export type {
   OakScriptContext,
@@ -147,6 +181,7 @@ export type {
   SeriesHandle,
   SeriesOptions,
   InputConfig,
+  InputCondition,
   InputOptions,
   OhlcvData,
   PlotConfig,
@@ -170,7 +205,7 @@ export type { LightweightSeriesDefinitions } from './runtime/adapters/Lightweigh
 export { SimpleInputAdapter } from './runtime/adapters/SimpleInputAdapter.js';
 
 // Version
-export const VERSION = '0.10.0';
+export const VERSION = '0.11.0';
 
 /**
  * Library information

package/src/label/index.ts

@@ -10,7 +10,7 @@
  * @version 6
  */
 
-import { all as allDrawings, isDeleted, register, remove } from '../drawing/registry.js';
+import { all as allDrawings, checkBarIndex, isDeleted, register, remove } from '../drawing/registry.js';
 import type { ChartPoint, Label, color } from '../types/index.js';
 
 type LabelXloc = 'bar_index' | 'bar_time';
@@ -80,6 +80,7 @@ export function new_label(...args: unknown[]): Label {
     string?, LabelXloc?, LabelYloc?, color?, LabelStyle?, color?, (string | number)?,
     ('left' | 'center' | 'right')?, string?, ('default' | 'monospace')?, boolean?, number?,
   ];
+  checkBarIndex('label.new', 'x', x, xloc);
   return register('label', {
     x,
     y,
@@ -188,6 +189,7 @@ export function copy(id: Label): Label {
  */
 export function set_x(id: Label, x: number): Label {
   if (isDeleted(id)) return id;
+  checkBarIndex('label.set_x', 'x', x, id.xloc);
   id.x = x;
   return id;
 }
@@ -227,6 +229,7 @@ export function set_y(id: Label, y: number): Label {
  */
 export function set_xy(id: Label, x: number, y: number): Label {
   if (isDeleted(id)) return id;
+  checkBarIndex('label.set_x', 'x', x, id.xloc);
   id.x = x;
   id.y = y;
   return id;

package/src/line/index.ts

@@ -10,7 +10,7 @@
  * @version 6
  */
 
-import { all as allDrawings, isDeleted, register, remove } from '../drawing/registry.js';
+import { all as allDrawings, checkBarIndex, isDeleted, register, remove } from '../drawing/registry.js';
 import type { ChartPoint, Line, color } from '../types/index.js';
 
 type LineXloc = 'bar_index' | 'bar_time';
@@ -70,6 +70,8 @@ export function new_line(...args: unknown[]): Line {
   const [xloc, extend, lineColor, style, width, force_overlay] = rest as [
     LineXloc?, LineExtend?, color?, LineStyle?, number?, boolean?,
   ];
+  checkBarIndex('line.new', 'x1', x1, xloc);
+  checkBarIndex('line.new', 'x2', x2, xloc);
   return register('line', {
     x1,
     y1,
@@ -79,7 +81,7 @@ export function new_line(...args: unknown[]): Line {
     extend: extend ?? 'none',
     color: lineColor,
     style: style || 'solid',
-    width: width || 1,
+    width: width ?? 1,
     force_overlay: force_overlay ?? false,
   });
 }
@@ -265,6 +267,7 @@ export function copy(id: Line): Line {
  */
 export function set_x1(id: Line, x: number): Line {
   if (isDeleted(id)) return id;
+  checkBarIndex('line.set_x***', 'x1', x, id.xloc);
   id.x1 = x;
   return id;
 }
@@ -284,6 +287,7 @@ export function set_x1(id: Line, x: number): Line {
  */
 export function set_x2(id: Line, x: number): Line {
   if (isDeleted(id)) return id;
+  checkBarIndex('line.set_x***', 'x2', x, id.xloc);
   id.x2 = x;
   return id;
 }
@@ -342,6 +346,7 @@ export function set_y2(id: Line, y: number): Line {
  */
 export function set_xy1(id: Line, x: number, y: number): Line {
   if (isDeleted(id)) return id;
+  checkBarIndex('line.set_x***', 'x1', x, id.xloc);
   id.x1 = x;
   id.y1 = y;
   return id;
@@ -363,6 +368,7 @@ export function set_xy1(id: Line, x: number, y: number): Line {
  */
 export function set_xy2(id: Line, x: number, y: number): Line {
   if (isDeleted(id)) return id;
+  checkBarIndex('line.set_x***', 'x2', x, id.xloc);
   id.x2 = x;
   id.y2 = y;
   return id;

package/src/math/index.ts

@@ -19,6 +19,7 @@
 import type { float, int, simple_int, series_float } from '../types/index.js';
 import { Series } from '../runtime/series.js';
 import { runningSum, runningSumSeries } from '../ta/running-sum.js';
+import { checkSumLength } from '../ta/limits.js';
 
 /**
  * Returns the absolute value of a number.
@@ -489,6 +490,7 @@ export function sum(
 ): series_float | Series {
   // Handle Series objects - extract to array first
   const sourceArray = source instanceof Series ? source.toArray() : source;
+  if (typeof length === 'number') checkSumLength('math.sum', length, 0);
   // PineScript: the sum of the last `length` non-na values (also +/-Infinity skipped); an na bar keeps the previous
   // result. A compensated running sum, bit for bit as PineScript.
   const result: series_float =

package/src/polyline/index.ts

@@ -11,7 +11,7 @@
  */
 
 import type { ChartPoint, Polyline, color } from '../types/index.js';
-import { all as allDrawings, register, remove } from '../drawing/registry.js';
+import { all as allDrawings, checkBarIndex, register, remove } from '../drawing/registry.js';
 
 // Re-export the Polyline type for convenience
 export type { Polyline };
@@ -86,6 +86,8 @@ export function new_polyline(
     line_width = 1;
   }
 
+  if (xloc === 'bar_index') for (const point of points) if (point.index !== null) checkBarIndex('polyline.new', 'points', point.index, xloc);
+
   const polyline: Polyline = {
     id: generateId(),
     points: [...points], // Create a copy of the points array

package/src/runtime/index.ts

@@ -41,11 +41,14 @@ export type {
   SeriesHandle,
   SeriesOptions,
   InputConfig,
+  InputCondition,
   InputOptions,
   OhlcvData,
     PlotConfig,
 } from './types.js';
 
+export { isInputActive } from './input-active.js';
+
 // Adapter exports
 export { LightweightChartsAdapter } from './adapters/LightweightChartsAdapter.js';
 export type { LightweightSeriesDefinitions } from './adapters/LightweightChartsAdapter.js';

package/src/runtime/input-active.ts

@@ -0,0 +1,50 @@
+/**
+ * @fileoverview PineScript `active` of an input: whether the settings dialog lets the user edit it
+ * @module runtime/input-active
+ */
+
+import type { InputConfig, InputCondition } from './types.js';
+
+/** Current value of an input: the host value, else the default of its config. */
+function inputValue(id: string, inputs: Record<string, unknown>, configs?: readonly InputConfig[]): unknown {
+  const value = inputs[id];
+  if (value !== undefined) return value;
+  return configs?.find((c) => c.id === id)?.defval;
+}
+
+function holds(condition: InputCondition, inputs: Record<string, unknown>, configs?: readonly InputConfig[]): boolean {
+  if (typeof condition === 'string') return inputValue(condition, inputs, configs) === true;
+  if ('not' in condition) return !holds(condition.not, inputs, configs);
+  if ('any' in condition) return condition.any.some((c) => holds(c, inputs, configs));
+  if ('all' in condition) return condition.all.every((c) => holds(c, inputs, configs));
+  const value = inputValue(condition.input, inputs, configs);
+  if (!('eq' in condition) && !('ne' in condition)) return value === true;
+  return (!('eq' in condition) || value === condition.eq) && (!('ne' in condition) || value !== condition.ne);
+}
+
+/**
+ * Whether an input is active (PineScript `active`): an inactive input is shown greyed out in the settings and
+ * cannot be edited. It still gives its value to the script.
+ *
+ * @param config - The input
+ * @param inputs - Current input values by id
+ * @param configs - All the inputs of the indicator: gives the default of an input that has no value in `inputs`
+ * @returns true when `config.active` is not set, is true, or is a condition that holds
+ *
+ * @example
+ * ```typescript
+ * const configs: InputConfig[] = [
+ *   { id: 'showMa1', type: 'bool', defval: true, title: 'MA #1' },
+ *   { id: 'ma1Length', type: 'int', defval: 20, active: 'showMa1' },
+ *   { id: 'bbMult', type: 'float', defval: 2, active: { input: 'maType', eq: 'SMA + Bollinger Bands' } },
+ * ];
+ * isInputActive(configs[1], { showMa1: false }) // false
+ * isInputActive(configs[1], {}, configs) // true: the default of showMa1
+ * ```
+ */
+export function isInputActive(config: InputConfig, inputs: Record<string, unknown> = {}, configs?: readonly InputConfig[]): boolean {
+  const { active } = config;
+  if (active === undefined) return true;
+  if (typeof active === 'boolean') return active;
+  return holds(active, inputs, configs);
+}

package/src/runtime/types.ts

@@ -46,6 +46,22 @@ export interface ChartAdapter {
   createPane?(): number;
 }
 
+/**
+ * Condition on other inputs, as plain data (PineScript `active = <expression>`):
+ * - `'showMa'`: the bool input `showMa` is true
+ * - `{ input: 'maType', eq: 'SMA' }` / `{ input: 'maType', ne: 'None' }`: the value of an input is / is not a value
+ *   (strict equality; without `eq` and `ne`: the input is true)
+ * - `{ not: c }`, `{ any: [c1, c2] }` (or), `{ all: [c1, c2] }` (and)
+ *
+ * Evaluated by `isInputActive()`.
+ */
+export type InputCondition =
+  | string
+  | { input: string; eq?: unknown; ne?: unknown }
+  | { not: InputCondition }
+  | { any: InputCondition[] }
+  | { all: InputCondition[] };
+
 /**
  * Configuration for registering an input
  */
@@ -78,10 +94,17 @@ export interface InputConfig {
   /** Ask for the value when the script is added to a chart (PineScript `confirm`) */
   confirm?: boolean;
   /**
-   * Where the input value is shown (PineScript `display`); not set means the PineScript default: 'all', except
-   * color inputs: 'none'
+   * Where the input value is shown (PineScript `display`); not set means the PineScript default: 'none' for
+   * bool, color and time inputs, 'all' for the others
    */
   display?: 'all' | 'none' | 'data_window' | 'status_line';
+  /**
+   * Whether the input can be edited (PineScript `active`): an inactive input is shown greyed out in the settings.
+   * UI only: an inactive input still gives its value to the script. Not set means always active. A boolean is the
+   * value for the current inputs; an `InputCondition` names the inputs it depends on, so a host can apply it
+   * without running the script (see `isInputActive()`)
+   */
+  active?: boolean | InputCondition;
 }
 
 /**