tradelab 1.0.1 → 1.2.0

package/src/ta/channels.js

@@ -0,0 +1,67 @@
+// src/ta/channels.js
+import { ema, atr } from "../utils/indicators.js";
+
+function rollingMean(values, period, i) {
+  let sum = 0;
+  for (let j = i - period + 1; j <= i; j += 1) sum += values[j];
+  return sum / period;
+}
+
+/**
+ * Bollinger Bands. `mult` standard deviations around the SMA middle band.
+ */
+export function bollinger(closes, period = 20, mult = 2) {
+  const middle = new Array(closes.length).fill(undefined);
+  const upper = new Array(closes.length).fill(undefined);
+  const lower = new Array(closes.length).fill(undefined);
+  for (let i = period - 1; i < closes.length; i += 1) {
+    const avg = rollingMean(closes, period, i);
+    let variance = 0;
+    for (let j = i - period + 1; j <= i; j += 1) variance += (closes[j] - avg) ** 2;
+    const sd = Math.sqrt(variance / period);
+    middle[i] = avg;
+    upper[i] = avg + mult * sd;
+    lower[i] = avg - mult * sd;
+  }
+  return { middle, upper, lower };
+}
+
+/**
+ * Donchian channel: rolling highest-high / lowest-low over `period` bars.
+ */
+export function donchian(bars, period = 20) {
+  const upper = new Array(bars.length).fill(undefined);
+  const lower = new Array(bars.length).fill(undefined);
+  const middle = new Array(bars.length).fill(undefined);
+  for (let i = period - 1; i < bars.length; i += 1) {
+    let hh = -Infinity;
+    let ll = Infinity;
+    for (let j = i - period + 1; j <= i; j += 1) {
+      if (bars[j].high > hh) hh = bars[j].high;
+      if (bars[j].low < ll) ll = bars[j].low;
+    }
+    upper[i] = hh;
+    lower[i] = ll;
+    middle[i] = (hh + ll) / 2;
+  }
+  return { upper, lower, middle };
+}
+
+/**
+ * Keltner channel: EMA middle, +/- mult * ATR width.
+ */
+export function keltner(bars, emaPeriod = 20, atrPeriod = 14, mult = 2) {
+  const closes = bars.map((b) => b.close);
+  const mid = ema(closes, emaPeriod);
+  const range = atr(bars, atrPeriod);
+  const upper = new Array(bars.length).fill(undefined);
+  const lower = new Array(bars.length).fill(undefined);
+  const middle = new Array(bars.length).fill(undefined);
+  for (let i = 0; i < bars.length; i += 1) {
+    if (range[i] === undefined) continue;
+    middle[i] = mid[i];
+    upper[i] = mid[i] + mult * range[i];
+    lower[i] = mid[i] - mult * range[i];
+  }
+  return { upper, lower, middle };
+}

package/src/ta/index.js

@@ -0,0 +1,16 @@
+// src/ta/index.js
+export {
+  ema,
+  atr,
+  swingHigh,
+  swingLow,
+  detectFVG,
+  lastSwing,
+  structureState,
+} from "../utils/indicators.js";
+
+export { rsi, macd, stochastic } from "./oscillators.js";
+
+export { bollinger, donchian, keltner } from "./channels.js";
+
+export { supertrend, vwap } from "./trend.js";

package/src/ta/oscillators.js

@@ -0,0 +1,70 @@
+// src/ta/oscillators.js
+import { ema } from "../utils/indicators.js";
+
+/**
+ * Wilder's RSI. Returns a full-length array; warmup positions are `undefined`.
+ */
+export function rsi(closes, period = 14) {
+  const out = new Array(closes.length).fill(undefined);
+  if (closes.length <= period) return out;
+
+  let gainSum = 0;
+  let lossSum = 0;
+  for (let i = 1; i <= period; i += 1) {
+    const change = closes[i] - closes[i - 1];
+    if (change >= 0) gainSum += change;
+    else lossSum -= change;
+  }
+  let avgGain = gainSum / period;
+  let avgLoss = lossSum / period;
+  out[period] = avgLoss === 0 ? 100 : 100 - 100 / (1 + avgGain / avgLoss);
+
+  for (let i = period + 1; i < closes.length; i += 1) {
+    const change = closes[i] - closes[i - 1];
+    const gain = change > 0 ? change : 0;
+    const loss = change < 0 ? -change : 0;
+    avgGain = (avgGain * (period - 1) + gain) / period;
+    avgLoss = (avgLoss * (period - 1) + loss) / period;
+    out[i] = avgLoss === 0 ? 100 : 100 - 100 / (1 + avgGain / avgLoss);
+  }
+  return out;
+}
+
+/**
+ * MACD line, signal line, histogram. All full-length, aligned to input.
+ */
+export function macd(closes, fast = 12, slow = 26, signalPeriod = 9) {
+  const emaFast = ema(closes, fast);
+  const emaSlow = ema(closes, slow);
+  const macdLine = closes.map((_, i) => emaFast[i] - emaSlow[i]);
+  const signalLine = ema(macdLine, signalPeriod);
+  const histogram = macdLine.map((v, i) => v - signalLine[i]);
+  return { macd: macdLine, signal: signalLine, histogram };
+}
+
+/**
+ * Stochastic oscillator %K (smoothed close position in the high-low range) and
+ * %D (SMA of %K). `bars` need { high, low, close }.
+ */
+export function stochastic(bars, kPeriod = 14, dPeriod = 3) {
+  const k = new Array(bars.length).fill(undefined);
+  for (let i = kPeriod - 1; i < bars.length; i += 1) {
+    let hh = -Infinity;
+    let ll = Infinity;
+    for (let j = i - kPeriod + 1; j <= i; j += 1) {
+      if (bars[j].high > hh) hh = bars[j].high;
+      if (bars[j].low < ll) ll = bars[j].low;
+    }
+    const range = hh - ll;
+    k[i] = range === 0 ? 0 : ((bars[i].close - ll) / range) * 100;
+  }
+
+  const d = new Array(bars.length).fill(undefined);
+  for (let i = 0; i < bars.length; i += 1) {
+    if (i < kPeriod - 1 + dPeriod - 1) continue;
+    let sum = 0;
+    for (let j = i - dPeriod + 1; j <= i; j += 1) sum += k[j];
+    d[i] = sum / dPeriod;
+  }
+  return { k, d };
+}

