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

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

@@ -29,21 +29,12 @@ import { BAR, COLUMN, BULLET, VERTICAL_BULLET, LINE, VERTICAL_LINE, AREA, VERTIC
 import { DATE, MAX_VALUE } from '../../common/constants';
 import { setDefaultOptions, inArray, deepExtend, defined, eventElement, grep, cycleIndex, hasOwnProperty } from '../../common';
 
-var AREA_SERIES = [ AREA, VERTICAL_AREA, RANGE_AREA, VERTICAL_RANGE_AREA ];
-var OUT_OF_RANGE_SERIES = [ LINE, VERTICAL_LINE ].concat(AREA_SERIES);
+const AREA_SERIES = [ AREA, VERTICAL_AREA, RANGE_AREA, VERTICAL_RANGE_AREA ];
+const OUT_OF_RANGE_SERIES = [ LINE, VERTICAL_LINE ].concat(AREA_SERIES);
 
-var CategoricalPlotArea = (function (PlotAreaBase) {
-    function CategoricalPlotArea () {
-        PlotAreaBase.apply(this, arguments);
-    }
-
-    if ( PlotAreaBase ) CategoricalPlotArea.__proto__ = PlotAreaBase;
-    CategoricalPlotArea.prototype = Object.create( PlotAreaBase && PlotAreaBase.prototype );
-    CategoricalPlotArea.prototype.constructor = CategoricalPlotArea;
-
-    CategoricalPlotArea.prototype.initFields = function initFields (series) {
-        var this$1 = this;
+class CategoricalPlotArea extends PlotAreaBase {
 
+    initFields(series) {
         this.namedCategoryAxes = {};
         this.namedValueAxes = {};
         this.valueAxisRangeTracker = new AxisGroupRangeTracker();
@@ -56,20 +47,18 @@ var CategoricalPlotArea = (function (PlotAreaBase) {
                     RANGE_BAR, HORIZONTAL_WATERFALL, VERTICAL_BOX_PLOT ]
             );
 
-            for (var i = 0; i < series.length; i++) {
-                var stack = series[i].stack;
+            for (let i = 0; i < series.length; i++) {
+                const stack = series[i].stack;
                 if (stack && stack.type === "100%") {
-                    this$1.stack100 = true;
+                    this.stack100 = true;
                     break;
                 }
             }
         }
-    };
-
-    CategoricalPlotArea.prototype.render = function render (panes) {
-        if ( panes === void 0 ) panes = this.panes;
+    }
 
-        this.series = [].concat( this.originalSeries );
+    render(panes = this.panes) {
+        this.series = [...this.originalSeries];
         this.createCategoryAxes(panes);
 
         this.aggregateCategories(panes);
@@ -78,12 +67,12 @@ var CategoricalPlotArea = (function (PlotAreaBase) {
         this.createCategoryAxesLabels(panes);
         this.createCharts(panes);
         this.createValueAxes(panes);
-    };
+    }
 
-    CategoricalPlotArea.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 instanceof CategoryAxis) {
             delete this.namedCategoryAxes[axisName];
@@ -99,16 +88,16 @@ var CategoricalPlotArea = (function (PlotAreaBase) {
         if (axis === this.valueAxis) {
             delete this.valueAxis;
         }
-    };
+    }
 
-    CategoricalPlotArea.prototype.trendlineFactory = function trendlineFactory$1 (options, series) {
-        var categoryAxis = this.seriesCategoryAxis(options);
-        var seriesValues = this.seriesValues.bind(this, series.index);
+    trendlineFactory(options, series) {
+        const categoryAxis = this.seriesCategoryAxis(options);
+        const seriesValues = this.seriesValues.bind(this, series.index);
 
-        var trendline = trendlineFactory(trendlineRegistry, options.type, {
-            options: options,
-            categoryAxis: categoryAxis,
-            seriesValues: seriesValues
+        const trendline = trendlineFactory(trendlineRegistry, options.type, {
+            options,
+            categoryAxis,
+            seriesValues
         });
 
         if (trendline) {
@@ -120,26 +109,24 @@ var CategoricalPlotArea = (function (PlotAreaBase) {
         }
 
         return trendline;
-    };
+    }
 
-    CategoricalPlotArea.prototype.trendlineAggregateForecast = function trendlineAggregateForecast () {
+    trendlineAggregateForecast() {
         return this.series
-            .map(function (series) { return (series.trendline || {}).forecast; })
-            .filter(function (forecast) { return forecast !== undefined; })
-            .reduce(function (result, forecast) { return ({
+            .map(series => (series.trendline || {}).forecast)
+            .filter(forecast => forecast !== undefined)
+            .reduce((result, forecast) => ({
                 before: Math.max(result.before, forecast.before || 0),
                 after: Math.max(result.after, forecast.after || 0)
-            }); }, { before: 0, after: 0 });
-    };
-
-    CategoricalPlotArea.prototype.seriesValues = function seriesValues (seriesIx, range) {
-        var this$1 = this;
+            }), { before: 0, after: 0 });
+    }
 
-        var result = [];
+    seriesValues(seriesIx, range) {
+        const result = [];
 
-        var series = this.srcSeries[seriesIx];
-        var categoryAxis = this.seriesCategoryAxis(series);
-        var dateAxis = equalsIgnoreCase(categoryAxis.options.type, DATE);
+        let series = this.srcSeries[seriesIx];
+        const categoryAxis = this.seriesCategoryAxis(series);
+        const dateAxis = equalsIgnoreCase(categoryAxis.options.type, DATE);
         if (dateAxis) {
             this._seriesPointsCache = {};
             this._currentPointsCache = {};
@@ -147,39 +134,37 @@ var CategoricalPlotArea = (function (PlotAreaBase) {
             series = this.aggregateSeries(series, categoryAxis, categoryAxis.totalRangeIndices());
         }
 
-        var min = range ? range.min : 0;
-        var max = range ? range.max : series.data.length;
-        for (var categoryIx = min; categoryIx < max; categoryIx++) {
-            var data = this$1.bindPoint(series, categoryIx);
-            result.push({ categoryIx: categoryIx, category: data.fields.category, valueFields: data.valueFields });
+        const min = range ? range.min : 0;
+        const max = range ? range.max : series.data.length;
+        for (let categoryIx = min; categoryIx < max; categoryIx++) {
+            const data = this.bindPoint(series, categoryIx);
+            result.push({ categoryIx, category: data.fields.category, valueFields: data.valueFields });
         }
 
         return result;
-    };
-
-    CategoricalPlotArea.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);
+        for (let i = 0; i < panes.length; i++) {
+            const pane = panes[i];
+            const paneSeries = seriesByPane[pane.options.name || "default"] || [];
+            this.addToLegend(paneSeries);
 
-            var visibleSeries = this$1.filterVisibleSeries(paneSeries);
+            const visibleSeries = this.filterVisibleSeries(paneSeries);
             if (!visibleSeries) {
                 continue;
             }
 
-            var groups = this$1.groupSeriesByCategoryAxis(visibleSeries);
-            for (var groupIx = 0; groupIx < groups.length; groupIx++) {
-                this$1.createChartGroup(groups[groupIx], pane);
+            const groups = this.groupSeriesByCategoryAxis(visibleSeries);
+            for (let groupIx = 0; groupIx < groups.length; groupIx++) {
+                this.createChartGroup(groups[groupIx], pane);
             }
         }
-    };
+    }
 
-    CategoricalPlotArea.prototype.createChartGroup = function createChartGroup (series, pane) {
+    createChartGroup(series, pane) {
         this.createAreaChart(
             filterSeriesByType(series, [ AREA, VERTICAL_AREA ]), pane
         );
@@ -219,28 +204,26 @@ var CategoricalPlotArea = (function (PlotAreaBase) {
         this.createLineChart(
             filterSeriesByType(series, [ LINE, VERTICAL_LINE ]), pane
         );
-    };
-
-    CategoricalPlotArea.prototype.aggregateCategories = function aggregateCategories (panes) {
-        var this$1 = this;
+    }
 
-        var series = [].concat( this.series );
-        var processedSeries = [];
+    aggregateCategories(panes) {
+        const series = [...this.series];
+        const processedSeries = [];
         this._currentPointsCache = {};
         this._seriesPointsCache = this._seriesPointsCache || {};
 
-        for (var i = 0; i < series.length; i++) {
-            var currentSeries = series[i];
+        for (let i = 0; i < series.length; i++) {
+            let currentSeries = series[i];
 
-            if (!this$1.isTrendline(currentSeries)) {
-                var categoryAxis = this$1.seriesCategoryAxis(currentSeries);
-                var axisPane = this$1.findPane(categoryAxis.options.pane);
-                var dateAxis = equalsIgnoreCase(categoryAxis.options.type, DATE);
+            if (!this.isTrendline(currentSeries)) {
+                const categoryAxis = this.seriesCategoryAxis(currentSeries);
+                const axisPane = this.findPane(categoryAxis.options.pane);
+                const dateAxis = equalsIgnoreCase(categoryAxis.options.type, DATE);
 
                 if ((dateAxis || currentSeries.categoryField) && inArray(axisPane, panes)) {
-                    currentSeries = this$1.aggregateSeries(currentSeries, categoryAxis, categoryAxis.currentRangeIndices());
+                    currentSeries = this.aggregateSeries(currentSeries, categoryAxis, categoryAxis.currentRangeIndices());
                 } else {
-                    currentSeries = this$1.filterSeries(currentSeries, categoryAxis);
+                    currentSeries = this.filterSeries(currentSeries, categoryAxis);
                 }
             }
 
@@ -252,59 +235,57 @@ var CategoricalPlotArea = (function (PlotAreaBase) {
 
         this.srcSeries = series;
         this.series = processedSeries;
-    };
+    }
 
-    CategoricalPlotArea.prototype.filterSeries = function filterSeries (series, categoryAxis) {
-        var dataLength = (series.data || {}).length;
+    filterSeries(series, categoryAxis) {
+        const dataLength = (series.data || {}).length;
         categoryAxis._seriesMax = Math.max(categoryAxis._seriesMax || 0, dataLength);
 
         if (!(defined(categoryAxis.options.min) || defined(categoryAxis.options.max))) {
             return series;
         }
 
-        var range = categoryAxis.currentRangeIndices();
-        var outOfRangePoints = inArray(series.type, OUT_OF_RANGE_SERIES);
-        var currentSeries = deepExtend({}, series);
+        const range = categoryAxis.currentRangeIndices();
+        const outOfRangePoints = inArray(series.type, OUT_OF_RANGE_SERIES);
+        const currentSeries = deepExtend({}, series);
 
         currentSeries.data = (currentSeries.data || []).slice(range.min, range.max + 1);
 
         if (outOfRangePoints) {
-            createOutOfRangePoints(currentSeries, range, dataLength, function (idx) { return ({
+            createOutOfRangePoints(currentSeries, range, dataLength, (idx) => ({
                 item: series.data[idx],
                 category: categoryAxis.categoryAt(idx, true),
                 categoryIx: idx - range.min
-            }); }, function (idx) { return defined(series.data[idx]); });
+            }), (idx) => defined(series.data[idx]));
         }
 
         return currentSeries;
-    };
+    }
 
-    CategoricalPlotArea.prototype.clearSeriesPointsCache = function clearSeriesPointsCache () {
+    clearSeriesPointsCache() {
         this._seriesPointsCache = {};
-    };
-
-    CategoricalPlotArea.prototype.seriesSourcePoints = function seriesSourcePoints (series, categoryAxis) {
-        var this$1 = this;
+    }
 
-        var key = (series.index) + ";" + (categoryAxis.categoriesHash());
+    seriesSourcePoints(series, categoryAxis) {
+        const key = `${ series.index };${ categoryAxis.categoriesHash() }`;
         if (this._seriesPointsCache && this._seriesPointsCache[key]) {
             this._currentPointsCache[key] = this._seriesPointsCache[key];
             return this._seriesPointsCache[key];
         }
 
-        var axisOptions = categoryAxis.options;
-        var srcCategories = axisOptions.srcCategories;
-        var dateAxis = equalsIgnoreCase(axisOptions.type, DATE);
-        var srcData = series.data;
-        var result = [];
+        const axisOptions = categoryAxis.options;
+        const srcCategories = axisOptions.srcCategories;
+        const dateAxis = equalsIgnoreCase(axisOptions.type, DATE);
+        const srcData = series.data;
+        const result = [];
         if (!dateAxis) {
             categoryAxis.indexCategories();
         }
 
-        for (var idx = 0; idx < srcData.length; idx++) {
-            var category = SeriesBinder.current.bindPoint(series, idx).fields.category;
+        for (let idx = 0; idx < srcData.length; idx++) {
+            let category = SeriesBinder.current.bindPoint(series, idx).fields.category;
             if (dateAxis) {
-                category = parseDateCategory(category, srcData[idx], this$1.chartService.intl);
+                category = parseDateCategory(category, srcData[idx], this.chartService.intl);
             }
 
             if (!defined(category)) {
@@ -312,7 +293,7 @@ var CategoricalPlotArea = (function (PlotAreaBase) {
             }
 
             if (defined(category) && category !== null) {
-                var categoryIx = categoryAxis.totalIndex(category);
+                const categoryIx = categoryAxis.totalIndex(category);
                 result[categoryIx] = result[categoryIx] || { items: [], category: category };
                 result[categoryIx].items.push(idx);
             }
@@ -321,24 +302,24 @@ var CategoricalPlotArea = (function (PlotAreaBase) {
         this._currentPointsCache[key] = result;
 
         return result;
-    };
+    }
 
-    CategoricalPlotArea.prototype.aggregateSeries = function aggregateSeries (series, categoryAxis, range) {
-        var srcData = series.data;
+    aggregateSeries(series, categoryAxis, range) {
+        const srcData = series.data;
         if (!srcData.length) {
             return series;
         }
 
-        var srcPoints = this.seriesSourcePoints(series, categoryAxis);
-        var result = deepExtend({}, series);
-        var aggregator = new SeriesAggregator(deepExtend({}, series), SeriesBinder.current, DefaultAggregates.current);
-        var data = result.data = [];
+        const srcPoints = this.seriesSourcePoints(series, categoryAxis);
+        const result = deepExtend({}, series);
+        const aggregator = new SeriesAggregator(deepExtend({}, series), SeriesBinder.current, DefaultAggregates.current);
+        const data = result.data = [];
 
-        var dataItems = categoryAxis.options.dataItems || [];
+        const dataItems = categoryAxis.options.dataItems || [];
 
-        var categoryItem = function (idx) {
-            var categoryIdx = idx - range.min;
-            var point = srcPoints[idx];
+        const categoryItem = (idx) => {
+            const categoryIdx = idx - range.min;
+            let point = srcPoints[idx];
             if (!point) {
                 point = srcPoints[idx] = {};
             }
@@ -346,7 +327,7 @@ var CategoricalPlotArea = (function (PlotAreaBase) {
             point.categoryIx = categoryIdx;
 
             if (!point.item) {
-                var category = categoryAxis.categoryAt(idx, true);
+                const category = categoryAxis.categoryAt(idx, true);
                 point.category = category;
                 point.item = aggregator.aggregatePoints(point.items, category);
             }
@@ -354,8 +335,8 @@ var CategoricalPlotArea = (function (PlotAreaBase) {
             return point;
         };
 
-        for (var idx = range.min; idx <= range.max; idx++) {
-            var point = categoryItem(idx);
+        for (let idx = range.min; idx <= range.max; idx++) {
+            const point = categoryItem(idx);
             data[point.categoryIx] = point.item;
 
             if (point.items && point.items.length) {
@@ -364,19 +345,19 @@ var CategoricalPlotArea = (function (PlotAreaBase) {
         }
 
         if (inArray(result.type, OUT_OF_RANGE_SERIES)) {
-            createOutOfRangePoints(result, range, categoryAxis.totalCount(), categoryItem, function (idx) { return srcPoints[idx]; });
+            createOutOfRangePoints(result, range, categoryAxis.totalCount(), categoryItem, (idx) => srcPoints[idx]);
         }
 
         categoryAxis.options.dataItems = dataItems;
 
         return result;
-    };
+    }
 
-    CategoricalPlotArea.prototype.appendChart = function appendChart (chart, pane) {
-        var series = chart.options.series;
-        var categoryAxis = this.seriesCategoryAxis(series[0]);
-        var categories = categoryAxis.options.categories;
-        var categoriesToAdd = Math.max(0, categoriesCount(series) - categories.length);
+    appendChart(chart, pane) {
+        const series = chart.options.series;
+        const categoryAxis = this.seriesCategoryAxis(series[0]);
+        let categories = categoryAxis.options.categories;
+        let categoriesToAdd = Math.max(0, categoriesCount(series) - categories.length);
 
         if (categoriesToAdd > 0) {//consider setting an option to axis instead of adding fake categories
             categories = categoryAxis.options.categories = categoryAxis.options.categories.slice(0);
@@ -387,37 +368,37 @@ var CategoricalPlotArea = (function (PlotAreaBase) {
 
         this.valueAxisRangeTracker.update(chart.valueAxisRanges);
 
-        PlotAreaBase.prototype.appendChart.call(this, chart, pane);
-    };
+        super.appendChart(chart, pane);
+    }
 
     // TODO: Refactor, optionally use series.pane option
-    CategoricalPlotArea.prototype.seriesPaneName = function seriesPaneName (series) {
-        var options = this.options;
-        var axisName = series.axis;
-        var axisOptions = [].concat(options.valueAxis);
-        var axis = grep(axisOptions, function(a) { return a.name === axisName; })[0];
-        var panes = options.panes || [ {} ];
-        var defaultPaneName = (panes[0] || {}).name || "default";
-        var paneName = (axis || {}).pane || defaultPaneName;
+    seriesPaneName(series) {
+        const options = this.options;
+        const axisName = series.axis;
+        const axisOptions = [].concat(options.valueAxis);
+        const axis = grep(axisOptions, function(a) { return a.name === axisName; })[0];
+        const panes = options.panes || [ {} ];
+        const defaultPaneName = (panes[0] || {}).name || "default";
+        const paneName = (axis || {}).pane || defaultPaneName;
 
         return paneName;
-    };
+    }
 
-    CategoricalPlotArea.prototype.seriesCategoryAxis = function seriesCategoryAxis (series) {
-        var axisName = series.categoryAxis;
-        var axis = axisName ? this.namedCategoryAxes[axisName] : this.categoryAxis;
+    seriesCategoryAxis(series) {
+        const axisName = series.categoryAxis;
+        const axis = axisName ? this.namedCategoryAxes[axisName] : this.categoryAxis;
 
         if (!axis) {
             throw new Error("Unable to locate category axis with name " + axisName);
         }
 
         return axis;
-    };
+    }
 
-    CategoricalPlotArea.prototype.stackableChartOptions = function stackableChartOptions (series, pane) {
-        var anyStackedSeries = series.some(function (s) { return s.stack; });
-        var isStacked100 = series.some(function (s) { return s.stack && s.stack.type === "100%"; });
-        var clip = pane.options.clip;
+    stackableChartOptions(series, pane) {
+        const anyStackedSeries = series.some(s => s.stack);
+        const isStacked100 = series.some(s => s.stack && s.stack.type === "100%");
+        const clip = pane.options.clip;
 
         return {
             defaultStack: series[0].stack,
@@ -425,23 +406,23 @@ var CategoricalPlotArea = (function (PlotAreaBase) {
             isStacked100: isStacked100,
             clip: clip
         };
-    };
+    }
 
-    CategoricalPlotArea.prototype.groupSeriesByCategoryAxis = function groupSeriesByCategoryAxis (series) {
-        var categoryAxes = [];
-        var unique = {};
-        for (var idx = 0; idx < series.length; idx++) {
-            var name = series[idx].categoryAxis || "$$default$$";
+    groupSeriesByCategoryAxis(series) {
+        const categoryAxes = [];
+        const unique = {};
+        for (let idx = 0; idx < series.length; idx++) {
+            const name = series[idx].categoryAxis || "$$default$$";
             if (!hasOwnProperty(unique, name)) {
                 unique[name] = true;
                 categoryAxes.push(name);
             }
         }
 
-        var groups = [];
-        for (var axisIx = 0; axisIx < categoryAxes.length; axisIx++) {
-            var axis = categoryAxes[axisIx];
-            var axisSeries = groupSeries(series, axis, axisIx);
+        const groups = [];
+        for (let axisIx = 0; axisIx < categoryAxes.length; axisIx++) {
+            const axis = categoryAxes[axisIx];
+            const axisSeries = groupSeries(series, axis, axisIx);
             if (axisSeries.length === 0) {
                 continue;
             }
@@ -450,15 +431,15 @@ var CategoricalPlotArea = (function (PlotAreaBase) {
         }
 
         return groups;
-    };
+    }
 
-    CategoricalPlotArea.prototype.createBarChart = function createBarChart (series, pane) {
+    createBarChart(series, pane) {
         if (series.length === 0) {
             return;
         }
 
-        var firstSeries = series[0];
-        var barChart = new BarChart(this, Object.assign({
+        const firstSeries = series[0];
+        const barChart = new BarChart(this, Object.assign({
             series: series,
             invertAxes: this.invertAxes,
             gap: firstSeries.gap,
@@ -466,15 +447,15 @@ var CategoricalPlotArea = (function (PlotAreaBase) {
         }, this.stackableChartOptions(series, pane)));
 
         this.appendChart(barChart, pane);
-    };
+    }
 
-    CategoricalPlotArea.prototype.createRangeBarChart = function createRangeBarChart (series, pane) {
+    createRangeBarChart(series, pane) {
         if (series.length === 0) {
             return;
         }
 
-        var firstSeries = series[0];
-        var rangeColumnChart = new RangeBarChart(this, {
+        const firstSeries = series[0];
+        const rangeColumnChart = new RangeBarChart(this, {
             series: series,
             invertAxes: this.invertAxes,
             gap: firstSeries.gap,
@@ -482,15 +463,15 @@ var CategoricalPlotArea = (function (PlotAreaBase) {
         });
 
         this.appendChart(rangeColumnChart, pane);
-    };
+    }
 
-    CategoricalPlotArea.prototype.createBulletChart = function createBulletChart (series, pane) {
+    createBulletChart(series, pane) {
         if (series.length === 0) {
             return;
         }
 
-        var firstSeries = series[0];
-        var bulletChart = new BulletChart(this, {
+        const firstSeries = series[0];
+        const bulletChart = new BulletChart(this, {
             series: series,
             invertAxes: this.invertAxes,
             gap: firstSeries.gap,
@@ -499,55 +480,55 @@ var CategoricalPlotArea = (function (PlotAreaBase) {
         });
 
         this.appendChart(bulletChart, pane);
-    };
+    }
 
-    CategoricalPlotArea.prototype.createLineChart = function createLineChart (series, pane) {
+    createLineChart(series, pane) {
         if (series.length === 0) {
             return;
         }
 
-        var lineChart = new LineChart(this, Object.assign({
+        const lineChart = new LineChart(this, Object.assign({
             invertAxes: this.invertAxes,
             series: series
         }, this.stackableChartOptions(series, pane)));
 
         this.appendChart(lineChart, pane);
-    };
+    }
 
-    CategoricalPlotArea.prototype.createAreaChart = function createAreaChart (series, pane) {
+    createAreaChart(series, pane) {
         if (series.length === 0) {
             return;
         }
 
-        var areaChart = new AreaChart(this, Object.assign({
+        const areaChart = new AreaChart(this, Object.assign({
             invertAxes: this.invertAxes,
             series: series
         }, this.stackableChartOptions(series, pane)));
 
         this.appendChart(areaChart, pane);
-    };
+    }
 
-    CategoricalPlotArea.prototype.createRangeAreaChart = function createRangeAreaChart (series, pane) {
+    createRangeAreaChart(series, pane) {
         if (series.length === 0) {
             return;
         }
 
-        var rangeAreaChart = new RangeAreaChart(this, {
+        const rangeAreaChart = new RangeAreaChart(this, {
             invertAxes: this.invertAxes,
             series: series,
             clip: pane.options.clip
         });
 
         this.appendChart(rangeAreaChart, pane);
-    };
+    }
 
-    CategoricalPlotArea.prototype.createOHLCChart = function createOHLCChart (series, pane) {
+    createOHLCChart(series, pane) {
         if (series.length === 0) {
             return;
         }
 
-        var firstSeries = series[0];
-        var chart = new OHLCChart(this, {
+        const firstSeries = series[0];
+        const chart = new OHLCChart(this, {
             invertAxes: this.invertAxes,
             gap: firstSeries.gap,
             series: series,
@@ -556,15 +537,15 @@ var CategoricalPlotArea = (function (PlotAreaBase) {
         });
 
         this.appendChart(chart, pane);
-    };
+    }
 
-    CategoricalPlotArea.prototype.createCandlestickChart = function createCandlestickChart (series, pane) {
+    createCandlestickChart(series, pane) {
         if (series.length === 0) {
             return;
         }
 
-        var firstSeries = series[0];
-        var chart = new CandlestickChart(this, {
+        const firstSeries = series[0];
+        const chart = new CandlestickChart(this, {
             invertAxes: this.invertAxes,
             gap: firstSeries.gap,
             series: series,
@@ -573,15 +554,15 @@ var CategoricalPlotArea = (function (PlotAreaBase) {
         });
 
         this.appendChart(chart, pane);
-    };
+    }
 
-    CategoricalPlotArea.prototype.createBoxPlotChart = function createBoxPlotChart (series, pane) {
+    createBoxPlotChart(series, pane) {
         if (series.length === 0) {
             return;
         }
 
-        var firstSeries = series[0];
-        var chart = new BoxPlotChart(this, {
+        const firstSeries = series[0];
+        const chart = new BoxPlotChart(this, {
             invertAxes: this.invertAxes,
             gap: firstSeries.gap,
             series: series,
@@ -590,15 +571,15 @@ var CategoricalPlotArea = (function (PlotAreaBase) {
         });
 
         this.appendChart(chart, pane);
-    };
+    }
 
-    CategoricalPlotArea.prototype.createWaterfallChart = function createWaterfallChart (series, pane) {
+    createWaterfallChart(series, pane) {
         if (series.length === 0) {
             return;
         }
 
-        var firstSeries = series[0];
-        var waterfallChart = new WaterfallChart(this, {
+        const firstSeries = series[0];
+        const waterfallChart = new WaterfallChart(this, {
             series: series,
             invertAxes: this.invertAxes,
             gap: firstSeries.gap,
@@ -606,104 +587,99 @@ var CategoricalPlotArea = (function (PlotAreaBase) {
         });
 
         this.appendChart(waterfallChart, pane);
-    };
-
-    CategoricalPlotArea.prototype.axisRequiresRounding = function axisRequiresRounding (categoryAxisName, categoryAxisIndex) {
-        var this$1 = this;
+    }
 
-        var centeredSeries = filterSeriesByType(this.series, EQUALLY_SPACED_SERIES);
+    axisRequiresRounding(categoryAxisName, categoryAxisIndex) {
+        const centeredSeries = filterSeriesByType(this.series, EQUALLY_SPACED_SERIES);
 
-        for (var seriesIx = 0; seriesIx < this.series.length; seriesIx++) {
-            var currentSeries = this$1.series[seriesIx];
+        for (let seriesIx = 0; seriesIx < this.series.length; seriesIx++) {
+            const currentSeries = this.series[seriesIx];
             if (inArray(currentSeries.type, AREA_SERIES)) {
-                var line = currentSeries.line;
+                const line = currentSeries.line;
                 if (line && line.style === STEP) {
                     centeredSeries.push(currentSeries);
                 }
             }
         }
 
-        for (var seriesIx$1 = 0; seriesIx$1 < centeredSeries.length; seriesIx$1++) {
-            var seriesAxis = centeredSeries[seriesIx$1].categoryAxis || "";
+        for (let seriesIx = 0; seriesIx < centeredSeries.length; seriesIx++) {
+            const seriesAxis = centeredSeries[seriesIx].categoryAxis || "";
             if (seriesAxis === categoryAxisName || (!seriesAxis && categoryAxisIndex === 0)) {
                 return true;
             }
         }
-    };
+    }
 
-    CategoricalPlotArea.prototype.aggregatedAxis = function aggregatedAxis (categoryAxisName, categoryAxisIndex) {
-        var series = this.series;
+    aggregatedAxis(categoryAxisName, categoryAxisIndex) {
+        const series = this.series;
 
-        for (var seriesIx = 0; seriesIx < series.length; seriesIx++) {
-            var seriesAxis = series[seriesIx].categoryAxis || "";
+        for (let seriesIx = 0; seriesIx < series.length; seriesIx++) {
+            const seriesAxis = series[seriesIx].categoryAxis || "";
             if ((seriesAxis === categoryAxisName || (!seriesAxis && categoryAxisIndex === 0)) && series[seriesIx].categoryField) {
                 return true;
             }
         }
-    };
+    }
 
-    CategoricalPlotArea.prototype.createCategoryAxesLabels = function createCategoryAxesLabels () {
-        var axes = this.axes;
-        for (var i = 0; i < axes.length; i++) {
+    createCategoryAxesLabels() {
+        const axes = this.axes;
+        for (let i = 0; i < axes.length; i++) {
             if (axes[i] instanceof CategoryAxis) {
                 axes[i].createLabels();
             }
         }
-    };
-
-    CategoricalPlotArea.prototype.createCategoryAxes = function createCategoryAxes (panes) {
-        var this$1 = this;
+    }
 
-        var invertAxes = this.invertAxes;
-        var definitions = [].concat(this.options.categoryAxis);
-        var axes = [];
+    createCategoryAxes(panes) {
+        const invertAxes = this.invertAxes;
+        const definitions = [].concat(this.options.categoryAxis);
+        const axes = [];
 
-        for (var i = 0; i < definitions.length; i++) {
-            var axisOptions = definitions[i];
-            var axisPane = this$1.findPane(axisOptions.pane);
+        for (let i = 0; i < definitions.length; i++) {
+            let axisOptions = definitions[i];
+            const axisPane = this.findPane(axisOptions.pane);
 
             if (inArray(axisPane, panes)) {
-                var name = axisOptions.name;
-                var categories = axisOptions.categories; if ( categories === void 0 ) categories = [];
+                const { name, categories = [] } = axisOptions;
                 axisOptions = deepExtend({
                     vertical: invertAxes,
-                    reverse: !invertAxes && this$1.chartService.rtl,
+                    reverse: !invertAxes && this.chartService.rtl,
                     axisCrossingValue: invertAxes ? MAX_VALUE : 0
                 }, axisOptions);
 
                 if (!defined(axisOptions.justified)) {
-                    axisOptions.justified = this$1.isJustified();
+                    axisOptions.justified = this.isJustified();
                 }
 
-                if (this$1.axisRequiresRounding(name, i)) {
+                if (this.axisRequiresRounding(name, i)) {
                     axisOptions.justified = false;
                 }
 
-                var categoryAxis = (void 0);
+                let categoryAxis;
 
                 if (isDateAxis(axisOptions, categories[0])) {
-                    axisOptions._forecast = this$1.trendlineAggregateForecast();
-                    categoryAxis = new DateCategoryAxis(axisOptions, this$1.chartService);
+                    axisOptions._forecast = this.trendlineAggregateForecast();
+                    categoryAxis = new DateCategoryAxis(axisOptions, this.chartService);
                 } else {
-                    categoryAxis = new CategoryAxis(axisOptions, this$1.chartService);
+                    categoryAxis = new CategoryAxis(axisOptions, this.chartService);
                 }
 
                 definitions[i].categories = categoryAxis.options.srcCategories;
 
                 if (name) {
-                    if (this$1.namedCategoryAxes[name]) {
-                        throw new Error(("Category axis with name " + name + " is already defined"));
+                    if (this.namedCategoryAxes[name]) {
+                        throw new Error(`Category axis with name ${ name } is already defined`);
                     }
-                    this$1.namedCategoryAxes[name] = categoryAxis;
+                    this.namedCategoryAxes[name] = categoryAxis;
                 }
 
                 categoryAxis.axisIndex = i;
                 axes.push(categoryAxis);
-                this$1.appendAxis(categoryAxis);
+                this.appendAxis(categoryAxis);
             }
         }
 
-        var primaryAxis = this.categoryAxis || axes[0];
+        const primaryAxis = this.categoryAxis || axes[0];
         this.categoryAxis = primaryAxis;
 
         if (invertAxes) {
@@ -711,76 +687,74 @@ var CategoricalPlotArea = (function (PlotAreaBase) {
         } else {
             this.axisX = primaryAxis;
         }
-    };
+    }
 
-    CategoricalPlotArea.prototype.isJustified = function isJustified () {
-        var series = this.series;
+    isJustified() {
+        const series = this.series;
 
-        for (var i = 0; i < series.length; i++) {
-            var currentSeries = series[i];
+        for (let i = 0; i < series.length; i++) {
+            const currentSeries = series[i];
             if (!inArray(currentSeries.type, AREA_SERIES)) {
                 return false;
             }
         }
 
         return true;
-    };
-
-    CategoricalPlotArea.prototype.createValueAxes = function createValueAxes (panes) {
-        var this$1 = this;
+    }
 
-        var tracker = this.valueAxisRangeTracker;
-        var defaultRange = tracker.query();
-        var definitions = [].concat(this.options.valueAxis);
-        var invertAxes = this.invertAxes;
-        var baseOptions = { vertical: !invertAxes, reverse: invertAxes && this.chartService.rtl };
-        var axes = [];
+    createValueAxes(panes) {
+        const tracker = this.valueAxisRangeTracker;
+        const defaultRange = tracker.query();
+        const definitions = [].concat(this.options.valueAxis);
+        const invertAxes = this.invertAxes;
+        const baseOptions = { vertical: !invertAxes, reverse: invertAxes && this.chartService.rtl };
+        const axes = [];
 
         if (this.stack100) {
             baseOptions.roundToMajorUnit = false;
             baseOptions.labels = { format: "P0" };
         }
 
-        for (var i = 0; i < definitions.length; i++) {
-            var axisOptions = definitions[i];
-            var axisPane = this$1.findPane(axisOptions.pane);
+        for (let i = 0; i < definitions.length; i++) {
+            const axisOptions = definitions[i];
+            const axisPane = this.findPane(axisOptions.pane);
 
             if (inArray(axisPane, panes)) {
-                var name = axisOptions.name;
-                var defaultAxisRange = equalsIgnoreCase(axisOptions.type, LOGARITHMIC) ? { min: 0.1, max: 1 } : { min: 0, max: 1 };
-                var range = tracker.query(name) || defaultRange || defaultAxisRange;
+                const name = axisOptions.name;
+                const defaultAxisRange = equalsIgnoreCase(axisOptions.type, LOGARITHMIC) ? { min: 0.1, max: 1 } : { min: 0, max: 1 };
+                const range = tracker.query(name) || defaultRange || defaultAxisRange;
 
                 if (i === 0 && range && defaultRange) {
                     range.min = Math.min(range.min, defaultRange.min);
                     range.max = Math.max(range.max, defaultRange.max);
                 }
 
-                var axisType = (void 0);
+                let axisType;
                 if (equalsIgnoreCase(axisOptions.type, LOGARITHMIC)) {
                     axisType = LogarithmicAxis;
                 } else {
                     axisType = NumericAxis;
                 }
 
-                var valueAxis = new axisType(range.min, range.max,
+                const valueAxis = new axisType(range.min, range.max,
                     deepExtend({}, baseOptions, axisOptions),
-                    this$1.chartService
+                    this.chartService
                 );
 
                 if (name) {
-                    if (this$1.namedValueAxes[name]) {
-                        throw new Error(("Value axis with name " + name + " is already defined"));
+                    if (this.namedValueAxes[name]) {
+                        throw new Error(`Value axis with name ${ name } is already defined`);
                     }
-                    this$1.namedValueAxes[name] = valueAxis;
+                    this.namedValueAxes[name] = valueAxis;
                 }
                 valueAxis.axisIndex = i;
 
                 axes.push(valueAxis);
-                this$1.appendAxis(valueAxis);
+                this.appendAxis(valueAxis);
             }
         }
 
-        var primaryAxis = this.valueAxis || axes[0];
+        const primaryAxis = this.valueAxis || axes[0];
         this.valueAxis = primaryAxis;
 
         if (invertAxes) {
@@ -788,22 +762,22 @@ var CategoricalPlotArea = (function (PlotAreaBase) {
         } else {
             this.axisY = primaryAxis;
         }
-    };
+    }
 
-    CategoricalPlotArea.prototype._dispatchEvent = function _dispatchEvent (chart, e, eventType) {
-        var coords = chart._eventCoordinates(e);
-        var point = new Point(coords.x, coords.y);
-        var pane = this.pointPane(point);
-        var categories = [];
-        var values = [];
+    _dispatchEvent(chart, e, eventType) {
+        const coords = chart._eventCoordinates(e);
+        const point = new Point(coords.x, coords.y);
+        const pane = this.pointPane(point);
+        const categories = [];
+        const values = [];
 
         if (!pane) {
             return;
         }
 
-        var allAxes = pane.axes;
-        for (var i = 0; i < allAxes.length; i++) {
-            var axis = allAxes[i];
+        const allAxes = pane.axes;
+        for (let i = 0; i < allAxes.length; i++) {
+            const axis = allAxes[i];
             if (axis.getValue) {
                 appendIfNotNull(values, axis.getValue(point));
             } else {
@@ -823,103 +797,96 @@ var CategoricalPlotArea = (function (PlotAreaBase) {
                 value: singleItemOrArray(values)
             });
         }
-    };
+    }
 
-    CategoricalPlotArea.prototype.pointPane = function pointPane (point) {
-        var panes = this.panes;
+    pointPane(point) {
+        const panes = this.panes;
 
-        for (var i = 0; i < panes.length; i++) {
-            var currentPane = panes[i];
+        for (let i = 0; i < panes.length; i++) {
+            const currentPane = panes[i];
             if (currentPane.contentBox.containsPoint(point)) {
                 return currentPane;
             }
         }
-    };
+    }
 
-    CategoricalPlotArea.prototype.updateAxisOptions = function updateAxisOptions$1 (axis, options) {
+    updateAxisOptions(axis, options) {
         updateAxisOptions(this.options, axis, options);
         updateAxisOptions(this.originalOptions, axis, options);
-    };
-
-    CategoricalPlotArea.prototype._pointsByVertical = function _pointsByVertical (basePoint, offset) {
-        if ( offset === void 0 ) offset = 0;
+    }
 
+    _pointsByVertical(basePoint, offset = 0) {
         if (this.invertAxes) {
             return this._siblingsBySeriesIndex(basePoint.series.index, offset);
         }
 
         return this._siblingsByPointIndex(basePoint.getIndex());
-    };
-
-    CategoricalPlotArea.prototype._pointsByHorizontal = function _pointsByHorizontal (basePoint, offset) {
-        if ( offset === void 0 ) offset = 0;
+    }
 
+    _pointsByHorizontal(basePoint, offset = 0) {
         if (this.invertAxes) {
             return this._siblingsByPointIndex(basePoint.getIndex());
         }
 
-        var siblings = this._siblingsBySeriesIndex(basePoint.series.index, offset);
+        const siblings = this._siblingsBySeriesIndex(basePoint.series.index, offset);
 
         if (this.chartService.rtl) {
             return siblings.reverse();
         }
 
         return siblings;
-    };
-
-    CategoricalPlotArea.prototype._siblingsByPointIndex = function _siblingsByPointIndex (pointIndex) {
-        var this$1 = this;
+    }
 
-        var charts = this.charts;
-        var result = [];
+    _siblingsByPointIndex(pointIndex) {
+        const charts = this.charts;
+        const result = [];
 
-        for (var i = 0; i < charts.length; i++) {
-            var chart = charts[i];
+        for (let i = 0; i < charts.length; i++) {
+            let chart = charts[i];
 
             if (chart.pane && chart.pane.options.name === "_navigator") {
                 continue;
             }
 
-            var chartPoints = chart.points
-                .filter(function (point) { return point && point.visible !== false && point.getIndex() === pointIndex; }
+            let chartPoints = chart.points
+                .filter(point =>
+                    point && point.visible !== false && point.getIndex() === pointIndex
                 );
 
-            result.push.apply(result, chartPoints.sort(this$1._getSeriesCompareFn(chartPoints[0])));
+            result.push(...chartPoints.sort(this._getSeriesCompareFn(chartPoints[0])));
         }
 
         return result;
-    };
+    }
 
-    CategoricalPlotArea.prototype._siblingsBySeriesIndex = function _siblingsBySeriesIndex (seriesIndex, offset) {
-        var index = cycleIndex(seriesIndex + offset, this.series.length);
+    _siblingsBySeriesIndex(seriesIndex, offset) {
+        const index = cycleIndex(seriesIndex + offset, this.series.length);
 
         return this.pointsBySeriesIndex(index);
-    };
+    }
 
-    CategoricalPlotArea.prototype._getSeriesCompareFn = function _getSeriesCompareFn (point) {
-        var isStacked = this._isInStackedSeries(point);
+    _getSeriesCompareFn(point) {
+        const isStacked = this._isInStackedSeries(point);
 
         if (isStacked && this.invertAxes || !isStacked && !this.invertAxes) {
-            return function (a, b) { return a.box.center().x - b.box.center().x; };
+            return (a, b) => a.box.center().x - b.box.center().x;
         }
 
-        return function (a, b) { return a.box.center().y - b.box.center().y; };
-    };
+        return (a, b) => a.box.center().y - b.box.center().y;
+    }
 
-    CategoricalPlotArea.prototype._isInStackedSeries = function _isInStackedSeries (point) {
-        var sortableSeries = inArray(point.series.type,
+    _isInStackedSeries(point) {
+        const sortableSeries = inArray(point.series.type,
             [ AREA, VERTICAL_AREA, RANGE_AREA, VERTICAL_RANGE_AREA, LINE, VERTICAL_LINE, RADAR_LINE, RADAR_AREA]);
 
-        var stackableSeries = inArray(point.series.type, [ COLUMN, BAR]);
+        const stackableSeries = inArray(point.series.type, [ COLUMN, BAR]);
 
         return sortableSeries || stackableSeries && point.options.isStacked;
-    };
-
-    return CategoricalPlotArea;
-}(PlotAreaBase));
+    }
+}
 
 function updateAxisOptions(targetOptions, axis, options) {
-    var axesOptions = axis instanceof CategoryAxis ? [].concat(targetOptions.categoryAxis) : [].concat(targetOptions.valueAxis);
+    const axesOptions = axis instanceof CategoryAxis ? [].concat(targetOptions.categoryAxis) : [].concat(targetOptions.valueAxis);
     deepExtend(axesOptions[axis.axisIndex], options);
 }