ta-crypto 0.1.5 → 0.3.0

package/dist/api.js

@@ -0,0 +1,241 @@
+import { assertFiniteSeries } from "./core/math.js";
+import { normalizePrice, toOHLCV } from "./candles.js";
+import { sma as coreSma, ema as coreEma, rma as coreRma, hl2 as coreHl2, hlc3 as coreHlc3, ohlc4 as coreOhlc4, vwap as coreVwap, bbands as coreBbands } from "./core/overlap.js";
+import { rsi as coreRsi, macd as coreMacd, stoch as coreStoch } from "./core/momentum.js";
+import { trueRange as coreTrueRange, atr as coreAtr, natr as coreNatr } from "./core/volatility.js";
+import { logReturn as coreLogReturn, percentReturn as corePercentReturn, realizedVolatility as coreRealizedVolatility } from "./core/performance.js";
+import { obv as coreObv, mfi as coreMfi } from "./core/volume.js";
+import { adx as coreAdx } from "./core/trend.js";
+import { vwapSession as coreVwapSession, fundingRateCumulative as coreFundingRateCumulative, fundingRateAPR as coreFundingRateAPR, volatilityRegime as coreVolatilityRegime, signedVolume as coreSignedVolume, volumeDelta as coreVolumeDelta, orderflowImbalance as coreOrderflowImbalance } from "./core/crypto.js";
+function isNumericArray(input) {
+    return Array.isArray(input) && (input.length === 0 || typeof input[0] === "number");
+}
+function parseHLC(input, low, close) {
+    if (isNumericArray(input)) {
+        if (!low || !close) {
+            throw new Error("Expected high, low, close arrays or candles/OHLCV object input");
+        }
+        assertFiniteSeries("high", input);
+        assertFiniteSeries("low", low);
+        assertFiniteSeries("close", close);
+        return { high: input, low, close };
+    }
+    return toOHLCV(input);
+}
+function parseOHLC(input, high, low, close) {
+    if (isNumericArray(input)) {
+        if (!high || !low || !close) {
+            throw new Error("Expected open, high, low, close arrays or candles/OHLCV object input");
+        }
+        assertFiniteSeries("open", input);
+        assertFiniteSeries("high", high);
+        assertFiniteSeries("low", low);
+        assertFiniteSeries("close", close);
+        return { open: input, high, low, close };
+    }
+    return toOHLCV(input);
+}
+function parseHLCV(input, low, close, volume) {
+    if (isNumericArray(input)) {
+        if (!low || !close || !volume) {
+            throw new Error("Expected high, low, close, volume arrays or candles/OHLCV object input");
+        }
+        assertFiniteSeries("high", input);
+        assertFiniteSeries("low", low);
+        assertFiniteSeries("close", close);
+        assertFiniteSeries("volume", volume);
+        return { high: input, low, close, volume };
+    }
+    return toOHLCV(input);
+}
+function parseOCV(input, close, volume) {
+    if (isNumericArray(input)) {
+        if (!close || !volume) {
+            throw new Error("Expected open, close, volume arrays or candles/OHLCV object input");
+        }
+        assertFiniteSeries("open", input);
+        assertFiniteSeries("close", close);
+        assertFiniteSeries("volume", volume);
+        return { open: input, close, volume };
+    }
+    return toOHLCV(input);
+}
+export function sma(input, length = 14) {
+    return coreSma(normalizePrice(input), length);
+}
+export function ema(input, length = 14) {
+    return coreEma(normalizePrice(input), length);
+}
+export function rma(input, length = 14) {
+    return coreRma(normalizePrice(input), length);
+}
+export function bbands(input, length = 20, std = 2) {
+    return coreBbands(normalizePrice(input), length, std);
+}
+export function macd(input, fast = 12, slow = 26, signal = 9) {
+    return coreMacd(normalizePrice(input), fast, slow, signal);
+}
+export function rsi(input, length = 14) {
+    return coreRsi(normalizePrice(input), length);
+}
+export function logReturn(input, cumulative = false) {
+    return coreLogReturn(normalizePrice(input), cumulative);
+}
+export function percentReturn(input, cumulative = false) {
+    return corePercentReturn(normalizePrice(input), cumulative);
+}
+export function realizedVolatility(input, length = 30, periodsPerYear = 365) {
+    return coreRealizedVolatility(normalizePrice(input), length, periodsPerYear);
+}
+export function hl2(input, low) {
+    if (isNumericArray(input)) {
+        if (!low)
+            throw new Error("Expected high + low arrays or candles/OHLCV object input");
+        return coreHl2(input, low);
+    }
+    const ohlcv = toOHLCV(input);
+    return coreHl2(ohlcv.high, ohlcv.low);
+}
+export function hlc3(input, low, close) {
+    const ohlcv = parseHLC(input, low, close);
+    return coreHlc3(ohlcv.high, ohlcv.low, ohlcv.close);
+}
+export function ohlc4(input, high, low, close) {
+    const ohlcv = parseOHLC(input, high, low, close);
+    return coreOhlc4(ohlcv.open, ohlcv.high, ohlcv.low, ohlcv.close);
+}
+export function vwap(input, lowOrLength, close, volume, length) {
+    if (isNumericArray(input)) {
+        const low = Array.isArray(lowOrLength) ? lowOrLength : undefined;
+        const resolvedLength = typeof lowOrLength === "number" ? lowOrLength : length;
+        const ohlcv = parseHLCV(input, low, close, volume);
+        return coreVwap(ohlcv.high, ohlcv.low, ohlcv.close, ohlcv.volume, resolvedLength);
+    }
+    const ohlcv = toOHLCV(input);
+    const resolvedLength = typeof lowOrLength === "number" ? lowOrLength : length;
+    return coreVwap(ohlcv.high, ohlcv.low, ohlcv.close, ohlcv.volume, resolvedLength);
+}
+export function stoch(input, lowOrKLength, closeOrDLength, kLength = 14, dLength = 3) {
+    if (isNumericArray(input)) {
+        const low = Array.isArray(lowOrKLength) ? lowOrKLength : undefined;
+        const close = Array.isArray(closeOrDLength) ? closeOrDLength : undefined;
+        const resolvedK = typeof lowOrKLength === "number" ? lowOrKLength : kLength;
+        const resolvedD = typeof closeOrDLength === "number" ? closeOrDLength : dLength;
+        const ohlcv = parseHLC(input, low, close);
+        return coreStoch(ohlcv.high, ohlcv.low, ohlcv.close, resolvedK, resolvedD);
+    }
+    const resolvedK = typeof lowOrKLength === "number" ? lowOrKLength : kLength;
+    const resolvedD = typeof closeOrDLength === "number" ? closeOrDLength : dLength;
+    const ohlcv = toOHLCV(input);
+    return coreStoch(ohlcv.high, ohlcv.low, ohlcv.close, resolvedK, resolvedD);
+}
+export function trueRange(input, low, close) {
+    const ohlcv = parseHLC(input, low, close);
+    return coreTrueRange(ohlcv.high, ohlcv.low, ohlcv.close);
+}
+export function atr(input, lowOrLength, close, length = 14) {
+    if (isNumericArray(input)) {
+        const low = Array.isArray(lowOrLength) ? lowOrLength : undefined;
+        const resolvedLength = typeof lowOrLength === "number" ? lowOrLength : length;
+        const ohlcv = parseHLC(input, low, close);
+        return coreAtr(ohlcv.high, ohlcv.low, ohlcv.close, resolvedLength);
+    }
+    const ohlcv = toOHLCV(input);
+    const resolvedLength = typeof lowOrLength === "number" ? lowOrLength : length;
+    return coreAtr(ohlcv.high, ohlcv.low, ohlcv.close, resolvedLength);
+}
+export function natr(input, lowOrLength, close, length = 14) {
+    if (isNumericArray(input)) {
+        const low = Array.isArray(lowOrLength) ? lowOrLength : undefined;
+        const resolvedLength = typeof lowOrLength === "number" ? lowOrLength : length;
+        const ohlcv = parseHLC(input, low, close);
+        return coreNatr(ohlcv.high, ohlcv.low, ohlcv.close, resolvedLength);
+    }
+    const ohlcv = toOHLCV(input);
+    const resolvedLength = typeof lowOrLength === "number" ? lowOrLength : length;
+    return coreNatr(ohlcv.high, ohlcv.low, ohlcv.close, resolvedLength);
+}
+export function obv(input, volume) {
+    if (isNumericArray(input)) {
+        if (!volume)
+            throw new Error("Expected close + volume arrays or candles/OHLCV object input");
+        return coreObv(input, volume);
+    }
+    const ohlcv = toOHLCV(input);
+    return coreObv(ohlcv.close, ohlcv.volume);
+}
+export function mfi(input, lowOrLength, close, volume, length = 14) {
+    if (isNumericArray(input)) {
+        const low = Array.isArray(lowOrLength) ? lowOrLength : undefined;
+        const resolvedLength = typeof lowOrLength === "number" ? lowOrLength : length;
+        const ohlcv = parseHLCV(input, low, close, volume);
+        return coreMfi(ohlcv.high, ohlcv.low, ohlcv.close, ohlcv.volume, resolvedLength);
+    }
+    const ohlcv = toOHLCV(input);
+    const resolvedLength = typeof lowOrLength === "number" ? lowOrLength : length;
+    return coreMfi(ohlcv.high, ohlcv.low, ohlcv.close, ohlcv.volume, resolvedLength);
+}
+export function adx(input, lowOrLength, close, length = 14) {
+    if (isNumericArray(input)) {
+        const low = Array.isArray(lowOrLength) ? lowOrLength : undefined;
+        const resolvedLength = typeof lowOrLength === "number" ? lowOrLength : length;
+        const ohlcv = parseHLC(input, low, close);
+        return coreAdx(ohlcv.high, ohlcv.low, ohlcv.close, resolvedLength);
+    }
+    const ohlcv = toOHLCV(input);
+    const resolvedLength = typeof lowOrLength === "number" ? lowOrLength : length;
+    return coreAdx(ohlcv.high, ohlcv.low, ohlcv.close, resolvedLength);
+}
+export function vwapSession(input, lowOrSession, close, volume, session) {
+    if (isNumericArray(input)) {
+        if (!isNumericArray(lowOrSession)) {
+            throw new Error("Expected high, low, close, volume, session arrays");
+        }
+        if (!session || !close || !volume) {
+            throw new Error("Expected high, low, close, volume, session arrays");
+        }
+        return coreVwapSession(input, lowOrSession, close, volume, session);
+    }
+    if (!Array.isArray(lowOrSession)) {
+        throw new Error("session must be an array");
+    }
+    const ohlcv = toOHLCV(input);
+    return coreVwapSession(ohlcv.high, ohlcv.low, ohlcv.close, ohlcv.volume, lowOrSession);
+}
+export function signedVolume(input, close, volume) {
+    const ohlcv = parseOCV(input, close, volume);
+    return coreSignedVolume(ohlcv.open, ohlcv.close, ohlcv.volume);
+}
+export function volumeDelta(input, closeOrLength, volume, length = 14) {
+    if (isNumericArray(input)) {
+        const close = Array.isArray(closeOrLength) ? closeOrLength : undefined;
+        const resolvedLength = typeof closeOrLength === "number" ? closeOrLength : length;
+        const ohlcv = parseOCV(input, close, volume);
+        return coreVolumeDelta(ohlcv.open, ohlcv.close, ohlcv.volume, resolvedLength);
+    }
+    const ohlcv = toOHLCV(input);
+    const resolvedLength = typeof closeOrLength === "number" ? closeOrLength : length;
+    return coreVolumeDelta(ohlcv.open, ohlcv.close, ohlcv.volume, resolvedLength);
+}
+export function orderflowImbalance(input, closeOrLength, volume, length = 14) {
+    if (isNumericArray(input)) {
+        const close = Array.isArray(closeOrLength) ? closeOrLength : undefined;
+        const resolvedLength = typeof closeOrLength === "number" ? closeOrLength : length;
+        const ohlcv = parseOCV(input, close, volume);
+        return coreOrderflowImbalance(ohlcv.open, ohlcv.close, ohlcv.volume, resolvedLength);
+    }
+    const ohlcv = toOHLCV(input);
+    const resolvedLength = typeof closeOrLength === "number" ? closeOrLength : length;
+    return coreOrderflowImbalance(ohlcv.open, ohlcv.close, ohlcv.volume, resolvedLength);
+}
+export function fundingRateCumulative(values) {
+    assertFiniteSeries("values", values);
+    return coreFundingRateCumulative(values);
+}
+export function fundingRateAPR(values, periodsPerYear = 365 * 3) {
+    assertFiniteSeries("values", values);
+    return coreFundingRateAPR(values, periodsPerYear);
+}
+export function volatilityRegime(input, length = 30, periodsPerYear = 365, lowZ = -0.5, highZ = 0.5) {
+    return coreVolatilityRegime(normalizePrice(input), length, periodsPerYear, lowZ, highZ);
+}

