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

package/dist/es/chart/plotarea/plotarea-factory.js

@@ -2,33 +2,30 @@ import filterSeriesByType from '../utils/filter-series-by-type';
 import { Class } from '../../common';
 import { TRENDLINE_SERIES } from '../constants';
 
-var PlotAreaFactory = (function (Class) {
-    function PlotAreaFactory() {
-        Class.call(this);
+class PlotAreaFactory extends Class {
+
+    constructor() {
+        super();
 
         this._registry = [];
     }
 
-    if ( Class ) PlotAreaFactory.__proto__ = Class;
-    PlotAreaFactory.prototype = Object.create( Class && Class.prototype );
-    PlotAreaFactory.prototype.constructor = PlotAreaFactory;
-
-    PlotAreaFactory.prototype.register = function register (type, seriesTypes) {
+    register(type, seriesTypes) {
         this._registry.push({
             type: type,
             seriesTypes: seriesTypes
         });
-    };
+    }
 
-    PlotAreaFactory.prototype.create = function create (srcSeries, options, chartService) {
-        var registry = this._registry;
-        var match = registry[0];
-        var series;
+    create(srcSeries, options, chartService) {
+        const registry = this._registry;
+        let match = registry[0];
+        let series;
 
-        for (var idx = 0; idx < registry.length; idx++) {
-            var entry = registry[idx];
+        for (let idx = 0; idx < registry.length; idx++) {
+            const entry = registry[idx];
             series = filterSeriesByType(srcSeries, entry.seriesTypes);
-            var trendlines = filterSeriesByType(srcSeries, TRENDLINE_SERIES);
+            const trendlines = filterSeriesByType(srcSeries, TRENDLINE_SERIES);
 
             if ((series.length - trendlines.length) > 0) {
                 match = entry;
@@ -37,10 +34,8 @@ var PlotAreaFactory = (function (Class) {
         }
 
         return new match.type(series, options, chartService);
-    };
-
-    return PlotAreaFactory;
-}(Class));
+    }
+}
 
 PlotAreaFactory.current = new PlotAreaFactory();
 

package/dist/es/chart/plotarea/polar-plotarea-base.js

@@ -7,50 +7,42 @@ import { LOGARITHMIC } from '../constants';
 import { getSpacing } from '../../common';
 import { Y, CENTER } from '../../common/constants';
 
-var DEFAULT_PADDING = 0.15;
+const DEFAULT_PADDING = 0.15;
 
-var PolarPlotAreaBase = (function (PlotAreaBase) {
-    function PolarPlotAreaBase () {
-        PlotAreaBase.apply(this, arguments);
-    }
-
-    if ( PlotAreaBase ) PolarPlotAreaBase.__proto__ = PlotAreaBase;
-    PolarPlotAreaBase.prototype = Object.create( PlotAreaBase && PlotAreaBase.prototype );
-    PolarPlotAreaBase.prototype.constructor = PolarPlotAreaBase;
-
-    PolarPlotAreaBase.prototype.initFields = function initFields () {
+class PolarPlotAreaBase extends PlotAreaBase {
+    initFields() {
         this.valueAxisRangeTracker = new AxisGroupRangeTracker();
-    };
+    }
 
-    PolarPlotAreaBase.prototype.render = function render () {
+    render() {
         this.addToLegend(this.series);
         this.createPolarAxis();
         this.createCharts();
         this.createValueAxis();
-    };
-
-    PolarPlotAreaBase.prototype.alignAxes = function alignAxes () {
-        var axis = this.valueAxis;
-        var range = axis.range();
-        var crossingValue = axis.options.reverse ? range.max : range.min;
-        var slot = axis.getSlot(crossingValue);
-        var center = this.polarAxis.getSlot(0).center;
-        var axisBox = axis.box.translate(
+    }
+
+    alignAxes() {
+        const axis = this.valueAxis;
+        const range = axis.range();
+        const crossingValue = axis.options.reverse ? range.max : range.min;
+        const slot = axis.getSlot(crossingValue);
+        const center = this.polarAxis.getSlot(0).center;
+        const axisBox = axis.box.translate(
             center.x - slot.x1,
             center.y - slot.y1
         );
 
         axis.reflow(axisBox);
-    };
+    }
 
-    PolarPlotAreaBase.prototype.createValueAxis = function createValueAxis () {
-        var tracker = this.valueAxisRangeTracker;
-        var defaultRange = tracker.query();
-        var axisOptions = this.valueAxisOptions({
+    createValueAxis() {
+        const tracker = this.valueAxisRangeTracker;
+        const defaultRange = tracker.query();
+        const axisOptions = this.valueAxisOptions({
             roundToMajorUnit: false,
             zIndex: -1
         });
-        var axisType, axisDefaultRange;
+        let axisType, axisDefaultRange;
 
         if (axisOptions.type === LOGARITHMIC) {
             axisType = RadarLogarithmicAxis;
@@ -60,14 +52,14 @@ var PolarPlotAreaBase = (function (PlotAreaBase) {
             axisDefaultRange = { min: 0, max: 1 };
         }
 
-        var range = tracker.query(name) || defaultRange || axisDefaultRange;
+        const range = tracker.query(name) || defaultRange || axisDefaultRange;
 
         if (range && defaultRange) {
             range.min = Math.min(range.min, defaultRange.min);
             range.max = Math.max(range.max, defaultRange.max);
         }
 
-        var valueAxis = new axisType(
+        const valueAxis = new axisType(
             range.min, range.max,
             axisOptions,
             this.chartService
@@ -75,40 +67,34 @@ var PolarPlotAreaBase = (function (PlotAreaBase) {
 
         this.valueAxis = valueAxis;
         this.appendAxis(valueAxis);
-    };
-
-    PolarPlotAreaBase.prototype.reflowAxes = function reflowAxes () {
-        var ref = this;
-        var options = ref.options.plotArea;
-        var valueAxis = ref.valueAxis;
-        var polarAxis = ref.polarAxis;
-        var box = ref.box;
-        var defaultPadding = Math.min(box.width(), box.height()) * DEFAULT_PADDING;
-        var padding = getSpacing(options.padding || {}, defaultPadding);
-        var paddingBox = box.clone().unpad(padding);
-        var axisBox = paddingBox.clone();
+    }
+
+    reflowAxes() {
+        const { options: { plotArea: options }, valueAxis, polarAxis, box } = this;
+        const defaultPadding = Math.min(box.width(), box.height()) * DEFAULT_PADDING;
+        const padding = getSpacing(options.padding || {}, defaultPadding);
+        const paddingBox = box.clone().unpad(padding);
+        const axisBox = paddingBox.clone();
 
         axisBox.y2 = axisBox.y1 + Math.min(axisBox.width(), axisBox.height());
         axisBox.align(paddingBox, Y, CENTER);
 
-        var valueAxisBox = axisBox.clone().shrink(0, axisBox.height() / 2);
+        const valueAxisBox = axisBox.clone().shrink(0, axisBox.height() / 2);
 
         polarAxis.reflow(axisBox);
         valueAxis.reflow(valueAxisBox);
-        var heightDiff = valueAxis.lineBox().height() - valueAxis.box.height();
+        const heightDiff = valueAxis.lineBox().height() - valueAxis.box.height();
         valueAxis.reflow(valueAxis.box.unpad({ top: heightDiff }));
 
         this.axisBox = axisBox;
         this.alignAxes(axisBox);
-    };
+    }
 
-    PolarPlotAreaBase.prototype.backgroundBox = function backgroundBox () {
+    backgroundBox() {
         return this.box;
-    };
-
-    PolarPlotAreaBase.prototype.detachLabels = function detachLabels () {};
+    }
 
-    return PolarPlotAreaBase;
-}(PlotAreaBase));
+    detachLabels() {}
+}
 
 export default PolarPlotAreaBase;

package/dist/es/chart/plotarea/polar-plotarea.js

@@ -15,60 +15,52 @@ import { ARC } from '../../common/constants';
 import { deepExtend, eventElement, setDefaultOptions } from '../../common';
 import XYPlotArea from './xy-plotarea';
 
-var PolarPlotArea = (function (PolarPlotAreaBase) {
-    function PolarPlotArea () {
-        PolarPlotAreaBase.apply(this, arguments);
-    }
-
-    if ( PolarPlotAreaBase ) PolarPlotArea.__proto__ = PolarPlotAreaBase;
-    PolarPlotArea.prototype = Object.create( PolarPlotAreaBase && PolarPlotAreaBase.prototype );
-    PolarPlotArea.prototype.constructor = PolarPlotArea;
-
-    PolarPlotArea.prototype.createPolarAxis = function createPolarAxis () {
-        var polarAxis = new PolarAxis(this.options.xAxis, this.chartService);
+class PolarPlotArea extends PolarPlotAreaBase {
+    createPolarAxis() {
+        const polarAxis = new PolarAxis(this.options.xAxis, this.chartService);
 
         this.polarAxis = polarAxis;
         this.axisX = polarAxis;
         this.appendAxis(polarAxis);
-    };
+    }
 
-    PolarPlotArea.prototype.render = function render () {
-        this.series = [].concat( this.originalSeries );
+    render() {
+        this.series = [...this.originalSeries];
         this.createTrendlineSeries();
 
-        PolarPlotAreaBase.prototype.render.call(this);
-    };
+        super.render();
+    }
 
-    PolarPlotArea.prototype.valueAxisOptions = function valueAxisOptions (defaults) {
+    valueAxisOptions(defaults) {
         return deepExtend(defaults, {
             majorGridLines: { type: ARC },
             minorGridLines: { type: ARC }
         }, this.options.yAxis);
-    };
+    }
 
-    PolarPlotArea.prototype.createValueAxis = function createValueAxis () {
-        PolarPlotAreaBase.prototype.createValueAxis.call(this);
+    createValueAxis() {
+        super.createValueAxis();
         this.axisY = this.valueAxis;
-    };
+    }
 
-    PolarPlotArea.prototype.trendlineFactory = function trendlineFactory (options, series) {
-        var trendline = XYPlotArea.prototype.trendlineFactory.call(this, options, series);
+    trendlineFactory(options, series) {
+        const trendline = XYPlotArea.prototype.trendlineFactory.call(this, options, series);
         if (trendline) {
             trendline.type = POLAR_LINE;
         }
 
         return trendline;
-    };
+    }
 
-    PolarPlotArea.prototype.appendChart = function appendChart (chart, pane) {
+    appendChart(chart, pane) {
         this.valueAxisRangeTracker.update(chart.yAxisRanges);
 
         PlotAreaBase.prototype.appendChart.call(this, chart, pane);
-    };
+    }
 
-    PolarPlotArea.prototype.createCharts = function createCharts () {
-        var series = this.filterVisibleSeries(this.series);
-        var pane = this.panes[0];
+    createCharts() {
+        const series = this.filterVisibleSeries(this.series);
+        const pane = this.panes[0];
 
         this.createLineChart(
             filterSeriesByType(series, [ POLAR_LINE ]),
@@ -84,43 +76,43 @@ var PolarPlotArea = (function (PolarPlotAreaBase) {
             filterSeriesByType(series, [ POLAR_AREA ]),
             pane
         );
-    };
+    }
 
-    PolarPlotArea.prototype.createLineChart = function createLineChart (series, pane) {
+    createLineChart(series, pane) {
         if (series.length === 0) {
             return;
         }
 
-        var lineChart = new PolarLineChart(this, { series: series });
+        const lineChart = new PolarLineChart(this, { series: series });
 
         this.appendChart(lineChart, pane);
-    };
+    }
 
-    PolarPlotArea.prototype.createScatterChart = function createScatterChart (series, pane) {
+    createScatterChart(series, pane) {
         if (series.length === 0) {
             return;
         }
 
-        var scatterChart = new PolarScatterChart(this, { series: series });
+        const scatterChart = new PolarScatterChart(this, { series: series });
 
         this.appendChart(scatterChart, pane);
-    };
+    }
 
-    PolarPlotArea.prototype.createAreaChart = function createAreaChart (series, pane) {
+    createAreaChart(series, pane) {
         if (series.length === 0) {
             return;
         }
 
-        var areaChart = new PolarAreaChart(this, { series: series });
+        const areaChart = new PolarAreaChart(this, { series: series });
 
         this.appendChart(areaChart, pane);
-    };
+    }
 
-    PolarPlotArea.prototype._dispatchEvent = function _dispatchEvent (chart, e, eventType) {
-        var coords = chart._eventCoordinates(e);
-        var point = new Point(coords.x, coords.y);
-        var xValue = this.axisX.getValue(point);
-        var yValue = this.axisY.getValue(point);
+    _dispatchEvent(chart, e, eventType) {
+        const coords = chart._eventCoordinates(e);
+        const point = new Point(coords.x, coords.y);
+        const xValue = this.axisX.getValue(point);
+        const yValue = this.axisY.getValue(point);
 
         if (xValue !== null && yValue !== null) {
             chart.trigger(eventType, {
@@ -129,12 +121,10 @@ var PolarPlotArea = (function (PolarPlotAreaBase) {
                 y: yValue
             });
         }
-    };
-
-    PolarPlotArea.prototype.createCrosshairs = function createCrosshairs () {};
+    }
 
-    return PolarPlotArea;
-}(PolarPlotAreaBase));
+    createCrosshairs() {}
+}
 
 setDefaultOptions(PolarPlotArea, {
     xAxis: {},

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

@@ -14,17 +14,9 @@ import filterSeriesByType from '../utils/filter-series-by-type';
 import { ARC } from '../../common/constants';
 import { eventElement, deepExtend, setDefaultOptions } from '../../common';
 
-var RadarPlotArea = (function (PolarPlotAreaBase) {
-    function RadarPlotArea () {
-        PolarPlotAreaBase.apply(this, arguments);
-    }
-
-    if ( PolarPlotAreaBase ) RadarPlotArea.__proto__ = PolarPlotAreaBase;
-    RadarPlotArea.prototype = Object.create( PolarPlotAreaBase && PolarPlotAreaBase.prototype );
-    RadarPlotArea.prototype.constructor = RadarPlotArea;
-
-    RadarPlotArea.prototype.createPolarAxis = function createPolarAxis () {
-        var categoryAxis = new RadarCategoryAxis(this.options.categoryAxis, this.chartService);
+class RadarPlotArea extends PolarPlotAreaBase {
+    createPolarAxis() {
+        const categoryAxis = new RadarCategoryAxis(this.options.categoryAxis, this.chartService);
 
         this.polarAxis = categoryAxis;
         this.categoryAxis = categoryAxis;
@@ -32,9 +24,9 @@ var RadarPlotArea = (function (PolarPlotAreaBase) {
         this.aggregateCategories();
         this.createTrendlineSeries();
         this.createCategoryAxesLabels();
-    };
+    }
 
-    RadarPlotArea.prototype.valueAxisOptions = function valueAxisOptions (defaults) {
+    valueAxisOptions(defaults) {
         if (this._hasBarCharts) {
             deepExtend(defaults, {
                 majorGridLines: { type: ARC },
@@ -50,34 +42,34 @@ var RadarPlotArea = (function (PolarPlotAreaBase) {
         }
 
         return deepExtend(defaults, this.options.valueAxis);
-    };
+    }
 
-    RadarPlotArea.prototype.aggregateCategories = function aggregateCategories () {
+    aggregateCategories() {
         // No separate panes in radar charts
         CategoricalPlotArea.prototype.aggregateCategories.call(this, this.panes);
-    };
+    }
 
-    RadarPlotArea.prototype.createCategoryAxesLabels = function createCategoryAxesLabels () {
+    createCategoryAxesLabels() {
         CategoricalPlotArea.prototype.createCategoryAxesLabels.call(this, this.panes);
-    };
+    }
 
-    RadarPlotArea.prototype.filterSeries = function filterSeries (currentSeries) {
+    filterSeries(currentSeries) {
         // Not supported for radar charts
         return currentSeries;
-    };
+    }
 
-    RadarPlotArea.prototype.trendlineFactory = function trendlineFactory (options, series) {
-        var trendline = CategoricalPlotArea.prototype.trendlineFactory.call(this, options, series);
+    trendlineFactory(options, series) {
+        const trendline = CategoricalPlotArea.prototype.trendlineFactory.call(this, options, series);
         if (trendline) {
             trendline.type = RADAR_LINE;
         }
 
         return trendline;
-    };
+    }
 
-    RadarPlotArea.prototype.createCharts = function createCharts () {
-        var series = this.filterVisibleSeries(this.series);
-        var pane = this.panes[0];
+    createCharts() {
+        const series = this.filterVisibleSeries(this.series);
+        const pane = this.panes[0];
 
         this.createAreaChart(
             filterSeriesByType(series, [ RADAR_AREA ]),
@@ -93,14 +85,14 @@ var RadarPlotArea = (function (PolarPlotAreaBase) {
             filterSeriesByType(series, [ RADAR_COLUMN ]),
             pane
         );
-    };
+    }
 
-    RadarPlotArea.prototype.chartOptions = function chartOptions (series) {
-        var options = { series: series };
-        var firstSeries = series[0];
+    chartOptions(series) {
+        const options = { series: series };
+        const firstSeries = series[0];
         if (firstSeries) {
-            var filteredSeries = this.filterVisibleSeries(series);
-            var stack = firstSeries.stack;
+            const filteredSeries = this.filterVisibleSeries(series);
+            const stack = firstSeries.stack;
             options.isStacked = stack && filteredSeries.length > 1;
             options.isStacked100 = stack && stack.type === "100%" && filteredSeries.length > 1;
 
@@ -110,57 +102,57 @@ var RadarPlotArea = (function (PolarPlotAreaBase) {
         }
 
         return options;
-    };
+    }
 
-    RadarPlotArea.prototype.createAreaChart = function createAreaChart (series, pane) {
+    createAreaChart(series, pane) {
         if (series.length === 0) {
             return;
         }
 
-        var areaChart = new RadarAreaChart(this, this.chartOptions(series));
+        const areaChart = new RadarAreaChart(this, this.chartOptions(series));
         this.appendChart(areaChart, pane);
-    };
+    }
 
-    RadarPlotArea.prototype.createLineChart = function createLineChart (series, pane) {
+    createLineChart(series, pane) {
         if (series.length === 0) {
             return;
         }
 
-        var lineChart = new RadarLineChart(this, this.chartOptions(series));
+        const lineChart = new RadarLineChart(this, this.chartOptions(series));
         this.appendChart(lineChart, pane);
-    };
+    }
 
-    RadarPlotArea.prototype.createBarChart = function createBarChart (series, pane) {
+    createBarChart(series, pane) {
         if (series.length === 0) {
             return;
         }
 
-        var firstSeries = series[0];
-        var options = this.chartOptions(series);
-        var filteredSeries = this.filterVisibleSeries(series);
-        var anyStackedSeries = filteredSeries.some(function (s) { return s.stack; });
-        var isStacked100 = filteredSeries.some(function (s) { return s.stack && s.stack.type === "100%"; });
+        const firstSeries = series[0];
+        const options = this.chartOptions(series);
+        const filteredSeries = this.filterVisibleSeries(series);
+        const anyStackedSeries = filteredSeries.some(s => s.stack);
+        const isStacked100 = filteredSeries.some(s => s.stack && s.stack.type === "100%");
         options.gap = firstSeries.gap;
         options.spacing = firstSeries.spacing;
         options.defaultStack = firstSeries.stack && filteredSeries.length > 1;
         options.isStacked = anyStackedSeries && filteredSeries.length > 1;
         options.isStacked100 = isStacked100 && filteredSeries.length > 1;
 
-        var barChart = new RadarBarChart(this, options);
+        const barChart = new RadarBarChart(this, options);
         this.appendChart(barChart, pane);
 
         this._hasBarCharts = true;
-    };
+    }
 
-    RadarPlotArea.prototype.seriesCategoryAxis = function seriesCategoryAxis () {
+    seriesCategoryAxis() {
         return this.categoryAxis;
-    };
+    }
 
-    RadarPlotArea.prototype._dispatchEvent = function _dispatchEvent (chart, e, eventType) {
-        var coords = chart._eventCoordinates(e);
-        var point = new Point(coords.x, coords.y);
-        var category = this.categoryAxis.getCategory(point);
-        var value = this.valueAxis.getValue(point);
+    _dispatchEvent(chart, e, eventType) {
+        const coords = chart._eventCoordinates(e);
+        const point = new Point(coords.x, coords.y);
+        const category = this.categoryAxis.getCategory(point);
+        const value = this.valueAxis.getValue(point);
 
         if (category !== null && value !== null) {
             chart.trigger(eventType, {
@@ -169,20 +161,18 @@ var RadarPlotArea = (function (PolarPlotAreaBase) {
                 value: value
             });
         }
-    };
-
-    RadarPlotArea.prototype.createCrosshairs = function createCrosshairs () {};
+    }
 
-    RadarPlotArea.prototype._pointsByVertical = function _pointsByVertical (basePoint) {
-        return PolarPlotAreaBase.prototype._pointsByVertical.call(this, basePoint).sort(this._getSeriesCompareFn());
-    };
+    createCrosshairs() {}
 
-    RadarPlotArea.prototype._getSeriesCompareFn = function _getSeriesCompareFn () {
-        return function (a, b) { return b.value - a.value; };
-    };
+    _pointsByVertical(basePoint) {
+        return super._pointsByVertical(basePoint).sort(this._getSeriesCompareFn());
+    }
 
-    return RadarPlotArea;
-}(PolarPlotAreaBase));
+    _getSeriesCompareFn() {
+        return (a, b) => b.value - a.value;
+    }
+}
 
 deepExtend(RadarPlotArea.prototype, PlotAreaEventsMixin, {
     appendChart: CategoricalPlotArea.prototype.appendChart,