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

package/dist/es/chart/radar-area-chart/radar-area-chart.js

@@ -4,21 +4,13 @@ import RadarAreaSegment from './radar-area-segment';
 
 import { SMOOTH, ZERO } from '../constants';
 
-var RadarAreaChart = (function (RadarLineChart) {
-    function RadarAreaChart () {
-        RadarLineChart.apply(this, arguments);
-    }
-
-    if ( RadarLineChart ) RadarAreaChart.__proto__ = RadarLineChart;
-    RadarAreaChart.prototype = Object.create( RadarLineChart && RadarLineChart.prototype );
-    RadarAreaChart.prototype.constructor = RadarAreaChart;
-
-    RadarAreaChart.prototype.createSegment = function createSegment (linePoints, currentSeries, seriesIx, prevSegment) {
-        var isStacked = this.options.isStacked;
-        var style = (currentSeries.line || {}).style;
-        var previousSegment;
-        var stackPoints;
-        var segment;
+class RadarAreaChart extends RadarLineChart {
+    createSegment(linePoints, currentSeries, seriesIx, prevSegment) {
+        const isStacked = this.options.isStacked;
+        const style = (currentSeries.line || {}).style;
+        let previousSegment;
+        let stackPoints;
+        let segment;
 
         if (isStacked && seriesIx > 0 && prevSegment) {
             stackPoints = prevSegment.linePoints.slice(0);
@@ -34,13 +26,11 @@ var RadarAreaChart = (function (RadarLineChart) {
         }
 
         return segment;
-    };
+    }
 
-    RadarAreaChart.prototype.seriesMissingValues = function seriesMissingValues (series) {
+    seriesMissingValues(series) {
         return series.missingValues || ZERO;
-    };
-
-    return RadarAreaChart;
-}(RadarLineChart));
+    }
+}
 
 export default RadarAreaChart;

package/dist/es/chart/radar-area-chart/radar-area-segment.js

@@ -1,17 +1,7 @@
 import AreaSegment from '../area-chart/area-segment';
 
-var RadarAreaSegment = (function (AreaSegment) {
-    function RadarAreaSegment () {
-        AreaSegment.apply(this, arguments);
-    }
-
-    if ( AreaSegment ) RadarAreaSegment.__proto__ = AreaSegment;
-    RadarAreaSegment.prototype = Object.create( AreaSegment && AreaSegment.prototype );
-    RadarAreaSegment.prototype.constructor = RadarAreaSegment;
-
-    RadarAreaSegment.prototype.fillToAxes = function fillToAxes () {};
-
-    return RadarAreaSegment;
-}(AreaSegment));
+class RadarAreaSegment extends AreaSegment {
+    fillToAxes() {}
+}
 
 export default RadarAreaSegment;

package/dist/es/chart/radar-area-chart/spline-radar-area-segment.js

@@ -1,17 +1,7 @@
 import SplineAreaSegment from '../area-chart/spline-area-segment';
 
-var SplineRadarAreaSegment = (function (SplineAreaSegment) {
-    function SplineRadarAreaSegment () {
-        SplineAreaSegment.apply(this, arguments);
-    }
-
-    if ( SplineAreaSegment ) SplineRadarAreaSegment.__proto__ = SplineAreaSegment;
-    SplineRadarAreaSegment.prototype = Object.create( SplineAreaSegment && SplineAreaSegment.prototype );
-    SplineRadarAreaSegment.prototype.constructor = SplineRadarAreaSegment;
-
-    SplineRadarAreaSegment.prototype.fillToAxes = function fillToAxes () {};
-
-    return SplineRadarAreaSegment;
-}(SplineAreaSegment));
+class SplineRadarAreaSegment extends SplineAreaSegment {
+    fillToAxes() {}
+}
 
 export default SplineRadarAreaSegment;

package/dist/es/chart/radar-bar-chart/radar-bar-chart.js

@@ -6,53 +6,43 @@ import CategoricalChart from '../categorical-chart';
 
 import { setDefaultOptions } from '../../common';
 
-var RadarBarChart = (function (BarChart) {
-    function RadarBarChart () {
-        BarChart.apply(this, arguments);
-    }
-
-    if ( BarChart ) RadarBarChart.__proto__ = BarChart;
-    RadarBarChart.prototype = Object.create( BarChart && BarChart.prototype );
-    RadarBarChart.prototype.constructor = RadarBarChart;
-
-    RadarBarChart.prototype.pointType = function pointType () {
+class RadarBarChart extends BarChart {
+    pointType() {
         return RadarSegment;
-    };
+    }
 
-    RadarBarChart.prototype.clusterType = function clusterType () {
+    clusterType() {
         return RadarClusterLayout;
-    };
+    }
 
-    RadarBarChart.prototype.stackType = function stackType () {
+    stackType() {
         return RadarStackLayout;
-    };
+    }
 
-    RadarBarChart.prototype.categorySlot = function categorySlot (categoryAxis, categoryIx) {
+    categorySlot(categoryAxis, categoryIx) {
         return categoryAxis.getSlot(categoryIx);
-    };
+    }
 
-    RadarBarChart.prototype.pointSlot = function pointSlot (categorySlot, valueSlot) {
-        var slot = categorySlot.clone();
-        var y = categorySlot.center.y;
+    pointSlot(categorySlot, valueSlot) {
+        const slot = categorySlot.clone();
+        const y = categorySlot.center.y;
 
         slot.radius = y - valueSlot.y1;
         slot.innerRadius = y - valueSlot.y2;
 
         return slot;
-    };
+    }
 
-    RadarBarChart.prototype.reflowPoint = function reflowPoint (point, pointSlot) {
+    reflowPoint(point, pointSlot) {
         point.sector = pointSlot;
         point.reflow();
-    };
+    }
 
-    RadarBarChart.prototype.createAnimation = function createAnimation () {
+    createAnimation() {
         this.options.animation.center = this.box.toRect().center();
-        BarChart.prototype.createAnimation.call(this);
-    };
-
-    return RadarBarChart;
-}(BarChart));
+        super.createAnimation();
+    }
+}
 
 RadarBarChart.prototype.reflow = CategoricalChart.prototype.reflow;
 

package/dist/es/chart/radar-bar-chart/radar-segment.js

@@ -2,21 +2,15 @@ import DonutSegment from '../donut-chart/donut-segment';
 
 import { setDefaultOptions } from '../../common';
 
-var RadarSegment = (function (DonutSegment) {
-    function RadarSegment(value, options) {
-        DonutSegment.call(this, value, null, options);
+class RadarSegment extends DonutSegment {
+    constructor(value, options) {
+        super(value, null, options);
     }
 
-    if ( DonutSegment ) RadarSegment.__proto__ = DonutSegment;
-    RadarSegment.prototype = Object.create( DonutSegment && DonutSegment.prototype );
-    RadarSegment.prototype.constructor = RadarSegment;
-
-    RadarSegment.prototype.getIndex = function getIndex () {
+    getIndex() {
         return this.categoryIx;
-    };
-
-    return RadarSegment;
-}(DonutSegment));
+    }
+}
 
 setDefaultOptions(RadarSegment, {
     overlay: {

package/dist/es/chart/radar-line-chart/radar-line-chart.js

@@ -9,9 +9,9 @@ import { SMOOTH, INTERPOLATE } from '../constants';
 import { setDefaultOptions, last } from '../../common';
 
 function groupBySeriesIx(segments) {
-    var seriesSegments = [];
-    for (var idx = 0; idx < segments.length; idx++) {
-        var segment = segments[idx];
+    const seriesSegments = [];
+    for (let idx = 0; idx < segments.length; idx++) {
+        const segment = segments[idx];
         seriesSegments[segment.seriesIx] = seriesSegments[segment.seriesIx] || [];
         seriesSegments[segment.seriesIx].push(segment);
     }
@@ -19,47 +19,40 @@ function groupBySeriesIx(segments) {
     return seriesSegments;
 }
 
-var RadarLineChart = (function (LineChart) {
-    function RadarLineChart () {
-        LineChart.apply(this, arguments);
-    }
-
-    if ( LineChart ) RadarLineChart.__proto__ = LineChart;
-    RadarLineChart.prototype = Object.create( LineChart && LineChart.prototype );
-    RadarLineChart.prototype.constructor = RadarLineChart;
+class RadarLineChart extends LineChart {
 
-    RadarLineChart.prototype.pointSlot = function pointSlot (categorySlot, valueSlot) {
-        var valueRadius = categorySlot.center.y - valueSlot.y1;
-        var slot = Point.onCircle(categorySlot.center, categorySlot.middle(), valueRadius);
+    pointSlot(categorySlot, valueSlot) {
+        const valueRadius = categorySlot.center.y - valueSlot.y1;
+        const slot = Point.onCircle(categorySlot.center, categorySlot.middle(), valueRadius);
 
         return new Box(slot.x, slot.y, slot.x, slot.y);
-    };
+    }
 
-    RadarLineChart.prototype.renderSegments = function renderSegments () {
-        LineChart.prototype.renderSegments.call(this);
+    renderSegments() {
+        super.renderSegments();
 
         if (this._segments && this._segments.length > 1) {
-            var seriesSegments = groupBySeriesIx(this._segments);
+            const seriesSegments = groupBySeriesIx(this._segments);
 
-            for (var idx = 0; idx < seriesSegments.length; idx++) {
-                var segments = seriesSegments[idx];
+            for (let idx = 0; idx < seriesSegments.length; idx++) {
+                const segments = seriesSegments[idx];
                 if (segments && segments.length > 1) {
-                    var firstPoint = segments[0].linePoints[0];
-                    var lastSegment = last(segments);
-                    var lastPoint = last(lastSegment.linePoints);
-                    var isFirstDataPoint = firstPoint.categoryIx === 0;
-                    var isLastDataPoint = lastPoint.categoryIx === lastPoint.categoriesCount - 1;
+                    const firstPoint = segments[0].linePoints[0];
+                    const lastSegment = last(segments);
+                    const lastPoint = last(lastSegment.linePoints);
+                    const isFirstDataPoint = firstPoint.categoryIx === 0;
+                    const isLastDataPoint = lastPoint.categoryIx === lastPoint.categoriesCount - 1;
                     if (isFirstDataPoint && isLastDataPoint) {
                         last(segments).linePoints.push(firstPoint);
                     }
                 }
             }
         }
-    };
+    }
 
-    RadarLineChart.prototype.createSegment = function createSegment (linePoints, currentSeries, seriesIx) {
-        var style = currentSeries.style;
-        var pointType;
+    createSegment(linePoints, currentSeries, seriesIx) {
+        const style = currentSeries.style;
+        let pointType;
 
         if (style === SMOOTH) {
             pointType = SplineSegment;
@@ -67,18 +60,16 @@ var RadarLineChart = (function (LineChart) {
             pointType = LineSegment;
         }
 
-        var segment = new pointType(linePoints, currentSeries, seriesIx);
-        var missingValues = this.seriesMissingValues(currentSeries);
+        const segment = new pointType(linePoints, currentSeries, seriesIx);
+        const missingValues = this.seriesMissingValues(currentSeries);
 
         if (linePoints.length === currentSeries.data.length || missingValues === INTERPOLATE) {
             segment.options.closed = true;
         }
 
         return segment;
-    };
-
-    return RadarLineChart;
-}(LineChart));
+    }
+}
 
 setDefaultOptions(RadarLineChart, {
     clip: false,

package/dist/es/chart/range-area-chart/range-area-chart.js

@@ -13,29 +13,21 @@ import { isNumber } from '../../common';
 import { deepExtend, isFunction } from '../../common';
 import { hasValue } from '../utils';
 
-var RangeAreaChart = (function (CategoricalChart) {
-    function RangeAreaChart () {
-        CategoricalChart.apply(this, arguments);
-    }
-
-    if ( CategoricalChart ) RangeAreaChart.__proto__ = CategoricalChart;
-    RangeAreaChart.prototype = Object.create( CategoricalChart && CategoricalChart.prototype );
-    RangeAreaChart.prototype.constructor = RangeAreaChart;
+class RangeAreaChart extends CategoricalChart {
 
-    RangeAreaChart.prototype.render = function render () {
-        CategoricalChart.prototype.render.call(this);
+    render() {
+        super.render();
 
         this.renderSegments();
-    };
+    }
 
-    RangeAreaChart.prototype.pointType = function pointType () {
+    pointType() {
         return RangeAreaPoint;
-    };
+    }
 
-    RangeAreaChart.prototype.createPoint = function createPoint (data, fields) {
-        var series = fields.series;
-        var seriesIx = fields.seriesIx;
-        var value = data.valueFields;
+    createPoint(data, fields) {
+        const { series, seriesIx } = fields;
+        let value = data.valueFields;
 
         if (!hasValue(value.from) && !hasValue(value.to)) {
             if (this.seriesMissingValues(series) === ZERO) {
@@ -48,25 +40,25 @@ var RangeAreaChart = (function (CategoricalChart) {
             }
         }
 
-        var pointOptions = this.pointOptions(series, seriesIx);
+        let pointOptions = this.pointOptions(series, seriesIx);
         pointOptions = this.evalPointOptions(pointOptions, value, fields);
 
-        var color = data.fields.color || series.color;
+        let color = data.fields.color || series.color;
         if (isFunction(series.color)) {
             color = pointOptions.color;
         }
 
-        var point = new RangeAreaPoint(value, pointOptions);
+        const point = new RangeAreaPoint(value, pointOptions);
         point.color = color;
 
         this.append(point);
 
         return point;
-    };
+    }
 
-    RangeAreaChart.prototype.createSegment = function createSegment (linePoints, currentSeries, seriesIx) {
-        var style = (currentSeries.line || {}).style;
-        var segmentType;
+    createSegment(linePoints, currentSeries, seriesIx) {
+        const style = (currentSeries.line || {}).style;
+        let segmentType;
         if (style === "smooth") {
             segmentType = SplineRangeAreaSegment;
         } else if (style === "step") {
@@ -76,31 +68,30 @@ var RangeAreaChart = (function (CategoricalChart) {
         }
 
         return new segmentType(linePoints, currentSeries, seriesIx);
-    };
+    }
 
-    RangeAreaChart.prototype.plotRange = function plotRange (point, startValue) {
+    plotRange(point, startValue) {
         if (!point) {
             return [ startValue, startValue ];
         }
 
         return [ point.value.from, point.value.to ];
-    };
+    }
 
-    RangeAreaChart.prototype.valueSlot = function valueSlot (valueAxis, plotRange) {
-        var fromSlot = valueAxis.getSlot(plotRange[0], plotRange[0], !this.options.clip);
-        var toSlot = valueAxis.getSlot(plotRange[1], plotRange[1], !this.options.clip);
+    valueSlot(valueAxis, plotRange) {
+        const fromSlot = valueAxis.getSlot(plotRange[0], plotRange[0], !this.options.clip);
+        const toSlot = valueAxis.getSlot(plotRange[1], plotRange[1], !this.options.clip);
         if (fromSlot && toSlot) {
             return {
                 from: fromSlot,
                 to: toSlot
             };
         }
-    };
+    }
 
-    RangeAreaChart.prototype.pointSlot = function pointSlot (categorySlot, valueSlot) {
-        var from = valueSlot.from;
-        var to = valueSlot.to;
-        var fromSlot, toSlot;
+    pointSlot(categorySlot, valueSlot) {
+        const { from, to } = valueSlot;
+        let fromSlot, toSlot;
 
         if (this.options.invertAxes) {
             fromSlot = new Box(from.x1, categorySlot.y1, from.x2, categorySlot.y2);
@@ -114,10 +105,10 @@ var RangeAreaChart = (function (CategoricalChart) {
             from: fromSlot,
             to: toSlot
         };
-    };
+    }
 
-    RangeAreaChart.prototype.addValue = function addValue (data, fields) {
-        var valueFields = data.valueFields;
+    addValue(data, fields) {
+        const valueFields = data.valueFields;
         if (!isNumber(valueFields.from)) {
             valueFields.from = valueFields.to;
         }
@@ -126,32 +117,31 @@ var RangeAreaChart = (function (CategoricalChart) {
             valueFields.to = valueFields.from;
         }
 
-        CategoricalChart.prototype.addValue.call(this, data, fields);
-    };
+        super.addValue(data, fields);
+    }
 
-    RangeAreaChart.prototype.updateRange = function updateRange (value, fields) {
+    updateRange(value, fields) {
         if (value !== null && isNumber(value.from) && isNumber(value.to)) {
-            var axisName = fields.series.axis;
-            var axisRange = this.valueAxisRanges[axisName] = this.valueAxisRanges[axisName] || { min: MAX_VALUE, max: MIN_VALUE };
-            var from = value.from;
-            var to = value.to;
+            const axisName = fields.series.axis;
+            const axisRange = this.valueAxisRanges[axisName] = this.valueAxisRanges[axisName] || { min: MAX_VALUE, max: MIN_VALUE };
+            const { from, to } = value;
 
             axisRange.min = Math.min(axisRange.min, from, to);
             axisRange.max = Math.max(axisRange.max, from, to);
         }
-    };
+    }
 
-    RangeAreaChart.prototype.formatPointValue = function formatPointValue (point, format) {
-        var value = point.value;
+    formatPointValue(point, format) {
+        const value = point.value;
 
         return this.chartService.format.auto(format, value.from, value.to);
-    };
+    }
 
-    RangeAreaChart.prototype.animationPoints = function animationPoints () {
-        var points = this.points;
-        var result = [];
-        for (var idx = 0; idx < points.length; idx++) {
-            var point = points[idx];
+    animationPoints() {
+        const points = this.points;
+        const result = [];
+        for (let idx = 0; idx < points.length; idx++) {
+            const point = points[idx];
             if (point) {
                 result.push((point.fromPoint || {}).marker);
                 result.push((point.toPoint || {}).marker);
@@ -159,10 +149,8 @@ var RangeAreaChart = (function (CategoricalChart) {
         }
 
         return result.concat(this._segments);
-    };
-
-    return RangeAreaChart;
-}(CategoricalChart));
+    }
+}
 
 deepExtend(RangeAreaChart.prototype, LineChartMixin, ClipAnimationMixin);