highcharts 7.1.1 → 7.1.2

package/es-modules/parts-more/PackedBubbleSeries.js

@@ -9,9 +9,9 @@
 /**
  * Formatter callback function.
  *
- * @callback Highcharts.PlotPackedBubbleDataLabelsFormatterCallbackFunction
+ * @callback Highcharts.SeriesPackedBubbleDataLabelsFormatterCallbackFunction
  *
- * @param {Highcharts.PlotPackedBubbleDataLabelsFormatterContextObject|Highcharts.DataLabelsFormatterContextObject} this
+ * @param {Highcharts.SeriesPackedBubbleDataLabelsFormatterContextObject|Highcharts.DataLabelsFormatterContextObject} this
  *        Data label context to format
  *
  * @return {string}
@@ -21,24 +21,24 @@
 /**
  * Context for the formatter function.
  *
- * @interface Highcharts.PlotPackedBubbleDataLabelsFormatterContextObject
+ * @interface Highcharts.SeriesPackedBubbleDataLabelsFormatterContextObject
  * @extends Highcharts.DataLabelsFormatterContextObject
  * @since 7.0.0
  *//**
  * The color of the node.
- * @name Highcharts.PlotPackedBubbleDataLabelsFormatterContextObject#color
+ * @name Highcharts.SeriesPackedBubbleDataLabelsFormatterContextObject#color
  * @type {Highcharts.ColorString}
  * @since 7.0.0
  *//**
  * The point (node) object. The node name, if defined, is available through
  * `this.point.name`. Arrays: `this.point.linksFrom` and `this.point.linksTo`
  * contains all nodes connected to this point.
- * @name Highcharts.PlotPackedBubbleDataLabelsFormatterContextObject#point
+ * @name Highcharts.SeriesPackedBubbleDataLabelsFormatterContextObject#point
  * @type {Highcharts.Point}
  * @since 7.0.0
  *//**
  * The ID of the node.
- * @name Highcharts.PlotPackedBubbleDataLabelsFormatterContextObject#key
+ * @name Highcharts.SeriesPackedBubbleDataLabelsFormatterContextObject#key
  * @type {string}
  * @since 7.0.0
  */
