highcharts-rails 5.0.14 → 6.0.0

data/app/assets/javascripts/highcharts/modules/pareto.js

@@ -0,0 +1,275 @@
+/**
+ * @license  Highcharts JS v6.0.0 (2017-10-04)
+ *
+ * Pareto series type for Highcharts
+ *
+ * (c) 2010-2017 Sebastian Bochan
+ *
+ * License: www.highcharts.com/license
+ */
+'use strict';
+(function(factory) {
+    if (typeof module === 'object' && module.exports) {
+        module.exports = factory;
+    } else {
+        factory(Highcharts);
+    }
+}(function(Highcharts) {
+    var derivedSeriesMixin = (function(H) {
+
+        var each = H.each,
+            Series = H.Series,
+            addEvent = H.addEvent,
+            fireEvent = H.fireEvent,
+            wrap = H.wrap,
+            noop = H.noop;
+
+
+        /* ***************************************************************************
+         *
+         * DERIVED SERIES MIXIN
+         *
+         **************************************************************************** */
+
+        /**
+         * Provides methods for auto setting/updating series data based on the based series data,
+         * 
+         * @mixin
+         **/
+        var derivedSeriesMixin = {
+            /**
+             * Initialise series
+             *
+             * returns {undefined}
+             **/
+            init: function() {
+                Series.prototype.init.apply(this, arguments);
+
+                this.initialised = false;
+                this.baseSeries = null;
+                this.eventRemovers = [];
+
+                this.addEvents();
+            },
+
+            /**
+             * Method to be implemented - inside the method the series has already access to the base series
+             * via m `this.baseSeries` and the bases data is initialised. It should
+             * return data in the format accepted by Series.setData() method
+             *
+             * @returns {Array} - an array of data
+             **/
+            setDerivedData: noop,
+
+            /**
+             * Sets base series for the series
+             *
+             * returns {undefined} 
+             **/
+            setBaseSeries: function() {
+                var chart = this.chart,
+                    baseSeriesOptions = this.options.baseSeries,
+                    baseSeries =
+                    baseSeriesOptions &&
+                    (chart.series[baseSeriesOptions] || chart.get(baseSeriesOptions));
+
+                this.baseSeries = baseSeries || null;
+            },
+
+            /**
+             * Adds events for the series
+             *
+             * @returns {undefined}
+             **/
+            addEvents: function() {
+                var derivedSeries = this,
+                    chartSeriesLinked;
+
+                chartSeriesLinked = addEvent(this.chart, 'seriesLinked', function() {
+                    derivedSeries.setBaseSeries();
+
+                    if (derivedSeries.baseSeries && !derivedSeries.initialised) {
+                        derivedSeries.setDerivedData();
+                        derivedSeries.addBaseSeriesEvents();
+                        derivedSeries.initialised = true;
+                    }
+                });
+
+                this.eventRemovers.push(
+                    chartSeriesLinked
+                );
+            },
+
+            /**
+             * Adds events to the base series - it required for recalculating the data in
+             * the series if the base series is updated / removed / etc.
+             *
+             * @returns {undefined}
+             **/
+            addBaseSeriesEvents: function() {
+                var derivedSeries = this,
+                    updatedDataRemover,
+                    destroyRemover;
+
+                updatedDataRemover = addEvent(derivedSeries.baseSeries, 'updatedData', function() {
+                    derivedSeries.setDerivedData();
+                });
+
+                destroyRemover = addEvent(derivedSeries.baseSeries, 'destroy', function() {
+                    derivedSeries.baseSeries = null;
+                    derivedSeries.initialised = false;
+                });
+
+                derivedSeries.eventRemovers.push(
+                    updatedDataRemover,
+                    destroyRemover
+                );
+            },
+
+            /**
+             * Destroys the series
+             *
+             * @returns {undefined}
+             **/
+            destroy: function() {
+                each(this.eventRemovers, function(remover) {
+                    remover();
+                });
+
+                Series.prototype.destroy.apply(this, arguments);
+            }
+        };
+
+        /**
+         * Adds a new chart event after the series are linked
+         **/
+        wrap(H.Chart.prototype, 'linkSeries', function(p) {
+            p.call(this);
+
+            fireEvent(this, 'seriesLinked');
+        });
+        return derivedSeriesMixin;
+    }(Highcharts));
+    (function(H, derivedSeriesMixin) {
+        /**
+         * (c) 2010-2017 Sebastian Bochan
+         *
+         * License: www.highcharts.com/license
+         */
+
+
+        var each = H.each,
+            correctFloat = H.correctFloat,
+            seriesType = H.seriesType,
+            merge = H.merge;
+
+
+        /**
+         * The pareto series type.
+         *
+         * @constructor seriesTypes.pareto
+         * @augments seriesTypes.line
+         */
+
+        /**
+         * A pareto diagram is a type of chart that contains both bars and a line graph, 
+         * where individual values are represented in descending order by bars, 
+         * and the cumulative total is represented by the line.
+         * 
+         * @extends {plotOptions.line}
+         * @product highcharts
+         * @sample {highcharts} highcharts/demo/pareto/
+         *         Pareto diagram
+         * @since 6.0.0
+         * @excluding allAreas,boostThreshold,borderColor,borderRadius,
+         *         borderWidth,crisp,colorAxis,depth,data,edgeColor,edgeWidth,
+         *         findNearestPointBy,gapSize,gapUnit,grouping,groupPadding,groupZPadding,maxPointWidth,
+         *         keys,negativeColor,pointInterval,pointIntervalUnit,pointPadding,
+         *         pointPlacement,pointRange,pointStart,pointWidth,shadow,step,softThreshold,
+         *         stacking,threshold,zoneAxis,zones
+         * @optionparent plotOptions.pareto
+         */
+
+        seriesType('pareto', 'line', {
+            /**
+             * Higher zIndex than column series to draw line above shapes.
+             */
+            zIndex: 3
+        }, merge(derivedSeriesMixin, {
+            /**
+             * calculate sum and return percent points
+             * 
+             * @param  {Object} series
+             * @return {Array} Returns array of points [x,y]
+             */
+            setDerivedData: function() {
+                if (this.baseSeries.yData.length > 1) {
+                    var xValues = this.baseSeries.xData,
+                        yValues = this.baseSeries.yData,
+                        sum = this.sumPointsPercents(yValues, xValues, null, true);
+
+                    this.setData(this.sumPointsPercents(yValues, xValues, sum, false), false);
+                }
+            },
+            /**
+             * calculate y sum and each percent point
+             *
+             * @param  {Array} yValues y values
+             * @param  {Array} xValues x values
+             * @param  {Number} sum of all y values 
+             * @param  {Boolean} isSum declares if calculate sum of all points
+             * @return {Array} Returns sum of points or array of points [x,y]
+             */
+            sumPointsPercents: function(yValues, xValues, sum, isSum) {
+                var sumY = 0,
+                    sumPercent = 0,
+                    percentPoints = [],
+                    percentPoint;
+
+                each(yValues, function(point, i) {
+                    if (point !== null) {
+                        if (isSum) {
+                            sumY += point;
+                        } else {
+                            percentPoint = (point / sum) * 100;
+                            percentPoints.push([xValues[i], correctFloat(sumPercent + percentPoint)]);
+                            sumPercent += percentPoint;
+                        }
+                    }
+                });
+
+                return isSum ? sumY : percentPoints;
+            }
+        }));
+
+        /**
+         * A `pareto` series. If the [type](#series.pareto.type) option is not
+         * specified, it is inherited from [chart.type](#chart.type).
+         * 
+         * For options that apply to multiple series, it is recommended to add
+         * them to the [plotOptions.series](#plotOptions.series) options structure.
+         * To apply to all series of this specific type, apply it to [plotOptions.
+         * pareto](#plotOptions.pareto).
+         * 
+         * @type {Object}
+         * @since 6.0.0
+         * @extends series,plotOptions.pareto
+         * @excluding data,dataParser,dataURL
+         * @product highcharts
+         * @apioption series.pareto
+         */
+
+
+        /**
+         * An array of data points for the series. For the `pareto` series type,
+         * points are calculated dynamically.
+         * 
+         * @type {Array<Object|Array>}
+         * @since 6.0.0
+         * @extends series.column.data
+         * @product highcharts
+         * @apioption series.pareto.data
+         */
+
+    }(Highcharts, derivedSeriesMixin));
+}));

