highcharts 9.1.1 → 9.2.2

package/es-modules/Extensions/Themes/Skies.js

@@ -10,94 +10,122 @@
  *
  * */
 'use strict';
-import Highcharts from '../../Core/Globals.js';
 import D from '../../Core/DefaultOptions.js';
 var setOptions = D.setOptions;
-Highcharts.theme = {
-    colors: ['#514F78', '#42A07B', '#9B5E4A', '#72727F', '#1F949A',
-        '#82914E', '#86777F', '#42A07B'],
-    chart: {
-        className: 'skies',
-        borderWidth: 0,
-        plotShadow: true,
-        plotBackgroundImage: 'https://www.highcharts.com/samples/graphics/skies.jpg',
-        plotBackgroundColor: {
-            linearGradient: { x1: 0, y1: 0, x2: 1, y2: 1 },
-            stops: [
-                [0, 'rgba(255, 255, 255, 1)'],
-                [1, 'rgba(255, 255, 255, 0)']
-            ]
+/* *
+ *
+ *  Theme
+ *
+ * */
+var SkiesTheme;
+(function (SkiesTheme) {
+    /* *
+     *
+     *  Constants
+     *
+     * */
+    SkiesTheme.options = {
+        colors: ['#514F78', '#42A07B', '#9B5E4A', '#72727F', '#1F949A',
+            '#82914E', '#86777F', '#42A07B'],
+        chart: {
+            className: 'skies',
+            borderWidth: 0,
+            plotShadow: true,
+            plotBackgroundImage: 'https://www.highcharts.com/samples/graphics/skies.jpg',
+            plotBackgroundColor: {
+                linearGradient: { x1: 0, y1: 0, x2: 1, y2: 1 },
+                stops: [
+                    [0, 'rgba(255, 255, 255, 1)'],
+                    [1, 'rgba(255, 255, 255, 0)']
+                ]
+            },
+            plotBorderWidth: 1
         },
-        plotBorderWidth: 1
-    },
-    title: {
-        style: {
-            color: '#3E576F',
-            font: '16px Lucida Grande, Lucida Sans Unicode,' +
-                ' Verdana, Arial, Helvetica, sans-serif'
-        }
-    },
-    subtitle: {
-        style: {
-            color: '#6D869F',
-            font: '12px Lucida Grande, Lucida Sans Unicode,' +
-                ' Verdana, Arial, Helvetica, sans-serif'
-        }
-    },
-    xAxis: {
-        gridLineWidth: 0,
-        lineColor: '#C0D0E0',
-        tickColor: '#C0D0E0',
-        labels: {
+        title: {
             style: {
-                color: '#666',
-                fontWeight: 'bold'
+                color: '#3E576F',
+                font: '16px Lucida Grande, Lucida Sans Unicode,' +
+                    ' Verdana, Arial, Helvetica, sans-serif'
             }
         },
-        title: {
+        subtitle: {
             style: {
-                color: '#666',
+                color: '#6D869F',
                 font: '12px Lucida Grande, Lucida Sans Unicode,' +
                     ' Verdana, Arial, Helvetica, sans-serif'
             }
-        }
-    },
-    yAxis: {
-        alternateGridColor: 'rgba(255, 255, 255, .5)',
-        lineColor: '#C0D0E0',
-        tickColor: '#C0D0E0',
-        tickWidth: 1,
-        labels: {
-            style: {
-                color: '#666',
-                fontWeight: 'bold'
+        },
+        xAxis: {
+            gridLineWidth: 0,
+            lineColor: '#C0D0E0',
+            tickColor: '#C0D0E0',
+            labels: {
+                style: {
+                    color: '#666',
+                    fontWeight: 'bold'
+                }
+            },
+            title: {
+                style: {
+                    color: '#666',
+                    font: '12px Lucida Grande, Lucida Sans Unicode,' +
+                        ' Verdana, Arial, Helvetica, sans-serif'
+                }
             }
         },
-        title: {
-            style: {
-                color: '#666',
-                font: '12px Lucida Grande, Lucida Sans Unicode,' +
-                    ' Verdana, Arial, Helvetica, sans-serif'
+        yAxis: {
+            alternateGridColor: 'rgba(255, 255, 255, .5)',
+            lineColor: '#C0D0E0',
+            tickColor: '#C0D0E0',
+            tickWidth: 1,
+            labels: {
+                style: {
+                    color: '#666',
+                    fontWeight: 'bold'
+                }
+            },
+            title: {
+                style: {
+                    color: '#666',
+                    font: '12px Lucida Grande, Lucida Sans Unicode,' +
+                        ' Verdana, Arial, Helvetica, sans-serif'
+                }
             }
-        }
-    },
-    legend: {
-        itemStyle: {
-            font: '9pt Trebuchet MS, Verdana, sans-serif',
-            color: '#3E576F'
         },
-        itemHoverStyle: {
-            color: 'black'
+        legend: {
+            itemStyle: {
+                font: '9pt Trebuchet MS, Verdana, sans-serif',
+                color: '#3E576F'
+            },
+            itemHoverStyle: {
+                color: 'black'
+            },
+            itemHiddenStyle: {
+                color: 'silver'
+            }
         },
-        itemHiddenStyle: {
-            color: 'silver'
-        }
-    },
-    labels: {
-        style: {
-            color: '#3E576F'
+        labels: {
+            style: {
+                color: '#3E576F'
+            }
         }
+    };
+    /* *
+     *
+     *  Functions
+     *
+     * */
+    /**
+     * Apply the theme.
+     */
+    function apply() {
+        setOptions(SkiesTheme.options);
     }
-};
-// Apply the theme
-setOptions(Highcharts.theme);
+    SkiesTheme.apply = apply;
+})(SkiesTheme || (SkiesTheme = {}));
+/* *
+ *
+ *  Default Export
+ *
+ * */
+export default SkiesTheme;

package/es-modules/Extensions/Themes/Sunset.js

@@ -13,26 +13,54 @@
  *
  * */
 'use strict';
-import H from '../../Core/Globals.js';
 import D from '../../Core/DefaultOptions.js';
 var setOptions = D.setOptions;
-H.theme = {
-    colors: ['#FDD089', '#FF7F79', '#A0446E', '#251535'],
-    colorAxis: {
-        maxColor: '#60042E',
-        minColor: '#FDD089'
-    },
-    plotOptions: {
-        map: {
-            nullColor: '#fefefc'
-        }
-    },
-    navigator: {
-        series: {
-            color: '#FF7F79',
-            lineColor: '#A0446E'
+/* *
+ *
+ *  Theme
+ *
+ * */
+var SunsetTheme;
+(function (SunsetTheme) {
+    /* *
+     *
+     *  Constants
+     *
+     * */
+    SunsetTheme.options = {
+        colors: ['#FDD089', '#FF7F79', '#A0446E', '#251535'],
+        colorAxis: {
+            maxColor: '#60042E',
+            minColor: '#FDD089'
+        },
+        plotOptions: {
+            map: {
+                nullColor: '#fefefc'
+            }
+        },
+        navigator: {
+            series: {
+                color: '#FF7F79',
+                lineColor: '#A0446E'
+            }
         }
+    };
+    /* *
+     *
+     *  Functions
+     *
+     * */
+    /**
+     * Apply the theme.
+     */
+    function apply() {
+        setOptions(SunsetTheme.options);
     }
-};
-// Apply the theme
-setOptions(H.theme);
+    SunsetTheme.apply = apply;
+})(SunsetTheme || (SunsetTheme = {}));
+/* *
+ *
+ *  Default Export
+ *
+ * */
+export default SunsetTheme;

package/es-modules/Mixins/ColorSeries.js

@@ -42,7 +42,6 @@ var colorPointMixin = {
  */
 var colorSeriesMixin = {
     optionalAxis: 'colorAxis',
-    colorAxis: 0,
     /* eslint-disable valid-jsdoc */
     /**
      * In choropleth maps, the color is a result of the value, so this needs

package/es-modules/Mixins/MultipleLines.js

@@ -100,11 +100,17 @@ var multipleLinesMixin = {
      */
     translate: function () {
         var indicator = this, pointArrayMap = indicator.pointArrayMap, LinesNames = [], value;
+        var modfidyValue = indicator.modifyValue;
         LinesNames = indicator.getTranslatedLinesNames();
         SMA.prototype.translate.apply(indicator, arguments);
         indicator.points.forEach(function (point) {
             pointArrayMap.forEach(function (propertyName, i) {
                 value = point[propertyName];
+                // If the modifier, like for example compare exists,
+                // modified the original value by that method, #15867.
+                if (modfidyValue) {
+                    value = modfidyValue.call(indicator, value);
+                }
                 if (value !== null) {
                     point[LinesNames[i]] = indicator.yAxis.toPixels(value, true);
                 }

package/es-modules/Mixins/TreeSeries.js

@@ -43,9 +43,9 @@ var setTreeValues = function setTreeValues(tree, options) {
             childrenTotal += child.val;
         }
     });
-    tree.visible = childrenTotal > 0 || tree.visible;
     // Set the values
     value = pick(optionsPoint.value, childrenTotal);
+    tree.visible = value >= 0 && (childrenTotal > 0 || tree.visible);
     tree.children = children;
     tree.childrenTotal = childrenTotal;
     tree.isLeaf = tree.visible && !childrenTotal;

package/es-modules/Series/Area/AreaSeries.js

@@ -23,7 +23,7 @@ var __extends = (this && this.__extends) || (function () {
 })();
 import Color from '../../Core/Color/Color.js';
 var color = Color.parse;
-import LegendSymbolMixin from '../../Mixins/LegendSymbol.js';
+import LegendSymbol from '../../Core/Legend/LegendSymbol.js';
 import SeriesRegistry from '../../Core/Series/SeriesRegistry.js';
 var LineSeries = SeriesRegistry.seriesTypes.line;
 import U from '../../Core/Utilities.js';
@@ -458,7 +458,7 @@ var AreaSeries = /** @class */ (function (_super) {
 }(LineSeries));
 extend(AreaSeries.prototype, {
     singleStacks: false,
-    drawLegendSymbol: LegendSymbolMixin.drawRectangle
+    drawLegendSymbol: LegendSymbol.drawRectangle
 });
 SeriesRegistry.registerSeriesType('area', AreaSeries);
 /* *

package/es-modules/Series/AreaSpline/AreaSplineSeries.js

@@ -24,7 +24,7 @@ var __extends = (this && this.__extends) || (function () {
 import AreaSeries from '../Area/AreaSeries.js';
 var areaProto = AreaSeries.prototype;
 import SplineSeries from '../Spline/SplineSeries.js';
-import LegendSymbolMixin from '../../Mixins/LegendSymbol.js';
+import LegendSymbol from '../../Core/Legend/LegendSymbol.js';
 import SeriesRegistry from '../../Core/Series/SeriesRegistry.js';
 import U from '../../Core/Utilities.js';
 var extend = U.extend, merge = U.merge;
@@ -102,7 +102,7 @@ extend(AreaSplineSeries.prototype, {
     getGraphPath: areaProto.getGraphPath,
     getStackPoints: areaProto.getStackPoints,
     drawGraph: areaProto.drawGraph,
-    drawLegendSymbol: LegendSymbolMixin.drawRectangle
+    drawLegendSymbol: LegendSymbol.drawRectangle
 });
 SeriesRegistry.registerSeriesType('areaspline', AreaSplineSeries);
 /* *

package/es-modules/Series/Bubble/BubbleLegendComposition.js

@@ -0,0 +1,279 @@
+/* *
+ *
+ *  (c) 2010-2021 Highsoft AS
+ *
+ *  Author: Paweł Potaczek
+ *
+ *  License: www.highcharts.com/license
+ *
+ *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+ *
+ * */
+'use strict';
+import BubbleLegendDefaults from './BubbleLegendDefaults.js';
+import BubbleLegendItem from './BubbleLegendItem.js';
+import D from '../../Core/DefaultOptions.js';
+var setOptions = D.setOptions;
+import U from '../../Core/Utilities.js';
+var addEvent = U.addEvent, objectEach = U.objectEach, wrap = U.wrap;
+/* *
+ *
+ *  Namespace
+ *
+ * */
+var BubbleLegendComposition;
+(function (BubbleLegendComposition) {
+    /* *
+     *
+     *  Constants
+     *
+     * */
+    var composedClasses = [];
+    /* *
+     *
+     *  Functions
+     *
+     * */
+    /* eslint-disable valid-jsdoc */
+    /**
+     * If ranges are not specified, determine ranges from rendered bubble series
+     * and render legend again.
+     */
+    function chartDrawChartBox(proceed, options, callback) {
+        var chart = this, legend = chart.legend, bubbleSeries = getVisibleBubbleSeriesIndex(chart) >= 0;
+        var bubbleLegendOptions, bubbleSizes;
+        if (legend && legend.options.enabled && legend.bubbleLegend &&
+            legend.options.bubbleLegend.autoRanges && bubbleSeries) {
+            bubbleLegendOptions = legend.bubbleLegend.options;
+            bubbleSizes = legend.bubbleLegend.predictBubbleSizes();
+            legend.bubbleLegend.updateRanges(bubbleSizes[0], bubbleSizes[1]);
+            // Disable animation on init
+            if (!bubbleLegendOptions.placed) {
+                legend.group.placed = false;
+                legend.allItems.forEach(function (item) {
+                    item.legendGroup.translateY = null;
+                });
+            }
+            // Create legend with bubbleLegend
+            legend.render();
+            chart.getMargins();
+            chart.axes.forEach(function (axis) {
+                if (axis.visible) { // #11448
+                    axis.render();
+                }
+                if (!bubbleLegendOptions.placed) {
+                    axis.setScale();
+                    axis.updateNames();
+                    // Disable axis animation on init
+                    objectEach(axis.ticks, function (tick) {
+                        tick.isNew = true;
+                        tick.isNewLabel = true;
+                    });
+                }
+            });
+            bubbleLegendOptions.placed = true;
+            // After recalculate axes, calculate margins again.
+            chart.getMargins();
+            // Call default 'drawChartBox' method.
+            proceed.call(chart, options, callback);
+            // Check bubble legend sizes and correct them if necessary.
+            legend.bubbleLegend.correctSizes();
+            // Correct items positions with different dimensions in legend.
+            retranslateItems(legend, getLinesHeights(legend));
+        }
+        else {
+            proceed.call(chart, options, callback);
+            // Allow color change on static bubble legend after click on legend
+            if (legend && legend.options.enabled && legend.bubbleLegend) {
+                legend.render();
+                retranslateItems(legend, getLinesHeights(legend));
+            }
+        }
+    }
+    /**
+     * Compose classes for use with Bubble series.
+     * @private
+     *
+     * @param {Highcharts.Chart} ChartClass
+     * Core chart class to use with Bubble series.
+     *
+     * @param {Highcharts.Legend} LegendClass
+     * Core legend class to use with Bubble series.
+     *
+     * @param {Highcharts.Series} SeriesClass
+     * Core series class to use with Bubble series.
+     */
+    function compose(ChartClass, LegendClass, SeriesClass) {
+        if (composedClasses.indexOf(ChartClass) === -1) {
+            composedClasses.push(ChartClass);
+            setOptions({
+                // Set default bubble legend options
+                legend: {
+                    bubbleLegend: BubbleLegendDefaults
+                }
+            });
+            wrap(ChartClass.prototype, 'drawChartBox', chartDrawChartBox);
+        }
+        if (composedClasses.indexOf(LegendClass) === -1) {
+            composedClasses.push(LegendClass);
+            addEvent(LegendClass, 'afterGetAllItems', onLegendAfterGetAllItems);
+        }
+        if (composedClasses.indexOf(SeriesClass) === -1) {
+            composedClasses.push(SeriesClass);
+            addEvent(SeriesClass, 'legendItemClick', onSeriesLegendItemClick);
+        }
+    }
+    BubbleLegendComposition.compose = compose;
+    /**
+     * Check if there is at least one visible bubble series.
+     *
+     * @private
+     * @function getVisibleBubbleSeriesIndex
+     * @param {Highcharts.Chart} chart
+     * Chart to check.
+     * @return {number}
+     * First visible bubble series index
+     */
+    function getVisibleBubbleSeriesIndex(chart) {
+        var series = chart.series;
+        var i = 0;
+        while (i < series.length) {
+            if (series[i] &&
+                series[i].isBubble &&
+                series[i].visible &&
+                series[i].zData.length) {
+                return i;
+            }
+            i++;
+        }
+        return -1;
+    }
+    /**
+     * Calculate height for each row in legend.
+     *
+     * @private
+     * @function getLinesHeights
+     *
+     * @param {Highcharts.Legend} legend
+     * Legend to calculate from.
+     *
+     * @return {Array<Highcharts.Dictionary<number>>}
+     * Informations about line height and items amount
+     */
+    function getLinesHeights(legend) {
+        var items = legend.allItems, lines = [], length = items.length;
+        var lastLine, i = 0, j = 0;
+        for (i = 0; i < length; i++) {
+            if (items[i].legendItemHeight) {
+                // for bubbleLegend
+                items[i].itemHeight = items[i].legendItemHeight;
+            }
+            if ( // Line break
+            items[i] === items[length - 1] ||
+                items[i + 1] &&
+                    items[i]._legendItemPos[1] !==
+                        items[i + 1]._legendItemPos[1]) {
+                lines.push({ height: 0 });
+                lastLine = lines[lines.length - 1];
+                // Find the highest item in line
+                for (j; j <= i; j++) {
+                    if (items[j].itemHeight > lastLine.height) {
+                        lastLine.height = items[j].itemHeight;
+                    }
+                }
+                lastLine.step = i;
+            }
+        }
+        return lines;
+    }
+    /**
+     * Start the bubble legend creation process.
+     */
+    function onLegendAfterGetAllItems(e) {
+        var legend = this, bubbleLegend = legend.bubbleLegend, legendOptions = legend.options, options = legendOptions.bubbleLegend, bubbleSeriesIndex = getVisibleBubbleSeriesIndex(legend.chart);
+        // Remove unnecessary element
+        if (bubbleLegend && bubbleLegend.ranges && bubbleLegend.ranges.length) {
+            // Allow change the way of calculating ranges in update
+            if (options.ranges.length) {
+                options.autoRanges =
+                    !!options.ranges[0].autoRanges;
+            }
+            // Update bubbleLegend dimensions in each redraw
+            legend.destroyItem(bubbleLegend);
+        }
+        // Create bubble legend
+        if (bubbleSeriesIndex >= 0 &&
+            legendOptions.enabled &&
+            options.enabled) {
+            options.seriesIndex = bubbleSeriesIndex;
+            legend.bubbleLegend = new BubbleLegendItem(options, legend);
+            legend.bubbleLegend.addToLegend(e.allItems);
+        }
+    }
+    /**
+     * Toggle bubble legend depending on the visible status of bubble series.
+     */
+    function onSeriesLegendItemClick() {
+        var series = this, chart = series.chart, visible = series.visible, legend = series.chart.legend;
+        var status;
+        if (legend && legend.bubbleLegend) {
+            // Temporary correct 'visible' property
+            series.visible = !visible;
+            // Save future status for getRanges method
+            series.ignoreSeries = visible;
+            // Check if at lest one bubble series is visible
+            status = getVisibleBubbleSeriesIndex(chart) >= 0;
+            // Hide bubble legend if all bubble series are disabled
+            if (legend.bubbleLegend.visible !== status) {
+                // Show or hide bubble legend
+                legend.update({
+                    bubbleLegend: { enabled: status }
+                });
+                legend.bubbleLegend.visible = status; // Restore default status
+            }
+            series.visible = visible;
+        }
+    }
+    /**
+     * Correct legend items translation in case of different elements heights.
+     *
+     * @private
+     * @function Highcharts.Legend#retranslateItems
+     *
+     * @param {Highcharts.Legend} legend
+     * Legend to translate in.
+     *
+     * @param {Array<Highcharts.Dictionary<number>>} lines
+     * Informations about line height and items amount
+     */
+    function retranslateItems(legend, lines) {
+        var items = legend.allItems, rtl = legend.options.rtl;
+        var orgTranslateX, orgTranslateY, movementX, actualLine = 0;
+        items.forEach(function (item, index) {
+            orgTranslateX = item.legendGroup.translateX;
+            orgTranslateY = item._legendItemPos[1];
+            movementX = item.movementX;
+            if (movementX || (rtl && item.ranges)) {
+                movementX = rtl ?
+                    orgTranslateX - item.options.maxSize / 2 :
+                    orgTranslateX + movementX;
+                item.legendGroup.attr({ translateX: movementX });
+            }
+            if (index > lines[actualLine].step) {
+                actualLine++;
+            }
+            item.legendGroup.attr({
+                translateY: Math.round(orgTranslateY + lines[actualLine].height / 2)
+            });
+            item._legendItemPos[1] = orgTranslateY +
+                lines[actualLine].height / 2;
+        });
+    }
+    /* eslint-disable valid-jsdoc */
+})(BubbleLegendComposition || (BubbleLegendComposition = {}));
+/* *
+ *
+ *  Default Export
+ *
+ * */
+export default BubbleLegendComposition;