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

package/dist/es/common/observable.js

@@ -1,32 +1,28 @@
 import { Class } from '../drawing-utils';
 
-var STRING = "string";
-var FUNCTION = "function";
+const STRING = "string";
+const FUNCTION = "function";
 
-var preventDefault = function() {
+let preventDefault = function() {
     this._defaultPrevented = true;
 };
 
-var isDefaultPrevented = function() {
+let isDefaultPrevented = function() {
     return this._defaultPrevented === true;
 };
 
-var Observable = (function (Class) {
-    function Observable() {
-        Class.call(this);
+export default class Observable extends Class {
+    constructor() {
+        super();
         this._events = {};
     }
 
-    if ( Class ) Observable.__proto__ = Class;
-    Observable.prototype = Object.create( Class && Class.prototype );
-    Observable.prototype.constructor = Observable;
-
-    Observable.prototype.destroy = function destroy () {
+    destroy() {
         this.unbind();
-    };
+    }
 
-    Observable.prototype.bind = function bind (event, handlers, one) {
-        var that = this,
+    bind(event, handlers, one) {
+        let that = this,
             idx,
             eventNames = typeof event === STRING ? [event] : event || [],
             length,
@@ -44,8 +40,8 @@ var Observable = (function (Class) {
         }
 
         /* eslint-disable no-loop-func */
-        var loop = function (  ) {
-            var eventName = eventNames[idx];
+        for (idx = 0, length = eventNames.length; idx < length; idx++) {
+            let eventName = eventNames[idx];
 
             handler = handlersIsFunction ? handlers : handlers[eventName];
 
@@ -63,20 +59,18 @@ var Observable = (function (Class) {
                 events = that._events[eventName] = that._events[eventName] || [];
                 events.push(handler);
             }
-        };
-
-        for (idx = 0, length = eventNames.length; idx < length; idx++) loop(  );
+        }
         /* eslint-enable no-loop-func */
 
         return that;
-    };
+    }
 
-    Observable.prototype.one = function one (eventNames, handlers) {
+    one(eventNames, handlers) {
         return this.bind(eventNames, handlers, true);
-    };
+    }
 
-    Observable.prototype.first = function first (eventName, handlers) {
-        var that = this,
+    first(eventName, handlers) {
+        let that = this,
             idx,
             eventNames = typeof eventName === STRING ? [eventName] : eventName,
             length,
@@ -85,27 +79,27 @@ var Observable = (function (Class) {
             events;
 
         for (idx = 0, length = eventNames.length; idx < length; idx++) {
-            var eventName$1 = eventNames[idx];
+            let eventName = eventNames[idx];
 
-            handler = handlersIsFunction ? handlers : handlers[eventName$1];
+            handler = handlersIsFunction ? handlers : handlers[eventName];
 
             if (handler) {
-                events = that._events[eventName$1] = that._events[eventName$1] || [];
+                events = that._events[eventName] = that._events[eventName] || [];
                 events.unshift(handler);
             }
         }
 
         return that;
-    };
+    }
 
-    Observable.prototype.trigger = function trigger (eventName, eventArgs) {
-        var that = this,
+    trigger(eventName, eventArgs) {
+        let that = this,
             events = that._events[eventName],
             idx,
             length;
 
         if (events) {
-            var e = eventArgs || {};
+            let e = eventArgs || {};
 
             e.sender = that;
 
@@ -125,10 +119,10 @@ var Observable = (function (Class) {
         }
 
         return false;
-    };
+    }
 
-    Observable.prototype.unbind = function unbind (eventName, handler) {
-        var that = this,
+    unbind(eventName, handler) {
+        let that = this,
             events = that._events[eventName],
             idx;
 
@@ -147,29 +141,23 @@ var Observable = (function (Class) {
         }
 
         return that;
-    };
-
-    Observable.prototype._setEvents = function _setEvents (options) {
-        var this$1 = this;
+    }
 
-        var length = (this.events || []).length;
+    _setEvents(options) {
+        const length = (this.events || []).length;
 
-        for (var idx = 0; idx < length; idx ++) {
-            var e = this$1.events[idx];
+        for (let idx = 0; idx < length; idx ++) {
+            let e = this.events[idx];
 
-            if (this$1.options[e] && options[e]) {
-                this$1.unbind(e, this$1.options[e]);
+            if (this.options[e] && options[e]) {
+                this.unbind(e, this.options[e]);
 
-                if (this$1._events && this$1._events[e]) {
-                    delete this$1._events[e];
+                if (this._events && this._events[e]) {
+                    delete this._events[e];
                 }
             }
         }
 
         this.bind(this.events, options);
-    };
-
-    return Observable;
-}(Class));
-
-export default Observable;
+    }
+}

package/dist/es/common/remove-class.js

@@ -1,4 +1,4 @@
-var SPACE_REGEX = /\s+/g;
+const SPACE_REGEX = /\s+/g;
 
 export default function removeClass(element, className) {
     if (element && element.className) {

package/dist/es/common/render-icon.js

@@ -6,29 +6,31 @@ import setDefaultOptions from './set-default-options';
 import addClass from './add-class';
 import removeClass from './remove-class';
 
-var KICON = 'k-icon';
-var KI_PREFFIX = 'k-i-';
-var KFONTICON = 'k-font-icon';
-var KSVGICON = 'k-svg-icon';
-var KSVG_PREFFIX = 'k-svg-i-';
-
-var HTMLBaseIcon = function HTMLBaseIcon(element, options) {
-    this.element = element;
-    this.options = deepExtend({}, this.options, options);
-
-    this.wrapper();
-};
+const KICON = 'k-icon';
+const KI_PREFFIX = 'k-i-';
+const KFONTICON = 'k-font-icon';
+const KSVGICON = 'k-svg-icon';
+const KSVG_PREFFIX = 'k-svg-i-';
+
+class HTMLBaseIcon {
+    constructor(element, options) {
+        this.element = element;
+        this.options = deepExtend({}, this.options, options);
+
+        this.wrapper();
+    }
 
-HTMLBaseIcon.prototype.wrapper = function wrapper () {
-    this.addClasses();
-};
+    wrapper() {
+        this.addClasses();
+    }
 
-HTMLBaseIcon.prototype.addClasses = function addClasses () {
-};
+    addClasses() {
+    }
 
-HTMLBaseIcon.prototype.html = function html () {
-    return this.element.outerHTML;
-};
+    html() {
+        return this.element.outerHTML;
+    }
+}
 
 setDefaultOptions(HTMLBaseIcon, {
     name: '',
@@ -39,19 +41,15 @@ setDefaultOptions(HTMLBaseIcon, {
     stylingOptions: [ 'size', 'themeColor', 'fill' ]
 });
 
-var HTMLFontIcon = (function (HTMLBaseIcon) {
-    function HTMLFontIcon(element, options) {
-        HTMLBaseIcon.call(this, element, options);
+class HTMLFontIcon extends HTMLBaseIcon {
+    constructor(element, options) {
+        super(element, options);
     }
 
-    if ( HTMLBaseIcon ) HTMLFontIcon.__proto__ = HTMLBaseIcon;
-    HTMLFontIcon.prototype = Object.create( HTMLBaseIcon && HTMLBaseIcon.prototype );
-    HTMLFontIcon.prototype.constructor = HTMLFontIcon;
-
-    HTMLFontIcon.prototype.wrapper = function wrapper () {
+    wrapper() {
         // Find if there is an existing k-i- class appended to the element.
-        var currentIconClass = this.element.className.split(" ").find(function (x) { return x.startsWith(KI_PREFFIX); });
-        var className = this.options.icon ? ("" + (this.options.icon.startsWith(KI_PREFFIX) ? "" : KI_PREFFIX) + (this.options.icon)) : "";
+        let currentIconClass = this.element.className.split(" ").find(x => x.startsWith(KI_PREFFIX));
+        let className = this.options.icon ? `${this.options.icon.startsWith(KI_PREFFIX) ? "" : KI_PREFFIX}${this.options.icon}` : "";
 
         this._className = className;
 
@@ -61,38 +59,32 @@ var HTMLFontIcon = (function (HTMLBaseIcon) {
         addClass(this.element, className);
         addClass(this.element, this.options.iconClass || '');
 
-        HTMLBaseIcon.prototype.wrapper.call(this);
-    };
-
-    return HTMLFontIcon;
-}(HTMLBaseIcon));
+        super.wrapper();
+    }
+}
 
 setDefaultOptions(HTMLFontIcon, {
     name: 'HTMLFontIcon',
     icon: null
 });
 
-var HTMLSvgIcon = (function (HTMLBaseIcon) {
-    function HTMLSvgIcon(element, options) {
+class HTMLSvgIcon extends HTMLBaseIcon {
+    constructor(element, options) {
         // Ensure that the inner contents of the wrapping span element are always removed for re-rendering purposes.
         element.innerHTML = "";
 
-        HTMLBaseIcon.call(this, element, options);
+        super(element, options);
     }
 
-    if ( HTMLBaseIcon ) HTMLSvgIcon.__proto__ = HTMLBaseIcon;
-    HTMLSvgIcon.prototype = Object.create( HTMLBaseIcon && HTMLBaseIcon.prototype );
-    HTMLSvgIcon.prototype.constructor = HTMLSvgIcon;
-
-    HTMLSvgIcon.prototype.wrapper = function wrapper () {
-        var icon = this.options.icon;
-        var iconClass = this.options.iconClass;
-        var currentIconClass = this.element.className.split(" ").find(function (x) { return x.startsWith(KSVG_PREFFIX); });
+    wrapper() {
+        let icon = this.options.icon;
+        let iconClass = this.options.iconClass;
+        let currentIconClass = this.element.className.split(" ").find(x => x.startsWith(KSVG_PREFFIX));
 
         if (!icon && iconClass) {
             // match k-i-(some-icon-name)
-            var regex = /k-i-(\w+(?:-\w+)*)/;
-            var iconNameMatch = iconClass.match(regex);
+            const regex = /k-i-(\w+(?:-\w+)*)/;
+            let iconNameMatch = iconClass.match(regex);
             if (iconNameMatch) {
                 icon = iconNameMatch[1];
                 iconClass = iconClass.replace(iconNameMatch[0], "");
@@ -100,11 +92,11 @@ var HTMLSvgIcon = (function (HTMLBaseIcon) {
         }
 
         if (isString(icon)) {
-            icon = icon.replace("k-i-", "").replace(/-./g, function (x) { return x[1].toUpperCase(); });
-            icon = this.options.svgIcons[icon] || this.options.svgIcons[(icon + "Icon")];
+            icon = icon.replace("k-i-", "").replace(/-./g, x => x[1].toUpperCase());
+            icon = this.options.svgIcons[icon] || this.options.svgIcons[`${icon}Icon`];
         }
 
-        var className = icon && icon.name ? ("" + KSVG_PREFFIX + (icon.name)) : "";
+        let className = icon && icon.name ? `${KSVG_PREFFIX}${icon.name}` : "";
         this._className = className;
 
         addClass(this.element, KSVGICON);
@@ -114,7 +106,7 @@ var HTMLSvgIcon = (function (HTMLBaseIcon) {
         this.element.setAttribute("aria-hidden", "true");
 
         if (icon && isPlainObject(icon)) {
-            var svgElement = document.createElementNS('http://www.w3.org/2000/svg', 'svg');
+            let svgElement = document.createElementNS('http://www.w3.org/2000/svg', 'svg');
             svgElement.setAttribute("viewBox", icon.viewBox || "");
             svgElement.setAttribute("focusable", "false");
             svgElement.innerHTML = icon.content || "";
@@ -122,11 +114,9 @@ var HTMLSvgIcon = (function (HTMLBaseIcon) {
             this.element.appendChild(svgElement);
         }
 
-        HTMLBaseIcon.prototype.wrapper.call(this);
-    };
-
-    return HTMLSvgIcon;
-}(HTMLBaseIcon));
+        super.wrapper();
+    }
+}
 
 setDefaultOptions(HTMLSvgIcon, {
     name: 'HTMLSvgIcon',
@@ -134,14 +124,14 @@ setDefaultOptions(HTMLSvgIcon, {
     svgIcons: {}
 });
 
-var ICON_TYPES = {
+const ICON_TYPES = {
     'svg': HTMLSvgIcon,
     'font': HTMLFontIcon
 };
 
 export default function renderIcon(iconElement, iconOptions) {
-    var element = iconElement;
-    var options = iconOptions;
+    let element = iconElement;
+    let options = iconOptions;
 
     if (!element
         || (isObject(element) && !(element instanceof HTMLElement))

package/dist/es/common/set-default-options.js

@@ -1,7 +1,7 @@
 import deepExtend from './deep-extend';
 
 export default function setDefaultOptions(type, options) {
-    var proto = type.prototype;
+    const proto = type.prototype;
     if (proto.options) {
         proto.options = deepExtend({}, proto.options, options);
     } else {

package/dist/es/common/sparse-array-limits.js

@@ -1,11 +1,11 @@
 import { MIN_VALUE, MAX_VALUE } from './constants';
 
 export default function sparseArrayLimits(arr) {
-    var min = MAX_VALUE;
-    var max = MIN_VALUE;
+    let min = MAX_VALUE;
+    let max = MIN_VALUE;
 
-    for (var idx = 0, length = arr.length; idx < length; idx++) {
-        var value = arr[idx];
+    for (let idx = 0, length = arr.length; idx < length; idx++) {
+        const value = arr[idx];
         if (value !== null && isFinite(value)) {
             min = Math.min(min, value);
             max = Math.max(max, value);