@devexperts/dxcharts-lite 1.0.2 → 2.0.0

package/dist/chart/utils/color.utils.js

@@ -3,4 +3,34 @@
  * 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/.
  */
-const c=/^(#)([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})$/i,o=/^\s*(rgba?)\s*[(]\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})\s*(?:,\s*[\d.]+\s*)?[)]\s*$/i;function i(n){const t=c.exec(n)||o.exec(n);let s=[];return t&&(s=t.slice(2,5),t[1]==="#")?s.map(function(e){return parseInt(e,16)}):s}const r={};export function toRGBA(n,t){let s=r[n+t];if(!s){const e=i(n);s=e&&"rgba("+e.join(",")+","+t+")",r[n+t]=s}return s}
+const HEX_COLOR_REGEXP = /^(#)([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})$/i;
+const RGB_COLOR_REGEXP = /^\s*(rgba?)\s*[(]\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})\s*(?:,\s*[\d.]+\s*)?[)]\s*$/i;
+function parseColor(color) {
+    const match = HEX_COLOR_REGEXP.exec(color) || RGB_COLOR_REGEXP.exec(color);
+    let colors = [];
+    if (match) {
+        colors = match.slice(2, 5);
+        if (match[1] === '#') {
+            return colors.map(function (s) {
+                return parseInt(s, 16);
+            });
+        }
+    }
+    return colors;
+}
+/**
+ *
+ * @param {String} color
+ * @param {Number} alpha
+ * @returns {String}
+ */
+const rgbaCache = {};
+export function toRGBA(color, alpha) {
+    let result = rgbaCache[color + alpha];
+    if (!result) {
+        const colors = parseColor(color);
+        result = colors && 'rgba(' + colors.join(',') + ',' + alpha + ')';
+        rgbaCache[color + alpha] = result;
+    }
+    return result;
+}

package/dist/chart/utils/device/browser.utils.js

@@ -3,4 +3,13 @@
  * 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 e;export const isMobile=()=>(e||(e=!!navigator.userAgent.match(/Android|iPhone|Opera Mini/)||!1),e);
+let isMobileCache = undefined;
+/**
+ * @doc-tags utility,mobile
+ */
+export const isMobile = () => {
+    if (!isMobileCache) {
+        isMobileCache = !!navigator.userAgent.match(/Android|iPhone|Opera Mini/) || false;
+    }
+    return isMobileCache;
+};

package/dist/chart/utils/device/device-detector.utils.js

@@ -3,4 +3,27 @@
  * 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 deviceDetector=()=>{const e=/Mac|iPod|iPhone|iPad/i.test(navigator.userAgent),i=[/Android/i,/webOS/i,/BlackBerry/i,/Windows Phone/i].some(o=>navigator.userAgent.match(o));return e?"apple":i?"mobile":"other"},multiplyZoomByDevice=(e,t)=>e==="apple"||e==="mobile"?3:t;
+/**
+ * Detects the user device. Naive approach.
+ * @doc-tags tricky,mobile
+ */
+export const deviceDetector = () => {
+    const isApple = /Mac|iPod|iPhone|iPad/i.test(navigator.userAgent);
+    const mobileMatch = [/Android/i, /webOS/i, /BlackBerry/i, /Windows Phone/i];
+    const isMobile = mobileMatch.some(os => {
+        return navigator.userAgent.match(os);
+    });
+    if (isApple) {
+        return 'apple';
+    }
+    if (isMobile) {
+        return 'mobile';
+    }
+    return 'other';
+};
+export const multiplyZoomByDevice = (device, defaultValue) => {
+    if (device === 'apple' || device === 'mobile') {
+        return 3;
+    }
+    return defaultValue;
+};

package/dist/chart/utils/device/device-pixel-ratio.utils.js

@@ -3,4 +3,24 @@
  * 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{ceil as t,floor as n,round as d}from"../math.utils";export let dpr=window.devicePixelRatio;let o=window.matchMedia(`screen and (resolution: ${window.devicePixelRatio}dppx)`);const i=()=>{o.removeEventListener("change",i),dpr=window.devicePixelRatio,o=window.matchMedia(`screen and (resolution: ${window.devicePixelRatio}dppx)`),o.addEventListener("change",i)};o.addEventListener("change",i);export const getDPR=()=>dpr,roundToDPR=e=>d(dpr*e)/dpr,floorToDPR=e=>n(dpr*e)/dpr,ceilToDPR=e=>t(dpr*e)/dpr;
