@devexperts/dxcharts-lite 1.0.1 → 2.0.0

package/dist/chart/utils/__tests__/array.utils.test.js

@@ -1,6 +1,140 @@
 /*
- * 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{moveInArrayMutable as c,reorderArray as a,slice2DArray as s,arrayIntersect as n,eqeqeq as l}from"../array.utils";describe("array functions",()=>{describe("Intersection of arrays",()=>{it("Intersection of [1, 2, 3, 1] and [1, 2, 4, 5, 6] should be [1, 2]",()=>{const r=n([1,2,3,1],[1,2,4,5,6]);expect(r).toEqual([1,2])}),it("Intersection of [1, 2, 3] and [4, 5, 6] should be an empty array",()=>{const r=n([1,2,3],[4,5,6]);expect(r).toEqual([])}),it("Intersection of [1, 2, 2, 3] and [1, 1, 2, 2, 4, 5] with duplicates should be [1, 2, 2]",()=>{const r=n([1,2,2,3],[1,1,2,2,4,5],l,!1);expect(r).toEqual([1,2,2])}),it("Intersection of [] and [1, 1, 2] should be []",()=>{const r=n([],[1,1,2]);expect(r).toEqual([])}),it("Intersection of [1, 1, 2] and [] should be []",()=>{const r=n([1,1,2],[]);expect(r).toEqual([])}),it("Intersection with custom comparison function",()=>{const o=n([{id:1},{id:2},{id:3}],[{id:2},{id:4},{id:6}],(i,u)=>i.id===u.id);expect(o).toEqual([{id:2}])}),it("Intersection of arrays of strings",()=>{const r=n(["apple","banana","orange","pear"],["banana","orange","grape","kiwi"]);expect(r).toEqual(["banana","orange"])})}),describe("slice 2D array",()=>{it("should correctly slice arrays with correct indexes",()=>{const t=[[1,2],[3,4]],e=s(t,1,2);expect(e.toString()).toBe([[2],[3]].toString());const r=s(t,0,1);expect(r.toString()).toBe([[1,2]].toString());const o=s(t,2,3);expect(o.toString()).toBe([[3,4]].toString());const i=s(t,0,3);expect(i.toString()).toBe([[1,2],[3,4]].toString())}),it("should corrercly slice arrays with exceeding indexes",()=>{const t=[[1,2],[3,4]],e=s(t,-2,0);expect(e.toString()).toBe([[1]].toString());const r=s(t,3,4);expect(r.toString()).toBe([[4]].toString());const o=s(t,-2,4);expect(o.toString()).toBe([[1,2],[3,4]].toString())})}),describe("reorder array",()=>{it("Reorders source array according to newOrder",()=>{const t=["1","2","3"],e=a(t,["3","1"]);expect(e.toString()).toBe(["3","2","1"].toString());const r=a(t,["3","1","2"]);expect(r.toString()).toBe(["3","1","2"].toString());const o=a(t,["3"]);expect(o.toString()).toBe(["1","2","3"].toString())}),it("should return the reordered array even if newOrder contains duplicates",()=>{const t=["1","2","3"],e=["2","1","2"];expect(a(t,e)).toEqual(["2","1","3"])}),it("should return the reordered array even if newOrder contains extra elements",()=>{const t=["1","2","3"],e=["6","2","1","5"];expect(a(t,e)).toEqual(["2","1","3"])})}),describe("moveInArrayMutable",()=>{it("should move an item from start to end",()=>{const e=c([1,2,3,4,5],1,3);expect(e).toEqual([1,3,4,2,5])}),it("should move an item from end to start",()=>{const e=c([1,2,3,4,5],4,1);expect(e).toEqual([1,5,2,3,4])}),it("should move an item to the same position",()=>{const e=c([1,2,3,4,5],2,2);expect(e).toEqual([1,2,3,4,5])}),it("should clamp from and to if start and end are out of bounds",()=>{const e=c([1,2,3,4,5],-1,6);expect(e).toEqual([2,3,4,5,1])}),it("should return the same array if start and end are the same",()=>{const e=c([1,2,3,4,5],2,2);expect(e).toEqual([1,2,3,4,5])}),it("should return the same array if we try to move first element outside left bound",()=>{const e=c([1,2,3,4,5],0,-1);expect(e).toEqual([1,2,3,4,5])})})});
+import { moveInArrayMutable, reorderArray, slice2DArray, arrayIntersect, eqeqeq } from '../array.utils';
+describe('array functions', () => {
+    describe('Intersection of arrays', () => {
+        it('Intersection of [1, 2, 3, 1] and [1, 2, 4, 5, 6] should be [1, 2]', () => {
+            const source = [1, 2, 3, 1];
+            const target = [1, 2, 4, 5, 6];
+            const result = arrayIntersect(source, target);
+            expect(result).toEqual([1, 2]);
+        });
+        it('Intersection of [1, 2, 3] and [4, 5, 6] should be an empty array', () => {
+            const source = [1, 2, 3];
+            const target = [4, 5, 6];
+            const result = arrayIntersect(source, target);
+            expect(result).toEqual([]);
+        });
+        it('Intersection of [1, 2, 2, 3] and [1, 1, 2, 2, 4, 5] with duplicates should be [1, 2, 2]', () => {
+            const source = [1, 2, 2, 3];
+            const target = [1, 1, 2, 2, 4, 5];
+            const result = arrayIntersect(source, target, eqeqeq, false);
+            expect(result).toEqual([1, 2, 2]);
+        });
+        it('Intersection of [] and [1, 1, 2] should be []', () => {
+            const source = [];
+            const target = [1, 1, 2];
+            const result = arrayIntersect(source, target);
+            expect(result).toEqual([]);
+        });
+        it('Intersection of [1, 1, 2] and [] should be []', () => {
+            const source = [1, 1, 2];
+            const target = [];
+            const result = arrayIntersect(source, target);
+            expect(result).toEqual([]);
+        });
+        it('Intersection with custom comparison function', () => {
+            const source = [{ id: 1 }, { id: 2 }, { id: 3 }];
+            const target = [{ id: 2 }, { id: 4 }, { id: 6 }];
+            const compareFn = (a, b) => a.id === b.id;
+            const result = arrayIntersect(source, target, compareFn);
+            expect(result).toEqual([{ id: 2 }]);
+        });
+        it('Intersection of arrays of strings', () => {
+            const source = ['apple', 'banana', 'orange', 'pear'];
+            const target = ['banana', 'orange', 'grape', 'kiwi'];
+            const result = arrayIntersect(source, target);
+            expect(result).toEqual(['banana', 'orange']);
+        });
+    });
+    describe('slice 2D array', () => {
+        it('should correctly slice arrays with correct indexes', () => {
+            const array = [
+                [1, 2],
+                [3, 4],
+            ];
+            const result = slice2DArray(array, 1, 2);
+            expect(result.toString()).toBe([[2], [3]].toString());
+            const result2 = slice2DArray(array, 0, 1);
+            expect(result2.toString()).toBe([[1, 2]].toString());
+            const result3 = slice2DArray(array, 2, 3);
+            expect(result3.toString()).toBe([[3, 4]].toString());
+            const result4 = slice2DArray(array, 0, 3);
+            expect(result4.toString()).toBe([
+                [1, 2],
+                [3, 4],
+            ].toString());
+        });
+        it('should corrercly slice arrays with exceeding indexes', () => {
+            const array = [
+                [1, 2],
+                [3, 4],
+            ];
+            const result = slice2DArray(array, -2, 0);
+            expect(result.toString()).toBe([[1]].toString());
+            const result2 = slice2DArray(array, 3, 4);
+            expect(result2.toString()).toBe([[4]].toString());
+            const result3 = slice2DArray(array, -2, 4);
+            expect(result3.toString()).toBe([
+                [1, 2],
+                [3, 4],
+            ].toString());
+        });
+    });
+    describe('reorder array', () => {
+        it('Reorders source array according to newOrder', () => {
+            const array = ['1', '2', '3'];
+            const result1 = reorderArray(array, ['3', '1']);
+            expect(result1.toString()).toBe(['3', '2', '1'].toString());
+            const result2 = reorderArray(array, ['3', '1', '2']);
+            expect(result2.toString()).toBe(['3', '1', '2'].toString());
+            const result3 = reorderArray(array, ['3']);
+            expect(result3.toString()).toBe(['1', '2', '3'].toString());
+        });
+        it('should return the reordered array even if newOrder contains duplicates', () => {
+            const source = ['1', '2', '3'];
+            const newOrder = ['2', '1', '2'];
+            expect(reorderArray(source, newOrder)).toEqual(['2', '1', '3']);
+        });
+        it('should return the reordered array even if newOrder contains extra elements', () => {
+            const source = ['1', '2', '3'];
+            const newOrder = ['6', '2', '1', '5'];
+            expect(reorderArray(source, newOrder)).toEqual(['2', '1', '3']);
+        });
+    });
+    describe('moveInArrayMutable', () => {
+        it('should move an item from start to end', () => {
+            const arr = [1, 2, 3, 4, 5];
+            const result = moveInArrayMutable(arr, 1, 3);
+            expect(result).toEqual([1, 3, 4, 2, 5]);
+        });
+        it('should move an item from end to start', () => {
+            const arr = [1, 2, 3, 4, 5];
+            const result = moveInArrayMutable(arr, 4, 1);
+            expect(result).toEqual([1, 5, 2, 3, 4]);
+        });
+        it('should move an item to the same position', () => {
+            const arr = [1, 2, 3, 4, 5];
+            const result = moveInArrayMutable(arr, 2, 2);
+            expect(result).toEqual([1, 2, 3, 4, 5]);
+        });
+        it('should clamp from and to if start and end are out of bounds', () => {
+            const arr = [1, 2, 3, 4, 5];
+            const result = moveInArrayMutable(arr, -1, 6);
+            expect(result).toEqual([2, 3, 4, 5, 1]);
+        });
+        it('should return the same array if start and end are the same', () => {
+            const arr = [1, 2, 3, 4, 5];
+            const result = moveInArrayMutable(arr, 2, 2);
+            expect(result).toEqual([1, 2, 3, 4, 5]);
+        });
+        it('should return the same array if we try to move first element outside left bound', () => {
+            const arr = [1, 2, 3, 4, 5];
+            const result = moveInArrayMutable(arr, 0, -1);
+            expect(result).toEqual([1, 2, 3, 4, 5]);
+        });
+    });
+});

package/dist/chart/utils/{perfomance/debounce.utils.js → __tests__/math.utils.test.d.ts}

@@ -1,6 +1,6 @@
 /*
- * 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 debounce=(t,o)=>{let e=0;return(...u)=>{clearTimeout(e),e=+setTimeout(()=>t(...u),o)}};
+export {};

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

@@ -0,0 +1,19 @@
+/*
+ * 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 { clamp } from '../math.utils';
+describe('math.utils', () => {
+    describe('clamp', () => {
+        it('should return the value if it is within the range', () => {
+            expect(clamp(5, 0, 10)).toEqual(5);
+        });
+        it('should return the min value if the value is less than the min', () => {
+            expect(clamp(-5, 0, 10)).toEqual(0);
+        });
+        it('should return the max value if the value is more than the max', () => {
+            expect(clamp(15, 0, 10)).toEqual(10);
+        });
+    });
+});

package/dist/chart/utils/__tests__/object.utils.test.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/__tests__/object.utils.test.js

@@ -1,6 +1,16 @@
 /*
- * 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{deepEqual as e}from"../object.utils";describe("object",()=>{describe("deepEqual",()=>{it("should deeply compare objects",()=>{expect(e({},{})).toBeTruthy(),expect(e({a:{foo:1}},{a:{foo:1}})).toBeTruthy(),expect(e({a:{foo:1}},{a:{foo:2}})).toBeFalsy(),expect(e({a:{foo:1}},{a:{bar:1}})).toBeFalsy()})})});
+import { deepEqual } from '../object.utils';
+describe('object', () => {
+    describe('deepEqual', () => {
+        it('should deeply compare objects', () => {
+            expect(deepEqual({}, {})).toBeTruthy();
+            expect(deepEqual({ a: { foo: 1 } }, { a: { foo: 1 } })).toBeTruthy(); //eslint-disable-line
+            expect(deepEqual({ a: { foo: 1 } }, { a: { foo: 2 } })).toBeFalsy(); //eslint-disable-line
+            expect(deepEqual({ a: { foo: 1 } }, { a: { bar: 1 } })).toBeFalsy(); //eslint-disable-line
+        });
+    });
+});

package/dist/chart/utils/__tests__/priceIncrementsUtils.test.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/__tests__/priceIncrementsUtils.test.js

@@ -1,6 +1,34 @@
 /*
- * 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{PriceIncrementsUtils as t}from"../price-increments.utils";describe("PriceIncrementsUtils",()=>{describe("autoDetectIncrementOfValueRange",()=>{it("should return increment=0.01 for range=0",()=>{const e=t.autoDetectIncrementOfValueRange(0);expect(e).toBeCloseTo(.01,10)}),it("should return increment=10 for range=6300.02931",()=>{const e=t.autoDetectIncrementOfValueRange(6300.02931);expect(e).toBeCloseTo(10,10)}),it("should return increment=1 for range=124.14",()=>{const e=t.autoDetectIncrementOfValueRange(124.14);expect(e).toBeCloseTo(1,10)}),it("should return increment=0.01 for range=5",()=>{const e=t.autoDetectIncrementOfValueRange(5);expect(e).toBeCloseTo(.01,10)}),it("should return increment=0.001 for range=0.5",()=>{const e=t.autoDetectIncrementOfValueRange(.5);expect(e).toBeCloseTo(.001,10)}),it("should return increment=0.00001 for range=0.0018",()=>{const e=t.autoDetectIncrementOfValueRange(.0018);expect(e).toBeCloseTo(1e-5,10)})})});
+import { PriceIncrementsUtils } from '../price-increments.utils';
+describe('PriceIncrementsUtils', () => {
+    describe('autoDetectIncrementOfValueRange', () => {
+        it('should return increment=0.01 for range=0', () => {
+            const result = PriceIncrementsUtils.autoDetectIncrementOfValueRange(0);
+            expect(result).toBeCloseTo(0.01, 10);
+        });
+        it('should return increment=10 for range=6300.02931', () => {
+            const result = PriceIncrementsUtils.autoDetectIncrementOfValueRange(6300.02931);
+            expect(result).toBeCloseTo(10, 10);
+        });
+        it('should return increment=1 for range=124.14', () => {
+            const result = PriceIncrementsUtils.autoDetectIncrementOfValueRange(124.14);
+            expect(result).toBeCloseTo(1, 10);
+        });
+        it('should return increment=0.01 for range=5', () => {
+            const result = PriceIncrementsUtils.autoDetectIncrementOfValueRange(5);
+            expect(result).toBeCloseTo(0.01, 10);
+        });
+        it('should return increment=0.001 for range=0.5', () => {
+            const result = PriceIncrementsUtils.autoDetectIncrementOfValueRange(0.5);
+            expect(result).toBeCloseTo(0.001, 10);
+        });
+        it('should return increment=0.00001 for range=0.0018', () => {
+            const result = PriceIncrementsUtils.autoDetectIncrementOfValueRange(0.0018);
+            expect(result).toBeCloseTo(0.00001, 10);
+        });
+    });
+});

package/dist/chart/utils/array.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/.
  */
