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

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

@@ -1,22 +1,14 @@
 import PiePlotArea from './pie-plotarea';
 import DonutChart from '../donut-chart/donut-chart';
 
-var DonutPlotArea = (function (PiePlotArea) {
-    function DonutPlotArea () {
-        PiePlotArea.apply(this, arguments);
-    }
-
-    if ( PiePlotArea ) DonutPlotArea.__proto__ = PiePlotArea;
-    DonutPlotArea.prototype = Object.create( PiePlotArea && PiePlotArea.prototype );
-    DonutPlotArea.prototype.constructor = DonutPlotArea;
-
-    DonutPlotArea.prototype.render = function render () {
+class DonutPlotArea extends PiePlotArea {
+    render() {
         this.createDonutChart(this.series);
-    };
+    }
 
-    DonutPlotArea.prototype.createDonutChart = function createDonutChart (series) {
-        var firstSeries = series[0];
-        var donutChart = new DonutChart(this, {
+    createDonutChart(series) {
+        const firstSeries = series[0];
+        const donutChart = new DonutChart(this, {
             series: series,
             padding: firstSeries.padding,
             connectors: firstSeries.connectors,
@@ -24,18 +16,16 @@ var DonutPlotArea = (function (PiePlotArea) {
         });
 
         this.appendChart(donutChart);
-    };
+    }
 
     // These were overriden in the Pie, so revert to original behavior
-    DonutPlotArea.prototype.getPointBelow = function getPointBelow (point) {
+    getPointBelow(point) {
         return this._getNextPoint(point, this._pointsByVertical, -1);
-    };
+    }
 
-    DonutPlotArea.prototype.getPointAbove = function getPointAbove (point) {
+    getPointAbove(point) {
         return this._getNextPoint(point, this._pointsByVertical, 1);
-    };
-
-    return DonutPlotArea;
-}(PiePlotArea));
+    }
+}
 
 export default DonutPlotArea;

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

@@ -7,27 +7,19 @@ import { filterSeriesByType } from '../utils';
 
 import { FUNNEL, PYRAMID } from '../constants';
 
-var FunnelPlotArea = (function (PlotAreaBase) {
-    function FunnelPlotArea () {
-        PlotAreaBase.apply(this, arguments);
-    }
-
-    if ( PlotAreaBase ) FunnelPlotArea.__proto__ = PlotAreaBase;
-    FunnelPlotArea.prototype = Object.create( PlotAreaBase && PlotAreaBase.prototype );
-    FunnelPlotArea.prototype.constructor = FunnelPlotArea;
-
-    FunnelPlotArea.prototype.render = function render () {
+class FunnelPlotArea extends PlotAreaBase {
+    render() {
         this.createChart(FunnelChart, filterSeriesByType(this.series, [ FUNNEL ]));
         this.createChart(PyramidChart, filterSeriesByType(this.series, [ PYRAMID ]));
-    };
+    }
 
-    FunnelPlotArea.prototype.createChart = function createChart (chartType, series) {
-        var firstSeries = series[0];
+    createChart(chartType, series) {
+        const firstSeries = series[0];
         if (!firstSeries) {
             return;
         }
 
-        var chart = new chartType(this, {
+        const chart = new chartType(this, {
             series: series,
             legend: this.options.legend,
             neckRatio: firstSeries.neckRatio,
@@ -38,26 +30,24 @@ var FunnelPlotArea = (function (PlotAreaBase) {
         });
 
         this.appendChart(chart);
-    };
+    }
 
-    FunnelPlotArea.prototype.appendChart = function appendChart (chart, pane) {
-        PlotAreaBase.prototype.appendChart.call(this, chart, pane);
+    appendChart(chart, pane) {
+        super.appendChart(chart, pane);
         append(this.options.legend.data, chart.legendItems);
-    };
+    }
 
-    FunnelPlotArea.prototype._pointsByVertical = function _pointsByVertical (basePoint) {
+    _pointsByVertical(basePoint) {
         return this.pointsBySeriesIndex(basePoint.series.index);
-    };
+    }
 
-    FunnelPlotArea.prototype.getPointToTheRight = function getPointToTheRight (point) {
+    getPointToTheRight(point) {
         return this.getPointBelow(point);
-    };
+    }
 
-    FunnelPlotArea.prototype.getPointToTheLeft = function getPointToTheLeft (point) {
+    getPointToTheLeft(point) {
         return this.getPointAbove(point);
-    };
-
-    return FunnelPlotArea;
-}(PlotAreaBase));
+    }
+}
 
 export default FunnelPlotArea;

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

@@ -10,48 +10,32 @@ import { appendIfNotNull, equalsIgnoreCase, filterSeriesByType, singleItemOrArra
 import PlotAreaBase from './plotarea-base';
 
 
-var HeatmapPlotArea = (function (PlotAreaBase) {
-    function HeatmapPlotArea () {
-        PlotAreaBase.apply(this, arguments);
-    }
-
-    if ( PlotAreaBase ) HeatmapPlotArea.__proto__ = PlotAreaBase;
-    HeatmapPlotArea.prototype = Object.create( PlotAreaBase && PlotAreaBase.prototype );
-    HeatmapPlotArea.prototype.constructor = HeatmapPlotArea;
-
-    HeatmapPlotArea.prototype.initFields = function initFields () {
+class HeatmapPlotArea extends PlotAreaBase {
+    initFields() {
         this.namedXAxes = {};
         this.namedYAxes = {};
-    };
-
-    HeatmapPlotArea.prototype.render = function render (panes) {
-        if ( panes === void 0 ) panes = this.panes;
+    }
 
+    render(panes = this.panes) {
         this.bindCategories();
         this.createAxes(panes);
         this.createCharts(panes);
         this.createAxisLabels();
-    };
-
-    HeatmapPlotArea.prototype.bindCategories = function bindCategories () {
-        var this$1 = this;
+    }
 
-        var series = this.srcSeries || this.series;
+    bindCategories() {
+        const series = this.srcSeries || this.series;
 
-        for (var i = 0; i < series.length; i++) {
-            var currentSeries = series[i];
-            var data = currentSeries.data || [];
-            var ref = this$1.seriesAxes(currentSeries);
-            var xAxis = ref.xAxis;
-            var yAxis = ref.yAxis;
+        for (let i = 0; i < series.length; i++) {
+            const currentSeries = series[i];
+            const data = currentSeries.data || [];
+            const { xAxis, yAxis } = this.seriesAxes(currentSeries);
 
-            var xCategories = createHashSet(xAxis.categories || []);
-            var yCategories = createHashSet(yAxis.categories || []);
+            const xCategories = createHashSet(xAxis.categories || []);
+            const yCategories = createHashSet(yAxis.categories || []);
 
-            for (var pointIndex = 0; pointIndex < data.length; pointIndex++) {
-                var ref$1 = SeriesBinder.current.bindPoint(currentSeries, pointIndex).valueFields;
-                var x = ref$1.x;
-                var y = ref$1.y;
+            for (let pointIndex = 0; pointIndex < data.length; pointIndex++) {
+                const { x, y } = SeriesBinder.current.bindPoint(currentSeries, pointIndex).valueFields;
 
                 if (!xCategories.has(x)) {
                     xCategories.add(x);
@@ -65,71 +49,69 @@ var HeatmapPlotArea = (function (PlotAreaBase) {
             xAxis.categories = xCategories.values();
             yAxis.categories = yCategories.values();
         }
-    };
-
-    HeatmapPlotArea.prototype.createCharts = function createCharts (panes) {
-        var this$1 = this;
+    }
 
-        var seriesByPane = this.groupSeriesByPane();
+    createCharts(panes) {
+        const seriesByPane = this.groupSeriesByPane();
 
-        for (var i = 0; i < panes.length; i++) {
-            var pane = panes[i];
-            var paneSeries = seriesByPane[pane.options.name || "default"] || [];
-            this$1.addToLegend(paneSeries);
-            var filteredSeries = this$1.filterVisibleSeries(paneSeries);
+        for (let i = 0; i < panes.length; i++) {
+            const pane = panes[i];
+            const paneSeries = seriesByPane[pane.options.name || "default"] || [];
+            this.addToLegend(paneSeries);
+            const filteredSeries = this.filterVisibleSeries(paneSeries);
 
             if (!filteredSeries) {
                 continue;
             }
 
-            this$1.createHeatmapChart(
+            this.createHeatmapChart(
                 filterSeriesByType(filteredSeries, [ HEATMAP ]),
                 pane
             );
         }
-    };
+    }
 
-    HeatmapPlotArea.prototype.createHeatmapChart = function createHeatmapChart (series, pane) {
-        var chart = new HeatmapChart(this, {
+    createHeatmapChart(series, pane) {
+        const chart = new HeatmapChart(this, {
             series: series
         });
 
         this.appendChart(chart, pane);
-    };
-
-    HeatmapPlotArea.prototype.seriesPaneName = function seriesPaneName (series) {
-        var options = this.options;
-        var xAxisName = series.xAxis;
-        var xAxisOptions = [].concat(options.xAxis);
-        var xAxis = grep(xAxisOptions, function(a) { return a.name === xAxisName; })[0];
-        var yAxisName = series.yAxis;
-        var yAxisOptions = [].concat(options.yAxis);
-        var yAxis = grep(yAxisOptions, function(a) { return a.name === yAxisName; })[0];
-        var panes = options.panes || [ {} ];
-        var defaultPaneName = panes[0].name || "default";
-        var paneName = (xAxis || {}).pane || (yAxis || {}).pane || defaultPaneName;
+    }
+
+    seriesPaneName(series) {
+        const options = this.options;
+        const xAxisName = series.xAxis;
+        const xAxisOptions = [].concat(options.xAxis);
+        const xAxis = grep(xAxisOptions, function(a) { return a.name === xAxisName; })[0];
+        const yAxisName = series.yAxis;
+        const yAxisOptions = [].concat(options.yAxis);
+        const yAxis = grep(yAxisOptions, function(a) { return a.name === yAxisName; })[0];
+        const panes = options.panes || [ {} ];
+        const defaultPaneName = panes[0].name || "default";
+        const paneName = (xAxis || {}).pane || (yAxis || {}).pane || defaultPaneName;
 
         return paneName;
-    };
+    }
 
-    HeatmapPlotArea.prototype.seriesAxes = function seriesAxes (series) {
-        var xAxis;
-        var yAxis;
+    seriesAxes(series) {
+        let xAxis;
+        let yAxis;
 
-        var options = this.options;
+        const options = this.options;
 
-        var xAxisOptions = [].concat(options.xAxis);
-        var xAxisName = series.xAxis;
+        const xAxisOptions = [].concat(options.xAxis);
+        const xAxisName = series.xAxis;
         if (xAxisName) {
-            xAxis = xAxisOptions.find(function (axis) { return axis.name === xAxisName; });
+            xAxis = xAxisOptions.find(axis => axis.name === xAxisName);
         } else {
             xAxis = xAxisOptions[0];
         }
 
-        var yAxisOptions = [].concat(options.yAxis);
-        var yAxisName = series.yAxis;
+        const yAxisOptions = [].concat(options.yAxis);
+        const yAxisName = series.yAxis;
         if (yAxisName) {
-            yAxis = yAxisOptions.find(function (axis) { return axis.name === yAxisName; });
+            yAxis = yAxisOptions.find(axis => axis.name === yAxisName);
         } else {
             yAxis = yAxisOptions[0];
         }
@@ -142,63 +124,63 @@ var HeatmapPlotArea = (function (PlotAreaBase) {
             throw new Error("Unable to locate Y axis with name " + yAxisName);
         }
 
-        return { xAxis: xAxis, yAxis: yAxis };
-    };
+        return { xAxis, yAxis };
+    }
 
-    HeatmapPlotArea.prototype.createAxisLabels = function createAxisLabels () {
-        var axes = this.axes;
-        for (var i = 0; i < axes.length; i++) {
+    createAxisLabels() {
+        const axes = this.axes;
+        for (let i = 0; i < axes.length; i++) {
             axes[i].createLabels();
         }
-    };
+    }
 
-    HeatmapPlotArea.prototype.createXYAxis = function createXYAxis (options, vertical, axisIndex) {
-        var axisName = options.name;
-        var namedAxes = vertical ? this.namedYAxes : this.namedXAxes;
-        var axisOptions = Object.assign({
+    createXYAxis(options, vertical, axisIndex) {
+        const axisName = options.name;
+        const namedAxes = vertical ? this.namedYAxes : this.namedXAxes;
+        const axisOptions = Object.assign({
             axisCrossingValue: 0
         }, options, {
             vertical: vertical,
             reverse: (vertical || this.chartService.rtl) ? !options.reverse : options.reverse,
             justified: false
         });
-        var firstCategory = axisOptions.categories ? axisOptions.categories[0] : null;
-        var typeSamples = [ axisOptions.min, axisOptions.max, firstCategory ];
-        var series = this.series;
+        const firstCategory = axisOptions.categories ? axisOptions.categories[0] : null;
+        const typeSamples = [ axisOptions.min, axisOptions.max, firstCategory ];
+        const series = this.series;
 
-        for (var seriesIx = 0; seriesIx < series.length; seriesIx++) {
-            var currentSeries = series[seriesIx];
-            var seriesAxisName = currentSeries[vertical ? "yAxis" : "xAxis"];
+        for (let seriesIx = 0; seriesIx < series.length; seriesIx++) {
+            const currentSeries = series[seriesIx];
+            const seriesAxisName = currentSeries[vertical ? "yAxis" : "xAxis"];
             if ((seriesAxisName === axisOptions.name) || (axisIndex === 0 && !seriesAxisName)) {
-                var firstPointValue = SeriesBinder.current.bindPoint(currentSeries, 0).valueFields;
+                const firstPointValue = SeriesBinder.current.bindPoint(currentSeries, 0).valueFields;
                 typeSamples.push(firstPointValue[vertical ? "y" : "x"]);
 
                 break;
             }
         }
 
-        var inferredDate;
+        let inferredDate;
 
-        for (var i = 0; i < typeSamples.length; i++) {
+        for (let i = 0; i < typeSamples.length; i++) {
             if (typeSamples[i] instanceof Date) {
                 inferredDate = true;
                 break;
             }
         }
 
-        var axisType;
+        let axisType;
         if (equalsIgnoreCase(axisOptions.type, DATE) || (!axisOptions.type && inferredDate)) {
             axisType = DateCategoryAxis;
         } else {
             axisType = CategoryAxis;
         }
 
-        var axis = new axisType(axisOptions, this.chartService);
+        const axis = new axisType(axisOptions, this.chartService);
         axis.axisIndex = axisIndex;
 
         if (axisName) {
             if (namedAxes[axisName]) {
-                throw new Error(((vertical ? "Y" : "X") + " axis with name " + axisName + " is already defined"));
+                throw new Error(`${ vertical ? "Y" : "X" } axis with name ${ axisName } is already defined`);
             }
             namedAxes[axisName] = axis;
         }
@@ -207,39 +189,37 @@ var HeatmapPlotArea = (function (PlotAreaBase) {
         axis.indexCategories();
 
         return axis;
-    };
-
-    HeatmapPlotArea.prototype.createAxes = function createAxes (panes) {
-        var this$1 = this;
+    }
 
-        var options = this.options;
-        var xAxesOptions = [].concat(options.xAxis);
-        var xAxes = [];
-        var yAxesOptions = [].concat(options.yAxis);
-        var yAxes = [];
+    createAxes(panes) {
+        const options = this.options;
+        const xAxesOptions = [].concat(options.xAxis);
+        const xAxes = [];
+        const yAxesOptions = [].concat(options.yAxis);
+        const yAxes = [];
 
-        for (var idx = 0; idx < xAxesOptions.length; idx++) {
-            var axisPane = this$1.findPane(xAxesOptions[idx].pane);
+        for (let idx = 0; idx < xAxesOptions.length; idx++) {
+            const axisPane = this.findPane(xAxesOptions[idx].pane);
             if (inArray(axisPane, panes)) {
-                xAxes.push(this$1.createXYAxis(xAxesOptions[idx], false, idx));
+                xAxes.push(this.createXYAxis(xAxesOptions[idx], false, idx));
             }
         }
 
-        for (var idx$1 = 0; idx$1 < yAxesOptions.length; idx$1++) {
-            var axisPane$1 = this$1.findPane(yAxesOptions[idx$1].pane);
-            if (inArray(axisPane$1, panes)) {
-                yAxes.push(this$1.createXYAxis(yAxesOptions[idx$1], true, idx$1));
+        for (let idx = 0; idx < yAxesOptions.length; idx++) {
+            const axisPane = this.findPane(yAxesOptions[idx].pane);
+            if (inArray(axisPane, panes)) {
+                yAxes.push(this.createXYAxis(yAxesOptions[idx], true, idx));
             }
         }
 
         this.axisX = this.axisX || xAxes[0];
         this.axisY = this.axisY || yAxes[0];
-    };
+    }
 
-    HeatmapPlotArea.prototype.removeAxis = function removeAxis (axis) {
-        var axisName = axis.options.name;
+    removeAxis(axis) {
+        const axisName = axis.options.name;
 
-        PlotAreaBase.prototype.removeAxis.call(this, axis);
+        super.removeAxis(axis);
 
         if (axis.options.vertical) {
             delete this.namedYAxes[axisName];
@@ -254,19 +234,19 @@ var HeatmapPlotArea = (function (PlotAreaBase) {
         if (axis === this.axisY) {
             delete this.axisY;
         }
-    };
-
-    HeatmapPlotArea.prototype._dispatchEvent = function _dispatchEvent (chart, e, eventType) {
-        var coords = chart._eventCoordinates(e);
-        var point = new Point(coords.x, coords.y);
-        var allAxes = this.axes;
-        var length = allAxes.length;
-        var xValues = [];
-        var yValues = [];
-
-        for (var i = 0; i < length; i++) {
-            var axis = allAxes[i];
-            var values = axis.options.vertical ? yValues : xValues;
+    }
+
+    _dispatchEvent(chart, e, eventType) {
+        const coords = chart._eventCoordinates(e);
+        const point = new Point(coords.x, coords.y);
+        const allAxes = this.axes;
+        const length = allAxes.length;
+        const xValues = [];
+        const yValues = [];
+
+        for (let i = 0; i < length; i++) {
+            const axis = allAxes[i];
+            const values = axis.options.vertical ? yValues : xValues;
             appendIfNotNull(values, axis.getCategory(point));
         }
 
@@ -278,80 +258,72 @@ var HeatmapPlotArea = (function (PlotAreaBase) {
                 y: singleItemOrArray(yValues)
             });
         }
-    };
+    }
 
-    HeatmapPlotArea.prototype.updateAxisOptions = function updateAxisOptions$1 (axis, options) {
-        var vertical = axis.options.vertical;
-        var axes = this.groupAxes(this.panes);
-        var index = (vertical ? axes.y : axes.x).indexOf(axis);
+    updateAxisOptions(axis, options) {
+        const vertical = axis.options.vertical;
+        const axes = this.groupAxes(this.panes);
+        const index = (vertical ? axes.y : axes.x).indexOf(axis);
 
         updateAxisOptions(this.options, index, vertical, options);
         updateAxisOptions(this.originalOptions, index, vertical, options);
-    };
+    }
 
-    HeatmapPlotArea.prototype.crosshairOptions = function crosshairOptions (axis) {
+    crosshairOptions(axis) {
         // Stack the crosshair above the series points.
         return Object.assign({}, axis.options.crosshair, { zIndex: 0 });
-    };
-
-    HeatmapPlotArea.prototype._pointsByVertical = function _pointsByVertical (basePoint, offset) {
-        var this$1 = this;
-        if ( offset === void 0 ) offset = 0;
+    }
 
-        var normalizedOffset = this.axisX.options.reverse ? offset * -1 : offset;
-        var axisXItems = this.axisX.children;
-        var xIndex = this._getPointAxisXIndex(basePoint) + normalizedOffset;
+    _pointsByVertical(basePoint, offset = 0) {
+        const normalizedOffset = this.axisX.options.reverse ? offset * -1 : offset;
+        const axisXItems = this.axisX.children;
+        let xIndex = this._getPointAxisXIndex(basePoint) + normalizedOffset;
 
         xIndex = cycleIndex(xIndex, axisXItems.length);
-        var targetXValue = axisXItems[xIndex].value;
+        const targetXValue = axisXItems[xIndex].value;
 
-        var points = this
-            .filterPoints(function (point) { return compareValues(point.pointData().x, targetXValue); })
-            .sort(function (a, b) { return this$1._getPointAxisYIndex(a) - this$1._getPointAxisYIndex(b); });
+        const points = this
+            .filterPoints(point => compareValues(point.pointData().x, targetXValue))
+            .sort((a, b) => this._getPointAxisYIndex(a) - this._getPointAxisYIndex(b));
 
         if (this.axisY.options.reverse) {
             return points.reverse();
         }
 
         return points;
-    };
-
-    HeatmapPlotArea.prototype._pointsByHorizontal = function _pointsByHorizontal (basePoint, offset) {
-        var this$1 = this;
-        if ( offset === void 0 ) offset = 0;
+    }
 
-        var normalizedOffset = this.axisY.options.reverse ? offset * -1 : offset;
-        var axisYItems = this.axisY.children;
-        var yIndex = this._getPointAxisYIndex(basePoint) + normalizedOffset;
+    _pointsByHorizontal(basePoint, offset = 0) {
+        const normalizedOffset = this.axisY.options.reverse ? offset * -1 : offset;
+        const axisYItems = this.axisY.children;
+        let yIndex = this._getPointAxisYIndex(basePoint) + normalizedOffset;
 
         yIndex = cycleIndex(yIndex, axisYItems.length);
-        var targetYValue = axisYItems[yIndex].value;
+        const targetYValue = axisYItems[yIndex].value;
 
-        var points = this
-            .filterPoints(function (point) { return compareValues(point.pointData().y, targetYValue); })
-            .sort(function (a, b) { return this$1._getPointAxisXIndex(a) - this$1._getPointAxisXIndex(b); });
+        const points = this
+            .filterPoints(point => compareValues(point.pointData().y, targetYValue))
+            .sort((a, b) => this._getPointAxisXIndex(a) - this._getPointAxisXIndex(b));
 
         if (this.axisX.options.reverse) {
             return points.reverse();
         }
 
         return points;
-    };
+    }
 
-    HeatmapPlotArea.prototype._getPointAxisXIndex = function _getPointAxisXIndex (point) {
+    _getPointAxisXIndex(point) {
         return this._getPointAxisIndex(this.axisX, point.pointData().x);
-    };
+    }
 
-    HeatmapPlotArea.prototype._getPointAxisYIndex = function _getPointAxisYIndex (point) {
+    _getPointAxisYIndex(point) {
         return this._getPointAxisIndex(this.axisY, point.pointData().y);
-    };
-
-    HeatmapPlotArea.prototype._getPointAxisIndex = function _getPointAxisIndex (axis, pointValue) {
-        return axis.children.findIndex(function (axisItem) { return compareValues(pointValue, axisItem.value); });
-    };
+    }
 
-    return HeatmapPlotArea;
-}(PlotAreaBase));
+    _getPointAxisIndex(axis, pointValue) {
+        return axis.children.findIndex(axisItem => compareValues(pointValue, axisItem.value));
+    }
+}
 
 function compareValues(a, b) {
     if (a instanceof Date && b instanceof Date) {
@@ -362,7 +334,7 @@ function compareValues(a, b) {
 }
 
 function updateAxisOptions(targetOptions, axisIndex, vertical, options) {
-    var axisOptions = ([].concat(vertical ? targetOptions.yAxis : targetOptions.xAxis))[axisIndex];
+    const axisOptions = ([].concat(vertical ? targetOptions.yAxis : targetOptions.xAxis))[axisIndex];
     deepExtend(axisOptions, options);
 }
 

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

@@ -3,22 +3,14 @@ import PieChart from '../pie-chart/pie-chart';
 
 import { append } from '../../common';
 
-var PiePlotArea = (function (PlotAreaBase) {
-    function PiePlotArea () {
-        PlotAreaBase.apply(this, arguments);
-    }
-
-    if ( PlotAreaBase ) PiePlotArea.__proto__ = PlotAreaBase;
-    PiePlotArea.prototype = Object.create( PlotAreaBase && PlotAreaBase.prototype );
-    PiePlotArea.prototype.constructor = PiePlotArea;
-
-    PiePlotArea.prototype.render = function render () {
+class PiePlotArea extends PlotAreaBase {
+    render() {
         this.createPieChart(this.series);
-    };
+    }
 
-    PiePlotArea.prototype.createPieChart = function createPieChart (series) {
-        var firstSeries = series[0];
-        var pieChart = new PieChart(this, {
+    createPieChart(series) {
+        const firstSeries = series[0];
+        const pieChart = new PieChart(this, {
             series: series,
             padding: firstSeries.padding,
             startAngle: firstSeries.startAngle,
@@ -27,22 +19,20 @@ var PiePlotArea = (function (PlotAreaBase) {
         });
 
         this.appendChart(pieChart);
-    };
+    }
 
-    PiePlotArea.prototype.appendChart = function appendChart (chart, pane) {
-        PlotAreaBase.prototype.appendChart.call(this, chart, pane);
+    appendChart(chart, pane) {
+        super.appendChart(chart, pane);
         append(this.options.legend.data, chart.legendItems);
-    };
+    }
 
-    PiePlotArea.prototype.getPointBelow = function getPointBelow (point) {
+    getPointBelow(point) {
         return this.getPointToTheRight(point);
-    };
+    }
 
-    PiePlotArea.prototype.getPointAbove = function getPointAbove (point) {
+    getPointAbove(point) {
         return this.getPointToTheLeft(point);
-    };
-
-    return PiePlotArea;
-}(PlotAreaBase));
+    }
+}
 
 export default PiePlotArea;