@tradingaction/core 2.0.0

package/src/utils/index.ts

@@ -0,0 +1,153 @@
+import React from "react";
+export { default as zipper } from "./zipper";
+export { default as slidingWindow } from "./slidingWindow";
+export * from "./closestItem";
+export * from "./identity";
+export * from "./noop";
+export * from "./shallowEqual";
+export { default as accumulatingWindow } from "./accumulatingWindow";
+export * from "./barWidth";
+export * from "./strokeDasharray";
+export * from "./PureComponent";
+
+export const sign = (x: any) => {
+    // @ts-ignore
+    return (x > 0) - (x < 0);
+};
+
+export const path = (loc = []) => {
+    const key = Array.isArray(loc) ? loc : [loc];
+    const length = key.length;
+
+    return function (obj: any, defaultValue?: any) {
+        if (length === 0) {
+            return isDefined(obj) ? obj : defaultValue;
+        }
+
+        let index = 0;
+        while (obj != null && index < length) {
+            obj = obj[key[index++]];
+        }
+        return index === length ? obj : defaultValue;
+    };
+};
+
+export const functor = (v: any) => {
+    return typeof v === "function" ? v : () => v;
+};
+
+export function getClosestValue(inputValue: any, currentValue: any) {
+    const values = Array.isArray(inputValue) ? inputValue : [inputValue];
+
+    const diff = values
+        .map((each) => each - currentValue)
+        .reduce((diff1, diff2) => (Math.abs(diff1) < Math.abs(diff2) ? diff1 : diff2));
+    return currentValue + diff;
+}
+
+export function d3Window(node: any) {
+    const d3win =
+        node && ((node.ownerDocument && node.ownerDocument.defaultView) || (node.document && node) || node.defaultView);
+    return d3win;
+}
+
+export const MOUSEENTER = "mouseenter.interaction";
+export const MOUSELEAVE = "mouseleave.interaction";
+export const MOUSEMOVE = "mousemove.pan";
+export const MOUSEUP = "mouseup.pan";
+export const TOUCHMOVE = "touchmove.pan";
+export const TOUCHEND = "touchend.pan touchcancel.pan";
+
+export function getTouchProps(touch: any) {
+    return {
+        pageX: touch.pageX,
+        pageY: touch.pageY,
+        clientX: touch.clientX,
+        clientY: touch.clientY,
+    };
+}
+
+export function head(array: any[], accessor?: any) {
+    if (accessor && array) {
+        let value: any;
+        // tslint:disable-next-line: prefer-for-of
+        for (let i = 0; i < array.length; i++) {
+            value = array[i];
+            if (isDefined(accessor(value))) {
+                return value;
+            }
+        }
+
+        return undefined;
+    }
+
+    return array ? array[0] : undefined;
+}
+
+export const first = head;
+
+export function last(array: any[], accessor?: any) {
+    if (accessor && array) {
+        let value;
+        for (let i = array.length - 1; i >= 0; i--) {
+            value = array[i];
+            if (isDefined(accessor(value))) {
+                return value;
+            }
+        }
+        return undefined;
+    }
+    const length = array ? array.length : 0;
+    return length ? array[length - 1] : undefined;
+}
+
+export const isDefined = <T>(d: T): d is NonNullable<T> => {
+    return d !== null && d !== undefined;
+};
+
+export function isNotDefined<T>(d: T) {
+    return !isDefined(d);
+}
+
+export function isObject(d: any) {
+    return isDefined(d) && typeof d === "object" && !Array.isArray(d);
+}
+
+export function touchPosition(touch: { clientX: number; clientY: number }, e: React.TouchEvent): [number, number] {
+    const container = e.currentTarget;
+    const rect = container.getBoundingClientRect();
+    const x = touch.clientX - rect.left - container.clientLeft;
+    const y = touch.clientY - rect.top - container.clientTop;
+    return [Math.round(x), Math.round(y)];
+}
+
+export function mousePosition(
+    e: React.MouseEvent,
+    defaultRect?: { height: number; width: number; left: number; top: number },
+): [number, number] {
+    const container = e.currentTarget;
+    const rect = defaultRect ?? container.getBoundingClientRect();
+    const x = e.clientX - rect.left - container.clientLeft;
+    const y = e.clientY - rect.top - container.clientTop;
+    return [Math.round(x), Math.round(y)];
+}
+
+export function clearCanvas(canvasList: CanvasRenderingContext2D[], ratio: number) {
+    canvasList.forEach((each) => {
+        each.setTransform(1, 0, 0, 1, 0, 0);
+        each.clearRect(-1, -1, each.canvas.width + 2, each.canvas.height + 2);
+        each.scale(ratio, ratio);
+    });
+}
+
+// copied from https://github.com/lodash/lodash/blob/master/mapObject.js
+export function mapObject(object = {}, iteratee = (x: any) => x) {
+    const props = Object.keys(object);
+    const result = new Array(props.length);
+
+    props.forEach((key, index) => {
+        // @ts-ignore
+        result[index] = iteratee(object[key], key, object);
+    });
+    return result;
+}

