Plotting

import { area, bar, histogram, input, line, lower, none, ohlcv, output, overlay, param, scatter, shape } from "./sdk/declare";
import { in_close, in_low, in_volume } from "./gen/inputs";
import {
  emitRow,
  out_cross_mark,
  out_crossed,
  out_delta,
  out_delta_sign,
  out_fast,
  out_overbought,
  out_rsi,
  out_slow,
  out_spread,
  out_volume,
} from "./gen/outputs";
import { p_fast, p_slow } from "./gen/params";
import { Cross, Rsi, Sma } from "./sdk/ta";

param("fast", 9, { min: 1, max: 200 });
param("slow", 21, { min: 2, max: 400 });
input("close", ohlcv.close);
input("low", ohlcv.low);
input("volume", ohlcv.volume);
output("fast", line, overlay, { color: "#2563eb", width: 2, description: "Fast average, a line" });
output("slow", area, overlay, { color: "#94a3b8", opacity: 0.3, description: "Slow average, drawn as an area" });
output("cross_mark", shape, overlay, { color: "#16a34a", shape_where: "crossed", description: "A mark on the low of each bullish-cross bar" });
output("crossed", none, overlay, { description: "1 on the bar the fast average crosses above the slow: the mark's gate" });
output("volume", bar, lower, { color: "#4ecdc4", description: "Volume as bars" });
output("delta", histogram, lower, { color_by: "delta_sign", colors: ["#ef5350", "#26a69a"], description: "Fast minus slow as columns, colored by sign" });
output("delta_sign", none, lower, { description: "0 negative, 1 positive: the histogram's palette index" });
output("spread", scatter, lower, { color: "#f97316", description: "Close minus fast, as dots" });
output("rsi", line, lower, { color: "#7c3aed", width: 2, description: "RSI" });
output("overbought", line, lower, { color: "#ff0000", width: 1, line_style: "dashed", description: "The 70 level, written on every bar" });

let fast = new Sma(9);
let slow = new Sma(21);
let rsi = new Rsi(14);
const cross = new Cross();
let fastValue: f64 = NaN;
let slowValue: f64 = NaN;
let rsiValue: f64 = NaN;
let close: f64 = NaN;
let low: f64 = NaN;
let volume: f64 = NaN;
let crossed: i32 = 0;

export function init(): void {
  fast = new Sma(i32(p_fast()));
  slow = new Sma(i32(p_slow()));
  rsi = new Rsi(14);
}

export function state(): i32 {
  close = in_close();
  low = in_low();
  volume = in_volume();
  fastValue = fast.update(close);
  slowValue = slow.update(close);
  rsiValue = rsi.update(close);
  crossed = cross.update(fastValue, slowValue);
  return isNaN(slowValue) ? 0 : 1;
}

export function finalize(): void {
  const delta = fastValue - slowValue;
  out_fast(fastValue);
  out_slow(slowValue);
  out_cross_mark(low);
  out_crossed(crossed == 1 ? 1.0 : 0.0);
  out_volume(volume);
  out_delta(delta);
  out_delta_sign(delta >= 0.0 ? 1.0 : 0.0);
  out_spread(close - fastValue);
  out_rsi(rsiValue);
  out_overbought(70.0);
  emitRow();
}

export function reset(): void {
  fast.reset();
  slow.reset();
  rsi.reset();
  cross.reset();
  fastValue = NaN;
  slowValue = NaN;
  rsiValue = NaN;
  close = NaN;
  low = NaN;
  volume = NaN;
  crossed = 0;
}

import { box, input, none, ohlcv, output, overlay, segment } from "./sdk/declare";
import { in_close, in_high, in_low, in_open } from "./gen/inputs";
import { emitRow, out_bearish, out_bullish, out_ha_close, out_ha_high, out_ha_low, out_ha_open } from "./gen/outputs";

