@tradingaction/indicators 2.0.1

package/src/indicator/wma.ts

@@ -0,0 +1,58 @@
+import { merge, rebind } from "../utils";
+import { wma } from "../calculator";
+import { WMAOptions } from "../calculator/wma";
+import baseIndicator from "./baseIndicator";
+
+const ALGORITHM_TYPE = "WMA";
+
+interface WMAIndicator {
+    (data: any[], options?: { merge: boolean }): any;
+    id(): number;
+    id(x: number): WMAIndicator;
+    accessor(): any;
+    accessor(x: any): WMAIndicator;
+    stroke(): string | any;
+    stroke(x: string | any): WMAIndicator;
+    fill(): string | any;
+    fill(x: string | any): WMAIndicator;
+    echo(): any;
+    echo(x: any): WMAIndicator;
+    type(): string;
+    type(x: string): WMAIndicator;
+    merge(): any;
+    merge(newMerge: any): WMAIndicator;
+    options(): WMAOptions;
+    options(newOptions: WMAOptions): WMAIndicator;
+}
+
+export default function () {
+    const base = baseIndicator()
+        .type(ALGORITHM_TYPE)
+        .accessor((d: any) => d.wma);
+
+    const underlyingAlgorithm = wma();
+
+    const mergedAlgorithm = merge()
+        .algorithm(underlyingAlgorithm)
+        .merge((datum: any, i: number) => {
+            datum.wma = 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 WMAIndicator;
+}

package/src/utils/functor.ts

@@ -0,0 +1,3 @@
+export const functor = (v: any) => {
+    return typeof v === "function" ? v : () => v;
+};

package/src/utils/identity.ts

@@ -0,0 +1 @@
+export const identity = <T>(d: T) => d;

package/src/utils/index.ts

@@ -0,0 +1,8 @@
+export * from "./functor";
+export * from "./identity";
+export { default as mappedSlidingWindow } from "./mappedSlidingWindow";
+export { default as merge } from "./merge";
+export * from "./path";
+export { default as rebind } from "./rebind";
+export { default as slidingWindow } from "./slidingWindow";
+export { default as zipper } from "./zipper";

package/src/utils/mappedSlidingWindow.ts

@@ -0,0 +1,95 @@
+import { functor } from "./functor";
+import { identity } from "./identity";
+
+interface MappedSlidingWindow {
+    (data: any[]): any;
+    accumulator(): any;
+    accumulator(x: any): MappedSlidingWindow;
+    skipInitial(): number;
+    skipInitial(x: number): MappedSlidingWindow;
+    source(): any;
+    source(x: any): MappedSlidingWindow;
+    undefinedValue(): any;
+    undefinedValue(x: any): MappedSlidingWindow;
+    windowSize(): number;
+    windowSize(x: number): MappedSlidingWindow;
+}
+
+export default function () {
+    let undefinedValue: any;
+    let windowSize = 10;
+    let accumulator = () => {
+        /** Do Nothing */
+    };
+    let source = identity;
+    let skipInitial = 0;
+
+    const mappedSlidingWindow = function (data: any[]) {
+        // @ts-ignore
+        const size = functor(windowSize).apply(this, arguments);
+        const windowData: any[] = [];
+        let accumulatorIdx = 0;
+        const undef = functor(undefinedValue);
+        const result: any[] = [];
+        data.forEach(function (d, i) {
+            let mapped;
+            if (i < skipInitial + size - 1) {
+                mapped = undef(d, i);
+                result.push(mapped);
+                windowData.push(mapped);
+                return;
+            }
+            if (i >= skipInitial + size) {
+                windowData.shift();
+            }
+            // @ts-ignore
+            windowData.push(source(d, i));
+
+            // @ts-ignore
+            mapped = accumulator(windowData, i, accumulatorIdx++);
+            result.push(mapped);
+            windowData.pop();
+            windowData.push(mapped);
+            return;
+        });
+        return result;
+    };
+
+    mappedSlidingWindow.undefinedValue = function (x: any) {
+        if (!arguments.length) {
+            return undefinedValue;
+        }
+        undefinedValue = x;
+        return mappedSlidingWindow;
+    };
+    mappedSlidingWindow.windowSize = function (x: number) {
+        if (!arguments.length) {
+            return windowSize;
+        }
+        windowSize = x;
+        return mappedSlidingWindow;
+    };
+    mappedSlidingWindow.accumulator = function (x: any) {
+        if (!arguments.length) {
+            return accumulator;
+        }
+        accumulator = x;
+        return mappedSlidingWindow;
+    };
+    mappedSlidingWindow.skipInitial = function (x: number) {
+        if (!arguments.length) {
+            return skipInitial;
+        }
+        skipInitial = x;
+        return mappedSlidingWindow;
+    };
+    mappedSlidingWindow.source = function (x: any) {
+        if (!arguments.length) {
+            return source;
+        }
+        source = x;
+        return mappedSlidingWindow;
+    };
+
+    return mappedSlidingWindow as MappedSlidingWindow;
+}

package/src/utils/merge.ts

@@ -0,0 +1,93 @@
+/*
+https://github.com/ScottLogic/d3fc/blob/master/src/indicator/algorithm/merge.js
+
+The MIT License (MIT)
+
+Copyright (c) 2014-2015 Scott Logic Ltd.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+import zipper from "./zipper";
+import { identity } from "./identity";
+
+interface Merge {
+    (data: any[]): any;
+    algorithm(): any;
+    algorithm(newAlgorithm: any): Merge;
+    merge(): any;
+    merge(newMerge: any): Merge;
+    skipUndefined(): boolean;
+    skipUndefined(newSkipUndefined: boolean): Merge;
+}
+
+// applies an algorithm to an array, merging the result back into
+// the source array using the given merge function.
+export default function () {
+    let algorithm = identity;
+    let skipUndefined = true;
+    let merge = () => {
+        /** Do Nothing */
+    };
+
+    const mergeCompute = (data: any[]) => {
+        const zip = zipper().combine((datum: any, indicator: any) => {
+            const result =
+                skipUndefined && indicator === undefined
+                    ? datum
+                    : // @ts-ignore
+                      merge(datum, indicator);
+            return result === undefined ? datum : result;
+        });
+
+        // @ts-ignore
+        return zip(data, algorithm(data));
+    };
+
+    mergeCompute.algorithm = (newAlgorithm?: any) => {
+        if (newAlgorithm === undefined) {
+            return algorithm;
+        }
+
+        algorithm = newAlgorithm;
+
+        return mergeCompute;
+    };
+
+    mergeCompute.merge = (newMerge?: any) => {
+        if (newMerge === undefined) {
+            return merge;
+        }
+
+        merge = newMerge;
+
+        return mergeCompute;
+    };
+
+    mergeCompute.skipUndefined = (newSkipUndefined?: boolean) => {
+        if (newSkipUndefined === undefined) {
+            return skipUndefined;
+        }
+
+        skipUndefined = newSkipUndefined;
+
+        return mergeCompute;
+    };
+
+    return mergeCompute as Merge;
+}

