@devexperts/dxcharts-lite 1.0.2 → 2.0.1

package/dist/chart/utils/linkedList.utils.js

@@ -0,0 +1,138 @@
+/*
+ * Copyright (C) 2019 - 2023 Devexperts Solutions IE Limited
+ * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
+ * If a copy of the MPL was not distributed with this file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+export class ListNode {
+    constructor(data) {
+        this.data = data;
+        this.next = null;
+    }
+}
+/**
+ * Implementation of Linked list data structure.
+ * @param _head
+ */
+export class LinkedList {
+    constructor(head) {
+        this._head = null;
+        this._tail = null;
+        this.length = 0;
+        this._head = head !== null && head !== void 0 ? head : null;
+        // init tail
+        if (this.head !== null) {
+            let current;
+            current = this.head;
+            while (current.next) {
+                current = current.next;
+            }
+            this._tail = current;
+        }
+    }
+    insertAtEnd(data) {
+        const node = new ListNode(data);
+        let current;
+        if (this.head === null) {
+            this._head = node;
+        }
+        else {
+            current = this.head;
+            while (current.next) {
+                current = current.next;
+            }
+            current.next = node;
+        }
+        this._tail = node;
+        this.length++;
+        return node;
+    }
+    insertAt(position, data) {
+        if (position > -1 && position < this.length && this.head) {
+            let current = this.head;
+            let index = 0;
+            let previous = null;
+            const node = new ListNode(data);
+            if (position === this.length - 1) {
+                this._tail = node;
+            }
+            if (position === 0) {
+                node.next = current;
+                this._head = node;
+            }
+            else {
+                while (index < position && current.next) {
+                    index++;
+                    previous = current;
+                    current = current.next;
+                }
+                node.next = current;
+                if (previous) {
+                    previous.next = node;
+                }
+            }
+            this.length++;
+            return current;
+        }
+        else {
+            this._head = new ListNode(data);
+            this.length++;
+            return this.head;
+        }
+    }
+    removeAt(position) {
+        if (position > -1 && position < this.length && this.head) {
+            let current = this.head;
+            let previous = null;
+            let index = 0;
+            if (position === 0) {
+                this._head = current.next;
+            }
+            else {
+                while (index < position && current.next) {
+                    index++;
+                    previous = current;
+                    current = current.next;
+                }
+                if (previous) {
+                    previous.next = current.next;
+                }
+                if (position === this.length - 1) {
+                    this._tail = current;
+                }
+            }
+            this.length--;
+            return current;
+        }
+        else {
+            return null;
+        }
+    }
+    getNodePosition(node) {
+        let index = 0;
+        let current = this.head;
+        while (node) {
+            if ((current === null || current === void 0 ? void 0 : current.data) === node.data) {
+                return index;
+            }
+            current = current && current.next;
+            index++;
+        }
+        return -1;
+    }
+    size() {
+        return this.length;
+    }
+    get head() {
+        return this._head;
+    }
+    get tail() {
+        return this._tail;
+    }
+    *[Symbol.iterator]() {
+        let current = this.head;
+        while (current) {
+            yield current.data;
+            current = current.next;
+        }
+    }
+}

package/dist/chart/utils/math.utils.js

@@ -3,4 +3,118 @@
  * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
  * If a copy of the MPL was not distributed with this file, You can obtain one at https://mozilla.org/MPL/2.0/.
  */