input("close", ohlcv.close);
input("open", ohlcv.open);
input("high", ohlcv.high);
input("low", ohlcv.low);
const haOpen = output("ha_open", none, overlay, { description: "Heikin Ashi open" });
const haHigh = output("ha_high", none, overlay, { description: "Heikin Ashi high" });
const haLow = output("ha_low", none, overlay, { description: "Heikin Ashi low" });
const haClose = output("ha_close", none, overlay, { description: "Heikin Ashi close" });
const bullish = output("bullish", none, overlay, { description: "1 when the smoothed close is above the smoothed open" });
const bearish = output("bearish", none, overlay, { description: "1 otherwise" });
// The body: one box per bar between open and close, one declaration per color.
box("body_up", { top: haClose, bottom: haOpen, when: bullish, color: "#4caf50", opacity: 0.9, borderWidth: 0 });
box("body_down", { top: haOpen, bottom: haClose, when: bearish, color: "#f44336", opacity: 0.9, borderWidth: 0 });
// The wick: a vertical segment from the high to the low on the same bar.
segment("wick", { yFrom: haHigh, yTo: haLow, color: "#9ca3af", width: 1 });

let prevOpen: f64 = NaN;
let prevClose: f64 = NaN;
let open: f64 = NaN;
let high: f64 = NaN;
let low: f64 = NaN;
let close: f64 = NaN;

export function init(): void {}

export function state(): i32 {
  const o = in_open();
  const h = in_high();
  const l = in_low();
  const c = in_close();
  close = (o + h + l + c) / 4.0;
  // The first bar seeds the open from the raw bar; after that it is the previous smoothed midpoint.
  open = isNaN(prevOpen) ? (o + c) / 2.0 : (prevOpen + prevClose) / 2.0;
  high = Math.max(h, Math.max(open, close));
  low = Math.min(l, Math.min(open, close));
  prevOpen = open;
  prevClose = close;
  return 1;
}

export function finalize(): void {
  out_ha_open(open);
  out_ha_high(high);
  out_ha_low(low);
  out_ha_close(close);
  out_bullish(close >= open ? 1.0 : 0.0);
  out_bearish(close < open ? 1.0 : 0.0);
  emitRow();
}

export function reset(): void {
  prevOpen = NaN;
  prevClose = NaN;
  open = NaN;
  high = NaN;
  low = NaN;
  close = NaN;
}

import { input, line, none, ohlcv, output, overlay, param, render, string, time } from "./sdk/declare";
import { in_bar_t, in_close, in_volume } from "./gen/inputs";
import { emitRow, out_average, out_bar_time, out_stretched, out_stretch_pct, out_volume } from "./gen/outputs";
import { p_period, p_stretch } from "./gen/params";
import {
  sb_clear,
  sb_f64,
  sb_text,
  str_readout_sb,
  str_stretch_label,
  str_stretch_text_sb,
  str_tag_sb,
} from "./gen/strings";
import { Sma } from "./sdk/ta";

param("period", 20, { min: 1, max: 200 });
param("stretch", 2, { min: 0.1, max: 20, description: "Percent from the average that counts as stretched" });
input("close", ohlcv.close);
input("volume", ohlcv.volume);
input("bar_t", time.bar_open_sec);
output("average", line, overlay, { color: "#38bdf8", width: 2, description: "Simple average" });
output("bar_time", none, overlay, { description: "Bar open in epoch seconds, the label's x" });
output("stretch_pct", none, overlay, { description: "Close distance from the average, percent" });
output("stretched", none, overlay, { description: "1 while the close is stretched from the average" });
output("volume", none, overlay, { description: "Volume, shown in the strip" });
string("readout", { max_bytes: 32 });
string("tag", { max_bytes: 32 });
string("stretch_label", { max_bytes: 16 });
string("stretch_text", { max_bytes: 16 });
// A text mark on every stretched bar (the slot is left unwritten on quiet bars).
render.text("stretch_mark", { y: "average", text: "readout", color: "#f59e0b", size: 10 });
// One price tag riding the newest bar.
render.label("average_tag", { x: "bar_time", y: "average", text: "tag", color: "#38bdf8", size: 11 });
// A fixed-position 1x2 dashboard: the newest bar where both cells were written wins.
render.table("stats", { rows: 1, cols: 2, cells: ["stretch_label", "stretch_text"], position: "top_right" });
// Volume as a statistics-strip row.
render.stats_row("volume_row", { output: "volume", title: "Volume", format: "si", polarity: "magnitude" });
// A background tint on stretched bars.
render.bgcolor("stretch_tint", { where: "stretched", color: "#f59e0b22" });

