highcharts 9.3.3 → 10.2.0

package/modules/sankey.src.js

@@ -1,5 +1,5 @@
 /**
- * @license Highcharts JS v9.3.3 (2022-02-01)
+ * @license Highcharts JS v10.2.0 (2022-07-05)
  *
  * Sankey diagram module
  *
@@ -7,7 +7,6 @@
  *
  * License: www.highcharts.com/license
  */
-'use strict';
 (function (factory) {
     if (typeof module === 'object' && module.exports) {
         factory['default'] = factory;
@@ -22,21 +21,35 @@
         factory(typeof Highcharts !== 'undefined' ? Highcharts : undefined);
     }
 }(function (Highcharts) {
+    'use strict';
     var _modules = Highcharts ? Highcharts._modules : {};
     function _registerModule(obj, path, args, fn) {
         if (!obj.hasOwnProperty(path)) {
             obj[path] = fn.apply(null, args);
+
+            if (typeof CustomEvent === 'function') {
+                window.dispatchEvent(
+                    new CustomEvent(
+                        'HighchartsModuleLoaded',
+                        { detail: { path: path, module: obj[path] }
+                    })
+                );
+            }
         }
     }
-    _registerModule(_modules, 'Series/NodesComposition.js', [_modules['Core/Series/Point.js'], _modules['Core/Series/Series.js'], _modules['Core/Utilities.js']], function (Point, Series, U) {
+    _registerModule(_modules, 'Series/NodesComposition.js', [_modules['Core/Series/SeriesRegistry.js'], _modules['Core/Utilities.js']], function (SeriesRegistry, U) {
         /* *
          *
          *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
          *
          * */
+        var _a = SeriesRegistry.series,
+            seriesProto = _a.prototype,
+            pointProto = _a.prototype.pointClass.prototype;
         var defined = U.defined,
             extend = U.extend,
             find = U.find,
+            merge = U.merge,
             pick = U.pick;
         /* *
          *
@@ -61,22 +74,22 @@
              *  Functions
              *
              * */
-            /* eslint-disable valid-jsdoc */
             /**
              * @private
              */
             function compose(PointClass, SeriesClass) {
                 if (composedClasses.indexOf(PointClass) === -1) {
                     composedClasses.push(PointClass);
-                    var pointProto = PointClass.prototype;
-                    pointProto.setNodeState = setNodeState;
-                    pointProto.setState = setNodeState;
+                    var pointProto_1 = PointClass.prototype;
+                    pointProto_1.setNodeState = setNodeState;
+                    pointProto_1.setState = setNodeState;
+                    pointProto_1.update = updateNode;
                 }
                 if (composedClasses.indexOf(SeriesClass) === -1) {
                     composedClasses.push(SeriesClass);
-                    var seriesProto = SeriesClass.prototype;
-                    seriesProto.destroy = destroy;
-                    seriesProto.setData = setData;
+                    var seriesProto_1 = SeriesClass.prototype;
+                    seriesProto_1.destroy = destroy;
+                    seriesProto_1.setData = setData;
                 }
                 return SeriesClass;
             }
@@ -96,37 +109,28 @@
                     options;
                 if (!node) {
                     options = this.options.nodes && findById(this.options.nodes, id);
-                    node = (new PointClass()).init(this, extend({
-                        className: 'highcharts-node',
-                        isNode: true,
-                        id: id,
-                        y: 1 // Pass isNull test
-                    }, options));
-                    node.linksTo = [];
-                    node.linksFrom = [];
-                    node.formatPrefix = 'node';
-                    // for use in formats
-                    node.name = node.name || node.options.id || '';
-                    // Mass is used in networkgraph:
-                    node.mass = pick(
-                    // Node:
-                    node.options.mass, node.options.marker && node.options.marker.radius, 
-                    // Series:
-                    this.options.marker && this.options.marker.radius, 
-                    // Default:
-                    4);
+                    var newNode_1 = (new PointClass()).init(this,
+                        extend({
+                            className: 'highcharts-node',
+                            isNode: true,
+                            id: id,
+                            y: 1 // Pass isNull test
+                        },
+                        options));
+                    newNode_1.linksTo = [];
+                    newNode_1.linksFrom = [];
                     /**
                      * Return the largest sum of either the incoming or outgoing links.
                      * @private
                      */
-                    node.getSum = function () {
+                    newNode_1.getSum = function () {
                         var sumTo = 0,
                             sumFrom = 0;
-                        node.linksTo.forEach(function (link) {
-                            sumTo += link.weight;
+                        newNode_1.linksTo.forEach(function (link) {
+                            sumTo += link.weight || 0;
                         });
-                        node.linksFrom.forEach(function (link) {
-                            sumFrom += link.weight;
+                        newNode_1.linksFrom.forEach(function (link) {
+                            sumFrom += link.weight || 0;
                         });
                         return Math.max(sumTo, sumFrom);
                     };
@@ -134,29 +138,41 @@
                      * Get the offset in weight values of a point/link.
                      * @private
                      */
-                    node.offset = function (point, coll) {
+                    newNode_1.offset = function (point, coll) {
                         var offset = 0;
-                        for (var i = 0; i < node[coll].length; i++) {
-                            if (node[coll][i] === point) {
+                        for (var i = 0; i < newNode_1[coll].length; i++) {
+                            if (newNode_1[coll][i] === point) {
                                 return offset;
                             }
-                            offset += node[coll][i].weight;
+                            offset += newNode_1[coll][i].weight;
                         }
                     };
                     // Return true if the node has a shape, otherwise all links are
                     // outgoing.
-                    node.hasShape = function () {
+                    newNode_1.hasShape = function () {
                         var outgoing = 0;
-                        node.linksTo.forEach(function (link) {
+                        newNode_1.linksTo.forEach(function (link) {
                             if (link.outgoing) {
                                 outgoing++;
                             }
                         });
-                        return (!node.linksTo.length ||
-                            outgoing !== node.linksTo.length);
+                        return (!newNode_1.linksTo.length ||
+                            outgoing !== newNode_1.linksTo.length);
                     };
-                    this.nodes.push(node);
+                    newNode_1.index = this.nodes.push(newNode_1) - 1;
+                    node = newNode_1;
                 }
+                node.formatPrefix = 'node';
+                // for use in formats
+                node.name = node.name || node.options.id || '';
+                // Mass is used in networkgraph:
+                node.mass = pick(
+                // Node:
+                node.options.mass, node.options.marker && node.options.marker.radius, 
+                // Series:
+                this.options.marker && this.options.marker.radius, 
+                // Default:
+                4);
                 return node;
             }
             NodesComposition.createNode = createNode;
@@ -168,17 +184,19 @@
                 // Nodes must also be destroyed (#8682, #9300)
                 this.data = []
                     .concat(this.points || [], this.nodes);
-                return Series.prototype.destroy.apply(this, arguments);
+                return seriesProto.destroy.apply(this, arguments);
             }
             NodesComposition.destroy = destroy;
             /**
-             * Extend generatePoints by adding the nodes, which are Point objects
-             * but pushed to the this.nodes array.
+             * Extend generatePoints by adding the nodes, which are Point objects but
+             * pushed to the this.nodes array.
+             * @private
              */
             function generatePoints() {
+                var _this = this;
                 var chart = this.chart,
                     nodeLookup = {};
-                Series.prototype.generatePoints.call(this);
+                seriesProto.generatePoints.call(this);
                 if (!this.nodes) {
                     this.nodes = []; // List of Point-like node items
                 }
@@ -193,7 +211,7 @@
                 this.points.forEach(function (point) {
                     if (defined(point.from)) {
                         if (!nodeLookup[point.from]) {
-                            nodeLookup[point.from] = this.createNode(point.from);
+                            nodeLookup[point.from] = _this.createNode(point.from);
                         }
                         nodeLookup[point.from].linksFrom.push(point);
                         point.fromNode = nodeLookup[point.from];
@@ -208,7 +226,7 @@
                     }
                     if (defined(point.to)) {
                         if (!nodeLookup[point.to]) {
-                            nodeLookup[point.to] = this.createNode(point.to);
+                            nodeLookup[point.to] = _this.createNode(point.to);
                         }
                         nodeLookup[point.to].linksTo.push(point);
                         point.toNode = nodeLookup[point.to];
@@ -230,11 +248,12 @@
                     });
                     this.nodes.length = 0;
                 }
-                Series.prototype.setData.apply(this, arguments);
+                seriesProto.setData.apply(this, arguments);
             }
             /**
              * When hovering node, highlight all connected links. When hovering a link,
              * highlight all connected nodes.
+             * @private
              */
             function setNodeState(state) {
                 var args = arguments,
@@ -244,21 +263,74 @@
                 if (state !== 'select') {
                     others.forEach(function (linkOrNode) {
                         if (linkOrNode && linkOrNode.series) {
-                            Point.prototype.setState.apply(linkOrNode, args);
+                            pointProto.setState.apply(linkOrNode, args);
                             if (!linkOrNode.isNode) {
                                 if (linkOrNode.fromNode.graphic) {
-                                    Point.prototype.setState.apply(linkOrNode.fromNode, args);
+                                    pointProto.setState.apply(linkOrNode.fromNode, args);
                                 }
                                 if (linkOrNode.toNode && linkOrNode.toNode.graphic) {
-                                    Point.prototype.setState.apply(linkOrNode.toNode, args);
+                                    pointProto.setState.apply(linkOrNode.toNode, args);
                                 }
                             }
                         }
                     });
                 }
-                Point.prototype.setState.apply(this, args);
+                pointProto.setState.apply(this, args);
             }
             NodesComposition.setNodeState = setNodeState;
+            /**
+             * When updating a node, don't update `series.options.data`, but
+             * `series.options.nodes`
+             * @private
+             */
+            function updateNode(options, redraw, animation, runEvent) {
+                var _this = this;
+                var nodes = this.series.options.nodes,
+                    data = this.series.options.data,
+                    dataLength = data && data.length || 0,
+                    linkConfig = data && data[this.index];
+                pointProto.update.call(this, options, this.isNode ? false : redraw, // Hold the redraw for nodes
+                animation, runEvent);
+                if (this.isNode) {
+                    // this.index refers to `series.nodes`, not `options.nodes` array
+                    var nodeIndex = (nodes || [])
+                            .reduce(// Array.findIndex needs a polyfill
+                        function (prevIndex,
+                        n,
+                        index) {
+                            return (_this.id === n.id ? index : prevIndex);
+                    }, -1), 
+                    // Merge old config with new config. New config is stored in
+                    // options.data, because of default logic in point.update()
+                    nodeConfig = merge(nodes && nodes[nodeIndex] || {}, data && data[this.index] || {});
+                    // Restore link config
+                    if (data) {
+                        if (linkConfig) {
+                            data[this.index] = linkConfig;
+                        }
+                        else {
+                            // Remove node from config if there's more nodes than links
+                            data.length = dataLength;
+                        }
+                    }
+                    // Set node config
+                    if (nodes) {
+                        if (nodeIndex >= 0) {
+                            nodes[nodeIndex] = nodeConfig;
+                        }
+                        else {
+                            nodes.push(nodeConfig);
+                        }
+                    }
+                    else {
+                        this.series.options.nodes = [nodeConfig];
+                    }
+                    if (pick(redraw, true)) {
+                        this.series.chart.redraw(animation);
+                    }
+                }
+            }
+            NodesComposition.updateNode = updateNode;
         })(NodesComposition || (NodesComposition = {}));
         /* *
          *
@@ -297,8 +369,7 @@
             };
         })();
         var ColumnSeries = SeriesRegistry.seriesTypes.column;
-        var defined = U.defined,
-            extend = U.extend;
+        var defined = U.defined;
         /* *
          *
          *  Class
@@ -353,6 +424,43 @@
                 return (this.isNode ? 'highcharts-node ' : 'highcharts-link ') +
                     Point.prototype.getClassName.call(this);
             };
+            /**
+             * If there are incoming links, place it to the right of the
+             * highest order column that links to this one.
+             *
+             * @private
+             */
+            SankeyPoint.prototype.getFromNode = function () {
+                var node = this;
+                var fromColumn = -1,
+                    fromNode;
+                for (var i = 0; i < node.linksTo.length; i++) {
+                    var point = node.linksTo[i];
+                    if (point.fromNode.column > fromColumn &&
+                        point.fromNode !== node // #16080
+                    ) {
+                        fromNode = point.fromNode;
+                        fromColumn = fromNode.column;
+                    }
+                }
+                return { fromNode: fromNode, fromColumn: fromColumn };
+            };
+            /**
+             * Calculate node.column if it's not set by user
+             * @private
+             */
+            SankeyPoint.prototype.setNodeColumn = function () {
+                var node = this;
+                if (!defined(node.options.column)) {
+                    // No links to this node, place it left
+                    if (node.linksTo.length === 0) {
+                        node.column = 0;
+                    }
+                    else {
+                        node.column = node.getFromNode().fromColumn + 1;
+                    }
+                }
+            };
             /**
              * @private
              */
@@ -369,6 +477,220 @@
 
         return SankeyPoint;
     });
+    _registerModule(_modules, 'Series/Sankey/SankeyColumnComposition.js', [_modules['Core/Utilities.js']], function (U) {
+        var defined = U.defined,
+            relativeLength = U.relativeLength;
+        var SankeyColumnComposition;
+        (function (SankeyColumnComposition) {
+            /* *
+             *
+             *  Declarations
+             *
+             * */
+            /**
+             * SankeyColumn Composition
+             * @private
+             * @function Highcharts.SankeyColumn#compose
+             *
+             * @param {Array<SankeyPoint>} points
+             * The array of nodes
+             * @param {SankeySeries} series
+             * Series connected to column
+             * @return {ArrayComposition} SankeyColumnArray
+             */
+            function compose(points, series) {
+                var sankeyColumnArray = points;
+                sankeyColumnArray.sankeyColumn =
+                    new SankeyColumnAdditions(sankeyColumnArray, series);
+                return sankeyColumnArray;
+            }
+            SankeyColumnComposition.compose = compose;
+            /* *
+             *
+             *  Classes
+             *
+             * */
+            var SankeyColumnAdditions = /** @class */ (function () {
+                    function SankeyColumnAdditions(points, series) {
+                        this.points = points;
+                    this.series = series;
+                }
+                /**
+                 * Calculate translation factor used in column and nodes distribution
+                 * @private
+                 * @function Highcharts.SankeyColumn#getTranslationFactor
+                 *
+                 * @param {SankeySeries} series
+                 * The Series
+                 * @return {number} TranslationFactor
+                 * Translation Factor
+                 */
+                SankeyColumnAdditions.prototype.getTranslationFactor = function (series) {
+                    var column = this.points,
+                        nodes = column.slice(),
+                        chart = series.chart,
+                        minLinkWidth = series.options.minLinkWidth || 0;
+                    var skipPoint,
+                        factor = 0,
+                        i,
+                        remainingHeight = ((chart.plotSizeY || 0) -
+                            (series.options.borderWidth || 0) -
+                            (column.length - 1) * series.nodePadding);
+                    // Because the minLinkWidth option doesn't obey the direct
+                    // translation, we need to run translation iteratively, check
+                    // node heights, remove those nodes affected by minLinkWidth,
+                    // check again, etc.
+                    while (column.length) {
+                        factor = remainingHeight / column.sankeyColumn.sum();
+                        skipPoint = false;
+                        i = column.length;
+                        while (i--) {
+                            if (column[i].getSum() * factor < minLinkWidth) {
+                                column.splice(i, 1);
+                                remainingHeight -= minLinkWidth;
+                                skipPoint = true;
+                            }
+                        }
+                        if (!skipPoint) {
+                            break;
+                        }
+                    }
+                    // Re-insert original nodes
+                    column.length = 0;
+                    nodes.forEach(function (node) {
+                        column.push(node);
+                    });
+                    return factor;
+                };
+                /**
+                 * Get the top position of the column in pixels
+                 * @private
+                 * @function Highcharts.SankeyColumn#top
+                 *
+                 * @param {number} factor
+                 * The Translation Factor
+                 * @return {number} top
+                 * The top position of the column
+                 */
+                SankeyColumnAdditions.prototype.top = function (factor) {
+                    var series = this.series;
+                    var nodePadding = series.nodePadding;
+                    var height = this.points.reduce(function (height,
+                        node) {
+                            if (height > 0) {
+                                height += nodePadding;
+                        }
+                        var nodeHeight = Math.max(node.getSum() * factor,
+                            series.options.minLinkWidth || 0);
+                        height += nodeHeight;
+                        return height;
+                    }, 0);
+                    return ((series.chart.plotSizeY || 0) - height) / 2;
+                };
+                /**
+                 * Get the left position of the column in pixels
+                 * @private
+                 * @function Highcharts.SankeyColumn#top
+                 *
+                 * @param {number} factor
+                 * The Translation Factor
+                 * @return {number} left
+                 * The left position of the column
+                 */
+                SankeyColumnAdditions.prototype.left = function (factor) {
+                    var series = this.series,
+                        chart = series.chart,
+                        equalNodes = series.options.equalNodes;
+                    var maxNodesLength = chart.inverted ?
+                            chart.plotHeight : chart.plotWidth,
+                        nodePadding = series.nodePadding;
+                    var width = this.points.reduce(function (width,
+                        node) {
+                            if (width > 0) {
+                                width += nodePadding;
+                        }
+                        var nodeWidth = equalNodes ?
+                                maxNodesLength / node.series.nodes.length - nodePadding :
+                                Math.max(node.getSum() * factor,
+                            series.options.minLinkWidth || 0);
+                        width += nodeWidth;
+                        return width;
+                    }, 0);
+                    return ((chart.plotSizeX || 0) - Math.round(width)) / 2;
+                };
+                /**
+                 * Calculate sum of all nodes inside specific column
+                 * @private
+                 * @function Highcharts.SankeyColumn#sum
+                 *
+                 * @param {ArrayComposition} this
+                 * Sankey Column Array
+                 *
+                 * @return {number} sum
+                 * Sum of all nodes inside column
+                 */
+                SankeyColumnAdditions.prototype.sum = function () {
+                    return this.points.reduce(function (sum, node) {
+                        return sum + node.getSum();
+                    }, 0);
+                };
+                /**
+                 * Get the offset in pixels of a node inside the column
+                 * @private
+                 * @function Highcharts.SankeyColumn#offset
+                 *
+                 * @param {SankeyPoint} node
+                 * Sankey node
+                 * @param {number} factor
+                 * Translation Factor
+                 * @return {number} offset
+                 * Offset of a node inside column
+                 */
+                SankeyColumnAdditions.prototype.offset = function (node, factor) {
+                    var column = this.points,
+                        series = this.series,
+                        nodePadding = series.nodePadding;
+                    var offset = 0,
+                        totalNodeOffset;
+                    if (series.is('organization') && node.hangsFrom) {
+                        return {
+                            absoluteTop: node.hangsFrom.nodeY
+                        };
+                    }
+                    for (var i = 0; i < column.length; i++) {
+                        var sum = column[i].getSum();
+                        var height = Math.max(sum * factor,
+                            series.options.minLinkWidth || 0);
+                        var directionOffset = node.options[series.chart.inverted ?
+                                'offsetHorizontal' :
+                                'offsetVertical'],
+                            optionOffset = node.options.offset || 0;
+                        if (sum) {
+                            totalNodeOffset = height + nodePadding;
+                        }
+                        else {
+                            // If node sum equals 0 nodePadding is missed #12453
+                            totalNodeOffset = 0;
+                        }
+                        if (column[i] === node) {
+                            return {
+                                relativeTop: offset + (defined(directionOffset) ?
+                                    // directionOffset is a percent
+                                    // of the node height
+                                    relativeLength(directionOffset, height) :
+                                    relativeLength(optionOffset, totalNodeOffset))
+                            };
+                        }
+                        offset += totalNodeOffset;
+                    }
+                };
+                return SankeyColumnAdditions;
+            }());
+            SankeyColumnComposition.SankeyColumnAdditions = SankeyColumnAdditions;
+        })(SankeyColumnComposition || (SankeyColumnComposition = {}));
+
+        return SankeyColumnComposition;
+    });
     _registerModule(_modules, 'Series/TreeUtilities.js', [_modules['Core/Color/Color.js'], _modules['Core/Utilities.js']], function (Color, U) {
         /* *
          *
@@ -599,7 +921,7 @@
 
         return TreeUtilities;
     });
-    _registerModule(_modules, 'Series/Sankey/SankeySeries.js', [_modules['Core/Color/Color.js'], _modules['Core/Globals.js'], _modules['Series/NodesComposition.js'], _modules['Series/Sankey/SankeyPoint.js'], _modules['Core/Series/SeriesRegistry.js'], _modules['Series/TreeUtilities.js'], _modules['Core/Utilities.js']], function (Color, H, NodesComposition, SankeyPoint, SeriesRegistry, TU, U) {
+    _registerModule(_modules, 'Series/Sankey/SankeySeries.js', [_modules['Core/Color/Color.js'], _modules['Core/Globals.js'], _modules['Series/NodesComposition.js'], _modules['Series/Sankey/SankeyPoint.js'], _modules['Core/Series/SeriesRegistry.js'], _modules['Series/Sankey/SankeyColumnComposition.js'], _modules['Series/TreeUtilities.js'], _modules['Core/Utilities.js']], function (Color, H, NodesComposition, SankeyPoint, SeriesRegistry, SankeyColumnComposition, TU, U) {
         /* *
          *
          *  Sankey diagram module
@@ -632,7 +954,6 @@
         var getLevelOptions = TU.getLevelOptions;
         var defined = U.defined,
             extend = U.extend,
-            find = U.find,
             isObject = U.isObject,
             merge = U.merge,
             pick = U.pick,
@@ -707,66 +1028,6 @@
              *
              * */
             /* eslint-disable valid-jsdoc */
-            /**
-             * Create a node column.
-             * @private
-             */
-            SankeySeries.prototype.createNodeColumn = function () {
-                var series = this,
-                    chart = this.chart,
-                    column = [];
-                column.sum = function () {
-                    return this.reduce(function (sum, node) {
-                        return sum + node.getSum();
-                    }, 0);
-                };
-                // Get the offset in pixels of a node inside the column.
-                column.offset = function (node, factor) {
-                    var offset = 0,
-                        totalNodeOffset,
-                        nodePadding = series.nodePadding;
-                    for (var i = 0; i < column.length; i++) {
-                        var sum = column[i].getSum(),
-                            height = Math.max(sum * factor,
-                            series.options.minLinkWidth),
-                            directionOffset = node.options[chart.inverted ?
-                                'offsetHorizontal' :
-                                'offsetVertical'],
-                            optionOffset = node.options.offset || 0;
-                        if (sum) {
-                            totalNodeOffset = height + nodePadding;
-                        }
-                        else {
-                            // If node sum equals 0 nodePadding is missed #12453
-                            totalNodeOffset = 0;
-                        }
-                        if (column[i] === node) {
-                            return {
-                                relativeTop: offset + (defined(directionOffset) ?
-                                    // directionOffset is a percent of the node height
-                                    relativeLength(directionOffset, height) : relativeLength(optionOffset, totalNodeOffset))
-                            };
-                        }
-                        offset += totalNodeOffset;
-                    }
-                };
-                // Get the top position of the column in pixels.
-                column.top = function (factor) {
-                    var nodePadding = series.nodePadding;
-                    var height = this.reduce(function (height,
-                        node) {
-                            if (height > 0) {
-                                height += nodePadding;
-                        }
-                        var nodeHeight = Math.max(node.getSum() * factor,
-                            series.options.minLinkWidth);
-                        height += nodeHeight;
-                        return height;
-                    }, 0);
-                    return (chart.plotSizeY - height) / 2;
-                };
-                return column;
-            };
             /**
              * Create node columns by analyzing the nodes and the relations between
              * incoming and outgoing links.
@@ -775,51 +1036,18 @@
             SankeySeries.prototype.createNodeColumns = function () {
                 var columns = [];
                 this.nodes.forEach(function (node) {
-                    var fromColumn = -1,
-                        fromNode;
-                    if (!defined(node.options.column)) {
-                        // No links to this node, place it left
-                        if (node.linksTo.length === 0) {
-                            node.column = 0;
-                            // There are incoming links, place it to the right of the
-                            // highest order column that links to this one.
-                        }
-                        else {
-                            for (var i = 0; i < node.linksTo.length; i++) {
-                                var point = node.linksTo[i];
-                                if (point.fromNode.column > fromColumn &&
-                                    point.fromNode !== node // #16080
-                                ) {
-                                    fromNode = point.fromNode;
-                                    fromColumn = fromNode.column;
-                                }
-                            }
-                            node.column = fromColumn + 1;
-                            // Hanging layout for organization chart
-                            if (fromNode &&
-                                fromNode.options.layout === 'hanging') {
-                                node.hangsFrom = fromNode;
-                                var i_1 = -1;
-                                find(fromNode.linksFrom, function (link, index) {
-                                    var found = link.toNode === node;
-                                    if (found) {
-                                        i_1 = index;
-                                    }
-                                    return found;
-                                });
-                                node.column += i_1;
-                            }
-                        }
-                    }
+                    node.setNodeColumn();
                     if (!columns[node.column]) {
-                        columns[node.column] = this.createNodeColumn();
+                        columns[node.column] =
+                            SankeyColumnComposition.compose([], this);
                     }
                     columns[node.column].push(node);
                 }, this);
                 // Fill in empty columns (#8865)
                 for (var i = 0; i < columns.length; i++) {
                     if (typeof columns[i] === 'undefined') {
-                        columns[i] = this.createNodeColumn();
+                        columns[i] =
+                            SankeyColumnComposition.compose([], this);
                     }
                 }
                 return columns;
@@ -899,10 +1127,23 @@
                 if (!point) {
                     return {};
                 }
-                var series = this, level = point.isNode ? point.level : point.fromNode.level, levelOptions = series.mapOptionsToLevel[level || 0] || {}, options = point.options, stateOptions = (levelOptions.states && levelOptions.states[state || '']) || {}, values = [
-                        'colorByPoint', 'borderColor', 'borderWidth', 'linkOpacity'
-                    ].reduce(function (obj, key) {
-                        obj[key] = pick(stateOptions[key], options[key], levelOptions[key], series.options[key]);
+                var series = this,
+                    level = point.isNode ? point.level : point.fromNode.level,
+                    levelOptions = series.mapOptionsToLevel[level || 0] || {},
+                    options = point.options,
+                    stateOptions = (levelOptions.states && levelOptions.states[state || '']) || {},
+                    values = [
+                        'colorByPoint',
+                        'borderColor',
+                        'borderWidth',
+                        'linkOpacity',
+                        'opacity'
+                    ].reduce(function (obj,
+                    key) {
+                        obj[key] = pick(stateOptions[key],
+                    options[key],
+                    levelOptions[key],
+                    series.options[key]);
                     return obj;
                 }, {}), color = pick(stateOptions.color, options.color, values.colorByPoint ? point.color : levelOptions.color);
                 // Node attributes
@@ -910,7 +1151,8 @@
                     return {
                         fill: color,
                         stroke: values.borderColor,
-                        'stroke-width': values.borderWidth
+                        'stroke-width': values.borderWidth,
+                        opacity: values.opacity
                     };
                 }
                 // Link attributes
@@ -934,42 +1176,6 @@
              * @private
              */
             SankeySeries.prototype.translate = function () {
-                var _this = this;
-                // Get the translation factor needed for each column to fill up the
-                // plot height
-                var getColumnTranslationFactor = function (column) {
-                        var nodes = column.slice();
-                    var minLinkWidth = _this.options.minLinkWidth || 0;
-                    var exceedsMinLinkWidth;
-                    var factor = 0;
-                    var i;
-                    var remainingHeight = (chart.plotSizeY -
-                            options.borderWidth -
-                            (column.length - 1) * series.nodePadding);
-                    // Because the minLinkWidth option doesn't obey the direct
-                    // translation, we need to run translation iteratively, check
-                    // node heights, remove those nodes affected by minLinkWidth,
-                    // check again, etc.
-                    while (column.length) {
-                        factor = remainingHeight / column.sum();
-                        exceedsMinLinkWidth = false;
-                        i = column.length;
-                        while (i--) {
-                            if (column[i].getSum() * factor < minLinkWidth) {
-                                column.splice(i, 1);
-                                remainingHeight -= minLinkWidth;
-                                exceedsMinLinkWidth = true;
-                            }
-                        }
-                        if (!exceedsMinLinkWidth) {
-                            break;
-                        }
-                    }
-                    // Re-insert original nodes
-                    column.length = 0;
-                    nodes.forEach(function (node) { return column.push(node); });
-                    return factor;
-                };
                 if (!this.processedXData) {
                     this.processData();
                 }
@@ -984,7 +1190,7 @@
                 this.nodePadding = this.getNodePadding();
                 // Find out how much space is needed. Base it on the translation
                 // factor of the most spaceous column.
-                this.translationFactor = nodeColumns.reduce(function (translationFactor, column) { return Math.min(translationFactor, getColumnTranslationFactor(column)); }, Infinity);
+                this.translationFactor = nodeColumns.reduce(function (translationFactor, column) { return Math.min(translationFactor, column.sankeyColumn.getTranslationFactor(series)); }, Infinity);
                 this.colDistance =
                     (chart.plotSizeX - nodeWidth -
                         options.borderWidth) / Math.max(1, nodeColumns.length - 1);
@@ -1155,8 +1361,10 @@
                     point.dlBox.x,
                     point.dlBox.y + linkHeight / 2
                 ];
-                // Pass test in drawPoints
+                // Pass test in drawPoints. plotX/Y needs to be defined for dataLabels.
+                // #15863
                 point.y = point.plotY = 1;
+                point.x = point.plotX = 1;
                 if (!point.color) {
                     point.color = fromNode.color;
                 }
@@ -1174,9 +1382,9 @@
                     this.options.minLinkWidth),
                     nodeWidth = Math.round(this.nodeWidth),
                     crisp = Math.round(options.borderWidth) % 2 / 2,
-                    nodeOffset = column.offset(node,
+                    nodeOffset = column.sankeyColumn.offset(node,
                     translationFactor),
-                    fromNodeTop = Math.floor(pick(nodeOffset.absoluteTop, (column.top(translationFactor) +
+                    fromNodeTop = Math.floor(pick(nodeOffset.absoluteTop, (column.sankeyColumn.top(translationFactor) +
                         nodeOffset.relativeTop))) + crisp,
                     left = Math.floor(this.colDistance * node.column +
                         options.borderWidth / 2) + relativeLength(node.options.offsetHorizontal || 0,
@@ -1391,6 +1599,12 @@
                  * @private
                  */
                 linkOpacity: 0.5,
+                /**
+                 * Opacity for the nodes in the sankey diagram.
+                 *
+                 * @private
+                 */
+                opacity: 1,
                 /**
                  * The minimal width for a line of a sankey. By default,
                  * 0 values are not shown.
@@ -1431,7 +1645,11 @@
                          * Opacity for the links between nodes in the sankey diagram in
                          * hover mode.
                          */
-                        linkOpacity: 1
+                        linkOpacity: 1,
+                        /**
+                         * Opacity for the nodes in the sankey diagram in hover mode.
+                         */
+                        opacity: 1
                     },
                     /**
                      * The opposite state of a hover for a single point node/link.
@@ -1445,10 +1663,7 @@
                          */
                         linkOpacity: 0.1,
                         /**
-                         * Opacity of inactive markers.
-                         *
-                         * @type      {number}
-                         * @apioption plotOptions.series.states.inactive.opacity
+                         * Opacity of the nodes in the sankey diagram in inactive mode.
                          */
                         opacity: 0.1,
                         /**
@@ -1501,7 +1716,7 @@
             isCartesian: false,
             orderNodes: true,
             noSharedTooltip: true,
-            pointArrayMap: ['from', 'to'],
+            pointArrayMap: ['from', 'to', 'weight'],
             pointClass: SankeyPoint,
             searchPoint: H.noop
         });