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

package/dist/es/chart/trendlines/scatter-polynomial-trendline.js

@@ -3,32 +3,27 @@ import scatterValueGetter from './scatter-value-getter';
 import calculatePolynomial from './calculate-polynomial';
 
 function scatterPolynomialTrendline(context) {
-    var options = context.options;
-    var seriesValues = context.seriesValues;
+    const {
+        options,
+        seriesValues
+    } = context;
 
-    var data = getData({ seriesValues: seriesValues, options: options });
+    const data = getData({ seriesValues, options });
     if (data) {
         return Object.assign({}, options,
 
             {type: 'scatterLine',
-            data: data});
+            data});
     }
 
     return null;
 }
 
-function getData(ref) {
-    var seriesValues = ref.seriesValues;
-    var options = ref.options;
-
-    var order = (options.trendline || {}).order;
-    var valueGetter = scatterValueGetter(options.field);
-    var ref$1 = calculatePolynomial(seriesValues(), valueGetter, order);
-    var count = ref$1.count;
-    var valueMapper = ref$1.valueMapper;
-    var xMin = ref$1.xMin;
-    var xMax = ref$1.xMax;
-    var range = { xMin: xMin, xMax: xMax };
+function getData({ seriesValues, options }) {
+    const order = (options.trendline || {}).order;
+    const valueGetter = scatterValueGetter(options.field);
+    const { count, valueMapper, xMin, xMax } = calculatePolynomial(seriesValues(), valueGetter, order);
+    const range = { xMin, xMax };
 
     if (count > 0) {
         // Polynomial trendline equation:

package/dist/es/chart/trendlines/scatter-power-trendline.js

@@ -5,47 +5,40 @@ import scatterValueGetter from './scatter-value-getter';
 import xValueLimits from './x-value-limits';
 
 function scatterPowerTrendline(context) {
-    var options = context.options;
-    var seriesValues = context.seriesValues;
+    const {
+        options,
+        seriesValues
+    } = context;
 
-    var data = getData({ seriesValues: seriesValues, options: options });
+    const data = getData({ seriesValues, options });
     if (data) {
         return Object.assign({}, options,
 
             {type: 'scatterLine',
-            data: data});
+            data});
     }
 
     return null;
 }
 
-var valueGetter = function (fieldName) { return function (ref) {
-        var valueFields = ref.valueFields;
+const valueGetter = fieldName => ({ valueFields }) =>
+    ({ xValue: Math.log(valueFields.x), yValue: Math.log(valueFields[fieldName]) });
 
-        return ({ xValue: Math.log(valueFields.x), yValue: Math.log(valueFields[fieldName]) });
-; }    };
-
-function getData(ref) {
-    var seriesValues = ref.seriesValues;
-    var options = ref.options;
-
-    var sourceValues = seriesValues();
+function getData({ seriesValues, options }) {
+    const sourceValues = seriesValues();
     if (!checkAllPositive(sourceValues, 'x')) {
         return null;
     }
 
-    var ref$1 = calculateSlope(sourceValues, valueGetter(options.field));
-    var slope = ref$1.slope;
-    var intercept = ref$1.intercept;
-    var count = ref$1.count;
-    var range = xValueLimits(sourceValues, scatterValueGetter(options.field));
+    let { slope, intercept, count } = calculateSlope(sourceValues, valueGetter(options.field));
+    let range = xValueLimits(sourceValues, scatterValueGetter(options.field));
 
     if (count > 0) {
         // Power trendline equation:
         // y = a * x ^ b
-        var a = Math.exp(intercept);
-        var b = slope;
-        return getScatterTrendlineData(function (x) { return a * Math.pow(x, b); }, range, options.trendline);
+        const a = Math.exp(intercept);
+        const b = slope;
+        return getScatterTrendlineData(x => a * Math.pow(x, b), range, options.trendline);
     }
 
     return null;

package/dist/es/chart/trendlines/scatter-trendline-registry.js

@@ -13,7 +13,7 @@ import scatterMovingAverageTrendline from './scatter-moving-average';
 import scatterPolynomialTrendline from './scatter-polynomial-trendline';
 import scatterPowerTrendline from './scatter-power-trendline';
 
-var scatterRegistry = {};
+const scatterRegistry = {};
 scatterRegistry[TRENDLINE_EXPONENTIAL] = scatterExponentialTrendline;
 scatterRegistry[TRENDLINE_LINEAR] = scatterLinearTrendline;
 scatterRegistry[TRENDLINE_LOGARITHMIC] = scatterLogarithmicTrendline;

package/dist/es/chart/trendlines/scatter-value-getter.js

@@ -1,7 +1,4 @@
-var scatterValueGetter = function (fieldName) { return function (ref) {
-        var valueFields = ref.valueFields;
-
-        return ({ xValue: valueFields.x, yValue: valueFields[fieldName] });
-; }    };
+const scatterValueGetter = fieldName => ({ valueFields }) =>
+    ({ xValue: valueFields.x, yValue: valueFields[fieldName] });
 
 export default scatterValueGetter;

package/dist/es/chart/trendlines/trendline-factory.js

@@ -1,5 +1,5 @@
 function trendlineFactory(registry, type, context) {
-    var impl = registry[String(type)];
+    const impl = registry[String(type)];
     if (impl) {
         return impl(context);
     }

package/dist/es/chart/trendlines/trendline-registry.js

@@ -13,7 +13,7 @@ import movingAverageTrendline from './moving-average';
 import polynomialTrendline from './polynomial-trendline';
 import powerTrendline from './power-trendline';
 
-var registry = {};
+const registry = {};
 registry[TRENDLINE_EXPONENTIAL] = exponentialTrendline;
 registry[TRENDLINE_LINEAR] = linearTrendline;
 registry[TRENDLINE_LOGARITHMIC] = logarithmicTrendline;

package/dist/es/chart/trendlines/x-value-limits.js

@@ -1,12 +1,10 @@
 function xValueLimits(sourceValues, valueGetter) {
-    var xMin = Number.MAX_VALUE;
-    var xMax = Number.MIN_VALUE;
+    let xMin = Number.MAX_VALUE;
+    let xMax = Number.MIN_VALUE;
 
-    for (var i = 0; i < sourceValues.length; i++) {
-        var value = sourceValues[i];
-        var ref = valueGetter(value);
-        var xValue = ref.xValue;
-        var yValue = ref.yValue;
+    for (let i = 0; i < sourceValues.length; i++) {
+        const value = sourceValues[i];
+        const { xValue, yValue } = valueGetter(value);
 
         if (isFinite(xValue) && xValue !== null && isFinite(yValue) && yValue !== null) {
             xMin = Math.min(xValue, xMin);
@@ -14,7 +12,7 @@ function xValueLimits(sourceValues, valueGetter) {
         }
     }
 
-    return { xMin: xMin, xMax: xMax };
+    return { xMin, xMax };
 }
 
 export default xValueLimits;

package/dist/es/chart/utils/any-has-z-index.js

@@ -1,7 +1,7 @@
 import { defined } from '../../common';
 
 export default function anyHasZIndex(elements) {
-    for (var idx = 0; idx < elements.length; idx++) {
+    for (let idx = 0; idx < elements.length; idx++) {
         if (defined(elements[idx].zIndex)) {
             return true;
         }

package/dist/es/chart/utils/bind-segments.js

@@ -3,14 +3,14 @@ import SeriesBinder from '../series-binder';
 import segmentVisible from './segment-visible';
 
 export default function bindSegments(series) {
-    var data = series.data;
-    var points = [];
-    var sum = 0;
-    var count = 0;
-
-    for (var idx = 0; idx < data.length; idx++) {
-        var pointData = SeriesBinder.current.bindPoint(series, idx);
-        var value = pointData.valueFields.value;
+    const data = series.data;
+    const points = [];
+    let sum = 0;
+    let count = 0;
+
+    for (let idx = 0; idx < data.length; idx++) {
+        const pointData = SeriesBinder.current.bindPoint(series, idx);
+        let value = pointData.valueFields.value;
 
 
         if (isString(value)) {

package/dist/es/chart/utils/categories-count.js

@@ -1,8 +1,8 @@
 export default function categoriesCount(series) {
-    var seriesCount = series.length;
-    var categories = 0;
+    const seriesCount = series.length;
+    let categories = 0;
 
-    for (var i = 0; i < seriesCount; i++) {
+    for (let i = 0; i < seriesCount; i++) {
         categories = Math.max(categories, series[i].data.length);
     }
 

package/dist/es/chart/utils/count-numbers.js

@@ -1,11 +1,11 @@
 import { isNumber } from '../../common';
 
 export default function countNumbers(values) {
-    var length = values.length;
-    var count = 0;
+    const length = values.length;
+    let count = 0;
 
-    for (var i = 0; i < length; i++) {
-        var num = values[i];
+    for (let i = 0; i < length; i++) {
+        const num = values[i];
         if (isNumber(num)) {
             count++;
         }

package/dist/es/chart/utils/create-out-of-range-points.js

@@ -2,7 +2,7 @@ import { INTERPOLATE, ZERO } from '../constants';
 import { convertableToNumber } from '../../common';
 import SeriesBinder from '../series-binder';
 
-var AREA_REGEX = /area/i;
+const AREA_REGEX = /area/i;
 
 function seriesMissingValues(series) {
     if (series.missingValues) {
@@ -13,27 +13,19 @@ function seriesMissingValues(series) {
 }
 
 function hasValue(series, item) {
-    var fields = SeriesBinder.current.bindPoint(series, null, item);
-    var valueFields = fields.valueFields;
+    const fields = SeriesBinder.current.bindPoint(series, null, item);
+    const valueFields = fields.valueFields;
 
-    for (var field in valueFields) {
+    for (let field in valueFields) {
         if (convertableToNumber(valueFields[field])) {
             return true;
         }
     }
 }
 
-function findNext(ref) {
-    var start = ref.start;
-    var dir = ref.dir;
-    var min = ref.min;
-    var max = ref.max;
-    var getter = ref.getter;
-    var hasItem = ref.hasItem;
-    var series = ref.series;
-
-    var pointHasValue, outPoint;
-    var idx = start;
+function findNext({ start, dir, min, max, getter, hasItem, series }) {
+    let pointHasValue, outPoint;
+    let idx = start;
     do {
         idx += dir;
         //aggregating and binding the item takes too much time for large number of categories
@@ -50,14 +42,13 @@ function findNext(ref) {
 }
 
 export default function createOutOfRangePoints(series, range, count, getter, hasItem) {
-    var min = range.min;
-    var max = range.max;
-    var hasMinPoint = min > 0 && min < count;
-    var hasMaxPoint = max + 1 < count;
+    const { min, max } = range;
+    const hasMinPoint = min > 0 && min < count;
+    const hasMaxPoint = max + 1 < count;
 
     if (hasMinPoint || hasMaxPoint) {
-        var missingValues = seriesMissingValues(series);
-        var minPoint, maxPoint;
+        const missingValues = seriesMissingValues(series);
+        let minPoint, maxPoint;
         if (missingValues !== INTERPOLATE) {
             if (hasMinPoint) {
                 minPoint = getter(min - 1);
@@ -67,7 +58,7 @@ export default function createOutOfRangePoints(series, range, count, getter, has
                 maxPoint = getter(max + 1);
             }
         } else {
-            var outPoint, pointHasValue;
+            let outPoint, pointHasValue;
             if (hasMinPoint) {
                 outPoint = getter(min - 1);
                 pointHasValue = hasValue(series, outPoint.item);

package/dist/es/chart/utils/eval-options.js

@@ -1,14 +1,11 @@
 import { inArray, isFunction, isObject, valueOrDefault, hasOwnProperty } from '../../common';
 
-var MAX_EXPAND_DEPTH = 5;
+const MAX_EXPAND_DEPTH = 5;
 
-export default function evalOptions(options, context, state, dryRun) {
-    if ( state === void 0 ) state = {};
-    if ( dryRun === void 0 ) dryRun = false;
-
-    var defaults = state.defaults = state.defaults || {};
-    var depth = state.depth = state.depth || 0;
-    var needsEval = false;
+export default function evalOptions(options, context, state = {}, dryRun = false) {
+    const defaults = state.defaults = state.defaults || {};
+    const depth = state.depth = state.depth || 0;
+    let needsEval = false;
 
     state.excluded = state.excluded || [];
 
@@ -16,9 +13,9 @@ export default function evalOptions(options, context, state, dryRun) {
         return null;
     }
 
-    for (var property in options) {
+    for (let property in options) {
         if (!inArray(property, state.excluded) && hasOwnProperty(options, property)) {
-            var propValue = options[property];
+            const propValue = options[property];
             if (isFunction(propValue)) {
                 needsEval = true;
                 if (!dryRun) {

package/dist/es/chart/utils/filter-series-by-type.js

@@ -1,11 +1,11 @@
 import { inArray } from '../../common';
 
 export default function filterSeriesByType(series, types) {
-    var result = [];
+    const result = [];
 
-    var seriesTypes = [].concat(types);
-    for (var idx = 0; idx < series.length; idx++) {
-        var currentSeries = series[idx];
+    const seriesTypes = [].concat(types);
+    for (let idx = 0; idx < series.length; idx++) {
+        const currentSeries = series[idx];
         if (inArray(currentSeries.type, seriesTypes)) {
             result.push(currentSeries);
         }

package/dist/es/chart/utils/get-field.js

@@ -5,6 +5,6 @@ export default function getField(field, row) {
         return row;
     }
 
-    var get = getter(field, true);
+    const get = getter(field, true);
     return get(row);
 }

package/dist/es/chart/utils/has-gradient-overlay.js

@@ -1,5 +1,5 @@
 export default function hasGradientOverlay(options) {
-    var overlay = options.overlay;
+    const overlay = options.overlay;
 
     return overlay && overlay.gradient && overlay.gradient !== "none";
 }

package/dist/es/chart/utils/is-date-axis.js

@@ -3,8 +3,8 @@ import equalsIgnoreCase from './equals-ignore-case';
 import { DATE } from '../../common/constants';
 
 export default function isDateAxis(axisOptions, sampleCategory) {
-    var type = axisOptions.type;
-    var dateCategory = sampleCategory instanceof Date;
+    const type = axisOptions.type;
+    const dateCategory = sampleCategory instanceof Date;
 
     return (!type && dateCategory) || equalsIgnoreCase(type, DATE);
 }

package/dist/es/chart/utils/parse-date-category.js

@@ -1,13 +1,13 @@
 import { parseDate } from '../../date-utils';
 
-var dateCache = new WeakMap();
+const dateCache = new WeakMap();
 
 export default function parseDateCategory(category, row, intlService) {
     if (row === null || typeof row !== 'object') {
         return parseDate(intlService, category);
     }
 
-    var date = dateCache.get(row);
+    let date = dateCache.get(row);
     if (!date) {
         date = parseDate(intlService, category);
         dateCache.set(row, date);

package/dist/es/chart/utils/segment-visible.js

@@ -1,12 +1,12 @@
 import { defined } from '../../common';
 
 export default function segmentVisible(series, fields, index) {
-    var visible = fields.visible;
+    const visible = fields.visible;
     if (defined(visible)) {
         return visible;
     }
 
-    var pointVisibility = series.pointVisibility;
+    const pointVisibility = series.pointVisibility;
     if (pointVisibility) {
         return pointVisibility[index];
     }

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

@@ -6,38 +6,28 @@ import categoriesCount from '../utils/categories-count';
 
 import { isNumber } from '../../common';
 
-var WaterfallChart = (function (BarChart) {
-    function WaterfallChart () {
-        BarChart.apply(this, arguments);
-    }
-
-    if ( BarChart ) WaterfallChart.__proto__ = BarChart;
-    WaterfallChart.prototype = Object.create( BarChart && BarChart.prototype );
-    WaterfallChart.prototype.constructor = WaterfallChart;
-
-    WaterfallChart.prototype.render = function render () {
-        BarChart.prototype.render.call(this);
+class WaterfallChart extends BarChart {
+    render() {
+        super.render();
         this.createSegments();
-    };
-
-    WaterfallChart.prototype.traverseDataPoints = function traverseDataPoints (callback) {
-        var this$1 = this;
+    }
 
-        var series = this.options.series;
-        var totalCategories = categoriesCount(series);
-        var isVertical = !this.options.invertAxes;
+    traverseDataPoints(callback) {
+        const series = this.options.series;
+        const totalCategories = categoriesCount(series);
+        const isVertical = !this.options.invertAxes;
 
-        for (var seriesIx = 0; seriesIx < series.length; seriesIx++) {
-            var currentSeries = series[seriesIx];
-            var total = 0;
-            var runningTotal = 0;
+        for (let seriesIx = 0; seriesIx < series.length; seriesIx++) {
+            const currentSeries = series[seriesIx];
+            let total = 0;
+            let runningTotal = 0;
 
-            for (var categoryIx = 0; categoryIx < totalCategories; categoryIx++) {
-                var data = SeriesBinder.current.bindPoint(currentSeries, categoryIx);
-                var value = data.valueFields.value;
-                var summary = data.fields.summary;
-                var from = total;
-                var to = (void 0);
+            for (let categoryIx = 0; categoryIx < totalCategories; categoryIx++) {
+                const data = SeriesBinder.current.bindPoint(currentSeries, categoryIx);
+                const value = data.valueFields.value;
+                const summary = data.fields.summary;
+                let from = total;
+                let to;
 
                 if (summary) {
                     if (summary.toLowerCase() === "total") {
@@ -56,7 +46,7 @@ var WaterfallChart = (function (BarChart) {
                 }
 
                 callback(data, {
-                    category: this$1.categoryAxis.categoryAt(categoryIx),
+                    category: this.categoryAxis.categoryAt(categoryIx),
                     categoryIx: categoryIx,
                     series: currentSeries,
                     seriesIx: seriesIx,
@@ -68,49 +58,45 @@ var WaterfallChart = (function (BarChart) {
                 });
             }
         }
-    };
+    }
 
-    WaterfallChart.prototype.updateRange = function updateRange (value, fields) {
-        BarChart.prototype.updateRange.call(this, { value: fields.to }, fields);
-    };
+    updateRange(value, fields) {
+        super.updateRange({ value: fields.to }, fields);
+    }
 
-    WaterfallChart.prototype.aboveAxis = function aboveAxis (point) {
+    aboveAxis(point) {
         return point.value >= 0;
-    };
+    }
 
-    WaterfallChart.prototype.plotRange = function plotRange (point) {
+    plotRange(point) {
         return [ point.from, point.to ];
-    };
-
-    WaterfallChart.prototype.createSegments = function createSegments () {
-        var this$1 = this;
+    }
 
-        var series = this.options.series;
-        var seriesPoints = this.seriesPoints;
-        var segments = this.segments = [];
+    createSegments() {
+        const series = this.options.series;
+        const seriesPoints = this.seriesPoints;
+        const segments = this.segments = [];
 
-        for (var seriesIx = 0; seriesIx < series.length; seriesIx++) {
-            var currentSeries = series[seriesIx];
-            var points = seriesPoints[seriesIx];
+        for (let seriesIx = 0; seriesIx < series.length; seriesIx++) {
+            const currentSeries = series[seriesIx];
+            const points = seriesPoints[seriesIx];
 
             if (points) {
-                var prevPoint = (void 0);
-                for (var pointIx = 0; pointIx < points.length; pointIx++) {
-                    var point = points[pointIx];
+                let prevPoint;
+                for (let pointIx = 0; pointIx < points.length; pointIx++) {
+                    const point = points[pointIx];
 
                     if (point && prevPoint) {
-                        var segment = new WaterfallSegment(prevPoint, point, currentSeries);
+                        const segment = new WaterfallSegment(prevPoint, point, currentSeries);
                         segments.push(segment);
-                        this$1.append(segment);
+                        this.append(segment);
                     }
 
                     prevPoint = point;
                 }
             }
         }
-    };
-
-    return WaterfallChart;
-}(BarChart));
+    }
+}
 
 export default WaterfallChart;

package/dist/es/chart/waterfall-chart/waterfall-segment.js

@@ -6,34 +6,28 @@ import { FADEIN, INITIAL_ANIMATION_DURATION } from '../constants';
 
 import { alignPathToPixel, setDefaultOptions } from '../../common';
 
-var WaterfallSegment = (function (ChartElement) {
-    function WaterfallSegment(from, to, series) {
-        ChartElement.call(this);
+class WaterfallSegment extends ChartElement {
+    constructor(from, to, series) {
+        super();
 
         this.from = from;
         this.to = to;
         this.series = series;
     }
 
-    if ( ChartElement ) WaterfallSegment.__proto__ = ChartElement;
-    WaterfallSegment.prototype = Object.create( ChartElement && ChartElement.prototype );
-    WaterfallSegment.prototype.constructor = WaterfallSegment;
-
-    WaterfallSegment.prototype.linePoints = function linePoints () {
-        var from = this.from;
-        var ref = this;
-        var fromBox = ref.from.box;
-        var toBox = ref.to.box;
-        var points = [];
+    linePoints() {
+        const from = this.from;
+        const { from: { box: fromBox }, to: { box: toBox } } = this;
+        const points = [];
 
         if (from.isVertical) {
-            var y = from.aboveAxis ? fromBox.y1 : fromBox.y2;
+            const y = from.aboveAxis ? fromBox.y1 : fromBox.y2;
             points.push(
                 [ fromBox.x1, y ],
                 [ toBox.x2, y ]
             );
         } else {
-            var x = from.aboveAxis ? fromBox.x2 : fromBox.x1;
+            const x = from.aboveAxis ? fromBox.x2 : fromBox.x1;
             points.push(
                 [ x, fromBox.y1 ],
                 [ x, toBox.y2 ]
@@ -41,14 +35,14 @@ var WaterfallSegment = (function (ChartElement) {
         }
 
         return points;
-    };
+    }
 
-    WaterfallSegment.prototype.createVisual = function createVisual () {
-        ChartElement.prototype.createVisual.call(this);
+    createVisual() {
+        super.createVisual();
 
-        var line = this.series.line || {};
+        const line = this.series.line || {};
 
-        var path = draw.Path.fromPoints(this.linePoints(), {
+        const path = draw.Path.fromPoints(this.linePoints(), {
             stroke: {
                 color: line.color,
                 width: line.width,
@@ -59,10 +53,8 @@ var WaterfallSegment = (function (ChartElement) {
 
         alignPathToPixel(path);
         this.visual.append(path);
-    };
-
-    return WaterfallSegment;
-}(ChartElement));
+    }
+}
 
 setDefaultOptions(WaterfallSegment, {
     animation: {

package/dist/es/chart-wizard/get-wizard-data-from-data-rows.js

@@ -1,14 +1,13 @@
 import getter from './../common/getter';
 
 export function getWizardDataFromDataRows(dataRows) {
-    var result = [];
+    const result = [];
 
-    dataRows.forEach(function (item) {
-        var dataItem = item.dataItem;
-        var dataColumns = item.dataColumns;
+    dataRows.forEach(item => {
+        const { dataItem, dataColumns } = item;
 
-        var row = [];
-        dataColumns.forEach(function (column) {
+        const row = [];
+        dataColumns.forEach(column => {
             row.push({
                 field: column.title || column.field,
                 value: getter(column.field)(dataItem)