Streaming Technical Indicators

Sponsored by Backticks — a visual canvas to build, backtest and optimize trading strategies in your browser. Built on top of this library.

A streaming, allocation-light technical-analysis toolkit for JavaScript / TypeScript. Every indicator is a class with a nextValue(...) method that consumes one bar at a time, so the same code path drives both backtests and live trading without rebuilding state. A second method, momentValue(...), computes the indicator's value for a hypothetical bar without committing any state — useful for tick-by-tick recalculation inside an unfinished candle.

Features

• Streaming-first. O(period) per bar; no full-array recomputation.
• momentValue everywhere. Ask "what would the value be if this bar closed now?" without mutating state.
• TypeScript. Strongly-typed across the public surface.
• Cross-SDK validated. 130+ jest tests cross-check our output against external reference libraries (lwc and ti) with epsilon ≤ 1e-9. See the Test column in the indicator tables below for which oracle each one is verified against.
• Tiny package. Ships only the prebuilt lib/ bundle — ~85 kB tarball.

Install

npm install @debut/indicators

Quick start

import { SMA, RSI, MACD, BollingerBands } from '@debut/indicators';

const sma = new SMA(20);
const rsi = new RSI(14);
const macd = new MACD(12, 26, 9);
const bb = new BollingerBands(20, 2);

for (const bar of bars) {
    const sm = sma.nextValue(bar.close);
    const r = rsi.nextValue(bar.close);
    const m = macd.nextValue(bar.close);   // → { macd, signal, histogram }
    const b = bb.nextValue(bar.close);     // → { lower, middle, upper }
    // ...indicator outputs are `undefined` until each one's warmup completes.
}

nextValue returns undefined until the indicator has seen enough bars to produce a result (its "warmup" — typically period bars). After that it returns the current value on every call.

Streaming model

nextValue(...) — close-of-bar

Call this once per closed bar. The method advances internal state and returns the new indicator value. Subsequent calls reflect the committed state.

momentValue(...) — intra-bar

Call this with the live (still-forming) candle's price/volume to read what the indicator would report if the bar closed now, without committing any state. Useful when you want to react inside the candle but recompute cleanly when the next real nextValue arrives.

const sma = new SMA(4);
[1, 2, 3].forEach((v) => sma.nextValue(v));   // warmup
sma.momentValue(8);   // 3.5  ← preview if close=8
sma.nextValue(4);     // 2.5  ← actual close=4 commits state
sma.momentValue(8);   // 4.75 ← preview based on committed state
sma.nextValue(8);     // 4.25 ← actual close=8 commits state

Available indicators

Below is the full catalog grouped by category. Names in code style are the exact named export from @debut/indicators. Linkable indicator names lead to a per-indicator doc page in docs/. The Test column marks which external library the cross-SDK validation runs against — `lwc` = lightweight-charts-indicators, `ti` = technicalindicators (see Cross-SDK validation for what that means).

Moving Averages

Oscillators

Momentum

Trend

Volatility

Channels & Bands

Volume

Candles & Pivots

Move / Wave (custom)

Runtime state save & restore

Every stateful indicator exposes two methods:

• dumpState() returns a JSON-safe snapshot of all internal runtime state.
• restoreState(state) restores that snapshot into a new indicator instance and returns the instance.

The snapshot includes nested providers and rolling buffers such as CircularBuffer, so an indicator can continue after a process restart without replaying the full history. Constructor parameters are still part of the indicator configuration: restore state into an instance created with the same period/options that produced the snapshot.

import { EMA } from '@debut/indicators';

const ema = new EMA(20);

for (const close of history) {
    ema.nextValue(close);
}

// Persist this string in your own runtime storage: database, file, Redis, etc.
const serialized = JSON.stringify(ema.dumpState());

// Later, after a restart:
const restored = new EMA(20).restoreState(JSON.parse(serialized));

const liveValue = restored.nextValue(nextClose);

For live systems, save the state after committing each closed bar, together with the indicator configuration and stream identity. On startup, recreate each indicator with the same constructor arguments, call restoreState(...), then continue feeding new bars through nextValue(...).

Candlestick Patterns

Each is a streaming class:

import { Doji, BullishEngulfingPattern, HammerPattern } from '@debut/indicators';

