@tradingaction/indicators 2.0.1

package/src/indicator/elderRay.ts

@@ -0,0 +1,56 @@
+import { elderRay } from "../calculator";
+import { merge, rebind } from "../utils";
+import { ElderRayOptions } from "../calculator/elderRay";
+import baseIndicator from "./baseIndicator";
+
+const ALGORITHM_TYPE = "ElderRay";
+
+interface ElderRayIndicator {
+    (data: any[], options?: { merge: boolean }): any;
+    id(): number;
+    id(x: number): ElderRayIndicator;
+    accessor(): any;
+    accessor(x: any): ElderRayIndicator;
+    stroke(): string | any;
+    stroke(x: string | any): ElderRayIndicator;
+    fill(): string | any;
+    fill(x: string | any): ElderRayIndicator;
+    echo(): any;
+    echo(x: any): ElderRayIndicator;
+    type(): string;
+    type(x: string): ElderRayIndicator;
+    merge(): any;
+    merge(newMerge: any): ElderRayIndicator;
+    options(): ElderRayOptions;
+    options(newOptions: ElderRayOptions): ElderRayIndicator;
+}
+
+export default function () {
+    const base = baseIndicator()
+        .type(ALGORITHM_TYPE)
+        .accessor((d: any) => d.elderRay);
+
+    const underlyingAlgorithm = elderRay();
+
+    const mergedAlgorithm = merge()
+        .algorithm(underlyingAlgorithm)
+        .merge((datum: any, i: number) => {
+            datum.elderRay = i;
+        });
+
+    const indicator = (data: any[], options = { merge: true }) => {
+        if (options.merge) {
+            if (!base.accessor()) {
+                throw new Error(`Set an accessor to ${ALGORITHM_TYPE} before calculating`);
+            }
+            return mergedAlgorithm(data);
+        }
+        return underlyingAlgorithm(data);
+    };
+
+    rebind(indicator, base, "id", "accessor", "stroke", "fill", "echo", "type");
+    rebind(indicator, underlyingAlgorithm, "options");
+    rebind(indicator, mergedAlgorithm, "merge", "skipUndefined");
+
+    return indicator as ElderRayIndicator;
+}

package/src/indicator/ema.ts

@@ -0,0 +1,58 @@
+import { merge, rebind } from "../utils";
+import { ema } from "../calculator";
+import { EMAOptions } from "../calculator/ema";
+import baseIndicator from "./baseIndicator";
+
+const ALGORITHM_TYPE = "EMA";
+
+interface EMAIndicator {
+    (data: any[], options?: { merge: boolean }): any;
+    id(): number;
+    id(x: number): EMAIndicator;
+    accessor(): any;
+    accessor(x: any): EMAIndicator;
+    stroke(): string | any;
+    stroke(x: string | any): EMAIndicator;
+    fill(): string | any;
+    fill(x: string | any): EMAIndicator;
+    echo(): any;
+    echo(x: any): EMAIndicator;
+    type(): string;
+    type(x: string): EMAIndicator;
+    merge(): any;
+    merge(newMerge: any): EMAIndicator;
+    options(): EMAOptions;
+    options(newOptions: EMAOptions): EMAIndicator;
+}
+
+export default function () {
+    const base = baseIndicator()
+        .type(ALGORITHM_TYPE)
+        .accessor((d: any) => d.ema);
+
+    const underlyingAlgorithm = ema();
+
+    const mergedAlgorithm = merge()
+        .algorithm(underlyingAlgorithm)
+        .merge((datum: any, i: number) => {
+            datum.ema = i;
+        });
+
+    const indicator = (data: any[], options = { merge: true }) => {
+        if (options.merge) {
+            if (!base.accessor()) {
+                throw new Error(`Set an accessor to ${ALGORITHM_TYPE} before calculating`);
+            }
+
+            return mergedAlgorithm(data);
+        }
+
+        return underlyingAlgorithm(data);
+    };
+
+    rebind(indicator, base, "id", "accessor", "stroke", "fill", "echo", "type");
+    rebind(indicator, underlyingAlgorithm, "options", "undefinedLength");
+    rebind(indicator, mergedAlgorithm, "merge", "skipUndefined");
+
+    return indicator as EMAIndicator;
+}

