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

package/dist/es/chart/error-bars/categorical-error-bar.js

@@ -1,21 +1,11 @@
 import ErrorBarBase from './error-bar-base';
 
-var CategoricalErrorBar = (function (ErrorBarBase) {
-    function CategoricalErrorBar () {
-        ErrorBarBase.apply(this, arguments);
-    }
-
-    if ( ErrorBarBase ) CategoricalErrorBar.__proto__ = ErrorBarBase;
-    CategoricalErrorBar.prototype = Object.create( ErrorBarBase && ErrorBarBase.prototype );
-    CategoricalErrorBar.prototype.constructor = CategoricalErrorBar;
-
-    CategoricalErrorBar.prototype.getAxis = function getAxis () {
-        var axis = this.chart.seriesValueAxis(this.series);
+class CategoricalErrorBar extends ErrorBarBase {
+    getAxis() {
+        const axis = this.chart.seriesValueAxis(this.series);
 
         return axis;
-    };
-
-    return CategoricalErrorBar;
-}(ErrorBarBase));
+    }
+}
 
 export default CategoricalErrorBar;

package/dist/es/chart/error-bars/error-bar-base.js

@@ -6,11 +6,11 @@ import { FADEIN, INITIAL_ANIMATION_DURATION } from '../constants';
 
 import { setDefaultOptions, alignPathToPixel } from '../../common';
 
-var DEFAULT_ERROR_BAR_WIDTH = 4;
+const DEFAULT_ERROR_BAR_WIDTH = 4;
 