@@ -46,7 +46,7 @@
 /**
  * Data labels options
  *
- * @interface Highcharts.PlotPackedBubbleDataLabelsOptionsObject
+ * @interface Highcharts.SeriesPackedBubbleDataLabelsOptionsObject
  * @extends Highcharts.DataLabelsOptionsObject
  * @since 7.0.0
  *//**
@@ -54,54 +54,54 @@
  * [format string](https://www.highcharts.com/docs/chart-concepts/labels-and-string-formatting)
  * specifying what to show for _node_ in the networkgraph. In v7.0 defaults to
  * `{key}`, since v7.1 defaults to `undefined` and `formatter` is used instead.
- * @name Highcharts.PlotPackedBubbleDataLabelsOptionsObject#format
+ * @name Highcharts.SeriesPackedBubbleDataLabelsOptionsObject#format
  * @type {string}
  * @since 7.0.0
  *//**
  * Callback JavaScript function to format the data label for a node. Note that
  * if a `format` is defined, the format takes precedence and the formatter is
  * ignored.
- * @name Highcharts.PlotPackedBubbleDataLabelsOptionsObject#formatter
- * @type {Highcharts.PlotPackedBubbleDataLabelsFormatterCallbackFunction|undefined}
+ * @name Highcharts.SeriesPackedBubbleDataLabelsOptionsObject#formatter
+ * @type {Highcharts.SeriesPackedBubbleDataLabelsFormatterCallbackFunction|undefined}
  * @since 7.0.0
  *//**
  * Callback to format data labels for _parentNodes_. The `parentNodeFormat`
  * option takes precedence over the `parentNodeFormatter`.
- * @name Highcharts.PlotPackedBubbleDataLabelsFormatterContextObject#parentNodeFormatter
+ * @name Highcharts.SeriesPackedBubbleDataLabelsFormatterContextObject#parentNodeFormatter
  * @type {Highcharts.FormatterCallbackFunction<Highcharts.DataLabelsFormatterContextObject>}
  * @since 7.1.0
  *//**
  * Options for a _parentNode_ label text.
  * @sample highcharts/series-packedbubble/packed-dashboard
  *         Dashboard with dataLabels on parentNodes
- * @name Highcharts.PlotPackedBubbleDataLabelsFormatterContextObject#parentNodeTextPath
- * @type {Highcharts.PlotPackedBubbleDataLabelsTextPath}
+ * @name Highcharts.SeriesPackedBubbleDataLabelsFormatterContextObject#parentNodeTextPath
+ * @type {Highcharts.SeriesPackedBubbleDataLabelsTextPath}
  * @since 7.1.0
 *//**
  * Options for a _node_ label text which should follow marker's shape.
  * **Note:** Only SVG-based renderer supports this option.
- * @see {@link Highcharts.PlotPackedBubbleDataLabelsTextPath#linkTextPath}
- * @name Highcharts.PlotPackedBubbleDataLabelsOptionsObject#textPath
- * @type {Highcharts.PlotPackedBubbleDataLabelsTextPath}
+ * @see {@link Highcharts.SeriesPackedBubbleDataLabelsTextPath#linkTextPath}
+ * @name Highcharts.SeriesPackedBubbleDataLabelsOptionsObject#textPath
+ * @type {Highcharts.SeriesPackedBubbleDataLabelsTextPath}
  * @since 7.1.0
  */
 
 /**
  * **Note:** Only SVG-based renderer supports this option.
  *
- * @see {@link Highcharts.PlotNetworkDataLabelsTextPath#linkTextPath}
- * @see {@link Highcharts.PlotNetworkDataLabelsTextPath#textPath}
+ * @see {@link Highcharts.SeriesNetworkDataLabelsTextPath#linkTextPath}
+ * @see {@link Highcharts.SeriesNetworkDataLabelsTextPath#textPath}
  *
- * @interface Highcharts.PlotPackedBubbleDataLabelsTextPath
+ * @interface Highcharts.SeriesPackedBubbleDataLabelsTextPath
  * @since 7.1.0
  *//**
  * Presentation attributes for the text path.
- * @name Highcharts.PlotPackedBubbleDataLabelsTextPath#attributes
+ * @name Highcharts.SeriesPackedBubbleDataLabelsTextPath#attributes
  * @type {Highcharts.SVGAttributes}
  * @since 7.1.0
  *//**
  * Enable or disable `textPath` option for link's or marker's data labels.
- * @name Highcharts.PlotPackedBubbleDataLabelsTextPath#enabled
+ * @name Highcharts.SeriesPackedBubbleDataLabelsTextPath#enabled
  * @type {boolean|undefined}
  * @since 7.1.0
  */
@@ -188,8 +188,7 @@ H.layouts.packedbubble = H.extendClass(
             if (this.options.marker) {
                 this.series.forEach(function (series) {
                     if (series) {
-                        series.translate();
-                        series.drawPoints();
+                        series.calculateParentRadius();
                     }
                 });
             }
@@ -325,7 +324,10 @@ H.layouts.packedbubble = H.extendClass(
             (
                 // In first iteration system does not move:
                 this.systemTemperature > 0 &&
-                this.systemTemperature / this.nodes.length < 0.01
+                (
+                    this.systemTemperature / this.nodes.length < 0.02 &&
+                    this.enableSimulation
+                ) // Use only when simulation is enabled
             );
         }
     }