package/src/indicator/forceIndex.ts

@@ -0,0 +1,57 @@
+import { merge, rebind } from "../utils";
+import { forceIndex } from "../calculator";
+import { ForceIndexOptions } from "../calculator/forceIndex";
+import baseIndicator from "./baseIndicator";
+
+const ALGORITHM_TYPE = "ForceIndex";
+
+interface ForceIndexIndicator {
+    (data: any[], options?: { merge: boolean }): any;
+    id(): number;
+    id(x: number): ForceIndexIndicator;
+    accessor(): any;
+    accessor(x: any): ForceIndexIndicator;
+    stroke(): string | any;
+    stroke(x: string | any): ForceIndexIndicator;
+    fill(): string | any;
+    fill(x: string | any): ForceIndexIndicator;
+    echo(): any;
+    echo(x: any): ForceIndexIndicator;
+    type(): string;
+    type(x: string): ForceIndexIndicator;
+    merge(): any;
+    merge(newMerge: any): ForceIndexIndicator;
+    options(): ForceIndexOptions;
+    options(newOptions: ForceIndexOptions): ForceIndexIndicator;
+}
+
+export default function () {
+    const base = baseIndicator()
+        .type(ALGORITHM_TYPE)
+        .accessor((d: any) => d.forceIndex);
+
+    const underlyingAlgorithm = forceIndex();
+
+    const mergedAlgorithm = merge()
+        .algorithm(underlyingAlgorithm)
+        .merge((datum: any, i: number) => {
+            datum.forceIndex = i;
+        });
+
+    const indicator = (data: any[], options = { merge: true }) => {
+        if (options.merge) {
+            if (!base.accessor()) {
+                throw new Error(`Set an accessor to ${ALGORITHM_TYPE} before calculating`);
+            }
+
+            return mergedAlgorithm(data);
+        }
+        return underlyingAlgorithm(data);
+    };
+
+    rebind(indicator, base, "id", "accessor", "stroke", "fill", "echo", "type");
+    rebind(indicator, underlyingAlgorithm, "options");
+    rebind(indicator, mergedAlgorithm, "merge", "skipUndefined");
+
+    return indicator as ForceIndexIndicator;
+}

package/src/indicator/heikinAshi.ts

@@ -0,0 +1,35 @@
+import { heikinAshi } from "../calculator";
+import baseIndicator from "./baseIndicator";
+import { merge, rebind } from "../utils";
+
+const ALGORITHM_TYPE = "HeikinAshi";
+
+export default function () {
+    const base = baseIndicator()
+        .type(ALGORITHM_TYPE)
+        .accessor((d: any) => d.ha);
+
+    const underlyingAlgorithm = heikinAshi();
+
+    const mergedAlgorithm = merge()
+        .algorithm(underlyingAlgorithm)
+        .merge((datum: any, i: any) => {
+            return { ...datum, ...i };
+        });
+
+    const indicator = (data: any[], options = { merge: true }) => {
+        if (options.merge) {
+            if (!base.accessor()) {
+                throw new Error(`Set an accessor to ${ALGORITHM_TYPE} before calculating`);
+            }
+
+            return mergedAlgorithm(data);
+        }
+        return underlyingAlgorithm(data);
+    };
+
+    rebind(indicator, base, "accessor", "stroke", "fill", "echo", "type");
+    rebind(indicator, mergedAlgorithm, "merge");
+
+    return indicator;
+}

package/src/indicator/index.ts

