oakscriptjs 0.9.6 → 0.10.1

package/src/script/index.ts

@@ -37,21 +37,39 @@ import type { Bar } from '../types/index.js';
 import type {
   ArrowData,
   BarColorData,
+  BgColorData,
+  BoxData,
   FillData,
   FillGradient,
   IndicatorResult,
+  LabelData,
+  LabelStyle,
+  LineDrawingData,
+  LinefillData,
   MarkerData,
   MarkerLocation,
+  MarkerPosition,
+  MarkerShape,
   MarkerSize,
+  PineSize,
+  PlotBarData,
+  PlotCandleData,
+  PolylineData,
   ShapeStyle,
+  TableCellData,
+  TableData,
+  TableMergeData,
+  TablePosition,
   TimeValue,
 } from '../types/metadata.js';
 import type {
   ArrowConfig,
   BarColorConfig,
+  CandleConfig,
   FillConfig,
   HLineConfig,
   InputConfig,
+  InputCondition,
   PlotConfig,
   ShapeConfig,
 } from '../runtime/types.js';
@@ -65,17 +83,21 @@ import * as labelCore from '../label/index.js';
 import * as boxCore from '../box/index.js';
 import * as linefillCore from '../linefill/index.js';
 import * as polylineCore from '../polyline/index.js';
+import * as tableCore from '../table/index.js';
 import * as chartPointCore from '../chartpoint/index.js';
 import * as textCore from '../text/index.js';
 import * as mathCore from '../math/index.js';
 import { resetDrawings, setDrawingLimits } from '../drawing/registry.js';
+import { drawingOutputs } from '../drawing/output.js';
 import * as timeframeCore from '../timeframe/index.js';
 import * as timeCore from '../time/index.js';
 import * as strCore from '../str/index.js';
 import { formatMessage } from '../str/messageformat.js';
+import { tickScale } from '../str/numberformat.js';
 import { TradingCalendar, type SessionSpec } from '../session/calendar.js';
 import { SessionBars, sessionFlags, type SessionFlags } from '../session/bars.js';
 import { afterCompletion, heikinAshi, mapToChart, periodsOf, resample } from '../security/resample.js';