package/src/utils/path.ts

@@ -0,0 +1,16 @@
+export const path = (loc: any | any[] = []) => {
+    const key = Array.isArray(loc) ? loc : [loc];
+    const length = key.length;
+
+    return function (obj: any, defaultValue?: any) {
+        if (length === 0) {
+            return obj !== undefined && obj !== null ? obj : defaultValue;
+        }
+
+        let index = 0;
+        while (obj != null && index < length) {
+            obj = obj[key[index++]];
+        }
+        return index === length ? obj : defaultValue;
+    };
+};

package/src/utils/rebind.ts

@@ -0,0 +1,19 @@
+// copied from https://github.com/d3fc/d3fc-rebind/blob/master/src/rebind.js
+
+function createReboundMethod(target: any, source: any, name: string) {
+    const method = source[name];
+    if (typeof method !== "function") {
+        throw new Error(`Attempt to rebind ${name} which isn't a function on the source object`);
+    }
+    return (...args: any[]) => {
+        const value = method.apply(source, args);
+        return value === source ? target : value;
+    };
+}
+
+export default function rebind(target: any, source: any, ...names: string[]) {
+    for (const name of names) {
+        target[name] = createReboundMethod(target, source, name);
+    }
+    return target;
+}

package/src/utils/slidingWindow.ts