data/app/assets/javascripts/highcharts/modules/sankey.js

@@ -0,0 +1,641 @@
+/**
+ * @license  Highcharts JS v6.0.0 (2017-10-04)
+ * Sankey diagram module
+ *
+ * (c) 2010-2017 Torstein Honsi
+ *
+ * License: www.highcharts.com/license
+ */
+'use strict';
+(function(factory) {
+    if (typeof module === 'object' && module.exports) {
+        module.exports = factory;
+    } else {
+        factory(Highcharts);
+    }
+}(function(Highcharts) {
+    (function(H) {
+        /**
+         * Solid angular gauge module
+         *
+         * (c) 2010-2017 Torstein Honsi
+         *
+         * License: www.highcharts.com/license
+         */
+
+
+        var defined = H.defined,
+            each = H.each,
+            extend = H.extend,
+            seriesType = H.seriesType,
+            pick = H.pick,
+            Point = H.Point;
+
+        /**
+         * A sankey diagram is a type of flow diagram, in which the width of the 
+         * link between two nodes is shown proportionally to the flow quantity.
+         * 
+         * @extends {plotOptions.column}
+         * @product highcharts
+         * @sample highcharts/demo/sankey-diagram/
+         *         Sankey diagram
+         * @sample highcharts/plotoptions/sankey-inverted/
+         *         Inverted sankey diagram
+         * @sample highcharts/plotoptions/sankey-outgoing
+         *         Sankey diagram with outgoing links
+         * @since 6.0.0
+         * @excluding animationLimit,boostThreshold,borderColor,borderRadius,
+         *         borderWidth,crisp,cropThreshold,depth,edgeColor,edgeWidth,
+         *         findNearestPointBy,grouping,groupPadding,groupZPadding,maxPointWidth,
+         *         negativeColor,pointInterval,pointIntervalUnit,pointPadding,
+         *         pointPlacement,pointRange,pointStart,pointWidth,shadow,softThreshold,
+         *         stacking,threshold,zoneAxis,zones
+         * @optionparent plotOptions.sankey
+         */
+        seriesType('sankey', 'column', {
+            colorByPoint: true,
+            /**
+             * Higher numbers makes the links in a sankey diagram render more curved.
+             * A `curveFactor` of 0 makes the lines straight.
+             */
+            curveFactor: 0.33,
+            /**
+             * Options for the data labels appearing on top of the nodes and links. For
+             * sankey charts, data labels are visible for the nodes by default, but 
+             * hidden for links. This is controlled by modifying the `nodeFormat`, and
+             * the `format` that applies to links and is an empty string by default.
+             */
+            dataLabels: {
+                enabled: true,
+                backgroundColor: 'none', // enable padding
+                crop: false,
+                /**
+                 * The [format string](http://www.highcharts.com/docs/chart-concepts/labels-
+                 * and-string-formatting) specifying what to show for _nodes_ in the 
+                 * sankey diagram.
+                 */
+                nodeFormat: '{point.name}',
+                /**
+                 * The [format string](http://www.highcharts.com/docs/chart-concepts/labels-
+                 * and-string-formatting) specifying what to show for _links_ in the 
+                 * sankey diagram. Defaults to an empty string, in effect disabling the
+                 * labels.
+                 * @default ""
+                 */
+                format: '',
+                inside: true
+            },
+
+            /**
+             * Opacity for the links between nodes in the sankey diagram.
+             */
+            linkOpacity: 0.5,
+
+            /**
+             * The pixel width of each node in a sankey diagram, or the height in case
+             * the chart is inverted.
+             */
+            nodeWidth: 20,
+            /**
+             * The padding between nodes in a sankey diagram, in pixels.
+             */
+            nodePadding: 10,
+            showInLegend: false,
+            states: {
+                hover: {
+                    /**
+                     * Opacity for the links between nodes in the sankey diagram in
+                     * hover mode.
+                     */
+                    linkOpacity: 1
+                }
+            },
+            tooltip: {
+                followPointer: true,
+
+
+                headerFormat: '<span style="font-size: 0.85em">{series.name}</span><br/>',
+
+                pointFormat: '{point.fromNode.name} \u2192 {point.toNode.name}: <b>{point.weight}</b><br/>',
+                /**
+                 * The [format string](http://www.highcharts.com/docs/chart-concepts/labels-
+                 * and-string-formatting) specifying what to show for _nodes_ in tooltip
+                 * of a sankey diagram series.
+                 */
+                nodeFormat: '{point.name}: <b>{point.sum}</b><br/>'
+            }
+
+        }, {
+            isCartesian: false,
+            forceDL: true,
+            /**
+             * Create a single node that holds information on incoming and outgoing
+             * links.
+             */
+            createNode: function(id) {
+
+                function findById(nodes, id) {
+                    return H.find(nodes, function(node) {
+                        return node.id === id;
+                    });
+                }
+
+                var node = findById(this.nodes, id),
+                    options;
+
+                if (!node) {
+                    options = this.options.nodes && findById(this.options.nodes, id);
+                    node = (new Point()).init(
+                        this,
+                        extend({
+                            className: 'highcharts-node',
+                            isNode: true,
+                            id: id,
+                            y: 1 // Pass isNull test
+                        }, options)
+                    );
+                    node.linksTo = [];
+                    node.linksFrom = [];
+                    node.formatPrefix = 'node';
+                    node.name = node.name || node.id; // for use in formats
+
+                    /**
+                     * Return the largest sum of either the incoming or outgoing links.
+                     */
+                    node.getSum = function() {
+                        var sumTo = 0,
+                            sumFrom = 0;
+                        each(node.linksTo, function(link) {
+                            sumTo += link.weight;
+                        });
+                        each(node.linksFrom, function(link) {
+                            sumFrom += link.weight;
+                        });
+                        return Math.max(sumTo, sumFrom);
+                    };
+                    /**
+                     * Get the offset in weight values of a point/link.
+                     */
+                    node.offset = function(point, coll) {
+                        var offset = 0;
+                        for (var i = 0; i < node[coll].length; i++) {
+                            if (node[coll][i] === point) {
+                                return offset;
+                            }
+                            offset += node[coll][i].weight;
+                        }
+                    };
+
+                    /** 
+                     * Return true if the node has a shape, otherwise all links are
+                     * outgoing.
+                     */
+                    node.hasShape = function() {
+                        var outgoing = 0;
+                        each(node.linksTo, function(link) {
+                            if (link.outgoing) {
+                                outgoing++;
+                            }
+                        });
+                        return !node.linksTo.length || outgoing !== node.linksTo.length;
+                    };
+
+                    this.nodes.push(node);
+                }
+                return node;
+            },
+
+            /**
+             * Create a node column.
+             */
+            createNodeColumn: function() {
+                var chart = this.chart,
+                    column = [],
+                    nodePadding = this.options.nodePadding;
+
+                column.sum = function() {
+                    var sum = 0;
+                    each(this, function(node) {
+                        sum += node.getSum();
+                    });
+                    return sum;
+                };
+                /**
+                 * Get the offset in pixels of a node inside the column.
+                 */
+                column.offset = function(node, factor) {
+                    var offset = 0;
+                    for (var i = 0; i < column.length; i++) {
+                        if (column[i] === node) {
+                            return offset;
+                        }
+                        offset += column[i].getSum() * factor + nodePadding;
+                    }
+                };
+
+                /**
+                 * Get the column height in pixels.
+                 */
+                column.top = function(factor) {
+                    var height = 0;
+                    for (var i = 0; i < column.length; i++) {
+                        if (i > 0) {
+                            height += nodePadding;
+                        }
+                        height += column[i].getSum() * factor;
+                    }
+                    return (chart.plotSizeY - height) / 2;
+                };
+
+                return column;
+            },
+
+            /**
+             * Create node columns by analyzing the nodes and the relations between
+             * incoming and outgoing links.
+             */
+            createNodeColumns: function() {
+                var columns = [];
+                each(this.nodes, function(node) {
+                    var fromColumn = 0,
+                        i,
+                        point;
+
+                    // 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 (i = 0; i < node.linksTo.length; i++) {
+                            point = node.linksTo[0];
+                            if (point.fromNode.column > fromColumn) {
+                                fromColumn = point.fromNode.column;
+                            }
+                        }
+                        node.column = fromColumn + 1;
+                    }
+
+                    if (!columns[node.column]) {
+                        columns[node.column] = this.createNodeColumn();
+                    }
+
+                    columns[node.column].push(node);
+
+                }, this);
+                return columns;
+            },
+
+
+            /**
+             * Return the presentational attributes.
+             */
+            pointAttribs: function(point, state) {
+
+                var opacity = this.options.linkOpacity;
+
+                if (state) {
+                    opacity = this.options.states[state].linkOpacity || opacity;
+                }
+
+                return {
+                    fill: point.isNode ?
+                        point.color : H.color(point.color).setOpacity(opacity).get()
+                };
+            },
+
+
+            /**
+             * Extend generatePoints by adding the nodes, which are Point objects
+             * but pushed to the this.nodes array.
+             */
+            generatePoints: function() {
+
+                var nodeLookup = {};
+
+                H.Series.prototype.generatePoints.call(this);
+
+                if (!this.nodes) {
+                    this.nodes = []; // List of Point-like node items
+                }
+                this.colorCounter = 0;
+
+                // Reset links from previous run
+                each(this.nodes, function(node) {
+                    node.linksFrom.length = 0;
+                    node.linksTo.length = 0;
+                });
+
+                // Create the node list and set up links
+                each(this.points, function(point) {
+                    if (defined(point.from)) {
+                        if (!nodeLookup[point.from]) {
+                            nodeLookup[point.from] = this.createNode(point.from);
+                        }
+                        nodeLookup[point.from].linksFrom.push(point);
+                        point.fromNode = nodeLookup[point.from];
+
+                        // Point color defaults to the fromNode's color
+
+                        point.color =
+                            point.options.color || nodeLookup[point.from].color;
+
+
+                    }
+                    if (defined(point.to)) {
+                        if (!nodeLookup[point.to]) {
+                            nodeLookup[point.to] = this.createNode(point.to);
+                        }
+                        nodeLookup[point.to].linksTo.push(point);
+                        point.toNode = nodeLookup[point.to];
+                    }
+
+                    point.name = point.name || point.id; // for use in formats
+
+                }, this);
+            },
+
+            /**
+             * Run pre-translation by generating the nodeColumns.
+             */
+            translate: function() {
+                if (!this.processedXData) {
+                    this.processData();
+                }
+                this.generatePoints();
+
+                this.nodeColumns = this.createNodeColumns();
+
+                var chart = this.chart,
+                    inverted = chart.inverted,
+                    options = this.options,
+                    left = 0,
+                    nodeWidth = options.nodeWidth,
+                    nodeColumns = this.nodeColumns,
+                    colDistance = (chart.plotSizeX - nodeWidth) /
+                    (nodeColumns.length - 1),
+                    curvy = (
+                        (inverted ? -colDistance : colDistance) *
+                        options.curveFactor
+                    ),
+                    factor = Infinity;
+
+                // Find out how much space is needed. Base it on the translation
+                // factor of the most spaceous column.
+                each(this.nodeColumns, function(column) {
+                    var height = chart.plotSizeY -
+                        (column.length - 1) * options.nodePadding;
+
+                    factor = Math.min(factor, height / column.sum());
+                });
+
+                each(this.nodeColumns, function(column) {
+                    each(column, function(node) {
+                        var sum = node.getSum(),
+                            height = sum * factor,
+                            fromNodeTop = (
+                                column.top(factor) +
+                                column.offset(node, factor)
+                            ),
+                            nodeLeft = inverted ?
+                            chart.plotSizeX - left :
+                            left;
+
+                        node.sum = sum;
+
+                        // Draw the node
+                        node.shapeType = 'rect';
+                        if (!inverted) {
+                            node.shapeArgs = {
+                                x: nodeLeft,
+                                y: fromNodeTop,
+                                width: nodeWidth,
+                                height: height
+                            };
+                        } else {
+                            node.shapeArgs = {
+                                x: nodeLeft - nodeWidth,
+                                y: chart.plotSizeY - fromNodeTop - height,
+                                width: nodeWidth,
+                                height: height
+                            };
+                        }
+                        node.shapeArgs.display = node.hasShape() ? '' : 'none';
+
+                        // Pass test in drawPoints
+                        node.plotY = 1;
+
+                        // Draw the links from this node
+                        each(node.linksFrom, function(point) {
+                            var linkHeight = point.weight * factor,
+                                fromLinkTop = node.offset(point, 'linksFrom') *
+                                factor,
+                                fromY = fromNodeTop + fromLinkTop,
+                                toNode = point.toNode,
+                                toColTop = nodeColumns[toNode.column].top(factor),
+                                toY = (
+                                    toColTop +
+                                    (toNode.offset(point, 'linksTo') * factor) +
+                                    nodeColumns[toNode.column].offset(
+                                        toNode,
+                                        factor
+                                    )
+                                ),
+                                nodeW = nodeWidth,
+                                right = toNode.column * colDistance,
+                                outgoing = point.outgoing;
+
+                            if (inverted) {
+                                fromY = chart.plotSizeY - fromY;
+                                toY = chart.plotSizeY - toY;
+                                right = chart.plotSizeX - right;
+                                nodeW = -nodeW;
+                                linkHeight = -linkHeight;
+                            }
+
+                            point.shapeType = 'path';
+                            point.shapeArgs = {
+                                d: [
+                                    'M', nodeLeft + nodeW, fromY,
+                                    'C', nodeLeft + nodeW + curvy, fromY,
+                                    right - curvy, toY,
+                                    right, toY,
+                                    'L',
+                                    right + (outgoing ? nodeW : 0),
+                                    toY + linkHeight / 2,
+                                    'L',
+                                    right,
+                                    toY + linkHeight,
+                                    'C', right - curvy, toY + linkHeight,
+                                    nodeLeft + nodeW + curvy, fromY + linkHeight,
+                                    nodeLeft + nodeW, fromY + linkHeight,
+                                    'z'
+                                ]
+                            };
+
+                            // Place data labels in the middle
+                            point.dlBox = {
+                                x: nodeLeft + (right - nodeLeft + nodeW) / 2,
+                                y: fromY + (toY - fromY) / 2,
+                                height: linkHeight,
+                                width: 0
+                            };
+                            // Pass test in drawPoints
+                            point.y = point.plotY = 1;
+
+                            if (!point.color) {
+                                point.color = node.color;
+                            }
+                        });
+                    });
+                    left += colDistance;
+
+                }, this);
+            },
+            /**
+             * Extend the render function to also render this.nodes together with
+             * the points.
+             */
+            render: function() {
+                var points = this.points;
+                this.points = this.points.concat(this.nodes);
+                H.seriesTypes.column.prototype.render.call(this);
+                this.points = points;
+            },
+            animate: H.Series.prototype.animate
+        }, {
+            getClassName: function() {
+                return 'highcharts-link ' + Point.prototype.getClassName.call(this);
+            },
+            isValid: function() {
+                return this.isNode || typeof this.weight === 'number';
+            }
+        });
+
+
+        /**
+         * A `sankey` series. If the [type](#series.sankey.type) option is not
+         * specified, it is inherited from [chart.type](#chart.type).
+         * 
+         * For options that apply to multiple series, it is recommended to add
+         * them to the [plotOptions.series](#plotOptions.series) options structure.
+         * To apply to all series of this specific type, apply it to [plotOptions.
+         * sankey](#plotOptions.sankey).
+         * 
+         * @type {Object}
+         * @extends series,plotOptions.sankey
+         * @excluding dataParser,dataURL
+         * @product highcharts
+         * @apioption series.sankey
+         */
+
+
+        /**
+         * A collection of options for the individual nodes. The nodes in a sankey 
+         * diagram are auto-generated instances of `Highcharts.Point`, but options can
+         * be applied here and linked by the `id`.
+         *
+         * @sample highcharts/css/sankey/ Sankey diagram with node options
+         * @type {Array.<Object>}
+         * @product highcharts
+         * @apioption series.sankey.nodes
+         */
+
+        /**
+         * The id of the auto-generated node, refering to the `from` or `to` setting of
+         * the link.
+         *
+         * @type {String}
+         * @product highcharts
+         * @apioption series.sankey.nodes.id
+         */
+
+        /**
+         * The color of the auto generated node.
+         *
+         * @type {Color}
+         * @product highcharts
+         * @apioption series.sankey.nodes.color
+         */
+
+        /**
+         * The color index of the auto generated node, especially for use in styled
+         * mode.
+         *
+         * @type {Number}
+         * @product highcharts
+         * @apioption series.sankey.nodes.colorIndex
+         */
+
+        /**
+         * An array of data points for the series. For the `sankey` series type,
+         * points can be given in the following way:
+         * 
+         * An array of objects with named values. The objects are point
+         * configuration objects as seen below. If the total number of data
+         * points exceeds the series' [turboThreshold](#series.area.turboThreshold),
+         * this option is not available.
+         * 
+         *  ```js
+         *     data: [{
+         *         from: 'Category1',
+         *         to: 'Category2',
+         *         weight: 2
+         *     }, {
+         *         from: 'Category1',
+         *         to: 'Category3',
+         *         weight: 5
+         *     }]
+         *  ```
+         * 
+         * @type {Array<Object|Array|Number>}
+         * @extends series.line.data
+         * @excluding drilldown,marker,x,y
+         * @sample {highcharts} highcharts/chart/reflow-true/ Numerical values
+         * @sample {highcharts} highcharts/series/data-array-of-arrays/ Arrays of numeric x and y
+         * @sample {highcharts} highcharts/series/data-array-of-arrays-datetime/ Arrays of datetime x and y
+         * @sample {highcharts} highcharts/series/data-array-of-name-value/ Arrays of point.name and y
+         * @sample {highcharts} highcharts/series/data-array-of-objects/ Config objects
+         * @product highcharts
+         * @apioption series.sankey.data
+         */
+
+
+        /**
+         * The node that the link runs from.
+         * 
+         * @type {String}
+         * @product highcharts
+         * @apioption series.sankey.data.from
+         */
+
+        /**
+         * The node that the link runs to.
+         * 
+         * @type {String}
+         * @product highcharts
+         * @apioption series.sankey.data.to
+         */
+
+        /**
+         * Whether the link goes out of the system.
+         * 
+         * @type {Boolean}
+         * @default false
+         * @sample highcharts/plotoptions/sankey-outgoing
+         *         Sankey chart with outgoing links
+         * @product highcharts
+         * @apioption series.sankey.data.outgoing
+         */
+
+        /**
+         * The weight of the link.
+         * 
+         * @type {Number}
+         * @product highcharts
+         * @apioption series.sankey.data.weight
+         */
+
+    }(Highcharts));
+}));