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

package/dist/es/sankey/element.js

@@ -3,47 +3,39 @@ import {
     deepExtend
 } from '../common';
 
-export var SankeyElement = (function (Class) {
-    function SankeyElement(options) {
-        Class.call(this);
+export class SankeyElement extends Class {
+    constructor(options) {
+        super();
         this.options = deepExtend({}, this.options, options);
         this.createVisual();
     }
 
-    if ( Class ) SankeyElement.__proto__ = Class;
-    SankeyElement.prototype = Object.create( Class && Class.prototype );
-    SankeyElement.prototype.constructor = SankeyElement;
-
-    SankeyElement.prototype.createVisual = function createVisual () {
+    createVisual() {
         this.visual = this.createElement();
-    };
+    }
 
-    SankeyElement.prototype.exportVisual = function exportVisual () {
+    exportVisual() {
         return this.visual;
-    };
-
-    SankeyElement.prototype.createElement = function createElement () {
-        var this$1 = this;
+    }
 
-        var customVisual = this.options.visual;
-        var visual;
+    createElement() {
+        const customVisual = this.options.visual;
+        let visual;
 
         if (customVisual) {
             visual = customVisual({
                 sender: this.getSender(),
                 options: this.visualOptions(),
-                createVisual: function () { return this$1.getElement(); }
+                createVisual: () => this.getElement()
             });
         } else {
             visual = this.getElement();
         }
 
         return visual;
-    };
+    }
 
-    SankeyElement.prototype.getSender = function getSender () {
+    getSender() {
         return this;
-    };
-
-    return SankeyElement;
-}(Class));
+    }
+}

package/dist/es/sankey/label.js

@@ -1,28 +1,15 @@
 import { setDefaultOptions, deepExtend } from '../common';
 import { SankeyElement } from './element';
 import { Box, TextBox } from '../core';
-var INSIDE = 'inside';
-var BEFORE = 'before';
-var AFTER = 'after';
+const INSIDE = 'inside';
+const BEFORE = 'before';
+const AFTER = 'after';
 
-export var Label = (function (SankeyElement) {
-    function Label () {
-        SankeyElement.apply(this, arguments);
-    }
-
-    if ( SankeyElement ) Label.__proto__ = SankeyElement;
-    Label.prototype = Object.create( SankeyElement && SankeyElement.prototype );
-    Label.prototype.constructor = Label;
-
-    Label.prototype.getElement = function getElement () {
-        var options = deepExtend({}, this.options, this.options.node.label);
-        var node = options.node;
-        var diagramMinX = options.diagramMinX;
-        var diagramMaxX = options.diagramMaxX;
-        var text = options.text;
-        var offset = options.offset;
-        var rtl = options.rtl;
-        var position = options.position;
+export class Label extends SankeyElement {
+    getElement() {
+        const options = deepExtend({}, this.options, this.options.node.label);
+        const { node, diagramMinX, diagramMaxX, text, offset, rtl } = options;
+        let position = options.position;
         if (rtl && position !== INSIDE) {
             position = position === BEFORE ? AFTER : BEFORE;
         }
@@ -31,35 +18,35 @@ export var Label = (function (SankeyElement) {
             return null;
         }
 
-        var nodeBox = new Box(node.x0, node.y0, node.x1, node.y1);
-        var visualOptions = this.visualOptions();
+        const nodeBox = new Box(node.x0, node.y0, node.x1, node.y1);
+        const visualOptions = this.visualOptions();
         if (rtl && !visualOptions.align) {
             visualOptions.align = 'right';
         }
-        var textbox = new TextBox(text, visualOptions);
+        const textbox = new TextBox(text, visualOptions);
         textbox.reflow(new Box());
-        var textSizeBox = textbox.box;
-        var textY = nodeBox.center().y - (textSizeBox.height() / 2);
+        const textSizeBox = textbox.box;
+        const textY = nodeBox.center().y - (textSizeBox.height() / 2);
 
-        var labelAfterLastNode = node.x1 + textSizeBox.width() > diagramMaxX;
-        var labelBeforeFirstNode = node.x0 - textSizeBox.width() < diagramMinX;
-        var side = position === BEFORE || (position === INSIDE && labelAfterLastNode) ? BEFORE : AFTER;
+        const labelAfterLastNode = node.x1 + textSizeBox.width() > diagramMaxX;
+        const labelBeforeFirstNode = node.x0 - textSizeBox.width() < diagramMinX;
+        let side = position === BEFORE || (position === INSIDE && labelAfterLastNode) ? BEFORE : AFTER;
         if (rtl) {
             side = position === AFTER || (position === INSIDE && labelBeforeFirstNode) ? AFTER : BEFORE;
         }
-        var textOrigin = [side === BEFORE ? node.x0 - textSizeBox.width() : node.x1, textY];
+        const textOrigin = [side === BEFORE ? node.x0 - textSizeBox.width() : node.x1, textY];
 
-        var textRect = new Box(textOrigin[0], textOrigin[1], textOrigin[0] + textSizeBox.width(), textOrigin[1] + textSizeBox.height());
+        const textRect = new Box(textOrigin[0], textOrigin[1], textOrigin[0] + textSizeBox.width(), textOrigin[1] + textSizeBox.height());
         textRect.translate(offset.left || 0, offset.top || 0);
         textbox.reflow(textRect);
 
         textbox.renderVisual();
 
         return textbox.visual;
-    };
+    }
 
-    Label.prototype.visualOptions = function visualOptions () {
-        var options = deepExtend({}, this.options, this.options.node.label);
+    visualOptions() {
+        const options = deepExtend({}, this.options, this.options.node.label);
         return {
             color: options.color,
             font: options.font,
@@ -70,22 +57,20 @@ export var Label = (function (SankeyElement) {
             paintOrder: options.paintOrder,
             stroke: options.stroke,
         };
-    };
-
-    return Label;
-}(SankeyElement));
+    }
+}
 
 setDefaultOptions(Label, {
     position: INSIDE, // inside, before, after
 });
 
-export var resolveLabelOptions = function (node, options, rtl, diagramMinX, diagramMaxX) { return deepExtend({},
+export const resolveLabelOptions = (node, options, rtl, diagramMinX, diagramMaxX) => deepExtend({},
     options,
     {
-        node: node,
-        diagramMinX: diagramMinX,
-        diagramMaxX: diagramMaxX,
-        rtl: rtl,
+        node,
+        diagramMinX,
+        diagramMaxX,
+        rtl,
         visual: node.label.visual,
         visible: node.label.visible,
         margin: node.label.margin,
@@ -94,4 +79,4 @@ export var resolveLabelOptions = function (node, options, rtl, diagramMinX, diag
         align: node.label.align,
         offset: node.label.offset
     }
-); };
+);

package/dist/es/sankey/legend.js

@@ -4,68 +4,54 @@ import { setDefaultOptions } from '../common';
 import { BOTTOM, CENTER, LEFT, POINTER, RIGHT } from "../common/constants";
 import { AREA } from "../chart/constants";
 
-var sortData = function (a, b) {
+const sortData = (a, b) => {
     if (a.node.x0 - b.node.x0 !== 0) {
         return a.node.x0 - b.node.x0;
     }
     return a.node.y0 - b.node.y0;
 };
 
-var sortDataRTL = function (a, b) {
+const sortDataRTL = (a, b) => {
     if (a.node.x1 - b.node.x1 !== 0) {
         return a.node.x1 - b.node.x1;
     }
     return b.node.y0 - a.node.y0;
 };
 
-var sort = function (rtl) { return (rtl ? sortDataRTL : sortData); };
+const sort = (rtl) => (rtl ? sortDataRTL : sortData);
 
-export var Legend = (function (SankeyElement) {
-    function Legend () {
-        SankeyElement.apply(this, arguments);
-    }
-
-    if ( SankeyElement ) Legend.__proto__ = SankeyElement;
-    Legend.prototype = Object.create( SankeyElement && SankeyElement.prototype );
-    Legend.prototype.constructor = Legend;
-
-    Legend.prototype.getElement = function getElement () {
-        var options = this.options;
-        var drawingRect = options.drawingRect;
-        var rtl = options.rtl;
-        var nodes = options.nodes; if ( nodes === void 0 ) nodes = [];
-        var item = options.item;
-        var position = options.position;
+export class Legend extends SankeyElement {
+    getElement() {
+        const options = this.options;
+        const { drawingRect, rtl, nodes = [], item, position } = options;
 
         if (options.visible === false || !nodes.length) {
             return null;
         }
 
-        var data = nodes.map(function (node) { return ({
+        const data = nodes.map((node) => ({
             text: (node.label && node.label.text) || '',
             area: {
                 background: item.areaBackground !== undefined ? item.areaBackground : node.color,
                 opacity: item.areaOpacity !== undefined ? item.areaOpacity : node.opacity
             },
             node: node
-        }); });
+        }));
 
         data.sort(sort(rtl));
 
-        var reverse = rtl && position !== LEFT && position !== RIGHT;
-        var legend = new ChartLegend(Object.assign({}, options, {data: data, reverse: reverse}), { rtl: rtl });
+        const reverse = rtl && position !== LEFT && position !== RIGHT;
+        const legend = new ChartLegend(Object.assign({}, options, {data, reverse}), { rtl });
         legend.reflow(drawingRect);
 
         legend.renderVisual();
         return legend.visual;
-    };
+    }
 
-    Legend.prototype.createElement = function createElement () {
+    createElement() {
         return this.getElement();
-    };
-
-    return Legend;
-}(SankeyElement));
+    }
+}
 
 setDefaultOptions(Legend, {
     markers: { visible: false },

package/dist/es/sankey/link.js

@@ -5,19 +5,19 @@ import { deepExtend } from '../common';
 import { defined } from '../drawing-utils';
 import { ARIA_ACTIVE_DESCENDANT } from '../common/constants';
 
-var bezierPoint = function (p1, p2, p3, p4, t) {
-    var t1 = 1 - t;
-    var t1t1 = t1 * t1;
-    var tt = t * t;
+const bezierPoint = (p1, p2, p3, p4, t) => {
+    const t1 = 1 - t;
+    const t1t1 = t1 * t1;
+    const tt = t * t;
     return (p1 * t1t1 * t1) + (3 * p2 * t * t1t1) + (3 * p3 * tt * t1) + (p4 * tt * t);
 };
 
 function calculatePerpendicularLine(x1, y1, x2, y2, L) {
     // 1. Calculate the midpoint M
-    var xM = (x1 + x2) / 2;
-    var yM = (y1 + y2) / 2;
+    let xM = (x1 + x2) / 2;
+    let yM = (y1 + y2) / 2;
 
-    var dx, dy;
+    let dx, dy;
     if (y1 === y2) {
         // The line AB is horizontal
         dx = 0;
@@ -29,10 +29,10 @@ function calculatePerpendicularLine(x1, y1, x2, y2, L) {
     } else {
         // Common case when the line is not horizontal or vertical
         // 2. Calculate the slope of the original line
-        var m = (y2 - y1) / (x2 - x1);
+        let m = (y2 - y1) / (x2 - x1);
 
         // 3. Calculate the slope of the perpendicular line
-        var mPerp = -1 / m;
+        let mPerp = -1 / m;
 
         // 4. Calculate dx and dy
         dx = (L / 2) / Math.sqrt(1 + mPerp * mPerp);
@@ -40,58 +40,58 @@ function calculatePerpendicularLine(x1, y1, x2, y2, L) {
     }
 
     // 5. Coordinates of the points of the perpendicular line
-    var P1 = { x: xM - dx, y: yM - dy };
-    var P2 = { x: xM + dx, y: yM + dy };
+    let P1 = { x: xM - dx, y: yM - dy };
+    let P2 = { x: xM + dx, y: yM + dy };
 
-    return { P1: P1, P2: P2 };
+    return { P1, P2 };
 }
 
 function findIntersection(a, b, L, p, q) {
     // Midpoint between a and b
-    var midpoint = {
+    const midpoint = {
         x: (a.x + b.x) / 2,
         y: (a.y + b.y) / 2
     };
 
     // Vector of the line ab
-    var ab_dx = b.x - a.x;
-    var ab_dy = b.y - a.y;
+    const ab_dx = b.x - a.x;
+    const ab_dy = b.y - a.y;
 
     // Vector, perpendicular to ab
-    var perp_dx = -ab_dy;
-    var perp_dy = ab_dx;
+    let perp_dx = -ab_dy;
+    let perp_dy = ab_dx;
 
     // Normalize the perpendicular vector and scale it to 2*L
-    var magnitude = Math.sqrt(perp_dx * perp_dx + perp_dy * perp_dy);
+    const magnitude = Math.sqrt(perp_dx * perp_dx + perp_dy * perp_dy);
     perp_dx = (perp_dx / magnitude) * L;
     perp_dy = (perp_dy / magnitude) * L;
 
     // The endpoints of the perpendicular, 2*L long
-    var c1 = {
+    const c1 = {
         x: midpoint.x + perp_dx,
         y: midpoint.y + perp_dy
     };
-    var c2 = {
+    const c2 = {
         x: midpoint.x - perp_dx,
         y: midpoint.y - perp_dy
     };
 
     // Check for intersection of the lines pq and the perpendicular
-    var pq_dx = q.x - p.x;
-    var pq_dy = q.y - p.y;
+    const pq_dx = q.x - p.x;
+    const pq_dy = q.y - p.y;
 
-    var denominator = (pq_dy) * (c1.x - c2.x) - (pq_dx) * (c1.y - c2.y);
+    const denominator = (pq_dy) * (c1.x - c2.x) - (pq_dx) * (c1.y - c2.y);
 
     if (Math.abs(denominator) < 1e-10) {
         // The lines are almost parallel, no intersection
         return null;
     }
 
-    var ua = (pq_dx * (c2.y - p.y) - pq_dy * (c2.x - p.x)) / denominator;
-    var ub = ((c1.x - c2.x) * (c2.y - p.y) - (c1.y - c2.y) * (c2.x - p.x)) / denominator;
+    const ua = (pq_dx * (c2.y - p.y) - pq_dy * (c2.x - p.x)) / denominator;
+    const ub = ((c1.x - c2.x) * (c2.y - p.y) - (c1.y - c2.y) * (c2.x - p.x)) / denominator;
 
     if (ua >= 0 && ua <= 1 && ub >= 0 && ub <= 1) {
-        var intersection = {
+        const intersection = {
             x: c2.x + ua * (c1.x - c2.x),
             // y: c2.y + ua * (c1.y - c2.y)
         };
@@ -102,76 +102,65 @@ function findIntersection(a, b, L, p, q) {
     return null;
 }
 
-var calculateControlPointsOffsetX = function (link, rtl) {
-    var halfWidth = link.width / 2;
-    var x0 = rtl ? link.x1 : link.x0;
-    var x1 = rtl ? link.x0 : link.x1;
-    var y0 = rtl ? link.y1 : link.y0;
-    var y1 = rtl ? link.y0 : link.y1;
+const calculateControlPointsOffsetX = (link, rtl) => {
+    const halfWidth = link.width / 2;
+    const x0 = rtl ? link.x1 : link.x0;
+    const x1 = rtl ? link.x0 : link.x1;
+    const y0 = rtl ? link.y1 : link.y0;
+    const y1 = rtl ? link.y0 : link.y1;
 
-    var xC = (x0 + x1) / 2;
-    var middlePoint = [xC, bezierPoint(y0, y0, y1, y1, 0.5)];
+    const xC = (x0 + x1) / 2;
+    const middlePoint = [xC, bezierPoint(y0, y0, y1, y1, 0.5)];
 
-    var tH = 0.4999;
+    const tH = 0.4999;
 
-    var pointH = [
+    const pointH = [
         bezierPoint(x0, xC, xC, x1, tH),
         bezierPoint(y0, y0, y1, y1, tH)
     ];
 
-    var line = calculatePerpendicularLine(middlePoint[0], middlePoint[1], pointH[0], pointH[1], link.width);
+    const line = calculatePerpendicularLine(middlePoint[0], middlePoint[1], pointH[0], pointH[1], link.width);
 
-    var middlePointDown = [xC, bezierPoint(y0 + halfWidth, y0 + halfWidth, y1 + halfWidth, y1 + halfWidth, 0.5)];
+    const middlePointDown = [xC, bezierPoint(y0 + halfWidth, y0 + halfWidth, y1 + halfWidth, y1 + halfWidth, 0.5)];
     // const middlePointUp = [xC, bezierPoint(y0 - halfWidth, y0 - halfWidth, y1 - halfWidth, y1 - halfWidth, 0.5)];
 
-    var P = line.P1.y > line.P2.y ? line.P1 : line.P2;
-    var L = halfWidth;
-    var LDir = (y0 > y1 ? 1 : -1) * L;
-    var a = P;
-    var b = { x: middlePointDown[0], y: middlePointDown[1] };
-    var p = { x: middlePointDown[0], y: middlePointDown[1] };
-    var q = { x: Math.max(1, middlePointDown[0] + LDir), y: middlePointDown[1] };
-    var Pmx = findIntersection(a, b, L, p, q) || { x: (middlePointDown[0] + P.x) / 2 };
-    var P1 = x0;
-    var P4 = x1;
-    var P2 = (Pmx.x - (0.125 * P1) - (0.125 * P4)) / 0.75;
+    const P = line.P1.y > line.P2.y ? line.P1 : line.P2;
+    const L = halfWidth;
+    const LDir = (y0 > y1 ? 1 : -1) * L;
+    const a = P;
+    const b = { x: middlePointDown[0], y: middlePointDown[1] };
+    const p = { x: middlePointDown[0], y: middlePointDown[1] };
+    const q = { x: Math.max(1, middlePointDown[0] + LDir), y: middlePointDown[1] };
+    const Pmx = findIntersection(a, b, L, p, q) || { x: (middlePointDown[0] + P.x) / 2 };
+    const P1 = x0;
+    const P4 = x1;
+    const P2 = (Pmx.x - (0.125 * P1) - (0.125 * P4)) / 0.75;
 
     return xC - P2;
 };
 
-export var Link = (function (SankeyElement) {
-    function Link () {
-        SankeyElement.apply(this, arguments);
-    }
-
-    if ( SankeyElement ) Link.__proto__ = SankeyElement;
-    Link.prototype = Object.create( SankeyElement && SankeyElement.prototype );
-    Link.prototype.constructor = Link;
-
-    Link.prototype.getElement = function getElement () {
-        var link = this.options.link;
-        var x0 = link.x0;
-        var x1 = link.x1;
-        var y0 = link.y0;
-        var y1 = link.y1;
-        var xC = (x0 + x1) / 2;
+export class Link extends SankeyElement {
+    getElement() {
+        const link = this.options.link;
+        const { x0, x1, y0, y1 } = link;
+        const xC = (x0 + x1) / 2;
 
         return new drawing.Path(this.visualOptions())
             .moveTo(x0, y0).curveTo([xC, y0], [xC, y1], [x1, y1]);
-    };
+    }
 
-    Link.prototype.getLabelText = function getLabelText (options) {
-        var labelTemplate = options.labels.ariaTemplate;
+    getLabelText(options) {
+        let labelTemplate = options.labels.ariaTemplate;
 
         if (labelTemplate) {
             return labelTemplate({ link: options.link });
         }
-    };
+    }
 
-    Link.prototype.visualOptions = function visualOptions () {
-        var options = this.options;
-        var link = this.options.link;
-        var ariaLabel = this.getLabelText(options);
+    visualOptions() {
+        const options = this.options;
+        const link = this.options.link;
+        const ariaLabel = this.getLabelText(options);
 
         return {
             stroke: {
@@ -183,23 +172,19 @@ export var Link = (function (SankeyElement) {
             ariaRoleDescription: 'Link',
             ariaLabel: ariaLabel
         };
-    };
+    }
 
-    Link.prototype.createFocusHighlight = function createFocusHighlight () {
+    createFocusHighlight() {
         if (!this.options.navigatable) {
             return;
         }
 
-        var ref = this.options;
-        var link = ref.link;
-        var x0 = link.x0;
-        var x1 = link.x1;
-        var y0 = link.y0;
-        var y1 = link.y1;
-        var xC = (x0 + x1) / 2;
-        var halfWidth = link.width / 2;
+        const { link } = this.options;
+        const { x0, x1, y0, y1 } = link;
+        const xC = (x0 + x1) / 2;
+        const halfWidth = link.width / 2;
 
-        var offset = calculateControlPointsOffsetX(link, this.options.rtl);
+        const offset = calculateControlPointsOffsetX(link, this.options.rtl);
 
         this._highlight = new drawing.Path({ stroke: this.options.focusHighlight.border, visible: false })
             .moveTo(x0, y0 + halfWidth)
@@ -207,25 +192,24 @@ export var Link = (function (SankeyElement) {
             .curveTo([xC + offset, y0 - halfWidth], [xC + offset, y1 - halfWidth], [x1, y1 - halfWidth])
             .lineTo(x1, y1 + halfWidth)
             .curveTo([xC - offset, y1 + halfWidth], [xC - offset, y0 + halfWidth], [x0, y0 + halfWidth]);
-    };
+    }
 
-    Link.prototype.focus = function focus (options) {
+    focus(options) {
         if (this._highlight) {
-            var ref = options || {};
-            var highlight = ref.highlight; if ( highlight === void 0 ) highlight = true;
+            const { highlight = true } = options || {};
             if (highlight) {
                 this._highlight.options.set('visible', true);
             }
-            var id = (this.options.link.sourceId) + "->" + (this.options.link.targetId);
+            const id = `${this.options.link.sourceId}->${this.options.link.targetId}`;
             this.visual.options.set('id', id);
 
             if (this.options.root()) {
                 this.options.root().setAttribute(ARIA_ACTIVE_DESCENDANT, id);
             }
         }
-    };
+    }
 
-    Link.prototype.blur = function blur () {
+    blur() {
         if (this._highlight) {
             this._highlight.options.set('visible', false);
             this.visual.options.set('id', '');
@@ -234,16 +218,14 @@ export var Link = (function (SankeyElement) {
                 this.options.root().removeAttribute(ARIA_ACTIVE_DESCENDANT);
             }
         }
-    };
-
-    return Link;
-}(SankeyElement));
+    }
+}
 
-export var resolveLinkOptions = function (link, options, sourceNode, targetNode) {
-    var linkOptions = deepExtend({},
+export const resolveLinkOptions = (link, options, sourceNode, targetNode) => {
+    const linkOptions = deepExtend({},
         options,
         {
-            link: link,
+            link,
             opacity: link.opacity,
             color: link.color,
             colorType: link.colorType,