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

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

@@ -17,71 +17,60 @@ import { SCATTER, SCATTER_LINE, BUBBLE, LOGARITHMIC } from '../constants';
 import { DATE } from '../../common/constants';
 import { deepExtend, eventElement, grep, inArray, setDefaultOptions } from '../../common';
 
-var XYPlotArea = (function (PlotAreaBase) {
-    function XYPlotArea () {
-        PlotAreaBase.apply(this, arguments);
-    }
-
-    if ( PlotAreaBase ) XYPlotArea.__proto__ = PlotAreaBase;
-    XYPlotArea.prototype = Object.create( PlotAreaBase && PlotAreaBase.prototype );
-    XYPlotArea.prototype.constructor = XYPlotArea;
-
-    XYPlotArea.prototype.initFields = function initFields () {
+class XYPlotArea extends PlotAreaBase {
+    initFields() {
         this.namedXAxes = {};
         this.namedYAxes = {};
 
         this.xAxisRangeTracker = new AxisGroupRangeTracker();
         this.yAxisRangeTracker = new AxisGroupRangeTracker();
-    };
-
-    XYPlotArea.prototype.render = function render (panes) {
-        var this$1 = this;
-        if ( panes === void 0 ) panes = this.panes;
+    }
 
-        this.series = [].concat( this.originalSeries );
+    render(panes = this.panes) {
+        this.series = [...this.originalSeries];
         this.createTrendlineSeries();
 
-        var 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);
+        const seriesByPane = this.groupSeriesByPane();
+        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.createScatterChart(
+            this.createScatterChart(
                 filterSeriesByType(filteredSeries, SCATTER),
                 pane
             );
 
-            this$1.createScatterLineChart(
+            this.createScatterLineChart(
                 filterSeriesByType(filteredSeries, SCATTER_LINE),
                 pane
             );
 
-            this$1.createBubbleChart(
+            this.createBubbleChart(
                 filterSeriesByType(filteredSeries, BUBBLE),
                 pane
             );
         }
 
         this.createAxes(panes);
-    };
+    }
 
-    XYPlotArea.prototype.appendChart = function appendChart (chart, pane) {
+    appendChart(chart, pane) {
         this.xAxisRangeTracker.update(chart.xAxisRanges);
         this.yAxisRangeTracker.update(chart.yAxisRanges);
 
-        PlotAreaBase.prototype.appendChart.call(this, chart, pane);
-    };
+        super.appendChart(chart, pane);
+    }
 
-    XYPlotArea.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) {
             this.yAxisRangeTracker.reset(axisName);
@@ -98,68 +87,68 @@ var XYPlotArea = (function (PlotAreaBase) {
         if (axis === this.axisY) {
             delete this.axisY;
         }
-    };
+    }
 
     // TODO: Refactor, optionally use series.pane option
-    XYPlotArea.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;
-    };
+    }
 
-    XYPlotArea.prototype.createScatterChart = function createScatterChart (series, pane) {
+    createScatterChart(series, pane) {
         if (series.length > 0) {
             this.appendChart(
                 new ScatterChart(this, { series: series, clip: pane.options.clip }),
                 pane
             );
         }
-    };
+    }
 
-    XYPlotArea.prototype.createScatterLineChart = function createScatterLineChart (series, pane) {
+    createScatterLineChart(series, pane) {
         if (series.length > 0) {
             this.appendChart(
                 new ScatterLineChart(this, { series: series, clip: pane.options.clip }),
                 pane
             );
         }
-    };
+    }
 
-    XYPlotArea.prototype.createBubbleChart = function createBubbleChart (series, pane) {
+    createBubbleChart(series, pane) {
         if (series.length > 0) {
             this.appendChart(
                 new BubbleChart(this, { series: series, clip: pane.options.clip }),
                 pane
             );
         }
-    };
-
-    XYPlotArea.prototype.createXYAxis = function createXYAxis (options, vertical, axisIndex) {
-        var axisName = options.name;
-        var namedAxes = vertical ? this.namedYAxes : this.namedXAxes;
-        var tracker = vertical ? this.yAxisRangeTracker : this.xAxisRangeTracker;
-        var axisOptions = deepExtend({ reverse: !vertical && this.chartService.rtl }, options, { vertical: vertical });
-        var isLog = equalsIgnoreCase(axisOptions.type, LOGARITHMIC);
-        var defaultRange = tracker.query();
-        var defaultAxisRange = isLog ? { min: 0.1, max: 1 } : { min: 0, max: 1 };
-        var range = tracker.query(axisName) || defaultRange || defaultAxisRange;
-        var typeSamples = [ axisOptions.min, axisOptions.max ];
-        var series = this.series;
-
-        for (var seriesIx = 0; seriesIx < series.length; seriesIx++) {
-            var currentSeries = series[seriesIx];
-            var seriesAxisName = currentSeries[vertical ? "yAxis" : "xAxis"];
+    }
+
+    createXYAxis(options, vertical, axisIndex) {
+        const axisName = options.name;
+        const namedAxes = vertical ? this.namedYAxes : this.namedXAxes;
+        const tracker = vertical ? this.yAxisRangeTracker : this.xAxisRangeTracker;
+        const axisOptions = deepExtend({ reverse: !vertical && this.chartService.rtl }, options, { vertical: vertical });
+        const isLog = equalsIgnoreCase(axisOptions.type, LOGARITHMIC);
+        const defaultRange = tracker.query();
+        const defaultAxisRange = isLog ? { min: 0.1, max: 1 } : { min: 0, max: 1 };
+        const range = tracker.query(axisName) || defaultRange || defaultAxisRange;
+        const typeSamples = [ axisOptions.min, axisOptions.max ];
+        const series = this.series;
+
+        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;
@@ -171,16 +160,16 @@ var XYPlotArea = (function (PlotAreaBase) {
             range.max = Math.max(range.max, defaultRange.max);
         }
 
-        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 = DateValueAxis;
         } else if (isLog) {
@@ -189,12 +178,12 @@ var XYPlotArea = (function (PlotAreaBase) {
             axisType = NumericAxis;
         }
 
-        var axis = new axisType(range.min, range.max, axisOptions, this.chartService);
+        const axis = new axisType(range.min, range.max, 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;
         }
@@ -202,47 +191,45 @@ var XYPlotArea = (function (PlotAreaBase) {
         this.appendAxis(axis);
 
         return axis;
-    };
-
-    XYPlotArea.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];
-    };
-
-    XYPlotArea.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;
-            var currentValue = axis.getValue(point);
+    }
+
+    _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;
+            const currentValue = axis.getValue(point);
             if (currentValue !== null) {
                 values.push(currentValue);
             }
@@ -256,23 +243,23 @@ var XYPlotArea = (function (PlotAreaBase) {
                 y: singleItemOrArray(yValues)
             });
         }
-    };
+    }
 
-    XYPlotArea.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);
-    };
+    }
 
