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

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

@@ -10,9 +10,9 @@ import { WHITE, CIRCLE, CENTER, TOP, BOTTOM, LEFT, HIGHLIGHT_ZINDEX } from '../.
 import { deepExtend, defined, getTemplate, getAriaTemplate, valueOrDefault, getSpacing } from '../../common';
 import guid from '../../core/utils/guid';
 
-var LinePoint = (function (ChartElement) {
-    function LinePoint(value, options) {
-        ChartElement.call(this);
+class LinePoint extends ChartElement {
+    constructor(value, options) {
+        super();
 
         this.value = value;
         this.options = options;
@@ -21,13 +21,8 @@ var LinePoint = (function (ChartElement) {
         this._id = guid();
     }
 
-    if ( ChartElement ) LinePoint.__proto__ = ChartElement;
-    LinePoint.prototype = Object.create( ChartElement && ChartElement.prototype );
-    LinePoint.prototype.constructor = LinePoint;
-
-    LinePoint.prototype.render = function render () {
-        var ref = this.options;
-        var markers = ref.markers;
+    render() {
+        const { markers } = this.options;
 
         if (this._rendered) {
             return;
@@ -46,19 +41,19 @@ var LinePoint = (function (ChartElement) {
         if (this.errorBar) {
             this.append(this.errorBar);
         }
-    };
+    }
 
-    LinePoint.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);
         }
-    };
+    }
 
-    LinePoint.prototype.createLabelElement = function createLabelElement (options) {
+    createLabelElement(options) {
         return new TextBox(this.getLabelText(options),
             deepExtend({
                 align: CENTER,
@@ -71,10 +66,10 @@ var LinePoint = (function (ChartElement) {
             }, options),
             this.pointData()
         );
-    };
+    }
 
-    LinePoint.prototype.getLabelText = function getLabelText (options) {
-        var labelTemplate = getTemplate(options);
+    getLabelText(options) {
+        let labelTemplate = getTemplate(options);
 
         if (labelTemplate) {
             return labelTemplate(this.pointData());
@@ -83,36 +78,36 @@ var LinePoint = (function (ChartElement) {
         }
 
         return this.value;
-    };
+    }
 
-    LinePoint.prototype.getAriaLabelText = function getAriaLabelText () {
-        var labels = this.options.labels;
-        var ariaTemplate = getAriaTemplate(labels);
+    getAriaLabelText() {
+        const labels = this.options.labels;
+        const ariaTemplate = getAriaTemplate(labels);
 
         if (ariaTemplate) {
             return ariaTemplate(this.pointData());
         }
 
         return this.getLabelText(labels);
-    };
+    }
 
-    LinePoint.prototype.markerBorder = function markerBorder () {
-        var options = this.options.markers;
-        var background = options.background;
-        var border = deepExtend({ color: this.color }, options.border);
+    markerBorder() {
+        const options = this.options.markers;
+        const background = options.background;
+        const border = deepExtend({ color: this.color }, options.border);
 
         if (!defined(border.color)) {
             border.color = new Color(background).brightness(BORDER_BRIGHTNESS).toHex();
         }
 
         return border;
-    };
+    }
 
-    LinePoint.prototype.createVisual = function createVisual () {};
+    createVisual() {}
 
-    LinePoint.prototype.createMarker = function createMarker () {
-        var options = this.options.markers;
-        var marker = new ShapeElement({
+    createMarker() {
+        const options = this.options.markers;
+        const marker = new ShapeElement({
             type: options.type,
             width: options.size,
             height: options.size,
@@ -135,29 +130,25 @@ var LinePoint = (function (ChartElement) {
         });
 
         return marker;
-    };
+    }
 
-    LinePoint.prototype.markerBox = function markerBox () {
+    markerBox() {
         if (!this.marker) {
             this.marker = this.createMarker();
             this.marker.reflow(this._childBox);
         }
 
         return this.marker.box;
-    };
-
-    LinePoint.prototype.reflow = function reflow (targetBox) {
-        var this$1 = this;
+    }
 
-        var ref = this;
-        var options = ref.options;
-        var aboveAxis = ref.aboveAxis;
-        var vertical = options.vertical;
+    reflow(targetBox) {
+        const { options, aboveAxis } = this;
+        const vertical = options.vertical;
 
         this.render();
 
         this.box = targetBox;
-        var childBox = targetBox.clone();
+        const childBox = targetBox.clone();
 
         if (vertical) {
             if (aboveAxis) {
@@ -181,28 +172,26 @@ var LinePoint = (function (ChartElement) {
         this.reflowLabel(childBox);
 
         if (this.errorBars) {
-            for (var i = 0; i < this.errorBars.length; i++) {
-                this$1.errorBars[i].reflow(childBox);
+            for (let i = 0; i < this.errorBars.length; i++) {
+                this.errorBars[i].reflow(childBox);
             }
         }
 
         if (this.note) {
-            var noteTargetBox = this.markerBox();
+            let noteTargetBox = this.markerBox();
 
             if (!(options.markers.visible && options.markers.size)) {
-                var center = noteTargetBox.center();
+                const center = noteTargetBox.center();
                 noteTargetBox = new Box(center.x, center.y, center.x, center.y);
             }
 
             this.note.reflow(noteTargetBox);
         }
-    };
+    }
 
-    LinePoint.prototype.reflowLabel = function reflowLabel (box) {
-        var ref = this;
-        var options = ref.options;
-        var label = ref.label;
-        var anchor = options.labels.position;
+    reflowLabel(box) {
+        const { options, label } = this;
+        let anchor = options.labels.position;
 
         if (label) {
             anchor = anchor === ABOVE ? TOP : anchor;
@@ -212,15 +201,15 @@ var LinePoint = (function (ChartElement) {
             label.box.alignTo(this.markerBox(), anchor);
             label.reflow(label.box);
         }
-    };
+    }
 
-    LinePoint.prototype.createHighlight = function createHighlight () {
-        var markers = this.options.highlight.markers;
-        var defaultColor = this.markerBorder().color;
-        var options = this.options.markers;
-        var size = options.size + (options.border.width || 0) + (markers.border.width || 0);
+    createHighlight() {
+        const markers = this.options.highlight.markers;
+        const defaultColor = this.markerBorder().color;
+        const options = this.options.markers;
+        const size = options.size + (options.border.width || 0) + (markers.border.width || 0);
 
-        var shadow = new ShapeElement({
+        const shadow = new ShapeElement({
             type: options.type,
             width: size,
             height: size,
@@ -236,23 +225,23 @@ var LinePoint = (function (ChartElement) {
         shadow.reflow(this._childBox);
 
         return shadow.getElement();
-    };
+    }
 
-    LinePoint.prototype.highlightVisual = function highlightVisual () {
+    highlightVisual() {
         return (this.marker || {}).visual;
-    };
+    }
 
-    LinePoint.prototype.highlightVisualArgs = function highlightVisualArgs () {
-        var marker = this.marker;
-        var visual, rect;
+    highlightVisualArgs() {
+        const marker = this.marker;
+        let visual, rect;
 
         if (marker) {
             rect = marker.paddingBox.toRect();
             visual = marker.visual;
         } else {
-            var size = this.options.markers.size;
-            var halfSize = size / 2;
-            var center = this.box.center();
+            const size = this.options.markers.size;
+            const halfSize = size / 2;
+            const center = this.box.center();
             rect = new geom.Rect([ center.x - halfSize, center.y - halfSize ], [ size, size ]);
         }
 
@@ -261,14 +250,14 @@ var LinePoint = (function (ChartElement) {
             rect: rect,
             visual: visual
         };
-    };
+    }
 
-    LinePoint.prototype.createFocusHighlight = function createFocusHighlight () {
-        var markerOptions = this.options.markers;
-        var highlightOptions = this.options.focusHighlight;
-        var size = markerOptions.size + (markerOptions.border.width || 0);
+    createFocusHighlight() {
+        const markerOptions = this.options.markers;
+        const highlightOptions = this.options.focusHighlight;
+        const size = markerOptions.size + (markerOptions.border.width || 0);
 
-        var highlight = new ShapeElement({
+        const highlight = new ShapeElement({
             type: markerOptions.type,
             width: size,
             height: size,
@@ -283,17 +272,17 @@ var LinePoint = (function (ChartElement) {
         highlight.reflow(this._childBox);
 
         return highlight.getElement();
-    };
+    }
 
-    LinePoint.prototype.tooltipAnchor = function tooltipAnchor () {
-        var markerBox = this.markerBox();
-        var clipBox = this.owner.pane.clipBox();
-        var showTooltip = !clipBox || clipBox.overlaps(markerBox);
+    tooltipAnchor() {
+        const markerBox = this.markerBox();
+        const clipBox = this.owner.pane.clipBox();
+        const showTooltip = !clipBox || clipBox.overlaps(markerBox);
 
         if (showTooltip) {
-            var x = markerBox.x2 + TOOLTIP_OFFSET;
-            var horizontalAlign = LEFT;
-            var y, verticalAlign;
+            const x = markerBox.x2 + TOOLTIP_OFFSET;
+            const horizontalAlign = LEFT;
+            let y, verticalAlign;
 
             if (this.aboveAxis) {
                 y = markerBox.y1;
@@ -311,18 +300,18 @@ var LinePoint = (function (ChartElement) {
                 }
             };
         }
-    };
+    }
 
-    LinePoint.prototype.formatValue = function formatValue (format) {
+    formatValue(format) {
         return this.owner.formatPointValue(this, format);
-    };
+    }
 
-    LinePoint.prototype.overlapsBox = function overlapsBox (box) {
-        var markerBox = this.markerBox();
+    overlapsBox(box) {
+        const markerBox = this.markerBox();
         return markerBox.overlaps(box);
-    };
+    }
 
-    LinePoint.prototype.unclipElements = function unclipElements () {
+    unclipElements() {
         if (this.label) {
             this.label.options.noclip = true;
         }
@@ -330,9 +319,9 @@ var LinePoint = (function (ChartElement) {
         if (this.note) {
             this.note.options.noclip = true;
         }
-    };
+    }
 
-    LinePoint.prototype.pointData = function pointData () {
+    pointData() {
         return {
             dataItem: this.dataItem,
             category: this.category,
@@ -341,9 +330,9 @@ var LinePoint = (function (ChartElement) {
             stackValue: this.stackValue,
             series: this.series
         };
-    };
+    }
 
-    LinePoint.prototype.focusVisual = function focusVisual () {
+    focusVisual() {
         if (this.marker) {
             if (this.marker.visual) {
                 this.marker.visual.options.set("id", this._id);
@@ -351,9 +340,9 @@ var LinePoint = (function (ChartElement) {
 
             this.toggleFocusHighlight(true);
         }
-    };
+    }
 
-    LinePoint.prototype.clearFocusFromVisual = function clearFocusFromVisual () {
+    clearFocusFromVisual() {
         if (this.marker) {
             if (this.marker.visual) {
                 this.marker.visual.options.set("id", "");
@@ -361,14 +350,12 @@ var LinePoint = (function (ChartElement) {
 
             this.toggleFocusHighlight(false);
         }
-    };
+    }
 
-    LinePoint.prototype.getIndex = function getIndex () {
+    getIndex() {
         return defined(this.categoryIx) ? this.categoryIx : this.pointIx;
-    };
-
-    return LinePoint;
-}(ChartElement));
+    }
+}
 
 LinePoint.prototype.defaults = {
     vertical: true,

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

@@ -4,47 +4,41 @@ import { ChartElement } from '../../core';
 
 import { defined, isFunction, setDefaultOptions } from '../../common';
 
-var LineSegment = (function (ChartElement) {
-    function LineSegment(linePoints, series, seriesIx) {
-        ChartElement.call(this);
+class LineSegment extends ChartElement {
+    constructor(linePoints, series, seriesIx) {
+        super();
 
         this.linePoints = linePoints;
         this.series = series;
         this.seriesIx = seriesIx;
     }
 
-    if ( ChartElement ) LineSegment.__proto__ = ChartElement;
-    LineSegment.prototype = Object.create( ChartElement && ChartElement.prototype );
-    LineSegment.prototype.constructor = LineSegment;
-
-    LineSegment.prototype.points = function points () {
+    points() {
         return this.toGeometryPoints(this.linePoints);
-    };
+    }
 
-    LineSegment.prototype.toGeometryPoints = function toGeometryPoints (points) {
-        var result = [];
-        for (var i = 0, length = points.length; i < length; i++) {
+    toGeometryPoints(points) {
+        const result = [];
+        for (let i = 0, length = points.length; i < length; i++) {
             if (points[i] && points[i].visible !== false) {
                 result.push(points[i]._childBox.toRect().center());
             }
         }
 
         return result;
-    };
-
-    LineSegment.prototype.createVisual = function createVisual () {
-        var this$1 = this;
+    }
 
-        var customVisual = this.series.visual;
+    createVisual() {
+        const customVisual = this.series.visual;
         if (customVisual) {
             this.visual = customVisual({
                 points: this.toGeometryPoints(this.linePoints),
                 series: this.series,
                 sender: this.getSender(),
-                createVisual: function () {
-                    this$1.segmentVisual();
+                createVisual: () => {
+                    this.segmentVisual();
 
-                    return this$1.visual;
+                    return this.visual;
                 }
             });
             if (this.visual && !defined(this.visual.options.zIndex)) {
@@ -53,20 +47,17 @@ var LineSegment = (function (ChartElement) {
         } else {
             this.segmentVisual();
         }
-    };
+    }
 
-    LineSegment.prototype.segmentVisual = function segmentVisual () {
-        var ref = this;
-        var options = ref.options;
-        var series = ref.series;
-        var color = series.color;
-        var defaults = series._defaults;
+    segmentVisual() {
+        const { options, series } = this;
+        let { color, _defaults: defaults } = series;
 
         if (isFunction(color) && defaults) {
             color = defaults.color;
         }
 
-        var line = draw.Path.fromPoints(this.points(), {
+        const line = draw.Path.fromPoints(this.points(), {
             stroke: {
                 color: color,
                 width: series.width,
@@ -81,14 +72,12 @@ var LineSegment = (function (ChartElement) {
         }
 
         this.visual = line;
-    };
+    }
 
-    LineSegment.prototype.aliasFor = function aliasFor (e, coords) {
+    aliasFor(e, coords) {
         return this.parent.getNearestPoint(coords.x, coords.y, this.seriesIx);
-    };
-
-    return LineSegment;
-}(ChartElement));
+    }
+}
 
 setDefaultOptions(LineSegment, {
     closed: false

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

@@ -6,27 +6,19 @@ import { CurveProcessor } from '../../core';
 
 import { isFunction } from '../../common';
 
-var SplineSegment = (function (LineSegment) {
-    function SplineSegment () {
-        LineSegment.apply(this, arguments);
-    }
-
-    if ( LineSegment ) SplineSegment.__proto__ = LineSegment;
-    SplineSegment.prototype = Object.create( LineSegment && LineSegment.prototype );
-    SplineSegment.prototype.constructor = SplineSegment;
-
-    SplineSegment.prototype.segmentVisual = function segmentVisual () {
-        var series = this.series;
-        var defaults = series._defaults;
-        var color = series.color;
+class SplineSegment extends LineSegment {
+    segmentVisual() {
+        const series = this.series;
+        const defaults = series._defaults;
+        let color = series.color;
 
         if (isFunction(color) && defaults) {
             color = defaults.color;
         }
 
-        var curveProcessor = new CurveProcessor(this.options.closed);
-        var segments = curveProcessor.process(this.points());
-        var curve = new draw.Path({
+        const curveProcessor = new CurveProcessor(this.options.closed);
+        const segments = curveProcessor.process(this.points());
+        const curve = new draw.Path({
             stroke: {
                 color: color,
                 width: series.width,
@@ -39,9 +31,7 @@ var SplineSegment = (function (LineSegment) {
         curve.segments.push.apply(curve.segments, segments);
 
         this.visual = curve;
-    };
-
-    return SplineSegment;
-}(LineSegment));
+    }
+}
 
 export default SplineSegment;

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

@@ -3,27 +3,24 @@ import { geometry as geom } from '@progress/kendo-drawing';
 import { last } from '../../common';
 import { X, Y } from '../../common/constants';
 
-var StepLineMixin = {
+const StepLineMixin = {
     calculateStepPoints: function(points) {
-        var categoryAxis = this.parent.plotArea.seriesCategoryAxis(this.series);
-        var ref = categoryAxis.options;
-        var justified = ref.justified;
-        var vertical = ref.vertical;
-        var reverse = ref.reverse;
+        const categoryAxis = this.parent.plotArea.seriesCategoryAxis(this.series);
+        const { justified, vertical, reverse } = categoryAxis.options;
 
-        var stepAxis = vertical ? X : Y;
-        var axis = vertical ? Y : X;
-        var stepDir = reverse ? 2 : 1;
-        var dir = stepDir;
+        const stepAxis = vertical ? X : Y;
+        const axis = vertical ? Y : X;
+        const stepDir = reverse ? 2 : 1;
+        const dir = stepDir;
 
-        var previousPoint = toGeometryPoint(points[0], stepAxis, stepDir, axis, dir);
-        var result = [ previousPoint ];
+        let previousPoint = toGeometryPoint(points[0], stepAxis, stepDir, axis, dir);
+        const result = [ previousPoint ];
 
-        for (var idx = 1; idx < points.length; idx++) {
-            var point = toGeometryPoint(points[idx], stepAxis, stepDir, axis, dir);
+        for (let idx = 1; idx < points.length; idx++) {
+            const point = toGeometryPoint(points[idx], stepAxis, stepDir, axis, dir);
 
             if (previousPoint[stepAxis] !== point[stepAxis]) {
-                var stepPoint = new geom.Point();
+                const stepPoint = new geom.Point();
                 stepPoint[stepAxis] = previousPoint[stepAxis];
                 stepPoint[axis] = point[axis];
 
@@ -45,8 +42,8 @@ var StepLineMixin = {
 };
 
 function toGeometryPoint(lintPoint, stepAxis, stepDir, axis, dir) {
-    var box = lintPoint.box;
-    var result = new geom.Point();
+    const box = lintPoint.box;
+    const result = new geom.Point();
 
     result[stepAxis] = box[stepAxis + stepDir];
     result[axis] = box[axis + dir];

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

@@ -2,21 +2,11 @@ import LineSegment from './line-segment';
 import StepLineMixin from './step-line-mixin';
 import { deepExtend } from '../../common';
 
-var StepLineSegment = (function (LineSegment) {
-    function StepLineSegment () {
-        LineSegment.apply(this, arguments);
-    }
-
-    if ( LineSegment ) StepLineSegment.__proto__ = LineSegment;
-    StepLineSegment.prototype = Object.create( LineSegment && LineSegment.prototype );
-    StepLineSegment.prototype.constructor = StepLineSegment;
-
-    StepLineSegment.prototype.points = function points () {
+class StepLineSegment extends LineSegment {
+    points() {
         return this.calculateStepPoints(this.linePoints);
-    };
-
-    return StepLineSegment;
-}(LineSegment));
+    }
+}
 
 deepExtend(StepLineSegment.prototype, StepLineMixin);
 

package/dist/es/chart/mixins/accessibility-attributes-mixin.js

@@ -2,20 +2,20 @@ import addAccessibilityAttributesToVisual from "../../core/utils/add-accessibili
 import { deepExtend, getAriaTemplate } from "../../common";
 import guid from '../../core/utils/guid';
 
-var AccessibilityAttributesMixin = {
+const AccessibilityAttributesMixin = {
     addAccessibilityAttributesToVisual: function() {
         this._id = this._id || guid();
 
-        var accessibilityOptions = deepExtend({
+        const accessibilityOptions = deepExtend({
             ariaLabel: this.getAriaLabelText()
         }, this.options.accessibility);
 
         addAccessibilityAttributesToVisual(this.visual, accessibilityOptions);
     },
 
-    getAriaLabelText: function getAriaLabelText() {
-        var labels = this.options.labels;
-        var ariaTemplate = getAriaTemplate(labels);
+    getAriaLabelText() {
+        const labels = this.options.labels;
+        const ariaTemplate = getAriaTemplate(labels);
 
         if (ariaTemplate) {
             return ariaTemplate(this.pointData());
@@ -24,12 +24,12 @@ var AccessibilityAttributesMixin = {
         return this.getLabelText(labels);
     },
 
-    focusVisual: function focusVisual() {
+    focusVisual() {
         this.visual.options.set("id", this._id);
         this.toggleFocusHighlight(true);
     },
 
-    clearFocusFromVisual: function clearFocusFromVisual() {
+    clearFocusFromVisual() {
         this.visual.options.set("id", "");
         this.toggleFocusHighlight(false);
     }

package/dist/es/chart/mixins/clip-animation-mixin.js

@@ -4,12 +4,12 @@ import ClipAnimation from '../animations/clip-animation';
 import anyHasZIndex from '../utils/any-has-z-index';
 import { defined } from '../../common';
 
-var ClipAnimationMixin = {
+const ClipAnimationMixin = {
     createAnimation: function() {
-        var root = this.getRoot();
+        const root = this.getRoot();
         if (root && (root.options || {}).transitions !== false) {
-            var box = root.size();
-            var clipPath = draw.Path.fromRect(box.toRect());
+            const box = root.size();
+            const clipPath = draw.Path.fromRect(box.toRect());
             this.visual.clip(clipPath);
             this.animation = new ClipAnimation(clipPath, {
                 box: box
@@ -21,10 +21,10 @@ var ClipAnimationMixin = {
     },
 
     _setChildrenAnimation: function(clipPath) {
-        var points = this.animationPoints();
+        const points = this.animationPoints();
 
-        for (var idx = 0; idx < points.length; idx++) {
-            var point = points[idx];
+        for (let idx = 0; idx < points.length; idx++) {
+            const point = points[idx];
             if (point && point.visual && defined(point.visual.options.zIndex)) {
                 point.visual.clip(clipPath);
             }