highcharts 6.1.1 → 6.2.0

package/js/es-modules/parts/DataGrouping.js

@@ -1,5 +1,5 @@
 /**
- * (c) 2010-2017 Torstein Honsi
+ * (c) 2010-2018 Torstein Honsi
  *
  * License: www.highcharts.com/license
  */
@@ -40,7 +40,11 @@ var addEvent = H.addEvent,
  *
  * If data grouping is applied, the grouping information of grouped
  * points can be read from the [Point.dataGroup](
- * /class-reference/Highcharts.Point#.dataGroup).
+ * /class-reference/Highcharts.Point#.dataGroup). If point options other than
+ * the data itself are set, for example `name` or `color` or custom properties,
+ * the grouping logic doesn't know how to group it. In this case the options of
+ * the first point instance are copied over to the group point. This can be
+ * altered through a custom `approximation` callback function.
  *
  * @product highstock
  * @apioption plotOptions.series.dataGrouping
@@ -488,6 +492,7 @@ seriesProto.groupData = function (xData, yData, groupPositions, approximation) {
                 ) || approximations[commonOptions.approximation],
         pointArrayMap = series.pointArrayMap,
         pointArrayMapLength = pointArrayMap && pointArrayMap.length,
+        extendedPointArrayMap = ['x'].concat(pointArrayMap || ['y']),
         pos = 0,
         start = 0,
         valuesLen,
@@ -524,6 +529,28 @@ seriesProto.groupData = function (xData, yData, groupPositions, approximation) {
             series.dataGroupInfo = { start: start, length: values[0].length };
             groupedY = approximationFn.apply(series, values);
 
+            // By default, let options of the first grouped point be passed over
+            // to the grouped point. This allows preserving properties like
+            // `name` and `color` or custom properties. Implementers can
+            // override this from the approximation function, where they can
+            // write custom options to `this.dataGroupInfo.options`.
+            if (!defined(series.dataGroupInfo.options)) {
+                // Convert numbers and arrays into objects
+                series.dataGroupInfo.options = merge(
+                    series.pointClass.prototype
+                        .optionsToObject.call(
+                            { series: series },
+                            series.options.data[start]
+                        )
+                );
+
+                // Make sure the raw data (x, y, open, high etc) is not copied
+                // over and overwriting approximated data.
+                each(extendedPointArrayMap, function (key) {
+                    delete series.dataGroupInfo.options[key];
+                });
+            }
+
             // push the grouped data
             if (groupedY !== undefined) {
                 groupedXData.push(pointX);
@@ -694,7 +721,13 @@ seriesProto.processData = function () {
                 groupedXData[0] < xAxis.dataMin &&
                 visible
             ) {
-                if (xAxis.min <= xAxis.dataMin) {
+                if (
+                    (
+                        !defined(xAxis.options.min) &&
+                        xAxis.min <= xAxis.dataMin
+                    ) ||
+                    xAxis.min === xAxis.dataMin
+                ) {
                     xAxis.min = groupedXData[0];
                 }
                 xAxis.dataMin = groupedXData[0];

package/js/es-modules/parts/DataLabels.js

@@ -1,12 +1,15 @@
 /**
- * (c) 2010-2017 Torstein Honsi
+ * (c) 2010-2018 Torstein Honsi
  *
  * License: www.highcharts.com/license
  */
+
 'use strict';
+
 import H from './Globals.js';
 import './Utilities.js';
 import './Series.js';
+
 var addEvent = H.addEvent,
     arrayMax = H.arrayMax,
     defined = H.defined,
@@ -21,8 +24,9 @@ var addEvent = H.addEvent,
     Series = H.Series,
     seriesTypes = H.seriesTypes,
     some = H.some,
-    stableSort = H.stableSort;
-
+    stableSort = H.stableSort,
+    isArray = H.isArray,
+    splat = H.splat;
 
 /**
  * General distribution algorithm for distributing labels of differing size
@@ -30,6 +34,15 @@ var addEvent = H.addEvent,
  * objects containing a size, a target and a rank. It will place the labels as
  * close as possible to their targets, skipping the lowest ranked labels if
  * necessary.
+ *
+ * @private
+ * @function Highcharts.distribute
+ *
+ * @param {Array<object>} boxes
+ *
+ * @param {number} len
+ *
+ * @param {number} maxDistance
  */
 H.distribute = function (boxes, len, maxDistance) {
 
@@ -174,19 +187,22 @@ H.distribute = function (boxes, len, maxDistance) {
 
 /**
  * Draw the data labels
+ *
+ * @private
+ * @function Highcharts.Series#drawDataLabels
+ *
+ * @fires Highcharts.Series#event:afterDrawDataLabels
  */
 Series.prototype.drawDataLabels = function () {
     var series = this,
         chart = series.chart,
         seriesOptions = series.options,
-        options = seriesOptions.dataLabels,
+        seriesDlOptions = seriesOptions.dataLabels,
         points = series.points,
         pointOptions,
-        generalOptions,
         hasRendered = series.hasRendered || 0,
-        str,
         dataLabelsGroup,
-        defer = pick(options.defer, !!seriesOptions.animation),
+        defer = pick(seriesDlOptions.defer, !!seriesOptions.animation),
         renderer = chart.renderer;
 
     /*
@@ -216,19 +232,59 @@ Series.prototype.drawDataLabels = function () {
         return true;
     }
 
-    if (options.enabled || series._hasPointLabels) {
-
-        // Process default alignment of data labels for columns
-        if (series.dlProcessOptions) {
-            series.dlProcessOptions(options);
+    /*
+     * Merge two objects that can be arrays. If one of them is an array, the
+     * other is merged into each element. If both are arrays, each element is
+     * merged by index. If neither are arrays, we use normal merge.
+     */
+    function mergeArrays(one, two) {
+        var res = [],
+            i;
+        if (isArray(one) && !isArray(two)) {
+            res = map(one, function (el) {
+                return merge(el, two);
+            });
+        } else if (isArray(two) && !isArray(one)) {
+            res = map(two, function (el) {
+                return merge(one, el);
+            });
+        } else if (!isArray(one) && !isArray(two)) {
+            res = merge(one, two);
+        } else {
+            i = Math.max(one.length, two.length);
+            while (i--) {
+                res[i] = merge(one[i], two[i]);
+            }
         }
+        return res;
+    }
+
+
+    // Merge in plotOptions.dataLabels for series
+    seriesDlOptions = mergeArrays(
+        mergeArrays(
+            chart.options.plotOptions &&
+            chart.options.plotOptions.series &&
+            chart.options.plotOptions.series.dataLabels,
+            chart.options.plotOptions &&
+            chart.options.plotOptions[series.type] &&
+            chart.options.plotOptions[series.type].dataLabels
+        ),
+        seriesDlOptions
+    );
+
+    if (
+        isArray(seriesDlOptions) ||
+        seriesDlOptions.enabled ||
+        series._hasPointLabels
+    ) {
 
         // Create a separate group for the data labels to avoid rotation
         dataLabelsGroup = series.plotGroup(
             'dataLabelsGroup',
             'data-labels',
             defer && !hasRendered ? 'hidden' : 'visible', // #5133
-            options.zIndex || 6
+            seriesDlOptions.zIndex || 6
         );
 
         if (defer) {
@@ -246,114 +302,161 @@ Series.prototype.drawDataLabels = function () {
         }
 
         // Make the labels for each point
-        generalOptions = options;
         each(points, function (point) {
-            var enabled,
-                dataLabel = point.dataLabel,
-                labelConfig,
-                attr,
-                rotation,
-                connector = point.connector,
-                isNew = !dataLabel,
-                style,
-                formatString;
-
-            // Determine if each data label is enabled
+
+            // Merge in series options for the point.
             // @note dataLabelAttribs (like pointAttribs) would eradicate
             // the need for dlOptions, and simplify the section below.
-            pointOptions = point.dlOptions || // dlOptions is used in treemaps
-                (point.options && point.options.dataLabels);
-            enabled = pick(
-                pointOptions && pointOptions.enabled,
-                generalOptions.enabled
-            ) && !point.isNull; // #2282, #4641, #7112
-
-            if (enabled) {
-                enabled = applyFilter(point, pointOptions || options) === true;
-            }
-
-            if (enabled) {
-                // Create individual options structure that can be extended
-                // without affecting others
-                options = merge(generalOptions, pointOptions);
-                labelConfig = point.getLabelConfig();
-                formatString = (
-                    options[point.formatPrefix + 'Format'] ||
-                    options.format
-                );
+            pointOptions = splat(
+                mergeArrays(
+                    seriesDlOptions,
+                    point.dlOptions || // dlOptions is used in treemaps
+                        (point.options && point.options.dataLabels)
+                )
+            );
 
-                str = defined(formatString) ?
-                    format(formatString, labelConfig, chart.time) :
-                    (
-                        options[point.formatPrefix + 'Formatter'] ||
-                        options.formatter
-                    ).call(labelConfig, options);
+            // Handle each individual data label for this point
+            each(pointOptions, function (labelOptions, i) {
+                // Options for one datalabel
+                var labelEnabled = labelOptions.enabled &&
+                        !point.isNull && // #2282, #4641, #7112
+                        applyFilter(point, labelOptions),
+                    labelConfig,
+                    formatString,
+                    labelText,
+                    style,
+                    rotation,
+                    attr,
+                    dataLabel = point.dataLabels ? point.dataLabels[i] :
+                        point.dataLabel,
+                    connector = point.connectors ? point.connectors[i] :
+                        point.connector,
+                    isNew = !dataLabel;
+
+                if (labelEnabled) {
+                    // Create individual options structure that can be extended
+                    // without affecting others
+                    labelConfig = point.getLabelConfig();
+                    formatString = (
+                        labelOptions[point.formatPrefix + 'Format'] ||
+                        labelOptions.format
+                    );
 
-                style = options.style;
-                rotation = options.rotation;
-                
+                    labelText = defined(formatString) ?
+                        format(formatString, labelConfig, chart.time) :
+                        (
+                            labelOptions[point.formatPrefix + 'Formatter'] ||
+                            labelOptions.formatter
+                        ).call(labelConfig, labelOptions);
 
-                attr = {
+                    style = labelOptions.style;
+                    rotation = labelOptions.rotation;
                     
-                    r: options.borderRadius || 0,
-                    rotation: rotation,
-                    padding: options.padding,
-                    zIndex: 1
-                };
 
-                // Remove unused attributes (#947)
-                H.objectEach(attr, function (val, name) {
-                    if (val === undefined) {
-                        delete attr[name];
-                    }
-                });
-            }
-            // If the point is outside the plot area, destroy it. #678, #820
-            if (dataLabel && (!enabled || !defined(str))) {
-                point.dataLabel = dataLabel = dataLabel.destroy();
-                if (connector) {
-                    point.connector = connector.destroy();
+                    attr = {
+                        
+                        r: labelOptions.borderRadius || 0,
+                        rotation: rotation,
+                        padding: labelOptions.padding,
+                        zIndex: 1
+                    };
+
+                    // Remove unused attributes (#947)
+                    H.objectEach(attr, function (val, name) {
+                        if (val === undefined) {
+                            delete attr[name];
+                        }
+                    });
                 }
-            // Individual labels are disabled if the are explicitly disabled
-            // in the point options, or if they fall outside the plot area.
-            } else if (enabled && defined(str)) {
-                // create new label
-                if (!dataLabel) {
-                    dataLabel = point.dataLabel = rotation ?
-
-                        renderer.text(str, 0, -9999) // labels don't rotate
-                            .addClass('highcharts-data-label') :
-
-                        renderer.label(
-                            str,
-                            0,
-                            -9999,
-                            options.shape,
-                            null,
-                            null,
-                            options.useHTML,
-                            null,
-                            'data-label'
+
+                // If the point is outside the plot area, destroy it. #678, #820
+                if (dataLabel && (!labelEnabled || !defined(labelText))) {
+                    point.dataLabel = point.dataLabel.destroy();
+                    if (point.dataLabels) {
+                        // Remove point.dataLabels if this was the last one
+                        if (point.dataLabels.length === 1) {
+                            delete point.dataLabels;
+                        } else {
+                            delete point.dataLabels[i];
+                        }
+                    }
+                    if (!i) {
+                        delete point.dataLabel;
+                    }
+                    if (connector) {
+                        point.connector = point.connector.destroy();
+                        if (point.connectors) {
+                            // Remove point.connectors if this was the last one
+                            if (point.connectors.length === 1) {
+                                delete point.connectors;
+                            } else {
+                                delete point.connectors[i];
+                            }
+                        }
+                    }
+
+                // Individual labels are disabled if the are explicitly disabled
+                // in the point options, or if they fall outside the plot area.
+                } else if (labelEnabled && defined(labelText)) {
+
+                    if (!dataLabel) {
+                        // Create new label element
+                        point.dataLabels = point.dataLabels || [];
+                        dataLabel = point.dataLabels[i] = rotation ?
+
+                            // Labels don't rotate, use text element
+                            renderer.text(labelText, 0, -9999)
+                                .addClass('highcharts-data-label') :
+
+                            // We can use label
+                            renderer.label(
+                                labelText,
+                                0,
+                                -9999,
+                                labelOptions.shape,
+                                null,
+                                null,
+                                labelOptions.useHTML,
+                                null,
+                                'data-label'
+                            );
+
+                        // Store for backwards compatibility
+                        if (!i) {
+                            point.dataLabel = dataLabel;
+                        }
+
+                        dataLabel.addClass(
+                            ' highcharts-data-label-color-' + point.colorIndex +
+                            ' ' + (labelOptions.className || '') +
+                            (   // #3398
+                                labelOptions.useHTML ?
+                                    ' highcharts-tracker' :
+                                    ''
+                            )
                         );
+                    } else {
+                        // Use old element and just update text
+                        attr.text = labelText;
+                    }
 
-                    dataLabel.addClass(
-                        ' highcharts-data-label-color-' + point.colorIndex +
-                        ' ' + (options.className || '') +
-                        (options.useHTML ? ' highcharts-tracker' : '') // #3398
-                    );
-                } else {
-                    attr.text = str;
-                }
-                dataLabel.attr(attr);
-                
+                    // Store data label options for later access
+                    dataLabel.options = labelOptions;
+
+                    dataLabel.attr(attr);
+                    
 
-                if (!dataLabel.added) {
-                    dataLabel.add(dataLabelsGroup);
+                    if (!dataLabel.added) {
+                        dataLabel.add(dataLabelsGroup);
+                    }
+
+                    // Now the data label is created and placed at 0,0, so we
+                    // need to align it
+                    series.alignDataLabel(
+                        point, dataLabel, labelOptions, null, isNew
+                    );
                 }
-                // Now the data label is created and placed at 0,0, so we need
-                // to align it
-                series.alignDataLabel(point, dataLabel, options, null, isNew);
-            }
+            });
         });
     }
 
@@ -361,7 +464,20 @@ Series.prototype.drawDataLabels = function () {
 };
 
 /**
- * Align each individual data label
+ * Align each individual data label.
+ *
+ * @private
+ * @function Highcharts.Series#alignDataLabel
+ *
+ * @param {Highcharts.Point} point
+ *
+ * @param {Highcharts.SVGElement} dataLabel
+ *
+ * @param {Highcharts.PlotSeriesDataLabelsOptions} options
+ *
+ * @param {Highcharts.BBoxObject} alignTo
+ *
+ * @param {boolean} isNew
  */
 Series.prototype.alignDataLabel = function (
     point,
@@ -463,7 +579,7 @@ Series.prototype.alignDataLabel = function (
         }
 
         // Handle justify or crop
-        if (justify) {
+        if (justify && alignTo.height >= 0) { // #8830
             point.isLabelJustified = this.justifyDataLabel(
                 dataLabel,
                 options,
@@ -507,6 +623,21 @@ Series.prototype.alignDataLabel = function (
 /**
  * If data labels fall partly outside the plot area, align them back in, in a
  * way that doesn't hide the point.
+ *
+ * @private
+ * @function Highcharts.Series#justifyDataLabel
+ *
+ * @param {Highcharts.SVGElement} dataLabel
+ *
+ * @param {Highcharts.PlotSeriesDataLabelsOptions} options
+ *
+ * @param {*} alignAttr
+ *
+ * @param {Highcharts.BBoxObject} bBox
+ *
+ * @param {boolean} isNew
+ *
+ * @return {boolean}
  */
 Series.prototype.justifyDataLabel = function (
     dataLabel,
@@ -575,10 +706,13 @@ Series.prototype.justifyDataLabel = function (
     return justified;
 };
 
-/**
- * Override the base drawDataLabels method by pie specific functionality
- */
 if (seriesTypes.pie) {
+    /**
+     * Override the base drawDataLabels method by pie specific functionality
+     *
+     * @private
+     * @function Highcharts.seriesTypes.pie#drawDataLabels
+     */
     seriesTypes.pie.prototype.drawDataLabels = function () {
         var series = this,
             data = series.data,
@@ -656,6 +790,12 @@ if (seriesTypes.pie) {
                     
                 } else {
                     point.dataLabel = point.dataLabel.destroy();
+                    // Workaround to make pies destroy multiple datalabels
+                    // correctly. This logic needs rewriting to support multiple
+                    // datalabels fully.
+                    if (point.dataLabels && point.dataLabels.length === 1) {
+                        delete point.dataLabels;
+                    }
                 }
             }
         });
@@ -891,6 +1031,13 @@ if (seriesTypes.pie) {
     /**
      * Extendable method for getting the path of the connector between the data
      * label and the pie slice.
+     *
+     * @private
+     * @function Highcharts.seriesTypes.pie#connectorPath
+     *
+     * @param {*} labelPos
+     *
+     * @return {Highcharts.PathObject}
      */
     seriesTypes.pie.prototype.connectorPath = function (labelPos) {
         var x = labelPos.x,
@@ -919,6 +1066,9 @@ if (seriesTypes.pie) {
     /**
      * Perform the final placement of the data labels after we have verified
      * that they fall within the plot area.
+     *
+     * @private
+     * @function Highcharts.seriesTypes.pie#placeDataLabels
      */
     seriesTypes.pie.prototype.placeDataLabels = function () {
         each(this.points, function (point) {
@@ -937,7 +1087,8 @@ if (seriesTypes.pie) {
                         dataLabel.css({
                             width: dataLabel._attr.width + 'px',
                             textOverflow: (
-                                this.options.dataLabels.style.textOverflow ||
+                                (this.options.dataLabels.style || {})
+                                    .textOverflow ||
                                 'ellipsis'
                             )
                         });
@@ -960,6 +1111,13 @@ if (seriesTypes.pie) {
      * Verify whether the data labels are allowed to draw, or we should run more
      * translation and data label positioning to keep them inside the plot area.
      * Returns true when data labels are ready to draw.
+     *
+     * @private
+     * @function Highcharts.seriesTypes.pie#verifyDataLabelOverflow
+     *
+     * @param {boolean} overflow
+     *
+     * @return {boolean}
      */
     seriesTypes.pie.prototype.verifyDataLabelOverflow = function (overflow) {
 
@@ -1033,7 +1191,20 @@ if (seriesTypes.column) {
 
     /**
      * Override the basic data label alignment by adjusting for the position of
-     * the column
+     * the column.
+     *
+     * @private
+     * @function Highcharts.seriesTypes.column#alignDataLabel
+     *
+     * @param {Highcharts.Point} point
+     *
+     * @param {Highcharts.SVGElement} dataLabel
+     *
+     * @param {Highcharts.PlotSeriesDataLabelsOptions} options
+     *
+     * @param {Highcharts.BBoxObject} alignTo
+     *
+     * @param {boolean} isNew
      */
     seriesTypes.column.prototype.alignDataLabel = function (
         point,
@@ -1112,7 +1283,7 @@ if (seriesTypes.column) {
 
         // If label was justified and we have contrast, set it:
         if (point.isLabelJustified && point.contrastColor) {
-            point.dataLabel.css({
+            dataLabel.css({
                 color: point.contrastColor
             });
         }

package/js/es-modules/parts/DateTimeAxis.js

@@ -1,27 +1,40 @@
 /**
- * (c) 2010-2017 Torstein Honsi
+ * (c) 2010-2018 Torstein Honsi
  *
  * License: www.highcharts.com/license
  */
 
 'use strict';
+
 import H from './Globals.js';
 import './Utilities.js';
+
 var Axis = H.Axis,
     getMagnitude = H.getMagnitude,
     normalizeTickInterval = H.normalizeTickInterval,
     timeUnits = H.timeUnits;
+
 /**
  * Set the tick positions to a time unit that makes sense, for example
  * on the first of each month or on every Monday. Return an array
  * with the time positions. Used in datetime axes as well as for grouping
  * data on a datetime axis.
  *
- * @param {Object} normalizedInterval
+ * @private
+ * @function Highcharts.Axis#getTimeTicks
+ *
+ * @param {*} normalizedInterval
  *        The interval in axis values (ms) and thecount
- * @param {Number} min The minimum in axis values
- * @param {Number} max The maximum in axis values
- * @param {Number} startOfWeek
+ *
+ * @param {number} min
+ *        The minimum in axis values
+ *
+ * @param {number} max
+ *        The maximum in axis values
+ *
+ * @param {number} startOfWeek
+ *
+ * @return {number}
  */
 Axis.prototype.getTimeTicks = function () {
     return this.chart.time.getTimeTicks.apply(this.chart.time, arguments);
@@ -34,6 +47,15 @@ Axis.prototype.getTimeTicks = function () {
  * of segments in stock charts, the normalizing logic was extracted in order to
  * prevent it for running over again for each segment having the same interval.
  * #662, #697.
+ *
+ * @private
+ * @function Highcharts.Axis#normalizeTimeTickInterval
+ *
+ * @param {number} tickInterval
+ *
+ * @param {Array<Array<number|string>>} [unitsOption]
+ *
+ * @return {*}
  */
 Axis.prototype.normalizeTimeTickInterval = function (
     tickInterval,