package/dist/candles.d.ts

@@ -0,0 +1,9 @@
+import type { Candle, OHLCV, OHLCVInput, PriceInput } from "./types.js";
+export declare function isCandleArray(input: PriceInput | OHLCVInput): input is Candle[];
+export declare function normalizePrice(input: PriceInput, name?: string): number[];
+export declare function pluckOpen(candles: Candle[]): number[];
+export declare function pluckHigh(candles: Candle[]): number[];
+export declare function pluckLow(candles: Candle[]): number[];
+export declare function pluckClose(candles: Candle[]): number[];
+export declare function pluckVolume(candles: Candle[], fallback?: number): number[];
+export declare function toOHLCV(input: Candle[] | OHLCVInput, volumeFallback?: number): OHLCV;

package/dist/candles.js

@@ -0,0 +1,98 @@
+import { assertFiniteSeries, assertSameLength, isNum } from "./core/math.js";
+function readField(candle, index, name, alias) {
+    const value = candle[name] ?? candle[alias];
+    if (!isNum(value)) {
+        throw new Error(`candles[${index}].${name} (or .${alias}) must be a finite number`);
+    }
+    return value;
+}
+function readTime(candle) {
+    const value = candle.time ?? candle.t;
+    return value;
+}
+function hasOHLCVArrays(input) {
+    return "open" in input && "high" in input && "low" in input && "close" in input;
+}
+export function isCandleArray(input) {
+    return Array.isArray(input) && input.length > 0 && typeof input[0] !== "number";
+}
+export function normalizePrice(input, name = "values") {
+    if (Array.isArray(input) && (input.length === 0 || typeof input[0] === "number")) {
+        assertFiniteSeries(name, input);
+        return input;
+    }
+    return pluckClose(input);
+}
+export function pluckOpen(candles) {
+    const out = candles.map((candle, index) => readField(candle, index, "open", "o"));
+    assertFiniteSeries("open", out);
+    return out;
+}
+export function pluckHigh(candles) {
+    const out = candles.map((candle, index) => readField(candle, index, "high", "h"));
+    assertFiniteSeries("high", out);
+    return out;
+}
+export function pluckLow(candles) {
+    const out = candles.map((candle, index) => readField(candle, index, "low", "l"));
+    assertFiniteSeries("low", out);
+    return out;
+}
+export function pluckClose(candles) {
+    const out = candles.map((candle, index) => readField(candle, index, "close", "c"));
+    assertFiniteSeries("close", out);
+    return out;
+}
+export function pluckVolume(candles, fallback = 0) {
+    if (!isNum(fallback)) {
+        throw new Error("volumeFallback must be a finite number");
+    }
+    const out = candles.map((candle, index) => {
+        const value = candle.volume ?? candle.v;
+        const normalized = value === undefined ? fallback : value;
+        if (!isNum(normalized)) {
+            throw new Error(`candles[${index}].volume (or .v) must be a finite number`);
+        }
+        return normalized;
+    });
+    assertFiniteSeries("volume", out);
+    return out;
+}
+export function toOHLCV(input, volumeFallback = 0) {
+    if (Array.isArray(input)) {
+        return {
+            open: pluckOpen(input),
+            high: pluckHigh(input),
+            low: pluckLow(input),
+            close: pluckClose(input),
+            volume: pluckVolume(input, volumeFallback),
+            time: input.map(c => readTime(c))
+        };
+    }
+    if (hasOHLCVArrays(input)) {
+        assertFiniteSeries("open", input.open);
+        assertFiniteSeries("high", input.high);
+        assertFiniteSeries("low", input.low);
+        assertFiniteSeries("close", input.close);
+        const volume = input.volume ?? new Array(input.close.length).fill(volumeFallback);
+        assertFiniteSeries("volume", volume);
+        assertSameLength(input.open, input.high, input.low, input.close, volume);
+        const time = input.time ?? new Array(input.close.length).fill(undefined);
+        if (time.length !== input.close.length) {
+            throw new Error(`All series must have the same length (expected ${input.close.length}, got ${time.length})`);
+        }
+        return { open: input.open, high: input.high, low: input.low, close: input.close, volume, time };
+    }
+    assertFiniteSeries("open", input.o);
+    assertFiniteSeries("high", input.h);
+    assertFiniteSeries("low", input.l);
+    assertFiniteSeries("close", input.c);
+    const volume = input.v ?? new Array(input.c.length).fill(volumeFallback);
+    assertFiniteSeries("volume", volume);
+    assertSameLength(input.o, input.h, input.l, input.c, volume);
+    const time = input.t ?? new Array(input.c.length).fill(undefined);
+    if (time.length !== input.c.length) {
+        throw new Error(`All series must have the same length (expected ${input.c.length}, got ${time.length})`);
+    }
+    return { open: input.o, high: input.h, low: input.l, close: input.c, volume, time };
+}