+import { ceil, floor, round } from '../math.utils';
+export let dpr = window.devicePixelRatio;
+// A media matcher which watches for changes in the device pixel ratio.
+let mediaMatcher = window.matchMedia(`screen and (resolution: ${window.devicePixelRatio}dppx)`);
+const updateDevicePixelRatio = () => {
+    mediaMatcher.removeEventListener('change', updateDevicePixelRatio);
+    dpr = window.devicePixelRatio;
+    mediaMatcher = window.matchMedia(`screen and (resolution: ${window.devicePixelRatio}dppx)`);
+    mediaMatcher.addEventListener('change', updateDevicePixelRatio);
+};
+mediaMatcher.addEventListener('change', updateDevicePixelRatio);
+export const getDPR = () => dpr;
+/**
+ * Rounds a given number according to the inverse of current DPR.
+ * For example, DPR = 2, num = 2, res => 2; DPR = 2, num = 2.5, res => 2.5; DPR = 2, num = 2.333, res => 2.5
+ * @param num
+ * @doc-tags chart-core,math,dpr
+ */
+export const roundToDPR = (num) => round(dpr * num) / dpr;
+export const floorToDPR = (num) => floor(dpr * num) / dpr;
+export const ceilToDPR = (num) => ceil(dpr * num) / dpr;

package/dist/chart/utils/device/touchpad.utils.js

@@ -3,4 +3,94 @@
  * 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/.
  */
-const o=/^((?!chrome|android).)*safari/i.test(navigator.userAgent),l=!!window.chrome;export const isFirefox=typeof InstallTrigger!="undefined";const d=navigator.platform.indexOf("Win")>-1;export const touchpadDetector=t=>{let i=!1;const{wheelDeltaY:a,wheelDeltaX:s}=t;if(a||s){let e;if(o)e=a===t.deltaY*-3||Math.abs(a+Math.sign(a))===Math.abs(Math.round(t.deltaY)*3)||Math.abs(a-Math.sign(a))===Math.abs(Math.round(t.deltaY)*3);else if(l){if(e=a+Math.sign(a)===t.deltaY*-3?a+Math.sign(a)===t.deltaY*-3:a===t.deltaY*-3,d){const n=Math.round(t.deltaY)===a||Math.abs(Math.round(t.deltaY)+Math.sign(t.deltaY))===Math.abs(a)||Math.abs(Math.round(t.deltaY)-Math.sign(t.deltaY))===Math.abs(a);e=Math.abs(a)===Math.abs(t.deltaY)||n}}else isFirefox?Math.abs(t.deltaY)>Math.abs(t.deltaX)?e=!1:e=s===t.deltaX*-3:e=a===t.deltaY*-3;e&&(i=!0)}else t.deltaMode===0&&(i=!0);return isFirefox&&t.deltaY>=16&&Math.abs(t.deltaY)%16===0&&(i=!1),t.ctrlKey&&(i=!0),i},getTouchpadSensitivity=t=>t.components.yAxis.type==="percent"?t.scale.zoomSensitivity/4:t.scale.zoomSensitivity;
+const isSafari = /^((?!chrome|android).)*safari/i.test(navigator.userAgent);
+//@ts-ignore
+const isChrome = !!window.chrome;
+//@ts-ignore
+export const isFirefox = typeof InstallTrigger !== 'undefined';
+const isWindows = navigator.platform.indexOf('Win') > -1;
+/**
+ * this function determines whether the event was triggered with the mouse or the touchpad
+ *
+ * This works because wheelDeltaY measures the physical distance that the actual hardware mouse wheel has travelled,
+ * while deltaY measures the amount of scrolling produced on screen.
+ * A conventional mouse typically has a much lower "scroll resolution" than a trackpad.
+ * The wheelDeltaY is exactly 3x the deltaY value(in most browsers)
+ * This function consist a lot of empiric if statements for some cases in different browsers and systems
+ * @param {WheelEvent} e
+ * @returns {boolean}
+ *
+ * @doc-tags chart-core, utility,
+ */
+export const touchpadDetector = (e) => {
+    let isTouchpad = false;
+    // this is essential prop to separate touchpad from mouse wheel
+    //@ts-ignore
+    const { wheelDeltaY, wheelDeltaX } = e;
+    if (wheelDeltaY || wheelDeltaX) {
+        let condition;
+        if (isSafari) {
+            condition =
+                wheelDeltaY === e.deltaY * -3 ||
+                    Math.abs(wheelDeltaY + Math.sign(wheelDeltaY)) === Math.abs(Math.round(e.deltaY) * 3) ||
+                    Math.abs(wheelDeltaY - Math.sign(wheelDeltaY)) === Math.abs(Math.round(e.deltaY) * 3);
+        }
+        else if (isChrome) {
+            condition =
+                wheelDeltaY + Math.sign(wheelDeltaY) === e.deltaY * -3
+                    ? wheelDeltaY + Math.sign(wheelDeltaY) === e.deltaY * -3
+                    : wheelDeltaY === e.deltaY * -3;
+            // Chrome windows case
+            if (isWindows) {
+                const diapazoneCondition = Math.round(e.deltaY) === wheelDeltaY ||
+                    Math.abs(Math.round(e.deltaY) + Math.sign(e.deltaY)) === Math.abs(wheelDeltaY) ||
+                    Math.abs(Math.round(e.deltaY) - Math.sign(e.deltaY)) === Math.abs(wheelDeltaY);
+                const equalCondition = Math.abs(wheelDeltaY) === Math.abs(e.deltaY);
+                condition = equalCondition || diapazoneCondition;
+            }
+        }
+        else if (isFirefox) {
+            if (Math.abs(e.deltaY) > Math.abs(e.deltaX)) {
+                // disable vertical scroll in Firefox bcs it is unstable
+                condition = false;
+            }
+            else {
+                condition = wheelDeltaX === e.deltaX * -3;
+            }
+        }
+        else {
+            // basic rule
+            condition = wheelDeltaY === e.deltaY * -3;
+        }
+        if (condition) {
+            isTouchpad = true;
+        }
+    }
+    else if (e.deltaMode === 0) {
+        isTouchpad = true;
+    }
+    // Firefox for some reason is not obey to rules above
+    // so we just this trigger this as mouse wheel event
+    if (isFirefox && e.deltaY >= 16 && Math.abs(e.deltaY) % 16 === 0) {
+        isTouchpad = false;
+    }
+    // it is necessary to correctly recognize pinch on touchpad
+    // could be emulated mouse wheel + ctrl key BE AWARE!!
+    if (e.ctrlKey) {
+        isTouchpad = true;
+    }
+    return isTouchpad;
+};
+/**
+ * this function returns different ящщь sensitivity for the percent axis and the others
+ * @param config
+ * @param isTouchpad
+ * @returns {number}
+ *
+ * @doc-tags chart-core, zoom
+ */
+export const getTouchpadSensitivity = (config) => {
+    const isPercentAxisType = config.components.yAxis.type === 'percent';
+    const zoomSensitivity = isPercentAxisType ? config.scale.zoomSensitivity / 4 : config.scale.zoomSensitivity;
+    return zoomSensitivity;
+};

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