let sma = new Sma(20);
let threshold: f64 = 2.0;
let value: f64 = NaN;
let close: f64 = NaN;
let volume: f64 = NaN;
let barTime: f64 = NaN;

export function init(): void {
  sma = new Sma(i32(p_period()));
  threshold = p_stretch();
}

export function state(): i32 {
  close = in_close();
  volume = in_volume();
  barTime = in_bar_t();
  value = sma.update(close);
  return isNaN(value) ? 0 : 1;
}

export function finalize(): void {
  const stretch = value == 0.0 ? NaN : ((close - value) / value) * 100.0;
  const stretched = Math.abs(stretch) >= threshold;
  out_average(value);
  out_bar_time(barTime);
  out_stretch_pct(stretch);
  out_stretched(stretched ? 1.0 : 0.0);
  out_volume(volume);
  if (stretched) {
    sb_clear();
    sb_f64(stretch, 1);
    sb_text("%");
    str_readout_sb();
  }
  sb_clear();
  sb_text("SMA ");
  sb_f64(value, 2);
  str_tag_sb();
  str_stretch_label("stretch");
  sb_clear();
  sb_f64(stretch, 2);
  sb_text("%");
  str_stretch_text_sb();
  emitRow();
}

export function reset(): void {
  sma.reset();
  value = NaN;
  close = NaN;
  volume = NaN;
  barTime = NaN;
}

{
  "id": "fn-corner-label",
  "name": "Corner label and price tags",
  "abi_version": "wrun-3",
  "params": [{ "name": "period", "default": 20, "min": 1, "max": 200 }],
  "inputSources": { "close": { "source": "ohlcv", "field": "close" } },
  "inputs": [{ "index": 0, "name": "close" }],
  "outputs": [{ "index": 0, "name": "average", "plot": "line", "panel": "overlay", "color": "#38bdf8" }],
  "string_slots": [
    { "index": 0, "name": "status", "max_bytes": 32 },
    { "index": 1, "name": "tag", "max_bytes": 16 }
  ],
  "renderers": [
    { "kind": "label", "name": "status_corner", "text": "status", "position": "top_right", "size": 12 },
    { "kind": "text", "name": "stretch_tag", "y": "average", "text": "tag", "style": "price_label", "color": "#f59e0b", "size": 10 }
  ]
}

import { in_close } from "./gen/inputs";
import { emitRow, out_average } from "./gen/outputs";
import { p_period } from "./gen/params";
import { sb_clear, sb_f64, sb_text, str_status_sb, str_tag_sb } from "./gen/strings";
import { Sma } from "./sdk/ta";

let sma = new Sma(20);
let value: f64 = NaN;
let close: f64 = NaN;

export function init(): void {
  sma = new Sma(i32(p_period()));
}

export function state(): i32 {
  close = in_close();
  value = sma.update(close);
  return isNaN(value) ? 0 : 1;
}

export function finalize(): void {
  out_average(value);
  // The corner label: rewritten on every bar, so the newest bar's text is what shows.
  sb_clear();
  sb_text("SMA ");
  sb_f64(value, 2);
  str_status_sb();
  // A price tag on stretched bars only: the slot stays unwritten on quiet bars.
  const stretch = value == 0.0 ? 0.0 : ((close - value) / value) * 100.0;
  if (Math.abs(stretch) >= 2.0) {
    sb_clear();
    sb_f64(stretch, 1);
    sb_text("%");
    str_tag_sb();
  }
  emitRow();
}

export function reset(): void {
  sma.reset();
  value = NaN;
  close = NaN;
}