-export const MAX_DECIMAL_DIGITS=14;const s=[];for(let n=0;n<14+1;n++)s.push(Math.pow(10,n));const c=5e-13;export class MathUtils{static roundToNearest(t,r){return isFinite(t)?MathUtils.isZero(t)?0:(t>0?t+=c:t<0&&(t-=c),MathUtils.roundDecimal(Math.round(MathUtils.roundDecimal(t/r))*r)):t}static roundUpToNearest(t,r){return MathUtils.roundDecimal(Math.ceil(t/r))*r}static roundDecimal(t){if(isNaN(t)||t===Math.floor(t))return t;const r=Math.sign(t),e=Math.abs(t),i=Math.min(14,14-1-Math.floor(Math.log10(e)));for(let o=i;o>=0;o--){const a=Math.floor(s[o]*e+.5);if(a<s[14])return r*a/s[o]}return Math.round(t)}static makeDecimal(t,r,e){if(isFinite(t)){const i=t.toFixed(r);return e?i.replace(".",e):i}else return""}static compare(t,r,e){return t>r+e?1:t<r-e?-1:(isNaN(t)?1:0)-(isNaN(r)?1:0)}static isZero(t){return MathUtils.compare(t,0,c)===0}static cutNumber(t,r,e=0){return{K:o=>o/1e3,M:o=>o/1e6}[r](t).toFixed(e)+r}}export function isDiffersBy(n,t,r){const e=n/t;return e>=r||e<=1/r}export function clamp(n,t,r){return Math.max(t,Math.min(n,r))}export function easeExpOut(n){return 1-(Math.pow(2,-10*n)-.0009765625)*1.0009775171065494}export function finite(...n){for(const t of n)if(t!==void 0&&isFinite(t))return t;return NaN}export const floor=n=>~~n,ceil=n=>~~(n+1),round=n=>~~(n+.5),shiftRight=(n,t)=>n>>t;
+export const MAX_DECIMAL_DIGITS = 14;
+// Array of powers of 10. Used in roundDecimal to walk through mantissa.
+const POW10 = [];
+for (let i = 0; i < MAX_DECIMAL_DIGITS + 1; i++) {
+    POW10.push(Math.pow(10, i));
+}
+const EPS = 5e-13;
+export class MathUtils {
+    static roundToNearest(value, precision) {
+        if (!isFinite(value)) {
+            return value;
+        }
+        if (MathUtils.isZero(value)) {
+            return 0.0;
+        }
+        if (value > 0) {
+            value += EPS;
+        }
+        else if (value < 0) {
+            value -= EPS;
+        }
+        return MathUtils.roundDecimal(Math.round(MathUtils.roundDecimal(value / precision)) * precision);
+    }
+    static roundUpToNearest(value, precision) {
+        return MathUtils.roundDecimal(Math.ceil(value / precision)) * precision;
+    }
+    static roundDecimal(x) {
+        if (isNaN(x) || x === Math.floor(x)) {
+            return x;
+        } // integer, NaN, or +/- inf
+        const signum = Math.sign(x);
+        const abs = Math.abs(x);
+        const pow = Math.min(MAX_DECIMAL_DIGITS, MAX_DECIMAL_DIGITS - 1 - Math.floor(Math.log10(abs)));
+        for (let i = pow; i >= 0; i--) {
+            const mantissa = Math.floor(POW10[i] * abs + 0.5);
+            if (mantissa < POW10[MAX_DECIMAL_DIGITS]) {
+                return (signum * mantissa) / POW10[i];
+            }
+        }
+        // Mantissa >= 10^14 with fractions -- just round
+        return Math.round(x);
+    }
+    static makeDecimal(value, precision, decimal) {
+        if (isFinite(value)) {
+            const stringValue = value.toFixed(precision);
+            return decimal ? stringValue.replace('.', decimal) : stringValue;
+        }
+        else {
+            return '';
+        }
+    }
+    static compare(a, b, eps) {
+        if (a > b + eps) {
+            return +1;
+        }
+        else if (a < b - eps) {
+            return -1;
+        }
+        else {
+            return (isNaN(a) ? 1 : 0) - (isNaN(b) ? 1 : 0);
+        }
+    }
+    static isZero(a) {
+        return MathUtils.compare(a, 0, EPS) === 0;
+    }
+    static cutNumber(value, amountToCut, zeros = 0) {
+        const cutMap = {
+            K: v => v / 1000,
+            M: v => v / 1000000,
+        };
+        return cutMap[amountToCut](value).toFixed(zeros) + amountToCut;
+    }
+}
+/**
+ * Checks if first and second number are differs by specified times
+ * @param first {number}
+ * @param second {number}
+ * @param times {number}
+ * @doc-tags utility,math
+ */
+export function isDiffersBy(first, second, times) {
+    const diff = first / second;
+    return diff >= times || diff <= 1 / times;
+}
+export function clamp(value, min, max) {
+    return Math.max(min, Math.min(value, max));
+}
+export function easeExpOut(value) {
+    return 1 - (Math.pow(2, -10 * value) - 0.0009765625) * 1.0009775171065494;
+}
+/**
+ * Returns the first finite number in a list of numbers. If no finite number is found,
+ * returns NaN.
+ * @param {...number} args - A list of numbers to search for a finite value.
+ * @returns {number} The first finite number in the list, or NaN if no finite number is found.
+ */
+export function finite(...args) {
+    for (const arg of args) {
+        if (arg !== undefined && isFinite(arg)) {
+            return arg;
+        }
+    }
+    return NaN;
+}
+/**
+ * These functions can be used only for chart coordinates because they all are working in positive coordinates!!!
+ */
+// eslint-disable-next-line no-bitwise
+export const floor = (value) => ~~value;
+// eslint-disable-next-line no-bitwise
+export const ceil = (value) => ~~(value + 1);
+// eslint-disable-next-line no-bitwise
+export const round = (value) => ~~(value + 0.5);
+// eslint-disable-next-line no-bitwise
+export const shiftRight = (value, shift) => value >> shift;

