@devexperts/dxcharts-lite 1.0.2 → 2.0.1

package/dist/chart/model/time-zone.model.js

@@ -3,4 +3,112 @@
  * 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{getTimezoneOffset as n}from"date-fns-tz";import{ReplaySubject as s}from"rxjs";import{memoize as f}from"../utils/perfomance/memoize.utils";import{dateTimeFormatterFactory as c}from"./date-time.formatter";export const memoizedTZOffset=f(n),getTimezoneOffset=(r,e)=>new Date(e).getTimezoneOffset()*60*1e3+memoizedTZOffset(r,e);export class TimeZoneModel{constructor(e){this.config=e,this.timeZoneChangedSubject=new s,this.currentTzOffset=t=>this.getOffset(this.config.timezone,t),this.formatterCache={},this.getOffset=(t,i)=>getTimezoneOffset(t,i),this.dateTimeFormatterFactory=this.initFormatterFactory(this.config.dateFormatter)}setTimeZone(e){this.config.timezone=e,this.formatterCache={},this.timeZoneChangedSubject.next(e)}observeTimeZoneChanged(){return this.timeZoneChangedSubject.asObservable()}initFormatterFactory(e){let t;if(e&&typeof e=="function")t=e;else if(e&&e.createFormatterFunction&&typeof e.createFormatterFunction=="function"){const i=e.createFormatterFunction;t=o=>i(o).bind(e)}else t=c(this.config,this.tzOffset);return t}getFormatterFactory(){return this.dateTimeFormatterFactory}getDateTimeFormatter(e){return this.formatterCache[e]===void 0&&(this.formatterCache[e]=this.dateTimeFormatterFactory(e)),this.formatterCache[e]}tzOffset(e){const t=o=>-new Date(o).getTimezoneOffset()*a;let i;return e?i=o=>memoizedTZOffset(e,o):i=t,o=>new Date(+o+i(o)-t(o))}}const a=60*1e3;
+import { getTimezoneOffset as getTimezoneOffsetDateFnsTz } from 'date-fns-tz';
+import { ReplaySubject } from 'rxjs';
+import { memoize } from '../utils/performance/memoize.utils';
+import { dateTimeFormatterFactory } from './date-time.formatter';
+export const memoizedTZOffset = memoize(getTimezoneOffsetDateFnsTz);
+export const getTimezoneOffset = (timezone, time) => {
+    // we must pass time here, because we can have daylight saving time, otherwise we will get wrong offset
+    const localOffset = new Date(time).getTimezoneOffset() * 60 * 1000;
+    return localOffset + memoizedTZOffset(timezone, time);
+};
+export class TimeZoneModel {
+    constructor(config) {
+        this.config = config;
+        this.timeZoneChangedSubject = new ReplaySubject();
+        this.currentTzOffset = (time) => this.getOffset(this.config.timezone, time);
+        this.formatterCache = {};
+        /**
+         * Calculates the offset of a given timezone from the local timezone.
+         * @private
+         * @param {string} timezone - The timezone to calculate the offset for.
+         */
+        this.getOffset = (timezone, time) => getTimezoneOffset(timezone, time);
+        this.dateTimeFormatterFactory = this.initFormatterFactory(this.config.dateFormatter);
+    }
+    /**
+     * Sets the timezone for the configuration and updates the current timezone offset.
+     * @param {string} timeZone - The timezone to set.
+     * @returns {void}
+     */
+    setTimeZone(timeZone) {
+        this.config.timezone = timeZone;
+        this.formatterCache = {};
+        this.timeZoneChangedSubject.next(timeZone);
+    }
+    /**
+     * Returns an Observable that emits a string value when the time zone is changed.
+     * The Observable is created from the timeZoneChangedSubject Subject.
+     * @returns {Observable<string>} An Observable that emits a string value when the time zone is changed.
+     */
+    observeTimeZoneChanged() {
+        return this.timeZoneChangedSubject.asObservable();
+    }
+    /**
+     * Initializes a DateTimeFormatterFactory object.
+     * @param {DateFormatter} [dateFormatter] - Optional DateFormatter object.
+     * @returns {DateTimeFormatterFactory} - Returns a DateTimeFormatterFactory object.
+     * If a plain function is provided as the dateFormatter parameter, it will be used as a date formatter without applying UTC datetime override for candles more than 1d period.
+     * If a custom date formatter exists, it will be used for datetime formatting applying optionally UTC datetime override for candles more than 1d period.
+     * If no dateFormatter is provided, a default DateTimeFormatterFactory object will be returned.
+     */
+    initFormatterFactory(dateFormatter) {
+        let result;
+        if (dateFormatter && typeof dateFormatter === 'function') {
+            // backward compatibility - if date formatter is a plain function then there is no need to use UTC datetime
+            // override for candles more than 1d period
+            result = dateFormatter;
+        }
+        else if (dateFormatter &&
+            dateFormatter.createFormatterFunction &&
+            typeof dateFormatter.createFormatterFunction === 'function') {
+            // if custom date formatter exists we use it for datetime formatting applying optionally
+            // UTC datetime override for candles more than 1d period
+            const createFormatter = dateFormatter.createFormatterFunction;
+            result = (pattern) => createFormatter(pattern).bind(dateFormatter);
+        }
+        else {
+            result = dateTimeFormatterFactory(this.config, this.tzOffset);
+        }
+        return result;
+    }
+    /**
+     * Returns the DateTimeFormatterFactory instance used by this class.
+     *
+     * @returns {DateTimeFormatterFactory} The DateTimeFormatterFactory instance used by this class.
+     */
+    getFormatterFactory() {
+        return this.dateTimeFormatterFactory;
+    }
+    getDateTimeFormatter(format) {
+        if (this.formatterCache[format] === undefined) {
+            this.formatterCache[format] = this.dateTimeFormatterFactory(format);
+        }
+        return this.formatterCache[format];
+    }
+    /**
+     * Gets the timezone offset value in milliseconds
+     * @param {string} timezone name
+     * @returns {function(time:Number):Date}
+     */
+    tzOffset(timezone) {
+        // we must pass time here, because we can have daylight saving time, otherwise we will get wrong offset
+        const localOffset = (time) => -new Date(time).getTimezoneOffset() * timeMultiplier;
+        let offset;
+        if (!timezone) {
+            offset = localOffset;
+        }
+        else {
+            // we must pass time here, because we can have daylight saving time, otherwise we will get wrong offset
+            offset = (time) => memoizedTZOffset(timezone, time);
+        }
+        // In JS Date object is created with local tz offset,
+        // so we have to subtract localOffset from current time
+        return time => {
+            return new Date(+time + offset(time) - localOffset(time));
+        };
+    }
+}
+// 1 hour in milliseconds
+const timeMultiplier = 60 * 1000;

