@devexperts/dxcharts-lite 1.0.1

package/dist/chart/utils/dom.utils.js

@@ -0,0 +1,6 @@
+/*
+ * Copyright (C) 2002 - 2023 Devexperts LLC
+ * 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 subscribeListener(n,r,i,t){return n.addEventListener(i,r,t),function(){n.removeEventListener(i,r,t)}}

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

@@ -0,0 +1,13 @@
+/*
+ * Copyright (C) 2002 - 2023 Devexperts LLC
+ * 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 interface Unsubscriber {
+    (): void;
+}
+export declare function clearerSafe(arr: Array<Unsubscriber>): Unsubscriber;
+export declare function identity<T>(x: T): T;
+export declare function notEmpty<T>(value: T | null | undefined): value is T;
+export declare const constVoid: () => undefined;
+export declare function nonNullableTypeGuard<T>(x: T | undefined | null): x is T;

package/dist/chart/utils/function.utils.js

@@ -0,0 +1,6 @@
+/*
+ * Copyright (C) 2002 - 2023 Devexperts LLC
+ * 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 clearerSafe(n){return function(){n.forEach(t=>typeof t=="function"&&t()),n.length=0}}export function identity(n){return n}export function notEmpty(n){return n!=null}export const constVoid=()=>{};export function nonNullableTypeGuard(n){return n!=null}

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

@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 2002 - 2023 Devexperts LLC
+ * 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 declare const MAX_DECIMAL_DIGITS = 14;
+export type NumberFormatLabels = 'K' | 'M' | 'B';
+export declare class MathUtils {
+    static roundToNearest(value: number, precision: number): number;
+    static roundUpToNearest(value: number, precision: number): number;
+    static roundDecimal(x: number): number;
+    static makeDecimal(value: number, precision: number, decimal?: string): string;
+    static compare(a: number, b: number, eps: number): number;
+    static isZero(a: number): boolean;
+    static cutNumber(value: number, amountToCut: NumberFormatLabels, zeros?: number): string;
+}
+/**
+ * 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 declare function isDiffersBy(first: number, second: number, times: number): boolean;
+export declare function clamp(value: number, min: number, max: number): number;
+export declare function easeExpOut(value: number): number;
+/**
+ * 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 declare function finite(...args: (number | undefined)[]): number;
+/**
+ * These functions can be used only for chart coordinates because they all are working in positive coordinates!!!
+ */
+export declare const floor: (value: number) => number;
+export declare const ceil: (value: number) => number;
+export declare const round: (value: number) => number;
+export declare const shiftRight: (value: number, shift: number) => number;

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

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

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

@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) 2002 - 2023 Devexperts LLC
+ * 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/.
+ */
+/**
+ * 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 declare function merge(base: Record<string, any>, override: Record<string, any>, options?: MergeOptions): any;
+export declare function mergeArray<A extends Record<string, any>>(base: Array<A>, override: Array<A>, hashFn: (a: A) => string, mergeObjects?: boolean): void;
+export declare const DEFAULT_MERGE_OPTIONS: {
+    overrideExisting: boolean;
+    addIfMissing: boolean;
+};
+export interface MergeOptions {
+    /** whether we need to override value if it's already presented in config. Note for arrays: if this flag is true, arrays replaced entirely */
+    overrideExisting: boolean;
+    /** whether we need to add a property to config, if this property was absent */
+    addIfMissing: boolean;
+}

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

@@ -0,0 +1,6 @@
+/*
+ * Copyright (C) 2002 - 2023 Devexperts LLC
+ * 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};

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

@@ -0,0 +1,46 @@
+/*
+ * Copyright (C) 2002 - 2023 Devexperts LLC
+ * 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/.
+ */
+/**
+ * @description
+ * Helps with the partial objects functions arguments, but errors the empty object case, which is allowed by simple Partial<T>
+ * @example
+ * function badUpdateSomeEntity(updates: Partial<Entity>): Entity
+ * badUpdateSomeEntity({ property: 123 }) // ok
+ * badUpdateSomeEntity() // error - expected
+ * badUpdateSomeEntity({}) // ok - not expected, should not be allowed to do such operation
+ *
+ * function goodUpdateSomeEntity(object: AtLeastOne<Entity>): Entity
+ * goodUpdateSomeEntity({ property: 123 }) // ok
+ * goodUpdateSomeEntity() // error - expected
+ * goodUpdateSomeEntity({}) // error - nice!
+ */
+export type AtLeastOne<T, Keys extends keyof T = keyof T> = Partial<T> & {
+    [K in Keys]: Required<Pick<T, K>>;
+}[Keys];
+export interface StringTMap<T> {
+    [key: string]: T;
+}
+export type DeepPartial<T> = T extends (...args: unknown[]) => unknown ? T : T extends Record<string, any> ? T extends unknown[] ? DeepPartial<T[number]>[] : {
+    [P in keyof T]?: DeepPartial<T[P]>;
+} : T;
+export type DeepRequired<T> = T extends (...args: unknown[]) => unknown ? T : T extends Record<string, any> ? T extends unknown[] ? DeepRequired<T[number]>[] : {
+    [P in keyof T]-?: DeepRequired<T[P]>;
+} : T;
+export declare const cloneUnsafe: <T>(value: T) => T;
+type Entries<T extends object> = {
+    [K in keyof T]: [K, T[K]];
+}[keyof T][];
+export declare function typedEntries_UNSAFE<T extends object>(obj: T): Entries<T>;
+export declare const findKeyFromValue: <K, V>(map: Map<K, V>, mapValue: V) => K | undefined;
+export declare function keys<K extends string>(r: Partial<Record<K, unknown>>): Array<K>;
+/**
+ * Deeply compares two objects
+ * @param {*} objA
+ * @param {*} objB
+ * @returns {Boolean}
+ */
+export declare function deepEqual(objA: object, objB: object): boolean;
+export {};

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

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

