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

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

@@ -7,23 +7,15 @@ import SplineAreaSegment from './spline-area-segment';
 
 import { STEP, SMOOTH, ZERO } from '../constants';
 
-var AreaChart = (function (LineChart) {
-    function AreaChart () {
-        LineChart.apply(this, arguments);
-    }
-
-    if ( LineChart ) AreaChart.__proto__ = LineChart;
-    AreaChart.prototype = Object.create( LineChart && LineChart.prototype );
-    AreaChart.prototype.constructor = AreaChart;
+class AreaChart extends LineChart {
+    createSegment(linePoints, currentSeries, seriesIx, prevSegment) {
+        const isStacked = this.options.isStacked;
+        const style = (currentSeries.line || {}).style;
+        let previousSegment;
 
-    AreaChart.prototype.createSegment = function createSegment (linePoints, currentSeries, seriesIx, prevSegment) {
-        var isStacked = this.options.isStacked;
-        var style = (currentSeries.line || {}).style;
-        var previousSegment;
-
-        var stackPoints;
+        let stackPoints;
         if (isStacked && seriesIx > 0 && prevSegment) {
-            var missingValues = this.seriesMissingValues(currentSeries);
+            const missingValues = this.seriesMissingValues(currentSeries);
             if (missingValues !== "gap") {
                 stackPoints = prevSegment.linePoints;
                 previousSegment = prevSegment;
@@ -32,7 +24,7 @@ var AreaChart = (function (LineChart) {
             }
         }
 
-        var pointType;
+        let pointType;
         if (style === STEP) {
             pointType = StepAreaSegment;
         } else if (style === SMOOTH) {
@@ -42,43 +34,39 @@ var AreaChart = (function (LineChart) {
         }
 
         return new pointType(linePoints, currentSeries, seriesIx, previousSegment, stackPoints);
-    };
-
-    AreaChart.prototype.reflow = function reflow (targetBox) {
-        var this$1 = this;
+    }
 
-        LineChart.prototype.reflow.call(this, targetBox);
+    reflow(targetBox) {
+        super.reflow(targetBox);
 
-        var stackPoints = this._stackPoints;
+        const stackPoints = this._stackPoints;
         if (stackPoints) {
-            for (var idx = 0; idx < stackPoints.length; idx++) {
-                var stackPoint = stackPoints[idx];
-                var pointSlot = this$1.categoryAxis.getSlot(stackPoint.categoryIx);
+            for (let idx = 0; idx < stackPoints.length; idx++) {
+                const stackPoint = stackPoints[idx];
+                const pointSlot = this.categoryAxis.getSlot(stackPoint.categoryIx);
                 stackPoint.reflow(pointSlot);
             }
         }
-    };
-
-    AreaChart.prototype._gapStackPoints = function _gapStackPoints (linePoints, seriesIx, style) {
-        var this$1 = this;
+    }
 
-        var seriesPoints = this.seriesPoints;
-        var startIdx = linePoints[0].categoryIx;
-        var length = linePoints.length;
+    _gapStackPoints(linePoints, seriesIx, style) {
+        const seriesPoints = this.seriesPoints;
+        let startIdx = linePoints[0].categoryIx;
+        let length = linePoints.length;
         if (startIdx < 0) {
             startIdx = 0;
             length--;
         }
 
-        var endIdx = startIdx + length;
-        var pointOffset = this.seriesOptions[0]._outOfRangeMinPoint ? 1 : 0;
-        var stackPoints = [];
+        const endIdx = startIdx + length;
+        const pointOffset = this.seriesOptions[0]._outOfRangeMinPoint ? 1 : 0;
+        const stackPoints = [];
 
         this._stackPoints = this._stackPoints || [];
-        for (var categoryIx = startIdx; categoryIx < endIdx; categoryIx++) {
-            var pointIx = categoryIx + pointOffset;
-            var currentSeriesIx = seriesIx;
-            var point = (void 0);
+        for (let categoryIx = startIdx; categoryIx < endIdx; categoryIx++) {
+            const pointIx = categoryIx + pointOffset;
+            let currentSeriesIx = seriesIx;
+            let point;
 
             do {
                 currentSeriesIx--;
@@ -87,28 +75,28 @@ var AreaChart = (function (LineChart) {
 
             if (point) {
                 if (style !== STEP && categoryIx > startIdx && !seriesPoints[currentSeriesIx][pointIx - 1]) {
-                    stackPoints.push(this$1._previousSegmentPoint(categoryIx, pointIx, pointIx - 1, currentSeriesIx));
+                    stackPoints.push(this._previousSegmentPoint(categoryIx, pointIx, pointIx - 1, currentSeriesIx));
                 }
 
                 stackPoints.push(point);
 
                 if (style !== STEP && categoryIx + 1 < endIdx && !seriesPoints[currentSeriesIx][pointIx + 1]) {
-                    stackPoints.push(this$1._previousSegmentPoint(categoryIx, pointIx, pointIx + 1, currentSeriesIx));
+                    stackPoints.push(this._previousSegmentPoint(categoryIx, pointIx, pointIx + 1, currentSeriesIx));
                 }
             } else {
-                var gapStackPoint = this$1._createGapStackPoint(categoryIx);
-                this$1._stackPoints.push(gapStackPoint);
+                const gapStackPoint = this._createGapStackPoint(categoryIx);
+                this._stackPoints.push(gapStackPoint);
                 stackPoints.push(gapStackPoint);
             }
         }
 
         return stackPoints;
-    };
+    }
 
-    AreaChart.prototype._previousSegmentPoint = function _previousSegmentPoint (categoryIx, pointIx, segmentIx, seriesIdx) {
-        var seriesPoints = this.seriesPoints;
-        var index = seriesIdx;
-        var point;
+    _previousSegmentPoint(categoryIx, pointIx, segmentIx, seriesIdx) {
+        const seriesPoints = this.seriesPoints;
+        let index = seriesIdx;
+        let point;
 
         while (index > 0 && !point) {
             index--;
@@ -123,26 +111,24 @@ var AreaChart = (function (LineChart) {
         }
 
         return point;
-    };
+    }
 
-    AreaChart.prototype._createGapStackPoint = function _createGapStackPoint (categoryIx) {
-        var options = this.pointOptions({}, 0);
-        var point = new LinePoint(0, options);
+    _createGapStackPoint(categoryIx) {
+        const options = this.pointOptions({}, 0);
+        const point = new LinePoint(0, options);
         point.categoryIx = categoryIx;
         point.series = {};
 
         return point;
-    };
+    }
 
-    AreaChart.prototype.seriesMissingValues = function seriesMissingValues (series) {
+    seriesMissingValues(series) {
         return series.missingValues || ZERO;
-    };
+    }
 
-    AreaChart.prototype.supportsPointInactiveOpacity = function supportsPointInactiveOpacity () {
+    supportsPointInactiveOpacity() {
         return false;
-    };
-
-    return AreaChart;
-}(LineChart));
+    }
+}
 
 export default AreaChart;

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

@@ -4,23 +4,19 @@ import LineSegment from '../line-chart/line-segment';
 import { append, deepExtend, isFunction, last } from '../../common';
 import { createPatternFill } from '../../core/pattern';
 
-var AreaSegment = (function (LineSegment) {
-    function AreaSegment(linePoints, currentSeries, seriesIx, prevSegment, stackPoints) {
-        LineSegment.call(this, linePoints, currentSeries, seriesIx);
+class AreaSegment extends LineSegment {
+    constructor(linePoints, currentSeries, seriesIx, prevSegment, stackPoints) {
+        super(linePoints, currentSeries, seriesIx);
 
         this.prevSegment = prevSegment;
         this.stackPoints = stackPoints;
     }
 
-    if ( LineSegment ) AreaSegment.__proto__ = LineSegment;
-    AreaSegment.prototype = Object.create( LineSegment && LineSegment.prototype );
-    AreaSegment.prototype.constructor = AreaSegment;
-
-    AreaSegment.prototype.createVisual = function createVisual () {
-        var series = this.series;
-        var defaults = series._defaults;
-        var lineOptions = series.line || {};
-        var color = series.color;
+    createVisual() {
+        const series = this.series;
+        const defaults = series._defaults;
+        const lineOptions = series.line || {};
+        let color = series.color;
 
         if (isFunction(color) && defaults) {
             color = defaults.color;
@@ -47,61 +43,61 @@ var AreaSegment = (function (LineSegment) {
                 }, lineOptions)
             });
         }
-    };
+    }
 
-    AreaSegment.prototype.strokeSegments = function strokeSegments () {
-        var segments = this._strokeSegments;
+    strokeSegments() {
+        let segments = this._strokeSegments;
 
         if (!segments) {
             segments = this._strokeSegments = this.createStrokeSegments();
         }
 
         return segments;
-    };
+    }
 
-    AreaSegment.prototype.createStrokeSegments = function createStrokeSegments () {
+    createStrokeSegments() {
         return this.segmentsFromPoints(this.points());
-    };
+    }
 
-    AreaSegment.prototype.stackSegments = function stackSegments () {
+    stackSegments() {
         if (this.prevSegment) {
             return this.prevSegment.createStackSegments(this.stackPoints);
         }
 
         return this.createStackSegments(this.stackPoints);
-    };
+    }
 
-    AreaSegment.prototype.createStackSegments = function createStackSegments (stackPoints) {
+    createStackSegments(stackPoints) {
         return this.segmentsFromPoints(this.toGeometryPoints(stackPoints)).reverse();
-    };
+    }
 
-    AreaSegment.prototype.segmentsFromPoints = function segmentsFromPoints (points) {
-        return points.map(function (point) { return new geom.Segment(point); });
-    };
+    segmentsFromPoints(points) {
+        return points.map((point) => new geom.Segment(point));
+    }
 
-    AreaSegment.prototype.createStroke = function createStroke (style) {
-        var stroke = new draw.Path(style);
+    createStroke(style) {
+        const stroke = new draw.Path(style);
         stroke.segments.push.apply(stroke.segments, this.strokeSegments());
 
         this.visual.append(stroke);
-    };
+    }
 
-    AreaSegment.prototype.hasStackSegment = function hasStackSegment () {
+    hasStackSegment() {
         return this.prevSegment || (this.stackPoints && this.stackPoints.length);
-    };
+    }
 
-    AreaSegment.prototype.createFill = function createFill (style) {
-        var strokeSegments = this.strokeSegments();
-        var fillSegments = strokeSegments.slice(0);
-        var hasStackSegments = this.hasStackSegment();
+    createFill(style) {
+        const strokeSegments = this.strokeSegments();
+        const fillSegments = strokeSegments.slice(0);
+        const hasStackSegments = this.hasStackSegment();
 
         if (hasStackSegments) {
-            var stackSegments = this.stackSegments();
+            const stackSegments = this.stackSegments();
 
             append(fillSegments, stackSegments);
         }
 
-        var fill = new draw.Path(style);
+        const fill = new draw.Path(style);
         fill.segments.push.apply(fill.segments, fillSegments);
 
         if (!hasStackSegments && strokeSegments.length > 1) {
@@ -109,18 +105,18 @@ var AreaSegment = (function (LineSegment) {
         }
 
         this.visual.append(fill);
-    };
-
-    AreaSegment.prototype.fillToAxes = function fillToAxes (fillPath) {
-        var chart = this.parent;
-        var invertAxes = chart.options.invertAxes;
-        var valueAxis = chart.seriesValueAxis(this.series);
-        var crossingValue = chart.categoryAxisCrossingValue(valueAxis);
-        var endSlot = valueAxis.getSlot(crossingValue, crossingValue, true);
-        var segments = this.strokeSegments();
-        var firstPoint = segments[0].anchor();
-        var lastPoint = last(segments).anchor();
-        var end = invertAxes ? endSlot.x1 : endSlot.y1;
+    }
+
+    fillToAxes(fillPath) {
+        const chart = this.parent;
+        const invertAxes = chart.options.invertAxes;
+        const valueAxis = chart.seriesValueAxis(this.series);
+        const crossingValue = chart.categoryAxisCrossingValue(valueAxis);
+        const endSlot = valueAxis.getSlot(crossingValue, crossingValue, true);
+        const segments = this.strokeSegments();
+        const firstPoint = segments[0].anchor();
+        const lastPoint = last(segments).anchor();
+        let end = invertAxes ? endSlot.x1 : endSlot.y1;
 
         if (invertAxes) {
             fillPath.lineTo(end, lastPoint.y)
@@ -129,9 +125,7 @@ var AreaSegment = (function (LineSegment) {
             fillPath.lineTo(lastPoint.x, end)
                 .lineTo(firstPoint.x, end);
         }
-    };
-
-    return AreaSegment;
-}(LineSegment));
+    }
+}
 
 export default AreaSegment;

package/dist/es/chart/area-chart/spline-area-segment.js

@@ -3,27 +3,20 @@ import { CurveProcessor } from '../../core';
 
 import AreaSegment from './area-segment';
 
-var SplineAreaSegment = (function (AreaSegment) {
-    function SplineAreaSegment () {
-        AreaSegment.apply(this, arguments);
-    }
-
-    if ( AreaSegment ) SplineAreaSegment.__proto__ = AreaSegment;
-    SplineAreaSegment.prototype = Object.create( AreaSegment && AreaSegment.prototype );
-    SplineAreaSegment.prototype.constructor = SplineAreaSegment;
+class SplineAreaSegment extends AreaSegment {
 
-    SplineAreaSegment.prototype.createStrokeSegments = function createStrokeSegments () {
-        var curveProcessor = new CurveProcessor(this.options.closed);
-        var linePoints = this.points();
+    createStrokeSegments() {
+        const curveProcessor = new CurveProcessor(this.options.closed);
+        const linePoints = this.points();
 
         return curveProcessor.process(linePoints);
-    };
+    }
 
-    SplineAreaSegment.prototype.createStackSegments = function createStackSegments () {
-        var strokeSegments = this.strokeSegments();
-        var stackSegments = [];
-        for (var idx = strokeSegments.length - 1; idx >= 0; idx--) {
-            var segment = strokeSegments[idx];
+    createStackSegments() {
+        const strokeSegments = this.strokeSegments();
+        const stackSegments = [];
+        for (let idx = strokeSegments.length - 1; idx >= 0; idx--) {
+            const segment = strokeSegments[idx];
             stackSegments.push(new geom.Segment(
                 segment.anchor(),
                 segment.controlOut(),
@@ -32,9 +25,7 @@ var SplineAreaSegment = (function (AreaSegment) {
         }
 
         return stackSegments;
-    };
-
-    return SplineAreaSegment;
-}(AreaSegment));
+    }
+}
 
 export default SplineAreaSegment;

package/dist/es/chart/area-chart/step-area-segment.js

@@ -3,25 +3,16 @@ import AreaSegment from './area-segment';
 
 import { deepExtend } from '../../common';
 
-var StepAreaSegment = (function (AreaSegment) {
-    function StepAreaSegment () {
-        AreaSegment.apply(this, arguments);
-    }
-
-    if ( AreaSegment ) StepAreaSegment.__proto__ = AreaSegment;
-    StepAreaSegment.prototype = Object.create( AreaSegment && AreaSegment.prototype );
-    StepAreaSegment.prototype.constructor = StepAreaSegment;
+class StepAreaSegment extends AreaSegment {
 
-    StepAreaSegment.prototype.createStrokeSegments = function createStrokeSegments () {
+    createStrokeSegments() {
         return this.segmentsFromPoints(this.calculateStepPoints(this.linePoints));
-    };
+    }
 
-    StepAreaSegment.prototype.createStackSegments = function createStackSegments (stackPoints) {
+    createStackSegments(stackPoints) {
         return this.segmentsFromPoints(this.calculateStepPoints(stackPoints)).reverse();
-    };
-
-    return StepAreaSegment;
-}(AreaSegment));
+    }
+}
 
 deepExtend(StepAreaSegment.prototype, StepLineMixin);
 

package/dist/es/chart/axis-group-range-tracker.js

@@ -1,39 +1,33 @@
 import { MIN_VALUE, MAX_VALUE } from '../common/constants';
 import { Class } from '../common';
 
-var AxisGroupRangeTracker = (function (Class) {
-    function AxisGroupRangeTracker() {
-        Class.call(this);
+class AxisGroupRangeTracker extends Class {
+    constructor() {
+        super();
 
         this.axisRanges = {};
     }
 
-    if ( Class ) AxisGroupRangeTracker.__proto__ = Class;
-    AxisGroupRangeTracker.prototype = Object.create( Class && Class.prototype );
-    AxisGroupRangeTracker.prototype.constructor = AxisGroupRangeTracker;
+    update(chartAxisRanges) {
+        const axisRanges = this.axisRanges;
 
-    AxisGroupRangeTracker.prototype.update = function update (chartAxisRanges) {
-        var axisRanges = this.axisRanges;
-
-        for (var axisName in chartAxisRanges) {
-            var chartRange = chartAxisRanges[axisName];
-            var range = axisRanges[axisName];
+        for (let axisName in chartAxisRanges) {
+            const chartRange = chartAxisRanges[axisName];
+            let range = axisRanges[axisName];
             axisRanges[axisName] = range = range || { min: MAX_VALUE, max: MIN_VALUE };
 
             range.min = Math.min(range.min, chartRange.min);
             range.max = Math.max(range.max, chartRange.max);
         }
-    };
+    }
 
-    AxisGroupRangeTracker.prototype.reset = function reset (axisName) {
+    reset(axisName) {
         this.axisRanges[axisName] = undefined;
-    };
+    }
 
-    AxisGroupRangeTracker.prototype.query = function query (axisName) {
+    query(axisName) {
         return this.axisRanges[axisName];
-    };
-
-    return AxisGroupRangeTracker;
-}(Class));
+    }
+}
 
 export default AxisGroupRangeTracker;