package/src/ta/trend.js

@@ -0,0 +1,78 @@
+// src/ta/trend.js
+import { atr } from "../utils/indicators.js";
+
+/**
+ * Supertrend. Returns { line, direction } full-length.
+ * direction: 1 = uptrend (line is support below price), -1 = downtrend.
+ */
+export function supertrend(bars, period = 10, mult = 3) {
+  const range = atr(bars, period);
+  const line = new Array(bars.length).fill(undefined);
+  const direction = new Array(bars.length).fill(undefined);
+
+  let prevUpper = Infinity;
+  let prevLower = -Infinity;
+  let prevDir = 1;
+
+  for (let i = 0; i < bars.length; i += 1) {
+    if (range[i] === undefined) continue;
+    const mid = (bars[i].high + bars[i].low) / 2;
+    const basicUpper = mid + mult * range[i];
+    const basicLower = mid - mult * range[i];
+    const close = bars[i].close;
+    const prevClose = i > 0 ? bars[i - 1].close : close;
+
+    const upper = basicUpper < prevUpper || prevClose > prevUpper ? basicUpper : prevUpper;
+    const lower = basicLower > prevLower || prevClose < prevLower ? basicLower : prevLower;
+
+    let dir = prevDir;
+    if (prevDir === 1 && close < lower) dir = -1;
+    else if (prevDir === -1 && close > upper) dir = 1;
+
+    line[i] = dir === 1 ? lower : upper;
+    direction[i] = dir;
+
+    prevUpper = upper;
+    prevLower = lower;
+    prevDir = dir;
+  }
+  return { line, direction };
+}
+
+function dayKeyUTC(timeMs) {
+  const d = new Date(timeMs);
+  return d.getUTCFullYear() * 10000 + (d.getUTCMonth() + 1) * 100 + d.getUTCDate();
+}
+
+/**
+ * Session VWAP, reset on each UTC calendar day. `bars` need
+ * { time, high, low, close, volume }. When volume is missing/zero, falls back
+ * to an unweighted cumulative typical-price average for that day.
+ */
+export function vwap(bars) {
+  const out = new Array(bars.length).fill(undefined);
+  let currentDay = null;
+  let cumPV = 0;
+  let cumV = 0;
+  let cumTP = 0;
+  let count = 0;
+
+  for (let i = 0; i < bars.length; i += 1) {
+    const day = dayKeyUTC(bars[i].time);
+    if (day !== currentDay) {
+      currentDay = day;
+      cumPV = 0;
+      cumV = 0;
+      cumTP = 0;
+      count = 0;
+    }
+    const tp = (bars[i].high + bars[i].low + bars[i].close) / 3;
+    const vol = Number.isFinite(bars[i].volume) ? bars[i].volume : 0;
+    cumPV += tp * vol;
+    cumV += vol;
+    cumTP += tp;
+    count += 1;
+    out[i] = cumV > 0 ? cumPV / cumV : cumTP / count;
+  }
+  return out;
+}

package/src/utils/random.js

@@ -0,0 +1,33 @@
+function xmur3(str) {
+  let h = 1779033703 ^ str.length;
+  for (let i = 0; i < str.length; i += 1) {
+    h = Math.imul(h ^ str.charCodeAt(i), 3432918353);
+    h = (h << 13) | (h >>> 19);
+  }
+  return () => {
+    h = Math.imul(h ^ (h >>> 16), 2246822507);
+    h = Math.imul(h ^ (h >>> 13), 3266489909);
+    return (h ^= h >>> 16) >>> 0;
+  };
+}
+
+function mulberry32(seed) {
+  let state = seed >>> 0;
+  return () => {
+    state = (state + 0x6d2b79f5) >>> 0;
+    let t = Math.imul(state ^ (state >>> 15), state | 1);
+    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+  };
+}
+
+/** Returns a deterministic () => float-in-[0,1) generator seeded by `seed`. */
+export function makeRng(seed = "tradelab") {
+  const seedFn = xmur3(String(seed));
+  return mulberry32(seedFn());
+}
+
+/** Integer in [0, maxExclusive) from an rng produced by makeRng. */
+export function randInt(rng, maxExclusive) {
+  return Math.floor(rng() * maxExclusive);
+}