@devexperts/dxcharts-lite 1.0.1 → 2.0.0

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

@@ -1,6 +1,61 @@
 /*
- * Copyright (C) 2002 - 2023 Devexperts LLC
+ * 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 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.d.ts

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2002 - 2023 Devexperts LLC
+ * 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/.
  */

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

@@ -1,6 +1,48 @@
 /*
- * Copyright (C) 2002 - 2023 Devexperts LLC
+ * 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 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/{perfomance → performance}/animation-frame-cache.utils.d.ts

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2002 - 2023 Devexperts LLC
+ * 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/.
  */

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.d.ts

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2002 - 2023 Devexperts LLC
+ * 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/.
  */

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

@@ -0,0 +1,12 @@
+/*
+ * 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 const debounce = (callback, waitFor) => {
+    let timeout = 0;
+    return (...args) => {
+        clearTimeout(timeout);
+        timeout = +setTimeout(() => callback(...args), waitFor);
+    };
+};

package/dist/chart/utils/{perfomance → performance}/memoize.utils.d.ts

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2002 - 2023 Devexperts LLC
+ * 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/.
  */

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/{perfomance → performance}/request-animation-frame-throttle.utils.d.ts

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2002 - 2023 Devexperts LLC
+ * 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/.
  */

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/{perfomance → performance}/throttle.utils.d.ts

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2002 - 2023 Devexperts LLC
+ * 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/.
  */

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

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2002 - 2023 Devexperts LLC
+ * 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/.
  */
@@ -42,3 +42,4 @@ export declare class PriceIncrementsUtils {
      */
     static validatePriceIncrementsOrPrecisions(data: number[]): boolean;
 }
+export declare const precisionsToIncrement: (price: number, precisions: number[]) => number;

package/dist/chart/utils/price-increments.utils.js