package/dist/chart/utils/merge.utils.js

@@ -3,4 +3,59 @@
  * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
  * If a copy of the MPL was not distributed with this file, You can obtain one at https://mozilla.org/MPL/2.0/.
  */
-export function merge(r,e,f=DEFAULT_MERGE_OPTIONS){function l(n,t){for(const i in t)i in n?typeof n[i]=="object"&&n[i]!==null&&!Array.isArray(n[i])?l(n[i],t[i]):f!=null&&f.overrideExisting&&(n[i]=t[i]):f!=null&&f.addIfMissing&&(n[i]=t[i]);return n}return l(r,e)}export function mergeArray(r,e,f,l=!1){!r||!e||e.length===0||e.forEach(n=>{const t=f(n),i=r.findIndex(u=>f(u)===t);i===-1?r.push(n):l?merge(r[i],n,{overrideExisting:!0,addIfMissing:!0}):r.splice(i,1,n)})}export const DEFAULT_MERGE_OPTIONS={overrideExisting:!1,addIfMissing:!0};
+/**
+ * Merges 2 js objects recursively with all properties.
+ * - does not modify base object
+ * - can override or only add missing ones
+ *
+ * @param base - base object to merge data into
+ * @param override - object with new data which should be merged
+ * @param options - merge options
+ * @doc-tags tricky,utility
+ */
+export function merge(base, override, options = DEFAULT_MERGE_OPTIONS) {
+    function doMerge(base, override) {
+        for (const k in override) {
+            if (k in base) {
+                if (typeof base[k] === 'object' && base[k] !== null && !Array.isArray(base[k])) {
+                    doMerge(base[k], override[k]);
+                }
+                else {
+                    // do not merge arrays or functions
+                    if (options === null || options === void 0 ? void 0 : options.overrideExisting) {
+                        base[k] = override[k];
+                    }
+                }
+            }
+            else {
+                if (options === null || options === void 0 ? void 0 : options.addIfMissing) {
+                    base[k] = override[k];
+                }
+            }
+        }
+        return base;
+    }
+    return doMerge(base, override);
+}
+export function mergeArray(base, override, hashFn, mergeObjects = false) {
+    if (!base || !override || override.length === 0) {
+        return;
+    }
+    override.forEach(o => {
+        const hash = hashFn(o);
+        const existingIndex = base.findIndex(b => hashFn(b) === hash);
+        if (existingIndex === -1) {
+            base.push(o);
+        }
+        else {
+            if (mergeObjects) {
+                // try merging objects in array
+                merge(base[existingIndex], o, { overrideExisting: true, addIfMissing: true });
+            }
+            else {
+                base.splice(existingIndex, 1, o);
+            }
+        }
+    });
+}
+export const DEFAULT_MERGE_OPTIONS = { overrideExisting: false, addIfMissing: true };

package/dist/chart/utils/object.utils.js

@@ -3,4 +3,46 @@
  * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
  * If a copy of the MPL was not distributed with this file, You can obtain one at https://mozilla.org/MPL/2.0/.
  */
-export const cloneUnsafe=e=>JSON.parse(JSON.stringify(e));export function typedEntries_UNSAFE(e){return Object.entries(e)}export const findKeyFromValue=(e,t)=>{for(const[r,s]of Array.from(e.entries()))if(s===t)return r};export function keys(e){return Object.keys(e)}export function deepEqual(e,t){if(Object.is(e,t))return!0;if(typeof e!="object"||e===null||typeof t!="object"||t===null)return!1;const r=Object.keys(e),s=Object.keys(t);if(r.length!==s.length)return!1;for(let n=0,f=r.length;n<f;n++)if(!hasOwnProperty.call(t,r[n])||!deepEqual(e[r[n]],t[r[n]]))return!1;return!0}
+export const cloneUnsafe = (value) => JSON.parse(JSON.stringify(value));
+export function typedEntries_UNSAFE(obj) {
+    // eslint-disable-next-line no-restricted-syntax
+    return Object.entries(obj);
+}
+export const findKeyFromValue = (map, mapValue) => {
+    for (const [key, value] of Array.from(map.entries())) {
+        if (value === mapValue) {
+            return key;
+        }
+    }
+};
+export function keys(r) {
+    // eslint-disable-next-line no-restricted-syntax
+    return Object.keys(r);
+}
+/**
+ * Deeply compares two objects
+ * @param {*} objA
+ * @param {*} objB
+ * @returns {Boolean}
+ */
+export function deepEqual(objA, objB) {
+    if (Object.is(objA, objB)) {
+        return true;
+    }
+    if (typeof objA !== 'object' || objA === null || typeof objB !== 'object' || objB === null) {
+        return false;
+    }
+    const keysA = Object.keys(objA);
+    const keysB = Object.keys(objB);
+    if (keysA.length !== keysB.length) {
+        return false;
+    }
+    // Test for A's keys different from B.
+    for (let i = 0, len = keysA.length; i < len; i++) {
+        // @ts-ignore
+        if (!hasOwnProperty.call(objB, keysA[i]) || !deepEqual(objA[keysA[i]], objB[keysA[i]])) {
+            return false;
+        }
+    }
+    return true;
+}