package/dist/chart/model/visual-candle.js

@@ -3,4 +3,137 @@
  * 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{floorToDPR as s,roundToDPR as l}from"../utils/device/device-pixel-ratio.utils";import{VisualSeriesPoint as u}from"./data-series.model";export default class y extends u{constructor(t,o,h,i,n,r,e,d,a=!1,c=!1,Y=!1){super(t,i),this.startUnit=t-o/2,this.width=o,this.open=h,this.high=n,this.low=r,this.name=e,this.candle=d,this.hasBorder=a,this.isActive=c,this.isHollow=Y}bodyHeight(t){return s(Math.abs(t.toY(this.open)-t.toY(this.close)))}candleHeight(t){return s(Math.abs(t.toY(this.high)-t.toY(this.low)))}bodyAsVLine(t){if(this.width<2)return[this.centerUnit,this.yLineStart(t),this.width,this.candleHeight(t)]}bodyRect(t){return[this.startUnit,this.yBodyStart(t),this.width,this.bodyHeight(t)]}getCandle(){return this.candle}yBodyKeyPoints(t){const o=s(t.toY(this.high)),h=s(t.toY(this.low)),i=s(t.toY(this.open)),n=s(t.toY(this.close)),[r,e]=i>n?[n,i]:[i,n],[d,a]=o>h?[h,o]:[o,h];return[d,r,e,a]}yLineEnd(t){return s(Math.max(t.toY(this.high),t.toY(this.low)))}yLineStart(t){return s(Math.min(t.toY(this.high),t.toY(this.low)))}yBodyStart(t){return s(Math.min(t.toY(this.open),t.toY(this.close)))}yBodyEnd(t){return s(Math.max(t.toY(this.open),t.toY(this.close)))}xCenter(t){return this.x(t)}xStart(t){return l(t.toX(this.startUnit))}}