@@ -422,7 +424,8 @@ seriesType(
          */
         useSimulation: true,
         /**
-         * @type {Highcharts.PlotPackedBubbleDataLabelsOptionsObject}
+         * @type    {Highcharts.SeriesPackedBubbleDataLabelsOptionsObject|Array<Highcharts.SeriesPackedBubbleDataLabelsOptionsObject>}
+         * @default {"formatter": function () { return this.point.value; }, "parentNodeFormatter": function () { return this.name; }, "parentNodeTextPath": {"enabled: true}, "padding": 0}
          *
          * @private
          */
@@ -519,7 +522,7 @@ seriesType(
                  * @sample highcharts/series-packedbubble/parentnode-style/
                  *         Bubble size
                  *
-                 * @extends   plotOptions.line.marker
+                 * @extends   plotOptions.series.marker
                  * @excluding states
                  */
                 marker: {
@@ -646,14 +649,18 @@ seriesType(
             var series = this,
                 dataLabels = [];
             Series.prototype.render.apply(this, arguments);
-            series.data.forEach(function (point) {
-                if (H.isArray(point.dataLabels)) {
-                    point.dataLabels.forEach(function (dataLabel) {
-                        dataLabels.push(dataLabel);
-                    });
-                }
-            });
-            series.chart.hideOverlappingLabels(dataLabels);
+            // #10823 - dataLabels should stay visible
+            // when enabled allowOverlap.
+            if (!series.options.dataLabels.allowOverlap) {
+                series.data.forEach(function (point) {
+                    if (H.isArray(point.dataLabels)) {
+                        point.dataLabels.forEach(function (dataLabel) {
+                            dataLabels.push(dataLabel);
+                        });
+                    }
+                });
+                series.chart.hideOverlappingLabels(dataLabels);
+            }
         },
         // Needed because of z-indexing issue if point is added in series.group
         setVisible: function () {
@@ -704,6 +711,38 @@ seriesType(
                 this.options.dataLabels.textPath = textPath;
             }
         },
+        /**
+         * The function responsible for calculating series bubble' s bBox.
+         * Needed because of exporting failure when useSimulation
+         * is set to false
+         * @private
+         */
+        seriesBox: function () {
+            var series = this,
+                chart = series.chart,
+                data = series.data,
+                max = Math.max,
+                min = Math.min,
+                radius,
+                // bBox = [xMin, xMax, yMin, yMax]
+                bBox = [
+                    chart.plotLeft,
+                    chart.plotLeft + chart.plotWidth,
+                    chart.plotTop,
+                    chart.plotTop + chart.plotHeight
+                ];
+
+            data.forEach(function (p) {
+                if (defined(p.plotX) && defined(p.plotY) && p.marker.radius) {
+                    radius = p.marker.radius;
+                    bBox[0] = min(bBox[0], p.plotX - radius);
+                    bBox[1] = max(bBox[1], p.plotX + radius);
+                    bBox[2] = min(bBox[2], p.plotY - radius);
+                    bBox[3] = max(bBox[3], p.plotY + radius);
+                }
+            });
+            return H.isNumber(bBox.width / bBox.height) ? bBox : null;
+        },
         /**
          * The function responsible for calculating the parent node radius
          * based on the total surface of iniside-bubbles and the group BBox
@@ -715,10 +754,7 @@ seriesType(
                 parentPadding = 20,
                 minParentRadius = 20;
 
-            if (series.group) {
-                bBox = series.group.element.getBBox();
-            }
-
+            bBox = series.seriesBox();
             series.parentNodeRadius =
                 Math.min(
                     Math.max(
@@ -1122,16 +1158,7 @@ seriesType(
                 return b[2] - a[2];
             });
 
-            if (sortedArr.length === 1) {
-                // if length is 1,return only one bubble
-                arr = [
-                    0, 0,
-                    sortedArr[0][0],
-                    sortedArr[0][1],
-                    sortedArr[0][2]
-                ];
-            } else if (sortedArr.length) {
-
+            if (sortedArr.length) {
                 // create first bubble in the middle of the chart
                 bubblePos.push([
                     [
@@ -1142,74 +1169,78 @@ seriesType(
                         sortedArr[0][4]
                     ] // point index
                 ]); // 0 level bubble
+                if (sortedArr.length > 1) {
+
+                    bubblePos.push([
+                        [
+                            0,
+                            0 - sortedArr[1][2] - sortedArr[0][2],
+                            // move bubble above first one
+                            sortedArr[1][2],
+                            sortedArr[1][3],
+                            sortedArr[1][4]
+                        ]
+                    ]); // 1 level 1st bubble
+
+                    // first two already positioned so starting from 2
+                    for (i = 2; i < sortedArr.length; i++) {
+                        sortedArr[i][2] = sortedArr[i][2] || 1;
+                        // in case if radius is calculated as 0.
+                        calculatedBubble = positionBubble(
+                            bubblePos[stage][j],
+                            bubblePos[stage - 1][k],
+                            sortedArr[i]
+                        ); // calculate initial bubble position
 
-                bubblePos.push([
-                    [
-                        0,
-                        0 - sortedArr[1][2] - sortedArr[0][2],
-                        // move bubble above first one
-                        sortedArr[1][2],
-                        sortedArr[1][3],
-                        sortedArr[1][4]
-                    ]
-                ]); // 1 level 1st bubble
-
-                // first two already positioned so starting from 2
-                for (i = 2; i < sortedArr.length; i++) {
-                    sortedArr[i][2] = sortedArr[i][2] || 1;
-                    // in case if radius is calculated as 0.
-                    calculatedBubble = positionBubble(
-                        bubblePos[stage][j],
-                        bubblePos[stage - 1][k],
-                        sortedArr[i]
-                    ); // calculate initial bubble position
-
-                    if (checkOverlap(calculatedBubble, bubblePos[stage][0])) {
-                        /* if new bubble is overlapping with first bubble
-                         * in current level (stage)
-                         */
-
-                        bubblePos.push([]);
-                        k = 0;
-                        /* reset index of bubble, used for
-                         * positioning the bubbles
-                         * around it, we are starting from first bubble in next
-                         * stage because we are changing level to higher
-                         */
-                        bubblePos[stage + 1].push(
-                            positionBubble(
-                                bubblePos[stage][j],
-                                bubblePos[stage][0],
-                                sortedArr[i]
-                            )
-                        );
-                        // (last added bubble, 1. from curr stage, new bubble)
-                        stage++; // the new level is created, above current one
-                        j = 0; // set the index of bubble in current level to 0
-                    } else if (
-                        stage > 1 && bubblePos[stage - 1][k + 1] &&
-                        checkOverlap(
-                            calculatedBubble, bubblePos[stage - 1][k + 1]
-                        )
-                    ) {
-                        /* if new bubble is overlapping with one of the previous
-                         * stage bubbles, it means that - bubble, used for
-                         * positioning the bubbles around it has changed
-                         * so we need to recalculate it
-                         */
-                        k++;
-                        bubblePos[stage].push(
-                            positionBubble(
-                                bubblePos[stage][j],
-                                bubblePos[stage - 1][k],
-                                sortedArr[i]
+                        if (
+                            checkOverlap(calculatedBubble, bubblePos[stage][0])
+                        ) {
+                            /* if new bubble is overlapping with first bubble
+                             * in current level (stage)
+                             */
+
+                            bubblePos.push([]);
+                            k = 0;
+                            /* reset index of bubble, used for
+                             * positioning the bubbles around it,
+                             * we are starting from first bubble in next
+                             * stage because we are changing level to higher
+                             */
+                            bubblePos[stage + 1].push(
+                                positionBubble(
+                                    bubblePos[stage][j],
+                                    bubblePos[stage][0],
+                                    sortedArr[i]
+                                )
+                            );
+                            // (last bubble, 1. from curr stage, new bubble)
+                            stage++; // the new level is created, above current
+                            j = 0; // set the index of bubble in curr level to 0
+                        } else if (
+                            stage > 1 && bubblePos[stage - 1][k + 1] &&
+                            checkOverlap(
+                                calculatedBubble, bubblePos[stage - 1][k + 1]
                             )
-                        );
-                        // (last added bubble, prev stage bubble, new bubble)
-                        j++;
-                    } else { // simply add calculated bubble
-                        j++;
-                        bubblePos[stage].push(calculatedBubble);
+                        ) {
+                            /* if new bubble is overlapping with one of the prev
+                             * stage bubbles, it means that - bubble, used for
+                             * positioning the bubbles around it has changed
+                             * so we need to recalculate it
+                             */
+                            k++;
+                            bubblePos[stage].push(
+                                positionBubble(
+                                    bubblePos[stage][j],
+                                    bubblePos[stage - 1][k],
+                                    sortedArr[i]
+                                )
+                            );
+                            // (last bubble, prev stage bubble, new bubble)
+                            j++;
+                        } else { // simply add calculated bubble
+                            j++;
+                            bubblePos[stage].push(calculatedBubble);
+                        }
                     }
                 }
                 series.chart.stages = bubblePos;
@@ -1221,7 +1252,6 @@ seriesType(
 
                 series.resizeRadius();
                 arr = series.chart.rawPositions;
-
             }
             return arr;
         },
@@ -1527,7 +1557,14 @@ addEvent(Chart, 'beforeRedraw', function () {
  * @apioption series.packedbubble.data
  */
 
+/**
+ * @type      {Highcharts.SeriesPackedBubbleDataLabelsOptionsObject|Array<Highcharts.SeriesPackedBubbleDataLabelsOptionsObject>}
+ * @product   highcharts
+ * @apioption series.packedbubble.data.dataLabels
+ */
+
 /**
  * @excluding enabled,enabledThreshold,height,radius,width
+ * @product   highcharts
  * @apioption series.packedbubble.marker
  */

package/es-modules/parts-more/RadialAxis.js

@@ -322,8 +322,8 @@ radialAxisMixin = {
 
         // Polygonal plot bands
         if (this.options.gridLineInterpolation === 'polygon') {
-            ret = this.getPlotLinePath(from).concat(
-                this.getPlotLinePath(to, true)
+            ret = this.getPlotLinePath({ value: from }).concat(
+                this.getPlotLinePath({ value: to, reverse: true })
             );
 
         // Circular grid bands
@@ -408,10 +408,12 @@ radialAxisMixin = {
     /* *
      * Find the path for plot lines perpendicular to the radial axis.
      */
-    getPlotLinePath: function (value, reverse) {
+    getPlotLinePath: function (options) {
         var axis = this,
             center = axis.center,
             chart = axis.chart,
+            value = options.value,
+            reverse = options.reverse,
             end = axis.getPosition(value),
             xAxis,
             xy,
@@ -462,6 +464,7 @@ radialAxisMixin = {
             });
 
         }
+
         return ret;
     },
 
@@ -605,6 +608,7 @@ addEvent(Tick, 'afterGetPosition', function (e) {
 addEvent(Tick, 'afterGetLabelPosition', function (e) {
     var axis = this.axis,
         label = this.label,
+        labelBBox = label.getBBox(),
         labelOptions = axis.options.labels,
         optionsY = labelOptions.y,
         ret,
@@ -613,11 +617,27 @@ addEvent(Tick, 'afterGetLabelPosition', function (e) {
         angle = (
             (axis.translate(this.pos) + axis.startAngleRad + Math.PI / 2) /
             Math.PI * 180
-        ) % 360;
+        ) % 360,
+        correctAngle = Math.round(angle),
+        labelDir = 'end', // Direction of the label 'start' or 'end'
+        reducedAngle1 = correctAngle < 0 ?
+            correctAngle + 360 : correctAngle,
+        reducedAngle2 = reducedAngle1,
+        translateY = 0,
+        translateX = 0,
+        labelYPosCorrection =
+            labelOptions.y === null ? -labelBBox.height * 0.3 : 0;
 
     if (axis.isRadial) { // Both X and Y axes in a polar chart
-        ret = axis.getPosition(this.pos, (axis.center[2] / 2) +
-            pick(labelOptions.distance, -25));
+        ret = axis.getPosition(
+            this.pos,
+            (axis.center[2] / 2) +
+                H.relativeLength(
+                    pick(labelOptions.distance, -25),
+                    axis.center[2] / 2,
+                    -axis.center[2] / 2
+                )
+        );
 
         // Automatically rotated
         if (labelOptions.rotation === 'auto') {
@@ -630,7 +650,7 @@ addEvent(Tick, 'afterGetLabelPosition', function (e) {
             optionsY = (
                 axis.chart.renderer
                     .fontMetrics(label.styles && label.styles.fontSize).b -
-                label.getBBox().height / 2
+                    labelBBox.height / 2
             );
         }
 
@@ -638,7 +658,7 @@ addEvent(Tick, 'afterGetLabelPosition', function (e) {
         if (align === null) {
             if (axis.isCircular) { // Y axis
                 if (
-                    this.label.getBBox().width >
+                    labelBBox.width >
                     axis.len * axis.tickInterval / (axis.max - axis.min)
                 ) { // #3506
                     centerSlot = 0;
@@ -661,6 +681,80 @@ addEvent(Tick, 'afterGetLabelPosition', function (e) {
             });
         }
 
+        // Auto alignment for solid-gauges with two labels (#10635)
+        if (
+            align === 'auto' &&
+            axis.tickPositions.length === 2 &&
+            axis.isCircular
+        ) {
+            // Angles reduced to 0 - 90 or 180 - 270
+            if (reducedAngle1 > 90 && reducedAngle1 < 180) {
+                reducedAngle1 = 180 - reducedAngle1;
+            } else if (reducedAngle1 > 270 && reducedAngle1 <= 360) {
+                reducedAngle1 = 540 - reducedAngle1;
+            }
+
+            // Angles reduced to 0 - 180
+            if (reducedAngle2 > 180 && reducedAngle2 <= 360) {
+                reducedAngle2 = 360 - reducedAngle2;
+            }
+
+            if (
+                (axis.pane.options.startAngle === correctAngle) ||
+                (axis.pane.options.startAngle === correctAngle + 360) ||
+                (axis.pane.options.startAngle === correctAngle - 360)
+            ) {
+                labelDir = 'start';
+            }
+
+            if (
+                (correctAngle >= -90 && correctAngle <= 90) ||
+                (correctAngle >= -360 && correctAngle <= -270) ||
+                (correctAngle >= 270 && correctAngle <= 360)
+            ) {
+                align = (labelDir === 'start') ? 'right' : 'left';
+            } else {
+                align = (labelDir === 'start') ? 'left' : 'right';
+            }
+
+            // For angles beetwen (90 + n * 180) +- 20
+            if (reducedAngle2 > 70 && reducedAngle2 < 110) {
+                align = 'center';
+            }
+
+            // auto Y translation
+            if (
+                reducedAngle1 < 15 ||
+                (reducedAngle1 >= 180 && reducedAngle1 < 195)
+            ) {
+                translateY = labelBBox.height * 0.3;
+            } else if (reducedAngle1 >= 15 && reducedAngle1 <= 35) {
+                translateY = labelDir === 'start' ?
+                    0 : labelBBox.height * 0.75;
+            } else if (reducedAngle1 >= 195 && reducedAngle1 <= 215) {
+                translateY = labelDir === 'start' ?
+                    labelBBox.height * 0.75 : 0;
+            } else if (reducedAngle1 > 35 && reducedAngle1 <= 90) {
+                translateY = labelDir === 'start' ?
+                    -labelBBox.height * 0.25 : labelBBox.height;
+            } else if (reducedAngle1 > 215 && reducedAngle1 <= 270) {
+                translateY = labelDir === 'start' ?
+                    labelBBox.height : -labelBBox.height * 0.25;
+            }
+
+            // auto X translation
+            if (reducedAngle2 < 15) {
+                translateX = labelDir === 'start' ?
+                    -labelBBox.height * 0.15 : labelBBox.height * 0.15;
+            } else if (reducedAngle2 > 165 && reducedAngle2 <= 180) {
+                translateX = labelDir === 'start' ?
+                    labelBBox.height * 0.15 : -labelBBox.height * 0.15;
+            }
+
+            label.attr({ align: align });
+            label.translate(translateX, translateY + labelYPosCorrection);
+        }
+
         e.pos.x = ret.x + labelOptions.x;
         e.pos.y = ret.y + optionsY;