package/dist/chart/utils/perfomance/animation-frame-cache.utils.d.ts

@@ -0,0 +1,53 @@
+/*
+ * Copyright (C) 2002 - 2023 Devexperts LLC
+ * 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/.
+ */
+/**
+ * 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 declare class AnimationFrameCache<T> {
+    private dataProvider;
+    private dataUpdatedPredicate;
+    calculatedInThisFrame: boolean;
+    cache?: T;
+    private animFrameId;
+    constructor(dataProvider: () => T, dataUpdatedPredicate?: () => boolean);
+    /**
+     * 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(): T;
+    /**
+     * Invalidates the current state and returns the result of the calculateOrGet() method.
+     * @returns {T} The result of the calculateOrGet() method.
+     */
+    forceCalculateOrGet(): T;
+    /**
+     * Returns the last cached value or undefined if there is no cached value.
+     * @returns {T | undefined} The last cached value or undefined.
+     */
+    getLastCachedValue(): T | undefined;
+    /**
+     * Updates the cache value with the provided value.
+     * @param {T} value - The new value to be set in the cache.
+     * @returns {void}
+     */
+    updateCacheValue(value: T): void;
+    /**
+     * Invalidates the cache and sets the calculatedInThisFrame flag to false.
+     * @function
+     * @name invalidate
+     * @memberof ClassName
+     * @instance
+     * @returns {void}
+     */
+    invalidate(): void;
+}

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

@@ -0,0 +1,6 @@
+/*
+ * Copyright (C) 2002 - 2023 Devexperts LLC
+ * 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 as e}from"./request-animation-frame-throttle.utils";import{uuid as i}from"../uuid.utils";export class AnimationFrameCache{constructor(a,t=()=>!0){this.dataProvider=a,this.dataUpdatedPredicate=t,this.calculatedInThisFrame=!1,this.animFrameId=`anim_cache_${i()}`}calculateOrGet(){var a;return this.calculatedInThisFrame||(this.cache=this.dataProvider(),this.dataUpdatedPredicate()&&(this.calculatedInThisFrame=!0),e(this.animFrameId,()=>{this.calculatedInThisFrame=!1})),(a=this.cache)!==null&&a!==void 0?a:this.dataProvider()}forceCalculateOrGet(){return this.invalidate(),this.calculateOrGet()}getLastCachedValue(){return this.cache}updateCacheValue(a){this.cache=a}invalidate(){this.cache=void 0,this.calculatedInThisFrame=!1}}

package/dist/chart/utils/perfomance/debounce.utils.d.ts

@@ -0,0 +1,6 @@
+/*
+ * Copyright (C) 2002 - 2023 Devexperts LLC
+ * 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 declare const debounce: <T extends (...args: any[]) => any>(callback: T, waitFor: number) => (...args: Parameters<T>) => void;

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

@@ -0,0 +1,6 @@
+/*
+ * Copyright (C) 2002 - 2023 Devexperts LLC
+ * 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)}};

package/dist/chart/utils/perfomance/memoize.utils.d.ts

@@ -0,0 +1,21 @@
+/*
+ * Copyright (C) 2002 - 2023 Devexperts LLC
+ * 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/.
+ */
+interface Eq<A> {
+    readonly equals: (x: A, y: A) => boolean;
+}
+export declare const MEMOIZE_CLEAR_FUNCTION: symbol;
+/**
+ * Memoizes function for passed arguments
+ * @doc-tags utility
+ */
+export declare function memoize<F extends Function>(this: any, fn: F): F;
+export declare const memoOnce: <A>(E: Eq<A>) => <Args extends A[], R>(f: (...args: Args) => R) => (...args: Args) => R;
+/**
+ * @param {Array.<*>} args
+ * @returns {String}
+ */
+export declare function serialize(args: any[]): string;
+export {};

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