@@ -0,0 +1,25 @@
+export { default as algo } from "./algorithm";
+export { default as ema } from "./ema";
+export { default as sma } from "./sma";
+export { default as wma } from "./wma";
+export { default as tma } from "./tma";
+export { default as bollingerBand } from "./bollingerBand";
+export { default as heikinAshi } from "./heikinAshi";
+export { default as kagi } from "./kagi";
+export { default as pointAndFigure } from "./pointAndFigure";
+export { default as renko } from "./renko";
+export { default as macd } from "./macd";
+export { default as rsi } from "./rsi";
+export { default as atr } from "./atr";
+export { default as stochasticOscillator } from "./stochasticOscillator";
+export { default as forceIndex } from "./forceIndex";
+export { default as sar } from "./sar";
+export { default as elderRay } from "./elderRay";
+export { default as change } from "./change";
+export { default as elderImpulse } from "./elderImpulse";
+export { default as compare } from "./compare";
+
+import * as defaultOptionsForComputation from "../calculator/defaultOptionsForComputation";
+import * as defaultOptionsForAppearance from "./defaultOptionsForAppearance";
+
+export { defaultOptionsForComputation, defaultOptionsForAppearance };

package/src/indicator/kagi.ts

@@ -0,0 +1,18 @@
+import { rebind } from "../utils";
+import { kagi } from "../calculator";
+import baseIndicator from "./baseIndicator";
+
+const ALGORITHM_TYPE = "Kagi";
+
+export default function () {
+    const base = baseIndicator().type(ALGORITHM_TYPE);
+
+    const underlyingAlgorithm = kagi();
+
+    const indicator = underlyingAlgorithm;
+
+    rebind(indicator, base, "id", "stroke", "fill", "echo", "type");
+    rebind(indicator, underlyingAlgorithm, "dateAccessor", "dateMutator", "options");
+
+    return indicator;
+}

package/src/indicator/macd.ts

@@ -0,0 +1,60 @@
+import { merge, rebind } from "../utils";
+import { macd } from "../calculator";
+import { MACDOptions } from "../calculator/macd";
+import baseIndicator from "./baseIndicator";
+import { MACD as appearanceOptions } from "./defaultOptionsForAppearance";
+
+const ALGORITHM_TYPE = "MACD";
+
+interface MACDIndicator {
+    (data: any[], options?: { merge: boolean }): any;
+    id(): number;
+    id(x: number): MACDIndicator;
+    accessor(): any;
+    accessor(x: any): MACDIndicator;
+    stroke(): string | any;
+    stroke(x: string | any): MACDIndicator;
+    fill(): string | any;
+    fill(x: string | any): MACDIndicator;
+    echo(): any;
+    echo(x: any): MACDIndicator;
+    type(): string;
+    type(x: string): MACDIndicator;
+    merge(): any;
+    merge(newMerge: any): MACDIndicator;
+    options(): MACDOptions;
+    options(newOptions: MACDOptions): MACDIndicator;
+}
+
+export default function () {
+    const base = baseIndicator()
+        .type(ALGORITHM_TYPE)
+        .fill(appearanceOptions.fill)
+        .stroke(appearanceOptions.stroke)
+        .accessor((d: any) => d.macd);
+
+    const underlyingAlgorithm = macd();
+
+    const mergedAlgorithm = merge()
+        .algorithm(underlyingAlgorithm)
+        .merge((datum: any, i: number) => {
+            datum.macd = i;
+        });
+
+    const indicator = (data: any[], options = { merge: true }) => {
+        if (options.merge) {
+            if (!base.accessor()) {
+                throw new Error(`Set an accessor to ${ALGORITHM_TYPE} before calculating`);
+            }
+
+            return mergedAlgorithm(data);
+        }
+        return underlyingAlgorithm(data);
+    };
+
+    rebind(indicator, base, "id", "accessor", "stroke", "fill", "echo", "type");
+    rebind(indicator, underlyingAlgorithm, "options", "undefinedLength");
+    rebind(indicator, mergedAlgorithm, "merge", "skipUndefined");
+
+    return indicator as MACDIndicator;
+}

