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

package/dist/es/chart/theme/load-theme.js

@@ -1,16 +1,16 @@
-var SERIES_COLORS = 30;
-var seriesVar = '--kendo-chart-series-';
-var elementStyles = function (element) { return element.ownerDocument.defaultView.getComputedStyle(element); };
-var cache = {};
+const SERIES_COLORS = 30;
+const seriesVar = '--kendo-chart-series-';
+const elementStyles = element => element.ownerDocument.defaultView.getComputedStyle(element);
+const cache = {};
 
-var toColor = function (colorMix, element) {
+const toColor = (colorMix, element) => {
     if (cache[colorMix]) {
         return cache[colorMix];
     }
 
-    var curColor = element.style.color;
+    const curColor = element.style.color;
     element.style.color = colorMix;
-    var color = elementStyles(element).color;
+    const color = elementStyles(element).color;
     element.style.color = curColor;
 
     cache[colorMix] = color;
@@ -18,45 +18,45 @@ var toColor = function (colorMix, element) {
     return color;
 };
 
-var getProp = function (element, prop) {
-    var value = elementStyles(element).getPropertyValue(prop);
+const getProp = (element, prop) => {
+    let value = elementStyles(element).getPropertyValue(prop);
     if (/^color-mix/i.test(value)) {
         value = toColor(value, element);
     }
     return value;
 };
 
-var getNumberProp = function (element, prop) { return parseFloat(elementStyles(element).getPropertyValue(prop)); };
+const getNumberProp = (element, prop) => parseFloat(elementStyles(element).getPropertyValue(prop));
 
-var getFont = function (element, weightProp, sizeProp, familyProp) {
-    var styles = elementStyles(element);
+const getFont = (element, weightProp, sizeProp, familyProp) => {
+    const styles = elementStyles(element);
     return [styles.getPropertyValue(weightProp), styles.getPropertyValue(sizeProp), styles.getPropertyValue(familyProp) || styles.fontFamily].join(" ");
 };
 
-var getSeriesColors = function (element) {
-    var styles = elementStyles(element);
-    var result = [];
-    var count = 1;
-    var color = styles.getPropertyValue(("" + seriesVar + count));
+const getSeriesColors = (element) => {
+    const styles = elementStyles(element);
+    const result = [];
+    let count = 1;
+    let color = styles.getPropertyValue(`${seriesVar}${count}`);
     while (color || count <= SERIES_COLORS) {
         result.push(color);
         count++;
-        color = styles.getPropertyValue(("" + seriesVar + count));
+        color = styles.getPropertyValue(`${seriesVar}${count}`);
     }
     return result;
 };
 
-var defaultFont = function (element) { return getFont(element, "--kendo-font-weight", '--kendo-chart-font-size', "--kendo-font-family"); };
-var paneTitleFont = function (element) { return getFont(element, "--kendo-chart-pane-title-font-weight", '--kendo-chart-pane-title-font-size', "--kendo-font-family"); };
-var normalTextColor = function (element) { return getProp(element, "--kendo-chart-text"); };
+const defaultFont = element => getFont(element, "--kendo-font-weight", '--kendo-chart-font-size', "--kendo-font-family");
+const paneTitleFont = (element) => getFont(element, "--kendo-chart-pane-title-font-weight", '--kendo-chart-pane-title-font-size', "--kendo-font-family");
+const normalTextColor = (element) => getProp(element, "--kendo-chart-text");
 
-var title = function (element) { return ({
+const title = (element) => ({
     color: normalTextColor(element),
     font: getFont(element, "--kendo-font-weight", '--kendo-chart-title-font-size', "--kendo-font-family"),
-}); };
+});
 
-var sankeyLegend = function (element) {
-    var textColorNormal = normalTextColor(element);
+const sankeyLegend = (element) => {
+    const textColorNormal = normalTextColor(element);
     return {
         labels: {
             color: textColorNormal,
@@ -68,8 +68,8 @@ var sankeyLegend = function (element) {
     };
 };
 
-var chartLegend = function (element) {
-    var inactiveColor = getProp(element, "--kendo-chart-inactive");
+const chartLegend = (element) => {
+    const inactiveColor = getProp(element, "--kendo-chart-inactive");
     return Object.assign({}, {inactiveItems: {
             labels: {
                 color: inactiveColor,
@@ -81,8 +81,8 @@ var chartLegend = function (element) {
         sankeyLegend(element));
 };
 
-export var gaugeTheme = function (element) {
-    var textColorNormal = normalTextColor(element);
+export const gaugeTheme = (element) => {
+    const textColorNormal = normalTextColor(element);
     return {
         pointer: {
             color: getProp(element, "--kendo-chart-gauge-pointer")
@@ -109,7 +109,7 @@ export var gaugeTheme = function (element) {
     };
 };
 
-export var sankeyTheme = function (element) { return ({
+export const sankeyTheme = (element) => ({
     labels: {
         color: normalTextColor(element),
         font: defaultFont(element),
@@ -123,9 +123,9 @@ export var sankeyTheme = function (element) { return ({
     nodeColors: getSeriesColors(element),
     title: title(element),
     legend: sankeyLegend(element),
-}); };
+});
 
-var notes = function (element) { return ({
+const notes = (element) => ({
     icon: {
         background: getProp(element, "--kendo-chart-notes-bg"),
         border: {
@@ -138,19 +138,19 @@ var notes = function (element) { return ({
     label: {
         font: defaultFont(element),
     },
-}); };
+});
 
-export var chartTheme = function (element) {
-    var majorLines = getProp(element, "--kendo-chart-major-lines");
-    var normalTextColor = getProp(element, "--kendo-chart-text");
-    var axisLabelFont = getFont(element, "--kendo-font-weight", "--kendo-chart-label-font-size", "--kendo-font-family");
-    var chartBg = getProp(element, "--kendo-chart-bg");
-    var notesProps = notes(element);
-    var areaOpacity = getNumberProp(element, "--kendo-chart-area-opacity");
-    var surfaceColor = getProp(element, "--kendo-color-surface");
-    var primaryBg = getProp(element, "--kendo-chart-primary-bg");
+export const chartTheme = (element) => {
+    const majorLines = getProp(element, "--kendo-chart-major-lines");
+    const normalTextColor = getProp(element, "--kendo-chart-text");
+    const axisLabelFont = getFont(element, "--kendo-font-weight", "--kendo-chart-label-font-size", "--kendo-font-family");
+    const chartBg = getProp(element, "--kendo-chart-bg");
+    const notesProps = notes(element);
+    const areaOpacity = getNumberProp(element, "--kendo-chart-area-opacity");
+    const surfaceColor = getProp(element, "--kendo-color-surface");
+    const primaryBg = getProp(element, "--kendo-chart-primary-bg");
 
-    var boxPlot = function () { return ({
+    const boxPlot = () => ({
         downColor: majorLines,
         mean: {
             color: surfaceColor,
@@ -161,32 +161,32 @@ export var chartTheme = function (element) {
         whiskers: {
             color: primaryBg,
         },
-    }); };
+    });
 
-    var waterfall = function () { return ({
+    const waterfall = () => ({
         line: {
             color: majorLines,
         },
-    }); };
+    });
 
-    var area = function () { return ({
+    const area = () => ({
         opacity: areaOpacity,
         highlight: {
             inactiveOpacity: getNumberProp(element, "--kendo-chart-area-inactive-opacity"),
         },
-    }); };
+    });
 
-    var line = function () { return ({
+    const line = () => ({
         highlight: {
             inactiveOpacity: getNumberProp(element, "--kendo-chart-line-inactive-opacity"),
         },
-    }); };
+    });
 
-    var bullet = function () { return ({
+    const bullet = () => ({
         target: {
             color: normalTextColor,
         },
-    }); };
+    });
 
     return {
         axisDefaults: {

package/dist/es/chart/tooltip/base-tooltip.js

@@ -3,29 +3,24 @@ import { Color } from '@progress/kendo-drawing';
 import { Class, defined, deepExtend, setDefaultOptions, valueOrDefault, getSpacing, styleValue } from '../../common';
 import { SHOW_TOOLTIP, HIDE_TOOLTIP } from '../constants';
 
-var BaseTooltip = (function (Class) {
-    function BaseTooltip(chartService, options) {
-        Class.call(this);
+class BaseTooltip extends Class {
+    constructor(chartService, options) {
+        super();
 
         this.chartService = chartService;
         this.options = deepExtend({}, this.options, options);
     }
 
-    if ( Class ) BaseTooltip.__proto__ = Class;
-    BaseTooltip.prototype = Object.create( Class && Class.prototype );
-    BaseTooltip.prototype.constructor = BaseTooltip;
-
-    BaseTooltip.prototype.getStyle = function getStyle (options, point) {
-        var background = options.background;
-        var border = options.border.color;
+    getStyle(options, point) {
+        let { background, border: { color: border } } = options;
 
         if (point) {
-            var pointColor = point.color || point.options.color;
+            const pointColor = point.color || point.options.color;
             background = valueOrDefault(background, pointColor);
             border = valueOrDefault(border, pointColor);
         }
 
-        var padding = options.padding !== undefined ? getSpacing(options.padding) : {};
+        const padding = options.padding !== undefined ? getSpacing(options.padding) : {};
 
         if (typeof options.padding === "object") {
             padding.top = options.padding.top !== undefined ? padding.top : undefined;
@@ -46,18 +41,18 @@ var BaseTooltip = (function (Class) {
             paddingLeft: styleValue(padding.left),
             paddingRight: styleValue(padding.right)
         };
-    };
+    }
 
-    BaseTooltip.prototype.show = function show (options, tooltipOptions, point) {
+    show(options, tooltipOptions, point) {
         if (!this.chartService) {
             return;
         }
         options.format = tooltipOptions.format;
 
-        var style = this.getStyle(tooltipOptions, point);
+        const style = this.getStyle(tooltipOptions, point);
         options.style = style;
 
-        var background = new Color(style.backgroundColor);
+        const background = new Color(style.backgroundColor);
         if (!defined(tooltipOptions.color) && !background.isDark()) {
             options.className = "k-chart-tooltip-inverse";
         }
@@ -65,22 +60,20 @@ var BaseTooltip = (function (Class) {
         this.chartService.notify(SHOW_TOOLTIP, options);
 
         this.visible = true;
-    };
+    }
 
-    BaseTooltip.prototype.hide = function hide () {
+    hide() {
         if (this.chartService) {
             this.chartService.notify(HIDE_TOOLTIP);
         }
 
         this.visible = false;
-    };
+    }
 
-    BaseTooltip.prototype.destroy = function destroy () {
+    destroy() {
         delete this.chartService;
-    };
-
-    return BaseTooltip;
-}(Class));
+    }
+}
 
 setDefaultOptions(BaseTooltip, {
     border: {

package/dist/es/chart/tooltip/shared-tooltip.js

@@ -3,31 +3,27 @@ import { Point } from '../../core';
 
 import { grep, setDefaultOptions } from '../../common';
 
-var SharedTooltip = (function (BaseTooltip) {
-    function SharedTooltip(plotArea, options) {
-        BaseTooltip.call(this, plotArea.chartService, options);
+class SharedTooltip extends BaseTooltip {
+    constructor(plotArea, options) {
+        super(plotArea.chartService, options);
 
         this.plotArea = plotArea;
         this.formatService = plotArea.chartService.format;
     }
 
-    if ( BaseTooltip ) SharedTooltip.__proto__ = BaseTooltip;
-    SharedTooltip.prototype = Object.create( BaseTooltip && BaseTooltip.prototype );
-    SharedTooltip.prototype.constructor = SharedTooltip;
-
-    SharedTooltip.prototype.showAt = function showAt (points, coords) {
-        var tooltipPoints = grep(points, function(point) {
-            var tooltip = point.series.tooltip;
-            var excluded = tooltip && tooltip.visible === false;
+    showAt(points, coords) {
+        const tooltipPoints = grep(points, function(point) {
+            const tooltip = point.series.tooltip;
+            const excluded = tooltip && tooltip.visible === false;
 
             return !excluded;
         });
 
         if (tooltipPoints.length > 0) {
-            var point = tooltipPoints[0];
-            var slot = this.plotArea.categoryAxis.getSlot(point.categoryIx);
+            const point = tooltipPoints[0];
+            const slot = this.plotArea.categoryAxis.getSlot(point.categoryIx);
 
-            var anchor = coords ? this._slotAnchor(coords, slot) : this._defaultAnchor(point, slot);
+            const anchor = coords ? this._slotAnchor(coords, slot) : this._defaultAnchor(point, slot);
 
             this.show({
                 anchor: anchor,
@@ -38,11 +34,11 @@ var SharedTooltip = (function (BaseTooltip) {
                 series: this.plotArea.series
             }, this.options);
         }
-    };
+    }
 
-    SharedTooltip.prototype._slotAnchor = function _slotAnchor (point, slot) {
-        var axis = this.plotArea.categoryAxis;
-        var align = {
+    _slotAnchor(point, slot) {
+        const axis = this.plotArea.categoryAxis;
+        const align = {
             horizontal: "left",
             vertical: "center"
         };
@@ -55,19 +51,19 @@ var SharedTooltip = (function (BaseTooltip) {
             point: point,
             align: align
         };
-    };
-
-    SharedTooltip.prototype._defaultAnchor = function _defaultAnchor (point, slot) {
-        var box = point.owner.pane.chartsBox();
-        var vertical = this.plotArea.categoryAxis.options.vertical;
-        var center = box.center();
-        var slotCenter = slot.center();
-        var align = {
+    }
+
+    _defaultAnchor(point, slot) {
+        const box = point.owner.pane.chartsBox();
+        const vertical = this.plotArea.categoryAxis.options.vertical;
+        const center = box.center();
+        const slotCenter = slot.center();
+        const align = {
             horizontal: "center",
             vertical: "center"
         };
 
-        var centerPoint;
+        let centerPoint;
         if (vertical) {
             centerPoint = new Point(center.x, slotCenter.y);
         } else {
@@ -78,10 +74,8 @@ var SharedTooltip = (function (BaseTooltip) {
             point: centerPoint,
             align: align
         };
-    };
-
-    return SharedTooltip;
-}(BaseTooltip));
+    }
+}
 
 setDefaultOptions(SharedTooltip, {
     categoryFormat: '{0:d}'

package/dist/es/chart/tooltip/tooltip.js

@@ -2,40 +2,30 @@ import BaseTooltip from './base-tooltip';
 
 import { deepExtend } from '../../common';
 
-var Tooltip = (function (BaseTooltip) {
-    function Tooltip () {
-        BaseTooltip.apply(this, arguments);
-    }
-
-    if ( BaseTooltip ) Tooltip.__proto__ = BaseTooltip;
-    Tooltip.prototype = Object.create( BaseTooltip && BaseTooltip.prototype );
-    Tooltip.prototype.constructor = Tooltip;
-
-    Tooltip.prototype.show = function show (point) {
+class Tooltip extends BaseTooltip {
+    show(point) {
         if (!point || !point.tooltipAnchor || (this._current && this._current === point)) {
             return;
         }
 
-        var options = deepExtend({}, this.options, point.options.tooltip);
-        var anchor = point.tooltipAnchor();
+        const options = deepExtend({}, this.options, point.options.tooltip);
+        const anchor = point.tooltipAnchor();
 
         if (anchor) {
             this._current = point;
-            BaseTooltip.prototype.show.call(this, {
+            super.show({
                 point: point,
                 anchor: anchor
             }, options, point);
         } else {
             this.hide();
         }
-    };
+    }
 
-    Tooltip.prototype.hide = function hide () {
+    hide() {
         delete this._current;
-        BaseTooltip.prototype.hide.call(this);
-    };
-
-    return Tooltip;
-}(BaseTooltip));
+        super.hide();
+    }
+}
 
 export default Tooltip;

package/dist/es/chart/trendlines/calculate-moving-average.js

@@ -1,18 +1,16 @@
 import { MIN_MOVING_AVERAGE_PERIOD } from '../constants';
 
 function calculateMovingAverage(sourceValues, valueGetter, period) {
-    var averagePoints = [];
-    var values = [];
-    var start = Math.max(MIN_MOVING_AVERAGE_PERIOD, period) - 1;
+    const averagePoints = [];
+    const values = [];
+    const start = Math.max(MIN_MOVING_AVERAGE_PERIOD, period) - 1;
 
-    var end = 0;
-    var sum = 0;
+    let end = 0;
+    let sum = 0;
 
-    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(yValue) && yValue !== null) {
             values.push(yValue);
@@ -23,11 +21,11 @@ function calculateMovingAverage(sourceValues, valueGetter, period) {
         }
 
         if (i >= start) {
-            var count = values.filter(function (value) { return value !== null; }).length;
-            var lastValue = values.shift() || 0;
+            const count = values.filter(value => value !== null).length;
+            const lastValue = values.shift() || 0;
 
             if (count > 0) {
-                var average = sum / count;
+                const average = sum / count;
                 averagePoints.push([xValue, average]);
 
                 sum -= lastValue;

package/dist/es/chart/trendlines/calculate-polynomial.js

@@ -1,23 +1,21 @@
 import { Matrix } from '../../common';
 
-var MIN_ORDER = 1;
-var MAX_ORDER = 6;
+const MIN_ORDER = 1;
+const MAX_ORDER = 6;
 
 function calculatePolynomial(sourceValues, valueGetter, order) {
-    var k = Math.min(Math.max(order || MIN_ORDER, MIN_ORDER), MAX_ORDER) + 1;
-    var X = new Matrix();
-    var Y = new Matrix();
-    var count = 0;
-    var xMin = Number.MAX_VALUE;
-    var xMax = Number.MIN_VALUE;
-    var valueMapper = function (x) { return x; };
-    var coefficients = [];
+    let k = Math.min(Math.max(order || MIN_ORDER, MIN_ORDER), MAX_ORDER) + 1;
+    let X = new Matrix();
+    let Y = new Matrix();
+    let count = 0;
+    let xMin = Number.MAX_VALUE;
+    let xMax = Number.MIN_VALUE;
+    let valueMapper = x => x;
+    let coefficients = [];
 
-    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];
+        let { xValue, yValue } = valueGetter(value);
 
         if (isFinite(xValue) && xValue !== null && isFinite(yValue) && yValue !== null) {
             xMin = Math.min(xValue, xMin);
@@ -30,7 +28,7 @@ function calculatePolynomial(sourceValues, valueGetter, order) {
             // Set indicator column to 1 for valid values
             X.set(i, 0, 1);
             X.set(i, 1, xValue);
-            for (var pow = 2; pow <= k; pow++) {
+            for (let pow = 2; pow <= k; pow++) {
                 X.set(i, pow, Math.pow(X.get(i, 1), pow));
             }
         } else {
@@ -46,24 +44,24 @@ function calculatePolynomial(sourceValues, valueGetter, order) {
         // Polynomial trendline equation:
         // y = aN * x^N + ... + a2 * x^2 + a1 * x + a0
         coefficients = linearRegression(X, Y);
-        valueMapper = function (x) { return coefficients.reduce(function (y, a, n) { return y + a * Math.pow(x, n); }, 0); };
+        valueMapper = x => coefficients.reduce((y, a, n) => y + a * Math.pow(x, n), 0);
     }
 
     return {
-        coefficients: coefficients,
-        count: count,
-        valueMapper: valueMapper,
-        xMin: xMin,
-        xMax: xMax
+        coefficients,
+        count,
+        valueMapper,
+        xMin,
+        xMax
     };
 }
 
 function linearRegression(X, Y) {
-    var Xt = X.transpose();
-    var B = Xt.multiply(X).inverse().multiply(Xt).multiply(Y); // the last square estimate of the coefficients
+    const Xt = X.transpose();
+    const B = Xt.multiply(X).inverse().multiply(Xt).multiply(Y); // the last square estimate of the coefficients
 
-    var coefficients = [];
-    for (var i = 0; i < B.height; i++) {
+    const coefficients = [];
+    for (let i = 0; i < B.height; i++) {
         coefficients.push(B.get(i, 0));
     }
 

package/dist/es/chart/trendlines/calculate-slope.js

@@ -1,19 +1,17 @@
 // Optimized version of calculatePolynomial for order = 1
 function calculateSlope(sourceValues, valueGetter) {
-    var x = 0;
-    var y = 0;
-    var x2 = 0;
-    var xy = 0;
-    var count = 0;
-    var slope, intercept;
-    var xMin = Number.MAX_VALUE;
-    var xMax = Number.MIN_VALUE;
+    let x = 0;
+    let y = 0;
+    let x2 = 0;
+    let xy = 0;
+    let count = 0;
+    let slope, intercept;
+    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);
@@ -32,7 +30,7 @@ function calculateSlope(sourceValues, valueGetter) {
         intercept = (y - slope * x) / count;
     }
 
-    return { slope: slope, intercept: intercept, count: count, xMin: xMin, xMax: xMax };
+    return { slope, intercept, count, xMin, xMax };
 }
 
 export default calculateSlope;

package/dist/es/chart/trendlines/check-all-positive.js

@@ -1,9 +1,6 @@
 import { hasValue } from '../utils';
 
-var checkAllPositive = function (sourceValues, fieldName) { return sourceValues.every(function (ref) {
-        var valueFields = ref.valueFields;
-
-        return !hasValue(valueFields[fieldName]) || valueFields[fieldName] > 0;
-        }); };
+const checkAllPositive = (sourceValues, fieldName) =>
+    sourceValues.every(({ valueFields }) => !hasValue(valueFields[fieldName]) || valueFields[fieldName] > 0);
 
 export default checkAllPositive;