package/dist/chart/utils/performance/animation-frame-cache.utils.js

@@ -0,0 +1,77 @@
+/*
+ * Copyright (C) 2019 - 2023 Devexperts Solutions IE Limited
+ * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
+ * If a copy of the MPL was not distributed with this file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+import { animationFrameThrottled } from './request-animation-frame-throttle.utils';
+import { uuid } from '../uuid.utils';
+/**
+ * Use this as a wrapper to cache calculation results during single animation frame cycle.
+ * It is useful if
+ * - you have multiple invocations of same code in same animation frame
+ * - you're sure that result will always be the same
+ */
+export class AnimationFrameCache {
+    constructor(dataProvider, dataUpdatedPredicate = () => true) {
+        this.dataProvider = dataProvider;
+        this.dataUpdatedPredicate = dataUpdatedPredicate;
+        this.calculatedInThisFrame = false;
+        this.animFrameId = `anim_cache_${uuid()}`;
+    }
+    /**
+     * Calculates or retrieves a cached value.
+     * If the value has not been calculated in the current frame, it calculates it by calling the dataProvider function.
+     * If the data has been updated, it sets the calculatedInThisFrame flag to true.
+     * It also sets a throttled animation frame to reset the calculatedInThisFrame flag to false.
+     * If the cache is not null, it returns the cached value, otherwise it calls the dataProvider function and returns its result.
+     * @returns {T} The cached or calculated value.
+     */
+    calculateOrGet() {
+        var _a;
+        if (!this.calculatedInThisFrame) {
+            this.cache = this.dataProvider();
+            if (this.dataUpdatedPredicate()) {
+                this.calculatedInThisFrame = true;
+            }
+            animationFrameThrottled(this.animFrameId, () => {
+                this.calculatedInThisFrame = false;
+            });
+        }
+        return (_a = this.cache) !== null && _a !== void 0 ? _a : this.dataProvider();
+    }
+    /**
+     * Invalidates the current state and returns the result of the calculateOrGet() method.
+     * @returns {T} The result of the calculateOrGet() method.
+     */
+    forceCalculateOrGet() {
+        this.invalidate();
+        return this.calculateOrGet();
+    }
+    /**
+     * Returns the last cached value or undefined if there is no cached value.
+     * @returns {T | undefined} The last cached value or undefined.
+     */
+    getLastCachedValue() {
+        return this.cache;
+    }
+    /**
+     * Updates the cache value with the provided value.
+     * @param {T} value - The new value to be set in the cache.
+     * @returns {void}
+     */
+    updateCacheValue(value) {
+        this.cache = value;
+    }
+    /**
+     * Invalidates the cache and sets the calculatedInThisFrame flag to false.
+     * @function
+     * @name invalidate
+     * @memberof ClassName
+     * @instance
+     * @returns {void}
+     */
+    invalidate() {
+        this.cache = undefined;
+        this.calculatedInThisFrame = false;
+    }
+}

package/dist/chart/utils/{perfomance → performance}/debounce.utils.js

@@ -3,4 +3,10 @@
  * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
  * If a copy of the MPL was not distributed with this file, You can obtain one at https://mozilla.org/MPL/2.0/.
  */
-export const debounce=(t,o)=>{let e=0;return(...u)=>{clearTimeout(e),e=+setTimeout(()=>t(...u),o)}};
+export const debounce = (callback, waitFor) => {
+    let timeout = 0;
+    return (...args) => {
+        clearTimeout(timeout);
+        timeout = +setTimeout(() => callback(...args), waitFor);
+    };
+};

package/dist/chart/utils/performance/memoize.utils.js