package/dist/core/math.d.ts

@@ -1,4 +1,5 @@
 export declare function isNum(value: unknown): value is number;
+export declare function assertFiniteSeries(name: string, values: number[]): void;
 export declare function assertSameLength(...series: number[][]): void;
 export declare function makeSeries(length: number): Array<number | null>;
 export declare function sum(values: number[], start: number, end: number): number;

package/dist/core/math.js

@@ -1,13 +1,20 @@
 export function isNum(value) {
     return typeof value === "number" && Number.isFinite(value);
 }
+export function assertFiniteSeries(name, values) {
+    for (let i = 0; i < values.length; i++) {
+        if (!isNum(values[i])) {
+            throw new Error(`${name}[${i}] must be a finite number`);
+        }
+    }
+}
 export function assertSameLength(...series) {
     if (series.length === 0)
         return;
     const len = series[0].length;
     for (const s of series) {
         if (s.length !== len) {
-            throw new Error("All series must have the same length");
+            throw new Error(`All series must have the same length (expected ${len}, got ${s.length})`);
         }
     }
 }

package/dist/core/momentum.js

@@ -1,4 +1,4 @@
-import { makeSeries } from "./math.js";
+import { assertSameLength, makeSeries } from "./math.js";
 import { ema } from "./overlap.js";
 export function macd(values, fast = 12, slow = 26, signal = 9) {
     const fastEma = ema(values, fast);
@@ -47,10 +47,8 @@ export function rsi(values, length = 14) {
     return out;
 }
 export function stoch(high, low, close, kLength = 14, dLength = 3) {
+    assertSameLength(high, low, close);
     const len = close.length;
-    if (high.length !== len || low.length !== len) {
-        throw new Error("All series must have the same length");
-    }
     const k = makeSeries(len);
     const d = makeSeries(len);
     for (let i = kLength - 1; i < len; i++) {

package/dist/core/trend.js

@@ -1,11 +1,9 @@
-import { makeSeries } from "./math.js";
+import { assertSameLength, makeSeries } from "./math.js";
 import { rma } from "./overlap.js";
 import { trueRange } from "./volatility.js";
 export function adx(high, low, close, length = 14) {
+    assertSameLength(high, low, close);
     const len = close.length;
-    if (high.length !== len || low.length !== len) {
-        throw new Error("All series must have the same length");
-    }
     const plusDM = new Array(len).fill(0);
     const minusDM = new Array(len).fill(0);
     for (let i = 1; i < len; i++) {

package/dist/core/volume.js

@@ -1,8 +1,6 @@
-import { makeSeries } from "./math.js";
+import { assertSameLength, makeSeries } from "./math.js";
 export function obv(close, volume) {
-    if (close.length !== volume.length) {
-        throw new Error("All series must have the same length");
-    }
+    assertSameLength(close, volume);
     const out = makeSeries(close.length);
     let acc = 0;
     for (let i = 0; i < close.length; i++) {
@@ -19,10 +17,8 @@ export function obv(close, volume) {
     return out;
 }
 export function mfi(high, low, close, volume, length = 14) {
+    assertSameLength(high, low, close, volume);
     const len = close.length;
-    if (high.length !== len || low.length !== len || volume.length !== len) {
-        throw new Error("All series must have the same length");
-    }
     const out = makeSeries(len);
     if (length <= 0)
         return out;

package/dist/crypto.d.ts

@@ -0,0 +1,2 @@
+export { vwapSession, fundingRateCumulative, fundingRateAPR, volatilityRegime, signedVolume, volumeDelta, orderflowImbalance } from "./api.js";
+export { createVWAPSession } from "./stateful.js";

package/dist/crypto.js

@@ -0,0 +1,2 @@
+export { vwapSession, fundingRateCumulative, fundingRateAPR, volatilityRegime, signedVolume, volumeDelta, orderflowImbalance } from "./api.js";
+export { createVWAPSession } from "./stateful.js";

package/dist/index.d.ts

@@ -1,52 +1,83 @@
-export { sma, ema, rma, hl2, hlc3, ohlc4, vwap, bbands } from "./core/overlap.js";
-export { rsi, macd, stoch } from "./core/momentum.js";
-export { trueRange, atr, natr } from "./core/volatility.js";
-export { logReturn, percentReturn, realizedVolatility } from "./core/performance.js";
-export { obv, mfi } from "./core/volume.js";
-export { adx } from "./core/trend.js";
-export { vwapSession, fundingRateCumulative, fundingRateAPR, volatilityRegime, signedVolume, volumeDelta, orderflowImbalance } from "./core/crypto.js";
+export { sma, ema, rma, hl2, hlc3, ohlc4, vwap, bbands, rsi, macd, stoch, trueRange, atr, natr, logReturn, percentReturn, realizedVolatility, obv, mfi, adx, vwapSession, fundingRateCumulative, fundingRateAPR, volatilityRegime, signedVolume, volumeDelta, orderflowImbalance } from "./api.js";
+export { pluckOpen, pluckHigh, pluckLow, pluckClose, pluckVolume, toOHLCV } from "./candles.js";
+export { createSMA, createEMA, createRSI, createVWAPSession } from "./stateful.js";
 export * from "./types.js";
+import * as stateful from "./stateful.js";
 export declare const ta: {
-    vwapSession(high: number[], low: number[], close: number[], volume: number[], session: Array<string | number>): Array<number | null>;
-    fundingRateCumulative(values: number[]): Array<number | null>;
-    fundingRateAPR(values: number[], periodsPerYear?: number): Array<number | null>;
-    volatilityRegime(values: number[], length?: number, periodsPerYear?: number, lowZ?: number, highZ?: number): Array<number | null>;
-    signedVolume(open: number[], close: number[], volume: number[]): Array<number | null>;
-    volumeDelta(open: number[], close: number[], volume: number[], length?: number): Array<number | null>;
-    orderflowImbalance(open: number[], close: number[], volume: number[], length?: number): Array<number | null>;
-    adx(high: number[], low: number[], close: number[], length?: number): {
-        adx: (number | null)[];
-        plusDI: (number | null)[];
-        minusDI: (number | null)[];
+    createSMA(period?: number): stateful.StatefulIndicator<number, number | null>;
+    createEMA(period?: number): stateful.StatefulIndicator<number, number | null>;
+    createRSI(period?: number): stateful.StatefulIndicator<number, number | null>;
+    createVWAPSession(): stateful.StatefulIndicator<stateful.VWAPSessionInput, number | null>;
+    isCandleArray(input: import("./types.js").PriceInput | import("./types.js").OHLCVInput): input is import("./types.js").Candle[];
+    normalizePrice(input: import("./types.js").PriceInput, name?: string): number[];
+    pluckOpen(candles: import("./types.js").Candle[]): number[];
+    pluckHigh(candles: import("./types.js").Candle[]): number[];
+    pluckLow(candles: import("./types.js").Candle[]): number[];
+    pluckClose(candles: import("./types.js").Candle[]): number[];
+    pluckVolume(candles: import("./types.js").Candle[], fallback?: number): number[];
+    toOHLCV(input: import("./types.js").Candle[] | import("./types.js").OHLCVInput, volumeFallback?: number): import("./types.js").OHLCV;
+    sma(input: import("./types.js").PriceInput, length?: number): Array<number | null>;
+    ema(input: import("./types.js").PriceInput, length?: number): Array<number | null>;
+    rma(input: import("./types.js").PriceInput, length?: number): Array<number | null>;
+    bbands(input: import("./types.js").PriceInput, length?: number, std?: number): {
+        basis: (number | null)[];
+        upper: (number | null)[];
+        lower: (number | null)[];
     };
-    obv(close: number[], volume: number[]): Array<number | null>;
-    mfi(high: number[], low: number[], close: number[], volume: number[], length?: number): Array<number | null>;
-    logReturn(values: number[], cumulative?: boolean): Array<number | null>;
-    percentReturn(values: number[], cumulative?: boolean): Array<number | null>;
-    realizedVolatility(values: number[], length?: number, periodsPerYear?: number): Array<number | null>;
-    trueRange(high: number[], low: number[], close: number[]): Array<number | null>;
-    atr(high: number[], low: number[], close: number[], length?: number): Array<number | null>;
-    natr(high: number[], low: number[], close: number[], length?: number): Array<number | null>;
-    macd(values: number[], fast?: number, slow?: number, signal?: number): {
+    macd(input: import("./types.js").PriceInput, fast?: number, slow?: number, signal?: number): {
         macd: (number | null)[];
         signal: (number | null)[];
         histogram: (number | null)[];
     };
-    rsi(values: number[], length?: number): Array<number | null>;
-    stoch(high: number[], low: number[], close: number[], kLength?: number, dLength?: number): {
-        k: (number | null)[];
-        d: (number | null)[];
-    };
-    sma(values: number[], length?: number): Array<number | null>;
-    ema(values: number[], length?: number): Array<number | null>;
-    rma(values: number[], length?: number): Array<number | null>;
+    rsi(input: import("./types.js").PriceInput, length?: number): Array<number | null>;
+    logReturn(input: import("./types.js").PriceInput, cumulative?: boolean): Array<number | null>;
+    percentReturn(input: import("./types.js").PriceInput, cumulative?: boolean): Array<number | null>;
+    realizedVolatility(input: import("./types.js").PriceInput, length?: number, periodsPerYear?: number): Array<number | null>;
     hl2(high: number[], low: number[]): Array<number | null>;
+    hl2(input: import("./types.js").OHLCVInput | import("./types.js").Candle[]): Array<number | null>;
     hlc3(high: number[], low: number[], close: number[]): Array<number | null>;
+    hlc3(input: import("./types.js").OHLCVInput | import("./types.js").Candle[]): Array<number | null>;
     ohlc4(open: number[], high: number[], low: number[], close: number[]): Array<number | null>;
+    ohlc4(input: import("./types.js").OHLCVInput | import("./types.js").Candle[]): Array<number | null>;
     vwap(high: number[], low: number[], close: number[], volume: number[], length?: number): Array<number | null>;
-    bbands(values: number[], length?: number, std?: number): {
-        basis: (number | null)[];
-        upper: (number | null)[];
-        lower: (number | null)[];
+    vwap(input: import("./types.js").OHLCVInput | import("./types.js").Candle[], length?: number): Array<number | null>;
+    stoch(high: number[], low: number[], close: number[], kLength?: number, dLength?: number): {
+        k: Array<number | null>;
+        d: Array<number | null>;
+    };
+    stoch(input: import("./types.js").OHLCVInput | import("./types.js").Candle[], kLength?: number, dLength?: number): {
+        k: Array<number | null>;
+        d: Array<number | null>;
+    };
+    trueRange(high: number[], low: number[], close: number[]): Array<number | null>;
+    trueRange(input: import("./types.js").OHLCVInput | import("./types.js").Candle[]): Array<number | null>;
+    atr(high: number[], low: number[], close: number[], length?: number): Array<number | null>;
+    atr(input: import("./types.js").OHLCVInput | import("./types.js").Candle[], length?: number): Array<number | null>;
+    natr(high: number[], low: number[], close: number[], length?: number): Array<number | null>;
+    natr(input: import("./types.js").OHLCVInput | import("./types.js").Candle[], length?: number): Array<number | null>;
+    obv(close: number[], volume: number[]): Array<number | null>;
+    obv(input: import("./types.js").OHLCVInput | import("./types.js").Candle[]): Array<number | null>;
+    mfi(high: number[], low: number[], close: number[], volume: number[], length?: number): Array<number | null>;
+    mfi(input: import("./types.js").OHLCVInput | import("./types.js").Candle[], length?: number): Array<number | null>;
+    adx(high: number[], low: number[], close: number[], length?: number): {
+        adx: Array<number | null>;
+        plusDI: Array<number | null>;
+        minusDI: Array<number | null>;
+    };
+    adx(input: import("./types.js").OHLCVInput | import("./types.js").Candle[], length?: number): {
+        adx: Array<number | null>;
+        plusDI: Array<number | null>;
+        minusDI: Array<number | null>;
     };
+    vwapSession(high: number[], low: number[], close: number[], volume: number[], session: Array<string | number>): Array<number | null>;
+    vwapSession(input: import("./types.js").OHLCVInput | import("./types.js").Candle[], session: Array<string | number>): Array<number | null>;
+    signedVolume(open: number[], close: number[], volume: number[]): Array<number | null>;
+    signedVolume(input: import("./types.js").OHLCVInput | import("./types.js").Candle[]): Array<number | null>;
+    volumeDelta(open: number[], close: number[], volume: number[], length?: number): Array<number | null>;
+    volumeDelta(input: import("./types.js").OHLCVInput | import("./types.js").Candle[], length?: number): Array<number | null>;
+    orderflowImbalance(open: number[], close: number[], volume: number[], length?: number): Array<number | null>;
+    orderflowImbalance(input: import("./types.js").OHLCVInput | import("./types.js").Candle[], length?: number): Array<number | null>;
+    fundingRateCumulative(values: number[]): Array<number | null>;
+    fundingRateAPR(values: number[], periodsPerYear?: number): Array<number | null>;
+    volatilityRegime(input: import("./types.js").PriceInput, length?: number, periodsPerYear?: number, lowZ?: number, highZ?: number): Array<number | null>;
 };

package/dist/index.js

@@ -1,24 +1,12 @@
-export { sma, ema, rma, hl2, hlc3, ohlc4, vwap, bbands } from "./core/overlap.js";
-export { rsi, macd, stoch } from "./core/momentum.js";
-export { trueRange, atr, natr } from "./core/volatility.js";
-export { logReturn, percentReturn, realizedVolatility } from "./core/performance.js";
-export { obv, mfi } from "./core/volume.js";
-export { adx } from "./core/trend.js";
-export { vwapSession, fundingRateCumulative, fundingRateAPR, volatilityRegime, signedVolume, volumeDelta, orderflowImbalance } from "./core/crypto.js";
+export { sma, ema, rma, hl2, hlc3, ohlc4, vwap, bbands, rsi, macd, stoch, trueRange, atr, natr, logReturn, percentReturn, realizedVolatility, obv, mfi, adx, vwapSession, fundingRateCumulative, fundingRateAPR, volatilityRegime, signedVolume, volumeDelta, orderflowImbalance } from "./api.js";
+export { pluckOpen, pluckHigh, pluckLow, pluckClose, pluckVolume, toOHLCV } from "./candles.js";
+export { createSMA, createEMA, createRSI, createVWAPSession } from "./stateful.js";
 export * from "./types.js";
-import * as overlap from "./core/overlap.js";
-import * as momentum from "./core/momentum.js";
-import * as volatility from "./core/volatility.js";
-import * as performance from "./core/performance.js";
-import * as volume from "./core/volume.js";
-import * as trend from "./core/trend.js";
-import * as crypto from "./core/crypto.js";
+import * as api from "./api.js";
+import * as candles from "./candles.js";
+import * as stateful from "./stateful.js";
 export const ta = {
-    ...overlap,
-    ...momentum,
-    ...volatility,
-    ...performance,
-    ...volume,
-    ...trend,
-    ...crypto
+    ...api,
+    ...candles,
+    ...stateful
 };

package/dist/indicators.d.ts

@@ -0,0 +1 @@
+export { sma, ema, rma, hl2, hlc3, ohlc4, vwap, bbands, rsi, macd, stoch, trueRange, atr, natr, logReturn, percentReturn, realizedVolatility, obv, mfi, adx } from "./api.js";

package/dist/indicators.js

@@ -0,0 +1 @@
+export { sma, ema, rma, hl2, hlc3, ohlc4, vwap, bbands, rsi, macd, stoch, trueRange, atr, natr, logReturn, percentReturn, realizedVolatility, obv, mfi, adx } from "./api.js";

package/dist/stateful.d.ts

@@ -0,0 +1,15 @@
+export type StatefulIndicator<TIn, TOut> = {
+    next(value: TIn): TOut;
+    reset(): void;
+};
+export declare function createSMA(period?: number): StatefulIndicator<number, number | null>;
+export declare function createEMA(period?: number): StatefulIndicator<number, number | null>;
+export declare function createRSI(period?: number): StatefulIndicator<number, number | null>;
+export type VWAPSessionInput = {
+    high: number;
+    low: number;
+    close: number;
+    volume: number;
+    sessionId: string | number;
+};
+export declare function createVWAPSession(): StatefulIndicator<VWAPSessionInput, number | null>;