+import { position } from '../types/index.js';
 import type { ChartPoint } from '../types/index.js';
 import {
   STRATEGY_CONSTANTS,
@@ -110,11 +132,17 @@ export interface ScriptRunResult {
   shapeConfig: ShapeConfig[];
   arrowConfig: ArrowConfig[];
   barColorConfig: BarColorConfig[];
+  /** plotcandle() / plotbar() declarations */
+  candleConfig: CandleConfig[];
   defaultInputs: Record<string, unknown>;
   alertConfig: AlertConditionConfig[];
   /** Strategy properties (declared values, else the PineScript defaults) when the script declares strategy(). */
   strategyConfig?: StrategyProperties;
-  /** The renderable output (plots keyed by plotConfig ids, plot-pair fills). */
+  /**
+   * 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.
+   */
   result: IndicatorResult & { alerts?: AlertState[] };
 }
 
@@ -159,8 +187,11 @@ interface Collector {
   arrowConfig: ArrowConfig[];
   arrows: ArrowData[];
   barColorConfig: BarColorConfig[];
-  bgcolors: BarColorData[];
-  barcolors: BarColorData[];
+  bgColors: BgColorData[];
+  barColors: BarColorData[];
+  candleConfig: CandleConfig[];
+  plotCandles: Record<string, PlotCandleData[]>;
+  plotBars: Record<string, PlotBarData[]>;
   alertConfig: AlertConditionConfig[];
   alerts: AlertState[];
   strategy?: StrategyRun;
@@ -210,8 +241,11 @@ function freshCollector(inputValues: Record<string, unknown>): Collector {
     arrowConfig: [],
     arrows: [],
     barColorConfig: [],
-    bgcolors: [],
-    barcolors: [],
+    bgColors: [],
+    barColors: [],
+    candleConfig: [],
+    plotCandles: {},
+    plotBars: {},
     alertConfig: [],
     alerts: [],
   };
@@ -284,6 +318,7 @@ export function executeScript(
       shapeConfig: c.shapeConfig,
       arrowConfig: c.arrowConfig,
       barColorConfig: c.barColorConfig,
+      candleConfig: c.candleConfig,
       defaultInputs: c.defaultInputs,
       alertConfig: c.alertConfig,
       strategyConfig: c.strategy?.properties,
@@ -293,8 +328,11 @@ export function executeScript(
         fills: c.fills.length ? c.fills : undefined,
         markers: c.markers.length ? c.markers : undefined,
         arrows: c.arrows.length ? c.arrows : undefined,
-        bgcolors: c.bgcolors.length ? c.bgcolors : undefined,
-        barcolors: c.barcolors.length ? c.barcolors : undefined,
+        bgColors: c.bgColors.length ? c.bgColors : undefined,
+        barColors: c.barColors.length ? c.barColors : undefined,
+        plotCandles: Object.keys(c.plotCandles).length ? c.plotCandles : undefined,
+        plotBars: Object.keys(c.plotBars).length ? c.plotBars : undefined,
+        ...drawingOutputs(ctxBars.bars, chartCtx.timeUnit),
         alerts: c.alerts.length ? c.alerts : undefined,
       },
     };
@@ -344,13 +382,19 @@ function declare(c: Collector, kind: 'indicator' | 'strategy'): void {
   c.declaration = kind;
 }
 
-/** Options of every `input.*` kind (PineScript `group`, `inline`, `tooltip`, `confirm`, `display`). */
+/** Options of every `input.*` kind (PineScript `group`, `inline`, `tooltip`, `confirm`, `display`, `active`). */
 export interface InputOptions {
   group?: string;
   inline?: string;
   tooltip?: string;
   confirm?: boolean;
   display?: InputConfig['display'];
+  /**
+   * PineScript `active`: false greys the input out in the settings (it keeps its value). A boolean as in
+   * PineScript (`active: showMa`), or a condition on input ids that a host can apply without running the script
+   * (`active: 'ma_1'`, `active: { input: 'type', ne: 'None' }`)
+   */
+  active?: boolean | InputCondition;
 }
 
 export interface NumericInputOptions extends InputOptions {
@@ -371,6 +415,7 @@ function common(opts: InputOptions): Partial<InputConfig> {
   if (opts.tooltip !== undefined) out.tooltip = opts.tooltip;
   if (opts.confirm !== undefined) out.confirm = opts.confirm;
   if (opts.display !== undefined) out.display = opts.display;
+  if (opts.active !== undefined) out.active = opts.active;
   return out;
 }
 
@@ -779,8 +824,46 @@ export interface PlotCharOptions extends Omit<PlotShapeOptions, 'style'> {
   char?: string;
 }
 
+/** PineScript shape.* style -> marker shape. */
+const MARKER_SHAPES: Record<ShapeStyle, MarkerShape> = {
+  xcross: 'xcross',
+  cross: 'cross',
+  triangleup: 'triangleUp',
+  triangledown: 'triangleDown',
+  flag: 'flag',
+  circle: 'circle',
+  arrowup: 'arrowUp',
+  arrowdown: 'arrowDown',
+  labelup: 'labelUp',
+  labeldown: 'labelDown',
+  square: 'square',
+  diamond: 'diamond',
+};
+
+/**
+ * Marker position of a PineScript location. With location.absolute the shape sits on the price: a label pointing
+ * down above it, a label pointing up below it, the other shapes (and the characters) centred on it.
+ */
+function markerPosition(location: MarkerLocation, shape: ShapeStyle | undefined): MarkerPosition {
+  switch (location) {
+    case 'abovebar':
+      return 'aboveBar';
+    case 'belowbar':
+      return 'belowBar';
+    case 'top':
+      return 'top';
+    case 'bottom':
+      return 'bottom';
+    case 'absolute':
+      return shape === 'labeldown' ? 'atPriceTop' : shape === 'labelup' ? 'atPriceBottom' : 'atPriceMiddle';
+  }
+}
+
+/** Default colour of plotshape / plotchar markers. */
+const MARKER_COLOR = '#2962FF';
+
 /** Shared emitter for plotshape()/plotchar(). Emits one marker per bar where
- *  the condition is truthy (not na, not 0). */
+ *  the condition is truthy (not na, not 0). A plotchar marker has the shape 'circle' and its character in `char`. */
 function emitMarkers(
   kind: 'shape' | 'char',
   condition: Series,
@@ -806,6 +889,19 @@ function emitMarkers(
     offset: options.offset,
     forceOverlay: options.force_overlay,
   });
+  const shapeStyle = kind === 'shape' ? (style as ShapeStyle) : undefined;
+  const template: Omit<MarkerData, 'time'> = {
+    position: markerPosition(location, shapeStyle),
+    shape: shapeStyle ? MARKER_SHAPES[shapeStyle] : 'circle',
+    color: options.color ?? MARKER_COLOR,
+    id,
+  };
+  if (char !== undefined) template.char = char;
+  if (options.text !== undefined) template.text = options.text;
+  if (options.textcolor !== undefined) template.textColor = options.textcolor;
+  if (options.size !== undefined) template.size = options.size;
+  if (options.tooltip !== undefined) template.tooltip = options.tooltip;
+  if (options.force_overlay) template.forceOverlay = true;
   const values = condition.toArray();
   const b = bars();
   const off = options.offset ?? 0;
@@ -814,19 +910,8 @@ function emitMarkers(
     if (v === undefined || Number.isNaN(v) || v === 0) continue;
     const j = i + off;
     if (j < 0 || j >= b.length) continue;
-    c.markers.push({
-      time: b[j]!.time,
-      id,
-      location,
-      style,
-      char,
-      color: options.color,
-      text: options.text,
-      textcolor: options.textcolor,
-      size: options.size,
-      tooltip: options.tooltip,
-      price: location === 'absolute' ? v : undefined,
-    });
+    const time = b[j]!.time;
+    c.markers.push(location === 'absolute' ? { time, ...template, price: v } : { time, ...template });
   }
 }
 
@@ -906,13 +991,14 @@ function emitBarColors(
   c.barColorConfig.push({ id, kind, title: options.title, offset: options.offset, forceOverlay: options.force_overlay });
   const b = bars();
   const off = options.offset ?? 0;
-  const target = kind === 'bgcolor' ? c.bgcolors : c.barcolors;
+  const target: BgColorData[] = kind === 'bgcolor' ? c.bgColors : c.barColors;
+  const forceOverlay = kind === 'bgcolor' && options.force_overlay === true;
   for (let i = 0; i < b.length; i++) {
     const col = typeof colors === 'string' ? colors : colors[i];
     if (!col) continue;
     const j = i + off;
     if (j < 0 || j >= b.length) continue;
-    target.push({ time: b[j]!.time, color: col });
+    target.push(forceOverlay ? { time: b[j]!.time, color: col, forceOverlay } : { time: b[j]!.time, color: col });
   }
 }
 
@@ -935,6 +1021,129 @@ export function barcolor(
   emitBarColors('barcolor', colors, options);
 }
 
+/** A colour argument of plotcandle() / plotbar(): a colour, or per-bar colours (null / undefined entries are na). */
+export type ScriptCandleColor = string | Array<string | null | undefined>;
+
+export interface PlotCandleOptions {
+  /** Body colour: a colour or a per-bar array (color.when); an na entry gives a transparent body */
+  color?: ScriptCandleColor;
+  /** Wick colour: a colour or a per-bar array */
+  wickcolor?: ScriptCandleColor;
+  /** Border colour: a colour or a per-bar array */
+  bordercolor?: ScriptCandleColor;
+  display?: CandleConfig['display'];
+  /** Draw on the main chart pane even when the script is not an overlay (PineScript `force_overlay`); default false. */
+  force_overlay?: boolean;
+}
+
+export interface PlotBarOptions {
+  /** Bar colour: a colour or a per-bar array (color.when); an na entry gives a transparent bar */
+  color?: ScriptCandleColor;
+  display?: CandleConfig['display'];
+  /** Draw on the main chart pane even when the script is not an overlay (PineScript `force_overlay`); default false. */
+  force_overlay?: boolean;
+}
+
+/** Colour of bar i: undefined when the argument is not given, 'transparent' for an na entry. */
+function candleColor(col: ScriptCandleColor | undefined, i: number): string | undefined {
+  if (col === undefined) return undefined;
+  if (typeof col === 'string') return col;
+  return col[i] ?? 'transparent';
+}
+
+interface OhlcRow {
+  i: number;
+  open: number;
+  high: number;
+  low: number;
+  close: number;
+}
+
+/** The bars where open, high, low and close are all not na (PineScript draws no candle / bar otherwise). */
+function ohlcRows(o: Series, h: Series, l: Series, cl: Series): OhlcRow[] {
+  const [ov, hv, lv, cv] = [o.toArray(), h.toArray(), l.toArray(), cl.toArray()];
+  const rows: OhlcRow[] = [];
+  for (let i = 0; i < bars().length; i++) {
+    const [open, high, low, close] = [ov[i]!, hv[i]!, lv[i]!, cv[i]!];
+    if (Number.isFinite(open) && Number.isFinite(high) && Number.isFinite(low) && Number.isFinite(close)) {
+      rows.push({ i, open, high, low, close });
+    }
+  }
+  return rows;
+}
+
+const staticColor = (col: ScriptCandleColor | undefined): string | undefined => (typeof col === 'string' ? col : undefined);
+
+/**
+ * PineScript `plotcandle(open, high, low, close, title?, { color, wickcolor, bordercolor, display, force_overlay })`:
+ * candles in `result.plotCandles[id]`, the declaration in `candleConfig`. A bar with an na value has no candle.
+ */
+export function plotcandle(
+  open: Series,
+  high: Series,
+  low: Series,
+  close: Series,
+  title?: string,
+  options: PlotCandleOptions = {}
+): void {
+  const c = collector();
+  const id = `plotcandle${c.candleConfig.filter((x) => x.kind === 'candle').length}`;
+  c.candleConfig.push({
+    id,
+    kind: 'candle',
+    title,
+    color: staticColor(options.color),
+    wickColor: staticColor(options.wickcolor),
+    borderColor: staticColor(options.bordercolor),
+    display: options.display,
+    forceOverlay: options.force_overlay,
+  });
+  const b = bars();
+  c.plotCandles[id] = ohlcRows(open, high, low, close).map(({ i, ...ohlc }) => {
+    const candle: PlotCandleData = { time: b[i]!.time, ...ohlc };
+    const color = candleColor(options.color, i);
+    const wickColor = candleColor(options.wickcolor, i);
+    const borderColor = candleColor(options.bordercolor, i);
+    if (color !== undefined) candle.color = color;
+    if (wickColor !== undefined) candle.wickColor = wickColor;
+    if (borderColor !== undefined) candle.borderColor = borderColor;
+    if (options.force_overlay) candle.forceOverlay = true;
+    return candle;
+  });
+}
+
+/**
+ * PineScript `plotbar(open, high, low, close, title?, { color, display, force_overlay })`: OHLC bars in
+ * `result.plotBars[id]`, the declaration in `candleConfig`. A bar with an na value is not drawn.
+ */
+export function plotbar(
+  open: Series,
+  high: Series,
+  low: Series,
+  close: Series,
+  title?: string,
+  options: PlotBarOptions = {}
+): void {
+  const c = collector();
+  const id = `plotbar${c.candleConfig.filter((x) => x.kind === 'bar').length}`;
+  c.candleConfig.push({
+    id,
+    kind: 'bar',
+    title,
+    color: staticColor(options.color),
+    display: options.display,
+    forceOverlay: options.force_overlay,
+  });
+  const b = bars();
+  c.plotBars[id] = ohlcRows(open, high, low, close).map(({ i, ...ohlc }) => {
+    const bar: PlotBarData = { time: b[i]!.time, ...ohlc };
+    const color = candleColor(options.color, i);
+    if (color !== undefined) bar.color = color;
+    if (options.force_overlay) bar.forceOverlay = true;
+    return bar;
+  });
+}
+
 // ── Per-bar execution (eachBar) ──────────────────────────────────────────────
 
 /**
@@ -1322,8 +1531,18 @@ export interface ChartContext {
   tickerid?: string;
   /** Unit of `Bar.time`: 's' (default, as lightweight-charts) or 'ms'. PineScript times are in ms. */
   timeUnit?: 's' | 'ms';
-  /** Minimum price move of the symbol (PineScript `syminfo.mintick`), e.g. 0.01; used by `math.round_to_mintick` */
+  /**
+   * Minimum price move of the symbol (PineScript `syminfo.mintick`), e.g. 0.01; used by `math.round_to_mintick` and
+   * `format.mintick`. Default: `minmove / pricescale` when both are given
+   */
   mintick?: number;
+  /**
+   * PineScript `syminfo.minmove` and `syminfo.pricescale` (mintick = minmove / pricescale). Default: from `mintick`,
+   * with pricescale 10^(its decimals) (0.25 is 25 / 100). Pass them for a symbol priced in fractions (1 / 32):
+   * `format.mintick` shows floor(log10(pricescale)) decimals
+   */
+  minmove?: number;
+  pricescale?: number;
   /** Currency value of one point of price move for one contract (PineScript `syminfo.pointvalue`); 1 for stocks */
   pointvalue?: number;
   /** Smallest tradable quantity (PineScript `syminfo.mincontract`); 1 for whole shares */
@@ -1411,19 +1630,37 @@ function symbolProperty(key: 'mintick' | 'pointvalue' | 'mincontract'): number {
   collector();
   const value = chartCtx[key];
   if (value === undefined) {
+    if (key === 'mintick' && chartCtx.minmove !== undefined && chartCtx.pricescale !== undefined) {
+      return chartCtx.minmove / chartCtx.pricescale;
+    }
     throw new Error(`syminfo.${key} is not known: pass it as executeScript(body, bars, inputs, { ${key} }).`);
   }
   return value;
 }
 
+/** `[minmove, pricescale]` of the chart symbol: from the chart context, else from its mintick. */
+function symbolScale(): [number, number] {
+  collector();
+  const { minmove, pricescale } = chartCtx;
+  if (minmove !== undefined && pricescale !== undefined) return [minmove, pricescale];
+  const [move, scale] = tickScale(symbolProperty('mintick'), pricescale);
+  return [minmove ?? move, scale];
+}
+
 /**
  * PineScript `syminfo.timezone`, `syminfo.tickerid`, `syminfo.session` (session type), `syminfo.mintick`,
- * `syminfo.pointvalue` and `syminfo.mincontract`, from the chart context.
+ * `syminfo.minmove`, `syminfo.pricescale`, `syminfo.pointvalue` and `syminfo.mincontract`, from the chart context.
  */
 export const syminfo = {
   get mintick(): number {
     return symbolProperty('mintick');
   },
+  get minmove(): number {
+    return symbolScale()[0];
+  },
+  get pricescale(): number {
+    return symbolScale()[1];
+  },
   get pointvalue(): number {
     return symbolProperty('pointvalue');
   },
@@ -1509,9 +1746,11 @@ export function inSession(time: number, session: string, timezone?: string): boo
 /** PineScript `str.*`; `format_time` and the dates of `format` use the exchange time zone by default. */
 export const str = {
   ...strCore,
-  // format.mintick rounds to the chart symbol's tick (syminfo.mintick)
-  tostring: ((value: unknown, format?: string, mintick?: number) =>
-    strCore.tostring(value as never, format, format === 'mintick' ? (mintick ?? syminfo.mintick) : mintick)) as typeof strCore.tostring,
+  // format.mintick uses the chart symbol's tick and price scale (syminfo.mintick, syminfo.pricescale)
+  tostring: ((value: unknown, format?: string, mintick?: number, pricescale?: number) =>
+    format === 'mintick' && mintick === undefined
+      ? strCore.tostring(value as never, format, syminfo.mintick, pricescale ?? syminfo.pricescale)
+      : strCore.tostring(value as never, format, mintick, pricescale)) as typeof strCore.tostring,
   format_time(time: number, format: string = "yyyy-MM-dd'T'HH:mm:ssZ", timezone?: string): string {
     return strCore.format_time(time, format, timezone ?? exchangeTimezone());
   },
@@ -1831,7 +2070,20 @@ export const polyline = {
   },
 };
 
-/** PineScript `text.format_*` constants. */
+/**
+ * PineScript `table.*`; `table.all` lists the live tables in creation order. The live tables go to `result.tables`.
+ */
+export const table = {
+  ...tableCore,
+  get all() {
+    return tableCore.all();
+  },
+};
+
+/** PineScript `position.*` constants (table positions). */
+export { position };
+
+/** PineScript `text.format_*`, `text.align_*` and `text.wrap_*` constants. */
 export const text = { ...textCore };
 
 /**
@@ -1902,21 +2154,40 @@ export const math = {
   }) as typeof mathCore.round_to_mintick,
 };
 export * as compare from '../compare/index.js';
+export { isInputActive } from '../runtime/input-active.js';
 export type {
   Bar,
   IndicatorResult,
   TimeValue,
   InputConfig,
+  InputCondition,
   PlotConfig,
   HLineConfig,
   FillConfig,
   ShapeConfig,
   ArrowConfig,
   BarColorConfig,
+  CandleConfig,
   MarkerData,
+  MarkerPosition,
+  MarkerShape,
   ArrowData,
   BarColorData,
+  BgColorData,
+  PlotCandleData,
+  PlotBarData,
+  LabelData,
+  LabelStyle,
+  LineDrawingData,
+  BoxData,
+  LinefillData,
+  PolylineData,
+  TableData,
+  TableCellData,
+  TableMergeData,
+  TablePosition,
   MarkerLocation,
   MarkerSize,
+  PineSize,
   ShapeStyle,
 };

package/src/str/index.ts

@@ -9,10 +9,9 @@
  * @version 6
  */
 
-import { formatNumber } from './numberformat.js';
+import { formatNumber, tickScale } from './numberformat.js';
 import { formatMessage } from './messageformat.js';
 import { formatDate } from './dateformat.js';
-import { round_to_mintick } from '../math/index.js';
 import type { int, bool, float, simple_int, simple_string } from '../types/index.js';
 
 /**
@@ -40,6 +39,8 @@ export function length(str: simple_string): int {
  *   `format.price` / `format.inherit`
  * @param mintick - Tick size for `format.mintick` (PineScript `syminfo.mintick`, implicit there). Not part of the
  *   PineScript signature: the core function cannot see the chart, so pass it, as for `math.round_to_mintick`
+ * @param pricescale - Price scale of the symbol for `format.mintick` (PineScript `syminfo.pricescale`), needed for a
+ *   symbol priced in fractions (32 for a 1/32 tick). Default: 10^(decimals of `mintick`)
  * @returns String representation of the value
  *
  * @remarks
@@ -53,8 +54,12 @@ export function length(str: simple_string): int {
  * - `format.percent` shows 2 decimals and "%" without multiplying; `format.volume` uses K, M, B, T
  * - `format.price` and `format.inherit` give "price1" / "inherit1" in PineScript: they are patterns
  *   without digit characters, and oakscriptjs does the same
- * - `format.mintick` rounds to the tick (`math.round_to_mintick`) and shows the tick's decimals ("#.##" for 0.01);
- *   it throws without `mintick`
+ * - `format.mintick` shows floor(log10(pricescale)) decimals, zeros included ("1.00", "0.40" for tick 0.01), and
+ *   rounds in two steps, with mintick = minmove / pricescale: the double quotient `|x| / (1 / pricescale)` half away
+ *   from zero (140.355 / 0.01 = 14035.499999999998 gives "140.35", where `math.round_to_mintick` gives 140.36),
+ *   then `floor(units / minmove + 0.5)` ticks (tick 0.02: 0.005 gives "0.02", -0.01 gives "0.00"). With a
+ *   pricescale that is no power of 10 the tick value is then rounded half even to those decimals (1/32: 25.25 gives
+ *   "25.2", -0.02 gives "-0.0"). It throws without `mintick`
  * - na gives "NaN" ("NaN%" with `format.percent`); an infinity gives "NaN" too ("NaN%" for `format.percent`,
  *   "NaNT" for `format.volume`), except `format.mintick`, which gives "Infinity" / "-Infinity"
  *
@@ -66,7 +71,7 @@ export function length(str: simple_string): int {
  * str.tostring(12345.678, format.volume) // "12.346K"
  * ```
  */
-export function tostring(value: any, format?: simple_string, mintick?: float): string {
+export function tostring(value: any, format?: simple_string, mintick?: float, pricescale?: float): string {
   if (typeof value !== 'number') return String(value);
   if (Number.isNaN(value)) return format === 'percent' ? 'NaN%' : 'NaN';
   if (!Number.isFinite(value)) {
@@ -94,11 +99,19 @@ export function tostring(value: any, format?: simple_string, mintick?: float): s
       if (mintick === undefined) {
         throw new Error('str.tostring(x, format.mintick) needs the tick size: pass it as str.tostring(x, format.mintick, syminfo.mintick)');
       }
-      // mask: one '#' per decimal of the tick ("#.##" for 0.01, "#" for 1)
-      const m = /^\d+(?:\.(\d+))?(?:e-(\d+))?$/.exec(String(mintick));
-      const decimals = m ? (m[1]?.length ?? 0) + Number(m[2] ?? 0) : 0;
-      const mask = decimals ? '#.' + '#'.repeat(decimals) : '#';
-      return formatNumber(round_to_mintick(value, mintick), mask, 'halfUpShortest');
+      const [minmove, scale] = tickScale(mintick, pricescale);
+      const decimals = Math.floor(Math.log10(scale) + 1e-9);
+      const mask = decimals > 0 ? '0.' + '0'.repeat(decimals) : '0';
+      if (!(minmove >= 1)) return formatNumber(value, mask, 'halfUpShortest');
+      // 1. the double quotient |x| / (1 / pricescale), half away from zero (not math.round_to_mintick's exact decimal)
+      const scaled = Math.abs(value) / (1 / scale);
+      let units = Math.trunc(scaled);
+      if (scaled - units >= 0.5) units++;
+      // 2. to the tick, a half going up (minmove 2: -0.01 gives "0.00", 0.01 gives "0.02")
+      const ticks = Math.floor((value < 0 ? -units : units) / minmove + 0.5);
+      // 3. the tick value at the scale's decimals; a negative one keeps its sign when it prints as zero ("-0.0")
+      const text = formatNumber((Math.abs(ticks) * minmove) / scale, mask, 'halfEvenExact');
+      return ticks < 0 ? '-' + text : text;
     }
     default:
       return formatNumber(value, format, 'halfUpShortest');

package/src/str/numberformat.ts

@@ -230,3 +230,16 @@ function affixes(p: Pattern, negative: boolean, body: string): string {
   if (p.negPrefix === null) return '-' + p.prefix + body + p.suffix;
   return p.negPrefix + body + p.negSuffix!;
 }
+
+/**
+ * `[minmove, pricescale]` of a tick (PineScript `syminfo.mintick = syminfo.minmove / syminfo.pricescale`).
+ * Without `pricescale` it is 10^(decimals of the tick): 0.02 is 2 / 100, 0.25 is 25 / 100. A symbol priced in
+ * fractions needs its own (1/32 is 1 / 32).
+ */
+export function tickScale(mintick: number, pricescale?: number): [number, number] {
+  if (pricescale === undefined) {
+    const m = /^\d+(?:\.(\d+))?(?:e-(\d+))?$/.exec(String(mintick));
+    pricescale = Number(`1e${m ? (m[1]?.length ?? 0) + Number(m[2] ?? 0) : 0}`);
+  }
+  return [Math.round(mintick * pricescale), pricescale];
+}