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

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

@@ -11,10 +11,10 @@ import { deepExtend, isNumber, isString, defined, isFunction, setDefaultOptions
 import { X, Y, MIN_VALUE, MAX_VALUE } from '../../common/constants';
 import { parseDate } from '../../date-utils';
 
-var ScatterChart = (function (ChartElement) {
-    function ScatterChart(plotArea, options) {
+class ScatterChart extends ChartElement {
+    constructor(plotArea, options) {
 
-        ChartElement.call(this, options);
+        super(options);
 
         this.plotArea = plotArea;
         this.chartService = plotArea.chartService;
@@ -23,11 +23,7 @@ var ScatterChart = (function (ChartElement) {
         this.render();
     }
 
-    if ( ChartElement ) ScatterChart.__proto__ = ChartElement;
-    ScatterChart.prototype = Object.create( ChartElement && ChartElement.prototype );
-    ScatterChart.prototype.constructor = ScatterChart;
-
-    ScatterChart.prototype._initFields = function _initFields () {
+    _initFields() {
         // X and Y axis ranges grouped by name, e.g.:
         // primary: { min: 0, max: 1 }
         this.xAxisRanges = {};
@@ -37,25 +33,24 @@ var ScatterChart = (function (ChartElement) {
         this.seriesPoints = [];
         this.seriesOptions = [];
         this._evalSeries = [];
-    };
+    }
 
-    ScatterChart.prototype.render = function render () {
+    render() {
         this.traverseDataPoints(this.addValue.bind(this));
-    };
-
-    ScatterChart.prototype.addErrorBar = function addErrorBar (point, field, fields) {
-        var value = point.value[field];
-        var valueErrorField = field + "Value";
-        var lowField = field + "ErrorLow";
-        var highField = field + "ErrorHigh";
-        var seriesIx = fields.seriesIx;
-        var series = fields.series;
-        var errorBars = point.options.errorBars;
-        var lowValue = fields[lowField];
-        var highValue = fields[highField];
+    }
+
+    addErrorBar(point, field, fields) {
+        const value = point.value[field];
+        const valueErrorField = field + "Value";
+        const lowField = field + "ErrorLow";
+        const highField = field + "ErrorHigh";
+        const { seriesIx, series } = fields;
+        const errorBars = point.options.errorBars;
+        const lowValue = fields[lowField];
+        const highValue = fields[highField];
 
         if (isNumber(value)) {
-            var errorRange;
+            let errorRange;
             if (isNumber(lowValue) && isNumber(highValue)) {
                 errorRange = { low: lowValue, high: highValue };
             }
@@ -72,21 +67,19 @@ var ScatterChart = (function (ChartElement) {
                 this.addPointErrorBar(errorRange, point, field);
             }
         }
-    };
+    }
 
-    ScatterChart.prototype.addPointErrorBar = function addPointErrorBar (errorRange, point, field) {
-        var low = errorRange.low;
-        var high = errorRange.high;
-        var series = point.series;
-        var options = point.options.errorBars;
-        var isVertical = field === Y;
-        var item = {};
+    addPointErrorBar(errorRange, point, field) {
+        const { low, high } = errorRange;
+        const { series, options: { errorBars: options } } = point;
+        const isVertical = field === Y;
+        const item = {};
 
         point[field + "Low"] = low;
         point[field + "High"] = high;
 
         point.errorBars = point.errorBars || [];
-        var errorBar = new ScatterErrorBar(low, high, isVertical, this, series, options);
+        const errorBar = new ScatterErrorBar(low, high, isVertical, this, series, options);
         point.errorBars.push(errorBar);
         point.append(errorBar);
 
@@ -94,22 +87,21 @@ var ScatterChart = (function (ChartElement) {
         this.updateRange(item, series);
         item[field] = high;
         this.updateRange(item, series);
-    };
+    }
 
-    ScatterChart.prototype.addValue = function addValue (value, fields) {
-        var x = value.x;
-        var y = value.y;
-        var seriesIx = fields.seriesIx;
-        var series = this.options.series[seriesIx];
-        var missingValues = this.seriesMissingValues(series);
-        var seriesPoints = this.seriesPoints[seriesIx];
+    addValue(value, fields) {
+        const { x, y } = value;
+        const seriesIx = fields.seriesIx;
+        const series = this.options.series[seriesIx];
+        const missingValues = this.seriesMissingValues(series);
+        const seriesPoints = this.seriesPoints[seriesIx];
 
-        var pointValue = value;
+        let pointValue = value;
         if (!(hasValue(x) && hasValue(y))) {
             pointValue = this.createMissingValue(pointValue, missingValues);
         }
 
-        var point;
+        let point;
         if (pointValue) {
             point = this.createPoint(pointValue, fields);
             if (point) {
@@ -122,22 +114,20 @@ var ScatterChart = (function (ChartElement) {
 
         this.points.push(point);
         seriesPoints.push(point);
-    };
+    }
 
-    ScatterChart.prototype.seriesMissingValues = function seriesMissingValues (series) {
+    seriesMissingValues(series) {
         return series.missingValues;
-    };
+    }
 
-    ScatterChart.prototype.createMissingValue = function createMissingValue () {};
+    createMissingValue() {}
 
-    ScatterChart.prototype.updateRange = function updateRange (value, series) {
-        var intlService = this.chartService.intl;
-        var xAxisName = series.xAxis;
-        var yAxisName = series.yAxis;
-        var x = value.x;
-        var y = value.y;
-        var xAxisRange = this.xAxisRanges[xAxisName];
-        var yAxisRange = this.yAxisRanges[yAxisName];
+    updateRange(value, series) {
+        const intlService = this.chartService.intl;
+        const { xAxis: xAxisName, yAxis: yAxisName } = series;
+        let { x, y } = value;
+        let xAxisRange = this.xAxisRanges[xAxisName];
+        let yAxisRange = this.yAxisRanges[yAxisName];
 
         if (hasValue(x)) {
             xAxisRange = this.xAxisRanges[xAxisName] =
@@ -162,12 +152,11 @@ var ScatterChart = (function (ChartElement) {
             yAxisRange.min = Math.min(yAxisRange.min, y);
             yAxisRange.max = Math.max(yAxisRange.max, y);
         }
-    };
+    }
 
-    ScatterChart.prototype.evalPointOptions = function evalPointOptions (options, value, fields) {
-        var series = fields.series;
-        var seriesIx = fields.seriesIx;
-        var state = {
+    evalPointOptions(options, value, fields) {
+        const { series, seriesIx } = fields;
+        const state = {
             defaults: series._defaults,
             excluded: [
                 "data", "tooltip", "content", "template", "visual", "toggle",
@@ -176,12 +165,12 @@ var ScatterChart = (function (ChartElement) {
             ]
         };
 
-        var doEval = this._evalSeries[seriesIx];
+        let doEval = this._evalSeries[seriesIx];
         if (!defined(doEval)) {
             this._evalSeries[seriesIx] = doEval = evalOptions(options, {}, state, true);
         }
 
-        var pointOptions = options;
+        let pointOptions = options;
         if (doEval) {
             pointOptions = deepExtend({}, options);
             evalOptions(pointOptions, {
@@ -192,16 +181,16 @@ var ScatterChart = (function (ChartElement) {
         }
 
         return pointOptions;
-    };
+    }
 
-    ScatterChart.prototype.pointType = function pointType () {
+    pointType() {
         return LinePoint;
-    };
+    }
 
-    ScatterChart.prototype.pointOptions = function pointOptions (series, seriesIx) {
-        var options = this.seriesOptions[seriesIx];
+    pointOptions(series, seriesIx) {
+        let options = this.seriesOptions[seriesIx];
         if (!options) {
-            var defaults = this.pointType().prototype.defaults;
+            const defaults = this.pointType().prototype.defaults;
             this.seriesOptions[seriesIx] = options = deepExtend({}, defaults, {
                 markers: {
                     opacity: series.opacity
@@ -216,12 +205,12 @@ var ScatterChart = (function (ChartElement) {
         }
 
         return options;
-    };
+    }
 
-    ScatterChart.prototype.createPoint = function createPoint (value, fields) {
-        var series = fields.series;
-        var pointOptions = this.pointOptions(series, fields.seriesIx);
-        var color = fields.color || series.color;
+    createPoint(value, fields) {
+        const series = fields.series;
+        let pointOptions = this.pointOptions(series, fields.seriesIx);
+        let color = fields.color || series.color;
 
         pointOptions = this.evalPointOptions(pointOptions, value, fields);
 
@@ -229,20 +218,19 @@ var ScatterChart = (function (ChartElement) {
             color = pointOptions.color;
         }
 
-        var point = new LinePoint(value, pointOptions);
+        const point = new LinePoint(value, pointOptions);
         point.color = color;
 
         this.append(point);
 
         return point;
-    };
+    }
 
-    ScatterChart.prototype.seriesAxes = function seriesAxes (series) {
-        var xAxisName = series.xAxis;
-        var yAxisName = series.yAxis;
-        var plotArea = this.plotArea;
-        var xAxis = xAxisName ? plotArea.namedXAxes[xAxisName] : plotArea.axisX;
-        var yAxis = yAxisName ? plotArea.namedYAxes[yAxisName] : plotArea.axisY;
+    seriesAxes(series) {
+        const { xAxis: xAxisName, yAxis: yAxisName } = series;
+        const plotArea = this.plotArea;
+        const xAxis = xAxisName ? plotArea.namedXAxes[xAxisName] : plotArea.axisX;
+        const yAxis = yAxisName ? plotArea.namedYAxes[yAxisName] : plotArea.axisY;
 
         if (!xAxis) {
             throw new Error("Unable to locate X axis with name " + xAxisName);
@@ -256,25 +244,23 @@ var ScatterChart = (function (ChartElement) {
             x: xAxis,
             y: yAxis
         };
-    };
-
-    ScatterChart.prototype.reflow = function reflow (targetBox) {
-        var this$1 = this;
+    }
 
-        var chartPoints = this.points;
-        var limit = !this.options.clip;
-        var pointIx = 0;
+    reflow(targetBox) {
+        const chartPoints = this.points;
+        const limit = !this.options.clip;
+        let pointIx = 0;
 
 
-        this.traverseDataPoints(function (value, fields) {
-            var point = chartPoints[pointIx++];
-            var seriesAxes = this$1.seriesAxes(fields.series);
-            var slotX = seriesAxes.x.getSlot(value.x, value.x, limit);
-            var slotY = seriesAxes.y.getSlot(value.y, value.y, limit);
+        this.traverseDataPoints((value, fields) => {
+            const point = chartPoints[pointIx++];
+            const seriesAxes = this.seriesAxes(fields.series);
+            const slotX = seriesAxes.x.getSlot(value.x, value.x, limit);
+            const slotY = seriesAxes.y.getSlot(value.y, value.y, limit);
 
             if (point) {
                 if (slotX && slotY) {
-                    var pointSlot = this$1.pointSlot(slotX, slotY);
+                    const pointSlot = this.pointSlot(slotX, slotY);
                     point.reflow(pointSlot);
                 } else {
                     point.visible = false;
@@ -283,58 +269,50 @@ var ScatterChart = (function (ChartElement) {
         });
 
         this.box = targetBox;
-    };
+    }
 
-    ScatterChart.prototype.pointSlot = function pointSlot (slotX, slotY) {
+    pointSlot(slotX, slotY) {
         return new Box(slotX.x1, slotY.y1, slotX.x2, slotY.y2);
-    };
-
-    ScatterChart.prototype.traverseDataPoints = function traverseDataPoints (callback) {
-        var this$1 = this;
+    }
 
-        var ref = this;
-        var series = ref.options.series;
-        var seriesPoints = ref.seriesPoints;
+    traverseDataPoints(callback) {
+        const { options: { series }, seriesPoints } = this;
 
-        for (var seriesIx = 0; seriesIx < series.length; seriesIx++) {
-            var currentSeries = series[seriesIx];
-            var currentSeriesPoints = seriesPoints[seriesIx];
+        for (let seriesIx = 0; seriesIx < series.length; seriesIx++) {
+            const currentSeries = series[seriesIx];
+            const currentSeriesPoints = seriesPoints[seriesIx];
             if (!currentSeriesPoints) {
                 seriesPoints[seriesIx] = [];
             }
 
-            for (var pointIx = 0; pointIx < currentSeries.data.length; pointIx++) {
-                var ref$1 = this$1.plotArea.bindPoint(currentSeries, pointIx);
-                var value = ref$1.valueFields;
-                var fields = ref$1.fields;
+            for (let pointIx = 0; pointIx < currentSeries.data.length; pointIx++) {
+                const { valueFields: value, fields } = this.plotArea.bindPoint(currentSeries, pointIx);
 
                 callback(value, deepExtend({
                     pointIx: pointIx,
                     series: currentSeries,
                     seriesIx: seriesIx,
                     dataItem: currentSeries.data[pointIx],
-                    owner: this$1
+                    owner: this
                 }, fields));
             }
         }
-    };
+    }
 
-    ScatterChart.prototype.formatPointValue = function formatPointValue (point, format) {
-        var value = point.value;
+    formatPointValue(point, format) {
+        const value = point.value;
         return this.chartService.format.auto(format, value.x, value.y);
-    };
+    }
 
-    ScatterChart.prototype.animationPoints = function animationPoints () {
-        var points = this.points;
-        var result = [];
-        for (var idx = 0; idx < points.length; idx++) {
+    animationPoints() {
+        const points = this.points;
+        const result = [];
+        for (let idx = 0; idx < points.length; idx++) {
             result.push((points[idx] || {}).marker);
         }
         return result;
-    };
-
-    return ScatterChart;
-}(ChartElement));
+    }
+}
 setDefaultOptions(ScatterChart, {
     series: [],
     tooltip: {

package/dist/es/chart/scatter-charts/scatter-line-chart.js

@@ -9,24 +9,16 @@ import hasValue from '../utils/has-value';
 
 import { deepExtend } from '../../common';
 
-var ScatterLineChart = (function (ScatterChart) {
-    function ScatterLineChart () {
-        ScatterChart.apply(this, arguments);
-    }
-
-    if ( ScatterChart ) ScatterLineChart.__proto__ = ScatterChart;
-    ScatterLineChart.prototype = Object.create( ScatterChart && ScatterChart.prototype );
-    ScatterLineChart.prototype.constructor = ScatterLineChart;
-
-    ScatterLineChart.prototype.render = function render () {
-        ScatterChart.prototype.render.call(this);
+class ScatterLineChart extends ScatterChart {
+    render() {
+        super.render();
 
         this.renderSegments();
-    };
+    }
 
-    ScatterLineChart.prototype.createSegment = function createSegment (linePoints, currentSeries, seriesIx) {
-        var style = currentSeries.style;
-        var pointType;
+    createSegment(linePoints, currentSeries, seriesIx) {
+        const style = currentSeries.style;
+        let pointType;
 
         if (style === SMOOTH) {
             pointType = SplineSegment;
@@ -35,16 +27,16 @@ var ScatterLineChart = (function (ScatterChart) {
         }
 
         return new pointType(linePoints, currentSeries, seriesIx);
-    };
+    }
 
-    ScatterLineChart.prototype.animationPoints = function animationPoints () {
-        var points = ScatterChart.prototype.animationPoints.call(this);
+    animationPoints() {
+        const points = super.animationPoints();
         return points.concat(this._segments);
-    };
+    }
 
-    ScatterLineChart.prototype.createMissingValue = function createMissingValue (value, missingValues) {
+    createMissingValue(value, missingValues) {
         if (missingValues === ZERO) {
-            var missingValue = {
+            const missingValue = {
                 x: value.x,
                 y: value.y
             };
@@ -56,10 +48,8 @@ var ScatterLineChart = (function (ScatterChart) {
             }
             return missingValue;
         }
-    };
-
-    return ScatterLineChart;
-}(ScatterChart));
+    }
+}
 
 deepExtend(ScatterLineChart.prototype, LineChartMixin);