@@ -0,0 +1,142 @@
+/*
+
+Taken from https://github.com/ScottLogic/d3fc/blob/master/src/indicator/algorithm/calculator/slidingWindow.js
+
+The MIT License (MIT)
+
+Copyright (c) 2014-2015 Scott Logic Ltd.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+*/
+
+import { functor } from "./functor";
+import { path } from "./path";
+
+interface SlidingWindow {
+    (data: any[]): any[];
+    misc(): any;
+    misc(x: any): SlidingWindow;
+    accumulator(): any;
+    accumulator(x: any): SlidingWindow;
+    skipInitial(): number;
+    skipInitial(x: number): SlidingWindow;
+    source(): any;
+    source(source: any): SlidingWindow;
+    sourcePath(): any;
+    sourcePath(x: any): SlidingWindow;
+    windowSize(): number;
+    windowSize(windowSize: number): SlidingWindow;
+    undefinedValue(): any;
+    undefinedValue(x: any): SlidingWindow;
+}
+
+export default function () {
+    let undefinedValue: any;
+    let windowSize = 10;
+    let accumulator = () => {
+        /** Do nothin */
+    };
+    let sourcePath: any;
+    let source: any;
+    let skipInitial = 0;
+    let misc: any;
+
+    const slidingWindow = (data: any[]) => {
+        const sourceFunction = source || path(sourcePath);
+
+        // @ts-ignore
+        const size = functor(windowSize).apply(this, arguments);
+        const windowData = data.slice(skipInitial, size + skipInitial).map(sourceFunction);
+
+        let accumulatorIdx = 0;
+        const undef = functor(undefinedValue);
+        return data.map((d, i) => {
+            if (i < skipInitial + size - 1) {
+                return undef(sourceFunction(d), i, misc);
+            }
+            if (i >= skipInitial + size) {
+                // Treat windowData as FIFO rolling buffer
+                windowData.shift();
+                windowData.push(sourceFunction(d, i));
+            }
+
+            // @ts-ignore
+            return accumulator(windowData, i, accumulatorIdx++, misc);
+        });
+    };
+
+    slidingWindow.undefinedValue = function (x: any) {
+        if (!arguments.length) {
+            return undefinedValue;
+        }
+        undefinedValue = x;
+        return slidingWindow;
+    };
+
+    slidingWindow.windowSize = function (x: any) {
+        if (!arguments.length) {
+            return windowSize;
+        }
+        windowSize = x;
+        return slidingWindow;
+    };
+
+    slidingWindow.misc = function (x: any) {
+        if (!arguments.length) {
+            return misc;
+        }
+        misc = x;
+        return slidingWindow;
+    };
+
+    slidingWindow.accumulator = function (x: any) {
+        if (!arguments.length) {
+            return accumulator;
+        }
+        accumulator = x;
+        return slidingWindow;
+    };
+
+    slidingWindow.skipInitial = function (x: any) {
+        if (!arguments.length) {
+            return skipInitial;
+        }
+        skipInitial = x;
+        return slidingWindow;
+    };
+
+    slidingWindow.sourcePath = function (x: any) {
+        if (!arguments.length) {
+            return sourcePath;
+        }
+        sourcePath = x;
+        return slidingWindow;
+    };
+
+    slidingWindow.source = function (x: any) {
+        if (!arguments.length) {
+            return source;
+        }
+        source = x;
+        return slidingWindow;
+    };
+
+    return slidingWindow as SlidingWindow;
+}

package/src/utils/zipper.ts

@@ -0,0 +1,45 @@
+/* an extension to d3.zip so we call a function instead of an array */
+
+import { min } from "d3-array";
+import { identity } from "./identity";
+
+interface Zip {
+    (...args: any[]): any[];
+    combine(): any;
+    combine(x: any): Zip;
+}
+
+export default function zipper() {
+    let combine = identity;
+
+    function zip() {
+        const n = arguments.length;
+        if (n === 0) {
+            return [];
+        }
+        const m = min(arguments, d3_zipLength) ?? 0;
+
+        const zips = new Array(m);
+        for (let i = -1; ++i < m; ) {
+            // tslint:disable-next-line: no-shadowed-variable
+            for (let j = -1, zip = (zips[i] = new Array(n)); ++j < n; ) {
+                zip[j] = arguments[j][i];
+            }
+
+            // @ts-ignore
+            zips[i] = combine.apply(this, zips[i]);
+        }
+        return zips;
+    }
+    function d3_zipLength(d: any[]) {
+        return d.length;
+    }
+    zip.combine = function (x: any) {
+        if (!arguments.length) {
+            return combine;
+        }
+        combine = x;
+        return zip;
+    };
+    return zip as Zip;
+}