@progress/kendo-charts 2.0.0-dev.202401111417 → 2.1.0-dev.202401181402

package/dist/es/{map/scroller → common}/observable.js

@@ -1,6 +1,6 @@
 import {
     Class
-} from '../../common';
+} from '../common';
 
 var STRING = "string";
 var FUNCTION = "function";

package/dist/es/main.js

@@ -7,6 +7,7 @@ export * from './gauges';
 export * from './barcode';
 export * from './qrcode';
 export * from './map';
+export * from './sankey';
 export * from './common';
 
 export { baseTheme as chartBaseTheme } from './chart/base-theme';

package/dist/es/map/attribution.js

@@ -11,7 +11,7 @@ import {
     removeChildren
 } from './utils';
 
-import { Observable } from './scroller/observable';
+import { Observable } from '../common/observable';
 
 export var Attribution = (function (Observable) {
     function Attribution(element, options) {

package/dist/es/map/map.js

@@ -76,7 +76,7 @@ import {
 
 import {
     Observable
-} from './scroller/observable';
+} from '../common/observable';
 
 import MapService from './../services/map-service';
 

package/dist/es/map/navigator.js

@@ -8,7 +8,7 @@ import {
 
 import {
     Observable
-} from './scroller/observable';
+} from '../common/observable';
 
 import {
     proxy,

package/dist/es/map/scroller/draggable.js

@@ -5,7 +5,7 @@ import {
 
 import {
     Observable
-} from './observable';
+} from '../../common/observable';
 
 import {
     getEventMap,

package/dist/es/map/scroller/scroller.js

@@ -39,7 +39,7 @@ import {
 
 import {
     Observable
-} from './observable';
+} from '../../common/observable';
 
 var
     extend = Object.assign,

package/dist/es/map/scroller/user-events.js

@@ -16,7 +16,7 @@ import {
 
 import {
     Observable
-} from './observable';
+} from '../../common/observable';
 
 var extend = Object.assign;
 

package/dist/es/map/zoom.js

@@ -9,7 +9,7 @@ import {
 
 import {
     Observable
-} from './scroller/observable';
+} from '../common/observable';
 
 import {
     on,

package/dist/es/sankey/calculation.js

@@ -0,0 +1,176 @@
+import { deepExtend } from '../common';
+
+var max = function (array, mapFn) { return Math.max.apply(null, array.map(mapFn)); };
+var min = function (array, mapFn) { return Math.min.apply(null, array.map(mapFn)); };
+var sum = function (array, mapFn) { return array.map(mapFn).reduce(function (acc, curr) { return (acc + curr); }, 0); };
+var sortAsc = function (a, b) { return a.y0 - b.y0; };
+var sortSource = function (a, b) { return sortAsc(a.source, b.source); };
+var sortTarget = function (a, b) { return sortAsc(a.target, b.target); };
+var value = function (node) { return node.value; };
+
+function sortLinks(nodes) {
+    nodes.forEach(function (node) {
+        var sourceLinks = node.sourceLinks;
+        var targetLinks = node.targetLinks;
+        sourceLinks.sort(sortTarget);
+        targetLinks.sort(sortSource);
+    });
+}
+
+var Sankey = function Sankey(options) {
+    var offset = options.nodesOptions.offset || {};
+    this.data = {
+        nodes: options.nodes.map(function (node) { return deepExtend({}, { offset: offset }, node); }),
+        links: options.links.map(function (link) { return deepExtend({}, link); })
+    };
+
+    this.width = options.width;
+    this.height = options.height;
+    this.offsetX = options.offsetX || 0;
+    this.offsetY = options.offsetY || 0;
+    this.nodeWidth = options.nodesOptions.width;
+    this.nodePadding = options.nodesOptions.padding;
+};
+
+Sankey.prototype.calculate = function calculate () {
+    var ref = this.data;
+        var nodes = ref.nodes;
+        var links = ref.links;
+    this.connectLinksToNodes(nodes, links);
+    this.calculateNodeValues(nodes);
+    this.calculateNodeDepths(nodes);
+
+    var columns = this.calculateNodeColumns(nodes);
+    this.calculateNodeBreadths(columns);
+    this.applyNodesOffset(nodes);
+    this.calculateLinkBreadths(nodes);
+
+    return this.data;
+};
+
+Sankey.prototype.connectLinksToNodes = function connectLinksToNodes (nodes, links) {
+    var nodesMap = new Map();
+
+    nodes.forEach(function (node) {
+        node.sourceLinks = [];
+        node.targetLinks = [];
+        node.id = node.id !== undefined ? node.id : node.label.text;
+        nodesMap.set(node.id, node);
+    });
+
+    links.forEach(function (link) {
+        link.source = nodesMap.get(link.sourceId);
+        link.target = nodesMap.get(link.targetId);
+        link.source.sourceLinks.push(link);
+        link.target.targetLinks.push(link);
+    });
+};
+
+Sankey.prototype.calculateNodeValues = function calculateNodeValues (nodes) {
+    nodes.forEach(function (node) {
+        node.value = Math.max(
+            sum(node.sourceLinks, value),
+            sum(node.targetLinks, value)
+        );
+    });
+};
+
+Sankey.prototype.calculateNodeDepths = function calculateNodeDepths (nodes) {
+    var current = new Set(nodes);
+    var next = new Set();
+    var currDepth = 0;
+    while (current.size) {
+        var currentNodes = Array.from(current);
+        for (var n = 0; n < currentNodes.length; n++) {
+            var node = currentNodes[n];
+            node.depth = currDepth;
+            for (var l = 0; l < node.sourceLinks.length; l++) {
+                var link = node.sourceLinks[l];
+                next.add(link.target);
+            }
+        }
+        currDepth++;
+        current = next;
+        next = new Set();
+    }
+};
+
+Sankey.prototype.calculateNodeColumns = function calculateNodeColumns (nodes) {
+        var this$1 = this;
+
+    var maxDepth = max(nodes, function (d) { return d.depth; });
+    var columnWidth = (this.width - this.offsetX - this.nodeWidth) / maxDepth;
+    var columns = new Array(maxDepth + 1);
+    for (var i = 0; i < nodes.length; i++) {
+        var node = nodes[i];
+        var depth = Math.max(0, Math.min(maxDepth, node.sourceLinks.length ? node.depth : maxDepth));
+        node.x0 = this$1.offsetX + depth * columnWidth;
+        node.x1 = node.x0 + this$1.nodeWidth;
+        columns[depth] = columns[depth] || [];
+        columns[depth].push(node);
+    }
+
+    return columns;
+};
+
+Sankey.prototype.calculateNodeBreadths = function calculateNodeBreadths (columns) {
+        var this$1 = this;
+
+    var kSize = min(columns, function (c) { return (this$1.height - this$1.offsetY - (c.length - 1) * this$1.nodePadding) / sum(c, value); });
+
+    for (var c = 0; c < columns.length; c++) {
+        var nodes = columns[c];
+        var y = this$1.offsetY;
+        for (var i = 0; i < nodes.length; i++) {
+            var node = nodes[i];
+            node.y0 = y;
+            node.y1 = y + node.value * kSize;
+            y = node.y1 + this$1.nodePadding;
+            for (var l = 0; l < node.sourceLinks.length; l++) {
+                var link = node.sourceLinks[l];
+                link.width = link.value * kSize;
+            }
+        }
+
+        y = (this$1.height - y + this$1.nodePadding) / (nodes.length + 1);
+        for (var i$1 = 0; i$1 < nodes.length; ++i$1) {
+            var node$1 = nodes[i$1];
+            node$1.y0 += y * (i$1 + 1);
+            node$1.y1 += y * (i$1 + 1);
+        }
+    }
+
+    for (var c$1 = 0; c$1 < columns.length; c$1++) {
+        sortLinks(columns[c$1]);
+    }
+};
+
+Sankey.prototype.applyNodesOffset = function applyNodesOffset (nodes) {
+    nodes.forEach(function (node) {
+        var offsetX = (node.offset ? node.offset.left : 0) || 0;
+        var offsetY = (node.offset ? node.offset.top : 0) || 0;
+        node.x0 += offsetX;
+        node.x1 += offsetX;
+        node.y0 += offsetY;
+        node.y1 += offsetY;
+    });
+};
+
+Sankey.prototype.calculateLinkBreadths = function calculateLinkBreadths (nodes) {
+    nodes.forEach(function (node) {
+        var sourceLinks = node.sourceLinks;
+            var targetLinks = node.targetLinks;
+        var y = node.y0;
+        var y1 = y;
+        sourceLinks.forEach(function (link) {
+            link.y0 = y + link.width / 2;
+            y += link.width;
+        });
+        targetLinks.forEach(function (link) {
+            link.y1 = y1 + link.width / 2;
+            y1 += link.width;
+        });
+    });
+};
+
+export var calculateSankey = function (options) { return new Sankey(options).calculate(); };

package/dist/es/sankey/element.js

@@ -0,0 +1,49 @@
+import {
+    Class,
+    deepExtend
+} from '../common';
+
+export var SankeyElement = (function (Class) {
+    function SankeyElement(options) {
+        Class.call(this);
+        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 () {
+        this.visual = this.createElement();
+    };
+
+    SankeyElement.prototype.exportVisual = function exportVisual () {
+        return this.visual;
+    };
+
+    SankeyElement.prototype.createElement = function createElement () {
+        var this$1 = this;
+
+        var customVisual = this.options.visual;
+        var visual;
+
+        if (customVisual) {
+            visual = customVisual({
+                sender: this.getSender(),
+                options: this.visualOptions(),
+                createVisual: function () { return this$1.getElement(); }
+            });
+        } else {
+            visual = this.getElement();
+        }
+
+        return visual;
+    };
+
+    SankeyElement.prototype.getSender = function getSender () {
+        return this;
+    };
+
+    return SankeyElement;
+}(Class));

package/dist/es/sankey/label.js

@@ -0,0 +1,83 @@
+import { setDefaultOptions, deepExtend } from '../common';
+import { SankeyElement } from './element';
+import { Box, TextBox } from '../core';
+var INSIDE = 'inside';
+var BEFORE = 'before';
+var 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 totalWidth = options.totalWidth;
+        var position = options.position;
+        var text = options.text;
+        var offset = options.offset;
+
+        if (!options.visible || !text) {
+            return null;
+        }
+
+        var nodeBox = new Box(node.x0, node.y0, node.x1, node.y1);
+        var visualOptions = this.visualOptions();
+        var textbox = new TextBox(text, visualOptions);
+        textbox.reflow(new Box());
+        var textSizeBox = textbox.box;
+
+        var goesOutside = node.x1 + textSizeBox.width() > totalWidth;
+        var textY = nodeBox.center().y - (textSizeBox.height() / 2);
+        var side = position === BEFORE || (position === INSIDE && goesOutside) ? BEFORE : AFTER;
+        var 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());
+        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);
+        return {
+            color: options.color,
+            opacity: options.opacity,
+            font: options.font,
+            border: options.border,
+            margin: options.margin,
+            padding: options.padding,
+            align: options.align,
+        };
+    };
+
+    return Label;
+}(SankeyElement));
+
+setDefaultOptions(Label, {
+    position: INSIDE, // inside, before, after
+});
+
+export var resolveLabelOptions = function (node, options, totalWidth) { return deepExtend({},
+    options,
+    {
+        node: node,
+        totalWidth: totalWidth,
+        visual: node.label.visual,
+        visible: node.label.visible,
+        margin: node.label.margin,
+        padding: node.label.padding,
+        border: node.label.border,
+        align: node.label.align,
+        opacity: node.label.opacity,
+        offset: node.label.offset
+    }
+); };

package/dist/es/sankey/link.js

@@ -0,0 +1,62 @@
+import { drawing } from '@progress/kendo-drawing';
+import { SankeyElement } from './element';
+import { deepExtend } from '../common';
+import { defined } from '../drawing-utils';
+
+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 source = link.source;
+        var target = link.target;
+        var y0 = link.y0;
+        var y1 = link.y1;
+        var xC = (source.x0 + target.x1) / 2;
+
+        return new drawing.Path(this.visualOptions())
+            .moveTo(source.x1, y0).curveTo([xC, y0], [xC, y1], [target.x0, y1]);
+    };
+
+    Link.prototype.visualOptions = function visualOptions () {
+        var options = this.options;
+        var link = this.options.link;
+        return {
+            stroke: {
+                width: options.link.width,
+                color: link.color || options.color,
+                opacity: defined(link.opacity) ? link.opacity : options.opacity
+            }
+        };
+    };
+
+    return Link;
+}(SankeyElement));
+
+export var resolveLinkOptions = function (link, options, sourceNode, targetNode) {
+    var linkOptions = deepExtend({},
+        options,
+        {
+            link: link,
+            opacity: link.opacity,
+            color: link.color,
+            colorType: link.colorType,
+            visual: link.visual,
+            highlight: link.highlight
+        }
+    );
+
+    if (linkOptions.colorType === 'source') {
+        linkOptions.color = sourceNode.options.fill.color;
+    } else if (linkOptions.colorType === 'target') {
+        linkOptions.color = targetNode.options.fill.color;
+    }
+
+    return linkOptions;
+};