@@ -3,4 +3,18 @@
  * 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)}}
+/**
+ * @param {Element} element
+ * @param {function} listener
+ * @param {string} eventType
+ * @param {boolean?} useCapture
+ * @return {Function}
+ */
+export function subscribeListener(element, listener, eventType, useCapture) {
+    // @ts-ignore
+    element.addEventListener(eventType, listener, useCapture);
+    return function () {
+        // @ts-ignore
+        element.removeEventListener(eventType, listener, useCapture);
+    };
+}

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

@@ -3,4 +3,19 @@
  * 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}
+export function clearerSafe(arr) {
+    return function doClearSafe() {
+        arr.forEach(f => typeof f === 'function' && f());
+        arr.length = 0;
+    };
+}
+export function identity(x) {
+    return x;
+}
+export function notEmpty(value) {
+    return value !== null && value !== undefined;
+}
+export const constVoid = () => void 0;
+export function nonNullableTypeGuard(x) {
+    return x !== undefined && x !== null;
+}

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

@@ -0,0 +1,28 @@
+/*
+ * 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 declare class ListNode<T> {
+    data: T;
+    next: ListNode<T> | null;
+    constructor(data: T);
+}
+/**
+ * Implementation of Linked list data structure.
+ * @param _head
+ */
+export declare class LinkedList<T> {
+    private _head;
+    private _tail;
+    private length;
+    constructor(head?: ListNode<T>);
+    insertAtEnd(data: T): ListNode<T>;
+    insertAt(position: number, data: T): ListNode<T> | null;
+    removeAt(position: number): ListNode<T> | null;
+    getNodePosition(node: ListNode<T>): number;
+    size(): number;
+    get head(): ListNode<T> | null;
+    get tail(): ListNode<T> | null;
+    [Symbol.iterator](): Generator<T, void, unknown>;
+}

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

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

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

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

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

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

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

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