package/src/indicator/pointAndFigure.ts

@@ -0,0 +1,18 @@
+import { rebind } from "../utils";
+import { pointAndFigure } from "../calculator";
+import baseIndicator from "./baseIndicator";
+
+const ALGORITHM_TYPE = "PointAndFigure";
+
+export default function () {
+    const base = baseIndicator().type(ALGORITHM_TYPE);
+
+    const underlyingAlgorithm = pointAndFigure();
+
+    const indicator = underlyingAlgorithm;
+
+    rebind(indicator, base, "id", "stroke", "fill", "echo", "type");
+    rebind(indicator, underlyingAlgorithm, "dateAccessor", "dateMutator", "options");
+
+    return indicator;
+}

package/src/indicator/renko.ts

@@ -0,0 +1,18 @@
+import { rebind } from "../utils";
+import { renko } from "../calculator";
+import baseIndicator from "./baseIndicator";
+
+const ALGORITHM_TYPE = "Renko";
+
+export default function () {
+    const base = baseIndicator().type(ALGORITHM_TYPE);
+
+    const underlyingAlgorithm = renko();
+
+    const indicator = underlyingAlgorithm;
+
+    rebind(indicator, base, "id", "stroke", "fill", "echo", "type");
+    rebind(indicator, underlyingAlgorithm, "options", "dateAccessor", "dateMutator");
+
+    return indicator;
+}

package/src/indicator/rsi.ts

@@ -0,0 +1,58 @@
+import { merge, rebind } from "../utils";
+import { rsi } from "../calculator";
+import { RSIOptions } from "../calculator/rsi";
+import baseIndicator from "./baseIndicator";
+
+const ALGORITHM_TYPE = "RSI";
+
+interface RSIIndicator {
+    (data: any[], options?: { merge: boolean }): any;
+    id(): number;
+    id(x: number): RSIIndicator;
+    accessor(): any;
+    accessor(x: any): RSIIndicator;
+    stroke(): string | any;
+    stroke(x: string | any): RSIIndicator;
+    fill(): string | any;
+    fill(x: string | any): RSIIndicator;
+    echo(): any;
+    echo(x: any): RSIIndicator;
+    type(): string;
+    type(x: string): RSIIndicator;
+    merge(): any;
+    merge(newMerge: any): RSIIndicator;
+    options(): RSIOptions;
+    options(newOptions: RSIOptions): RSIIndicator;
+}
+
+export default function () {
+    const base = baseIndicator()
+        .type(ALGORITHM_TYPE)
+        .accessor((d: any) => d.rsi);
+
+    const underlyingAlgorithm = rsi();
+
+    const mergedAlgorithm = merge()
+        .algorithm(underlyingAlgorithm)
+        .merge((datum: any, i: number) => {
+            datum.rsi = i;
+        });
+
+    const indicator = (data: any[], options = { merge: true }) => {
+        if (options.merge) {
+            if (!base.accessor()) {
+                throw new Error(`Set an accessor to ${ALGORITHM_TYPE} before calculating`);
+            }
+
+            return mergedAlgorithm(data);
+        }
+
+        return underlyingAlgorithm(data);
+    };
+
+    rebind(indicator, base, "id", "accessor", "stroke", "fill", "echo", "type");
+    rebind(indicator, underlyingAlgorithm, "options", "undefinedLength");
+    rebind(indicator, mergedAlgorithm, "merge", "skipUndefined");
+
+    return indicator as RSIIndicator;
+}

package/src/indicator/sar.ts