+import { floorToDPR, roundToDPR } from '../utils/device/device-pixel-ratio.utils';
+import { VisualSeriesPoint } from './data-series.model';
+/**
+ * Candle's visual representation. Candle's coordinates are adjusted by .5 unit to prevent anti-aliasing effect for
+ * lines with 1px width
+ *
+ * @param x wick location on X-axis
+ * @param width candle's width
+ * @param op open price location on Y axis
+ * @param cl close price location on Y axis
+ * @param lineStart wick's top location on Y axis
+ * @param lineEnd wick's bottom location on Y axis
+ * @param name candle's direction: up | down | none
+ * @param candle original candle
+ * @param hasBorder flag denoting if border should be drawn
+ * @constructor
+ */
+export default class VisualCandle extends VisualSeriesPoint {
+    constructor(x, width, open, close, high, low, name, candle, hasBorder = false, isActive = false, isHollow = false) {
+        super(x, close);
+        this.startUnit = x - width / 2;
+        this.width = width;
+        this.open = open;
+        this.high = high;
+        this.low = low;
+        this.name = name;
+        this.candle = candle;
+        this.hasBorder = hasBorder;
+        this.isActive = isActive;
+        this.isHollow = isHollow;
+    }
+    /**
+     * Calculates the height of the body of a viewable element.
+     * @param {Viewable} viewable - The viewable element.
+     * @returns {Pixel} - The height of the body in pixels.
+     */
+    bodyHeight(viewable) {
+        return floorToDPR(Math.abs(viewable.toY(this.open) - viewable.toY(this.close)));
+    }
+    /**
+     * Calculates the height of a candle in pixels based on the high and low values of the candle and the viewable area.
+     *
+     * @param {Viewable} viewable - The viewable area object.
+     * @returns {Pixel} - The height of the candle in pixels.
+     */
+    candleHeight(viewable) {
+        return floorToDPR(Math.abs(viewable.toY(this.high) - viewable.toY(this.low)));
+    }
+    /**
+     * Returns coordinates of vertical line used to draw candle's body in case of small candle width
+     * @returns {[x,y,x2,y2]}
+     */
+    bodyAsVLine(viewable) {
+        if (this.width < 2) {
+            return [this.centerUnit, this.yLineStart(viewable), this.width, this.candleHeight(viewable)];
+        }
+    }
+    /**
+     * Returns rectangle used to draw candles' body
+     * @returns {[x,y,width,height]}
+     */
+    bodyRect(viewable) {
+        // candle is drawn using wick as center
+        return [this.startUnit, this.yBodyStart(viewable), this.width, this.bodyHeight(viewable)];
+    }
+    /**
+     * Returns the current candle object.
+     *
+     * @returns {Candle} The current candle object.
+     */
+    getCandle() {
+        return this.candle;
+    }
+    /**
+     * Returns candle Y points in ascending order
+     */
+    yBodyKeyPoints(viewable) {
+        const highY = floorToDPR(viewable.toY(this.high));
+        const lowY = floorToDPR(viewable.toY(this.low));
+        const openY = floorToDPR(viewable.toY(this.open));
+        const closeY = floorToDPR(viewable.toY(this.close));
+        const [bodyStart, bodyEnd] = openY > closeY ? [closeY, openY] : [openY, closeY];
+        const [lineStart, lineEnd] = highY > lowY ? [lowY, highY] : [highY, lowY];
+        return [lineStart, bodyStart, bodyEnd, lineEnd];
+    }
+    /**
+     * Calculates the y-coordinate of the end of a line segment that is within the viewable area.
+     * @param {Viewable} viewable - The viewable area object.
+     * @returns {Pixel} - The y-coordinate of the end of the line segment in pixels.
+     */
+    yLineEnd(viewable) {
+        return floorToDPR(Math.max(viewable.toY(this.high), viewable.toY(this.low)));
+    }
+    /**
+     * Returns the pixel value of the starting point of the y-axis line on the given viewable area.
+     * @param {Viewable} viewable - The viewable area to calculate the pixel value on.
+     * @returns {Pixel} - The pixel value of the starting point of the y-axis line.
+     */
+    yLineStart(viewable) {
+        return floorToDPR(Math.min(viewable.toY(this.high), viewable.toY(this.low)));
+    }
+    /**
+     * Calculates the starting y-coordinate of the body of a viewable object.
+     * @param {Viewable} viewable - The viewable object for which the starting y-coordinate of the body is to be calculated.
+     * @returns {Pixel} - The starting y-coordinate of the body of the viewable object.
+     */
+    yBodyStart(viewable) {
+        return floorToDPR(Math.min(viewable.toY(this.open), viewable.toY(this.close)));
+    }
+    /**
+     * Calculates the maximum pixel value of the y-coordinate of the viewable object's end point and the open and close values of the current object.
+     * @param {Viewable} viewable - The viewable object whose end point is to be compared with the open and close values of the current object.
+     * @returns {Pixel} - The maximum pixel value of the y-coordinate of the viewable object's end point and the open and close values of the current object.
+     */
+    yBodyEnd(viewable) {
+        return floorToDPR(Math.max(viewable.toY(this.open), viewable.toY(this.close)));
+    }
+    /**
+     * Calculates the x-coordinate of the center of a viewable object in pixels.
+     * @param {Viewable} viewable - The viewable object whose center is to be calculated.
+     * @returns {Pixel} - The x-coordinate of the center of the viewable object in pixels.
+     */
+    xCenter(viewable) {
+        return this.x(viewable);
+    }
+    /**
+     * Returns the starting pixel position of a viewable object
+     * @param {Viewable} viewable - The viewable object to get the starting pixel position from
+     * @returns {Pixel} - The starting pixel position of the viewable object
+     */
+    xStart(viewable) {
+        return roundToDPR(viewable.toX(this.startUnit));
+    }
+}

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

@@ -3,4 +3,138 @@
  * 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/__tests__/math.utils.test.js

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

@@ -3,4 +3,14 @@
  * 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.js

@@ -3,4 +3,32 @@
  * 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

@@ -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']