@@ -50,7 +50,7 @@ type ItemFinder<T> = (item: T) => boolean;
  */
 export declare function replaceInArray<T>(arr: Array<T>, itemFinder: ItemFinder<T>, replace: T): T[];
 export declare const uniqueArray: <T extends string | number>(arr: T[]) => T[];
-export declare const groupBy: <T, KT extends T[keyof T] extends string | number ? T[keyof T] : never>(array: T[], key: keyof T) => Record<KT, T[]>;
+export declare const groupBy: <T, K extends keyof T, KV extends T[K] extends string | number ? T[K] : never>(array: T[], key: K) => Record<KV, T[]>;
 /**
  * Inserts *something* between every two elements in the source array
  * Example: interleave(['first', 'second', 'third'], 'bar') => ['first', 'bar', 'second', 'bar', 'third']

package/dist/chart/utils/array.utils.js

@@ -1,6 +1,274 @@
 /*
- * 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{identity as x}from"./function.utils";import{clamp as d,shiftRight as a}from"./math.utils";export function arrayIntersect(t,e,r=eqeqeq,n=!0){const i=t.filter(o=>e.some(c=>r(o,c)));return n?i.filter((o,c,u)=>u.indexOf(o)===c):i}export const reorderArray=(t,e)=>{const r=e.slice().filter(n=>t.find(i=>i===n));return t.map(n=>{var i;return e.indexOf(n)>=0&&(i=r.shift())!==null&&i!==void 0?i:n})},eqeqeq=(t,e)=>t===e,arraySubtract=(t,e,r)=>t.filter(n=>e.filter(i=>r(n,i)).length===0);const m=(t,e)=>t===e;export const arrayCompare=(t,e,r=m)=>t.length===e.length&&t.every((n,i)=>r(n,e[i]));export function moveInArray(t,e,r){const n=t.slice(),i=n[e];return n.splice(e,1),n.splice(r,0,i),n}export function moveInArrayMutable(t,e,r){const n=t.length,i=d(e,0,n-1),o=d(r,0,n-1),c=t[i];return t.splice(i,1),t.splice(o,0,c),t}export function replaceInArray(t,e,r){const n=t.slice(),i=n.findIndex(e);return i!==-1&&(n.splice(i,1),n.splice(i,0,r)),n}export const uniqueArray=t=>{const e={};return t.filter(r=>e[r]?!1:e[r]=!0)},groupBy=(t,e)=>t.reduce((r,n)=>((r[n[e]]=r[n[e]]||[]).push(n),r),{}),interleave=(t,e)=>[].concat(...t.map(r=>[r,e])).slice(0,-1),isTwoDimArray=t=>Array.isArray(t[0]),create2DArray=t=>Array.isArray(t[0])?t:[t],slice2DArray=(t,e,r)=>{const n=[];let i=0;for(const o of t){const c=Math.max(e-i,0),u=Math.max(r-i,-1),s=o.slice(c,u+1);s.length>0&&n.push(s),i+=o.length}return n},at=(t,e)=>t>=0?e[t]:e[e.length+t],flat=t=>Array.prototype.flat?t.flat():flatMap(t,x),flatMap=(t,e)=>{if(Array.prototype.flatMap)return t.flatMap(e);const r=[];for(let n=0;n<t.length;n++){const i=t[n];r.push(...e(i,n,t))}return r};export function binarySearch(t,e,r){const n=r!=null?r:x;return!t.length||e!==e?{index:-1,exact:!0}:p(t,e,0,t.length,n)}function p(t,e,r,n,i){const o=a(r+n,1),c=i(t[o]);return e===c?{index:o,exact:!0}:r===o?{index:r,exact:!1}:e<c?p(t,e,r,o,i):p(t,e,o,n,i)}export function lastOf(t){if(t&&t.length)return t[t.length-1]}export function arrayRemove(t){const e=this.indexOf(t);return e!==-1&&this.splice(e,1),this}export function arrayRemove2(t,e){if(!t)return;const r=t.indexOf(e);r!==-1&&t.splice(r,1)}export function firstOf(t){if(t)return t[0]}export function maxMin(t){function e(r,n){const i=t(n);return i==null||!isFinite(i)?r:[Math.max(r[0],i),Math.min(r[1],i)]}return function(r){const n=[Number.NEGATIVE_INFINITY,Number.POSITIVE_INFINITY];return r?r.reduce(e,n):n}}export function getElementsInRange(t,e,r,n=()=>0){const i=(c,u)=>{let s=0,l=c.length-1;for(;l>=s;){const f=Math.ceil((s+l)/2);n(c[f])<=u?s=f+1:l=f-1}return l},o=(c,u)=>{let s=0,l=c.length-1;for(;l>=s;){const f=Math.ceil((s+l)/2);n(c[f])>=u?l=f-1:s=f+1}return s};return t.slice(o(t,e),i(t,r)+1)}
+import { identity } from './function.utils';
+import { clamp, shiftRight } from './math.utils';
+/**
+ * Intersects 2 arrays.
+ * Example:
+ *  source: [1, 2, 3, 1]
+ *  target: [1, 2, 4, 5, 6]
+ *  result: [1, 2]
+ *  result (with duplicates): [1, 1, 2]
+ * @param source
+ * @param target
+ * @param compareFn
+ * @param removeDuplicates
+ * @doc-tags fp,utility
+ */
+export function arrayIntersect(source, target, compareFn = eqeqeq, removeDuplicates = true) {
+    const intersection = source.filter(a => target.some(b => compareFn(a, b)));
+    if (removeDuplicates) {
+        return intersection.filter((value, index, self) => self.indexOf(value) === index);
+    }
+    return intersection;
+}
+/**
+ * Reorders source array according to newOrder.
+ * Returns a reorder copy of the source array.
+ * Example:
+ * 	source: ['1', '2', '3']
+ * 	newOrder: ['3', '1']
+ * 	result: ['3', '2', '1']
+ */
+export const reorderArray = (source, newOrder) => {
+    // filter out elements which are not presented in the source array
+    const order = newOrder.slice().filter(i => source.find(s => s === i));
+    return source.map(el => {
+        var _a;
+        if (newOrder.indexOf(el) >= 0) {
+            return (_a = order.shift()) !== null && _a !== void 0 ? _a : el;
+        }
+        return el;
+    });
+};
+export const eqeqeq = (a, b) => a === b;
+/**
+ * Subtracts target from source array.
+ * Example:
+ *   source: [1, 2, 3, 4]
+ *   target: [2, 4, 6]
+ *   result: [1, 3]
+ * @param source
+ * @param target
+ * @param compareFn
+ */
+export const arraySubtract = (source, target, compareFn) => {
+    return source.filter(a => target.filter(b => compareFn(a, b)).length === 0);
+};
+const eqStrict = (a, b) => a === b;
+export const arrayCompare = (source, target, compareFn = eqStrict) => {
+    return source.length === target.length && source.every((w, i) => compareFn(w, target[i]));
+};
+export function moveInArray(arr, from, to) {
+    const result = arr.slice();
+    const item = result[from];
+    result.splice(from, 1);
+    result.splice(to, 0, item);
+    return result;
+}
+export function moveInArrayMutable(arr, _from, _to) {
+    const n = arr.length;
+    const from = clamp(_from, 0, n - 1);
+    const to = clamp(_to, 0, n - 1);
+    const item = arr[from];
+    arr.splice(from, 1);
+    arr.splice(to, 0, item);
+    return arr;
+}
+/**
+ * Replaces item in array with another one.
+ * @param arr
+ * @param itemFinder - predicate to find item
+ * @param replace - item to replace
+ */
+export function replaceInArray(arr, itemFinder, replace) {
+    const result = arr.slice();
+    const idx = result.findIndex(itemFinder);
+    if (idx !== -1) {
+        result.splice(idx, 1);
+        result.splice(idx, 0, replace);
+    }
+    return result;
+}
+export const uniqueArray = (arr) => {
+    const hashTable = {};
+    return arr.filter(item => (hashTable[item] ? false : (hashTable[item] = true)));
+};
+export const groupBy = (array, key) => {
+    return array.reduce((result, currentValue) => {
+        // If an array already present for key, push it to the array. Else create an array and push the object
+        (result[currentValue[key]] = result[currentValue[key]] || []).push(currentValue);
+        // Return the current iteration `result` value, this will be taken as next iteration `result` value and accumulate
+        return result;
+        // eslint-disable-next-line no-restricted-syntax
+    }, {}); // empty object is the initial value for result object
+};
+/**
+ * Inserts *something* between every two elements in the source array
+ * Example: interleave(['first', 'second', 'third'], 'bar') => ['first', 'bar', 'second', 'bar', 'third']
+ * @param arr
+ * @param something
+ */
+export const interleave = (arr, something) => 
+// eslint-disable-next-line no-restricted-syntax
+[].concat(...arr.map(n => [n, something])).slice(0, -1);
+export const isTwoDimArray = (arr) => Array.isArray(arr[0]);
+// @ts-ignore
+export const create2DArray = (arr) => (Array.isArray(arr[0]) ? arr : [arr]);
+export const slice2DArray = (arr, startIdx, endIdx) => {
+    const result = [];
+    let pointsCurrentIdx = 0;
+    for (const arr1D of arr) {
+        const localIdxStart = Math.max(startIdx - pointsCurrentIdx, 0);
+        const localEndIdx = Math.max(endIdx - pointsCurrentIdx, -1);
+        const newPoints = arr1D.slice(localIdxStart, localEndIdx + 1);
+        newPoints.length > 0 && result.push(newPoints);
+        pointsCurrentIdx += arr1D.length;
+    }
+    return result;
+};
+// Array.at() polyfill (as of December 2022 method is not supported on iOS <= v15)
+export const at = (idx, arr) => (idx >= 0 ? arr[idx] : arr[arr.length + idx]);
+// Array.flat() polyfill (support for chrome 66)
+export const flat = (arr) => {
+    // @ts-ignore
+    if (Array.prototype.flat) {
+        return arr.flat();
+    }
+    return flatMap(arr, identity);
+};
+// Array.flatMap() polyfill (support for chrome 66)
+export const flatMap = (arr, callback) => {
+    // @ts-ignore
+    if (Array.prototype.flatMap) {
+        return arr.flatMap(callback);
+    }
+    const result = [];
+    for (let i = 0; i < arr.length; i++) {
+        const item = arr[i];
+        result.push(...callback(item, i, arr));
+    }
+    return result;
+};
+// eslint-disable-next-line no-redeclare
+export function binarySearch(array, what, transform) {
+    // @ts-ignore
+    const applyTransform = transform !== null && transform !== void 0 ? transform : identity;
+    if (!array.length || what !== what) {
+        return {
+            index: -1,
+            exact: true,
+        };
+    }
+    return binarySearchFn(array, what, 0, array.length, applyTransform);
+}
+function binarySearchFn(array, what, from, to, transform) {
+    const center = shiftRight(from + to, 1);
+    const centerValue = transform(array[center]);
+    if (what === centerValue) {
+        return {
+            index: center,
+            exact: true,
+        };
+    }
+    else {
+        if (from === center) {
+            return {
+                index: from,
+                exact: false,
+            };
+        }
+        else {
+            if (what < centerValue) {
+                return binarySearchFn(array, what, from, center, transform);
+            }
+            else {
+                return binarySearchFn(array, what, center, to, transform);
+            }
+        }
+    }
+}
+export function lastOf(arr) {
+    if (arr && arr.length) {
+        return arr[arr.length - 1];
+    }
+}
+export function arrayRemove(element) {
+    const idx = this.indexOf(element);
+    if (idx !== -1) {
+        this.splice(idx, 1);
+    }
+    return this;
+}
+// ... and this is how a normal person would write "arrayRemove" function
+export function arrayRemove2(array, element) {
+    if (!array) {
+        return;
+    }
+    const idx = array.indexOf(element);
+    if (idx !== -1) {
+        array.splice(idx, 1);
+    }
+}
+export function firstOf(arr) {
+    if (arr) {
+        return arr[0];
+    }
+}
+/**
+ @param {Function} gather - get the comparing value from the array
+ */
+export function maxMin(gather) {
+    function reducer(a, b) {
+        const v = gather(b);
+        if (v === null || v === undefined || !isFinite(v)) {
+            return a;
+        }
+        else {
+            return [Math.max(a[0], v), Math.min(a[1], v)];
+        }
+    }
+    return function (arr) {
+        const defaultResult = [Number.NEGATIVE_INFINITY, Number.POSITIVE_INFINITY];
+        if (arr) {
+            return arr.reduce(reducer, defaultResult);
+        }
+        return defaultResult;
+    };
+}
+export function getElementsInRange(array, leftBound, rightBound, transform = () => 0) {
+    const upperIndex = (arr, bound) => {
+        let l = 0;
+        let h = arr.length - 1;
+        while (h >= l) {
+            const midIndex = Math.ceil((l + h) / 2);
+            const mid = transform(arr[midIndex]);
+            if (mid <= bound) {
+                l = midIndex + 1;
+            }
+            else {
+                h = midIndex - 1;
+            }
+        }
+        return h;
+    };
+    const lowerIndex = (arr, bound) => {
+        let l = 0;
+        let h = arr.length - 1;
+        while (h >= l) {
+            const midIndex = Math.ceil((l + h) / 2);
+            const mid = transform(arr[midIndex]);
+            if (mid >= bound) {
+                h = midIndex - 1;
+            }
+            else {
+                l = midIndex + 1;
+            }
+        }
+        return l;
+    };
+    return array.slice(lowerIndex(array, leftBound), upperIndex(array, rightBound) + 1);
+}

