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

package/dist/es/core/ring.js

@@ -3,9 +3,10 @@ import Point from './point';
 import { COORD_PRECISION, MAX_VALUE, MIN_VALUE } from '../common/constants';
 import { Class, clockwise, rad, round } from '../common';
 
-var Ring = (function (Class) {
-    function Ring(center, innerRadius, radius, startAngle, angle) {
-        Class.call(this);
+class Ring extends Class {
+
+    constructor(center, innerRadius, radius, startAngle, angle) {
+        super();
 
         this.center = center;
         this.innerRadius = innerRadius;
@@ -14,19 +15,15 @@ var Ring = (function (Class) {
         this.angle = angle;
     }
 
-    if ( Class ) Ring.__proto__ = Class;
-    Ring.prototype = Object.create( Class && Class.prototype );
-    Ring.prototype.constructor = Ring;
-
-    Ring.prototype.clone = function clone () {
+    clone() {
         return new Ring(this.center, this.innerRadius, this.radius, this.startAngle, this.angle);
-    };
+    }
 
-    Ring.prototype.middle = function middle () {
+    middle() {
         return this.startAngle + this.angle / 2;
-    };
+    }
 
-    Ring.prototype.setRadius = function setRadius (newRadius, innerRadius) {
+    setRadius(newRadius, innerRadius) {
         if (innerRadius) {
             this.innerRadius = newRadius;
         } else {
@@ -34,30 +31,30 @@ var Ring = (function (Class) {
         }
 
         return this;
-    };
+    }
 
     // TODO: Remove and replace with Point.onCircle
-    Ring.prototype.point = function point (angle, innerRadius) {
-        var radianAngle = rad(angle);
-        var ax = Math.cos(radianAngle);
-        var ay = Math.sin(radianAngle);
-        var radius = innerRadius ? this.innerRadius : this.radius;
-        var x = round(this.center.x - (ax * radius), COORD_PRECISION);
-        var y = round(this.center.y - (ay * radius), COORD_PRECISION);
+    point(angle, innerRadius) {
+        const radianAngle = rad(angle);
+        const ax = Math.cos(radianAngle);
+        const ay = Math.sin(radianAngle);
+        const radius = innerRadius ? this.innerRadius : this.radius;
+        const x = round(this.center.x - (ax * radius), COORD_PRECISION);
+        const y = round(this.center.y - (ay * radius), COORD_PRECISION);
 
         return new Point(x, y);
-    };
-
-    Ring.prototype.adjacentBox = function adjacentBox (distance, width, height) {
-        var sector = this.clone().expand(distance);
-        var midAndle = sector.middle();
-        var midPoint = sector.point(midAndle);
-        var hw = width / 2;
-        var hh = height / 2;
-        var sa = Math.sin(rad(midAndle));
-        var ca = Math.cos(rad(midAndle));
-        var x = midPoint.x - hw;
-        var y = midPoint.y - hh;
+    }
+
+    adjacentBox(distance, width, height) {
+        const sector = this.clone().expand(distance);
+        const midAndle = sector.middle();
+        const midPoint = sector.point(midAndle);
+        const hw = width / 2;
+        const hh = height / 2;
+        const sa = Math.sin(rad(midAndle));
+        const ca = Math.cos(rad(midAndle));
+        let x = midPoint.x - hw;
+        let y = midPoint.y - hh;
 
         if (Math.abs(sa) < 0.9) {
             x += hw * -ca / Math.abs(ca);
@@ -68,39 +65,37 @@ var Ring = (function (Class) {
         }
 
         return new Box(x, y, x + width, y + height);
-    };
-
-    Ring.prototype.containsPoint = function containsPoint (p) {
-        var center = this.center;
-        var innerRadius = this.innerRadius;
-        var radius = this.radius;
-        var startAngle = this.startAngle;
-        var endAngle = this.startAngle + this.angle;
-        var dx = p.x - center.x;
-        var dy = p.y - center.y;
-        var vector = new Point(dx, dy);
-        var startPoint = this.point(startAngle);
-        var startVector = new Point(startPoint.x - center.x, startPoint.y - center.y);
-        var endPoint = this.point(endAngle);
-        var endVector = new Point(endPoint.x - center.x, endPoint.y - center.y);
-        var dist = round(dx * dx + dy * dy, COORD_PRECISION);
+    }
+
+    containsPoint(p) {
+        const center = this.center;
+        const innerRadius = this.innerRadius;
+        const radius = this.radius;
+        const startAngle = this.startAngle;
+        const endAngle = this.startAngle + this.angle;
+        const dx = p.x - center.x;
+        const dy = p.y - center.y;
+        const vector = new Point(dx, dy);
+        const startPoint = this.point(startAngle);
+        const startVector = new Point(startPoint.x - center.x, startPoint.y - center.y);
+        const endPoint = this.point(endAngle);
+        const endVector = new Point(endPoint.x - center.x, endPoint.y - center.y);
+        const dist = round(dx * dx + dy * dy, COORD_PRECISION);
 
         return (startVector.equals(vector) || clockwise(startVector, vector)) &&
                !clockwise(endVector, vector) &&
                dist >= innerRadius * innerRadius && dist <= radius * radius;
-    };
-
-    Ring.prototype.getBBox = function getBBox () {
-        var this$1 = this;
+    }
 
-        var box = new Box(MAX_VALUE, MAX_VALUE, MIN_VALUE, MIN_VALUE);
-        var startAngle = round(this.startAngle % 360);
-        var endAngle = round((startAngle + this.angle) % 360);
-        var innerRadius = this.innerRadius;
-        var allAngles = [ 0, 90, 180, 270, startAngle, endAngle ].sort(numericComparer);
-        var startAngleIndex = allAngles.indexOf(startAngle);
-        var endAngleIndex = allAngles.indexOf(endAngle);
-        var angles;
+    getBBox() {
+        const box = new Box(MAX_VALUE, MAX_VALUE, MIN_VALUE, MIN_VALUE);
+        const startAngle = round(this.startAngle % 360);
+        const endAngle = round((startAngle + this.angle) % 360);
+        const innerRadius = this.innerRadius;
+        const allAngles = [ 0, 90, 180, 270, startAngle, endAngle ].sort(numericComparer);
+        const startAngleIndex = allAngles.indexOf(startAngle);
+        const endAngleIndex = allAngles.indexOf(endAngle);
+        let angles;
 
         if (startAngle === endAngle) {
             angles = allAngles;
@@ -115,8 +110,8 @@ var Ring = (function (Class) {
             }
         }
 
-        for (var i = 0; i < angles.length; i++) {
-            var point = this$1.point(angles[i]);
+        for (let i = 0; i < angles.length; i++) {
+            let point = this.point(angles[i]);
             box.wrapPoint(point);
             box.wrapPoint(point, innerRadius);
         }
@@ -126,15 +121,13 @@ var Ring = (function (Class) {
         }
 
         return box;
-    };
+    }
 
-    Ring.prototype.expand = function expand (value) {
+    expand(value) {
         this.radius += value;
         return this;
-    };
-
-    return Ring;
-}(Class));
+    }
+}
 
 function numericComparer(a, b) {
     return a - b;

package/dist/es/core/root-element.js

@@ -9,46 +9,40 @@ import boxDiff from './utils/box-diff';
 import { DEFAULT_WIDTH, DEFAULT_HEIGHT, WHITE, BLACK } from '../common/constants';
 import { getSpacing, objectKey, setDefaultOptions } from '../common';
 
-var RootElement = (function (ChartElement) {
-    function RootElement(options) {
-        ChartElement.call(this, options);
+class RootElement extends ChartElement {
+    constructor(options) {
+        super(options);
 
-        var rootOptions = this.options;
+        const rootOptions = this.options;
         rootOptions.width = parseInt(rootOptions.width, 10);
         rootOptions.height = parseInt(rootOptions.height, 10);
 
         this.gradients = {};
     }
 
-    if ( ChartElement ) RootElement.__proto__ = ChartElement;
-    RootElement.prototype = Object.create( ChartElement && ChartElement.prototype );
-    RootElement.prototype.constructor = RootElement;
-
-    RootElement.prototype.reflow = function reflow () {
-        var ref = this;
-        var options = ref.options;
-        var children = ref.children;
-        var currentBox = new Box(0, 0, options.width, options.height);
+    reflow() {
+        const { options, children } = this;
+        let currentBox = new Box(0, 0, options.width, options.height);
 
         this.box = currentBox.unpad(options.margin);
 
-        for (var i = 0; i < children.length; i++) {
+        for (let i = 0; i < children.length; i++) {
             children[i].reflow(currentBox);
             currentBox = boxDiff(currentBox, children[i].box) || new Box();
         }
-    };
+    }
 
-    RootElement.prototype.createVisual = function createVisual () {
+    createVisual() {
         this.visual = new draw.Group();
         this.createBackground();
-    };
+    }
 
-    RootElement.prototype.createBackground = function createBackground () {
-        var options = this.options;
-        var border = options.border || {};
-        var box = this.box.clone().pad(options.margin).unpad(border.width);
+    createBackground() {
+        const options = this.options;
+        const border = options.border || {};
+        const box = this.box.clone().pad(options.margin).unpad(border.width);
 
-        var background = draw.Path.fromRect(box.toRect(), {
+        const background = draw.Path.fromRect(box.toRect(), {
             stroke: {
                 color: border.width ? border.color : "",
                 width: border.width,
@@ -62,22 +56,22 @@ var RootElement = (function (ChartElement) {
         });
 
         this.visual.append(background);
-    };
+    }
 
-    RootElement.prototype.getRoot = function getRoot () {
+    getRoot() {
         return this;
-    };
+    }
 
-    RootElement.prototype.createGradient = function createGradient (options) {
-        var gradients = this.gradients;
-        var hashCode = objectKey(options);
-        var gradient = GRADIENTS[options.gradient];
-        var drawingGradient;
+    createGradient(options) {
+        const gradients = this.gradients;
+        const hashCode = objectKey(options);
+        const gradient = GRADIENTS[options.gradient];
+        let drawingGradient;
 
         if (gradients[hashCode]) {
             drawingGradient = gradients[hashCode];
         } else {
-            var gradientOptions = Object.assign({}, gradient, options);
+            const gradientOptions = Object.assign({}, gradient, options);
             if (gradient.type === "linear") {
                 drawingGradient = new draw.LinearGradient(gradientOptions);
             } else {
@@ -91,22 +85,20 @@ var RootElement = (function (ChartElement) {
         }
 
         return drawingGradient;
-    };
+    }
 
-    RootElement.prototype.cleanGradients = function cleanGradients () {
-        var gradients = this.gradients;
-        for (var hashCode in gradients) {
+    cleanGradients() {
+        const gradients = this.gradients;
+        for (let hashCode in gradients) {
             gradients[hashCode]._observers = [];//add clear observers method in drawing ObserversMixin
         }
-    };
+    }
 
-    RootElement.prototype.size = function size () {
-        var options = this.options;
+    size() {
+        const options = this.options;
         return new Box(0, 0, options.width, options.height);
-    };
-
-    return RootElement;
-}(ChartElement));
+    }
+}
 
 setDefaultOptions(RootElement, {
     width: DEFAULT_WIDTH,
@@ -121,13 +113,13 @@ setDefaultOptions(RootElement, {
 });
 
 function innerRadialStops(options) {
-    var stops = options.stops;
-    var usedSpace = ((options.innerRadius / options.radius) * 100);
-    var length = stops.length;
-    var currentStops = [];
+    const stops = options.stops;
+    const usedSpace = ((options.innerRadius / options.radius) * 100);
+    const length = stops.length;
+    const currentStops = [];
 
-    for (var i = 0; i < length; i++) {
-        var currentStop = Object.assign({}, stops[i]);
+    for (let i = 0; i < length; i++) {
+        let currentStop = Object.assign({}, stops[i]);
         currentStop.offset = (currentStop.offset * (100 - usedSpace) + usedSpace) / 100;
         currentStops.push(currentStop);
     }

package/dist/es/core/sector.js

@@ -1,29 +1,23 @@
 import Ring from './ring';
 
-var Sector = (function (Ring) {
-    function Sector(center, radius, startAngle, angle) {
-        Ring.call(this, center, 0, radius, startAngle, angle);
+class Sector extends Ring {
+    constructor(center, radius, startAngle, angle) {
+        super(center, 0, radius, startAngle, angle);
     }
 
-    if ( Ring ) Sector.__proto__ = Ring;
-    Sector.prototype = Object.create( Ring && Ring.prototype );
-    Sector.prototype.constructor = Sector;
-
-    Sector.prototype.expand = function expand (value) {
-        return Ring.prototype.expand.call(this, value);
-    };
+    expand(value) {
+        return super.expand(value);
+    }
 
-    Sector.prototype.clone = function clone () {
+    clone() {
         return new Sector(this.center, this.radius, this.startAngle, this.angle);
-    };
+    }
 
-    Sector.prototype.setRadius = function setRadius (newRadius) {
+    setRadius(newRadius) {
         this.radius = newRadius;
 
         return this;
-    };
-
-    return Sector;
-}(Ring));
+    }
+}
 
 export default Sector;

package/dist/es/core/shape-builder.js

@@ -1,40 +1,32 @@
 import { geometry as geom, drawing as draw } from '@progress/kendo-drawing';
 import { Class } from '../common';
 
-var DIRECTION_ANGLE = 0.001; //any value that will make the endAngle bigger than the start angle will work here.
+const DIRECTION_ANGLE = 0.001; //any value that will make the endAngle bigger than the start angle will work here.
 
-var ShapeBuilder = (function (Class) {
-    function ShapeBuilder () {
-        Class.apply(this, arguments);
-    }
-
-    if ( Class ) ShapeBuilder.__proto__ = Class;
-    ShapeBuilder.prototype = Object.create( Class && Class.prototype );
-    ShapeBuilder.prototype.constructor = ShapeBuilder;
-
-    ShapeBuilder.prototype.createRing = function createRing (sector, options) {
-        var startAngle = sector.startAngle + 180;
-        var endAngle = sector.angle + startAngle;
+class ShapeBuilder extends Class {
+    createRing(sector, options) {
+        const startAngle = sector.startAngle + 180;
+        let endAngle = sector.angle + startAngle;
 
         //required in order to avoid reversing the arc direction in cases like 0.000000000000001 + 100 === 100
         if (sector.angle === 0 || sector.angle > 0 && startAngle === endAngle) {
             endAngle += DIRECTION_ANGLE;
         }
 
-        var center = new geom.Point(sector.center.x, sector.center.y);
-        var radius = Math.max(sector.radius, 0);
-        var innerRadius = Math.max(sector.innerRadius, 0);
-        var arc = new geom.Arc(center, {
+        const center = new geom.Point(sector.center.x, sector.center.y);
+        const radius = Math.max(sector.radius, 0);
+        const innerRadius = Math.max(sector.innerRadius, 0);
+        const arc = new geom.Arc(center, {
             startAngle: startAngle,
             endAngle: endAngle,
             radiusX: radius,
             radiusY: radius
         });
-        var path = draw.Path.fromArc(arc, options).close();
+        const path = draw.Path.fromArc(arc, options).close();
 
         if (innerRadius) {
             arc.radiusX = arc.radiusY = innerRadius;
-            var innerEnd = arc.pointAt(endAngle);
+            const innerEnd = arc.pointAt(endAngle);
             path.lineTo(innerEnd.x, innerEnd.y);
             path.arc(endAngle, startAngle, innerRadius, innerRadius, true);
         } else {
@@ -42,10 +34,8 @@ var ShapeBuilder = (function (Class) {
         }
 
         return path;
-    };
-
-    return ShapeBuilder;
-}(Class));
+    }
+}
 
 ShapeBuilder.current = new ShapeBuilder();
 

package/dist/es/core/shape-element.js

@@ -5,33 +5,27 @@ import { valueOrDefault } from '../drawing-utils';
 import BoxElement from './box-element';
 import addAccessibilityAttributesToVisual from './utils/add-accessibility-attributes-to-visual';
 
-var ShapeElement = (function (BoxElement) {
-    function ShapeElement(options, pointData) {
-        BoxElement.call(this, options);
+class ShapeElement extends BoxElement {
+
+    constructor(options, pointData) {
+        super(options);
 
         this.pointData = pointData;
     }
 
-    if ( BoxElement ) ShapeElement.__proto__ = BoxElement;
-    ShapeElement.prototype = Object.create( BoxElement && BoxElement.prototype );
-    ShapeElement.prototype.constructor = ShapeElement;
-
-    ShapeElement.prototype.getElement = function getElement () {
-        var ref = this;
-        var options = ref.options;
-        var box = ref.paddingBox;
-        var type = options.type;
-        var rotation = options.rotation;
-        var center = box.center();
-        var halfWidth = box.width() / 2;
-        var halfHeight = box.height() / 2;
+    getElement() {
+        const { options, paddingBox: box } = this;
+        const { type, rotation } = options;
+        const center = box.center();
+        const halfWidth = box.width() / 2;
+        const halfHeight = box.height() / 2;
 
         if (!options.visible || !this.hasBox()) {
             return null;
         }
 
-        var style = this.visualStyle();
-        var element;
+        const style = this.visualStyle();
+        let element;
 
         if (type === CIRCLE) {
             element = new draw.Circle(
@@ -53,9 +47,9 @@ var ShapeElement = (function (BoxElement) {
             element.moveTo(box.x1, box.y1).lineTo(box.x2, box.y2);
             element.moveTo(box.x1, box.y2).lineTo(box.x2, box.y1);
         } else {
-            var rect = box.toRect();
+            const rect = box.toRect();
             if (type === ROUNDED_RECT) {
-                var borderRadius = valueOrDefault(options.borderRadius, rect.width() / 5);
+                const borderRadius = valueOrDefault(options.borderRadius, rect.width() / 5);
                 rect.setCornerRadius(borderRadius);
             }
 
@@ -71,14 +65,12 @@ var ShapeElement = (function (BoxElement) {
         element.options.zIndex = options.zIndex;
 
         return element;
-    };
-
-    ShapeElement.prototype.createElement = function createElement () {
-        var this$1 = this;
+    }
 
-        var customVisual = this.options.visual;
-        var pointData = this.pointData || {};
-        var visual;
+    createElement() {
+        const customVisual = this.options.visual;
+        const pointData = this.pointData || {};
+        let visual;
 
         if (customVisual) {
             visual = customVisual({
@@ -89,17 +81,17 @@ var ShapeElement = (function (BoxElement) {
                 category: pointData.category,
                 rect: this.paddingBox.toRect(),
                 options: this.visualOptions(),
-                createVisual: function () { return this$1.getElement(); }
+                createVisual: () => this.getElement()
             });
         } else {
             visual = this.getElement();
         }
 
         return visual;
-    };
+    }
 
-    ShapeElement.prototype.visualOptions = function visualOptions () {
-        var options = this.options;
+    visualOptions() {
+        const options = this.options;
         return {
             background: options.background,
             border: options.border,
@@ -109,16 +101,14 @@ var ShapeElement = (function (BoxElement) {
             size: options.width,
             visible: options.visible
         };
-    };
+    }
 
-    ShapeElement.prototype.createVisual = function createVisual () {
+    createVisual() {
         this.visual = this.createElement();
 
         addAccessibilityAttributesToVisual(this.visual, this.options.accessibilityOptions);
-    };
-
-    return ShapeElement;
-}(BoxElement));
+    }
+}
 
 setDefaultOptions(ShapeElement, {
     type: CIRCLE,