const doji = new Doji();
const engulfing = new BullishEngulfingPattern();
const hammer = new HammerPattern();   // 5-bar with confirmation candle

for (const bar of bars) {
    if (doji.nextValue(bar.open, bar.high, bar.low, bar.close)) console.log('Doji', bar.time);
    if (engulfing.nextValue(bar.open, bar.high, bar.low, bar.close)) console.log('Bull Engulfing', bar.time);
    if (hammer.nextValue(bar.open, bar.high, bar.low, bar.close)) console.log('Hammer', bar.time);
}

nextValue returns true when the pattern fires, false if not, and undefined while it's still warming up (multi-bar patterns need their full lookback first).

Configurable thresholds

Each pattern accepts an options bag in its constructor. The defaults match the ti reference exactly; tighten or loosen them as you see fit.

const wideDoji = new Doji({ precision: 0.005 });           // 0.5% relative tolerance
const fastHammer = new HammerPattern({ confirm: false });  // skip the confirmation candle
const looseTweezer = new TweezerBottom({ equalityTolerance: 0.0001 });

Combined scanners

If you want to scan a bar against many patterns at once, use one of the three combined scanners. They share the singleton OhlcBuffer declared inside the patterns module so you don't pay for per-pattern buffers.

import { AllCandlestickPatterns, BullishPatterns, BearishPatterns } from '@debut/indicators';

const all = new AllCandlestickPatterns();
const bull = new BullishPatterns();
const bear = new BearishPatterns();

for (const bar of bars) {
    const fired = all.nextValue(bar.open, bar.high, bar.low, bar.close);
    if (fired.length) console.log(bar.time, fired);
    // → e.g. [1700000000, ['BullishHammerStick', 'BullishMarubozu']]

    if (bull.nextValue(bar.open, bar.high, bar.low, bar.close)) console.log('any bullish');
    if (bear.nextValue(bar.open, bar.high, bar.low, bar.close)) console.log('any bearish');
}

AllCandlestickPatterns.nextValue returns the array of pattern names that fired on the bar; BullishPatterns / BearishPatterns return a single boolean ("did any pattern fire").

Singleton buffer & resetting between streams

All multi-bar patterns share one OhlcBuffer(5) declared at module scope in src/candlestick/patterns.ts. The first pattern that sees a brand-new bar advances the buffer; later calls within the same tick are dedup'd by OHLC equality. This means dropping in a fresh pattern instance is essentially free — there's no per-pattern ring allocation.

If you switch between independent bar streams (or want a clean slate between test cases), call BasePattern.reset():

import { BasePattern } from '@debut/indicators/lib/src/candlestick/patterns';

BasePattern.reset(); // clears the singleton OHLC ring + dedupe state

Namespaced import

If you'd rather not pull 35 symbols into scope:

import { Candlestick } from '@debut/indicators';

const doji = new Candlestick.Doji();
const all = new Candlestick.AllCandlestickPatterns();

Pattern catalog

Session Volume Profile

VolumeProfile aggregates traded volume across price rows and exposes POC, VAH / VAL with configurable tickSize, distribution, and session anchoring ('daily' by default — unbounded streams can't grow the row map forever).

import { VolumeProfile } from '@debut/indicators';
const vp = new VolumeProfile({ tickSize: 0.5 });
for (const bar of bars) {
    const { poc, val, vah, total } = vp.nextValue(bar);
}

Full options, formula, performance notes, and custom-session recipe: docs/VolumeProfile.md.

Utilities

Cross-SDK validation

Every ported indicator and candlestick pattern has a vitest-style spec in tests/<name>/<name>.spec.ts that:

1. Generates deterministic synthetic OHLCV bars with a seeded LCG (see tests/lwc-fixtures.ts).
2. Runs them through the streaming @debut/indicators class.
3. Runs the same bars through the corresponding lwc calculate() (or ti for the older specs) — see the Test column in each indicator table for which oracle that pattern is matched against.
4. Asserts numeric equality with epsilon ≤ 1e-9 (or set membership for boolean pattern firings).

Run npm test to execute the full suite.

Benchmarks

Apple M1 Pro, Node v16.14.0. Tested on dataset with 100k elements.

Benchmarks results is autogenerated by https://github.com/debut-js/indicators-benchmark

License

GPL-3.0