package/dist/chart/utils/auto-period-detector.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/auto-period-detector.utils.js

@@ -1,6 +1,44 @@
 /*
- * 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 autoDetectPeriod(i){if(i.length>1){const f=i.reduce((t,e,o)=>{if(o!==i.length-1){const n=i[o+1].timestamp-e.timestamp;t[n]?t[n]++:t[n]=1}return t},{});let p=0,r;for(const t of Object.keys(f)){const e=parseInt(t,10),o=f[e];o>p&&e>0&&(p=o,r=e)}if(r)return r}}
+/**
+ * Automatically detect period of candle source.
+ * Cannot just take first-second candles distance because of non-trading hours.
+ * Naive approach:
+ *  1. get all time distances between candles
+ *  2. the most frequent distance = period
+ * @param candles
+ * @doc-tags tricky,period
+ */
+export function autoDetectPeriod(candles) {
+    if (candles.length > 1) {
+        // simply get distance between two candles
+        const periodToCount = candles.reduce((acc, candle, idx) => {
+            if (idx !== candles.length - 1) {
+                const period = candles[idx + 1].timestamp - candle.timestamp;
+                if (acc[period]) {
+                    acc[period]++;
+                }
+                else {
+                    acc[period] = 1;
+                }
+            }
+            return acc;
+        }, {});
+        let maxCount = 0;
+        let naivePeriod;
+        for (const _period of Object.keys(periodToCount)) {
+            const period = parseInt(_period, 10);
+            const count = periodToCount[period];
+            if (count > maxCount && period > 0) {
+                maxCount = count;
+                naivePeriod = period;
+            }
+        }
+        if (naivePeriod) {
+            return naivePeriod;
+        }
+    }
+}

package/dist/chart/utils/candles-generator-ts.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/candles-generator-ts.utils.js

@@ -1,6 +1,25 @@
 /*
- * 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 a from"./candles-generator.utils.js";export function generateCandlesDataTS(e){return a(e)}
+import generateCandlesData from './candles-generator.utils.js';
+/**
+ * Generated mock candles data.
+ *
+ * @param config
+ *   quantity - avg number of candles
+ *   startY - avg candle Y to start generation with
+ *   avgCandleSize - avg size of candle
+ *   avgTrendLength:
+ *     sw - avg length of SIDEWAYS trend
+ *     down - avg length of DOWN trend
+ *     up - avg length of UP trend
+ *   withVolume - add random volumes or not
+ *   period - specify distance between candles (60 for 1m, 3600 for 1h, 84600 for 1d)
+ * @return Array<Candle>
+ * @doc-tags tricky
+ */
+export function generateCandlesDataTS(config) {
+    return generateCandlesData(config);
+}

package/dist/chart/utils/candles-generator.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/.
  */