-var ErrorBarBase = (function (ChartElement) {
-    function ErrorBarBase(low, high, isVertical, chart, series, options) {
-        ChartElement.call(this, options);
+class ErrorBarBase extends ChartElement {
+    constructor(low, high, isVertical, chart, series, options) {
+        super(options);
 
         this.low = low;
         this.high = high;
@@ -19,21 +19,17 @@ var ErrorBarBase = (function (ChartElement) {
         this.series = series;
     }
 
-    if ( ChartElement ) ErrorBarBase.__proto__ = ChartElement;
-    ErrorBarBase.prototype = Object.create( ChartElement && ChartElement.prototype );
-    ErrorBarBase.prototype.constructor = ErrorBarBase;
-
-    ErrorBarBase.prototype.reflow = function reflow (targetBox) {
-        var endCaps = this.options.endCaps;
-        var isVertical = this.isVertical;
-        var axis = this.getAxis();
-        var valueBox = axis.getSlot(this.low, this.high);
-        var centerBox = targetBox.center();
-        var capsWidth = this.getCapsWidth(targetBox, isVertical);
-        var capValue = isVertical ? centerBox.x : centerBox.y;
-        var capStart = capValue - capsWidth;
-        var capEnd = capValue + capsWidth;
-        var linePoints;
+    reflow(targetBox) {
+        const endCaps = this.options.endCaps;
+        const isVertical = this.isVertical;
+        const axis = this.getAxis();
+        const valueBox = axis.getSlot(this.low, this.high);
+        const centerBox = targetBox.center();
+        const capsWidth = this.getCapsWidth(targetBox, isVertical);
+        const capValue = isVertical ? centerBox.x : centerBox.y;
+        const capStart = capValue - capsWidth;
+        const capEnd = capValue + capsWidth;
+        let linePoints;
 
         if (isVertical) {
             linePoints = [
@@ -62,20 +58,18 @@ var ErrorBarBase = (function (ChartElement) {
         }
 
         this.linePoints = linePoints;
-    };
+    }
 
-    ErrorBarBase.prototype.getCapsWidth = function getCapsWidth (box, isVertical) {
-        var boxSize = isVertical ? box.width() : box.height();
-        var capsWidth = Math.min(Math.floor(boxSize / 2), DEFAULT_ERROR_BAR_WIDTH) || DEFAULT_ERROR_BAR_WIDTH;
+    getCapsWidth(box, isVertical) {
+        const boxSize = isVertical ? box.width() : box.height();
+        const capsWidth = Math.min(Math.floor(boxSize / 2), DEFAULT_ERROR_BAR_WIDTH) || DEFAULT_ERROR_BAR_WIDTH;
 
         return capsWidth;
-    };
-
-    ErrorBarBase.prototype.createVisual = function createVisual () {
-        var this$1 = this;
+    }
 
-        var options = this.options;
-        var visual = options.visual;
+    createVisual() {
+        const options = this.options;
+        const visual = options.visual;
 
         if (visual) {
             this.visual = visual({
@@ -88,25 +82,21 @@ var ErrorBarBase = (function (ChartElement) {
                     color: options.color,
                     line: options.line
                 },
-                createVisual: function () {
-                    this$1.createDefaultVisual();
-                    var defaultVisual = this$1.visual;
-                    delete this$1.visual;
+                createVisual: () => {
+                    this.createDefaultVisual();
+                    const defaultVisual = this.visual;
+                    delete this.visual;
                     return defaultVisual;
                 }
             });
         } else {
             this.createDefaultVisual();
         }
-    };
-
-    ErrorBarBase.prototype.createDefaultVisual = function createDefaultVisual () {
-        var this$1 = this;
+    }
 
-        var ref = this;
-        var options = ref.options;
-        var linePoints = ref.linePoints;
-        var lineOptions = {
+    createDefaultVisual() {
+        const { options, linePoints } = this;
+        const lineOptions = {
             stroke: {
                 color: options.color,
                 width: options.line.width,
@@ -114,20 +104,18 @@ var ErrorBarBase = (function (ChartElement) {
             }
         };
 
-        ChartElement.prototype.createVisual.call(this);
+        super.createVisual();
 
-        for (var idx = 0; idx < linePoints.length; idx += 2) {
-            var line = new draw.Path(lineOptions)
+        for (let idx = 0; idx < linePoints.length; idx += 2) {
+            const line = new draw.Path(lineOptions)
                 .moveTo(linePoints[idx].x, linePoints[idx].y)
                 .lineTo(linePoints[idx + 1].x, linePoints[idx + 1].y);
 
             alignPathToPixel(line);
-            this$1.visual.append(line);
+            this.visual.append(line);
         }
-    };
-
-    return ErrorBarBase;
-}(ChartElement));
+    }
+}
 
 setDefaultOptions(ErrorBarBase, {
     animation: {

package/dist/es/chart/error-bars/error-range-calculator.js

@@ -3,69 +3,65 @@ import SeriesBinder from '../series-binder';
 import { OBJECT } from '../../common/constants';
 import { Class, defined, getter, isArray, isNumber } from '../../common';
 
-var STD_ERR = "stderr";
-var STD_DEV = "stddev";
-var percentRegex = /percent(?:\w*)\((\d+)\)/;
-var standardDeviationRegex = new RegExp("^" + STD_DEV + "(?:\\((\\d+(?:\\.\\d+)?)\\))?$");
+const STD_ERR = "stderr";
+const STD_DEV = "stddev";
+const percentRegex = /percent(?:\w*)\((\d+)\)/;
+const standardDeviationRegex = new RegExp("^" + STD_DEV + "(?:\\((\\d+(?:\\.\\d+)?)\\))?$");
 
-var ErrorRangeCalculator = (function (Class) {
-    function ErrorRangeCalculator(errorValue, series, field) {
-        Class.call(this);
+class ErrorRangeCalculator extends Class {
+    constructor(errorValue, series, field) {
+        super();
 
         this.initGlobalRanges(errorValue, series, field);
     }
 
-    if ( Class ) ErrorRangeCalculator.__proto__ = Class;
-    ErrorRangeCalculator.prototype = Object.create( Class && Class.prototype );
-    ErrorRangeCalculator.prototype.constructor = ErrorRangeCalculator;
-
-    ErrorRangeCalculator.prototype.initGlobalRanges = function initGlobalRanges (errorValue, series, field) {
-        var data = series.data;
-        var deviationMatch = standardDeviationRegex.exec(errorValue);
+    initGlobalRanges(errorValue, series, field) {
+        const data = series.data;
+        const deviationMatch = standardDeviationRegex.exec(errorValue);
 
         if (deviationMatch) {
             this.valueGetter = this.createValueGetter(series, field);
 
-            var average = this.getAverage(data);
-            var deviation = this.getStandardDeviation(data, average, false);
-            var multiple = deviationMatch[1] ? parseFloat(deviationMatch[1]) : 1;
-            var errorRange = { low: average.value - deviation * multiple, high: average.value + deviation * multiple };
+            const average = this.getAverage(data);
+            const deviation = this.getStandardDeviation(data, average, false);
+            const multiple = deviationMatch[1] ? parseFloat(deviationMatch[1]) : 1;
+            const errorRange = { low: average.value - deviation * multiple, high: average.value + deviation * multiple };
 
             this.globalRange = function() {
                 return errorRange;
             };
         } else if (errorValue.indexOf && errorValue.indexOf(STD_ERR) >= 0) {
             this.valueGetter = this.createValueGetter(series, field);
-            var standardError = this.getStandardError(data, this.getAverage(data));
+            const standardError = this.getStandardError(data, this.getAverage(data));
 
             this.globalRange = function(value) {
                 return { low: value - standardError, high: value + standardError };
             };
         }
-    };
+    }
 
-    ErrorRangeCalculator.prototype.createValueGetter = function createValueGetter (series, field) {
-        var data = series.data;
-        var binder = SeriesBinder.current;
-        var valueFields = binder.valueFields(series);
-        var item = defined(data[0]) ? data[0] : {};
-        var valueGetter;
+    createValueGetter(series, field) {
+        const data = series.data;
+        const binder = SeriesBinder.current;
+        const valueFields = binder.valueFields(series);
+        const item = defined(data[0]) ? data[0] : {};
+        let valueGetter;
 
         if (isArray(item)) {
-            var index = field ? valueFields.indexOf(field) : 0;
+            const index = field ? valueFields.indexOf(field) : 0;
             valueGetter = getter("[" + index + "]");
         } else if (isNumber(item)) {
             valueGetter = getter();
         } else if (typeof item === OBJECT) {
-            var srcValueFields = binder.sourceFields(series, valueFields);
+            const srcValueFields = binder.sourceFields(series, valueFields);
             valueGetter = getter(srcValueFields[valueFields.indexOf(field)]);
         }
 
         return valueGetter;
-    };
+    }
 
-    ErrorRangeCalculator.prototype.getErrorRange = function getErrorRange (pointValue, errorValue) {
-        var low, high, value;
+    getErrorRange(pointValue, errorValue) {
+        let low, high, value;
 
         if (!defined(errorValue)) {
             return null;
@@ -82,7 +78,7 @@ var ErrorRangeCalculator = (function (Class) {
             low = pointValue - value;
             high = pointValue + value;
         } else if ((value = percentRegex.exec(errorValue))) {
-            var percentValue = pointValue * (parseFloat(value[1]) / 100);
+            const percentValue = pointValue * (parseFloat(value[1]) / 100);
             low = pointValue - Math.abs(percentValue);
             high = pointValue + Math.abs(percentValue);
         } else {
@@ -90,38 +86,34 @@ var ErrorRangeCalculator = (function (Class) {
         }
 
         return { low: low, high: high };
-    };
+    }
 
-    ErrorRangeCalculator.prototype.getStandardError = function getStandardError (data, average) {
+    getStandardError(data, average) {
         return this.getStandardDeviation(data, average, true) / Math.sqrt(average.count);
-    };
-
-    ErrorRangeCalculator.prototype.getStandardDeviation = function getStandardDeviation (data, average, isSample) {
-        var this$1 = this;
+    }
 
-        var length = data.length;
-        var total = isSample ? average.count - 1 : average.count;
-        var squareDifferenceSum = 0;
+    getStandardDeviation(data, average, isSample) {
+        const length = data.length;
+        const total = isSample ? average.count - 1 : average.count;
+        let squareDifferenceSum = 0;
 
-        for (var idx = 0; idx < length; idx++) {
-            var value = this$1.valueGetter(data[idx]);
+        for (let idx = 0; idx < length; idx++) {
+            const value = this.valueGetter(data[idx]);
             if (isNumber(value)) {
                 squareDifferenceSum += Math.pow(value - average.value, 2);
             }
         }
 
         return Math.sqrt(squareDifferenceSum / total);
-    };
-
-    ErrorRangeCalculator.prototype.getAverage = function getAverage (data) {
-        var this$1 = this;
+    }
 
-        var length = data.length;
-        var sum = 0;
-        var count = 0;
+    getAverage(data) {
+        const length = data.length;
+        let sum = 0;
+        let count = 0;
 
-        for (var idx = 0; idx < length; idx++) {
-            var value = this$1.valueGetter(data[idx]);
+        for (let idx = 0; idx < length; idx++) {
+            const value = this.valueGetter(data[idx]);
             if (isNumber(value)) {
                 sum += value;
                 count++;
@@ -132,9 +124,7 @@ var ErrorRangeCalculator = (function (Class) {
             value: sum / count,
             count: count
         };
-    };
-
-    return ErrorRangeCalculator;
-}(Class));
+    }
+}
 
 export default ErrorRangeCalculator;

package/dist/es/chart/error-bars/scatter-error-bar.js

@@ -1,22 +1,12 @@
 import ErrorBarBase from './error-bar-base';
 
-var ScatterErrorBar = (function (ErrorBarBase) {
-    function ScatterErrorBar () {
-        ErrorBarBase.apply(this, arguments);
-    }
-
-    if ( ErrorBarBase ) ScatterErrorBar.__proto__ = ErrorBarBase;
-    ScatterErrorBar.prototype = Object.create( ErrorBarBase && ErrorBarBase.prototype );
-    ScatterErrorBar.prototype.constructor = ScatterErrorBar;
-
-    ScatterErrorBar.prototype.getAxis = function getAxis () {
-        var axes = this.chart.seriesAxes(this.series);
-        var axis = this.isVertical ? axes.y : axes.x;
+class ScatterErrorBar extends ErrorBarBase {
+    getAxis() {
+        const axes = this.chart.seriesAxes(this.series);
+        const axis = this.isVertical ? axes.y : axes.x;
 
         return axis;
-    };
-
-    return ScatterErrorBar;
-}(ErrorBarBase));
+    }
+}
 
 export default ScatterErrorBar;