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

package/dist/es/gauges/gauge.js

@@ -4,15 +4,13 @@ import { DEFAULT_WIDTH, DEFAULT_HEIGHT } from './constants';
 import { ChartService } from '../services';
 import { unpad } from './utils';
 
-var DEFAULT_MARGIN = 5;
-var Path = drawing.Path;
-var Surface = drawing.Surface;
+const DEFAULT_MARGIN = 5;
+const { Path, Surface } = drawing;
 
-var Gauge = (function (Class) {
-    function Gauge(element, userOptions, theme, context) {
-        if ( context === void 0 ) context = {};
+class Gauge extends Class {
 
-        Class.call(this);
+    constructor(element, userOptions, theme, context = {}) {
+        super();
 
         this.element = element;
         this.theme = theme;
@@ -24,11 +22,7 @@ var Gauge = (function (Class) {
         this.redraw();
     }
 
-    if ( Class ) Gauge.__proto__ = Class;
-    Gauge.prototype = Object.create( Class && Class.prototype );
-    Gauge.prototype.constructor = Gauge;
-
-    Gauge.prototype.destroy = function destroy () {
+    destroy() {
         if (this.surface) {
             this.surface.destroy();
             this.surface = null;
@@ -36,10 +30,10 @@ var Gauge = (function (Class) {
 
         delete this.element;
         delete this.surfaceElement;
-    };
+    }
 
-    Gauge.prototype.value = function value (pointerValue) {
-        var pointer = this.pointers[0];
+    value(pointerValue) {
+        const pointer = this.pointers[0];
 
         if (arguments.length === 0) {
             return pointer.value();
@@ -47,25 +41,25 @@ var Gauge = (function (Class) {
 
         pointer.value(pointerValue);
         this._setValueOptions(pointerValue);
-    };
+    }
 
-    Gauge.prototype._draw = function _draw () {
-        var surface = this.surface;
+    _draw() {
+        const surface = this.surface;
 
         surface.clear();
         surface.draw(this._visuals);
-    };
+    }
 
-    Gauge.prototype.exportVisual = function exportVisual () {
+    exportVisual() {
         return this._visuals;
-    };
+    }
 
-    Gauge.prototype.allValues = function allValues (values) {
-        var pointers = this.pointers;
-        var allValues = [];
+    allValues(values) {
+        const pointers = this.pointers;
+        const allValues = [];
 
         if (arguments.length === 0) {
-            for (var i = 0; i < pointers.length; i++) {
+            for (let i = 0; i < pointers.length; i++) {
                 allValues.push(pointers[i].value());
             }
 
@@ -73,42 +67,42 @@ var Gauge = (function (Class) {
         }
 
         if (isArray(values)) {
-            for (var i$1 = 0; i$1 < values.length; i$1++) {
-                if (isNumber(values[i$1])) {
-                    pointers[i$1].value(values[i$1]);
+            for (let i = 0; i < values.length; i++) {
+                if (isNumber(values[i])) {
+                    pointers[i].value(values[i]);
                 }
             }
         }
 
         this._setValueOptions(values);
-    };
+    }
 
-    Gauge.prototype._setValueOptions = function _setValueOptions (values) {
-        var pointers = [].concat(this.options.pointer);
-        var arrayValues = [].concat(values);
+    _setValueOptions(values) {
+        const pointers = [].concat(this.options.pointer);
+        const arrayValues = [].concat(values);
 
-        for (var i = 0; i < arrayValues.length; i++) {
+        for (let i = 0; i < arrayValues.length; i++) {
             pointers[i].value = arrayValues[i];
         }
-    };
+    }
 
-    Gauge.prototype.resize = function resize () {
+    resize() {
         this.noTransitionsRedraw();
-    };
+    }
 
-    Gauge.prototype.noTransitionsRedraw = function noTransitionsRedraw () {
-        var transitions = this.options.transitions;
+    noTransitionsRedraw() {
+        const transitions = this.options.transitions;
 
         this._toggleTransitions(false);
 
         this.redraw();
 
         this._toggleTransitions(transitions);
-    };
+    }
 
-    Gauge.prototype.redraw = function redraw () {
-        var size = this._surfaceSize();
-        var wrapper = new geo.Rect([ 0, 0 ], [ size.width, size.height ]);
+    redraw() {
+        const size = this._surfaceSize();
+        const wrapper = new geo.Rect([ 0, 0 ], [ size.width, size.height ]);
 
         this._initSurface();
 
@@ -116,53 +110,53 @@ var Gauge = (function (Class) {
 
         this._createModel();
 
-        var bbox = unpad(wrapper.bbox(), this._gaugeAreaMargin);
+        const bbox = unpad(wrapper.bbox(), this._gaugeAreaMargin);
         this.reflow(bbox);
-    };
+    }
 
-    Gauge.prototype.setOptions = function setOptions (options, theme) {
+    setOptions(options, theme) {
         this._originalOptions = deepExtend(this._originalOptions, options);
         this.options = deepExtend({}, this._originalOptions);
 
         this._initTheme(theme);
 
         this.redraw();
-    };
+    }
 
-    Gauge.prototype.setDirection = function setDirection (rtl) {
+    setDirection(rtl) {
         this.contextService.rtl = Boolean(rtl);
         if (this.surface && this.surface.type === 'svg') {
             this.surface.destroy();
             this.surface = null;
         }
-    };
+    }
 
-    Gauge.prototype.setIntlService = function setIntlService (intl) {
+    setIntlService(intl) {
         this.contextService.intl = intl;
-    };
+    }
 
-    Gauge.prototype._initTheme = function _initTheme (theme) {
-        var currentTheme = theme || this.theme || {};
+    _initTheme(theme) {
+        let currentTheme = theme || this.theme || {};
         this.theme = currentTheme;
 
         this.options = deepExtend({}, currentTheme, this.options);
-        var options = this.options;
-        var pointer = options.pointer;
+        const options = this.options;
+        const pointer = options.pointer;
 
         if (isArray(pointer)) {
-            var pointers = [];
-            for (var i = 0; i < pointer.length; i++) {
+            const pointers = [];
+            for (let i = 0; i < pointer.length; i++) {
                 pointers.push(deepExtend({}, currentTheme.pointer, pointer[i]));
             }
             options.pointer = pointers;
         }
-    };
+    }
 
-    Gauge.prototype._createGaugeArea = function _createGaugeArea () {
-        var options = this.options.gaugeArea;
-        var size = this.surface.size();
-        var border = options.border || {};
-        var areaGeometry = new geo.Rect([ 0, 0 ], [ size.width, size.height ]);
+    _createGaugeArea() {
+        const options = this.options.gaugeArea;
+        const size = this.surface.size();
+        const border = options.border || {};
+        let areaGeometry = new geo.Rect([ 0, 0 ], [ size.width, size.height ]);
 
         this._gaugeAreaMargin = options.margin || DEFAULT_MARGIN;
 
@@ -170,7 +164,7 @@ var Gauge = (function (Class) {
             areaGeometry = unpad(areaGeometry, border.width);
         }
 
-        var gaugeArea = Path.fromRect(areaGeometry, {
+        const gaugeArea = Path.fromRect(areaGeometry, {
             stroke: {
                 color: border.width ? border.color : "",
                 width: border.width,
@@ -185,14 +179,12 @@ var Gauge = (function (Class) {
         });
 
         return gaugeArea;
-    };
+    }
 
-    Gauge.prototype._initSurface = function _initSurface () {
-        var ref = this;
-        var options = ref.options;
-        var surface = ref.surface;
-        var element = this._surfaceElement();
-        var size = this._surfaceSize();
+    _initSurface() {
+        const { options, surface } = this;
+        const element = this._surfaceElement();
+        const size = this._surfaceSize();
 
         elementSize(element, size);
 
@@ -208,37 +200,37 @@ var Gauge = (function (Class) {
             this.surface.clear();
             this.surface.resize();
         }
-    };
+    }
 
-    Gauge.prototype._surfaceSize = function _surfaceSize () {
-        var options = this.options;
-        var size = this._getSize();
+    _surfaceSize() {
+        const options = this.options;
+        const size = this._getSize();
 
         if (options.gaugeArea) {
             deepExtend(size, options.gaugeArea);
         }
 
         return size;
-    };
+    }
 
-    Gauge.prototype._surfaceElement = function _surfaceElement () {
+    _surfaceElement() {
         if (!this.surfaceElement) {
             this.surfaceElement = document.createElement('div');
             this.element.appendChild(this.surfaceElement);
         }
 
         return this.surfaceElement;
-    };
+    }
 
-    Gauge.prototype.getSize = function getSize () {
+    getSize() {
         return this._getSize();
-    };
+    }
 
-    Gauge.prototype._getSize = function _getSize () {
-        var element = this.element;
-        var defaultSize = this._defaultSize();
-        var width = element.offsetWidth;
-        var height = element.offsetHeight;
+    _getSize() {
+        const element = this.element;
+        const defaultSize = this._defaultSize();
+        let width = element.offsetWidth;
+        let height = element.offsetHeight;
 
         if (!width) {
             width = defaultSize.width;
@@ -249,26 +241,22 @@ var Gauge = (function (Class) {
         }
 
         return { width: width, height: height };
-    };
+    }
 
-    Gauge.prototype._defaultSize = function _defaultSize () {
+    _defaultSize() {
         return {
             width: DEFAULT_WIDTH,
             height: DEFAULT_HEIGHT
         };
-    };
-
-    Gauge.prototype._toggleTransitions = function _toggleTransitions (value) {
-        var this$1 = this;
+    }
 
+    _toggleTransitions(value) {
         this.options.transitions = value;
-        for (var i = 0; i < this.pointers.length; i++) {
-            this$1.pointers[i].options.animation.transitions = value;
+        for (let i = 0; i < this.pointers.length; i++) {
+            this.pointers[i].options.animation.transitions = value;
         }
-    };
-
-    return Gauge;
-}(Class));
+    }
+}
 
 setDefaultOptions(Gauge, {
     plotArea: {},

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

@@ -2,22 +2,12 @@ import { geometry, drawing } from '@progress/kendo-drawing';
 import { interpolateValue, setDefaultOptions } from '../../common';
 import { ARROW_POINTER, LINEAR_SPEED, LINEAR } from '../constants';
 
-var ArrowLinearPointerAnimation = (function (superclass) {
-    function ArrowLinearPointerAnimation () {
-        superclass.apply(this, arguments);
-    }
-
-    if ( superclass ) ArrowLinearPointerAnimation.__proto__ = superclass;
-    ArrowLinearPointerAnimation.prototype = Object.create( superclass && superclass.prototype );
-    ArrowLinearPointerAnimation.prototype.constructor = ArrowLinearPointerAnimation;
+class ArrowLinearPointerAnimation extends drawing.Animation {
 
-    ArrowLinearPointerAnimation.prototype.setup = function setup () {
-        var options = this.options;
-        var margin = options.margin;
-        var from = options.from;
-        var to = options.to;
-        var vertical = options.vertical;
-        var axis = vertical ? "x1" : "y1";
+    setup() {
+        const options = this.options;
+        const { margin, from, to, vertical } = options;
+        const axis = vertical ? "x1" : "y1";
 
         if (options.mirror === vertical) {
             from[axis] -= margin; to[axis] -= margin;
@@ -25,23 +15,21 @@ var ArrowLinearPointerAnimation = (function (superclass) {
             from[axis] += margin; to[axis] += margin;
         }
 
-        var fromScale = this.fromScale = new geometry.Point(from.x1, from.y1);
-        var toScale = this.toScale = new geometry.Point(to.x1, to.y1);
+        const fromScale = this.fromScale = new geometry.Point(from.x1, from.y1);
+        const toScale = this.toScale = new geometry.Point(to.x1, to.y1);
 
         if (options.duration !== 0) {
             options.duration = Math.max((fromScale.distanceTo(toScale) / options.duration) * 1000, 1);
         }
-    };
+    }
 
-    ArrowLinearPointerAnimation.prototype.step = function step (pos) {
-        var translateX = interpolateValue(this.fromScale.x, this.toScale.x, pos);
-        var translateY = interpolateValue(this.fromScale.y, this.toScale.y, pos);
+    step(pos) {
+        const translateX = interpolateValue(this.fromScale.x, this.toScale.x, pos);
+        const translateY = interpolateValue(this.fromScale.y, this.toScale.y, pos);
 
         this.element.transform(geometry.transform().translate(translateX, translateY));
-    };
-
-    return ArrowLinearPointerAnimation;
-}(drawing.Animation));
+    }
+}
 
 setDefaultOptions(ArrowLinearPointerAnimation, {
     easing: LINEAR,

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

@@ -4,29 +4,23 @@ import { ARROW_POINTER } from '../constants';
 import LinearPointer from './linear-pointer';
 import ArrowLinearPointerAnimation from './arrow-linear-pointer-animation';
 
-var Point = geo.Point;
-var Path = drawing.Path;
+const Point = geo.Point;
+const Path = drawing.Path;
 
-var ArrowLinearPointer = (function (LinearPointer) {
-    function ArrowLinearPointer(scale, options) {
-        LinearPointer.call(this, scale, options);
+class ArrowLinearPointer extends LinearPointer {
+    constructor(scale, options) {
+        super(scale, options);
 
         if (!defined(this.options.size)) {
             this.options.size = this.scale.options.majorTicks.size * 0.6;
         }
     }
 
-    if ( LinearPointer ) ArrowLinearPointer.__proto__ = LinearPointer;
-    ArrowLinearPointer.prototype = Object.create( LinearPointer && LinearPointer.prototype );
-    ArrowLinearPointer.prototype.constructor = ArrowLinearPointer;
-
-    ArrowLinearPointer.prototype.pointerShape = function pointerShape () {
-        var ref = this;
-        var scale = ref.scale;
-        var size = ref.options.size;
-        var halfSize = size / 2;
-        var sign = (scale.options.mirror ? -1 : 1);
-        var shape;
+    pointerShape() {
+        const { scale, options: { size } } = this;
+        const halfSize = size / 2;
+        const sign = (scale.options.mirror ? -1 : 1);
+        let shape;
 
         if (scale.options.vertical) {
             shape = [
@@ -39,13 +33,11 @@ var ArrowLinearPointer = (function (LinearPointer) {
         }
 
         return shape;
-    };
+    }
 
-    ArrowLinearPointer.prototype.repaint = function repaint () {
-        var ref = this;
-        var scale = ref.scale;
-        var options = ref.options;
-        var animation = new ArrowLinearPointerAnimation(this.elements, deepExtend(options.animation, {
+    repaint() {
+        const { scale, options } = this;
+        const animation = new ArrowLinearPointerAnimation(this.elements, deepExtend(options.animation, {
             vertical: scale.options.vertical,
             mirror: scale.options.mirror,
             margin: this._margin(options.margin),
@@ -59,31 +51,27 @@ var ArrowLinearPointer = (function (LinearPointer) {
 
         animation.setup();
         animation.play();
-    };
+    }
 
-    ArrowLinearPointer.prototype.render = function render () {
-        var ref = this;
-        var scale = ref.scale;
-        var options = ref.options;
-        var elementOptions = this.getElementOptions();
-        var shape = this.pointerShape(options.value);
+    render() {
+        const { scale, options } = this;
+        const elementOptions = this.getElementOptions();
+        const shape = this.pointerShape(options.value);
 
         options.animation.type = ARROW_POINTER;
 
-        var elements = new Path({
+        const elements = new Path({
             stroke: elementOptions.stroke,
             fill: elementOptions.fill
         }).moveTo(shape[0]).lineTo(shape[1]).lineTo(shape[2]).close();
 
-        var slot = scale.getSlot(options.value);
+        const slot = scale.getSlot(options.value);
         elements.transform(geo.transform().translate(slot.x1, slot.y1));
 
         this.elements = elements;
 
         return elements;
-    };
-
-    return ArrowLinearPointer;
-}(LinearPointer));
+    }
+}
 
 export default ArrowLinearPointer;

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

@@ -3,43 +3,34 @@ import { interpolateValue, setDefaultOptions } from '../../common';
 import { X, Y } from '../../common/constants';
 import { BAR_POINTER, LINEAR_SPEED, LINEAR } from '../constants';
 
-var BarLinearPointerAnimation = (function (superclass) {
-    function BarLinearPointerAnimation () {
-        superclass.apply(this, arguments);
-    }
-
-    if ( superclass ) BarLinearPointerAnimation.__proto__ = superclass;
-    BarLinearPointerAnimation.prototype = Object.create( superclass && superclass.prototype );
-    BarLinearPointerAnimation.prototype.constructor = BarLinearPointerAnimation;
+class BarLinearPointerAnimation extends drawing.Animation {
 
-    BarLinearPointerAnimation.prototype.setup = function setup () {
-        var options = this.options;
-        var axis = this.axis = options.vertical ? Y : X;
-        var to = this.to = options.newPoints[0][axis];
-        var from = this.from = options.oldPoints[0][axis];
+    setup() {
+        const options = this.options;
+        const axis = this.axis = options.vertical ? Y : X;
+        const to = this.to = options.newPoints[0][axis];
+        const from = this.from = options.oldPoints[0][axis];
 
         if (options.duration !== 0) {
             options.duration = Math.max((Math.abs(to - from) / options.speed) * 1000, 1);
         }
 
         this._set(from);
-    };
+    }
 
-    BarLinearPointerAnimation.prototype.step = function step (pos) {
-        var value = interpolateValue(this.from, this.to, pos);
+    step(pos) {
+        const value = interpolateValue(this.from, this.to, pos);
         this._set(value);
-    };
+    }
 
-    BarLinearPointerAnimation.prototype._set = function _set (value) {
-        var setter = "set" + this.axis.toUpperCase();
-        var points = this.options.newPoints;
+    _set(value) {
+        const setter = "set" + this.axis.toUpperCase();
+        const points = this.options.newPoints;
 
         points[0][setter](value);
         points[1][setter](value);
-    };
-
-    return BarLinearPointerAnimation;
-}(drawing.Animation));
+    }
+}
 
 setDefaultOptions(BarLinearPointerAnimation, {
     easing: LINEAR,