highcharts-rails 5.0.14 → 6.0.0

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

@@ -1,5 +1,5 @@
 /**
- * @license Highcharts JS v5.0.14 (2017-07-28)
+ * @license Highcharts JS v6.0.0 (2017-10-04)
  *
  * (c) 2014 Highsoft AS
  * Authors: Jon Arild Nygard / Oystein Moseng
@@ -14,7 +14,142 @@
         factory(Highcharts);
     }
 }(function(Highcharts) {
-    (function(H) {
+    var result = (function(H) {
+        var each = H.each,
+            extend = H.extend,
+            isBoolean = function(x) {
+                return typeof x === 'boolean';
+            },
+            isFn = function(x) {
+                return typeof x === 'function';
+            },
+            pick = H.pick;
+        // TODO Combine buildTree and buildNode with setTreeValues
+        // TODO Remove logic from Treemap and make it utilize this mixin.
+        var setTreeValues = function setTreeValues(tree, options) {
+            var before = options.before,
+                idRoot = options.idRoot,
+                mapIdToNode = options.mapIdToNode,
+                nodeRoot = mapIdToNode[idRoot],
+                levelIsConstant = (
+                    isBoolean(options.levelIsConstant) ?
+                    options.levelIsConstant :
+                    true
+                ),
+                points = options.points,
+                point = points[tree.i],
+                optionsPoint = point && point.options || {},
+                childrenTotal = 0,
+                children = [],
+                value;
+            extend(tree, {
+                levelDynamic: tree.level - (levelIsConstant ? 0 : nodeRoot.level),
+                name: pick(point && point.name, ''),
+                visible: (
+                    idRoot === tree.id ||
+                    (isBoolean(options.visible) ? options.visible : false)
+                )
+            });
+            if (isFn(before)) {
+                tree = before(tree, options);
+            }
+            // First give the children some values
+            each(tree.children, function(child, i) {
+                var newOptions = extend({}, options);
+                extend(newOptions, {
+                    index: i,
+                    siblings: tree.children.length,
+                    visible: tree.visible
+                });
+                child = setTreeValues(child, newOptions);
+                children.push(child);
+                if (child.visible) {
+                    childrenTotal += child.val;
+                }
+            });
+            tree.visible = childrenTotal > 0 || tree.visible;
+            // Set the values
+            value = pick(optionsPoint.value, childrenTotal);
+            extend(tree, {
+                children: children,
+                childrenTotal: childrenTotal,
+                isLeaf: tree.visible && !childrenTotal,
+                val: value
+            });
+            return tree;
+        };
+
+        var getColor = function getColor(node, options) {
+            var index = options.index,
+                levelMap = options.levelMap,
+                parentColor = options.parentColor,
+                parentColorIndex = options.parentColorIndex,
+                series = options.series,
+                colors = options.colors,
+                siblings = options.siblings,
+                points = series.points,
+                getColorByPoint,
+                point,
+                level,
+                colorByPoint,
+                color,
+                colorIndex;
+
+            function variation(color) {
+                var colorVariation = level && level.colorVariation;
+                if (colorVariation) {
+                    if (colorVariation.key === 'brightness') {
+                        return H.color(color).brighten(
+                            colorVariation.to * (index / siblings)
+                        ).get();
+                    }
+                }
+
+                return color;
+            }
+
+            if (node) {
+                point = points[node.i];
+                level = levelMap[node.levelDynamic] || {};
+                getColorByPoint = (
+                    point &&
+                    (
+                        isBoolean(level.colorByPoint) ?
+                        level.colorByPoint :
+                        !!series.options.colorByPoint
+                    )
+                );
+                if (getColorByPoint) {
+                    colorByPoint = colors[(point.index % colors.length)];
+                }
+                // Select either point color, level color or inherited color.
+                color = pick(
+                    point && point.options.color,
+                    level && level.color,
+                    colorByPoint,
+                    parentColor && variation(parentColor),
+                    series.color
+                );
+                colorIndex = pick(
+                    point && point.options.colorIndex,
+                    level && level.colorIndex,
+                    parentColorIndex,
+                    options.colorIndex
+                );
+            }
+            return {
+                color: color,
+                colorIndex: colorIndex
+            };
+        };
+
+        var result = {
+            getColor: getColor,
+            setTreeValues: setTreeValues
+        };
+        return result;
+    }(Highcharts));
+    (function(H, mixinTreeSeries) {
         /**
          * (c) 2014 Highsoft AS
          * Authors: Jon Arild Nygard / Oystein Moseng
@@ -29,6 +164,7 @@
             extend = H.extend,
             noop = H.noop,
             each = H.each,
+            getColor = mixinTreeSeries.getColor,
             grep = H.grep,
             isNumber = H.isNumber,
             isString = H.isString,
@@ -42,14 +178,7 @@
                     func.call(context, val, key, list);
                 });
             },
-            reduce = function(arr, func, previous, context) {
-                context = context || this;
-                arr = arr || []; // @note should each be able to handle empty values automatically?
-                each(arr, function(current, i) {
-                    previous = func.call(context, previous, current, i, arr);
-                });
-                return previous;
-            },
+            reduce = H.reduce,
             // @todo find correct name for this function. 
             // @todo Similar to reduce, this function is likely redundant
             recursive = function(item, func, context) {
@@ -61,13 +190,72 @@
                 }
             };
 
-        // The Treemap series type
         /**
+         * A treemap displays hierarchical data using nested rectangles. The data can be
+         * laid out in varying ways depending on options.
+         *
+         * @sample highcharts/demo/treemap-large-dataset/ Treemap
+         * 
          * @extends {plotOptions.scatter}
+         * @excluding marker
+         * @product highcharts
          * @optionparent plotOptions.treemap
          */
         seriesType('treemap', 'scatter', {
 
+            /**
+             * When enabled the user can click on a point which is a parent and
+             * zoom in on its children.
+             * 
+             * @type {Boolean}
+             * @sample {highcharts} highcharts/plotoptions/treemap-allowdrilltonode/ Enabled
+             * @default false
+             * @since 4.1.0
+             * @product highcharts
+             * @apioption plotOptions.treemap.allowDrillToNode
+             */
+
+            /**
+             * When the series contains less points than the crop threshold, all
+             * points are drawn, event if the points fall outside the visible plot
+             * area at the current zoom. The advantage of drawing all points (including
+             * markers and columns), is that animation is performed on updates.
+             * On the other hand, when the series contains more points than the
+             * crop threshold, the series data is cropped to only contain points
+             * that fall within the plot area. The advantage of cropping away invisible
+             * points is to increase performance on large series.
+             * 
+             * @type {Number}
+             * @default 300
+             * @since 4.1.0
+             * @product highcharts
+             * @apioption plotOptions.treemap.cropThreshold
+             */
+
+            /**
+             * This option decides if the user can interact with the parent nodes
+             * or just the leaf nodes. When this option is undefined, it will be
+             * true by default. However when allowDrillToNode is true, then it will
+             * be false by default.
+             * 
+             * @type {Boolean}
+             * @sample {highcharts} highcharts/plotoptions/treemap-interactbyleaf-false/ False
+             * @sample {highcharts} highcharts/plotoptions/treemap-interactbyleaf-true-and-allowdrilltonode/ InteractByLeaf and allowDrillToNode is true
+             * @since 4.1.2
+             * @product highcharts
+             * @apioption plotOptions.treemap.interactByLeaf
+             */
+
+            /**
+             * The sort index of the point inside the treemap level.
+             * 
+             * @type {Number}
+             * @sample {highcharts} highcharts/plotoptions/treemap-sortindex/ Sort by years
+             * @since 4.1.10
+             * @product highcharts
+             * @apioption plotOptions.treemap.sortIndex
+             */
+
             /**
              * Whether to display this series type or specific series item in the
              * legend.
@@ -79,6 +267,7 @@
             showInLegend: false,
 
             /**
+             * @ignore
              */
             marker: false,
 
@@ -88,98 +277,18 @@
              * @product highcharts
              */
             dataLabels: {
-
-                /**
-                 * Enable or disable the data labels.
-                 * 
-                 * @type {Boolean}
-                 * @sample {highcharts} highcharts/plotoptions/series-datalabels-enabled/ Data labels enabled
-                 * @default true
-                 * @since 4.1.0
-                 * @product highcharts
-                 */
                 enabled: true,
-
-                /**
-                 * Whether to defer displaying the data labels until the initial series
-                 * animation has finished.
-                 * 
-                 * @type {Boolean}
-                 * @default false
-                 * @since 4.1.0
-                 * @product highcharts
-                 */
                 defer: false,
-
-                /**
-                 * The vertical alignment of a data label. Can be one of top, middle
-                 * or bottom. The default value depends on the data, for instance
-                 * in a column chart, the label is above positive values and below
-                 * negative values.
-                 * 
-                 * @type {String}
-                 * @default middle
-                 * @since 4.1.0
-                 * @product highcharts
-                 */
                 verticalAlign: 'middle',
-
-                /**
-                 */
                 formatter: function() { // #2945
                     return this.point.name || this.point.id;
                 },
-
-                /**
-                 * Whether to align the data label inside the box or to the actual
-                 * value point.
-                 * 
-                 * @type {Boolean}
-                 * @default true
-                 * @since 4.1.0
-                 * @product highcharts
-                 */
                 inside: true
             },
 
-            /**
-             * @extends plotOptions.heatmap.tooltip
-             * @since 4.1.0
-             * @product highcharts
-             */
             tooltip: {
-
-                /**
-                 * The HTML of the tooltip header line. Variables are enclosed by
-                 * curly brackets. Available variables are point.key, series.name,
-                 * series.color and other members from the point and series objects.
-                 * The point.key variable contains the category name, x value or
-                 * datetime string depending on the type of axis. For datetime axes,
-                 * the point.key date format can be set using tooltip.xDateFormat.
-                 * 
-                 * @type {String}
-                 * @sample {highcharts} highcharts/tooltip/footerformat/ A HTML table in the tooltip
-                 * @default ""
-                 * @since 4.1.0
-                 * @product highcharts
-                 */
                 headerFormat: '',
-
-                /**
-                 * The HTML of the point's line in the tooltip. Variables are enclosed
-                 * by curly brackets. Available variables are point.x, point.y, series.
-                 * name and series.color and other properties on the same form. Furthermore,
-                 * point.y can be extended by the tooltip.yPrefix and tooltip.ySuffix
-                 * variables. This can also be overridden for each series, which makes
-                 * it a good hook for displaying units.
-                 * 
-                 * @type {String}
-                 * @sample {highcharts} highcharts/tooltip/pointformat/ A different point format with value suffix
-                 * @default "<b>{point.name}</b>: {point.value}</b><br/>"
-                 * @since 4.1.0
-                 * @product highcharts
-                 */
-                pointFormat: '<b>{point.name}</b>: {point.value}</b><br/>'
+                pointFormat: '<b>{point.name}</b>: {point.value}<br/>'
             },
 
             /**
@@ -252,24 +361,40 @@
             levelIsConstant: true,
 
             /**
+             * Options for the button appearing when drilling down in a treemap.
              */
             drillUpButton: {
 
                 /**
+                 * The position of the button.
                  */
                 position: {
 
                     /**
+                     * Horizontal alignment of the button.
+                     * @validvalue ["left", "center", "right"]
                      */
                     align: 'right',
 
                     /**
+                     * Horizontal offset of the button.
+                     * @default -10
+                     * @type {Number}
                      */
                     x: -10,
 
                     /**
+                     * Vertical offset of the button.
                      */
                     y: 10
+
+                    /**
+                     * Vertical alignment of the button.
+                     *
+                     * @default top
+                     * @validvalue ["top", "middle", "bottom"]
+                     * @apioption plotOptions.treemap.drillUpButton.position.verticalAlign
+                     */
                 }
             },
 
@@ -285,6 +410,7 @@
             borderColor: '#e6e6e6',
 
             /**
+             * The width of the border surrounding each tree map item.
              */
             borderWidth: 1,
 
@@ -317,13 +443,22 @@
                 hover: {
 
                     /**
+                     * The border color for the hovered state.
                      */
                     borderColor: '#999999',
 
                     /**
+                     * Brightness for the hovered point. Defaults to 0 if the heatmap
+                     * series is loaded, otherwise 0.1.
+                     *
+                     * @default null
+                     * @type {Number}
                      */
                     brightness: seriesTypes.heatmap ? 0 : 0.1,
-
+                    /**
+                     * @extends plotOptions.heatmap.states.hover.halo
+                     */
+                    halo: false,
                     /**
                      * The opacity of a point in treemap. When a point has children,
                      * the visibility of the children is determined by the opacity.
@@ -336,12 +471,146 @@
                     opacity: 0.75,
 
                     /**
+                     * The shadow option for hovered state.
                      */
                     shadow: false
                 }
             }
 
 
+
+            /**
+             * Set options on specific levels. Takes precedence over series options,
+             * but not point options.
+             * 
+             * @type {Array<Object>}
+             * @sample {highcharts} highcharts/plotoptions/treemap-levels/
+             *         Styling dataLabels and borders
+             * @sample {highcharts} highcharts/demo/treemap-with-levels/
+             *         Different layoutAlgorithm
+             * @since 4.1.0
+             * @product highcharts
+             * @apioption plotOptions.treemap.levels
+             */
+
+            /**
+             * Can set a `borderColor` on all points which lies on the same level.
+             * 
+             * @type {Color}
+             * @since 4.1.0
+             * @product highcharts
+             * @apioption plotOptions.treemap.levels.borderColor
+             */
+
+            /**
+             * Set the dash style of the border of all the point which lies on the
+             * level. See <a href"#plotoptions.scatter.dashstyle">
+             * plotOptions.scatter.dashStyle</a> for possible options.
+             * 
+             * @type {String}
+             * @since 4.1.0
+             * @product highcharts
+             * @apioption plotOptions.treemap.levels.borderDashStyle
+             */
+
+            /**
+             * Can set the borderWidth on all points which lies on the same level.
+             * 
+             * @type {Number}
+             * @since 4.1.0
+             * @product highcharts
+             * @apioption plotOptions.treemap.levels.borderWidth
+             */
+
+            /**
+             * Can set a color on all points which lies on the same level.
+             * 
+             * @type {Color}
+             * @since 4.1.0
+             * @product highcharts
+             * @apioption plotOptions.treemap.levels.color
+             */
+
+            /**
+             * A configuration object to define how the color of a child varies from the
+             * parent's color. The variation is distributed among the children of node.
+             * For example when setting brightness, the brightness change will range
+             * from the parent's original brightness on the first child, to the amount
+             * set in the `to` setting on the last node. This allows a gradient-like
+             * color scheme that sets children out from each other while highlighting
+             * the grouping on treemaps and sectors on sunburst charts.
+             * 
+             * @type {Object}
+             * @sample highcharts/demo/sunburst/ Sunburst with color variation
+             * @since 6.0.0
+             * @product highcharts
+             * @apioption plotOptions.treemap.levels.colorVariation
+             */
+
+            /**
+             * The key of a color variation. Currently supports `brightness` only.
+             *  
+             * @type {String}
+             * @validvalue ["brightness"]
+             * @since 6.0.0
+             * @product highcharts
+             * @apioption plotOptions.treemap.levels.colorVariation.key
+             */
+
+            /**
+             * The ending value of a color variation. The last sibling will receive this
+             * value.
+             *  
+             * @type {Number}
+             * @since 6.0.0
+             * @product highcharts
+             * @apioption plotOptions.treemap.levels.colorVariation.to
+             */
+
+            /**
+             * Can set the options of dataLabels on each point which lies on the
+             * level. [plotOptions.treemap.dataLabels](#plotOptions.treemap.dataLabels)
+             * for possible values.
+             * 
+             * @type {Object}
+             * @default undefined
+             * @since 4.1.0
+             * @product highcharts
+             * @apioption plotOptions.treemap.levels.dataLabels
+             */
+
+            /**
+             * Can set the layoutAlgorithm option on a specific level.
+             * 
+             * @validvalue ["sliceAndDice", "stripes", "squarified", "strip"]
+             * @type {String}
+             * @since 4.1.0
+             * @product highcharts
+             * @apioption plotOptions.treemap.levels.layoutAlgorithm
+             */
+
+            /**
+             * Can set the layoutStartingDirection option on a specific level.
+             * 
+             * @validvalue ["vertical", "horizontal"]
+             * @type {String}
+             * @since 4.1.0
+             * @product highcharts
+             * @apioption plotOptions.treemap.levels.layoutStartingDirection
+             */
+
+            /**
+             * Decides which level takes effect from the options set in the levels
+             * object.
+             * 
+             * @type {Number}
+             * @sample {highcharts} highcharts/plotoptions/treemap-levels/
+             *         Styling of both levels
+             * @since 4.1.0
+             * @product highcharts
+             * @apioption plotOptions.treemap.levels.level
+             */
+
             // Prototype members
         }, {
             pointArrayMap: ['value'],
@@ -351,7 +620,14 @@
             getSymbol: noop,
             parallelArrays: ['x', 'y', 'value', 'colorValue'],
             colorKey: 'colorValue', // Point color option key
-            translateColors: seriesTypes.heatmap && seriesTypes.heatmap.prototype.translateColors,
+            translateColors: (
+                seriesTypes.heatmap &&
+                seriesTypes.heatmap.prototype.translateColors
+            ),
+            colorAttribs: (
+                seriesTypes.heatmap &&
+                seriesTypes.heatmap.prototype.colorAttribs
+            ),
             trackerGroups: ['group', 'dataLabelsGroup'],
             /**
              * Creates an object map from parent id to childrens index.
@@ -361,7 +637,7 @@
              * @return {Object} Map from parent id to children index in data.
              */
             getListOfParents: function(data, ids) {
-                var listOfParents = reduce(data, function(prev, curr, i) {
+                var listOfParents = reduce(data || [], function(prev, curr, i) {
                     var parent = pick(curr.parent, '');
                     if (prev[parent] === undefined) {
                         prev[parent] = [];
@@ -405,18 +681,21 @@
                 var series = this,
                     children = [],
                     point = series.points[i],
+                    height = 0,
                     node,
                     child;
 
                 // Actions
                 each((list[id] || []), function(i) {
                     child = series.buildNode(series.points[i].id, i, (level + 1), list, id);
+                    height = Math.max(child.height + 1, height);
                     children.push(child);
                 });
                 node = {
                     id: id,
                     i: i,
                     children: children,
+                    height: height,
                     level: level,
                     parent: parent,
                     visible: false // @todo move this to better location
@@ -552,38 +831,44 @@
                     }
                 });
             },
-            setColorRecursive: function(node, color, colorIndex) {
+
+            /**
+             * Set the node's color recursively, from the parent down.
+             */
+            setColorRecursive: function(node, parentColor, colorIndex, index, siblings) {
                 var series = this,
-                    point,
-                    level;
+                    chart = series && series.chart,
+                    colors = chart && chart.options && chart.options.colors,
+                    colorInfo,
+                    point;
+
                 if (node) {
-                    point = series.points[node.i];
-                    level = series.levelMap[node.levelDynamic];
-                    // Select either point color, level color or inherited color.
-                    color = pick(
-                        point && point.options.color,
-                        level && level.color,
-                        color,
-                        series.color
-                    );
-                    colorIndex = pick(
-                        point && point.options.colorIndex,
-                        level && level.colorIndex,
-                        colorIndex,
-                        series.colorIndex
-                    );
+                    colorInfo = getColor(node, {
+                        colors: colors,
+                        index: index,
+                        levelMap: series.levelMap,
+                        parentColor: parentColor,
+                        parentColorIndex: colorIndex,
+                        series: series,
+                        siblings: siblings
+                    });
 
+                    point = series.points[node.i];
                     if (point) {
-                        point.color = color;
-                        point.colorIndex = colorIndex;
+                        point.color = colorInfo.color;
+                        point.colorIndex = colorInfo.colorIndex;
                     }
 
-                    // Do it all again with the children	
-                    if (node.children.length) {
-                        each(node.children, function(child) {
-                            series.setColorRecursive(child, color, colorIndex);
-                        });
-                    }
+                    // Do it all again with the children
+                    each(node.children || [], function(child, i) {
+                        series.setColorRecursive(
+                            child,
+                            colorInfo.color,
+                            colorInfo.colorIndex,
+                            i,
+                            node.children.length
+                        );
+                    });
                 }
             },
             algorithmGroup: function(h, w, d, p) {
@@ -793,10 +1078,11 @@
                 // Call prototype function
                 Series.prototype.translate.call(series);
                 // Create a object map from level to options
-                series.levelMap = reduce(series.options.levels, function(arr, item) {
-                    arr[item.level] = item;
-                    return arr;
-                }, {});
+                series.levelMap = reduce(series.options.levels || [],
+                    function(arr, item) {
+                        arr[item.level] = item;
+                        return arr;
+                    }, {});
                 tree = series.tree = series.getTree(); // @todo Only if series.isDirtyData is true
                 rootNode = series.nodeMap[rootId];
                 if (
@@ -929,20 +1215,33 @@
              * Get presentational attributes
              */
             pointAttribs: function(point, state) {
-                var level = this.levelMap[point.node.levelDynamic] || {},
+                var level = point && this.levelMap[point.node.levelDynamic] || {},
                     options = this.options,
                     attr,
                     stateOptions = (state && options.states[state]) || {},
-                    className = point.getClassName(),
+                    className = (point && point.getClassName()) || '',
                     opacity;
 
                 // Set attributes by precedence. Point trumps level trumps series. Stroke width uses pick
                 // because it can be 0.
                 attr = {
-                    'stroke': point.borderColor || level.borderColor || stateOptions.borderColor || options.borderColor,
-                    'stroke-width': pick(point.borderWidth, level.borderWidth, stateOptions.borderWidth, options.borderWidth),
-                    'dashstyle': point.borderDashStyle || level.borderDashStyle || stateOptions.borderDashStyle || options.borderDashStyle,
-                    'fill': point.color || this.color
+                    'stroke':
+                        (point && point.borderColor) ||
+                        level.borderColor ||
+                        stateOptions.borderColor ||
+                        options.borderColor,
+                    'stroke-width': pick(
+                        point && point.borderWidth,
+                        level.borderWidth,
+                        stateOptions.borderWidth,
+                        options.borderWidth
+                    ),
+                    'dashstyle':
+                        (point && point.borderDashStyle) ||
+                        level.borderDashStyle ||
+                        stateOptions.borderDashStyle ||
+                        options.borderDashStyle,
+                    'fill': (point && point.color) || this.color
                 };
 
                 // Hide levels above the current view
@@ -977,7 +1276,7 @@
                     });
 
                 each(points, function(point) {
-                    var groupKey = 'levelGroup-' + point.node.levelDynamic;
+                    var groupKey = 'level-group-' + point.node.levelDynamic;
                     if (!series[groupKey]) {
                         series[groupKey] = series.chart.renderer.g(groupKey)
                             .attr({
@@ -991,6 +1290,8 @@
                 // Call standard drawPoints
                 seriesTypes.column.prototype.drawPoints.call(this);
 
+
+
                 // If drillToNode is allowed, set a point cursor on clickables & add drillId to point 
                 if (series.options.allowDrillToNode) {
                     each(points, function(point) {
@@ -1059,6 +1360,7 @@
                 var series = this,
                     nodeMap = series.nodeMap,
                     node = nodeMap[id];
+                series.idPreviousRoot = series.rootNode;
                 series.rootNode = id;
                 if (id === '') {
                     series.drillUpButton = series.drillUpButton.destroy();
@@ -1138,6 +1440,10 @@
                 Series.prototype.bindAxes.call(this);
                 H.extend(this.yAxis.options, treeAxis);
                 H.extend(this.xAxis.options, treeAxis);
+            },
+            utils: {
+                recursive: recursive,
+                reduce: reduce
             }
 
             // Point class
@@ -1159,8 +1465,13 @@
                 }
                 return className;
             },
+
+            /**
+             * A tree point is valid if it has han id too, assume it may be a parent
+             * item.
+             */
             isValid: function() {
-                return isNumber(this.value);
+                return this.id || isNumber(this.value);
             },
             setState: function(state) {
                 H.Point.prototype.setState.call(this, state);
@@ -1175,5 +1486,98 @@
             setVisible: seriesTypes.pie.prototype.pointClass.prototype.setVisible
         });
 
-    }(Highcharts));
+
+        /**
+         * A `treemap` series. If the [type](#series.treemap.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.
+         * treemap](#plotOptions.treemap).
+         * 
+         * @type {Object}
+         * @extends series,plotOptions.treemap
+         * @excluding dataParser,dataURL,stack
+         * @product highcharts
+         * @apioption series.treemap
+         */
+
+        /**
+         * An array of data points for the series. For the `treemap` series
+         * type, points can be given in the following ways:
+         * 
+         * 1.  An array of numerical values. In this case, the numerical values
+         * will be interpreted as `value` options. Example:
+         * 
+         *  ```js
+         *  data: [0, 5, 3, 5]
+         *  ```
+         * 
+         * 2.  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.treemap.turboThreshold),
+         * this option is not available.
+         * 
+         *  ```js
+         *     data: [{
+         *         value: 9,
+         *         name: "Point2",
+         *         color: "#00FF00"
+         *     }, {
+         *         value: 6,
+         *         name: "Point1",
+         *         color: "#FF00FF"
+         *     }]
+         *  ```
+         * 
+         * @type {Array<Object|Number>}
+         * @extends series.heatmap.data
+         * @excluding 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.treemap.data
+         */
+
+        /**
+         * The value of the point, resulting in a relative area of the point
+         * in the treemap.
+         * 
+         * @type {Number}
+         * @product highcharts
+         * @apioption series.treemap.data.value
+         */
+
+        /**
+         * Serves a purpose only if a `colorAxis` object is defined in the chart
+         * options. This value will decide which color the point gets from the
+         * scale of the colorAxis.
+         * 
+         * @type {Number}
+         * @default undefined
+         * @since 4.1.0
+         * @product highcharts
+         * @apioption series.treemap.data.colorValue
+         */
+
+        /**
+         * Only for treemap. Use this option to build a tree structure. The
+         * value should be the id of the point which is the parent. If no points
+         * has a matching id, or this option is undefined, then the parent will
+         * be set to the root.
+         * 
+         * @type {String}
+         * @sample {highcharts} highcharts/point/parent/ Point parent
+         * @sample {highcharts} highcharts/demo/treemap-with-levels/ Example where parent id is not matching
+         * @default undefined
+         * @since 4.1.0
+         * @product highcharts
+         * @apioption series.treemap.data.parent
+         */
+
+    }(Highcharts, result));
 }));