@@ -0,0 +1,74 @@
+/*
+ * Copyright (C) 2019 - 2023 Devexperts Solutions IE Limited
+ * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
+ * If a copy of the MPL was not distributed with this file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+// eslint-disable-next-line no-restricted-syntax
+export const MEMOIZE_CLEAR_FUNCTION = Symbol('MEMOIZE_CLEAR_FUNCTION');
+/**
+ * Memoizes function for passed arguments
+ * @doc-tags utility
+ */
+// eslint-disable-next-line @typescript-eslint/ban-types
+export function memoize(fn) {
+    const storage = {};
+    const result = function () {
+        const args = Array.prototype.slice.call(arguments);
+        const key = serialize(args);
+        if (typeof storage[key] === 'undefined') {
+            // eslint-disable-next-line no-restricted-syntax
+            storage[key] = fn.apply(this, args);
+        }
+        return storage[key];
+    }.bind(this);
+    // inject clearer
+    // @ts-ignore
+    result[MEMOIZE_CLEAR_FUNCTION] = function () {
+        const args = Array.prototype.slice.call(arguments);
+        const key = serialize(args);
+        delete storage[key];
+    };
+    // eslint-disable-next-line no-restricted-syntax
+    return result;
+}
+export const memoOnce = (E) => (f) => {
+    let hasValue = false;
+    let cachedR;
+    // eslint-disable-next-line no-restricted-syntax
+    let cachedArgs = [];
+    const update = (args) => {
+        cachedR = f(...args);
+        hasValue = true;
+        cachedArgs = args;
+    };
+    return (...args) => {
+        const length = args.length;
+        if (hasValue && length === 0) {
+            return cachedR;
+        }
+        if (!hasValue || cachedArgs.length !== length) {
+            update(args);
+            return cachedR;
+        }
+        for (let i = 0; i < length; i++) {
+            if (!E.equals(cachedArgs[i], args[i])) {
+                update(args);
+                return cachedR;
+            }
+        }
+        return cachedR;
+    };
+};
+/**
+ * @param {Array.<*>} args
+ * @returns {String}
+ */
+export function serialize(args) {
+    const argsAreValid = args.every(arg => {
+        return typeof arg === 'number' || typeof arg === 'string' || typeof arg === 'boolean';
+    });
+    if (!argsAreValid) {
+        throw Error('Arguments to memoized function can only be strings or numbers');
+    }
+    return JSON.stringify(args);
+}

package/dist/chart/utils/performance/request-animation-frame-throttle.utils.js

@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2019 - 2023 Devexperts Solutions IE Limited
+ * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
+ * If a copy of the MPL was not distributed with this file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+let fired = false;
+export let animationFrameId = 0;
+// map is faster than record
+const actions = new Map();
+const priorActions = new Map();
+const animFrame = () => {
+    if (!fired) {
+        fired = true;
+        animationFrameId = requestAnimationFrame(() => {
+            priorActions.forEach((action, key) => {
+                action();
+                priorActions.delete(key);
+            });
+            actions.forEach((action, key) => {
+                action();
+                actions.delete(key);
+            });
+            fired = false;
+        });
+    }
+};
+export const animationFrameThrottled = (name, action) => {
+    actions.set(name, action);
+    animFrame();
+};
+export const cancelThrottledAnimationFrame = (name) => {
+    actions.delete(name);
+};
+/**
+ * Prior actions will be called before regular actions
+ * An example of regular action - draw event
+ * @param name
+ * @param action
+ */
+export const animationFrameThrottledPrior = (name, action) => {
+    priorActions.set(name, action);
+    animFrame();
+};

package/dist/chart/utils/performance/throttle.utils.js

@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2019 - 2023 Devexperts Solutions IE Limited
+ * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
+ * If a copy of the MPL was not distributed with this file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+import { uuid } from '../uuid.utils';
+import { animationFrameThrottled } from './request-animation-frame-throttle.utils';
+export function throttle(shouldPreventDefault, listener, isSuppressed) {
+    let last;
+    const animFrameId = uuid();
+    function fireLastEvent() {
+        const event = last;
+        last = void 0;
+        if (event) {
+            listener(event);
+        }
+    }
+    return function (event) {
+        const hasEvent = last;
+        last = event;
+        shouldPreventDefault && event.preventDefault();
+        if (!hasEvent && !(typeof isSuppressed === 'function' && isSuppressed())) {
+            animationFrameThrottled(animFrameId, fireLastEvent);
+        }
+    };
+}

package/dist/chart/utils/price-increments.utils.d.ts

@@ -42,3 +42,4 @@ export declare class PriceIncrementsUtils {
      */
     static validatePriceIncrementsOrPrecisions(data: number[]): boolean;
 }
+export declare const precisionsToIncrement: (price: number, precisions: number[]) => number;