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

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

@@ -10,9 +10,9 @@ import { ChartElement, Box } from '../core';
 import { VALUE, STRING, MIN_VALUE, MAX_VALUE, OBJECT } from '../common/constants';
 import { convertableToNumber, deepExtend, defined, isNumber, last, setDefaultOptions, sparseArrayLimits } from '../common';
 
-var CategoricalChart = (function (ChartElement) {
-    function CategoricalChart(plotArea, options) {
-        ChartElement.call(this, options);
+class CategoricalChart extends ChartElement {
+    constructor(plotArea, options) {
+        super(options);
 
         this.plotArea = plotArea;
         this.chartService = plotArea.chartService;
@@ -31,42 +31,38 @@ var CategoricalChart = (function (ChartElement) {
         this.render();
     }
 
-    if ( ChartElement ) CategoricalChart.__proto__ = ChartElement;
-    CategoricalChart.prototype = Object.create( ChartElement && ChartElement.prototype );
-    CategoricalChart.prototype.constructor = CategoricalChart;
-
-    CategoricalChart.prototype.render = function render () {
+    render() {
         this.traverseDataPoints(this.addValue.bind(this));
-    };
+    }
 
-    CategoricalChart.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, {
                 vertical: !this.options.invertAxes
             }, series);
         }
 
         return options;
-    };
+    }
 
-    CategoricalChart.prototype.plotValue = function plotValue (point) {
+    plotValue(point) {
         if (!point) {
             return 0;
         }
 
         if (this.options.isStacked100 && isNumber(point.value)) {
-            var categoryIx = point.categoryIx;
-            var categoryPoints = this.categoryPoints[categoryIx];
-            var otherValues = [];
-            var categorySum = 0;
+            const categoryIx = point.categoryIx;
+            const categoryPoints = this.categoryPoints[categoryIx];
+            const otherValues = [];
+            let categorySum = 0;
 
-            for (var i = 0; i < categoryPoints.length; i++) {
-                var other = categoryPoints[i];
+            for (let i = 0; i < categoryPoints.length; i++) {
+                const other = categoryPoints[i];
                 if (other) {
-                    var stack = point.series.stack;
-                    var otherStack = other.series.stack;
+                    const stack = point.series.stack;
+                    const otherStack = other.series.stack;
 
                     if ((stack && otherStack) && stack.group !== otherStack.group) {
                         continue;
@@ -85,31 +81,28 @@ var CategoricalChart = (function (ChartElement) {
         }
 
         return point.value;
-    };
-
-    CategoricalChart.prototype.plotRange = function plotRange (point, startValue) {
-        var this$1 = this;
-        if ( startValue === void 0 ) startValue = 0;
+    }
 
-        var categoryPoints = this.categoryPoints[point.categoryIx];
+    plotRange(point, startValue = 0) {
+        const categoryPoints = this.categoryPoints[point.categoryIx];
 
         if (this.options.isStacked) {
-            var plotValue = this.plotValue(point);
-            var positive = plotValue >= 0;
-            var prevValue = startValue;
-            var isStackedBar = false;
-            var stack = defined(point.series.stack) ? point.series.stack : this.options.defaultStack;
-            var isNonGroupStack = function (stack) { return stack === true || typeof stack === OBJECT && !stack.group; };
+            let plotValue = this.plotValue(point);
+            const positive = plotValue >= 0;
+            let prevValue = startValue;
+            let isStackedBar = false;
+            const stack = defined(point.series.stack) ? point.series.stack : this.options.defaultStack;
+            const isNonGroupStack = (stack) => stack === true || typeof stack === OBJECT && !stack.group;
 
             if (stack) {
-                for (var i = 0; i < categoryPoints.length; i++) {
-                    var other = categoryPoints[i];
+                for (let i = 0; i < categoryPoints.length; i++) {
+                    const other = categoryPoints[i];
 
                     if (point === other) {
                         break;
                     }
 
-                    var otherStack = defined(other.series.stack) ? other.series.stack : this$1.options.defaultStack;
+                    const otherStack = defined(other.series.stack) ? other.series.stack : this.options.defaultStack;
 
                     if (!otherStack) {
                         continue;
@@ -127,7 +120,7 @@ var CategoricalChart = (function (ChartElement) {
                         continue;
                     }
 
-                    var otherValue = this$1.plotValue(other);
+                    const otherValue = this.plotValue(other);
                     if ((otherValue >= 0 && positive) ||
                         (otherValue < 0 && !positive)) {
                         // zero values should be skipped for log axis (startValue !== 0)
@@ -136,7 +129,7 @@ var CategoricalChart = (function (ChartElement) {
                             plotValue += otherValue;
                             isStackedBar = true;
 
-                            if (this$1.options.isStacked100) {
+                            if (this.options.isStacked100) {
                                 plotValue = Math.min(plotValue, 1);
                             }
                         }
@@ -151,30 +144,28 @@ var CategoricalChart = (function (ChartElement) {
             return [ prevValue, plotValue ];
         }
 
-        var series = point.series;
-        var valueAxis = this.seriesValueAxis(series);
-        var axisCrossingValue = this.categoryAxisCrossingValue(valueAxis);
+        const series = point.series;
+        const valueAxis = this.seriesValueAxis(series);
+        const axisCrossingValue = this.categoryAxisCrossingValue(valueAxis);
 
         return [ axisCrossingValue, convertableToNumber(point.value) ? point.value : axisCrossingValue ];
-    };
-
-    CategoricalChart.prototype.stackLimits = function stackLimits (axisName, stackName) {
-        var this$1 = this;
+    }
 
-        var min = MAX_VALUE;
-        var max = MIN_VALUE;
+    stackLimits(axisName, stackName) {
+        let min = MAX_VALUE;
+        let max = MIN_VALUE;
 
-        for (var i = 0; i < this.categoryPoints.length; i++) {
-            var categoryPoints = this$1.categoryPoints[i];
+        for (let i = 0; i < this.categoryPoints.length; i++) {
+            const categoryPoints = this.categoryPoints[i];
             if (!categoryPoints) {
                 continue;
             }
 
-            for (var pIx = 0; pIx < categoryPoints.length; pIx++) {
-                var point = categoryPoints[pIx];
+            for (let pIx = 0; pIx < categoryPoints.length; pIx++) {
+                const point = categoryPoints[pIx];
                 if (point) {
                     if (point.series.stack === stackName || point.series.axis === axisName) {
-                        var to = this$1.plotRange(point, 0)[1];
+                        const to = this.plotRange(point, 0)[1];
                         if (defined(to) && isFinite(to)) {
                             max = Math.max(max, to);
                             min = Math.min(min, to);
@@ -185,27 +176,23 @@ var CategoricalChart = (function (ChartElement) {
         }
 
         return { min: min, max: max };
-    };
-
-    CategoricalChart.prototype.updateStackRange = function updateStackRange () {
-        var this$1 = this;
+    }
 
-        var ref = this.options;
-        var isStacked = ref.isStacked;
-        var chartSeries = ref.series;
-        var limitsCache = {};
+    updateStackRange() {
+        const { isStacked, series: chartSeries } = this.options;
+        const limitsCache = {};
 
         if (isStacked) {
-            for (var i = 0; i < chartSeries.length; i++) {
-                var series = chartSeries[i];
-                var axisName = series.axis;
-                var key = axisName + series.stack;
+            for (let i = 0; i < chartSeries.length; i++) {
+                const series = chartSeries[i];
+                const axisName = series.axis;
+                const key = axisName + series.stack;
 
-                var limits = limitsCache[key];
+                let limits = limitsCache[key];
                 if (!limits) {
-                    limits = this$1.stackLimits(axisName, series.stack);
+                    limits = this.stackLimits(axisName, series.stack);
 
-                    var errorTotals = this$1.errorTotals;
+                    const errorTotals = this.errorTotals;
                     if (errorTotals) {
                         if (errorTotals.negative.length) {
                             limits.min = Math.min(limits.min, sparseArrayLimits(errorTotals.negative).min);
@@ -223,20 +210,18 @@ var CategoricalChart = (function (ChartElement) {
                 }
 
                 if (limits) {
-                    this$1.valueAxisRanges[axisName] = limits;
+                    this.valueAxisRanges[axisName] = limits;
                 }
             }
         }
-    };
+    }
 
-    CategoricalChart.prototype.addErrorBar = function addErrorBar (point, data, categoryIx) {
-        var value = point.value;
-        var series = point.series;
-        var seriesIx = point.seriesIx;
-        var errorBars = point.options.errorBars;
-        var lowValue = data.fields[ERROR_LOW_FIELD];
-        var highValue = data.fields[ERROR_HIGH_FIELD];
-        var errorRange;
+    addErrorBar(point, data, categoryIx) {
+        const { value, series, seriesIx } = point;
+        const errorBars = point.options.errorBars;
+        const lowValue = data.fields[ERROR_LOW_FIELD];
+        const highValue = data.fields[ERROR_HIGH_FIELD];
+        let errorRange;
 
         if (isNumber(lowValue) && isNumber(highValue)) {
             errorRange = { low: lowValue, high: highValue };
@@ -253,34 +238,32 @@ var CategoricalChart = (function (ChartElement) {
             point.high = errorRange.high;
             this.addPointErrorBar(point, categoryIx);
         }
-    };
+    }
 
-    CategoricalChart.prototype.addPointErrorBar = function addPointErrorBar (point, categoryIx) {
-        var isVertical = !this.options.invertAxes;
-        var options = point.options.errorBars;
-        var series = point.series;
-        var low = point.low;
-        var high = point.high;
+    addPointErrorBar(point, categoryIx) {
+        const isVertical = !this.options.invertAxes;
+        const options = point.options.errorBars;
+        let { series, low, high } = point;
 
         if (this.options.isStacked) {
-            var stackedErrorRange = this.stackedErrorRange(point, categoryIx);
+            const stackedErrorRange = this.stackedErrorRange(point, categoryIx);
             low = stackedErrorRange.low;
             high = stackedErrorRange.high;
         } else {
-            var fields = { categoryIx: categoryIx, series: series };
+            const fields = { categoryIx: categoryIx, series: series };
             this.updateRange({ value: low }, fields);
             this.updateRange({ value: high }, fields);
         }
 
-        var errorBar = new CategoricalErrorBar(low, high, isVertical, this, series, options);
+        const errorBar = new CategoricalErrorBar(low, high, isVertical, this, series, options);
         point.errorBars = [ errorBar ];
         point.append(errorBar);
-    };
+    }
 
-    CategoricalChart.prototype.stackedErrorRange = function stackedErrorRange (point, categoryIx) {
-        var plotValue = this.plotRange(point, 0)[1] - point.value;
-        var low = point.low + plotValue;
-        var high = point.high + plotValue;
+    stackedErrorRange(point, categoryIx) {
+        const plotValue = this.plotRange(point, 0)[1] - point.value;
+        const low = point.low + plotValue;
+        const high = point.high + plotValue;
 
         this.errorTotals = this.errorTotals || { positive: [], negative: [] };
 
@@ -293,24 +276,22 @@ var CategoricalChart = (function (ChartElement) {
         }
 
         return { low: low, high: high };
-    };
+    }
 
-    CategoricalChart.prototype.addValue = function addValue (data, fields) {
-        var categoryIx = fields.categoryIx;
-        var series = fields.series;
-        var seriesIx = fields.seriesIx;
+    addValue(data, fields) {
+        const { categoryIx, series, seriesIx } = fields;
 
-        var categoryPoints = this.categoryPoints[categoryIx];
+        let categoryPoints = this.categoryPoints[categoryIx];
         if (!categoryPoints) {
             this.categoryPoints[categoryIx] = categoryPoints = [];
         }
 
-        var seriesPoints = this.seriesPoints[seriesIx];
+        let seriesPoints = this.seriesPoints[seriesIx];
         if (!seriesPoints) {
             this.seriesPoints[seriesIx] = seriesPoints = [];
         }
 
-        var point = this.createPoint(data, fields);
+        const point = this.createPoint(data, fields);
         if (point) {
             Object.assign(point, fields);
 
@@ -327,14 +308,14 @@ var CategoricalChart = (function (ChartElement) {
         categoryPoints.push(point);
 
         this.updateRange(data.valueFields, fields);
-    };
-
-    CategoricalChart.prototype.evalPointOptions = function evalPointOptions (options, value, fields) {
-        var categoryIx = fields.categoryIx;
-        var category = fields.category;
-        var series = fields.series;
-        var seriesIx = fields.seriesIx;
-        var state = {
+    }
+
+    evalPointOptions(options, value, fields) {
+        const categoryIx = fields.categoryIx;
+        const category = fields.category;
+        const series = fields.series;
+        const seriesIx = fields.seriesIx;
+        const state = {
             defaults: series._defaults,
             excluded: [
                 "data", "aggregate", "_events", "tooltip", "content", "template",
@@ -343,12 +324,12 @@ var CategoricalChart = (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({}, pointOptions);
             evalOptions(pointOptions, {
@@ -361,12 +342,12 @@ var CategoricalChart = (function (ChartElement) {
         }
 
         return pointOptions;
-    };
+    }
 
-    CategoricalChart.prototype.updateRange = function updateRange (data, fields) {
-        var axisName = fields.series.axis;
-        var value = data.value;
-        var axisRange = this.valueAxisRanges[axisName];
+    updateRange(data, fields) {
+        const axisName = fields.series.axis;
+        const value = data.value;
+        let axisRange = this.valueAxisRanges[axisName];
 
         if (isFinite(value) && value !== null) {
             axisRange = this.valueAxisRanges[axisName] =
@@ -375,55 +356,52 @@ var CategoricalChart = (function (ChartElement) {
             axisRange.min = Math.min(axisRange.min, value);
             axisRange.max = Math.max(axisRange.max, value);
         }
-    };
+    }
 
-    CategoricalChart.prototype.seriesValueAxis = function seriesValueAxis (series) {
-        var plotArea = this.plotArea;
-        var axisName = series.axis;
-        var axis = axisName ? plotArea.namedValueAxes[axisName] : plotArea.valueAxis;
+    seriesValueAxis(series) {
+        const plotArea = this.plotArea;
+        const axisName = series.axis;
+        const axis = axisName ? plotArea.namedValueAxes[axisName] : plotArea.valueAxis;
 
         if (!axis) {
             throw new Error("Unable to locate value axis with name " + axisName);
         }
 
         return axis;
-    };
-
-    CategoricalChart.prototype.reflow = function reflow (targetBox) {
-        var this$1 = this;
+    }
 
-        var categorySlots = this.categorySlots = [];
-        var chartPoints = this.points;
-        var categoryAxis = this.categoryAxis;
-        var pointIx = 0;
+    reflow(targetBox) {
+        const categorySlots = this.categorySlots = [];
+        const chartPoints = this.points;
+        const categoryAxis = this.categoryAxis;
+        let pointIx = 0;
 
-        this.traverseDataPoints(function (data, fields) {
-            var categoryIx = fields.categoryIx;
-            var currentSeries = fields.series;
+        this.traverseDataPoints((data, fields) => {
+            const { categoryIx, series: currentSeries } = fields;
 
-            var valueAxis = this$1.seriesValueAxis(currentSeries);
-            var point = chartPoints[pointIx++];
+            const valueAxis = this.seriesValueAxis(currentSeries);
+            const point = chartPoints[pointIx++];
 
-            var categorySlot = categorySlots[categoryIx];
+            let categorySlot = categorySlots[categoryIx];
             if (!categorySlot) {
                 categorySlots[categoryIx] = categorySlot =
-                    this$1.categorySlot(categoryAxis, categoryIx, valueAxis);
+                    this.categorySlot(categoryAxis, categoryIx, valueAxis);
             }
 
             if (point) {
-                var plotRange = this$1.plotRange(point, valueAxis.startValue());
-                var valueSlot = this$1.valueSlot(valueAxis, plotRange);
+                const plotRange = this.plotRange(point, valueAxis.startValue());
+                const valueSlot = this.valueSlot(valueAxis, plotRange);
                 if (valueSlot) {
-                    var pointSlot = this$1.pointSlot(categorySlot, valueSlot);
+                    const pointSlot = this.pointSlot(categorySlot, valueSlot);
 
-                    point.aboveAxis = this$1.aboveAxis(point, valueAxis);
+                    point.aboveAxis = this.aboveAxis(point, valueAxis);
                     point.stackValue = plotRange[1];
 
-                    if (this$1.options.isStacked100) {
-                        point.percentage = this$1.plotValue(point);
+                    if (this.options.isStacked100) {
+                        point.percentage = this.plotValue(point);
                     }
 
-                    this$1.reflowPoint(point, pointSlot);
+                    this.reflowPoint(point, pointSlot);
                 } else {
                     point.visible = false;
                 }
@@ -436,105 +414,101 @@ var CategoricalChart = (function (ChartElement) {
         }
 
         this.box = targetBox;
-    };
+    }
 
-    CategoricalChart.prototype.valueSlot = function valueSlot (valueAxis, plotRange) {
+    valueSlot(valueAxis, plotRange) {
         return valueAxis.getSlot(plotRange[0], plotRange[1], !this.options.clip);
-    };
-
-    CategoricalChart.prototype.limitPoints = function limitPoints () {
-        var this$1 = this;
+    }
 
-        var categoryPoints = this.categoryPoints;
-        var points = categoryPoints[0].concat(last(categoryPoints));
-        for (var idx = 0; idx < points.length; idx++) {
+    limitPoints() {
+        const categoryPoints = this.categoryPoints;
+        const points = categoryPoints[0].concat(last(categoryPoints));
+        for (let idx = 0; idx < points.length; idx++) {
             if (points[idx]) {
-                this$1.limitPoint(points[idx]);
+                this.limitPoint(points[idx]);
             }
         }
-    };
+    }
 
-    CategoricalChart.prototype.limitPoint = function limitPoint (point) {
-        var limitedSlot = this.categoryAxis.limitSlot(point.box);
+    limitPoint(point) {
+        const limitedSlot = this.categoryAxis.limitSlot(point.box);
         if (!limitedSlot.equals(point.box)) {
             point.reflow(limitedSlot);
         }
-    };
+    }
 
-    CategoricalChart.prototype.aboveAxis = function aboveAxis (point, valueAxis) {
-        var axisCrossingValue = this.categoryAxisCrossingValue(valueAxis);
-        var value = point.value;
+    aboveAxis(point, valueAxis) {
+        const axisCrossingValue = this.categoryAxisCrossingValue(valueAxis);
+        const value = point.value;
 
         return valueAxis.options.reverse ?
             value < axisCrossingValue : value >= axisCrossingValue;
-    };
+    }
 
-    CategoricalChart.prototype.categoryAxisCrossingValue = function categoryAxisCrossingValue (valueAxis) {
-        var categoryAxis = this.categoryAxis;
-        var options = valueAxis.options;
-        var crossingValues = [].concat(
+    categoryAxisCrossingValue(valueAxis) {
+        const categoryAxis = this.categoryAxis;
+        const options = valueAxis.options;
+        const crossingValues = [].concat(
             options.axisCrossingValues || options.axisCrossingValue
         );
 
         return crossingValues[categoryAxis.axisIndex || 0] || 0;
-    };
+    }
 
-    CategoricalChart.prototype.reflowPoint = function reflowPoint (point, pointSlot) {
+    reflowPoint(point, pointSlot) {
         point.reflow(pointSlot);
-    };
+    }
 
-    CategoricalChart.prototype.reflowCategories = function reflowCategories () { };
+    reflowCategories() { }
 
-    CategoricalChart.prototype.pointSlot = function pointSlot (categorySlot, valueSlot) {
-        var options = this.options;
-        var invertAxes = options.invertAxes;
-        var slotX = invertAxes ? valueSlot : categorySlot;
-        var slotY = invertAxes ? categorySlot : valueSlot;
+    pointSlot(categorySlot, valueSlot) {
+        const options = this.options;
+        const invertAxes = options.invertAxes;
+        const slotX = invertAxes ? valueSlot : categorySlot;
+        const slotY = invertAxes ? categorySlot : valueSlot;
 
         return new Box(slotX.x1, slotY.y1, slotX.x2, slotY.y2);
-    };
+    }
 
-    CategoricalChart.prototype.categorySlot = function categorySlot (categoryAxis, categoryIx) {
+    categorySlot(categoryAxis, categoryIx) {
         return categoryAxis.getSlot(categoryIx);
-    };
-
-    CategoricalChart.prototype.traverseDataPoints = function traverseDataPoints (callback) {
-        var this$1 = this;
+    }
 
-        var series = this.options.series;
-        var count = categoriesCount(series);
-        var seriesCount = series.length;
+    traverseDataPoints(callback) {
+        const series = this.options.series;
+        const count = categoriesCount(series);
+        const seriesCount = series.length;
 
-        for (var seriesIx = 0; seriesIx < seriesCount; seriesIx++) {
-            this$1._outOfRangeCallback(series[seriesIx], "_outOfRangeMinPoint", seriesIx, callback);
+        for (let seriesIx = 0; seriesIx < seriesCount; seriesIx++) {
+            this._outOfRangeCallback(series[seriesIx], "_outOfRangeMinPoint", seriesIx, callback);
         }
 
-        for (var categoryIx = 0; categoryIx < count; categoryIx++) {
-            for (var seriesIx$1 = 0; seriesIx$1 < seriesCount; seriesIx$1++) {
-                var currentSeries = series[seriesIx$1];
-                var currentCategory = this$1.categoryAxis.categoryAt(categoryIx);
-                var pointData = this$1.plotArea.bindPoint(currentSeries, categoryIx);
+        for (let categoryIx = 0; categoryIx < count; categoryIx++) {
+            for (let seriesIx = 0; seriesIx < seriesCount; seriesIx++) {
+                const currentSeries = series[seriesIx];
+                const currentCategory = this.categoryAxis.categoryAt(categoryIx);
+                const pointData = this.plotArea.bindPoint(currentSeries, categoryIx);
 
                 callback(pointData, {
                     category: currentCategory,
                     categoryIx: categoryIx,
                     categoriesCount: count,
                     series: currentSeries,
-                    seriesIx: seriesIx$1
+                    seriesIx: seriesIx
                 });
             }
         }
 
-        for (var seriesIx$2 = 0; seriesIx$2 < seriesCount; seriesIx$2++) {
-            this$1._outOfRangeCallback(series[seriesIx$2], "_outOfRangeMaxPoint", seriesIx$2, callback);
+        for (let seriesIx = 0; seriesIx < seriesCount; seriesIx++) {
+            this._outOfRangeCallback(series[seriesIx], "_outOfRangeMaxPoint", seriesIx, callback);
         }
-    };
+    }
 
-    CategoricalChart.prototype._outOfRangeCallback = function _outOfRangeCallback (series, field, seriesIx, callback) {
-        var outOfRangePoint = series[field];
+    _outOfRangeCallback(series, field, seriesIx, callback) {
+        const outOfRangePoint = series[field];
         if (outOfRangePoint) {
-            var categoryIx = outOfRangePoint.categoryIx;
-            var pointData = this.plotArea.bindPoint(series, categoryIx, outOfRangePoint.item);
+            const categoryIx = outOfRangePoint.categoryIx;
+            const pointData = this.plotArea.bindPoint(series, categoryIx, outOfRangePoint.item);
 
             callback(pointData, {
                 category: outOfRangePoint.category,
@@ -544,22 +518,20 @@ var CategoricalChart = (function (ChartElement) {
                 dataItem: outOfRangePoint.item
             });
         }
-    };
+    }
 
-    CategoricalChart.prototype.formatPointValue = function formatPointValue (point, format) {
+    formatPointValue(point, format) {
         if (point.value === null) {
             return "";
         }
 
         return this.chartService.format.auto(format, point.value);
-    };
+    }
 
-    CategoricalChart.prototype.pointValue = function pointValue (data) {
+    pointValue(data) {
         return data.valueFields.value;
-    };
-
-    return CategoricalChart;
-}(ChartElement));
+    }
+}
 
 setDefaultOptions(CategoricalChart, {
     series: [],