@@ -0,0 +1,56 @@
+import { merge, rebind } from "../utils";
+import { sar } from "../calculator";
+import { SAROptions } from "../calculator/sar";
+import baseIndicator from "./baseIndicator";
+
+const ALGORITHM_TYPE = "SMA";
+
+interface SARIndicator {
+    (data: any[], options?: { merge: boolean }): any;
+    id(): number;
+    id(x: number): SARIndicator;
+    accessor(): any;
+    accessor(x: any): SARIndicator;
+    stroke(): string | any;
+    stroke(x: string | any): SARIndicator;
+    fill(): string | any;
+    fill(x: string | any): SARIndicator;
+    echo(): any;
+    echo(x: any): SARIndicator;
+    type(): string;
+    type(x: string): SARIndicator;
+    merge(): any;
+    merge(newMerge: any): SARIndicator;
+    options(): SAROptions;
+    options(newOptions: SAROptions): SARIndicator;
+}
+
+export default function () {
+    const base = baseIndicator()
+        .type(ALGORITHM_TYPE)
+        .accessor((d: any) => d.sar);
+
+    const underlyingAlgorithm = sar();
+
+    const mergedAlgorithm = merge()
+        .algorithm(underlyingAlgorithm)
+        .merge((datum: any, i: number) => {
+            datum.sar = i;
+        });
+
+    const indicator = (data: any[], options = { merge: true }) => {
+        if (options.merge) {
+            if (!base.accessor()) {
+                throw new Error(`Set an accessor to ${ALGORITHM_TYPE} before calculating`);
+            }
+            return mergedAlgorithm(data);
+        }
+        return underlyingAlgorithm(data);
+    };
+
+    rebind(indicator, base, "id", "accessor", "stroke", "echo", "type");
+    rebind(indicator, underlyingAlgorithm, "options", "undefinedLength");
+    rebind(indicator, mergedAlgorithm, "merge");
+
+    return indicator as SARIndicator;
+}

package/src/indicator/sma.ts

@@ -0,0 +1,57 @@
+import { merge, rebind } from "../utils";
+import { sma } from "../calculator";
+import { SMAOptions } from "../calculator/sma";
+import baseIndicator from "./baseIndicator";
+
+const ALGORITHM_TYPE = "SMA";
+
+interface SMAIndicator {
+    (data: any[], options?: { merge: boolean }): any;
+    id(): number;
+    id(x: number): SMAIndicator;
+    accessor(): any;
+    accessor(x: any): SMAIndicator;
+    stroke(): string | any;
+    stroke(x: string | any): SMAIndicator;
+    fill(): string | any;
+    fill(x: string | any): SMAIndicator;
+    echo(): any;
+    echo(x: any): SMAIndicator;
+    type(): string;
+    type(x: string): SMAIndicator;
+    merge(): any;
+    merge(newMerge: any): SMAIndicator;
+    options(): SMAOptions;
+    options(newOptions: SMAOptions): SMAIndicator;
+}
+
+export default function () {
+    const base = baseIndicator()
+        .type(ALGORITHM_TYPE)
+        .accessor((d: any) => d.sma);
+
+    const underlyingAlgorithm = sma();
+
+    const mergedAlgorithm = merge()
+        .algorithm(underlyingAlgorithm)
+        .merge((datum: any, i: number) => {
+            datum.sma = i;
+        });
+
+    const indicator = (data: any[], options = { merge: true }) => {
+        if (options.merge) {
+            if (!base.accessor()) {
+                throw new Error(`Set an accessor to ${ALGORITHM_TYPE} before calculating`);
+            }
+
+            return mergedAlgorithm(data);
+        }
+
+        return underlyingAlgorithm(data);
+    };
+    rebind(indicator, base, "id", "accessor", "stroke", "fill", "echo", "type");
+    rebind(indicator, underlyingAlgorithm, "options", "undefinedLength");
+    rebind(indicator, mergedAlgorithm, "merge", "skipUndefined");
+
+    return indicator as SMAIndicator;
+}

package/src/indicator/stochasticOscillator.ts