@@ -0,0 +1,6 @@
+/*
+ * Copyright (C) 2002 - 2023 Devexperts LLC
+ * 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 MEMOIZE_CLEAR_FUNCTION=Symbol("MEMOIZE_CLEAR_FUNCTION");export function memoize(s){const r={},e=function(){const t=Array.prototype.slice.call(arguments),n=serialize(t);return typeof r[n]=="undefined"&&(r[n]=s.apply(this,t)),r[n]}.bind(this);return e[MEMOIZE_CLEAR_FUNCTION]=function(){const t=Array.prototype.slice.call(arguments),n=serialize(t);delete r[n]},e}export const memoOnce=s=>r=>{let e=!1,t,n=[];const l=o=>{t=r(...o),e=!0,n=o};return(...o)=>{const c=o.length;if(e&&c===0)return t;if(!e||n.length!==c)return l(o),t;for(let i=0;i<c;i++)if(!s.equals(n[i],o[i]))return l(o),t;return t}};export function serialize(s){if(!s.every(e=>typeof e=="number"||typeof e=="string"||typeof e=="boolean"))throw Error("Arguments to memoized function can only be strings or numbers");return JSON.stringify(s)}

package/dist/chart/utils/perfomance/request-animation-frame-throttle.utils.d.ts

@@ -0,0 +1,15 @@
+/*
+ * Copyright (C) 2002 - 2023 Devexperts LLC
+ * 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 declare let animationFrameId: number;
+export declare const animationFrameThrottled: (name: string, action: () => void) => void;
+export declare const cancelThrottledAnimationFrame: (name: string) => void;
+/**
+ * Prior actions will be called before regular actions
+ * An example of regular action - draw event
+ * @param name
+ * @param action
+ */
+export declare const animationFrameThrottledPrior: (name: string, action: () => void) => void;

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

@@ -0,0 +1,6 @@
+/*
+ * Copyright (C) 2002 - 2023 Devexperts LLC
+ * 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 a=!1;export let animationFrameId=0;const o=new Map,n=new Map,r=()=>{a||(a=!0,animationFrameId=requestAnimationFrame(()=>{n.forEach((e,t)=>{e(),n.delete(t)}),o.forEach((e,t)=>{e(),o.delete(t)}),a=!1}))};export const animationFrameThrottled=(e,t)=>{o.set(e,t),r()},cancelThrottledAnimationFrame=e=>{o.delete(e)},animationFrameThrottledPrior=(e,t)=>{n.set(e,t),r()};

package/dist/chart/utils/perfomance/throttle.utils.d.ts

@@ -0,0 +1,15 @@
+/*
+ * Copyright (C) 2002 - 2023 Devexperts LLC
+ * 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/.
+ */
+/**
+ @param shouldPreventDefault
+ @param {Function} listener
+ wraps the listener, that it would be fired not as frequent as event itself, but not more than every 30 ms
+ @param {Function} [isSuppressed] optional callback to check if the event is suppressed for some reason before adding
+ the handler in requestAnimationFrame, which would execute it asynchronously
+ @returns {Function}
+ */
+export declare function throttle<L extends EventListener>(shouldPreventDefault: boolean, listener: L, isSuppressed?: () => boolean): L;
+export declare function throttle(shouldPreventDefault: boolean, listener: EventListener, isSuppressed?: () => boolean): () => void;

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

@@ -0,0 +1,6 @@
+/*
+ * Copyright (C) 2002 - 2023 Devexperts LLC
+ * 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 as m}from"../uuid.utils";import{animationFrameThrottled as c}from"./request-animation-frame-throttle.utils";export function throttle(i,e,o){let n;const r=m();function f(){const t=n;n=void 0,t&&e(t)}return function(t){const a=n;n=t,i&&t.preventDefault(),!a&&!(typeof o=="function"&&o())&&c(r,f)}}

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

@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2002 - 2023 Devexperts LLC
+ * 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 declare class PriceIncrementsUtils {
+    static DEFAULT_INCREMENT: number;
+    static DEFAULT_PRECISION: number;
+    static RELATIVE_EPS: number;
+    static MAXIMUM_PRECISION: number;
+    /**
+     * 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: number): number;
+    /**
+     * 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
+     */
+    private static getDigitsInNumber;
+    static getPriceIncrement(price: number, increments?: number[]): number;
+    static getPricePrecision(price: number, precisions: number[]): number;
+    static roundPriceToIncrement(price: number, increments: number[], incrementReferencePrice: number): number;
+    static computePrecisions(increments: number[]): number[];
+    static calculatePrecision(value: number): number;
+    /**
+     * checks if the received from feed increments/precisions data is valid to display
+     * examples of wrong data: [], [0], not an array
+     */
+    static validatePriceIncrementsOrPrecisions(data: number[]): boolean;
+}

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

@@ -0,0 +1,6 @@
+/*
+ * Copyright (C) 2002 - 2023 Devexperts LLC
+ * 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};

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

@@ -0,0 +1,6 @@
+/*
+ * Copyright (C) 2002 - 2023 Devexperts LLC
+ * 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 declare function uuid(): string;

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

@@ -0,0 +1,6 @@
+/*
+ * Copyright (C) 2002 - 2023 Devexperts LLC
+ * 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()}`}