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

package/dist/es/date-utils/to-date.js

@@ -1,5 +1,5 @@
 export default function toDate(value) {
-    var result;
+    let result;
 
     if (value instanceof Date) {
         result = value;

package/dist/es/date-utils/to-time.js

@@ -3,8 +3,8 @@ import toDate from './to-date';
 
 export default function toTime(value) {
     if (isArray(value)) {
-        var result = [];
-        for (var idx = 0; idx < value.length; idx++) {
+        let result = [];
+        for (let idx = 0; idx < value.length; idx++) {
             result.push(toTime(value[idx]));
         }
 

package/dist/es/drawing-utils.js

@@ -4,23 +4,24 @@ import {
     logToConsole
 } from '@progress/kendo-drawing';
 
-var ref = drawing.util;
-var append = ref.append;
-var bindEvents = ref.bindEvents;
-var defined = ref.defined;
-var deg = ref.deg;
-var elementOffset = ref.elementOffset;
-var elementSize = ref.elementSize;
-var eventCoordinates = ref.eventCoordinates;
-var eventElement = ref.eventElement;
-var hashKey = ref.hashKey;
-var last = ref.last;
-var limitValue = ref.limitValue;
-var objectKey = ref.objectKey;
-var rad = ref.rad;
-var round = ref.round;
-var unbindEvents = ref.unbindEvents;
-var valueOrDefault = ref.valueOrDefault;
+const {
+    append,
+    bindEvents,
+    defined,
+    deg,
+    elementOffset,
+    elementSize,
+    eventCoordinates,
+    eventElement,
+    hashKey,
+    last,
+    limitValue,
+    objectKey,
+    rad,
+    round,
+    unbindEvents,
+    valueOrDefault
+} = drawing.util;
 
 export {
     append,

package/dist/es/gauges/arc/arc-gauge.js

@@ -5,26 +5,19 @@ import RangePointer from './range-pointer';
 import { deepExtend } from '../../common';
 
 
-var ArcGauge = (function (RadialGauge) {
-    function ArcGauge () {
-        RadialGauge.apply(this, arguments);
-    }
-
-    if ( RadialGauge ) ArcGauge.__proto__ = RadialGauge;
-    ArcGauge.prototype = Object.create( RadialGauge && RadialGauge.prototype );
-    ArcGauge.prototype.constructor = ArcGauge;
+class ArcGauge extends RadialGauge {
 
-    ArcGauge.prototype._initTheme = function _initTheme (theme) {
-        RadialGauge.prototype._initTheme.call(this, theme);
+    _initTheme(theme) {
+        super._initTheme(theme);
 
         this.options.color = this.options.color || (this.theme.pointer || {}).color;
-    };
+    }
 
-    ArcGauge.prototype._createModel = function _createModel () {
-        var options = this.options;
-        var scale = this.scale = new ArcScale(options.scale, this.contextService);
+    _createModel() {
+        const options = this.options;
+        const scale = this.scale = new ArcScale(options.scale, this.contextService);
 
-        var pointer = new RangePointer(scale, deepExtend({}, {
+        const pointer = new RangePointer(scale, deepExtend({}, {
             colors: options.colors,
             color: options.color,
             value: options.value,
@@ -35,37 +28,37 @@ var ArcGauge = (function (RadialGauge) {
         }));
 
         this.pointers = [ pointer ];
-    };
+    }
 
-    ArcGauge.prototype._buildPointers = function _buildPointers (pointers) {
-        for (var i = 0; i < pointers.length; i++) {
-            var current = pointers[i];
+    _buildPointers(pointers) {
+        for (let i = 0; i < pointers.length; i++) {
+            const current = pointers[i];
             current.render();
 
             current.value(current.options.value);
         }
-    };
+    }
 
-    ArcGauge.prototype._setValueOptions = function _setValueOptions (value) {
+    _setValueOptions(value) {
         this.options.value = value;
-    };
+    }
 
-    ArcGauge.prototype.currentColor = function currentColor () {
-        var pointer = this.pointers[0];
+    currentColor() {
+        const pointer = this.pointers[0];
         if (pointer) {
             return pointer.currentColor();
         }
-    };
+    }
 
-    ArcGauge.prototype.centerLabelPosition = function centerLabelPosition (width, height) {
-        var size = this.getSize();
-        var center = this.scale.arc.center;
+    centerLabelPosition(width, height) {
+        const size = this.getSize();
+        const center = this.scale.arc.center;
 
-        var left = center.x - width / 2;
-        var top = center.y - height / 2;
+        let left = center.x - width / 2;
+        let top = center.y - height / 2;
 
         if (width < size.width) {
-            var right = left + width;
+            const right = left + width;
 
             left = Math.max(left, 0);
 
@@ -75,9 +68,9 @@ var ArcGauge = (function (RadialGauge) {
         }
 
         if (height < size.height) {
-            var bbox = this.scale.bbox;
-            var yLimit = bbox.bottomRight().y;
-            var bottom = top + height;
+            const bbox = this.scale.bbox;
+            const yLimit = bbox.bottomRight().y;
+            const bottom = top + height;
 
             top = Math.max(top, bbox.origin.y);
 
@@ -90,9 +83,7 @@ var ArcGauge = (function (RadialGauge) {
             left: left,
             top: top
         };
-    };
-
-    return ArcGauge;
-}(RadialGauge));
+    }
+}
 
 export default ArcGauge;

package/dist/es/gauges/arc/arc-scale.js

@@ -1,54 +1,41 @@
 import RadialScale from '../radial/radial-scale';
 import { setDefaultOptions } from '../../common';
 
-var ArcScale = (function (RadialScale) {
-    function ArcScale () {
-        RadialScale.apply(this, arguments);
-    }
-
-    if ( RadialScale ) ArcScale.__proto__ = RadialScale;
-    ArcScale.prototype = Object.create( RadialScale && RadialScale.prototype );
-    ArcScale.prototype.constructor = ArcScale;
+class ArcScale extends RadialScale {
 
-    ArcScale.prototype.rangeSegments = function rangeSegments () {
-        var ref = this.options;
-        var min = ref.min;
-        var max = ref.max;
-        var rangePlaceholderColor = ref.rangePlaceholderColor;
-        var rangeLineCap = ref.rangeLineCap;
+    rangeSegments() {
+        const { min, max, rangePlaceholderColor, rangeLineCap } = this.options;
 
         return [ { from: min, to: max, color: rangePlaceholderColor, lineCap: rangeLineCap } ];
-    };
+    }
 
-    ArcScale.prototype.hasRanges = function hasRanges () {
+    hasRanges() {
         return true;
-    };
+    }
 
-    ArcScale.prototype.placeholderRangeAngle = function placeholderRangeAngle (angle) {
-        var geometry = this.ranges.children[0].geometry();
+    placeholderRangeAngle(angle) {
+        const geometry = this.ranges.children[0].geometry();
 
         if (this.options.reverse) {
             geometry.setEndAngle(angle);
         } else {
             geometry.setStartAngle(angle);
         }
-    };
+    }
 
-    ArcScale.prototype.addRange = function addRange (from, to, options) {
-        var reverse = this.options.reverse;
+    addRange(from, to, options) {
+        const reverse = this.options.reverse;
 
-        var startAngle = this.slotAngle(reverse ? to : from);
-        var endAngle = this.slotAngle(reverse ? from : to);
+        const startAngle = this.slotAngle(reverse ? to : from);
+        const endAngle = this.slotAngle(reverse ? from : to);
 
-        var range = this.createRange(startAngle, endAngle, this.getRangeRadius(), options);
+        const range = this.createRange(startAngle, endAngle, this.getRangeRadius(), options);
 
         this.ranges.append(range);
 
         return range;
-    };
-
-    return ArcScale;
-}(RadialScale));
+    }
+}
 
 setDefaultOptions(ArcScale, {
     min: 0,

package/dist/es/gauges/arc/range-pointer-animation.js

@@ -2,47 +2,38 @@ import { drawing, Color } from '@progress/kendo-drawing';
 import { interpolateValue, setDefaultOptions, round, limitValue } from '../../common';
 import { ANGULAR_SPEED, LINEAR, RADIAL_RANGE_POINTER } from '../constants';
 
-var MAX_DURATION = 800;
+const MAX_DURATION = 800;
 
-var RangePointerAnimation = (function (superclass) {
-    function RangePointerAnimation(element, options) {
-        superclass.call(this, element, options);
+class RangePointerAnimation extends drawing.Animation {
+    constructor(element, options) {
+        super(element, options);
 
-        var animationOptions = this.options;
-        var duration = (Math.abs(animationOptions.newAngle - animationOptions.oldAngle) / animationOptions.duration) * 1000;
+        const animationOptions = this.options;
+        const duration = (Math.abs(animationOptions.newAngle - animationOptions.oldAngle) / animationOptions.duration) * 1000;
         animationOptions.duration = limitValue(duration, ANGULAR_SPEED, MAX_DURATION);
 
-        var startColor = element.elements.options.get("stroke.color");
-        var color = element.currentColor();
+        const startColor = element.elements.options.get("stroke.color");
+        const color = element.currentColor();
         if (startColor !== color) {
             this.startColor = new Color(startColor);
             this.color = new Color(color);
         }
     }
 
-    if ( superclass ) RangePointerAnimation.__proto__ = superclass;
-    RangePointerAnimation.prototype = Object.create( superclass && superclass.prototype );
-    RangePointerAnimation.prototype.constructor = RangePointerAnimation;
-
-    RangePointerAnimation.prototype.step = function step (pos) {
-        var ref = this;
-        var options = ref.options;
-        var startColor = ref.startColor;
-        var color = ref.color;
-        var angle = interpolateValue(options.oldAngle, options.newAngle, pos);
+    step(pos) {
+        const { options, startColor, color } = this;
+        const angle = interpolateValue(options.oldAngle, options.newAngle, pos);
         this.element.angle(angle);
 
         if (color) {
-            var r = round(interpolateValue(startColor.r, color.r, pos));
-            var g = round(interpolateValue(startColor.g, color.g, pos));
-            var b = round(interpolateValue(startColor.b, color.b, pos));
+            const r = round(interpolateValue(startColor.r, color.r, pos));
+            const g = round(interpolateValue(startColor.g, color.g, pos));
+            const b = round(interpolateValue(startColor.b, color.b, pos));
 
             this.element.stroke(new Color(r, g, b).toHex());
         }
-    };
-
-    return RangePointerAnimation;
-}(drawing.Animation));
+    }
+}
 
 setDefaultOptions(RangePointerAnimation, {
     easing: LINEAR,

package/dist/es/gauges/arc/range-pointer.js

@@ -3,21 +3,12 @@ import { ANGULAR_SPEED, RADIAL_RANGE_POINTER } from '../constants';
 import Pointer from '../pointer';
 import RangePointerAnimation from './range-pointer-animation';
 
-var RangePointer = (function (Pointer) {
-    function RangePointer () {
-        Pointer.apply(this, arguments);
-    }
-
-    if ( Pointer ) RangePointer.__proto__ = Pointer;
-    RangePointer.prototype = Object.create( Pointer && Pointer.prototype );
-    RangePointer.prototype.constructor = RangePointer;
+class RangePointer extends Pointer {
 
-    RangePointer.prototype.repaint = function repaint () {
-        var ref = this;
-        var scale = ref.scale;
-        var options = ref.options;
-        var oldAngle = scale.slotAngle(options._oldValue);
-        var newAngle = scale.slotAngle(options.value);
+    repaint() {
+        const { scale, options } = this;
+        const oldAngle = scale.slotAngle(options._oldValue);
+        const newAngle = scale.slotAngle(options.value);
 
         if (this.animation) {
             this.animation.abort();
@@ -34,30 +25,28 @@ var RangePointer = (function (Pointer) {
 
             this.animation.play();
         }
-    };
+    }
 
-    RangePointer.prototype.angle = function angle (value) {
-        var geometry = this.elements.geometry();
+    angle(value) {
+        const geometry = this.elements.geometry();
         if (this.scale.options.reverse) {
             geometry.setStartAngle(value);
         } else {
             geometry.setEndAngle(value);
         }
         this.scale.placeholderRangeAngle(value);
-    };
+    }
 
-    RangePointer.prototype.stroke = function stroke (value) {
+    stroke(value) {
         this.elements.stroke(value);
-    };
+    }
 
-    RangePointer.prototype.render = function render () {
+    render() {
         if (this.elements) {
             return;
         }
 
-        var ref = this;
-        var scale = ref.scale;
-        var options = ref.options;
+        const { scale, options } = this;
 
         if (options.animation !== false) {
             deepExtend(options.animation, {
@@ -72,24 +61,16 @@ var RangePointer = (function (Pointer) {
             opacity: options.opacity,
             lineCap: scale.options.rangeLineCap
         });
-    };
-
-    RangePointer.prototype.currentColor = function currentColor () {
-        var ref = this.scale.options;
-        var min = ref.min;
-        var max = ref.max;
-        var ref$1 = this.options;
-        var colors = ref$1.colors;
-        var color = ref$1.color;
-        var value = ref$1.value;
-        var currentValue = isNumber(value) ? value : min;
+    }
+
+    currentColor() {
+        const { min, max } = this.scale.options;
+        const { colors, color, value } = this.options;
+        const currentValue = isNumber(value) ? value : min;
 
         if (colors) {
-            for (var idx = 0; idx < colors.length; idx++) {
-                var ref$2 = colors[idx];
-                var rangeColor = ref$2.color;
-                var from = ref$2.from; if ( from === void 0 ) from = min;
-                var to = ref$2.to; if ( to === void 0 ) to = max;
+            for (let idx = 0; idx < colors.length; idx++) {
+                const { color: rangeColor, from = min, to = max } = colors[idx];
 
                 if (from <= currentValue && currentValue <= to) {
                     return rangeColor;
@@ -98,16 +79,14 @@ var RangePointer = (function (Pointer) {
         }
 
         return color;
-    };
+    }
 
-    RangePointer.prototype.reflow = function reflow () {
+    reflow() {
         this.render();
 
         this.bbox = this.elements.bbox();
-    };
-
-    return RangePointer;
-}(Pointer));
+    }
+}
 
 setDefaultOptions(RangePointer, {
     animation: {

package/dist/es/gauges/circular/circular-gauge.js

@@ -1,28 +1,18 @@
 import ArcGauge from '../arc/arc-gauge';
 
-var defaultStartAngle = 90;
+const defaultStartAngle = 90;
 
-var CircularGauge = (function (ArcGauge) {
-    function CircularGauge () {
-        ArcGauge.apply(this, arguments);
-    }
-
-    if ( ArcGauge ) CircularGauge.__proto__ = ArcGauge;
-    CircularGauge.prototype = Object.create( ArcGauge && ArcGauge.prototype );
-    CircularGauge.prototype.constructor = CircularGauge;
-
-    CircularGauge.prototype._createModel = function _createModel () {
-        var scaleOptions = this.options.scale;
+class CircularGauge extends ArcGauge {
+    _createModel() {
+        const scaleOptions = this.options.scale;
         if (typeof scaleOptions.startAngle !== 'number') {
             scaleOptions.startAngle = defaultStartAngle;
         }
 
         scaleOptions.endAngle = scaleOptions.startAngle + 360;
 
-        ArcGauge.prototype._createModel.call(this);
-    };
-
-    return CircularGauge;
-}(ArcGauge));
+        super._createModel();
+    }
+}
 
 export default CircularGauge;

package/dist/es/gauges/constants.js

@@ -1,17 +1,17 @@
-var ANGULAR_SPEED = 150;
-var LINEAR_SPEED = 250;
-var ARROW = "arrow";
-var ARROW_POINTER = "arrowPointer";
-var BAR_POINTER = "barPointer";
-var DEFAULT_HEIGHT = 200;
-var DEFAULT_LINE_WIDTH = 0.5;
-var DEFAULT_WIDTH = 200;
-var DEGREE = Math.PI / 180;
-var INSIDE = "inside";
-var LINEAR = "linear";
-var OUTSIDE = "outside";
-var RADIAL_POINTER = "radialPointer";
-var RADIAL_RANGE_POINTER = "radialRangePointer";
+const ANGULAR_SPEED = 150;
+const LINEAR_SPEED = 250;
+const ARROW = "arrow";
+const ARROW_POINTER = "arrowPointer";
+const BAR_POINTER = "barPointer";
+const DEFAULT_HEIGHT = 200;
+const DEFAULT_LINE_WIDTH = 0.5;
+const DEFAULT_WIDTH = 200;
+const DEGREE = Math.PI / 180;
+const INSIDE = "inside";
+const LINEAR = "linear";
+const OUTSIDE = "outside";
+const RADIAL_POINTER = "radialPointer";
+const RADIAL_RANGE_POINTER = "radialRangePointer";
 
 export {
     ANGULAR_SPEED, LINEAR_SPEED, ARROW, ARROW_POINTER, BAR_POINTER,