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

package/dist/es/gauges/linear/bar-linear-pointer.js

@@ -4,42 +4,33 @@ import { X, Y } from '../../common/constants';
 import LinearPointer from './linear-pointer';
 import BarLinearPointerAnimation from './bar-linear-pointer-animation';
 
-var Group = drawing.Group;
-var Path = drawing.Path;
+const { Group, Path } = drawing;
 
-var BarLinearPointer = (function (LinearPointer) {
-    function BarLinearPointer(scale, options) {
-        LinearPointer.call(this, scale, options);
+class BarLinearPointer extends LinearPointer {
+    constructor(scale, options) {
+        super(scale, options);
 
         if (!defined(this.options.size)) {
             this.options.size = this.scale.options.majorTicks.size * 0.3;
         }
     }
 
-    if ( LinearPointer ) BarLinearPointer.__proto__ = LinearPointer;
-    BarLinearPointer.prototype = Object.create( LinearPointer && LinearPointer.prototype );
-    BarLinearPointer.prototype.constructor = BarLinearPointer;
-
-    BarLinearPointer.prototype.pointerShape = function pointerShape (value) {
-        var ref = this;
-        var scale = ref.scale;
-        var options = ref.options;
-        var ref$1 = scale.options;
-        var mirror = ref$1.mirror;
-        var vertical = ref$1.vertical;
-        var dir = mirror === vertical ? -1 : 1;
-        var size = options.size * dir;
-        var minSlot = scale.getSlot(scale.options.min);
-        var slot = scale.getSlot(value);
-        var axis = vertical ? Y : X;
-        var sizeAxis = vertical ? X : Y;
-        var margin = this._margin() * dir;
-
-        var p1 = new geo.Point();
+    pointerShape(value) {
+        const { scale, options } = this;
+        const { mirror, vertical } = scale.options;
+        const dir = mirror === vertical ? -1 : 1;
+        const size = options.size * dir;
+        const minSlot = scale.getSlot(scale.options.min);
+        const slot = scale.getSlot(value);
+        const axis = vertical ? Y : X;
+        const sizeAxis = vertical ? X : Y;
+        const margin = this._margin() * dir;
+
+        const p1 = new geo.Point();
         p1[axis] = minSlot[axis + "1"];
         p1[sizeAxis] = minSlot[sizeAxis + "1"];
 
-        var p2 = new geo.Point();
+        const p2 = new geo.Point();
         p2[axis] = slot[axis + "1"];
         p2[sizeAxis] = slot[sizeAxis + "1"];
 
@@ -51,8 +42,8 @@ var BarLinearPointer = (function (LinearPointer) {
             p2.translate(0, margin);
         }
 
-        var p3 = p2.clone();
-        var p4 = p1.clone();
+        const p3 = p2.clone();
+        const p4 = p1.clone();
 
         if (vertical) {
             p3.translate(size, 0);
@@ -63,19 +54,17 @@ var BarLinearPointer = (function (LinearPointer) {
         }
 
         return [ p1, p2, p3, p4 ];
-    };
+    }
 
-    BarLinearPointer.prototype.repaint = function repaint () {
-        var ref = this;
-        var scale = ref.scale;
-        var options = ref.options;
-        var shape = this.pointerShape(options.value);
-        var pointerPath = this.pointerPath;
-        var oldShape = this.pointerShape(options._oldValue);
+    repaint() {
+        const { scale, options } = this;
+        const shape = this.pointerShape(options.value);
+        const pointerPath = this.pointerPath;
+        const oldShape = this.pointerShape(options._oldValue);
 
         pointerPath.moveTo(shape[0]).lineTo(shape[1]).lineTo(shape[2]).lineTo(shape[3]).close();
 
-        var animation = new BarLinearPointerAnimation(pointerPath, deepExtend(options.animation, {
+        const animation = new BarLinearPointerAnimation(pointerPath, deepExtend(options.animation, {
             reverse: scale.options.reverse,
             vertical: scale.options.vertical,
             oldPoints: [ oldShape[1], oldShape[2] ],
@@ -88,17 +77,17 @@ var BarLinearPointer = (function (LinearPointer) {
 
         animation.setup();
         animation.play();
-    };
+    }
 
-    BarLinearPointer.prototype.render = function render () {
-        var group = new Group();
-        var elementOptions = this.getElementOptions();
+    render() {
+        const group = new Group();
+        const elementOptions = this.getElementOptions();
 
         if (this.options.track.visible) {
             group.append(this.renderTrack());
         }
 
-        var pointer = this.pointerPath = new Path({
+        const pointer = this.pointerPath = new Path({
             stroke: elementOptions.stroke,
             fill: elementOptions.fill
         });
@@ -108,12 +97,12 @@ var BarLinearPointer = (function (LinearPointer) {
         this.elements = group;
 
         return group;
-    };
+    }
 
-    BarLinearPointer.prototype.renderTrack = function renderTrack () {
-        var trackOptions = this.options.track;
-        var border = trackOptions.border || {};
-        var trackBox = this.trackBox.clone().pad(border.width || 0);
+    renderTrack() {
+        const trackOptions = this.options.track;
+        const border = trackOptions.border || {};
+        const trackBox = this.trackBox.clone().pad(border.width || 0);
 
         return new Path.fromRect(trackBox.toRect(), {
             fill: {
@@ -126,9 +115,7 @@ var BarLinearPointer = (function (LinearPointer) {
                 dashType: border.dashType
             }
         });
-    };
-
-    return BarLinearPointer;
-}(LinearPointer));
+    }
+}
 
 export default BarLinearPointer;

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

@@ -7,31 +7,24 @@ import LinearScale from './linear-scale';
 import ArrowLinearPointer from './arrow-linear-pointer';
 import BarLinearPointer from './bar-linear-pointer';
 
-var DEFAULT_MIN_WIDTH = 60;
-var DEFAULT_MIN_HEIGHT = 60;
+const DEFAULT_MIN_WIDTH = 60;
+const DEFAULT_MIN_HEIGHT = 60;
 
-var Group = drawing.Group;
+const Group = drawing.Group;
 
-var LinearGauge = (function (Gauge) {
-    function LinearGauge () {
-        Gauge.apply(this, arguments);
-    }
-
-    if ( Gauge ) LinearGauge.__proto__ = Gauge;
-    LinearGauge.prototype = Object.create( Gauge && Gauge.prototype );
-    LinearGauge.prototype.constructor = LinearGauge;
+class LinearGauge extends Gauge {
 
-    LinearGauge.prototype.reflow = function reflow (bbox) {
-        var pointers = this.pointers;
-        var bboxX = bbox.origin.x;
-        var bboxY = bbox.origin.y;
+    reflow(bbox) {
+        const pointers = this.pointers;
+        const bboxX = bbox.origin.x;
+        const bboxY = bbox.origin.y;
 
-        var box = new Box(bboxX, bboxY, bboxX + bbox.width(), bboxY + bbox.height());
+        const box = new Box(bboxX, bboxY, bboxX + bbox.width(), bboxY + bbox.height());
 
         this.scale.reflow(box);
         this._shrinkScaleWidth(box);
 
-        for (var i = 0; i < pointers.length; i++) {
+        for (let i = 0; i < pointers.length; i++) {
             pointers[i].reflow();
         }
 
@@ -40,69 +33,65 @@ var LinearGauge = (function (Gauge) {
         this._shrinkElements();
         this._buildVisual();
         this._draw();
-    };
+    }
 
-    LinearGauge.prototype._buildVisual = function _buildVisual () {
-        var visuals = new Group();
-        var scaleElements = this.scale.render();
-        var pointers = this.pointers;
+    _buildVisual() {
+        const visuals = new Group();
+        const scaleElements = this.scale.render();
+        const pointers = this.pointers;
 
         visuals.append(this.gaugeArea);
         visuals.append(scaleElements);
 
-        for (var i = 0; i < pointers.length; i++) {
-            var current = pointers[i];
+        for (let i = 0; i < pointers.length; i++) {
+            const current = pointers[i];
             visuals.append(current.render());
             current.value(current.options.value);
         }
 
         this._visuals = visuals;
-    };
-
-    LinearGauge.prototype._createModel = function _createModel () {
-        var this$1 = this;
+    }
 
-        var options = this.options;
-        var scale = this.scale = new LinearScale(options.scale, this.contextService);
+    _createModel() {
+        const options = this.options;
+        const scale = this.scale = new LinearScale(options.scale, this.contextService);
 
         this.pointers = [];
 
-        var pointers = options.pointer;
+        let pointers = options.pointer;
         pointers = isArray(pointers) ? pointers : [ pointers ];
 
-        for (var i = 0; i < pointers.length; i++) {
-            var currentOptions = deepExtend({}, pointers[i], {
+        for (let i = 0; i < pointers.length; i++) {
+            const currentOptions = deepExtend({}, pointers[i], {
                 animation: {
                     transitions: options.transitions
                 }
             });
-            var pointerType = currentOptions.shape === ARROW ? ArrowLinearPointer : BarLinearPointer;
+            const pointerType = currentOptions.shape === ARROW ? ArrowLinearPointer : BarLinearPointer;
 
-            this$1.pointers.push(new pointerType(scale, currentOptions));
+            this.pointers.push(new pointerType(scale, currentOptions));
         }
-    };
+    }
 
-    LinearGauge.prototype._defaultSize = function _defaultSize () {
-        var vertical = this.options.scale.vertical;
+    _defaultSize() {
+        const vertical = this.options.scale.vertical;
 
         return {
             width: vertical ? DEFAULT_MIN_WIDTH : DEFAULT_WIDTH,
             height: vertical ? DEFAULT_HEIGHT : DEFAULT_MIN_HEIGHT
         };
-    };
+    }
 
-    LinearGauge.prototype._getBox = function _getBox (box) {
-        var ref = this;
-        var scale = ref.scale;
-        var pointers = ref.pointers;
-        var boxCenter = box.center();
-        var plotAreaBox = pointers[0].box.clone().wrap(scale.box);
+    _getBox(box) {
+        const { scale, pointers } = this;
+        const boxCenter = box.center();
+        let plotAreaBox = pointers[0].box.clone().wrap(scale.box);
 
-        for (var i = 0; i < pointers.length; i++) {
+        for (let i = 0; i < pointers.length; i++) {
             plotAreaBox.wrap(pointers[i].box.clone());
         }
 
-        var size;
+        let size;
         if (scale.options.vertical) {
             size = plotAreaBox.width() / 2;
             plotAreaBox = new Box(
@@ -118,23 +107,19 @@ var LinearGauge = (function (Gauge) {
         }
 
         return plotAreaBox;
-    };
-
-    LinearGauge.prototype._alignElements = function _alignElements () {
-        var this$1 = this;
+    }
 
-        var ref = this;
-        var scale = ref.scale;
-        var pointers = ref.pointers;
-        var scaleBox = scale.box;
-        var box = pointers[0].box.clone().wrap(scale.box);
-        var plotAreaBox = this.bbox;
+    _alignElements() {
+        const { scale, pointers } = this;
+        const scaleBox = scale.box;
+        const box = pointers[0].box.clone().wrap(scale.box);
+        const plotAreaBox = this.bbox;
 
-        for (var i = 0; i < pointers.length; i++) {
+        for (let i = 0; i < pointers.length; i++) {
             box.wrap(pointers[i].box.clone());
         }
 
-        var diff;
+        let diff;
         if (scale.options.vertical) {
             diff = plotAreaBox.center().x - box.center().x;
             scale.reflow(new Box(
@@ -149,35 +134,30 @@ var LinearGauge = (function (Gauge) {
             ));
         }
 
-        for (var i$1 = 0; i$1 < pointers.length; i$1++) {
-            pointers[i$1].reflow(this$1.bbox);
+        for (let i = 0; i < pointers.length; i++) {
+            pointers[i].reflow(this.bbox);
         }
-    };
+    }
 
-    LinearGauge.prototype._shrinkScaleWidth = function _shrinkScaleWidth (bbox) {
-        var ref = this;
-        var scale = ref.scale;
+    _shrinkScaleWidth(bbox) {
+        const { scale } = this;
         if (!scale.options.vertical) {
-            var overflow = scale.contentBox().width() - bbox.width();
+            const overflow = scale.contentBox().width() - bbox.width();
             if (overflow > 0) {
                 scale.box.shrink(overflow, 0);
                 scale.box.alignTo(bbox, 'center');
                 scale.reflow(scale.box);
             }
         }
-    };
-
-    LinearGauge.prototype._shrinkElements = function _shrinkElements () {
-        var this$1 = this;
+    }
 
-        var ref = this;
-        var scale = ref.scale;
-        var pointers = ref.pointers;
-        var scaleBox = scale.box.clone();
-        var pos = scale.options.vertical ? "y" : "x";
-        var pointerBox = pointers[0].box;
+    _shrinkElements() {
+        const { scale, pointers } = this;
+        const scaleBox = scale.box.clone();
+        const pos = scale.options.vertical ? "y" : "x";
+        const pointerBox = pointers[0].box;
 
-        for (var i = 0; i < pointers.length; i++) {
+        for (let i = 0; i < pointers.length; i++) {
             pointerBox.wrap(pointers[i].box.clone());
         }
 
@@ -186,13 +166,11 @@ var LinearGauge = (function (Gauge) {
 
         scale.reflow(scaleBox);
 
-        for (var i$1 = 0; i$1 < pointers.length; i$1++) {
-            pointers[i$1].reflow(this$1.bbox);
+        for (let i = 0; i < pointers.length; i++) {
+            pointers[i].reflow(this.bbox);
         }
-    };
-
-    return LinearGauge;
-}(Gauge));
+    }
+}
 
 setDefaultOptions(LinearGauge, {
     transitions: true,

package/dist/es/gauges/linear/linear-pointer.js

@@ -4,9 +4,9 @@ import { BLACK } from '../../common/constants';
 import { BAR_POINTER } from '../constants';
 import Pointer from '../pointer';
 
-var LinearPointer = (function (Pointer) {
-    function LinearPointer(scale, options) {
-        Pointer.call(this, scale, options);
+class LinearPointer extends Pointer {
+    constructor(scale, options) {
+        super(scale, options);
 
         this.options = deepExtend({
             track: {
@@ -15,25 +15,17 @@ var LinearPointer = (function (Pointer) {
         }, this.options);
     }
 
-    if ( Pointer ) LinearPointer.__proto__ = Pointer;
-    LinearPointer.prototype = Object.create( Pointer && Pointer.prototype );
-    LinearPointer.prototype.constructor = LinearPointer;
-
-    LinearPointer.prototype.reflow = function reflow () {
-        var ref = this;
-        var options = ref.options;
-        var scale = ref.scale;
-        var ref$1 = scale.options;
-        var mirror = ref$1.mirror;
-        var vertical = ref$1.vertical;
-        var scaleLine = scale.lineBox();
-        var trackSize = options.track.size || options.size;
-        var pointerHalfSize = options.size / 2;
-        var margin = getSpacing(options.margin);
-        var space = vertical ?
+    reflow() {
+        const { options, scale } = this;
+        const { mirror, vertical } = scale.options;
+        const scaleLine = scale.lineBox();
+        const trackSize = options.track.size || options.size;
+        const pointerHalfSize = options.size / 2;
+        const margin = getSpacing(options.margin);
+        let space = vertical ?
             margin[mirror ? "left" : "right"] :
             margin[mirror ? "bottom" : "top"];
-        var pointerBox, pointerRangeBox, trackBox;
+        let pointerBox, pointerRangeBox, trackBox;
 
         space = mirror ? -space : space;
 
@@ -78,10 +70,10 @@ var LinearPointer = (function (Pointer) {
         this.trackBox = trackBox;
         this.pointerRangeBox = pointerRangeBox;
         this.box = pointerBox || trackBox.clone().pad(options.border.width);
-    };
+    }
 
-    LinearPointer.prototype.getElementOptions = function getElementOptions () {
-        var options = this.options;
+    getElementOptions() {
+        const options = this.options;
 
         return {
             fill: {
@@ -95,26 +87,20 @@ var LinearPointer = (function (Pointer) {
                 opacity: options.opacity
             } : null
         };
-    };
-
-    LinearPointer.prototype._margin = function _margin () {
-        var ref = this;
-        var scale = ref.scale;
-        var options = ref.options;
-        var ref$1 = scale.options;
-        var mirror = ref$1.mirror;
-        var vertical = ref$1.vertical;
-        var margin = getSpacing(options.margin);
-
-        var space = vertical ?
+    }
+
+    _margin() {
+        const { scale, options } = this;
+        const { mirror, vertical } = scale.options;
+        const margin = getSpacing(options.margin);
+
+        const space = vertical ?
             margin[mirror ? "left" : "right"] :
             margin[mirror ? "bottom" : "top"];
 
         return space;
-    };
-
-    return LinearPointer;
-}(Pointer));
+    }
+}
 
 setDefaultOptions(LinearPointer, {
     shape: BAR_POINTER,