package/dist/es/sankey/node.js

@@ -0,0 +1,50 @@
+import { geometry, drawing } from '@progress/kendo-drawing';
+import { SankeyElement } from './element';
+import { deepExtend } from '../common';
+
+export var Node = (function (SankeyElement) {
+    function Node () {
+        SankeyElement.apply(this, arguments);
+    }
+
+    if ( SankeyElement ) Node.__proto__ = SankeyElement;
+    Node.prototype = Object.create( SankeyElement && SankeyElement.prototype );
+    Node.prototype.constructor = Node;
+
+    Node.prototype.getElement = function getElement () {
+        var options = this.options;
+        var node = options.node;
+        var rect = new geometry.Rect([node.x0, node.y0], [node.x1 - node.x0, node.y1 - node.y0]);
+
+        return drawing.Path.fromRect(rect, this.visualOptions());
+    };
+
+    Node.prototype.visualOptions = function visualOptions () {
+        var options = deepExtend({}, this.options, this.options.node);
+
+        return {
+            fill: {
+                color: options.color,
+                opacity: options.opacity
+            },
+            stroke: { width: 0 },
+        };
+    };
+
+    return Node;
+}(SankeyElement));
+
+export var resolveNodeOptions = function (node, options, nodesColors, index) {
+    var nodeOptions = deepExtend({}, options, options.node);
+    return deepExtend({},
+        { color: nodesColors[index % nodesColors.length] },
+        nodeOptions,
+        { node: node },
+        {
+            visual: node.visual,
+            opacity: node.opacity,
+            offset: node.offset,
+            color: node.color
+        }
+    );
+};