-    XYPlotArea.prototype.trendlineFactory = function trendlineFactory$1 (options, series) {
-        var seriesValues = this.seriesValues.bind(this, series.index);
+    trendlineFactory(options, series) {
+        const seriesValues = this.seriesValues.bind(this, series.index);
 
-        var trendline = trendlineFactory(scatterTrendlineRegistry, options.type, {
-            options: options,
-            seriesValues: seriesValues
+        const trendline = trendlineFactory(scatterTrendlineRegistry, options.type, {
+            options,
+            seriesValues
         });
 
         if (trendline) {
@@ -282,27 +269,23 @@ var XYPlotArea = (function (PlotAreaBase) {
         }
 
         return trendline;
-    };
-
-    XYPlotArea.prototype.seriesValues = function seriesValues (seriesIx) {
-        var this$1 = this;
+    }
 
-        var result = [];
-        var currentSeries = this.series[seriesIx];
+    seriesValues(seriesIx) {
+        const result = [];
+        const currentSeries = this.series[seriesIx];
 
-        for (var pointIx = 0; pointIx < currentSeries.data.length; pointIx++) {
-            var data = this$1.bindPoint(currentSeries, pointIx);
-            result.push({ pointIx: pointIx, valueFields: data.valueFields });
+        for (let pointIx = 0; pointIx < currentSeries.data.length; pointIx++) {
+            const data = this.bindPoint(currentSeries, pointIx);
+            result.push({ pointIx, valueFields: data.valueFields });
         }
 
         return result;
-    };
-
-    return XYPlotArea;
-}(PlotAreaBase));
+    }
+}
 
 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/polar-area-chart/polar-area-chart.js

@@ -6,18 +6,10 @@ import { SMOOTH, INTERPOLATE, ZERO, GAP } from '../constants';
 
 import hasValue from '../utils/has-value';
 
-var PolarAreaChart = (function (PolarLineChart) {
-    function PolarAreaChart () {
-        PolarLineChart.apply(this, arguments);
-    }
-
-    if ( PolarLineChart ) PolarAreaChart.__proto__ = PolarLineChart;
-    PolarAreaChart.prototype = Object.create( PolarLineChart && PolarLineChart.prototype );
-    PolarAreaChart.prototype.constructor = PolarAreaChart;
-
-    PolarAreaChart.prototype.createSegment = function createSegment (linePoints, currentSeries, seriesIx) {
-        var style = (currentSeries.line || {}).style;
-        var segment;
+class PolarAreaChart extends PolarLineChart {
+    createSegment(linePoints, currentSeries, seriesIx) {
+        const style = (currentSeries.line || {}).style;
+        let segment;
 
         if (style === SMOOTH) {
             segment = new SplinePolarAreaSegment(linePoints, currentSeries, seriesIx);
@@ -25,10 +17,10 @@ var PolarAreaChart = (function (PolarLineChart) {
             segment = new PolarAreaSegment(linePoints, currentSeries, seriesIx);
         }
         return segment;
-    };
+    }
 
-    PolarAreaChart.prototype.createMissingValue = function createMissingValue (value, missingValues) {
-        var missingValue;
+    createMissingValue(value, missingValues) {
+        let missingValue;
 
         if (hasValue(value.x) && missingValues !== INTERPOLATE) {
             missingValue = {
@@ -41,35 +33,31 @@ var PolarAreaChart = (function (PolarLineChart) {
         }
 
         return missingValue;
-    };
+    }
 
-    PolarAreaChart.prototype.seriesMissingValues = function seriesMissingValues (series) {
+    seriesMissingValues(series) {
         return series.missingValues || ZERO;
-    };
-
-    PolarAreaChart.prototype._hasMissingValuesGap = function _hasMissingValuesGap () {
-        var this$1 = this;
+    }
 
-        var series = this.options.series;
+    _hasMissingValuesGap() {
+        const series = this.options.series;
 
-        for (var idx = 0; idx < series.length; idx++) {
-            if (this$1.seriesMissingValues(series[idx]) === GAP) {
+        for (let idx = 0; idx < series.length; idx++) {
+            if (this.seriesMissingValues(series[idx]) === GAP) {
                 return true;
             }
         }
-    };
-
-    PolarAreaChart.prototype.sortPoints = function sortPoints (points) {
-        var this$1 = this;
+    }
 
+    sortPoints(points) {
         points.sort(xComparer);
 
         if (this._hasMissingValuesGap()) {
-            for (var idx = 0; idx < points.length; idx++) {
-                var point = points[idx];
+            for (let idx = 0; idx < points.length; idx++) {
+                const point = points[idx];
                 if (point) {
-                    var value = point.value;
-                    if (!hasValue(value.y) && this$1.seriesMissingValues(point.series) === GAP) {
+                    const value = point.value;
+                    if (!hasValue(value.y) && this.seriesMissingValues(point.series) === GAP) {
                         delete points[idx];
                     }
                 }
@@ -77,10 +65,8 @@ var PolarAreaChart = (function (PolarLineChart) {
         }
 
         return points;
-    };
-
-    return PolarAreaChart;
-}(PolarLineChart));
+    }
+}
 
 function xComparer(a, b) {
     return a.value.x - b.value.x;

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

@@ -1,25 +1,15 @@
 import { geometry as geom } from '@progress/kendo-drawing';
 import AreaSegment from '../area-chart/area-segment';
 
-var PolarAreaSegment = (function (AreaSegment) {
-    function PolarAreaSegment () {
-        AreaSegment.apply(this, arguments);
-    }
-
-    if ( AreaSegment ) PolarAreaSegment.__proto__ = AreaSegment;
-    PolarAreaSegment.prototype = Object.create( AreaSegment && AreaSegment.prototype );
-    PolarAreaSegment.prototype.constructor = PolarAreaSegment;
-
-    PolarAreaSegment.prototype.fillToAxes = function fillToAxes (fillPath) {
-        var polarAxis = this.parent.plotArea.polarAxis;
-        var center = polarAxis.box.center();
-        var centerSegment = new geom.Segment([ center.x, center.y ]);
+class PolarAreaSegment extends AreaSegment {
+    fillToAxes(fillPath) {
+        const polarAxis = this.parent.plotArea.polarAxis;
+        const center = polarAxis.box.center();
+        const centerSegment = new geom.Segment([ center.x, center.y ]);
 
         fillPath.segments.unshift(centerSegment);
         fillPath.segments.push(centerSegment);
-    };
-
-    return PolarAreaSegment;
-}(AreaSegment));
+    }
+}
 
 export default PolarAreaSegment;

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

@@ -1,33 +1,25 @@
 import SplineAreaSegment from '../area-chart/spline-area-segment';
 import { CurveProcessor } from '../../core';
 
-var SplinePolarAreaSegment = (function (SplineAreaSegment) {
-    function SplinePolarAreaSegment () {
-        SplineAreaSegment.apply(this, arguments);
-    }
-
-    if ( SplineAreaSegment ) SplinePolarAreaSegment.__proto__ = SplineAreaSegment;
-    SplinePolarAreaSegment.prototype = Object.create( SplineAreaSegment && SplineAreaSegment.prototype );
-    SplinePolarAreaSegment.prototype.constructor = SplinePolarAreaSegment;
-
-    SplinePolarAreaSegment.prototype.fillToAxes = function fillToAxes (fillPath) {
-        var center = this._polarAxisCenter();
+class SplinePolarAreaSegment extends SplineAreaSegment {
+    fillToAxes(fillPath) {
+        const center = this._polarAxisCenter();
         fillPath.lineTo(center.x, center.y);
-    };
+    }
 
-    SplinePolarAreaSegment.prototype._polarAxisCenter = function _polarAxisCenter () {
-        var polarAxis = this.parent.plotArea.polarAxis;
-        var center = polarAxis.box.center();
+    _polarAxisCenter() {
+        const polarAxis = this.parent.plotArea.polarAxis;
+        const center = polarAxis.box.center();
         return center;
-    };
+    }
 
-    SplinePolarAreaSegment.prototype.strokeSegments = function strokeSegments () {
-        var segments = this._strokeSegments;
+    strokeSegments() {
+        let segments = this._strokeSegments;
 
         if (!segments) {
-            var center = this._polarAxisCenter();
-            var curveProcessor = new CurveProcessor(false);
-            var linePoints = this.points();
+            const center = this._polarAxisCenter();
+            const curveProcessor = new CurveProcessor(false);
+            const linePoints = this.points();
 
             linePoints.push(center);
             segments = this._strokeSegments = curveProcessor.process(linePoints);
@@ -35,9 +27,7 @@ var SplinePolarAreaSegment = (function (SplineAreaSegment) {
         }
 
         return segments;
-    };
-
-    return SplinePolarAreaSegment;
-}(SplineAreaSegment));
+    }
+}
 
 export default SplinePolarAreaSegment;

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

@@ -3,17 +3,8 @@ import PolarScatterChart from '../polar-scatter-chart/polar-scatter-chart';
 
 import { setDefaultOptions } from '../../common';
 
-var PolarLineChart = (function (ScatterLineChart) {
-    function PolarLineChart () {
-        ScatterLineChart.apply(this, arguments);
-    }if ( ScatterLineChart ) PolarLineChart.__proto__ = ScatterLineChart;
-    PolarLineChart.prototype = Object.create( ScatterLineChart && ScatterLineChart.prototype );
-    PolarLineChart.prototype.constructor = PolarLineChart;
-
-    
-
-    return PolarLineChart;
-}(ScatterLineChart));
+class PolarLineChart extends ScatterLineChart {
+}
 
 PolarLineChart.prototype.pointSlot = PolarScatterChart.prototype.pointSlot;
 

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

@@ -4,24 +4,14 @@ import { Point, Box } from '../../core';
 
 import { setDefaultOptions } from '../../common';
 
-var PolarScatterChart = (function (ScatterChart) {
-    function PolarScatterChart () {
-        ScatterChart.apply(this, arguments);
-    }
-
-    if ( ScatterChart ) PolarScatterChart.__proto__ = ScatterChart;
-    PolarScatterChart.prototype = Object.create( ScatterChart && ScatterChart.prototype );
-    PolarScatterChart.prototype.constructor = PolarScatterChart;
-
-    PolarScatterChart.prototype.pointSlot = function pointSlot (slotX, slotY) {
-        var valueRadius = slotX.center.y - slotY.y1;
-        var slot = Point.onCircle(slotX.center, slotX.startAngle, valueRadius);
+class PolarScatterChart extends ScatterChart {
+    pointSlot(slotX, slotY) {
+        const valueRadius = slotX.center.y - slotY.y1;
+        const slot = Point.onCircle(slotX.center, slotX.startAngle, valueRadius);
 
         return new Box(slot.x, slot.y, slot.x, slot.y);
-    };
-
-    return PolarScatterChart;
-}(ScatterChart));
+    }
+}
 
 setDefaultOptions(PolarScatterChart, {
     clip: false