package/src/utils/noop.ts

@@ -0,0 +1,2 @@
+// eslint-disable-next-line @typescript-eslint/no-empty-function
+export const noop = () => {};

package/src/utils/shallowEqual.ts

@@ -0,0 +1,25 @@
+export const shallowEqual = (a: any, b: any) => {
+    if (a === b) {
+        return true;
+    }
+    if (!(a instanceof Object) || !(b instanceof Object)) {
+        return false;
+    }
+
+    const keys = Object.keys(a);
+    const length = keys.length;
+
+    for (let i = 0; i < length; i++) {
+        if (!(keys[i] in b)) {
+            return false;
+        }
+    }
+
+    for (let i = 0; i < length; i++) {
+        if (a[keys[i]] !== b[keys[i]]) {
+            return false;
+        }
+    }
+
+    return length === Object.keys(b).length;
+};

package/src/utils/slidingWindow.ts

@@ -0,0 +1,140 @@
+/*
+
+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, path } from "./index";
+import { noop } from "./noop";
+
+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 = noop;
+    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/strokeDasharray.ts

@@ -0,0 +1,52 @@
+export type strokeDashTypes =
+    | "Solid"
+    | "ShortDash"
+    | "ShortDash2"
+    | "ShortDot"
+    | "ShortDashDot"
+    | "ShortDashDotDot"
+    | "Dot"
+    | "Dash"
+    | "LongDash"
+    | "DashDot"
+    | "LongDashDot"
+    | "LongDashDotDot";
+
+export const getStrokeDasharrayCanvas = (type?: strokeDashTypes) => {
+    const a = getStrokeDasharray(type).split(",");
+    if (a.length === 1) {
+        return [];
+    }
+
+    return a.map((d) => Number(d));
+};
+
+export const getStrokeDasharray = (type?: strokeDashTypes) => {
+    switch (type) {
+        default:
+        case "Solid":
+            return "none";
+        case "ShortDash":
+            return "6, 2";
+        case "ShortDash2":
+            return "6, 3";
+        case "ShortDot":
+            return "2, 2";
+        case "ShortDashDot":
+            return "6, 2, 2, 2";
+        case "ShortDashDotDot":
+            return "6, 2, 2, 2, 2, 2";
+        case "Dot":
+            return "2, 6";
+        case "Dash":
+            return "4, 6";
+        case "LongDash":
+            return "16, 6";
+        case "DashDot":
+            return "8, 6, 2, 6";
+        case "LongDashDot":
+            return "16, 6, 2, 6";
+        case "LongDashDotDot":
+            return "16, 6, 2, 6, 2, 6";
+    }
+};

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;
+}

package/src/zoom/index.ts

@@ -0,0 +1 @@
+export * from "./zoomBehavior";

package/src/zoom/zoomBehavior.ts

@@ -0,0 +1,34 @@
+import { ScaleContinuousNumeric, ScaleTime } from "d3-scale";
+import { getCurrentItem } from "../utils/ChartDataUtil";
+import { last } from "../utils/index";
+
+export interface IZoomAnchorOptions<TData, TXAxis extends number | Date> {
+    readonly plotData: TData[];
+    readonly mouseXY: number[];
+    readonly xAccessor: (data: TData) => TXAxis;
+    readonly xScale: ScaleContinuousNumeric<number, number> | ScaleTime<number, number>;
+}
+
+export const mouseBasedZoomAnchor = <TData, TXAxis extends number | Date>(
+    options: IZoomAnchorOptions<TData, TXAxis>,
+) => {
+    const { xScale, xAccessor, mouseXY, plotData } = options;
+    const currentItem = getCurrentItem(xScale, xAccessor, mouseXY, plotData);
+    return xAccessor(currentItem);
+};
+
+export const lastVisibleItemBasedZoomAnchor = <TData, TXAxis extends number | Date>(
+    options: IZoomAnchorOptions<TData, TXAxis>,
+) => {
+    const { xAccessor, plotData } = options;
+    const lastItem = last(plotData);
+    return xAccessor(lastItem);
+};
+
+export const rightDomainBasedZoomAnchor = <TData, TXAxis extends number | Date>(
+    options: IZoomAnchorOptions<TData, TXAxis>,
+) => {
+    const { xScale } = options;
+    const [, end] = xScale.domain();
+    return end;
+};