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

package/dist/es/chart/mixins/line-chart-mixin.js

@@ -4,45 +4,41 @@ import { Point } from '../../core';
 import { MAX_VALUE } from '../../common/constants';
 import { defined } from '../../common';
 
-var LineChartMixin = {
+const LineChartMixin = {
     renderSegments: function() {
-        var this$1 = this;
-
-        var ref = this;
-        var options = ref.options;
-        var seriesPoints = ref.seriesPoints;
-        var series = options.series;
-        var seriesCount = seriesPoints.length;
-        var lastSegment;
+        const { options, seriesPoints } = this;
+        const series = options.series;
+        const seriesCount = seriesPoints.length;
+        let lastSegment;
 
         this._segments = [];
 
-        for (var seriesIx = 0; seriesIx < seriesCount; seriesIx++) {
-            var currentSeries = series[seriesIx];
-            var sortedPoints = this$1.sortPoints(seriesPoints[seriesIx]);
-            var pointCount = sortedPoints.length;
-            var linePoints = [];
+        for (let seriesIx = 0; seriesIx < seriesCount; seriesIx++) {
+            const currentSeries = series[seriesIx];
+            const sortedPoints = this.sortPoints(seriesPoints[seriesIx]);
+            const pointCount = sortedPoints.length;
+            let linePoints = [];
 
-            for (var pointIx = 0; pointIx < pointCount; pointIx++) {
-                var point = sortedPoints[pointIx];
+            for (let pointIx = 0; pointIx < pointCount; pointIx++) {
+                const point = sortedPoints[pointIx];
                 if (point) {
                     linePoints.push(point);
-                } else if (this$1.seriesMissingValues(currentSeries) !== INTERPOLATE) {
+                } else if (this.seriesMissingValues(currentSeries) !== INTERPOLATE) {
                     if (linePoints.length > 1) {
-                        lastSegment = this$1.createSegment(
+                        lastSegment = this.createSegment(
                             linePoints, currentSeries, seriesIx, lastSegment
                         );
-                        this$1._addSegment(lastSegment);
+                        this._addSegment(lastSegment);
                     }
                     linePoints = [];
                 }
             }
 
             if (linePoints.length > 1) {
-                lastSegment = this$1.createSegment(
+                lastSegment = this.createSegment(
                     linePoints, currentSeries, seriesIx, lastSegment
                 );
-                this$1._addSegment(lastSegment);
+                this._addSegment(lastSegment);
             }
         }
 
@@ -59,24 +55,24 @@ var LineChartMixin = {
     },
 
     seriesMissingValues: function(series) {
-        var missingValues = series.missingValues;
-        var assumeZero = !missingValues && this.options.isStacked;
+        const missingValues = series.missingValues;
+        const assumeZero = !missingValues && this.options.isStacked;
 
         return assumeZero ? ZERO : missingValues || INTERPOLATE;
     },
 
     getNearestPoint: function(x, y, seriesIx) {
-        var target = new Point(x, y);
-        var allPoints = this.seriesPoints[seriesIx];
-        var nearestPointDistance = MAX_VALUE;
-        var nearestPoint;
+        const target = new Point(x, y);
+        const allPoints = this.seriesPoints[seriesIx];
+        let nearestPointDistance = MAX_VALUE;
+        let nearestPoint;
 
-        for (var i = 0; i < allPoints.length; i++) {
-            var point = allPoints[i];
+        for (let i = 0; i < allPoints.length; i++) {
+            const point = allPoints[i];
 
             if (point && defined(point.value) && point.value !== null && point.visible !== false) {
-                var pointBox = point.box;
-                var pointDistance = pointBox.center().distanceTo(target);
+                const pointBox = point.box;
+                const pointDistance = pointBox.center().distanceTo(target);
 
                 if (pointDistance < nearestPointDistance) {
                     nearestPoint = point;

package/dist/es/chart/mixins/note-mixin.js

@@ -1,10 +1,10 @@
 import { Note } from '../../core';
 import { defined } from '../../common';
 
-var NoteMixin = {
+const NoteMixin = {
     createNote: function() {
-        var options = this.options.notes;
-        var text = this.noteText || options.label.text;
+        const options = this.options.notes;
+        const text = this.noteText || options.label.text;
 
         if (options.visible !== false && defined(text) && text !== null) {
             this.note = new Note({

package/dist/es/chart/mixins/pie-chart-mixin.js

@@ -1,18 +1,18 @@
 import { getTemplate } from '../../common';
 import { hasValue } from '../utils';
 
-var PieChartMixin = {
+const PieChartMixin = {
     createLegendItem: function(value, point, options) {
-        var legendOptions = this.options.legend || {};
-        var labelsOptions = legendOptions.labels || {};
-        var inactiveItems = legendOptions.inactiveItems || {};
-        var inactiveItemsLabels = inactiveItems.labels || {};
+        const legendOptions = this.options.legend || {};
+        const labelsOptions = legendOptions.labels || {};
+        const inactiveItems = legendOptions.inactiveItems || {};
+        const inactiveItemsLabels = inactiveItems.labels || {};
 
         if (options && options.visibleInLegend !== false) {
-            var pointVisible = options.visible !== false;
-            var labelTemplate = pointVisible ? getTemplate(labelsOptions) :
+            const pointVisible = options.visible !== false;
+            const labelTemplate = pointVisible ? getTemplate(labelsOptions) :
                 getTemplate(inactiveItemsLabels) || getTemplate(labelsOptions);
-            var text = options.category;
+            let text = options.category;
 
             if (labelTemplate) {
                 text = labelTemplate({
@@ -24,7 +24,7 @@ var PieChartMixin = {
                 });
             }
 
-            var itemLabelOptions, markerColor;
+            let itemLabelOptions, markerColor;
             if (pointVisible) {
                 itemLabelOptions = {};
                 markerColor = point.color;

package/dist/es/chart/mixins/plotarea-events-mixin.js

@@ -1,6 +1,6 @@
 import { PLOT_AREA_HOVER, PLOT_AREA_CLICK } from '../constants';
 
-var PlotAreaEventsMixin = {
+const PlotAreaEventsMixin = {
     hover: function(chart, e) {
         this._dispatchEvent(chart, e, PLOT_AREA_HOVER);
     },

package/dist/es/chart/mixins/point-events-mixin.js

@@ -1,7 +1,7 @@
 import { SERIES_CLICK, SERIES_HOVER, SERIES_LEAVE, SERIES_OVER } from '../constants';
 import { eventElement } from '../../common';
 
-var PointEventsMixin = {
+const PointEventsMixin = {
     click: function(chart, e) {
         return chart.trigger(
             SERIES_CLICK,

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

@@ -1,20 +1,10 @@
 import CandlestickChart from '../candlestick-chart/candlestick-chart';
 import OHLCPoint from './ohlc-point';
 
-var OHLCChart = (function (CandlestickChart) {
-    function OHLCChart () {
-        CandlestickChart.apply(this, arguments);
-    }
-
-    if ( CandlestickChart ) OHLCChart.__proto__ = CandlestickChart;
-    OHLCChart.prototype = Object.create( CandlestickChart && CandlestickChart.prototype );
-    OHLCChart.prototype.constructor = OHLCChart;
-
-    OHLCChart.prototype.pointType = function pointType () {
+class OHLCChart extends CandlestickChart {
+    pointType() {
         return OHLCPoint;
-    };
-
-    return OHLCChart;
-}(CandlestickChart));
+    }
+}
 
 export default OHLCChart;

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

@@ -1,32 +1,21 @@
 import Candlestick from '../candlestick-chart/candlestick';
 
-var OHLCPoint = (function (Candlestick) {
-    function OHLCPoint () {
-        Candlestick.apply(this, arguments);
-    }
-
-    if ( Candlestick ) OHLCPoint.__proto__ = Candlestick;
-    OHLCPoint.prototype = Object.create( Candlestick && Candlestick.prototype );
-    OHLCPoint.prototype.constructor = OHLCPoint;
-
-    OHLCPoint.prototype.reflow = function reflow (box) {
-        var ref = this;
-        var options = ref.options;
-        var value = ref.value;
-        var chart = ref.owner;
-        var valueAxis = chart.seriesValueAxis(options);
-        var oPoints = [];
-        var cPoints = [];
-        var lhPoints = [];
-
-        var lhSlot = valueAxis.getSlot(value.low, value.high);
-        var oSlot = valueAxis.getSlot(value.open, value.open);
-        var cSlot = valueAxis.getSlot(value.close, value.close);
+class OHLCPoint extends Candlestick {
+    reflow(box) {
+        const { options, value, owner: chart } = this;
+        const valueAxis = chart.seriesValueAxis(options);
+        const oPoints = [];
+        const cPoints = [];
+        const lhPoints = [];
+
+        const lhSlot = valueAxis.getSlot(value.low, value.high);
+        const oSlot = valueAxis.getSlot(value.open, value.open);
+        const cSlot = valueAxis.getSlot(value.close, value.close);
 
         oSlot.x1 = cSlot.x1 = lhSlot.x1 = box.x1;
         oSlot.x2 = cSlot.x2 = lhSlot.x2 = box.x2;
 
-        var mid = lhSlot.center().x;
+        const mid = lhSlot.center().x;
 
         oPoints.push([ oSlot.x1, oSlot.y1 ]);
         oPoints.push([ mid, oSlot.y1 ]);
@@ -42,11 +31,9 @@ var OHLCPoint = (function (Candlestick) {
         this.box = lhSlot.clone().wrap(oSlot.clone().wrap(cSlot));
 
         this.reflowNote();
-    };
-
-    OHLCPoint.prototype.createBody = function createBody () {};
+    }
 
-    return OHLCPoint;
-}(Candlestick));
+    createBody() {}
+}
 
 export default OHLCPoint;

package/dist/es/chart/pan-and-zoom/accept-key.js

@@ -1,7 +1,7 @@
 export default function acceptKey(e, mouseKey) {
-    var key = (mouseKey || "").toLowerCase();
-    var event = e.event;
-    var accept = (key === "none" && !(event.ctrlKey || event.shiftKey || event.altKey)) || event[key + "Key"];
+    const key = (mouseKey || "").toLowerCase();
+    const event = e.event;
+    const accept = (key === "none" && !(event.ctrlKey || event.shiftKey || event.altKey)) || event[key + "Key"];
 
     return accept;
 }

package/dist/es/chart/pan-and-zoom/mousewheel-zoom.js

@@ -7,13 +7,13 @@ import { limitValue } from '../../drawing-utils';
 
 // Limit the zoom rate between 1% and 90% per mousewheel event.
 // At zoom rates close to 100% the axis range quickly becomes 0.
-var MIN_RATE = 0.01;
-var MAX_RATE = 0.9;
-var DEFAULT_RATE = 0.3;
+const MIN_RATE = 0.01;
+const MAX_RATE = 0.9;
+const DEFAULT_RATE = 0.3;
 
-var MousewheelZoom = (function (Class) {
-    function MousewheelZoom(chart, options) {
-        Class.call(this);
+class MousewheelZoom extends Class {
+    constructor(chart, options) {
+        super();
 
         this.chart = chart;
         this.options = deepExtend({
@@ -21,24 +21,18 @@ var MousewheelZoom = (function (Class) {
         }, this.options, options);
     }
 
-    if ( Class ) MousewheelZoom.__proto__ = Class;
-    MousewheelZoom.prototype = Object.create( Class && Class.prototype );
-    MousewheelZoom.prototype.constructor = MousewheelZoom;
+    updateRanges(delta, coords) {
+        const lock = (this.options.lock || "").toLowerCase();
+        const axisRanges = [];
+        const axes = this.chart._plotArea.axes;
 
-    MousewheelZoom.prototype.updateRanges = function updateRanges (delta, coords) {
-        var this$1 = this;
-
-        var lock = (this.options.lock || "").toLowerCase();
-        var axisRanges = [];
-        var axes = this.chart._plotArea.axes;
-
-        for (var idx = 0; idx < axes.length; idx++) {
-            var axis = axes[idx];
-            var vertical = axis.options.vertical;
+        for (let idx = 0; idx < axes.length; idx++) {
+            const axis = axes[idx];
+            const vertical = axis.options.vertical;
 
             if (!(lock === X && !vertical) && !(lock === Y && vertical) && axis.zoomRange) {
-                var rate = limitValue(this$1.options.rate, MIN_RATE, MAX_RATE);
-                var range = axis.zoomRange(-delta * rate, coords);
+                const rate = limitValue(this.options.rate, MIN_RATE, MAX_RATE);
+                const range = axis.zoomRange(-delta * rate, coords);
 
                 if (range) {
                     axisRanges.push({
@@ -51,26 +45,24 @@ var MousewheelZoom = (function (Class) {
 
         this.axisRanges = axisRanges;
         return toChartAxisRanges(axisRanges);
-    };
+    }
 
-    MousewheelZoom.prototype.zoom = function zoom () {
-        var axisRanges = this.axisRanges;
-        var plotArea = this.chart._plotArea;
+    zoom() {
+        const axisRanges = this.axisRanges;
+        const plotArea = this.chart._plotArea;
 
         if (axisRanges && axisRanges.length && plotArea.updateAxisOptions) {
-            for (var idx = 0; idx < axisRanges.length; idx++) {
-                var axisRange = axisRanges[idx];
+            for (let idx = 0; idx < axisRanges.length; idx++) {
+                const axisRange = axisRanges[idx];
                 plotArea.updateAxisOptions(axisRange.axis, axisRange.range);
             }
             plotArea.redraw(plotArea.panes);
         }
-    };
+    }
 
-    MousewheelZoom.prototype.destroy = function destroy () {
+    destroy() {
         delete this.chart;
-    };
-
-    return MousewheelZoom;
-}(Class));
+    }
+}
 
 export default MousewheelZoom;

package/dist/es/chart/pan-and-zoom/pannable.js

@@ -4,70 +4,64 @@ import toChartAxisRanges from './to-chart-axis-ranges';
 import { X, Y } from '../../common/constants';
 import { Class, deepExtend } from '../../common';
 
-var Pannable = (function (Class) {
-    function Pannable(plotArea, options) {
-        Class.call(this);
+class Pannable extends Class {
+    constructor(plotArea, options) {
+        super();
 
         this.plotArea = plotArea;
         this.options = deepExtend({}, this.options, options);
     }
 
-    if ( Class ) Pannable.__proto__ = Class;
-    Pannable.prototype = Object.create( Class && Class.prototype );
-    Pannable.prototype.constructor = Pannable;
-
-    Pannable.prototype.start = function start (e) {
+    start(e) {
         this._active = acceptKey(e, this.options.key);
         return this._active;
-    };
+    }
 
-    Pannable.prototype.move = function move (e) {
+    move(e) {
         if (this._active) {
-            var axisRanges = this.axisRanges = this._panAxes(e, X).concat(this._panAxes(e, Y));
+            const axisRanges = this.axisRanges = this._panAxes(e, X).concat(this._panAxes(e, Y));
             if (axisRanges.length) {
                 this.axisRanges = axisRanges;
                 return toChartAxisRanges(axisRanges);
             }
         }
-    };
+    }
 
-    Pannable.prototype.end = function end () {
-        var active = this._active;
+    end() {
+        const active = this._active;
         this._active = false;
 
         return active;
-    };
+    }
 
-    Pannable.prototype.pan = function pan () {
-        var ref = this;
-        var plotArea = ref.plotArea;
-        var axisRanges = ref.axisRanges;
+    pan() {
+        const { plotArea, axisRanges } = this;
         if (axisRanges.length) {
-            for (var idx = 0; idx < axisRanges.length; idx++) {
-                var range = axisRanges[idx];
+            for (let idx = 0; idx < axisRanges.length; idx++) {
+                const range = axisRanges[idx];
                 plotArea.updateAxisOptions(range.axis, range.range);
             }
             plotArea.redraw(plotArea.panes);
         }
-    };
+    }
 
-    Pannable.prototype.destroy = function destroy () {
+    destroy() {
         delete this.plotArea;
-    };
+    }
 
-    Pannable.prototype._panAxes = function _panAxes (e, position) {
-        var plotArea = this.plotArea;
-        var delta = -e[position].delta;
-        var lock = (this.options.lock || "").toLowerCase();
-        var updatedAxes = [];
+    _panAxes(e, position) {
+        const plotArea = this.plotArea;
+        const delta = -e[position].delta;
+        const lock = (this.options.lock || "").toLowerCase();
+        const updatedAxes = [];
 
         if (delta !== 0 && (lock || "").toLowerCase() !== position) {
-            var axes = plotArea.axes;
-            for (var idx = 0; idx < axes.length; idx++) {
-                var axis = axes[idx];
+            const axes = plotArea.axes;
+            for (let idx = 0; idx < axes.length; idx++) {
+                const axis = axes[idx];
 
                 if (position === X && !axis.options.vertical || position === Y && axis.options.vertical) {
-                    var range = axis.pan(delta);
+                    const range = axis.pan(delta);
 
                     if (range) {
                         range.limitRange = true;
@@ -81,10 +75,8 @@ var Pannable = (function (Class) {
         }
 
         return updatedAxes;
-    };
-
-    return Pannable;
-}(Class));
+    }
+}
 
 Pannable.prototype.options = {
     key: "none",

package/dist/es/chart/pan-and-zoom/to-chart-axis-ranges.js

@@ -1,7 +1,7 @@
 export default function toChartAxisRanges(axisRanges) {
-    var ranges = {};
-    for (var idx = 0; idx < axisRanges.length; idx++) {
-        var axisRange = axisRanges[idx];
+    const ranges = {};
+    for (let idx = 0; idx < axisRanges.length; idx++) {
+        const axisRange = axisRanges[idx];
         if (axisRange.axis.options.name) {
             ranges[axisRange.axis.options.name] = {
                 min: axisRange.range.min,