@@ -1,6 +1,132 @@
 /*
- * Copyright (C) 2002 - 2023 Devexperts LLC
+ * 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{floor as i,MathUtils as u}from"./math.utils";class o{static autoDetectIncrementOfValueRange(r){const a=this.getDigitsInNumber(r);return r===0?.01:Math.pow(10,a-3)}static getDigitsInNumber(r){const a=h=>i(Math.log10((h^h>>31)-(h>>31)))+1;let t=a(r);return t===1&&r<1&&(t=a(r*1e9)-9),t}static getPriceIncrement(r,a=[]){if(!this.validatePriceIncrementsOrPrecisions(a))return this.DEFAULT_INCREMENT;if(isNaN(r))return Math.round(a[0]);r=Math.abs(r);let t=1;const h=1e-6;for(;t<a.length&&r>a[t]+Math.min(a[t-1],a[t+1])*h;)t+=2;return t>=a.length||r<a[t]-Math.min(a[t-1],a[t+1])*h?a[t-1]:Math.min(a[t-1],a[t+1])}static getPricePrecision(r,a){if(!this.validatePriceIncrementsOrPrecisions(a))return 0;if(isNaN(r))return Math.round(a[0]);r=Math.abs(r);let t=1;for(;t<a.length&&r>a[t];)t+=2;return Math.round(a[t-1])}static roundPriceToIncrement(r,a,t){const h=o.getPriceIncrement(t||r,a);return u.roundToNearest(r,h)}static computePrecisions(r){const a=[...r];for(let t=0;t<r.length;t+=2)a[t]=o.calculatePrecision(r[t]);for(let t=1;t<r.length;t+=2)a[t]=r[t]+Math.min(r[t-1],r[t+1])*o.RELATIVE_EPS;return a}static calculatePrecision(r){let a=r>1?Math.abs(Math.floor(r)-r):r;for(let t=0;t<o.MAXIMUM_PRECISION;t++){const h=Math.floor(a+.5),M=Math.abs(a*o.RELATIVE_EPS);if(h>=a-M&&h<=a+M)return t;a*=10}return o.MAXIMUM_PRECISION}static validatePriceIncrementsOrPrecisions(r){return!(r.length===0||!Array.isArray(r)||r.findIndex(a=>a!==0)===-1)}}o.DEFAULT_INCREMENT=.01,o.DEFAULT_PRECISION=2,o.RELATIVE_EPS=1e-8,o.MAXIMUM_PRECISION=10;export{o as PriceIncrementsUtils};
+import { lastOf } from './array.utils';
+import { floor, MathUtils } from './math.utils';
+class PriceIncrementsUtils {
+    /**
+     * Automatically detects increment of provided value range.
+     * Naive algorithm takes 1st mantissa number's :
+     * range=124.14 	=> increment=1
+     * range=6300.02931	=> increment=10
+     * range=0.0018		=> increment=0.00001
+     *
+     * @param valueRange
+     * @doc-tags tricky,y-axis
+     */
+    static autoDetectIncrementOfValueRange(valueRange) {
+        const extent = this.getDigitsInNumber(valueRange);
+        if (valueRange === 0) {
+            return 0.01;
+        }
+        else {
+            return Math.pow(10, extent - 3);
+        }
+    }
+    /**
+     * Gets number of digits in number.
+     * 20 => 2
+     * 100 => 3
+     * 7 => 1
+     * 1.123 => 1
+     * -200 => 3
+     * -1234567.00031 => 7
+     * 0.0001 = > -4
+     * @param x - any number
+     */
+    static getDigitsInNumber(x) {
+        // eslint-disable-next-line no-bitwise
+        const getDigits = (val) => floor(Math.log10((val ^ (val >> 31)) - (val >> 31))) + 1;
+        let numberDigitsIntegerPart = getDigits(x);
+        if (numberDigitsIntegerPart === 1 && x < 1) {
+            numberDigitsIntegerPart = getDigits(x * 10e8) - 9;
+        }
+        return numberDigitsIntegerPart;
+    }
+    // Price increment represent array of increment-price couples and trailing increment
+    // e.g. [(priceIncrement, price,)*  incrementForOtherPrices]
+    // [0.01, 1, 0.1, 10, 1] means
+    // there are three  increments (0.01 for price < 1 ), (0.1 for price < 10), (1 for any other price)
+    static getPriceIncrement(price, increments = []) {
+        if (!this.validatePriceIncrementsOrPrecisions(increments)) {
+            return this.DEFAULT_INCREMENT;
+        }
+        if (isNaN(price)) {
+            return Math.round(increments[0]);
+        }
+        price = Math.abs(price);
+        let i = 1;
+        const RELATIVE_EPS = 1e-6;
+        while (i < increments.length &&
+            price > increments[i] + Math.min(increments[i - 1], increments[i + 1]) * RELATIVE_EPS) {
+            i += 2;
+        }
+        if (i >= increments.length ||
+            price < increments[i] - Math.min(increments[i - 1], increments[i + 1]) * RELATIVE_EPS) {
+            return increments[i - 1];
+        }
+        return Math.min(increments[i - 1], increments[i + 1]);
+    }
+    static getPricePrecision(price, precisions) {
+        if (!this.validatePriceIncrementsOrPrecisions(precisions)) {
+            return 0;
+        }
+        if (isNaN(price)) {
+            return Math.round(precisions[0]);
+        }
+        price = Math.abs(price);
+        let i = 1;
+        while (i < precisions.length && price > precisions[i]) {
+            i += 2;
+        }
+        return Math.round(precisions[i - 1]);
+    }
+    static roundPriceToIncrement(price, increments, incrementReferencePrice) {
+        const increment = PriceIncrementsUtils.getPriceIncrement(incrementReferencePrice ? incrementReferencePrice : price, increments);
+        return MathUtils.roundToNearest(price, increment);
+    }
+    static computePrecisions(increments) {
+        const precisions = [...increments];
+        for (let i = 0; i < increments.length; i += 2) {
+            precisions[i] = PriceIncrementsUtils.calculatePrecision(increments[i]);
+        }
+        for (let i = 1; i < increments.length; i += 2) {
+            precisions[i] =
+                increments[i] + Math.min(increments[i - 1], increments[i + 1]) * PriceIncrementsUtils.RELATIVE_EPS;
+        }
+        return precisions;
+    }
+    static calculatePrecision(value) {
+        // in case value is a huge number we need to perform normalization so that relative epsilon still works
+        let val = value > 1 ? Math.abs(Math.floor(value) - value) : value;
+        for (let i = 0; i < PriceIncrementsUtils.MAXIMUM_PRECISION; i++) {
+            const round = Math.floor(val + 0.5);
+            const eps = Math.abs(val * PriceIncrementsUtils.RELATIVE_EPS);
+            if (round >= val - eps && round <= val + eps) {
+                return i;
+            }
+            val *= 10;
+        }
+        return PriceIncrementsUtils.MAXIMUM_PRECISION;
+    }
+    /**
+     * checks if the received from feed increments/precisions data is valid to display
+     * examples of wrong data: [], [0], not an array
+     */
+    static validatePriceIncrementsOrPrecisions(data) {
+        return !(data.length === 0 || !Array.isArray(data) || data.findIndex((i) => i !== 0) === -1);
+    }
+}
+PriceIncrementsUtils.DEFAULT_INCREMENT = 0.01;
+PriceIncrementsUtils.DEFAULT_PRECISION = 2;
+PriceIncrementsUtils.RELATIVE_EPS = 1e-8;
+PriceIncrementsUtils.MAXIMUM_PRECISION = 10;
+export { PriceIncrementsUtils };
+// TODO review dxFeed precision format
+export const precisionsToIncrement = (price, precisions) => {
+    var _a;
+    const precision = (_a = lastOf(precisions)) !== null && _a !== void 0 ? _a : 1;
+    return Math.pow(10, -precision);
+};

package/dist/chart/utils/uuid.utils.d.ts

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2002 - 2023 Devexperts LLC
+ * 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/.
  */

package/dist/chart/utils/uuid.utils.js

@@ -1,6 +1,9 @@
 /*
- * Copyright (C) 2002 - 2023 Devexperts LLC
+ * 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 function uuid(){const t=()=>Math.random().toString(16).slice(-4);return`${t()+t()}-${t()}-${t()}-${t()}-${t()+t()+t()}`}
+export function uuid() {
+    const chr4 = () => Math.random().toString(16).slice(-4);
+    return `${chr4() + chr4()}-${chr4()}-${chr4()}-${chr4()}-${chr4() + chr4() + chr4()}`;
+}