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

package/dist/es/core/chart-element.js

@@ -3,93 +3,86 @@ import { drawing as draw } from '@progress/kendo-drawing';
 import { WHITE } from '../common/constants';
 import { Class, deepExtend, defined, valueOrDefault, autoTextColor } from '../common';
 
-var ChartElement = (function (Class) {
-    function ChartElement(options) {
-        Class.call(this);
+class ChartElement extends Class {
+    constructor(options) {
+        super();
 
         this.children = [];
 
         this.options = deepExtend({}, this.options, this.initUserOptions(options));
     }
 
-    if ( Class ) ChartElement.__proto__ = Class;
-    ChartElement.prototype = Object.create( Class && Class.prototype );
-    ChartElement.prototype.constructor = ChartElement;
-
-    ChartElement.prototype.initUserOptions = function initUserOptions (options) {
+    initUserOptions(options) {
         return options;
-    };
+    }
 
-    ChartElement.prototype.reflow = function reflow (targetBox) {
-        var children = this.children;
-        var box;
+    reflow(targetBox) {
+        const children = this.children;
+        let box;
 
-        for (var i = 0; i < children.length; i++) {
-            var currentChild = children[i];
+        for (let i = 0; i < children.length; i++) {
+            let currentChild = children[i];
             currentChild.reflow(targetBox);
 
             box = box ? box.wrap(currentChild.box) : currentChild.box.clone();
         }
 
         this.box = box || targetBox;
-    };
+    }
 
-    ChartElement.prototype.destroy = function destroy () {
-        var children = this.children;
+    destroy() {
+        const children = this.children;
 
         if (this.animation) {
             this.animation.destroy();
         }
 
-        for (var i = 0; i < children.length; i++) {
+        for (let i = 0; i < children.length; i++) {
             children[i].destroy();
         }
-    };
+    }
 
-    ChartElement.prototype.getRoot = function getRoot () {
-        var parent = this.parent;
+    getRoot() {
+        const parent = this.parent;
 
         return parent ? parent.getRoot() : null;
-    };
+    }
 
-    ChartElement.prototype.getSender = function getSender () {
-        var service = this.getService();
+    getSender() {
+        const service = this.getService();
         if (service) {
             return service.sender;
         }
-    };
+    }
 
-    ChartElement.prototype.getService = function getService () {
-        var element = this;
+    getService() {
+        let element = this;
         while (element) {
             if (element.chartService) {
                 return element.chartService;
             }
             element = element.parent;
         }
-    };
+    }
 
-    ChartElement.prototype.translateChildren = function translateChildren (dx, dy) {
-        var children = this.children;
-        var childrenCount = children.length;
+    translateChildren(dx, dy) {
+        const children = this.children;
+        const childrenCount = children.length;
 
-        for (var i = 0; i < childrenCount; i++) {
+        for (let i = 0; i < childrenCount; i++) {
             children[i].box.translate(dx, dy);
         }
-    };
-
-    ChartElement.prototype.append = function append () {
-        var arguments$1 = arguments;
-        var this$1 = this;
+    }
 
-        for (var i = 0; i < arguments.length; i++) {
-            var item = arguments$1[i];
-            this$1.children.push(item);
-            item.parent = this$1;
+    append() {
+        for (let i = 0; i < arguments.length; i++) {
+            let item = arguments[i];
+            this.children.push(item);
+            item.parent = this;
         }
-    };
+    }
 
-    ChartElement.prototype.renderVisual = function renderVisual () {
+    renderVisual() {
         if (this.options.visible === false) {
             return;
         }
@@ -102,9 +95,9 @@ var ChartElement = (function (Class) {
 
         this.createAnimation();
         this.renderComplete();
-    };
+    }
 
-    ChartElement.prototype.addVisual = function addVisual () {
+    addVisual() {
         if (this.visual) {
             this.visual.chartElement = this;
 
@@ -112,32 +105,32 @@ var ChartElement = (function (Class) {
                 this.parent.appendVisual(this.visual);
             }
         }
-    };
+    }
 
-    ChartElement.prototype.renderChildren = function renderChildren () {
-        var children = this.children;
-        var length = children.length;
-        for (var i = 0; i < length; i++) {
+    renderChildren() {
+        const children = this.children;
+        const length = children.length;
+        for (let i = 0; i < length; i++) {
             children[i].renderVisual();
         }
-    };
+    }
 
-    ChartElement.prototype.createVisual = function createVisual () {
+    createVisual() {
         this.visual = new draw.Group({
             zIndex: this.options.zIndex,
             visible: valueOrDefault(this.options.visible, true)
         });
-    };
+    }
 
-    ChartElement.prototype.createAnimation = function createAnimation () {
+    createAnimation() {
         if (this.visual && this.options.animation) {
             this.animation = draw.Animation.create(
                 this.visual, this.options.animation
             );
         }
-    };
+    }
 
-    ChartElement.prototype.appendVisual = function appendVisual (childVisual) {
+    appendVisual(childVisual) {
         if (!childVisual.chartElement) {
             childVisual.chartElement = this;
         }
@@ -155,58 +148,58 @@ var ChartElement = (function (Class) {
             // pass through child visuals
             this.parent.appendVisual(childVisual);
         }
-    };
+    }
 
-    ChartElement.prototype.clipRoot = function clipRoot () {
+    clipRoot() {
         if (this.parent) {
             return this.parent.clipRoot();
         }
 
         return this;
-    };
+    }
 
-    ChartElement.prototype.stackRoot = function stackRoot () {
+    stackRoot() {
         if (this.parent) {
             return this.parent.stackRoot();
         }
 
         return this;
-    };
+    }
 
-    ChartElement.prototype.stackVisual = function stackVisual (childVisual) {
-        var zIndex = childVisual.options.zIndex || 0;
-        var visuals = this.visual.children;
-        var length = visuals.length;
-        var pos;
+    stackVisual(childVisual) {
+        const zIndex = childVisual.options.zIndex || 0;
+        const visuals = this.visual.children;
+        const length = visuals.length;
+        let pos;
 
         for (pos = 0; pos < length; pos++) {
-            var sibling = visuals[pos];
-            var here = valueOrDefault(sibling.options.zIndex, 0);
+            let sibling = visuals[pos];
+            let here = valueOrDefault(sibling.options.zIndex, 0);
             if (here > zIndex) {
                 break;
             }
         }
 
         this.visual.insert(pos, childVisual);
-    };
+    }
 
-    ChartElement.prototype.traverse = function traverse (callback) {
-        var children = this.children;
-        var length = children.length;
+    traverse(callback) {
+        const children = this.children;
+        const length = children.length;
 
-        for (var i = 0; i < length; i++) {
-            var child = children[i];
+        for (let i = 0; i < length; i++) {
+            let child = children[i];
 
             callback(child);
             if (child.traverse) {
                 child.traverse(callback);
             }
         }
-    };
+    }
 
-    ChartElement.prototype.closest = function closest (match) {
-        var element = this;
-        var matched = false;
+    closest(match) {
+        let element = this;
+        let matched = false;
 
         while (element && !matched) {
             matched = match(element);
@@ -219,24 +212,22 @@ var ChartElement = (function (Class) {
         if (matched) {
             return element;
         }
-    };
+    }
 
-    ChartElement.prototype.renderComplete = function renderComplete () {};
+    renderComplete() {}
 
-    ChartElement.prototype.hasHighlight = function hasHighlight () {
-        var options = (this.options || {}).highlight;
+    hasHighlight() {
+        const options = (this.options || {}).highlight;
         return !(!this.createHighlight || (options && options.visible === false) || this.visible === false);
-    };
-
-    ChartElement.prototype.toggleHighlight = function toggleHighlight (show, opacity) {
-        var this$1 = this;
+    }
 
-        var options = (this.options || {}).highlight || {};
-        var customVisual = options.visual;
-        var highlight = this._highlight;
+    toggleHighlight(show, opacity) {
+        const options = (this.options || {}).highlight || {};
+        const customVisual = options.visual;
+        let highlight = this._highlight;
 
         if (!highlight) {
-            var highlightOptions = {
+            const highlightOptions = {
                 fill: {
                     color: WHITE,
                     opacity: opacity || 0.2
@@ -251,7 +242,7 @@ var ChartElement = (function (Class) {
             if (customVisual) {
                 highlight = this._highlight = customVisual(
                     Object.assign(this.highlightVisualArgs(), {
-                        createVisual: function () { return this$1.createHighlight(highlightOptions); },
+                        createVisual: () => this.createHighlight(highlightOptions),
                         sender: this.getSender(),
                         series: this.series,
                         dataItem: this.dataItem,
@@ -278,20 +269,20 @@ var ChartElement = (function (Class) {
         }
 
         highlight.visible(show);
-    };
+    }
 
-    ChartElement.prototype.toggleFocusHighlight = function toggleFocusHighlight (show) {
-        var options = (this.options || {}).focusHighlight || {};
-        var focusHighlight = this._focusHighlight;
+    toggleFocusHighlight(show) {
+        const options = (this.options || {}).focusHighlight || {};
+        let focusHighlight = this._focusHighlight;
 
         if (!show && !focusHighlight) {
             return;
         }
 
         if (!focusHighlight) {
-            var rootBackground = this.getRoot().options.background;
-            var highlightColor = autoTextColor(rootBackground);
-            var focusHighlightOptions = {
+            const rootBackground = this.getRoot().options.background;
+            const highlightColor = autoTextColor(rootBackground);
+            const focusHighlightOptions = {
                 fill: {
                     opacity: options.opacity,
                     color: options.color
@@ -306,10 +297,10 @@ var ChartElement = (function (Class) {
         }
 
         focusHighlight.visible(show);
-    };
+    }
 
-    ChartElement.prototype.createGradientOverlay = function createGradientOverlay (element, options, gradientOptions) {
-        var overlay = new draw.Path(Object.assign({
+    createGradientOverlay(element, options, gradientOptions) {
+        const overlay = new draw.Path(Object.assign({
             stroke: {
                 color: "none"
             },
@@ -320,20 +311,18 @@ var ChartElement = (function (Class) {
         overlay.segments.elements(element.segments.elements());
 
         return overlay;
-    };
+    }
 
-    ChartElement.prototype.createGradient = function createGradient (options) {
+    createGradient(options) {
         if (this.parent) {
             return this.parent.createGradient(options);
         }
-    };
+    }
 
-    ChartElement.prototype.supportsPointInactiveOpacity = function supportsPointInactiveOpacity () {
+    supportsPointInactiveOpacity() {
         return true;
-    };
-
-    return ChartElement;
-}(Class));
+    }
+}
 
 ChartElement.prototype.options = { };
 

package/dist/es/core/constants.js

@@ -1,6 +1,6 @@
-var COORDINATE_LIMIT = 300000;
+const COORDINATE_LIMIT = 300000;
 
-var DateLabelFormats = {
+const DateLabelFormats = {
     milliseconds: "HH:mm:ss.fff",
     seconds: "HH:mm:ss",
     minutes: "HH:mm",
@@ -11,7 +11,7 @@ var DateLabelFormats = {
     years: "yyyy"
 };
 
-var ZERO_THRESHOLD = 0.2;
+const ZERO_THRESHOLD = 0.2;
 
 export {
     COORDINATE_LIMIT, DateLabelFormats, ZERO_THRESHOLD