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

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

@@ -5,9 +5,9 @@ import evalOptions from '../utils/eval-options';
 import colorScale from './color-scale';
 import HeatmapPoint from './heatmap-point';
 
-var HeatmapChart = (function (ChartElement) {
-    function HeatmapChart(plotArea, options) {
-        ChartElement.call(this, options);
+class HeatmapChart extends ChartElement {
+    constructor(plotArea, options) {
+        super(options);
 
         this.plotArea = plotArea;
         this.chartService = plotArea.chartService;
@@ -16,44 +16,36 @@ var HeatmapChart = (function (ChartElement) {
         this.render();
     }
 
-    if ( ChartElement ) HeatmapChart.__proto__ = ChartElement;
-    HeatmapChart.prototype = Object.create( ChartElement && ChartElement.prototype );
-    HeatmapChart.prototype.constructor = HeatmapChart;
-
-    HeatmapChart.prototype._initFields = function _initFields () {
+    _initFields() {
         this.points = [];
         this.seriesOptions = [];
         this.valueRange = { min: MAX_VALUE, max: MIN_VALUE };
         this._evalSeries = [];
-    };
+    }
 
-    HeatmapChart.prototype.render = function render () {
+    render() {
         this.setRange();
         this.traverseDataPoints(this.addValue.bind(this));
-    };
-
-    HeatmapChart.prototype.setRange = function setRange () {
-        var this$1 = this;
+    }
 
-        var ref = this;
-        var series = ref.options.series;
+    setRange() {
+        const { options: { series } } = this;
 
-        for (var seriesIx = 0; seriesIx < series.length; seriesIx++) {
-            var currentSeries = series[seriesIx];
+        for (let seriesIx = 0; seriesIx < series.length; seriesIx++) {
+            const currentSeries = series[seriesIx];
 
-            for (var pointIx = 0; pointIx < currentSeries.data.length; pointIx++) {
-                var ref$1 = this$1.plotArea.bindPoint(currentSeries, pointIx);
-                var valueFields = ref$1.valueFields;
+            for (let pointIx = 0; pointIx < currentSeries.data.length; pointIx++) {
+                const { valueFields } = this.plotArea.bindPoint(currentSeries, pointIx);
                 if (defined(valueFields.value) && valueFields.value !== null) {
-                    this$1.valueRange.min = Math.min(this$1.valueRange.min, valueFields.value);
-                    this$1.valueRange.max = Math.max(this$1.valueRange.max, valueFields.value);
+                    this.valueRange.min = Math.min(this.valueRange.min, valueFields.value);
+                    this.valueRange.max = Math.max(this.valueRange.max, valueFields.value);
                 }
             }
         }
-    };
+    }
 
-    HeatmapChart.prototype.addValue = function addValue (value, fields) {
-        var point;
+    addValue(value, fields) {
+        let point;
         if (value && defined(value.value) && value.value !== null) {
             point = this.createPoint(value, fields);
             if (point) {
@@ -62,12 +54,11 @@ var HeatmapChart = (function (ChartElement) {
         }
 
         this.points.push(point);
-    };
+    }
 
-    HeatmapChart.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",
@@ -76,12 +67,12 @@ var HeatmapChart = (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, {
@@ -94,16 +85,16 @@ var HeatmapChart = (function (ChartElement) {
         }
 
         return pointOptions;
-    };
+    }
 
-    HeatmapChart.prototype.pointType = function pointType () {
+    pointType() {
         return HeatmapPoint;
-    };
+    }
 
-    HeatmapChart.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
@@ -118,12 +109,12 @@ var HeatmapChart = (function (ChartElement) {
         }
 
         return Object.assign({}, options);
-    };
+    }
 
-    HeatmapChart.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.pattern = fields.pattern || pointOptions.pattern;
         pointOptions = this.evalPointOptions(pointOptions, value, fields);
@@ -131,24 +122,23 @@ var HeatmapChart = (function (ChartElement) {
         if (isFunction(series.color)) {
             color = pointOptions.color;
         } else if (this.valueRange.max !== 0) {
-            var scale = colorScale(color);
+            const scale = colorScale(color);
             color = scale(value.value / this.valueRange.max);
         }
 
-        var point = new HeatmapPoint(value, pointOptions);
+        const point = new HeatmapPoint(value, pointOptions);
         point.color = color;
 
         this.append(point);
 
         return point;
-    };
+    }
 
-    HeatmapChart.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);
@@ -158,30 +148,26 @@ var HeatmapChart = (function (ChartElement) {
             throw new Error("Unable to locate Y axis with name " + yAxisName);
         }
 
-        return { xAxis: xAxis, yAxis: yAxis };
-    };
-
-    HeatmapChart.prototype.reflow = function reflow (targetBox) {
-        var this$1 = this;
+        return { xAxis, yAxis };
+    }
 
-        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 ref = this$1.seriesAxes(fields.series);
-            var xAxis = ref.xAxis;
-            var yAxis = ref.yAxis;
-            var indexX = xAxis.categoryIndex(value.x);
-            var indexY = yAxis.categoryIndex(value.y);
-            var slotX = xAxis.getSlot(indexX, indexX, limit);
-            var slotY = yAxis.getSlot(indexY, indexY, limit);
+        this.traverseDataPoints((value, fields) => {
+            const point = chartPoints[pointIx++];
+            const { xAxis, yAxis } = this.seriesAxes(fields.series);
+            const indexX = xAxis.categoryIndex(value.x);
+            const indexY = yAxis.categoryIndex(value.y);
+            const slotX = xAxis.getSlot(indexX, indexX, limit);
+            const slotY = yAxis.getSlot(indexY, indexY, 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;
@@ -190,34 +176,27 @@ var HeatmapChart = (function (ChartElement) {
         });
 
         this.box = targetBox;
-    };
+    }
 
-    HeatmapChart.prototype.pointSlot = function pointSlot (slotX, slotY) {
+    pointSlot(slotX, slotY) {
         return new Box(slotX.x1, slotY.y1, slotX.x2, slotY.y2);
-    };
-
-    HeatmapChart.prototype.traverseDataPoints = function traverseDataPoints (callback) {
-        var this$1 = this;
-
-        var ref = this;
-        var series = ref.options.series;
-
-        for (var seriesIx = 0; seriesIx < series.length; seriesIx++) {
-            var currentSeries = series[seriesIx];
-            var ref$1 = this$1.seriesAxes(currentSeries);
-            var xAxis = ref$1.xAxis;
-            var yAxis = ref$1.yAxis;
-            var xRange = xAxis.currentRangeIndices();
-            var yRange = yAxis.currentRangeIndices();
-
-            for (var pointIx = 0; pointIx < currentSeries.data.length; pointIx++) {
-                var ref$2 = this$1.plotArea.bindPoint(currentSeries, pointIx);
-                var value = ref$2.valueFields;
-                var fields = ref$2.fields;
-                var xIndex = xAxis.totalIndex(value.x);
-                var yIndex = yAxis.totalIndex(value.y);
-                var xIn = xRange.min <= xIndex && xIndex <= xRange.max;
-                var yIn = yRange.min <= yIndex && yIndex <= yRange.max;
+    }
+
+    traverseDataPoints(callback) {
+        const { options: { series } } = this;
+
+        for (let seriesIx = 0; seriesIx < series.length; seriesIx++) {
+            const currentSeries = series[seriesIx];
+            const { xAxis, yAxis } = this.seriesAxes(currentSeries);
+            const xRange = xAxis.currentRangeIndices();
+            const yRange = yAxis.currentRangeIndices();
+
+            for (let pointIx = 0; pointIx < currentSeries.data.length; pointIx++) {
+                const { valueFields: value, fields } = this.plotArea.bindPoint(currentSeries, pointIx);
+                const xIndex = xAxis.totalIndex(value.x);
+                const yIndex = yAxis.totalIndex(value.y);
+                const xIn = xRange.min <= xIndex && xIndex <= xRange.max;
+                const yIn = yRange.min <= yIndex && yIndex <= yRange.max;
 
                 if (xIn && yIn) {
                     callback(value, deepExtend({
@@ -225,29 +204,27 @@ var HeatmapChart = (function (ChartElement) {
                         series: currentSeries,
                         seriesIx: seriesIx,
                         dataItem: currentSeries.data[pointIx],
-                        owner: this$1
+                        owner: this
                     }, fields));
                 }
             }
         }
-    };
+    }
 
-    HeatmapChart.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, value.value);
-    };
+    }
 
-    HeatmapChart.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 HeatmapChart;
-}(ChartElement));
+    }
+}
 setDefaultOptions(HeatmapChart, {
     series: [],
     tooltip: {

package/dist/es/chart/heatmap-chart/heatmap-point.js

@@ -6,20 +6,16 @@ import AccessibilityAttributesMixin from '../mixins/accessibility-attributes-mix
 import NoteMixin from '../mixins/note-mixin';
 import PointEventsMixin from '../mixins/point-events-mixin';
 
-var HeatmapPoint = (function (ChartElement) {
-    function HeatmapPoint(value, options) {
-        ChartElement.call(this);
+class HeatmapPoint extends ChartElement {
+    constructor(value, options) {
+        super();
 
         this.options = options;
         this.color = options.color || WHITE;
         this.value = value;
     }
 
-    if ( ChartElement ) HeatmapPoint.__proto__ = ChartElement;
-    HeatmapPoint.prototype = Object.create( ChartElement && ChartElement.prototype );
-    HeatmapPoint.prototype.constructor = HeatmapPoint;
-
-    HeatmapPoint.prototype.render = function render () {
+    render() {
         if (this._rendered) {
             return;
         }
@@ -29,20 +25,20 @@ var HeatmapPoint = (function (ChartElement) {
         this.createMarker();
         this.createLabel();
         this.createNote();
-    };
+    }
 
-    HeatmapPoint.prototype.createLabel = function createLabel () {
-        var options = this.options;
-        var labels = options.labels;
+    createLabel() {
+        const options = this.options;
+        const labels = options.labels;
 
         if (labels.visible) {
             this.label = this.createLabelElement(labels);
             this.append(this.label);
         }
-    };
+    }
 
-    HeatmapPoint.prototype.createLabelElement = function createLabelElement (options) {
-        var labelColor = options.color;
+    createLabelElement(options) {
+        let labelColor = options.color;
 
         if (!labelColor) {
             labelColor = autoTextColor(this.color);
@@ -63,26 +59,26 @@ var HeatmapPoint = (function (ChartElement) {
             }),
             this.pointData()
         );
-    };
+    }
 
-    HeatmapPoint.prototype.getLabelText = function getLabelText (options) {
-        var labelTemplate = getTemplate(options);
+    getLabelText(options) {
+        let labelTemplate = getTemplate(options);
 
         if (labelTemplate) {
             return labelTemplate(this.pointData());
         }
 
         return this.formatValue(options.format);
-    };
+    }
 
-    HeatmapPoint.prototype.formatValue = function formatValue (format) {
+    formatValue(format) {
         return this.owner.formatPointValue(this, format);
-    };
+    }
 
-    HeatmapPoint.prototype.reflow = function reflow (targetBox) {
+    reflow(targetBox) {
         this.render();
 
-        var label = this.label;
+        const label = this.label;
 
         this.box = targetBox;
 
@@ -95,26 +91,26 @@ var HeatmapPoint = (function (ChartElement) {
         }
 
         this.marker.reflow(this.markerBox());
-    };
+    }
 
-    HeatmapPoint.prototype.createVisual = function createVisual () {
-        ChartElement.prototype.createVisual.call(this);
+    createVisual() {
+        super.createVisual();
 
         this.addAccessibilityAttributesToVisual();
-    };
-
-    HeatmapPoint.prototype.markerBox = function markerBox () {
-        var options = this.options;
-        var markers = options.markers;
-        var border = markers.border;
-        var rect = this.box.toRect();
-        var type = valueOrDefault(markers.type, 'rect');
-        var isRoundRect = type === ROUNDED_RECT;
-        var borderWidth = valueOrDefault(border.width, isRoundRect ? 1 : 0);
-        var halfBorderWidth = Math.round(borderWidth / 2);
+    }
+
+    markerBox() {
+        const options = this.options;
+        const markers = options.markers;
+        const border = markers.border;
+        const rect = this.box.toRect();
+        const type = valueOrDefault(markers.type, 'rect');
+        const isRoundRect = type === ROUNDED_RECT;
+        let borderWidth = valueOrDefault(border.width, isRoundRect ? 1 : 0);
+        const halfBorderWidth = Math.round(borderWidth / 2);
 
         if (markers.size) {
-            var center = rect.center();
+            const center = rect.center();
             rect.size.width = rect.size.height = markers.size;
             rect.origin.x = Math.round(center.x - rect.size.width / 2);
             rect.origin.y = Math.round(center.y - rect.size.height / 2);
@@ -126,13 +122,13 @@ var HeatmapPoint = (function (ChartElement) {
         rect.origin.x += halfBorderWidth + 0.5;
 
         return rectToBox(rect);
-    };
+    }
 
-    HeatmapPoint.prototype.markerBorder = function markerBorder () {
-        var options = this.options;
-        var markers = options.markers;
-        var border = markers.border;
-        var opacity = valueOrDefault(border.opacity, options.opacity);
+    markerBorder() {
+        const options = this.options;
+        const markers = options.markers;
+        const border = markers.border;
+        const opacity = valueOrDefault(border.opacity, options.opacity);
 
         return {
             color: border.color || this.color,
@@ -140,12 +136,12 @@ var HeatmapPoint = (function (ChartElement) {
             opacity: opacity,
             dashType: border.dashType
         };
-    };
+    }
 
-    HeatmapPoint.prototype.createMarker = function createMarker () {
-        var options = this.options;
-        var markerOptions = options.markers;
-        var marker = new ShapeElement({
+    createMarker() {
+        const options = this.options;
+        const markerOptions = options.markers;
+        const marker = new ShapeElement({
             type: valueOrDefault(markerOptions.type, 'rect'),
             width: markerOptions.size,
             height: markerOptions.size,
@@ -167,13 +163,13 @@ var HeatmapPoint = (function (ChartElement) {
 
         this.marker = marker;
         this.append(marker);
-    };
+    }
 
-    HeatmapPoint.prototype.createHighlight = function createHighlight (style) {
-        var options = this.options;
-        var markerOptions = this.options.highlight.markers || this.options.markers;
+    createHighlight(style) {
+        const options = this.options;
+        const markerOptions = this.options.highlight.markers || this.options.markers;
 
-        var highlight = new ShapeElement({
+        const highlight = new ShapeElement({
             type: valueOrDefault(markerOptions.type, 'rect'),
             width: markerOptions.size,
             height: markerOptions.size,
@@ -186,31 +182,31 @@ var HeatmapPoint = (function (ChartElement) {
         });
 
         highlight.reflow(this.markerBox());
-        var visual = highlight.getElement();
+        const visual = highlight.getElement();
 
         visual.options.fill = style.fill;
         visual.options.stroke = style.stroke;
 
         return visual;
-    };
+    }
 
-    HeatmapPoint.prototype.highlightVisual = function highlightVisual () {
+    highlightVisual() {
         return this.rectVisual;
-    };
+    }
 
-    HeatmapPoint.prototype.highlightVisualArgs = function highlightVisualArgs () {
+    highlightVisualArgs() {
         return {
             options: this.options,
             rect: this.box.toRect(),
             visual: this.rectVisual
         };
-    };
+    }
 
-    HeatmapPoint.prototype.createFocusHighlight = function createFocusHighlight () {
-        var markerOptions = this.options.markers;
-        var highlightOptions = this.options.focusHighlight;
+    createFocusHighlight() {
+        const markerOptions = this.options.markers;
+        const highlightOptions = this.options.focusHighlight;
 
-        var highlight = new ShapeElement({
+        const highlight = new ShapeElement({
             type: valueOrDefault(markerOptions.type, 'rect'),
             width: markerOptions.size,
             height: markerOptions.size,
@@ -225,11 +221,11 @@ var HeatmapPoint = (function (ChartElement) {
         highlight.reflow(this.markerBox());
 
         return highlight.getElement();
-    };
+    }
 
-    HeatmapPoint.prototype.tooltipAnchor = function tooltipAnchor () {
-        var left = this.box.center().x;
-        var top = this.box.y1 - TOOLTIP_OFFSET;
+    tooltipAnchor() {
+        const left = this.box.center().x;
+        const top = this.box.y1 - TOOLTIP_OFFSET;
 
         return {
             point: new Point(left, top),
@@ -238,17 +234,17 @@ var HeatmapPoint = (function (ChartElement) {
                 vertical: BOTTOM
             }
         };
-    };
+    }
 
-    HeatmapPoint.prototype.overlapsBox = function overlapsBox (box) {
+    overlapsBox(box) {
         return this.box.overlaps(box);
-    };
+    }
 
-    HeatmapPoint.prototype.unclipElements = function unclipElements () {
+    unclipElements() {
         /* noop, clip labels */
-    };
+    }
 
-    HeatmapPoint.prototype.pointData = function pointData () {
+    pointData() {
         return {
             x: this.value.x,
             y: this.value.y,
@@ -256,10 +252,8 @@ var HeatmapPoint = (function (ChartElement) {
             dataItem: this.dataItem,
             series: this.series
         };
-    };
-
-    return HeatmapPoint;
-}(ChartElement));
+    }
+}
 
 deepExtend(HeatmapPoint.prototype, PointEventsMixin);
 deepExtend(HeatmapPoint.prototype, NoteMixin);