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

package/dist/es/sankey/sankey.js

@@ -10,34 +10,33 @@ import { Box, rectToBox } from '../core';
 import { Legend } from './legend';
 import { defined } from '../drawing-utils';
 
-var LINK = 'link';
-var NODE = 'node';
-
-var toRtl = function (sankey) {
-    var nodes = sankey.nodes;
-    var links = sankey.links;
-    var startX = Math.min.apply(Math, nodes.map(function (node) { return node.x0; }));
-    var endX = Math.max.apply(Math, nodes.map(function (node) { return node.x1; }));
-    var width = endX - startX;
-
-    nodes.forEach(function (node) {
-        var x0 = width - (node.x1 - 2 * startX);
-        var x1 = width - (node.x0 - 2 * startX);
+const LINK = 'link';
+const NODE = 'node';
+
+const toRtl = sankey => {
+    const { nodes, links } = sankey;
+    const startX = Math.min(...nodes.map(node => node.x0));
+    const endX = Math.max(...nodes.map(node => node.x1));
+    const width = endX - startX;
+
+    nodes.forEach(node => {
+        const x0 = width - (node.x1 - 2 * startX);
+        const x1 = width - (node.x0 - 2 * startX);
         node.x0 = x0;
         node.x1 = x1;
     });
 
-    links.forEach(function (link) {
-        var x0 = width - (link.x1 - 2 * startX);
-        var x1 = width - (link.x0 - 2 * startX);
+    links.forEach(link => {
+        const x0 = width - (link.x1 - 2 * startX);
+        const x1 = width - (link.x0 - 2 * startX);
         link.x1 = x0;
         link.x0 = x1;
     });
 };
 
-export var Sankey = (function (Observable) {
-    function Sankey(element, options, theme) {
-        Observable.call(this);
+export class Sankey extends Observable {
+    constructor(element, options, theme) {
+        super();
 
         this._initTheme(theme);
         this._setOptions(options);
@@ -51,11 +50,7 @@ export var Sankey = (function (Observable) {
         }
     }
 
-    if ( Observable ) Sankey.__proto__ = Observable;
-    Sankey.prototype = Object.create( Observable && Observable.prototype );
-    Sankey.prototype.constructor = Sankey;
-
-    Sankey.prototype.destroy = function destroy () {
+    destroy() {
         this.unbind();
         this._destroySurface();
         this._destroyResizeObserver();
@@ -71,15 +66,14 @@ export var Sankey = (function (Observable) {
         this._focusState = null;
 
         this.element = null;
-    };
+    }
 
-    Sankey.prototype._initElement = function _initElement (element) {
+    _initElement(element) {
         this.element = element;
         addClass(element, [ "k-chart", "k-sankey" ]);
         element.setAttribute('role', 'graphics-document');
 
-        var ref = this.options;
-        var title = ref.title;
+        const { title } = this.options;
 
         if (title.text) {
             element.setAttribute('aria-label', title.text);
@@ -88,17 +82,17 @@ export var Sankey = (function (Observable) {
         if (title.description) {
             element.setAttribute("aria-roledescription", title.description);
         }
-    };
+    }
 
-    Sankey.prototype._initSurface = function _initSurface () {
+    _initSurface() {
         if (!this.surface) {
             this._destroySurface();
             this._initSurfaceElement();
             this.surface = this._createSurface();
         }
-    };
+    }
 
-    Sankey.prototype._initNavigation = function _initNavigation (element) {
+    _initNavigation(element) {
         element.tabIndex = element.getAttribute("tabindex") || 0;
 
         if (this.options.disableKeyboardNavigation) {
@@ -121,114 +115,103 @@ export var Sankey = (function (Observable) {
             node: this.firstFocusableNode(),
             link: null
         };
-    };
+    }
 
-    Sankey.prototype.firstFocusableNode = function firstFocusableNode () {
+    firstFocusableNode() {
         return this.columns[0][0];
-    };
-
-    Sankey.prototype._initResizeObserver = function _initResizeObserver () {
-        var this$1 = this;
-
-        var observer = new ResizeObserver(function (entries) {
-            entries.forEach(function (entry) {
-                var ref = entry.contentRect;
-                var width = ref.width;
-                var height = ref.height;
-                if (entry.target !== this$1.element ||
-                    (this$1.size && this$1.size.width === width && this$1.size.height === height)) {
+    }
+
+    _initResizeObserver() {
+        const observer = new ResizeObserver((entries) => {
+            entries.forEach(entry => {
+                const { width, height } = entry.contentRect;
+                if (entry.target !== this.element ||
+                    (this.size && this.size.width === width && this.size.height === height)) {
                     return;
                 }
-                this$1.size = { width: width, height: height };
-                this$1.surface.setSize(this$1.size);
-                this$1.resize = true;
-                this$1._redraw();
+                this.size = { width, height };
+                this.surface.setSize(this.size);
+                this.resize = true;
+                this._redraw();
             });
         });
         this._resizeObserver = observer;
         observer.observe(this.element);
-    };
+    }
 
-    Sankey.prototype._createSurface = function _createSurface () {
+    _createSurface() {
         return drawing.Surface.create(this.surfaceElement, {
             mouseenter: this._mouseenter.bind(this),
             mouseleave: this._mouseleave.bind(this),
             mousemove: this._mousemove.bind(this),
             click: this._click.bind(this)
         });
-    };
+    }
 
-    Sankey.prototype._initTheme = function _initTheme (theme) {
-        var currentTheme = theme || this.theme || {};
+    _initTheme(theme) {
+        let currentTheme = theme || this.theme || {};
         this.theme = currentTheme;
         this.options = deepExtend({}, currentTheme, this.options);
-    };
-
-    Sankey.prototype.setLinksOpacity = function setLinksOpacity (opacity) {
-        var this$1 = this;
+    }
 
-        this.linksVisuals.forEach(function (link) {
-            this$1.setOpacity(link, opacity, link.linkOptions.opacity);
+    setLinksOpacity(opacity) {
+        this.linksVisuals.forEach(link => {
+            this.setOpacity(link, opacity, link.linkOptions.opacity);
         });
-    };
-
-    Sankey.prototype.setLinksInactivityOpacity = function setLinksInactivityOpacity (inactiveOpacity) {
-        var this$1 = this;
+    }
 
-        this.linksVisuals.forEach(function (link) {
-            this$1.setOpacity(link, inactiveOpacity, link.linkOptions.highlight.inactiveOpacity);
+    setLinksInactivityOpacity(inactiveOpacity) {
+        this.linksVisuals.forEach(link => {
+            this.setOpacity(link, inactiveOpacity, link.linkOptions.highlight.inactiveOpacity);
         });
-    };
+    }
 
-    Sankey.prototype.setOpacity = function setOpacity (link, opacity, linkValue) {
+    setOpacity(link, opacity, linkValue) {
         link.options.set('stroke', Object.assign({}, link.options.stroke,
             {opacity: defined(linkValue) ? linkValue : opacity}));
-    };
+    }
 
-    Sankey.prototype.trigger = function trigger (name, ev) {
-        var dataItem = ev.element.dataItem;
-        var targetType = ev.element.type;
+    trigger(name, ev) {
+        let dataItem = ev.element.dataItem;
+        const targetType = ev.element.type;
 
-        var event = Object.assign({}, ev,
+        const event = Object.assign({}, ev,
             {type: name,
-            targetType: targetType,
+            targetType,
             dataItem: dataItem});
 
-        return Observable.prototype.trigger.call(this, name, event);
-    };
+        return super.trigger(name, event);
+    }
 
-    Sankey.prototype._mouseenter = function _mouseenter (ev) {
-        var element = ev.element;
-        var isLink = element.type === LINK;
-        var isNode = element.type === NODE;
-        var isLegendItem = Boolean(element.chartElement && element.chartElement.options.node);
+    _mouseenter(ev) {
+        const element = ev.element;
+        const isLink = element.type === LINK;
+        const isNode = element.type === NODE;
+        const isLegendItem = Boolean(element.chartElement && element.chartElement.options.node);
 
         if ((isLink && this.trigger('linkEnter', ev)) ||
             (isNode && this.trigger('nodeEnter', ev))) {
             return;
         }
 
-        var ref = this.options.links;
-        var highlight = ref.highlight;
+        const { highlight } = this.options.links;
         if (isLink) {
             this.setLinksInactivityOpacity(highlight.inactiveOpacity);
             this.setOpacity(element, highlight.opacity, element.linkOptions.highlight.opacity);
         } else if (isNode) {
             this.highlightLinks(element, highlight);
         } else if (isLegendItem) {
-            var nodeVisual = this.nodesVisuals.get(element.chartElement.options.node.id);
+            const nodeVisual = this.nodesVisuals.get(element.chartElement.options.node.id);
             this.highlightLinks(nodeVisual, highlight);
         }
-    };
-
-    Sankey.prototype._mouseleave = function _mouseleave (ev) {
-        var this$1 = this;
+    }
 
-        var element = ev.element;
-        var isLink = element.type === LINK;
-        var isNode = element.type === NODE;
-        var isLegendItem = Boolean(element.chartElement && element.chartElement.options.node);
-        var target = ev.originalEvent.relatedTarget;
+    _mouseleave(ev) {
+        const element = ev.element;
+        const isLink = element.type === LINK;
+        const isNode = element.type === NODE;
+        const isLegendItem = Boolean(element.chartElement && element.chartElement.options.node);
+        const target = ev.originalEvent.relatedTarget;
 
         if (isLink && target && target.nodeName === 'text') {
             return;
@@ -249,29 +232,25 @@ export var Sankey = (function (Observable) {
         }
 
         if (isLink || isNode || isLegendItem) {
-            this.linksVisuals.forEach(function (link) {
-                this$1.setOpacity(link, this$1.options.links.opacity, link.linkOptions.opacity);
+            this.linksVisuals.forEach(link => {
+                this.setOpacity(link, this.options.links.opacity, link.linkOptions.opacity);
             });
         }
-    };
-
-    Sankey.prototype._mousemove = function _mousemove (ev) {
-        var this$1 = this;
+    }
 
-        var ref = this.options.tooltip;
-        var followPointer = ref.followPointer;
-        var delay = ref.delay;
-        var element = ev.element;
-        var tooltipElType = element.type;
+    _mousemove(ev) {
+        const { followPointer, delay } = this.options.tooltip;
+        const element = ev.element;
+        const tooltipElType = element.type;
 
         if ((tooltipElType !== LINK && tooltipElType !== NODE) || (this.tooltipShown && !followPointer)) {
             return;
         }
 
-        var mouseEvent = ev.originalEvent;
-        var rect = this.element.getBoundingClientRect();
-        var isLeft = mouseEvent.clientX - rect.left < rect.width / 2;
-        var isTop = mouseEvent.clientY - rect.top < rect.height / 2;
+        const mouseEvent = ev.originalEvent;
+        const rect = this.element.getBoundingClientRect();
+        const isLeft = mouseEvent.clientX - rect.left < rect.width / 2;
+        const isTop = mouseEvent.clientY - rect.top < rect.height / 2;
 
         ev.tooltipData = {
             popupOffset: {
@@ -285,11 +264,9 @@ export var Sankey = (function (Observable) {
         };
 
         if (tooltipElType === NODE) {
-            var ref$1 = element.dataItem;
-            var sourceLinks = ref$1.sourceLinks;
-            var targetLinks = ref$1.targetLinks;
-            var links = targetLinks.length ? targetLinks : sourceLinks;
-            ev.nodeValue = links.reduce(function (acc, link) { return acc + link.value; }, 0);
+            const { sourceLinks, targetLinks } = element.dataItem;
+            const links = targetLinks.length ? targetLinks : sourceLinks;
+            ev.nodeValue = links.reduce((acc, link) => acc + link.value, 0);
         }
 
         if (this.tooltipTimeOut) {
@@ -297,24 +274,24 @@ export var Sankey = (function (Observable) {
             this.tooltipTimeOut = null;
         }
 
-        var nextDelay = followPointer && this.tooltipShown ? 0 : delay;
+        const nextDelay = followPointer && this.tooltipShown ? 0 : delay;
 
-        this.tooltipTimeOut = setTimeout(function () {
-            this$1.trigger('tooltipShow', ev);
-            this$1.tooltipShown = true;
-            this$1.tooltipTimeOut = null;
+        this.tooltipTimeOut = setTimeout(() => {
+            this.trigger('tooltipShow', ev);
+            this.tooltipShown = true;
+            this.tooltipTimeOut = null;
         }, nextDelay);
-    };
+    }
 
-    Sankey.prototype._click = function _click (ev) {
-        var element = ev.element;
-        var dataItem = element.dataItem;
-        var isLink = element.type === LINK;
-        var isNode = element.type === NODE;
-        var focusState = this._focusState || {};
+    _click(ev) {
+        const element = ev.element;
+        const dataItem = element.dataItem;
+        const isLink = element.type === LINK;
+        const isNode = element.type === NODE;
+        const focusState = this._focusState || {};
 
         if (isNode) {
-            var focusedNodeClicked = !focusState.link && this.sameNode(focusState.node, dataItem);
+            const focusedNodeClicked = !focusState.link && this.sameNode(focusState.node, dataItem);
 
             if (!focusedNodeClicked) {
                 this._focusState = { node: dataItem, link: null };
@@ -323,12 +300,12 @@ export var Sankey = (function (Observable) {
 
             this.trigger('nodeClick', ev);
         } else if (isLink) {
-            var link = {
+            const link = {
                 sourceId: dataItem.source.id,
                 targetId: dataItem.target.id,
                 value: dataItem.value
             };
-            var focusedLinkClicked = this.sameLink(focusState.link, link);
+            const focusedLinkClicked = this.sameLink(focusState.link, link);
 
             if (!focusedLinkClicked) {
                 this._focusState = { node: dataItem.source, link: link };
@@ -337,109 +314,105 @@ export var Sankey = (function (Observable) {
 
             this.trigger('linkClick', ev);
         }
-    };
+    }
 
-    Sankey.prototype.sameNode = function sameNode (node1, node2) {
+    sameNode(node1, node2) {
         return node1 && node2 && node1.id === node2.id;
-    };
+    }
 
-    Sankey.prototype.sameLink = function sameLink (link1, link2) {
+    sameLink(link1, link2) {
         return link1 && link2 && link1.sourceId === link2.sourceId && link1.targetId === link2.targetId;
-    };
+    }
 
-    Sankey.prototype._focusNode = function _focusNode (options) {
+    _focusNode(options) {
         this._cleanFocusHighlight();
 
-        var nodeData = this._focusState.node;
-        var node = this.models.map.get(nodeData.id);
+        const nodeData = this._focusState.node;
+        const node = this.models.map.get(nodeData.id);
         node.focus(options);
-    };
+    }
 
-    Sankey.prototype._focusLink = function _focusLink (options) {
+    _focusLink(options) {
         this._cleanFocusHighlight();
 
-        var linkData = this._focusState.link;
-        var link = this.models.map.get(((linkData.sourceId) + "-" + (linkData.targetId)));
+        const linkData = this._focusState.link;
+        const link = this.models.map.get(`${linkData.sourceId}-${linkData.targetId}`);
         link.focus(options);
-    };
-
-    Sankey.prototype._focusNextNode = function _focusNextNode (direction) {
-        if ( direction === void 0 ) direction = 1;
+    }
 
-        var current = this._focusState.node;
+    _focusNextNode(direction = 1) {
+        const current = this._focusState.node;
 
-        var columnIndex = this.columns.findIndex(function (column) { return column.find(function (n) { return n.id === current.id; }); });
-        var columnNodes = this.columns[columnIndex];
-        var nodeIndex = columnNodes.findIndex(function (n) { return n.id === current.id; });
+        const columnIndex = this.columns.findIndex(column => column.find(n => n.id === current.id));
+        const columnNodes = this.columns[columnIndex];
+        const nodeIndex = columnNodes.findIndex(n => n.id === current.id);
 
-        var nextNode = columnNodes[nodeIndex + direction];
+        const nextNode = columnNodes[nodeIndex + direction];
         if (nextNode) {
             this._focusState.node = nextNode;
             this._focusNode();
         }
-    };
-
-    Sankey.prototype._focusNextLink = function _focusNextLink (direction) {
-        if ( direction === void 0 ) direction = 1;
+    }
 
-        var node = this._focusState.node;
-        var link = this._focusState.link;
+    _focusNextLink(direction = 1) {
+        const node = this._focusState.node;
+        const link = this._focusState.link;
 
-        var sourceLinkIndex = node.sourceLinks.findIndex(function (l) { return l.sourceId === link.sourceId && l.targetId === link.targetId; });
-        var targetLinkIndex = node.targetLinks.findIndex(function (l) { return l.sourceId === link.sourceId && l.targetId === link.targetId; });
+        const sourceLinkIndex = node.sourceLinks.findIndex(l => l.sourceId === link.sourceId && l.targetId === link.targetId);
+        const targetLinkIndex = node.targetLinks.findIndex(l => l.sourceId === link.sourceId && l.targetId === link.targetId);
 
         if (sourceLinkIndex !== -1) {
-            var nextLink = node.sourceLinks[sourceLinkIndex + direction];
+            const nextLink = node.sourceLinks[sourceLinkIndex + direction];
 
             if (nextLink) {
                 this._focusState.link = nextLink;
                 this._focusLink();
             }
         } else if (targetLinkIndex !== -1) {
-            var nextLink$1 = node.targetLinks[targetLinkIndex + direction];
+            const nextLink = node.targetLinks[targetLinkIndex + direction];
 
-            if (nextLink$1) {
-                this._focusState.link = nextLink$1;
+            if (nextLink) {
+                this._focusState.link = nextLink;
                 this._focusLink();
             }
         }
-    };
+    }
 
-    Sankey.prototype._focusSourceNode = function _focusSourceNode () {
-        var linkData = this._focusState.link;
-        var sourceNode = this.models.map.get(linkData.sourceId);
+    _focusSourceNode() {
+        const linkData = this._focusState.link;
+        const sourceNode = this.models.map.get(linkData.sourceId);
         this._focusState = { node: sourceNode.options.node, link: null };
         this._focusNode();
-    };
+    }
 
-    Sankey.prototype._focusTargetNode = function _focusTargetNode () {
-        var linkData = this._focusState.link;
-        var targetNode = this.models.map.get(linkData.targetId);
+    _focusTargetNode() {
+        const linkData = this._focusState.link;
+        const targetNode = this.models.map.get(linkData.targetId);
         this._focusState = { node: targetNode.options.node, link: null };
         this._focusNode();
-    };
+    }
 
-    Sankey.prototype._focusSourceLink = function _focusSourceLink () {
-        var nodeData = this._focusState.node;
-        var sourceLinks = nodeData.sourceLinks;
-        var linkData = sourceLinks[0];
+    _focusSourceLink() {
+        const nodeData = this._focusState.node;
+        const sourceLinks = nodeData.sourceLinks;
+        const linkData = sourceLinks[0];
         if (linkData) {
             this._focusState.link = linkData;
             this._focusLink();
         }
-    };
+    }
 
-    Sankey.prototype._focusTargetLink = function _focusTargetLink () {
-        var nodeData = this._focusState.node;
-        var targetLinks = nodeData.targetLinks;
-        var linkData = targetLinks[0];
+    _focusTargetLink() {
+        const nodeData = this._focusState.node;
+        const targetLinks = nodeData.targetLinks;
+        const linkData = targetLinks[0];
         if (linkData) {
             this._focusState.link = linkData;
             this._focusLink();
         }
-    };
+    }
 
-    Sankey.prototype._focus = function _focus () {
+    _focus() {
         if (!this._skipFocusHighlight) {
             if (this._focusState.link) {
                 this._focusLink();
@@ -449,30 +422,30 @@ export var Sankey = (function (Observable) {
         }
 
         this._skipFocusHighlight = false;
-    };
+    }
 
-    Sankey.prototype._blur = function _blur () {
+    _blur() {
         this._cleanFocusHighlight();
-    };
+    }
 
-    Sankey.prototype._onDown = function _onDown () {
+    _onDown() {
         if (!this._hasFocus()) {
             this._skipFocusHighlight = true;
         }
-    };
+    }
 
-    Sankey.prototype._hasFocus = function _hasFocus () {
+    _hasFocus() {
         return this.element.ownerDocument.activeElement === this.element;
-    };
+    }
 
-    Sankey.prototype._cleanFocusHighlight = function _cleanFocusHighlight () {
-        this.models.nodes.forEach(function (node) { return node.blur(); });
-        this.models.links.forEach(function (link) { return link.blur(); });
-    };
+    _cleanFocusHighlight() {
+        this.models.nodes.forEach(node => node.blur());
+        this.models.links.forEach(link => link.blur());
+    }
 
-    Sankey.prototype._keydown = function _keydown (ev) {
-        var handler = this['on' + ev.key];
-        var rtl = this.options.rtl;
+    _keydown(ev) {
+        let handler = this['on' + ev.key];
+        const rtl = this.options.rtl;
 
         if (rtl && ev.key === 'ArrowLeft') {
             handler = this.onArrowRight;
@@ -483,16 +456,16 @@ export var Sankey = (function (Observable) {
         if (handler) {
             handler.call(this, ev);
         }
-    };
+    }
 
-    Sankey.prototype.onEscape = function onEscape (ev) {
+    onEscape(ev) {
         ev.preventDefault();
 
         this._focusState = { node: this.firstFocusableNode(), link: null };
         this._focusNode();
-    };
+    }
 
-    Sankey.prototype.onArrowDown = function onArrowDown (ev) {
+    onArrowDown(ev) {
         ev.preventDefault();
 
         if (this._focusState.link) {
@@ -500,9 +473,9 @@ export var Sankey = (function (Observable) {
         } else {
             this._focusNextNode(1);
         }
-    };
+    }
 
-    Sankey.prototype.onArrowUp = function onArrowUp (ev) {
+    onArrowUp(ev) {
         ev.preventDefault();
 
         if (this._focusState.link) {
@@ -510,9 +483,9 @@ export var Sankey = (function (Observable) {
         } else {
             this._focusNextNode(-1);
         }
-    };
+    }
 
-    Sankey.prototype.onArrowLeft = function onArrowLeft (ev) {
+    onArrowLeft(ev) {
         ev.preventDefault();
 
         if (this._focusState.link) {
@@ -520,9 +493,9 @@ export var Sankey = (function (Observable) {
         } else {
             this._focusTargetLink();
         }
-    };
+    }
 
-    Sankey.prototype.onArrowRight = function onArrowRight (ev) {
+    onArrowRight(ev) {
         ev.preventDefault();
 
         if (this._focusState.link) {
@@ -530,121 +503,109 @@ export var Sankey = (function (Observable) {
         } else {
             this._focusSourceLink();
         }
-    };
-
-    Sankey.prototype.highlightLinks = function highlightLinks (node, highlight) {
-        var this$1 = this;
+    }
 
+    highlightLinks(node, highlight) {
         if (node) {
             this.setLinksInactivityOpacity(highlight.inactiveOpacity);
-            node.links.forEach(function (link) {
-                this$1.setOpacity(link, highlight.opacity, link.linkOptions.highlight.opacity);
+            node.links.forEach(link => {
+                this.setOpacity(link, highlight.opacity, link.linkOptions.highlight.opacity);
             });
         }
-    };
+    }
 
-    Sankey.prototype._destroySurface = function _destroySurface () {
+    _destroySurface() {
         if (this.surface) {
             this.surface.destroy();
             this.surface = null;
             this._destroySurfaceElement();
         }
-    };
+    }
 
-    Sankey.prototype._destroyResizeObserver = function _destroyResizeObserver () {
+    _destroyResizeObserver() {
         if (this._resizeObserver) {
             this._resizeObserver.disconnect();
             this._resizeObserver = null;
         }
-    };
+    }
 
-    Sankey.prototype._initSurfaceElement = function _initSurfaceElement () {
+    _initSurfaceElement() {
         if (!this.surfaceElement) {
             this.surfaceElement = document.createElement('div');
             this.element.appendChild(this.surfaceElement);
         }
-    };
+    }
 
-    Sankey.prototype._destroySurfaceElement = function _destroySurfaceElement () {
+    _destroySurfaceElement() {
         if (this.surfaceElement && this.surfaceElement.parentNode) {
             this.surfaceElement.parentNode.removeChild(this.surfaceElement);
             this.surfaceElement = null;
         }
-    };
+    }
 
-    Sankey.prototype.setOptions = function setOptions (options, theme) {
+    setOptions(options, theme) {
         this._setOptions(options);
         this._initTheme(theme);
         this._initSurface();
         this._redraw();
-    };
+    }
 
-    Sankey.prototype._redraw = function _redraw () {
+    _redraw() {
         this.surface.clear();
 
-        var ref = this._getSize();
-        var width = ref.width;
-        var height = ref.height;
-        this.size = { width: width, height: height };
+        const { width, height } = this._getSize();
+        this.size = { width, height };
         this.surface.setSize(this.size);
 
         this.createVisual();
 
         this.surface.draw(this.visual);
-    };
+    }
 
-    Sankey.prototype._getSize = function _getSize () {
+    _getSize() {
         return this.element.getBoundingClientRect();
-    };
+    }
 
-    Sankey.prototype.createVisual = function createVisual () {
+    createVisual() {
         this.visual = this._render();
-    };
+    }
 
-    Sankey.prototype.titleBox = function titleBox (title, drawingRect) {
+    titleBox(title, drawingRect) {
         if (!title || title.visible === false || !title.text) {
             return null;
         }
 
-        var titleElement = new Title(Object.assign({}, {drawingRect: drawingRect}, title));
-        var titleVisual = titleElement.exportVisual();
+        const titleElement = new Title(Object.assign({}, {drawingRect}, title));
+        const titleVisual = titleElement.exportVisual();
         return titleVisual.chartElement.box;
-    };
+    }
 
-    Sankey.prototype.legendBox = function legendBox (options, nodes, drawingRect) {
+    legendBox(options, nodes, drawingRect) {
         if (!options || options.visible === false) {
             return null;
         }
 
-        var legend = new Legend(Object.assign({}, {nodes: nodes}, options, {drawingRect: drawingRect}));
-        var legendVisual = legend.exportVisual();
+        const legend = new Legend(Object.assign({}, {nodes}, options, {drawingRect}));
+        const legendVisual = legend.exportVisual();
 
         return legendVisual.chartElement.box;
-    };
-
-    Sankey.prototype.calculateSankey = function calculateSankey$1 (calcOptions, sankeyOptions) {
-        var title = sankeyOptions.title;
-        var legend = sankeyOptions.legend;
-        var data = sankeyOptions.data;
-        var nodes = sankeyOptions.nodes;
-        var labels = sankeyOptions.labels;
-        var nodeColors = sankeyOptions.nodeColors;
-        var disableAutoLayout = sankeyOptions.disableAutoLayout;
-        var disableKeyboardNavigation = sankeyOptions.disableKeyboardNavigation;
-        var rtl = sankeyOptions.rtl;
-        var autoLayout = !disableAutoLayout;
-        var focusHighlightWidth = ((nodes.focusHighlight || {}).border || {}).width || 0;
-        var padding = disableKeyboardNavigation ? 0 : focusHighlightWidth / 2;
-
-        var sankeyBox = new Box(0, 0, calcOptions.width, calcOptions.height);
+    }
+
+    calculateSankey(calcOptions, sankeyOptions) {
+        const { title, legend, data, nodes, labels, nodeColors, disableAutoLayout, disableKeyboardNavigation, rtl } = sankeyOptions;
+        const autoLayout = !disableAutoLayout;
+        const focusHighlightWidth = ((nodes.focusHighlight || {}).border || {}).width || 0;
+        const padding = disableKeyboardNavigation ? 0 : focusHighlightWidth / 2;
+
+        const sankeyBox = new Box(0, 0, calcOptions.width, calcOptions.height);
         sankeyBox.unpad(padding);
 
-        var titleBox = this.titleBox(title, sankeyBox);
+        const titleBox = this.titleBox(title, sankeyBox);
 
-        var legendArea = sankeyBox.clone();
+        let legendArea = sankeyBox.clone();
 
         if (titleBox) {
-            var titleHeight = titleBox.height();
+            const titleHeight = titleBox.height();
             if (title.position === TOP) {
                 sankeyBox.unpad({ top: titleHeight });
                 legendArea = new Box(0, titleHeight, calcOptions.width, calcOptions.height);
@@ -654,8 +615,8 @@ export var Sankey = (function (Observable) {
             }
         }
 
-        var legendBox = this.legendBox(legend, data.nodes, legendArea);
-        var legendPosition = (legend && legend.position) || Legend.prototype.options.position;
+        const legendBox = this.legendBox(legend, data.nodes, legendArea);
+        const legendPosition = (legend && legend.position) || Legend.prototype.options.position;
 
         if (legendBox) {
             if (legendPosition === LEFT) {
@@ -675,42 +636,39 @@ export var Sankey = (function (Observable) {
             }
         }
 
-        var ref = calculateSankey(Object.assign({}, calcOptions, {offsetX: 0, offsetY: 0, width: sankeyBox.width(), height: sankeyBox.height()}));
-        var calculatedNodes = ref.nodes;
-        var circularLinks = ref.circularLinks;
+        const { nodes: calculatedNodes, circularLinks } = calculateSankey(Object.assign({}, calcOptions, {offsetX: 0, offsetY: 0, width: sankeyBox.width(), height: sankeyBox.height()}));
         if (circularLinks) {
             console.warn('Circular links detected. Kendo Sankey diagram does not support circular links.');
-            return { sankey: { nodes: [], links: [], columns: [[]], circularLinks: circularLinks }, legendBox: legendBox, titleBox: titleBox };
+            return { sankey: { nodes: [], links: [], columns: [[]], circularLinks }, legendBox, titleBox };
         }
 
-        var box = new Box();
+        const box = new Box();
 
-        var diagramMinX = calculatedNodes.reduce(function (acc, node) { return Math.min(acc, node.x0); }, Infinity);
-        var diagramMaxX = calculatedNodes.reduce(function (acc, node) { return Math.max(acc, node.x1); }, 0);
+        const diagramMinX = calculatedNodes.reduce((acc, node) => Math.min(acc, node.x0), Infinity);
+        const diagramMaxX = calculatedNodes.reduce((acc, node) => Math.max(acc, node.x1), 0);
 
-        calculatedNodes.forEach(function (nodeEl, i) {
+        calculatedNodes.forEach((nodeEl, i) => {
             if (rtl) {
-                var x0 = nodeEl.x0;
-                var x1 = nodeEl.x1;
+                const { x0, x1 } = nodeEl;
                 nodeEl.x0 = diagramMaxX - x1;
                 nodeEl.x1 = diagramMaxX - x0;
             }
-            var nodeOps = resolveNodeOptions(nodeEl, nodes, nodeColors, i);
-            var nodeInstance = new Node(nodeOps);
+            const nodeOps = resolveNodeOptions(nodeEl, nodes, nodeColors, i);
+            const nodeInstance = new Node(nodeOps);
             box.wrap(rectToBox(nodeInstance.exportVisual().rawBBox()));
 
-            var labelInstance = new Label(resolveLabelOptions(nodeEl, labels, rtl, diagramMinX, diagramMaxX));
-            var labelVisual = labelInstance.exportVisual();
+            const labelInstance = new Label(resolveLabelOptions(nodeEl, labels, rtl, diagramMinX, diagramMaxX));
+            const labelVisual = labelInstance.exportVisual();
             if (labelVisual) {
                 box.wrap(rectToBox(labelVisual.rawBBox()));
             }
         });
 
-        var offsetX = sankeyBox.x1;
-        var offsetY = sankeyBox.y1;
+        let offsetX = sankeyBox.x1;
+        let offsetY = sankeyBox.y1;
 
-        var width = sankeyBox.width() + offsetX;
-        var height = sankeyBox.height() + offsetY;
+        let width = sankeyBox.width() + offsetX;
+        let height = sankeyBox.height() + offsetY;
 
         width -= box.x2 > sankeyBox.width() ? box.x2 - sankeyBox.width() : 0;
         height -= box.y2 > sankeyBox.height() ? box.y2 - sankeyBox.height() : 0;
@@ -720,29 +678,29 @@ export var Sankey = (function (Observable) {
 
         if (autoLayout === false) {
             return {
-                sankey: calculateSankey(Object.assign({}, calcOptions, {offsetX: offsetX, offsetY: offsetY, width: width, height: height, autoLayout: false})),
-                legendBox: legendBox,
-                titleBox: titleBox
+                sankey: calculateSankey(Object.assign({}, calcOptions, {offsetX, offsetY, width, height, autoLayout: false})),
+                legendBox,
+                titleBox
             };
         }
 
         if (this.resize && autoLayout && this.permutation) {
             this.resize = false;
             return {
-                sankey: calculateSankey(Object.assign({}, calcOptions, {offsetX: offsetX, offsetY: offsetY, width: width, height: height}, this.permutation)),
-                legendBox: legendBox,
-                titleBox: titleBox
+                sankey: calculateSankey(Object.assign({}, calcOptions, {offsetX, offsetY, width, height}, this.permutation)),
+                legendBox,
+                titleBox
             };
         }
 
-        var startColumn = 1;
-        var loops = 2;
-        var columnsLength = calculateSankey(Object.assign({}, calcOptions, {offsetX: offsetX, offsetY: offsetY, width: width, height: height, autoLayout: false})).columns.length;
-        var results = [];
+        const startColumn = 1;
+        const loops = 2;
+        const columnsLength = calculateSankey(Object.assign({}, calcOptions, {offsetX, offsetY, width, height, autoLayout: false})).columns.length;
+        const results = [];
 
-        var permutation = function (targetColumnIndex, reverse) {
-            var currPerm = calculateSankey(Object.assign({}, calcOptions, {offsetX: offsetX, offsetY: offsetY, width: width, height: height, loops: loops, targetColumnIndex: targetColumnIndex, reverse: reverse}));
-            var crosses = crossesValue(currPerm.links);
+        const permutation = (targetColumnIndex, reverse) => {
+            let currPerm = calculateSankey(Object.assign({}, calcOptions, {offsetX, offsetY, width, height, loops: loops, targetColumnIndex, reverse}));
+            let crosses = crossesValue(currPerm.links);
             results.push({
                 crosses: crosses,
                 reverse: reverse,
@@ -751,66 +709,52 @@ export var Sankey = (function (Observable) {
             return crosses === 0;
         };
 
-        for (var index = startColumn; index <= columnsLength - 1; index++) {
+        for (let index = startColumn; index <= columnsLength - 1; index++) {
             if (permutation(index, false) || permutation(index, true)) {
                 break;
             }
         }
 
-        var minCrosses = Math.min.apply(null, results.map(function (r) { return r.crosses; }));
-        var bestResult = results.find(function (r) { return r.crosses === minCrosses; });
+        const minCrosses = Math.min.apply(null, results.map(r => r.crosses));
+        const bestResult = results.find(r => r.crosses === minCrosses);
         this.permutation = { targetColumnIndex: bestResult.targetColumnIndex, reverse: bestResult.reverse };
-        var result = calculateSankey(Object.assign({}, calcOptions, {offsetX: offsetX, offsetY: offsetY, width: width, height: height}, this.permutation));
+        const result = calculateSankey(Object.assign({}, calcOptions, {offsetX, offsetY, width, height}, this.permutation));
 
         return {
             sankey: result,
-            legendBox: legendBox,
-            titleBox: titleBox
+            legendBox,
+            titleBox
         };
-    };
-
-    Sankey.prototype._render = function _render (options, context) {
-        var sankeyOptions = options || this.options;
-        var sankeyContext = context || this;
-
-        var labelOptions = sankeyOptions.labels;
-        var nodesOptions = sankeyOptions.nodes;
-        var linkOptions = sankeyOptions.links;
-        var nodeColors = sankeyOptions.nodeColors;
-        var title = sankeyOptions.title;
-        var legend = sankeyOptions.legend;
-        var rtl = sankeyOptions.rtl;
-        var disableKeyboardNavigation = sankeyOptions.disableKeyboardNavigation;
-        var data = sankeyOptions.data;
-        var ref = sankeyContext.size;
-        var width = ref.width;
-        var height = ref.height;
-
-        var calcOptions = Object.assign({}, data, {width: width, height: height, nodesOptions: nodesOptions, title: title, legend: legend});
-        var ref$1 = this.calculateSankey(calcOptions, sankeyOptions);
-        var sankey = ref$1.sankey;
-        var titleBox = ref$1.titleBox;
-        var legendBox = ref$1.legendBox;
+    }
+
+    _render(options, context) {
+        const sankeyOptions = options || this.options;
+        const sankeyContext = context || this;
+
+        const { labels: labelOptions, nodes: nodesOptions, links: linkOptions, nodeColors, title, legend, rtl, disableKeyboardNavigation } = sankeyOptions;
+        let data = sankeyOptions.data;
+        const { width, height } = sankeyContext.size;
+
+        const calcOptions = Object.assign({}, data, {width, height, nodesOptions, title, legend});
+        const { sankey, titleBox, legendBox } = this.calculateSankey(calcOptions, sankeyOptions);
         if (rtl) {
             toRtl(sankey);
         }
-        var nodes = sankey.nodes;
-        var links = sankey.links;
-        var columns = sankey.columns;
+        const { nodes, links, columns } = sankey;
 
-        sankeyContext.columns = columns.map(function (column) {
-            var newColumn = column.slice();
-            newColumn.sort(function (a, b) { return a.y0 - b.y0; });
+        sankeyContext.columns = columns.map(column => {
+            const newColumn = column.slice();
+            newColumn.sort((a, b) => a.y0 - b.y0);
             return newColumn;
         });
 
-        var visual = new drawing.Group({
+        const visual = new drawing.Group({
             clip: drawing.Path.fromRect(new geometry.Rect([0, 0], [width, height]))
         });
 
         if (titleBox) {
-            var titleElement = new Title(Object.assign({}, title, {drawingRect: titleBox}));
-            var titleVisual = titleElement.exportVisual();
+            const titleElement = new Title(Object.assign({}, title, {drawingRect: titleBox}));
+            const titleVisual = titleElement.exportVisual();
             visual.append(titleVisual);
         }
 
@@ -818,25 +762,25 @@ export var Sankey = (function (Observable) {
             return visual;
         }
 
-        var visualNodes = new Map();
+        const visualNodes = new Map();
         sankeyContext.nodesVisuals = visualNodes;
 
-        var models = {
+        const models = {
             nodes: [],
             links: [],
             map: new Map()
         };
         sankeyContext.models = models;
 
-        var focusHighlights = [];
+        const focusHighlights = [];
 
-        nodes.forEach(function (node, i) {
-            var nodeOps = resolveNodeOptions(node, nodesOptions, nodeColors, i);
-            nodeOps.root = function () { return sankeyContext.element; };
+        nodes.forEach((node, i) => {
+            const nodeOps = resolveNodeOptions(node, nodesOptions, nodeColors, i);
+            nodeOps.root = () => sankeyContext.element;
             nodeOps.navigatable = disableKeyboardNavigation !== true;
 
-            var nodeInstance = new Node(nodeOps);
-            var nodeVisual = nodeInstance.exportVisual();
+            const nodeInstance = new Node(nodeOps);
+            const nodeVisual = nodeInstance.exportVisual();
             nodeVisual.links = [];
             nodeVisual.type = NODE;
 
@@ -846,8 +790,8 @@ export var Sankey = (function (Observable) {
             nodeVisual.dataItem = Object.assign({}, data.nodes[i],
                 {color: nodeOps.color,
                 opacity: nodeOps.opacity,
-                sourceLinks: node.sourceLinks.map(function (link) { return ({ sourceId: link.sourceId, targetId: link.targetId, value: link.value }); }),
-                targetLinks: node.targetLinks.map(function (link) { return ({ sourceId: link.sourceId, targetId: link.targetId, value: link.value }); })});
+                sourceLinks: node.sourceLinks.map(link => ({ sourceId: link.sourceId, targetId: link.targetId, value: link.value })),
+                targetLinks: node.targetLinks.map(link => ({ sourceId: link.sourceId, targetId: link.targetId, value: link.value }))});
             visualNodes.set(node.id, nodeVisual);
 
             models.nodes.push(nodeInstance);
@@ -862,22 +806,21 @@ export var Sankey = (function (Observable) {
             }
         });
 
-        var sortedLinks = links.slice().sort(function (a, b) { return b.value - a.value; });
+        const sortedLinks = links.slice().sort((a, b) => b.value - a.value);
 
-        var linksVisuals = [];
+        const linksVisuals = [];
         sankeyContext.linksVisuals = linksVisuals;
 
-        sortedLinks.forEach(function (link) {
-            var source = link.source;
-            var target = link.target;
-            var sourceNode = visualNodes.get(source.id);
-            var targetNode = visualNodes.get(target.id);
-            var resolvedOptions = resolveLinkOptions(link, linkOptions, sourceNode, targetNode);
-            resolvedOptions.root = function () { return sankeyContext.element; };
+        sortedLinks.forEach(link => {
+            const { source, target } = link;
+            const sourceNode = visualNodes.get(source.id);
+            const targetNode = visualNodes.get(target.id);
+            const resolvedOptions = resolveLinkOptions(link, linkOptions, sourceNode, targetNode);
+            resolvedOptions.root = () => sankeyContext.element;
             resolvedOptions.navigatable = disableKeyboardNavigation !== true;
             resolvedOptions.rtl = rtl;
-            var linkInstance = new Link(resolvedOptions);
-            var linkVisual = linkInstance.exportVisual();
+            const linkInstance = new Link(resolvedOptions);
+            const linkVisual = linkInstance.exportVisual();
 
             linkVisual.type = LINK;
             linkVisual.dataItem = {
@@ -892,7 +835,7 @@ export var Sankey = (function (Observable) {
             targetNode.links.push(linkVisual);
 
             models.links.push(linkInstance);
-            models.map.set(((source.id) + "-" + (target.id)), linkInstance);
+            models.map.set(`${source.id}-${target.id}`, linkInstance);
 
             linkInstance.createFocusHighlight();
 
@@ -903,13 +846,13 @@ export var Sankey = (function (Observable) {
             visual.append(linkVisual);
         });
 
-        var diagramMinX = nodes.reduce(function (acc, node) { return Math.min(acc, node.x0); }, Infinity);
-        var diagramMaxX = nodes.reduce(function (acc, node) { return Math.max(acc, node.x1); }, 0);
+        const diagramMinX = nodes.reduce((acc, node) => Math.min(acc, node.x0), Infinity);
+        const diagramMaxX = nodes.reduce((acc, node) => Math.max(acc, node.x1), 0);
 
-        nodes.forEach(function (node) {
-            var textOps = resolveLabelOptions(node, labelOptions, rtl, diagramMinX, diagramMaxX);
-            var labelInstance = new Label(textOps);
-            var labelVisual = labelInstance.exportVisual();
+        nodes.forEach((node) => {
+            const textOps = resolveLabelOptions(node, labelOptions, rtl, diagramMinX, diagramMaxX);
+            const labelInstance = new Label(textOps);
+            const labelVisual = labelInstance.exportVisual();
 
             if (labelVisual) {
                 visual.append(labelVisual);
@@ -917,25 +860,25 @@ export var Sankey = (function (Observable) {
         });
 
         if (legendBox) {
-            var legendElement = new Legend(Object.assign({}, legend, {rtl: rtl, drawingRect: legendBox, nodes: nodes}));
-            var legendVisual = legendElement.exportVisual();
+            const legendElement = new Legend(Object.assign({}, legend, {rtl, drawingRect: legendBox, nodes}));
+            const legendVisual = legendElement.exportVisual();
             visual.append(legendVisual);
         }
 
         if (focusHighlights.length !== 0) {
-            var focusHighlight = new drawing.Group();
-            focusHighlight.append.apply(focusHighlight, focusHighlights);
+            const focusHighlight = new drawing.Group();
+            focusHighlight.append(...focusHighlights);
             visual.append(focusHighlight);
         }
 
         return visual;
-    };
+    }
 
-    Sankey.prototype.exportVisual = function exportVisual (exportOptions) {
-        var options = (exportOptions && exportOptions.options) ?
+    exportVisual(exportOptions) {
+        const options = (exportOptions && exportOptions.options) ?
             deepExtend({}, this.options, exportOptions.options) : this.options;
 
-        var context = {
+        const context = {
             size: {
                 width: defined(exportOptions && exportOptions.width) ? exportOptions.width : this.size.width,
                 height: defined(exportOptions && exportOptions.height) ? exportOptions.height : this.size.height
@@ -943,16 +886,14 @@ export var Sankey = (function (Observable) {
         };
 
         return this._render(options, context);
-    };
+    }
 
-    Sankey.prototype._setOptions = function _setOptions (options) {
+    _setOptions(options) {
         this.options = deepExtend({}, this.options, options);
-    };
-
-    return Sankey;
-}(Observable));
+    }
+}
 
-var highlightOptions = {
+const highlightOptions = {
     opacity: 1,
     width: 2,
     color: BLACK
@@ -989,11 +930,7 @@ setDefaultOptions(Sankey, {
             border: Object.assign({}, highlightOptions)
         },
         labels: {
-            ariaTemplate: function (ref) {
-                var node = ref.node;
-
-                return node.label.text;
-}
+            ariaTemplate: ({ node }) => node.label.text
         }
     },
     links: {
@@ -1007,11 +944,7 @@ setDefaultOptions(Sankey, {
             border: Object.assign({}, highlightOptions)
         },
         labels: {
-            ariaTemplate: function (ref) {
-                var link = ref.link;
-
-                return ((link.source.label.text) + " to " + (link.target.label.text));
-}
+            ariaTemplate: ({ link }) => `${link.source.label.text} to ${link.target.label.text}`
         }
     },
     tooltip: {