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

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

@@ -6,15 +6,12 @@ import { DEFAULT_LINE_WIDTH, INSIDE } from '../constants';
 import { autoMajorUnit } from '../../core';
 import { buildLabelElement, getRange } from '../utils';
 
-var Path = drawing.Path;
-var Group = drawing.Group;
-var Point = geo.Point;
+const { Path, Group } = drawing;
+const Point = geo.Point;
 
 function renderAxisTick(tickRenderOptions, tickOptions) {
-    var position = tickRenderOptions.position;
-    var tickX = tickRenderOptions.tickX;
-    var tickY = tickRenderOptions.tickY;
-    var start, end;
+    const { position, tickX, tickY } = tickRenderOptions;
+    let start, end;
 
     if (tickRenderOptions.vertical) {
         start = new Point(tickX, position);
@@ -24,7 +21,7 @@ function renderAxisTick(tickRenderOptions, tickOptions) {
         end = new Point(position, tickY + tickOptions.size);
     }
 
-    var tickPath = new Path({
+    const tickPath = new Path({
         stroke: {
             color: tickOptions.color,
             width: tickOptions.width
@@ -35,12 +32,11 @@ function renderAxisTick(tickRenderOptions, tickOptions) {
 }
 
 function renderTicks(tickGroup, tickPositions, tickRenderOptions, tickOptions) {
-    var count = tickPositions.length;
+    const count = tickPositions.length;
 
     if (tickOptions.visible) {
-        var mirror = tickRenderOptions.mirror;
-        var lineBox = tickRenderOptions.lineBox;
-        for (var i = tickOptions.skip; i < count; i += tickOptions.step) {
+        const { mirror, lineBox } = tickRenderOptions;
+        for (let i = tickOptions.skip; i < count; i += tickOptions.step) {
             if (i % tickOptions.skipUnit === 0) {
                 continue;
             }
@@ -54,65 +50,56 @@ function renderTicks(tickGroup, tickPositions, tickRenderOptions, tickOptions) {
     }
 }
 
-var LinearScale = (function (NumericAxis) {
-    function LinearScale(options, service) {
-        var scaleOptions = options || {};
+class LinearScale extends NumericAxis {
+    constructor(options, service) {
+        let scaleOptions = options || {};
         if (!defined(scaleOptions.reverse) && scaleOptions.vertical === false && (service || {}).rtl) {
             scaleOptions = Object.assign({}, scaleOptions, {
                 reverse: true
             });
         }
 
-        NumericAxis.call(this, 0, 1, scaleOptions, service);
+        super(0, 1, scaleOptions, service);
 
         this.options.minorUnit = this.options.minorUnit || this.options.majorUnit / 10;
     }
 
-    if ( NumericAxis ) LinearScale.__proto__ = NumericAxis;
-    LinearScale.prototype = Object.create( NumericAxis && NumericAxis.prototype );
-    LinearScale.prototype.constructor = LinearScale;
-
-    LinearScale.prototype.initUserOptions = function initUserOptions (options) {
-        var scaleOptions = deepExtend({}, this.options, options);
+    initUserOptions(options) {
+        let scaleOptions = deepExtend({}, this.options, options);
         scaleOptions = deepExtend({}, scaleOptions , { labels: { mirror: scaleOptions.mirror } });
         scaleOptions.majorUnit = scaleOptions.majorUnit || autoMajorUnit(scaleOptions.min, scaleOptions.max);
 
         return scaleOptions;
-    };
+    }
 
-    LinearScale.prototype.initFields = function initFields () {
-    };
+    initFields() {
+    }
 
-    LinearScale.prototype.render = function render () {
-        var elements = this.elements = new Group();
-        var labels = this.renderLabels();
-        var scaleLine = this.renderLine();
-        var scaleTicks = this.renderTicks();
-        var ranges = this.renderRanges();
+    render() {
+        const elements = this.elements = new Group();
+        const labels = this.renderLabels();
+        const scaleLine = this.renderLine();
+        const scaleTicks = this.renderTicks();
+        const ranges = this.renderRanges();
 
         elements.append(scaleLine, labels, scaleTicks, ranges);
 
         return elements;
-    };
-
-    LinearScale.prototype.renderRanges = function renderRanges () {
-        var this$1 = this;
-
-        var options = this.options;
-        var min = options.min;
-        var max = options.max;
-        var vertical = options.vertical;
-        var mirror = options.labels.mirror;
-        var ranges = options.ranges || [];
-        var elements = new Group();
-        var count = ranges.length;
-        var rangeSize = options.rangeSize || options.minorTicks.size / 2;
-
-        for (var i = 0; i < count; i++) {
-            var range = getRange(ranges[i], min, max);
-            var slot = this$1.getSlot(range.from, range.to);
-            var slotX = vertical ? this$1.lineBox() : slot;
-            var slotY = vertical ? slot : this$1.lineBox();
+    }
+
+    renderRanges() {
+        const options = this.options;
+        const { min, max, vertical, labels: { mirror } } = options;
+        const ranges = options.ranges || [];
+        const elements = new Group();
+        const count = ranges.length;
+        const rangeSize = options.rangeSize || options.minorTicks.size / 2;
+
+        for (let i = 0; i < count; i++) {
+            const range = getRange(ranges[i], min, max);
+            const slot = this.getSlot(range.from, range.to);
+            const slotX = vertical ? this.lineBox() : slot;
+            const slotY = vertical ? slot : this.lineBox();
             if (vertical) {
                 slotX.x1 -= rangeSize * (mirror ? -1 : 1);
             } else {
@@ -126,28 +113,26 @@ var LinearScale = (function (NumericAxis) {
         }
 
         return elements;
-    };
+    }
 
-    LinearScale.prototype.renderLabels = function renderLabels () {
-        var ref = this;
-        var labels = ref.labels;
-        var options = ref.options;
-        var elements = new Group();
+    renderLabels() {
+        const { labels, options } = this;
+        const elements = new Group();
 
-        for (var i = 0; i < labels.length; i++) {
+        for (let i = 0; i < labels.length; i++) {
             elements.append(buildLabelElement(labels[i], options.labels));
         }
 
         return elements;
-    };
+    }
 
-    LinearScale.prototype.renderLine = function renderLine () {
-        var line = this.options.line;
-        var lineBox = this.lineBox();
-        var elements = new Group();
+    renderLine() {
+        const line = this.options.line;
+        const lineBox = this.lineBox();
+        const elements = new Group();
 
         if (line.width > 0 && line.visible) {
-            var linePath = new Path({
+            const linePath = new Path({
                 stroke: {
                     color: line.color,
                     dashType: line.dashType,
@@ -160,13 +145,13 @@ var LinearScale = (function (NumericAxis) {
         }
 
         return elements;
-    };
+    }
 
-    LinearScale.prototype.renderTicks = function renderTicks$1 () {
-        var ticks = new Group();
-        var options = this.options;
-        var majorUnit = options.majorTicks.visible ? options.majorUnit : 0;
-        var tickRenderOptions = {
+    renderTicks() {
+        const ticks = new Group();
+        const options = this.options;
+        const majorUnit = options.majorTicks.visible ? options.majorUnit : 0;
+        const tickRenderOptions = {
             vertical: options.vertical,
             mirror: options.labels.mirror,
             lineBox: this.lineBox()
@@ -178,10 +163,8 @@ var LinearScale = (function (NumericAxis) {
         }, options.minorTicks));
 
         return ticks;
-    };
-
-    return LinearScale;
-}(NumericAxis));
+    }
+}
 
 setDefaultOptions(LinearScale, {
     min: 0,

package/dist/es/gauges/pointer.js

@@ -1,14 +1,12 @@
 import { Class, setDefaultOptions, defined, deepExtend, limitValue } from '../common';
 import { BLACK } from '../common/constants';
 
-var Pointer = (function (Class) {
-    function Pointer(scale, userOptions) {
-        Class.call(this);
+class Pointer extends Class {
+    constructor(scale, userOptions) {
+        super();
 
-        var ref = scale.options;
-        var min = ref.min;
-        var max = ref.max;
-        var options = this.options = deepExtend({}, this.options, userOptions);
+        const { min, max } = scale.options;
+        const options = this.options = deepExtend({}, this.options, userOptions);
 
         options.fill = options.color;
 
@@ -21,21 +19,15 @@ var Pointer = (function (Class) {
         }
     }
 
-    if ( Class ) Pointer.__proto__ = Class;
-    Pointer.prototype = Object.create( Class && Class.prototype );
-    Pointer.prototype.constructor = Pointer;
-
-    Pointer.prototype.value = function value (newValue) {
-        var options = this.options;
-        var value = options.value;
+    value(newValue) {
+        const options = this.options;
+        const value = options.value;
 
         if (arguments.length === 0) {
             return value;
         }
 
-        var ref = this.scale.options;
-        var min = ref.min;
-        var max = ref.max;
+        const { min, max } = this.scale.options;
 
         options._oldValue = defined(options._oldValue) ? options.value : min;
         options.value = limitValue(newValue, min, max);
@@ -43,10 +35,8 @@ var Pointer = (function (Class) {
         if (this.elements) {
             this.repaint();
         }
-    };
-
-    return Pointer;
-}(Class));
+    }
+}
 
 setDefaultOptions(Pointer, {
     color: BLACK

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

@@ -5,68 +5,55 @@ import Gauge from '../gauge';
 import RadialScale from './radial-scale';
 import RadialPointer from './radial-pointer';
 
-var Group = drawing.Group;
+const Group = drawing.Group;
 
-var RadialGauge = (function (Gauge) {
-    function RadialGauge () {
-        Gauge.apply(this, arguments);
-    }
-
-    if ( Gauge ) RadialGauge.__proto__ = Gauge;
-    RadialGauge.prototype = Object.create( Gauge && Gauge.prototype );
-    RadialGauge.prototype.constructor = RadialGauge;
-
-    RadialGauge.prototype.reflow = function reflow (bbox) {
-        var this$1 = this;
+class RadialGauge extends Gauge {
 
-        var pointers = this.pointers;
+    reflow(bbox) {
+        const pointers = this.pointers;
         this.scale.reflow(bbox);
         this._initialPlotArea = this.scale.bbox;
 
-        for (var i = 0; i < pointers.length; i++) {
-            pointers[i].reflow(this$1.scale.arc);
-            this$1._initialPlotArea = geo.Rect.union(this$1._initialPlotArea, pointers[i].bbox);
+        for (let i = 0; i < pointers.length; i++) {
+            pointers[i].reflow(this.scale.arc);
+            this._initialPlotArea = geo.Rect.union(this._initialPlotArea, pointers[i].bbox);
         }
 
         this.fitScale(bbox);
         this.alignScale(bbox);
         this._buildVisual(this.gaugeArea, pointers, this.scale);
         this._draw();
-    };
+    }
 
-    RadialGauge.prototype._buildVisual = function _buildVisual (gaugeArea, pointers, scale) {
-        var visuals = this._visuals = new Group();
+    _buildVisual(gaugeArea, pointers, scale) {
+        const visuals = this._visuals = new Group();
 
         visuals.append(gaugeArea);
         visuals.append(scale.ticks);
         visuals.append(scale.ranges);
         this._buildPointers(pointers);
         visuals.append(scale.labelElements);
-    };
-
-    RadialGauge.prototype._buildPointers = function _buildPointers (pointers) {
-        var this$1 = this;
+    }
 
-        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();
-            this$1._visuals.append(current.elements);
+            this._visuals.append(current.elements);
 
             current.value(current.options.value);
         }
-    };
-
-    RadialGauge.prototype.fitScale = function fitScale (bbox) {
-        var this$1 = this;
+    }
 
-        var arc = this.scale.arc;
-        var plotAreaBox = this._initialPlotArea;
-        var step = Math.abs(this.getDiff(plotAreaBox, bbox));
-        var min = round(step, COORD_PRECISION);
-        var max = round(-step, COORD_PRECISION);
-        var minDiff, midDiff, maxDiff, mid, oldDiff;
-        var staleFlag = 0;
-        var i = 0;
+    fitScale(bbox) {
+        const arc = this.scale.arc;
+        const plotAreaBox = this._initialPlotArea;
+        const step = Math.abs(this.getDiff(plotAreaBox, bbox));
+        let min = round(step, COORD_PRECISION);
+        let max = round(-step, COORD_PRECISION);
+        let minDiff, midDiff, maxDiff, mid, oldDiff;
+        let staleFlag = 0;
+        let i = 0;
 
         while (i++ < 100) {
             staleFlag = (oldDiff === maxDiff) ? (staleFlag + 1) : 0;
@@ -76,14 +63,14 @@ var RadialGauge = (function (Gauge) {
             }
 
             if (min !== mid) {
-                minDiff = this$1.getPlotBox(min, bbox, arc);
+                minDiff = this.getPlotBox(min, bbox, arc);
                 if (0 <= minDiff && minDiff <= 2) {
                     break;
                 }
             }
 
             if (max !== mid) {
-                maxDiff = this$1.getPlotBox(max, bbox, arc);
+                maxDiff = this.getPlotBox(max, bbox, arc);
                 if (0 <= maxDiff && maxDiff <= 2) {
                     break;
                 }
@@ -97,7 +84,7 @@ var RadialGauge = (function (Gauge) {
                 mid = round(((min + max) / 2) || 1, COORD_PRECISION);
             }
 
-            midDiff = this$1.getPlotBox(mid, bbox, arc);
+            midDiff = this.getPlotBox(mid, bbox, arc);
             if (0 <= midDiff && midDiff <= 2) {
                 break;
             }
@@ -112,15 +99,13 @@ var RadialGauge = (function (Gauge) {
                 minDiff = midDiff;
             }
         }
-    };
-
-    RadialGauge.prototype.getPlotBox = function getPlotBox (step, bbox, arc) {
-        var this$1 = this;
+    }
 
-        var scale = this.scale;
-        var pointers = this.pointers;
-        var radius = arc.getRadiusX();
-        var scaleArc = arc.clone();
+    getPlotBox(step, bbox, arc) {
+        const scale = this.scale;
+        const pointers = this.pointers;
+        const radius = arc.getRadiusX();
+        const scaleArc = arc.clone();
 
         scaleArc.setRadiusX(radius + step).setRadiusY(radius + step);
 
@@ -128,63 +113,55 @@ var RadialGauge = (function (Gauge) {
         scale.reflow(bbox);
         this.plotBbox = scale.bbox;
 
-        for (var i = 0; i < pointers.length; i++) {
+        for (let i = 0; i < pointers.length; i++) {
             pointers[i].reflow(scaleArc);
-            this$1.plotBbox = geo.Rect.union(this$1.plotBbox, pointers[i].bbox);
+            this.plotBbox = geo.Rect.union(this.plotBbox, pointers[i].bbox);
         }
 
         return this.getDiff(this.plotBbox, bbox);
-    };
+    }
 
-    RadialGauge.prototype.getDiff = function getDiff (plotBox, box) {
+    getDiff(plotBox, box) {
         return Math.min(box.width() - plotBox.width(), box.height() - plotBox.height());
-    };
-
-    RadialGauge.prototype.alignScale = function alignScale (bbox) {
-        var this$1 = this;
+    }
 
-        var plotBoxCenter = this.plotBbox.center();
-        var boxCenter = bbox.center();
-        var paddingX = plotBoxCenter.x - boxCenter.x;
-        var paddingY = plotBoxCenter.y - boxCenter.y;
-        var ref = this;
-        var scale = ref.scale;
-        var pointers = ref.pointers;
+    alignScale(bbox) {
+        const plotBoxCenter = this.plotBbox.center();
+        const boxCenter = bbox.center();
+        const paddingX = plotBoxCenter.x - boxCenter.x;
+        const paddingY = plotBoxCenter.y - boxCenter.y;
+        const { scale, pointers } = this;
 
         scale.arc.center.x -= paddingX;
         scale.arc.center.y -= paddingY;
 
         scale.reflow(bbox);
 
-        for (var i = 0; i < pointers.length; i++) {
+        for (let i = 0; i < pointers.length; i++) {
             pointers[i].reflow(scale.arc);
-            this$1.plotBbox = geo.Rect.union(scale.bbox, pointers[i].bbox);
+            this.plotBbox = geo.Rect.union(scale.bbox, pointers[i].bbox);
         }
-    };
-
-    RadialGauge.prototype._createModel = function _createModel () {
-        var this$1 = this;
+    }
 
-        var options = this.options;
-        var pointers = options.pointer;
-        var scale = this.scale = new RadialScale(options.scale, this.contextService);
+    _createModel() {
+        const options = this.options;
+        const pointers = options.pointer;
+        const scale = this.scale = new RadialScale(options.scale, this.contextService);
 
         this.pointers = [];
 
-        var pointersArr = isArray(pointers) ? pointers : [ pointers ];
-        for (var i = 0; i < pointersArr.length; i++) {
-            var current = new RadialPointer(scale, deepExtend({}, pointersArr[i], {
+        const pointersArr = isArray(pointers) ? pointers : [ pointers ];
+        for (let i = 0; i < pointersArr.length; i++) {
+            const current = new RadialPointer(scale, deepExtend({}, pointersArr[i], {
                 animation: {
                     transitions: options.transitions
                 }
             }));
 
-            this$1.pointers.push(current);
+            this.pointers.push(current);
         }
-    };
-
-    return RadialGauge;
-}(Gauge));
+    }
+}
 
 setDefaultOptions(RadialGauge, {
     transitions: true,

package/dist/es/gauges/radial/radial-pointer-animation.js

@@ -2,28 +2,22 @@ import { geometry, drawing } from '@progress/kendo-drawing';
 import { interpolateValue, setDefaultOptions } from '../../common';
 import { ANGULAR_SPEED, LINEAR, RADIAL_POINTER } from '../constants';
 
-var RadialPointerAnimation = (function (superclass) {
-    function RadialPointerAnimation(element, options) {
-        superclass.call(this, element, options);
+class RadialPointerAnimation extends drawing.Animation {
+    constructor(element, options) {
+        super(element, options);
 
-        var animationOptions = this.options;
+        const animationOptions = this.options;
 
         animationOptions.duration = Math.max((Math.abs(animationOptions.newAngle - animationOptions.oldAngle) / animationOptions.duration) * 1000, 1);
     }
 
-    if ( superclass ) RadialPointerAnimation.__proto__ = superclass;
-    RadialPointerAnimation.prototype = Object.create( superclass && superclass.prototype );
-    RadialPointerAnimation.prototype.constructor = RadialPointerAnimation;
-
-    RadialPointerAnimation.prototype.step = function step (pos) {
-        var options = this.options;
-        var angle = interpolateValue(options.oldAngle, options.newAngle, pos);
+    step(pos) {
+        const options = this.options;
+        const angle = interpolateValue(options.oldAngle, options.newAngle, pos);
 
         this.element.transform(geometry.transform().rotate(angle, options.center));
-    };
-
-    return RadialPointerAnimation;
-}(drawing.Animation));
+    }
+}
 
 setDefaultOptions(RadialPointerAnimation, {
     easing: LINEAR,

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

@@ -5,30 +5,19 @@ import { ANGULAR_SPEED, DEGREE, DEFAULT_LINE_WIDTH, RADIAL_POINTER } from '../co
 import Pointer from '../pointer';
 import RadialPointerAnimation from './radial-pointer-animation';
 
-var CAP_SIZE = 0.05;
-var Circle = drawing.Circle;
-var Group = drawing.Group;
-var Path = drawing.Path;
-
-var RadialPointer = (function (Pointer) {
-    function RadialPointer () {
-        Pointer.apply(this, arguments);
-    }
+const CAP_SIZE = 0.05;
+const { Circle, Group, Path } = drawing;
 
-    if ( Pointer ) RadialPointer.__proto__ = Pointer;
-    RadialPointer.prototype = Object.create( Pointer && Pointer.prototype );
-    RadialPointer.prototype.constructor = RadialPointer;
+class RadialPointer extends Pointer {
 
-    RadialPointer.prototype.setAngle = function setAngle (angle) {
+    setAngle(angle) {
         this.elements.transform(geo.transform().rotate(angle, this.center));
-    };
+    }
 
-    RadialPointer.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 (options.animation.transitions === false) {
             this.setAngle(newAngle);
@@ -38,13 +27,11 @@ var RadialPointer = (function (Pointer) {
                 newAngle: newAngle
             })).play();
         }
-    };
+    }
 
-    RadialPointer.prototype.render = function render () {
-        var ref = this;
-        var scale = ref.scale;
-        var options = ref.options;
-        var elements = new Group();
+    render() {
+        const { scale, options } = this;
+        const elements = new Group();
 
         if (options.animation !== false) {
             deepExtend(options.animation, {
@@ -60,24 +47,24 @@ var RadialPointer = (function (Pointer) {
         this.setAngle(DEGREE);
 
         return elements;
-    };
+    }
 
-    RadialPointer.prototype.reflow = function reflow (arc) {
-        var center = this.center = arc.center;
-        var length = limitValue(this.options.length || 1, 0.1, 1.5);
-        var radius = this.radius = arc.getRadiusX() * length;
-        var capSize = this.capSize = Math.round(radius * this.options.cap.size);
+    reflow(arc) {
+        const center = this.center = arc.center;
+        const length = limitValue(this.options.length || 1, 0.1, 1.5);
+        const radius = this.radius = arc.getRadiusX() * length;
+        const capSize = this.capSize = Math.round(radius * this.options.cap.size);
 
         this.bbox = geo.Rect.fromPoints(new geo.Point(center.x - capSize, center.y - capSize),
             new geo.Point(center.x + capSize, center.y + capSize));
-    };
+    }
 
-    RadialPointer.prototype._renderNeedle = function _renderNeedle () {
-        var minorTickSize = this.scale.options.minorTicks.size;
-        var center = this.center;
-        var needleColor = this.options.color;
+    _renderNeedle() {
+        const minorTickSize = this.scale.options.minorTicks.size;
+        const center = this.center;
+        const needleColor = this.options.color;
 
-        var needlePath = new Path({
+        const needlePath = new Path({
             fill: { color: needleColor },
             stroke: { color: needleColor, width: DEFAULT_LINE_WIDTH }
         });
@@ -88,23 +75,21 @@ var RadialPointer = (function (Pointer) {
             .close();
 
         return needlePath;
-    };
+    }
 
-    RadialPointer.prototype._renderCap = function _renderCap () {
-        var options = this.options;
-        var capColor = options.cap.color || options.color;
-        var circle = new geo.Circle(this.center, this.capSize);
+    _renderCap() {
+        const options = this.options;
+        const capColor = options.cap.color || options.color;
+        const circle = new geo.Circle(this.center, this.capSize);
 
-        var cap = new Circle(circle, {
+        const cap = new Circle(circle, {
             fill: { color: capColor },
             stroke: { color: capColor }
         });
 
         return cap;
-    };
-
-    return RadialPointer;
-}(Pointer));
+    }
+}
 
 setDefaultOptions(RadialPointer, {
     cap: {