@progress/kendo-charts 2.7.2-dev.202502101310 → 2.7.2-develop.1

package/dist/es/common/get-spacing.js

@@ -1,9 +1,7 @@
 import { TOP, BOTTOM, LEFT, RIGHT } from './constants';
 
-export default function getSpacing(value, defaultSpacing) {
-    if ( defaultSpacing === void 0 ) defaultSpacing = 0;
-
-    var spacing = { top: 0, right: 0, bottom: 0, left: 0 };
+export default function getSpacing(value, defaultSpacing = 0) {
+    const spacing = { top: 0, right: 0, bottom: 0, left: 0 };
 
     if (typeof(value) === "number") {
         spacing[TOP] = spacing[RIGHT] = spacing[BOTTOM] = spacing[LEFT] = value;

package/dist/es/common/get-supported-features.js

@@ -1,6 +1,6 @@
 export default function getSupportedFeatures() {
-    var os = detectOS(navigator.userAgent);
-    var support = {};
+    const os = detectOS(navigator.userAgent);
+    const support = {};
 
     support.mobileOS = os;
 
@@ -8,8 +8,8 @@ export default function getSupportedFeatures() {
 }
 
 function detectOS(ua) {
-    var os = false;
-    var agentRxs = {
+    let os = false;
+    const agentRxs = {
             wp: /(Windows Phone(?: OS)?)\s(\d+)\.(\d+(\.\d+)?)/,
             fire: /(Silk)\/(\d+)\.(\d+(\.\d+)?)/,
             android: /(Android|Android.*(?:Opera|Firefox).*?\/)\s*(\d+)\.?(\d+(\.\d+)?)?/,
@@ -28,8 +28,8 @@ function detectOS(ua) {
             flat: /sailfish|ffos|tizen/i
         };
 
-    for (var agent in agentRxs) {
-        var match = ua.match(agentRxs[agent]);
+    for (let agent in agentRxs) {
+        let match = ua.match(agentRxs[agent]);
         if (match) {
             if (agent === "windows" && "plugins" in navigator) { return false; } // Break if not Metro/Mobile Windows
 
@@ -46,7 +46,7 @@ function detectOS(ua) {
 }
 
 function testRegex(agent, regexes, dflt) {
-    for (var regex in regexes) {
+    for (let regex in regexes) {
         if (regexes[regex].test(agent)) {
             return regex;
         }

package/dist/es/common/get-template.js

@@ -1,10 +1,8 @@
 import TemplateService from '../services/template-service';
 import isFunction from './is-function';
 
-export default function getTemplate(options) {
-    if ( options === void 0 ) options = {};
-
-    var template;
+export default function getTemplate(options = {}) {
+    let template;
     if (options.template) {
         options.template = template = TemplateService.compile(options.template);
     } else if (isFunction(options.content)) {

package/dist/es/common/getter.js

@@ -1,7 +1,7 @@
 import { drawing } from '@progress/kendo-drawing';
 
-var FIELD_REGEX = /\[(?:(\d+)|['"](.*?)['"])\]|((?:(?!\[.*?\]|\.).)+)/g;
-var getterCache = {};
+const FIELD_REGEX = /\[(?:(\d+)|['"](.*?)['"])\]|((?:(?!\[.*?\]|\.).)+)/g;
+const getterCache = {};
 
 getterCache['undefined'] = function(obj) {
     return obj;
@@ -12,14 +12,14 @@ export default function getter(field) {
         return getterCache[field];
     }
 
-    var fields = [];
+    const fields = [];
     field.replace(FIELD_REGEX, function(match, index, indexAccessor, field) {
         fields.push(drawing.util.defined(index) ? index : (indexAccessor || field));
     });
 
     getterCache[field] = function(obj) {
-        var result = obj;
-        for (var idx = 0; idx < fields.length && result; idx++) {
+        let result = obj;
+        for (let idx = 0; idx < fields.length && result; idx++) {
             result = result[fields[idx]];
         }
 

package/dist/es/common/grep.js

@@ -1,7 +1,7 @@
 export default function grep(array, callback) {
-    var length = array.length;
-    var result = [];
-    for (var idx = 0; idx < length; idx++) {
+    const length = array.length;
+    const result = [];
+    for (let idx = 0; idx < length; idx++) {
         if (callback(array[idx])) {
             result .push(array[idx]);
         }

package/dist/es/common/has-classes.js

@@ -1,7 +1,7 @@
 export default function hasClasses(element, classNames) {
     if (element.className) {
-        var names = classNames.split(" ");
-        for (var idx = 0; idx < names.length; idx++) {
+        const names = classNames.split(" ");
+        for (let idx = 0; idx < names.length; idx++) {
             if (element.className.indexOf && element.className.indexOf(names[idx]) !== -1) {
                 return true;
             }

package/dist/es/common/hash-map.js

@@ -1,14 +1,14 @@
 // TODO: Remove and replace with Map/WeakMap.
-var HashMap = function HashMap() {
-    this._map = new Map();
-};
+export default class HashMap {
+    constructor() {
+        this._map = new Map();
+    }
 
-HashMap.prototype.get = function get (key) {
-    return this._map.get(key);
-};
+    get(key) {
+        return this._map.get(key);
+    }
 
-HashMap.prototype.set = function set (key, value) {
-    this._map.set(key, value);
-};
-
-export default HashMap;
+    set(key, value) {
+        this._map.set(key, value);
+    }
+}

package/dist/es/common/instance-observer.js

@@ -1,45 +1,40 @@
 import deepExtend from './deep-extend';
 
-var TRIGGER = 'trigger';
-
-var InstanceObserver = function InstanceObserver(observer, handlers) {
-    this.observer = observer;
-    this.handlerMap = deepExtend({}, this.handlerMap, handlers);
-};
-
-InstanceObserver.prototype.trigger = function trigger (name, args) {
-    var ref = this;
-        var observer = ref.observer;
-        var handlerMap = ref.handlerMap;
-    var isDefaultPrevented;
-    if (handlerMap[name]) {
-        isDefaultPrevented = this.callObserver(handlerMap[name], args);
-    } else if (observer[TRIGGER]) {
-        isDefaultPrevented = this.callObserver(TRIGGER, name, args);
-    }
-
-    return isDefaultPrevented;
-};
+const TRIGGER = 'trigger';
 
-InstanceObserver.prototype.callObserver = function callObserver (fnName) {
-        var args = [], len = arguments.length - 1;
-        while ( len-- > 0 ) args[ len ] = arguments[ len + 1 ];
+class InstanceObserver {
+    constructor(observer, handlers) {
+        this.observer = observer;
+        this.handlerMap = deepExtend({}, this.handlerMap, handlers);
+    }
 
-    return this.observer[fnName].apply(this.observer, args);
-};
+    trigger(name, args) {
+        const { observer, handlerMap } = this;
+        let isDefaultPrevented;
+        if (handlerMap[name]) {
+            isDefaultPrevented = this.callObserver(handlerMap[name], args);
+        } else if (observer[TRIGGER]) {
+            isDefaultPrevented = this.callObserver(TRIGGER, name, args);
+        }
 
-InstanceObserver.prototype.requiresHandlers = function requiresHandlers (names) {
-        var this$1 = this;
+        return isDefaultPrevented;
+    }
 
-    if (this.observer.requiresHandlers) {
-        return this.observer.requiresHandlers(names);
+    callObserver(fnName, ...args) {
+        return this.observer[fnName].apply(this.observer, args);
     }
 
-    for (var idx = 0; idx < names.length; idx++) {
-        if (this$1.handlerMap[names[idx]]) {
-            return true;
+    requiresHandlers(names) {
+        if (this.observer.requiresHandlers) {
+            return this.observer.requiresHandlers(names);
+        }
+
+        for (let idx = 0; idx < names.length; idx++) {
+            if (this.handlerMap[names[idx]]) {
+                return true;
+            }
         }
     }
-};
+}
 
 export default InstanceObserver;

package/dist/es/common/keys.js

@@ -1,4 +1,4 @@
-var keys = {
+let keys = {
     INSERT: 45,
     DELETE: 46,
     BACKSPACE: 8,

package/dist/es/common/map.js

@@ -1,10 +1,10 @@
 import { drawing } from '@progress/kendo-drawing';
 
 export default function map(array, callback) {
-    var length = array.length;
-    var result = [];
-    for (var idx = 0; idx < length; idx++) {
-        var value = callback(array[idx]);
+    const length = array.length;
+    const result = [];
+    for (let idx = 0; idx < length; idx++) {
+        let value = callback(array[idx]);
         if (drawing.util.defined(value)) {
             result.push(value);
         }

package/dist/es/common/matrix.js

@@ -1,182 +1,174 @@
 // Based on the implementation from kendo-spreadsheet-common/src/calc.js
-var Matrix = function Matrix() {
-    this.height = 0;
-    this.width = 0;
-    this.data = [];
-};
-
-Matrix.prototype.clone = function clone () {
-    var m = new Matrix();
-    m.height = this.height;
-    m.width = this.width;
-    m.data = this.data.map(function (row) { return row.slice(); });
-    return m;
-};
-
-Matrix.prototype.get = function get (row, col) {
-    var line = this.data[row];
-    var val = line ? line[col] : null;
-    return val;
-};
-
-Matrix.prototype.set = function set (row, col, data) {
-    var line = this.data[row];
-    if (line == null) {
-        line = this.data[row] = [];
+class Matrix {
+    constructor() {
+        this.height = 0;
+        this.width = 0;
+        this.data = [];
     }
-    line[col] = data;
-    if (row >= this.height) {
-        this.height = row + 1;
+
+    clone() {
+        const m = new Matrix();
+        m.height = this.height;
+        m.width = this.width;
+        m.data = this.data.map(row => row.slice());
+        return m;
     }
-    if (col >= this.width) {
-        this.width = col + 1;
+
+    get(row, col) {
+        const line = this.data[row];
+        const val = line ? line[col] : null;
+        return val;
     }
-};
-
-Matrix.prototype.each = function each (f, includeEmpty) {
-        var this$1 = this;
-
-    for (var row = 0; row < this.height; ++row) {
-        for (var col = 0; col < this.width; ++col) {
-            var val = this$1.get(row, col);
-            if (includeEmpty || val != null) {
-                val = f(val, row, col);
-                if (val !== undefined) {
-                    return val;
-                }
-            }
+
+    set(row, col, data) {
+        let line = this.data[row];
+        if (line == null) {
+            line = this.data[row] = [];
         }
-    }
-};
-
-Matrix.prototype.map = function map (f, includeEmpty) {
-    var m = new Matrix();
-    this.each(function(el, row, col) {
-        m.set(row, col, f(el, row, col));
-    }, includeEmpty);
-    return m;
-};
-
-Matrix.prototype.transpose = function transpose () {
-    var m = new Matrix();
-    this.each(function(el, row, col) {
-        m.set(col, row, el);
-    });
-    return m;
-};
-
-Matrix.prototype.unit = function unit (n) {
-    this.width = this.height = n;
-    var a = this.data = new Array(n);
-    for (var i = n; --i >= 0;) {
-        var row = a[i] = new Array(n);
-        for (var j = n; --j >= 0;) {
-            row[j] = i === j ? 1 : 0;
+        line[col] = data;
+        if (row >= this.height) {
+            this.height = row + 1;
+        }
+        if (col >= this.width) {
+            this.width = col + 1;
         }
     }
-    return this;
-};
-
-Matrix.prototype.multiply = function multiply (b) {
-    var a = this;
-    var m = new Matrix();
-    for (var row = 0; row < a.height; ++row) {
-        for (var col = 0; col < b.width; ++col) {
-            var s = 0;
-            for (var i = 0; i < a.width; ++i) {
-                var va = a.get(row, i);
-                var vb = b.get(i, col);
-                if (typeof va === "number" && typeof vb === "number") {
-                    s += va * vb;
+
+    each(f, includeEmpty) {
+        for (let row = 0; row < this.height; ++row) {
+            for (let col = 0; col < this.width; ++col) {
+                let val = this.get(row, col);
+                if (includeEmpty || val != null) {
+                    val = f(val, row, col);
+                    if (val !== undefined) {
+                        return val;
+                    }
                 }
             }
-            m.set(row, col, s);
         }
     }
-    return m;
-};
-
-Matrix.prototype.inverse = function inverse () {
-    var n = this.width;
-    var m = this.augment(new Matrix().unit(n));
-    var a = m.data;
-
-    // Gaussian elimination
-    // https://en.wikipedia.org/wiki/Gaussian_elimination#Finding_the_inverse_of_a_matrix
-
-    // 1. Get zeros below main diagonal
-    var loop = function ( k ) {
-        var imax = argmax(k, n, function(i) { return a[i][k]; });
-        if (!a[imax][k]) {
-            return { v: null }; // singular matrix
-        }
-        if (k !== imax) {
-            var tmp = a[k];
-            a[k] = a[imax];
-            a[imax] = tmp;
+
+    map(f, includeEmpty) {
+        const m = new Matrix();
+        this.each(function(el, row, col) {
+            m.set(row, col, f(el, row, col));
+        }, includeEmpty);
+        return m;
+    }
+
+    transpose() {
+        const m = new Matrix();
+        this.each(function(el, row, col) {
+            m.set(col, row, el);
+        });
+        return m;
+    }
+
+    unit(n) {
+        this.width = this.height = n;
+        const a = this.data = new Array(n);
+        for (let i = n; --i >= 0;) {
+            const row = a[i] = new Array(n);
+            for (let j = n; --j >= 0;) {
+                row[j] = i === j ? 1 : 0;
+            }
         }
-        for (var i = k + 1; i < n; ++i) {
-            for (var j = k + 1; j < 2 * n; ++j) {
-                a[i][j] -= a[k][j] * a[i][k] / a[k][k];
+        return this;
+    }
+
+    multiply(b) {
+        const a = this;
+        const m = new Matrix();
+        for (let row = 0; row < a.height; ++row) {
+            for (let col = 0; col < b.width; ++col) {
+                let s = 0;
+                for (let i = 0; i < a.width; ++i) {
+                    const va = a.get(row, i);
+                    const vb = b.get(i, col);
+                    if (typeof va === "number" && typeof vb === "number") {
+                        s += va * vb;
+                    }
+                }
+                m.set(row, col, s);
             }
-            a[i][k] = 0;
         }
-    };
+        return m;
+    }
+
+    inverse() {
+        const n = this.width;
+        const m = this.augment(new Matrix().unit(n));
+        const a = m.data;
 
-        for (var k = 0; k < n; ++k) {
-            var returned = loop( k );
+        // Gaussian elimination
+        // https://en.wikipedia.org/wiki/Gaussian_elimination#Finding_the_inverse_of_a_matrix
 
-            if ( returned ) return returned.v;
+        // 1. Get zeros below main diagonal
+        for (let k = 0; k < n; ++k) {
+            const imax = argmax(k, n, function(i) { return a[i][k]; });
+            if (!a[imax][k]) {
+                return null; // singular matrix
+            }
+            if (k !== imax) {
+                let tmp = a[k];
+                a[k] = a[imax];
+                a[imax] = tmp;
+            }
+            for (let i = k + 1; i < n; ++i) {
+                for (let j = k + 1; j < 2 * n; ++j) {
+                    a[i][j] -= a[k][j] * a[i][k] / a[k][k];
+                }
+                a[i][k] = 0;
+            }
         }
 
-    // 2. Get 1-s on main diagonal, dividing by pivot
-    for (var i$1 = 0; i$1 < n; ++i$1) {
-        for (var f = a[i$1][i$1], j$1 = 0; j$1 < 2 * n; ++j$1) {
-            a[i$1][j$1] /= f;
+        // 2. Get 1-s on main diagonal, dividing by pivot
+        for (let i = 0; i < n; ++i) {
+            for (let f = a[i][i], j = 0; j < 2 * n; ++j) {
+                a[i][j] /= f;
+            }
         }
-    }
 
-    // 3. Get zeros above main diagonal.  Actually, we only care to compute the right side
-    // here (that will be the inverse), so in the inner loop below we go while j >= n,
-    // instead of j >= k.
-    for (var k$1 = n; --k$1 >= 0;) {
-        for (var i$2 = k$1; --i$2 >= 0;) {
-            if (a[i$2][k$1]) {
-                for (var j$2 = 2 * n; --j$2 >= n;) {
-                    a[i$2][j$2] -= a[k$1][j$2] * a[i$2][k$1];
+        // 3. Get zeros above main diagonal.  Actually, we only care to compute the right side
+        // here (that will be the inverse), so in the inner loop below we go while j >= n,
+        // instead of j >= k.
+        for (let k = n; --k >= 0;) {
+            for (let i = k; --i >= 0;) {
+                if (a[i][k]) {
+                    for (let j = 2 * n; --j >= n;) {
+                        a[i][j] -= a[k][j] * a[i][k];
+                    }
                 }
             }
         }
+
+        return m.slice(0, n, n, n);
     }
 
-    return m.slice(0, n, n, n);
-};
-
-Matrix.prototype.augment = function augment (m) {
-    var ret = this.clone();
-    var n = ret.width;
-    m.each(function(val, row, col) {
-        ret.set(row, col + n, val);
-    });
-    return ret;
-};
-
-Matrix.prototype.slice = function slice (row, col, height, width) {
-        var this$1 = this;
-
-    var m = new Matrix();
-    for (var i = 0; i < height; ++i) {
-        for (var j = 0; j < width; ++j) {
-            m.set(i, j, this$1.get(row + i, col + j));
+    augment(m) {
+        const ret = this.clone();
+        const n = ret.width;
+        m.each(function(val, row, col) {
+            ret.set(row, col + n, val);
+        });
+        return ret;
+    }
+
+    slice(row, col, height, width) {
+        const m = new Matrix();
+        for (let i = 0; i < height; ++i) {
+            for (let j = 0; j < width; ++j) {
+                m.set(i, j, this.get(row + i, col + j));
+            }
         }
+        return m;
     }
-    return m;
-};
+}
 
 function argmax(start, end, f) {
-    var max = f(start), pos = start;
-    for (var i = start + 1; i < end; i++) {
-        var v = f(start);
+    let max = f(start), pos = start;
+    for (let i = start + 1; i < end; i++) {
+        const v = f(start);
         if (v > max) {
             max = v;
             pos = start;

package/dist/es/common/mousewheel-delta.js

@@ -1,9 +1,9 @@
 import { support } from '@progress/kendo-drawing';
 
-var browser = support.browser || {};
+const browser = support.browser || {};
 
 export default function mousewheelDelta(e) {
-    var delta = 0;
+    let delta = 0;
 
     if (e.wheelDelta) {
         delta = -e.wheelDelta / 120;