@@ -0,0 +1,56 @@
+import { merge, rebind } from "../utils";
+import { sto } from "../calculator";
+import { STOOptions } from "../calculator/sto";
+import baseIndicator from "./baseIndicator";
+
+const ALGORITHM_TYPE = "STO";
+
+interface StochasticOscillatorIndicator {
+    (data: any[], options?: { merge: boolean }): any;
+    id(): number;
+    id(x: number): StochasticOscillatorIndicator;
+    accessor(): any;
+    accessor(x: any): StochasticOscillatorIndicator;
+    stroke(): string | any;
+    stroke(x: string | any): StochasticOscillatorIndicator;
+    fill(): string | any;
+    fill(x: string | any): StochasticOscillatorIndicator;
+    echo(): any;
+    echo(x: any): StochasticOscillatorIndicator;
+    type(): string;
+    type(x: string): StochasticOscillatorIndicator;
+    merge(): any;
+    merge(newMerge: any): StochasticOscillatorIndicator;
+    options(): STOOptions;
+    options(newOptions: STOOptions): StochasticOscillatorIndicator;
+}
+
+export default function () {
+    const base = baseIndicator().type(ALGORITHM_TYPE);
+
+    const underlyingAlgorithm = sto();
+
+    const mergedAlgorithm = merge()
+        .algorithm(underlyingAlgorithm)
+        .merge((datum: any, i: number) => {
+            datum.sto = i;
+        });
+
+    const indicator = (data: any[], options = { merge: true }) => {
+        if (options.merge) {
+            if (!base.accessor()) {
+                throw new Error(`Set an accessor to ${ALGORITHM_TYPE} before calculating`);
+            }
+
+            return mergedAlgorithm(data);
+        }
+
+        return underlyingAlgorithm(data);
+    };
+
+    rebind(indicator, base, "id", "accessor", "stroke", "fill", "echo", "type");
+    rebind(indicator, underlyingAlgorithm, "options", "undefinedLength");
+    rebind(indicator, mergedAlgorithm, "merge", "skipUndefined");
+
+    return indicator as StochasticOscillatorIndicator;
+}

package/src/indicator/tma.ts

@@ -0,0 +1,57 @@
+import { merge, rebind } from "../utils";
+import { tma } from "../calculator";
+import { TMAOptions } from "../calculator/tma";
+import baseIndicator from "./baseIndicator";
+
+const ALGORITHM_TYPE = "TMA";
+
+interface TMAIndicator {
+    (data: any[], options?: { merge: boolean }): any;
+    id(): number;
+    id(x: number): TMAIndicator;
+    accessor(): any;
+    accessor(x: any): TMAIndicator;
+    stroke(): string | any;
+    stroke(x: string | any): TMAIndicator;
+    fill(): string | any;
+    fill(x: string | any): TMAIndicator;
+    echo(): any;
+    echo(x: any): TMAIndicator;
+    type(): string;
+    type(x: string): TMAIndicator;
+    merge(): any;
+    merge(newMerge: any): TMAIndicator;
+    options(): TMAOptions;
+    options(newOptions: TMAOptions): TMAIndicator;
+}
+
+export default function () {
+    const base = baseIndicator()
+        .type(ALGORITHM_TYPE)
+        .accessor((d: any) => d.tma);
+
+    const underlyingAlgorithm = tma();
+
+    const mergedAlgorithm = merge()
+        .algorithm(underlyingAlgorithm)
+        .merge((datum: any, i: number) => {
+            datum.tma = i;
+        });
+
+    const indicator = (data: any[], options = { merge: true }) => {
+        if (options.merge) {
+            if (!base.accessor()) {
+                throw new Error(`Set an accessor to ${ALGORITHM_TYPE} before calculating`);
+            }
+
+            return mergedAlgorithm(data);
+        }
+
+        return underlyingAlgorithm(data);
+    };
+    rebind(indicator, base, "id", "accessor", "stroke", "fill", "echo", "type");
+    rebind(indicator, underlyingAlgorithm, "options", "undefinedLength");
+    rebind(indicator, mergedAlgorithm, "merge", "skipUndefined");
+
+    return indicator as TMAIndicator;
+}