highcharts 8.1.0 → 8.2.2

package/es-modules/{parts → Core/Axis}/OrdinalAxis.js

@@ -9,240 +9,52 @@
  * */
 'use strict';
 import Axis from './Axis.js';
-import H from './Globals.js';
-import U from './Utilities.js';
+import H from '../Globals.js';
+import CartesianSeries from '../Series/CartesianSeries.js';
+import U from '../Utilities.js';
 var addEvent = U.addEvent, css = U.css, defined = U.defined, pick = U.pick, timeUnits = U.timeUnits;
-import './Chart.js';
+import Chart from '../Chart/Chart.js';
 // Has a dependency on Navigator due to the use of Axis.toFixedRange
-import './Navigator.js';
-import './Series.js';
-var Chart = H.Chart, Series = H.Series;
-/* eslint-disable valid-jsdoc */
-var OrdinalAxisAdditions = /** @class */ (function () {
-    /* *
-     *
-     *  Constructors
-     *
-     * */
-    /**
-     * @private
-     */
-    function OrdinalAxisAdditions(axis) {
-        this.index = {};
-        this.axis = axis;
-    }
+import '../Navigator.js';
+/**
+ * Extends the axis with ordinal support.
+ * @private
+ */
+var OrdinalAxis;
+(function (OrdinalAxis) {
     /* *
      *
-     *  Functions
+     *  Classes
      *
      * */
     /**
-     * Get the ordinal positions for the entire data set. This is necessary
-     * in chart panning because we need to find out what points or data
-     * groups are available outside the visible range. When a panning
-     * operation starts, if an index for the given grouping does not exists,
-     * it is created and cached. This index is deleted on updated data, so
-     * it will be regenerated the next time a panning operation starts.
-     *
-     * @private
-     */
-    OrdinalAxisAdditions.prototype.getExtendedPositions = function () {
-        var ordinal = this, axis = ordinal.axis, axisProto = axis.constructor.prototype, chart = axis.chart, grouping = axis.series[0].currentDataGrouping, ordinalIndex = ordinal.index, key = grouping ?
-            grouping.count + grouping.unitName :
-            'raw', overscroll = axis.options.overscroll, extremes = axis.getExtremes(), fakeAxis, fakeSeries;
-        // If this is the first time, or the ordinal index is deleted by
-        // updatedData,
-        // create it.
-        if (!ordinalIndex) {
-            ordinalIndex = ordinal.index = {};
-        }
-        if (!ordinalIndex[key]) {
-            // Create a fake axis object where the extended ordinal
-            // positions are emulated
-            fakeAxis = {
-                series: [],
-                chart: chart,
-                getExtremes: function () {
-                    return {
-                        min: extremes.dataMin,
-                        max: extremes.dataMax + overscroll
-                    };
-                },
-                options: {
-                    ordinal: true
-                },
-                ordinal: {},
-                ordinal2lin: axisProto.ordinal2lin,
-                val2lin: axisProto.val2lin // #2590
-            };
-            fakeAxis.ordinal.axis = fakeAxis;
-            // Add the fake series to hold the full data, then apply
-            // processData to it
-            axis.series.forEach(function (series) {
-                fakeSeries = {
-                    xAxis: fakeAxis,
-                    xData: series.xData.slice(),
-                    chart: chart,
-                    destroyGroupedData: H.noop,
-                    getProcessedData: H.Series.prototype.getProcessedData
-                };
-                fakeSeries.xData = fakeSeries.xData.concat(ordinal.getOverscrollPositions());
-                fakeSeries.options = {
-                    dataGrouping: grouping ? {
-                        enabled: true,
-                        forced: true,
-                        // doesn't matter which, use the fastest
-                        approximation: 'open',
-                        units: [[
-                                grouping.unitName,
-                                [grouping.count]
-                            ]]
-                    } : {
-                        enabled: false
-                    }
-                };
-                series.processData.apply(fakeSeries);
-                fakeAxis.series.push(fakeSeries);
-            });
-            // Run beforeSetTickPositions to compute the ordinalPositions
-            axis.beforeSetTickPositions.apply(fakeAxis);
-            // Cache it
-            ordinalIndex[key] = fakeAxis.ordinal.positions;
-        }
-        return ordinalIndex[key];
-    };
-    /**
-     * Find the factor to estimate how wide the plot area would have been if
-     * ordinal gaps were included. This value is used to compute an imagined
-     * plot width in order to establish the data grouping interval.
-     *
-     * A real world case is the intraday-candlestick example. Without this
-     * logic, it would show the correct data grouping when viewing a range
-     * within each day, but once moving the range to include the gap between
-     * two days, the interval would include the cut-away night hours and the
-     * data grouping would be wrong. So the below method tries to compensate
-     * by identifying the most common point interval, in this case days.
-     *
-     * An opposite case is presented in issue #718. We have a long array of
-     * daily data, then one point is appended one hour after the last point.
-     * We expect the data grouping not to change.
-     *
-     * In the future, if we find cases where this estimation doesn't work
-     * optimally, we might need to add a second pass to the data grouping
-     * logic, where we do another run with a greater interval if the number
-     * of data groups is more than a certain fraction of the desired group
-     * count.
-     *
-     * @private
-     */
-    OrdinalAxisAdditions.prototype.getGroupIntervalFactor = function (xMin, xMax, series) {
-        var ordinal = this, axis = ordinal.axis, i, processedXData = series.processedXData, len = processedXData.length, distances = [], median, groupIntervalFactor = ordinal.groupIntervalFactor;
-        // Only do this computation for the first series, let the other
-        // inherit it (#2416)
-        if (!groupIntervalFactor) {
-            // Register all the distances in an array
-            for (i = 0; i < len - 1; i++) {
-                distances[i] =
-                    processedXData[i + 1] - processedXData[i];
-            }
-            // Sort them and find the median
-            distances.sort(function (a, b) {
-                return a - b;
-            });
-            median = distances[Math.floor(len / 2)];
-            // Compensate for series that don't extend through the entire
-            // axis extent. #1675.
-            xMin = Math.max(xMin, processedXData[0]);
-            xMax = Math.min(xMax, processedXData[len - 1]);
-            ordinal.groupIntervalFactor = groupIntervalFactor =
-                (len * median) / (xMax - xMin);
-        }
-        // Return the factor needed for data grouping
-        return groupIntervalFactor;
-    };
-    /**
-     * Get ticks for an ordinal axis within a range where points don't
-     * exist. It is required when overscroll is enabled. We can't base on
-     * points, because we may not have any, so we use approximated
-     * pointRange and generate these ticks between Axis.dataMax,
-     * Axis.dataMax + Axis.overscroll evenly spaced. Used in panning and
-     * navigator scrolling.
-     *
      * @private
      */
-    OrdinalAxisAdditions.prototype.getOverscrollPositions = function () {
-        var ordinal = this, axis = ordinal.axis, extraRange = axis.options.overscroll, distance = ordinal.overscrollPointsRange, positions = [], max = axis.dataMax;
-        if (defined(distance)) {
-            // Max + pointRange because we need to scroll to the last
-            positions.push(max);
-            while (max <= axis.dataMax + extraRange) {
-                max += distance;
-                positions.push(max);
-            }
-        }
-        return positions;
-    };
-    /**
-     * Make the tick intervals closer because the ordinal gaps make the
-     * ticks spread out or cluster.
-     *
-     * @private
-     */
-    OrdinalAxisAdditions.prototype.postProcessTickInterval = function (tickInterval) {
-        // Problem: https://jsfiddle.net/highcharts/FQm4E/1/
-        // This is a case where this algorithm doesn't work optimally. In
-        // this case, the tick labels are spread out per week, but all the
-        // gaps reside within weeks. So we have a situation where the labels
-        // are courser than the ordinal gaps, and thus the tick interval
-        // should not be altered.
-        var ordinal = this, axis = ordinal.axis, ordinalSlope = ordinal.slope, ret;
-        if (ordinalSlope) {
-            if (!axis.options.breaks) {
-                ret = tickInterval / (ordinalSlope / axis.closestPointRange);
-            }
-            else {
-                ret = axis.closestPointRange || tickInterval; // #7275
-            }
-        }
-        else {
-            ret = tickInterval;
+    var Composition = /** @class */ (function () {
+        /* *
+         *
+         *  Constructors
+         *
+         * */
+        /**
+         * @private
+         */
+        function Composition(axis) {
+            this.index = {};
+            this.axis = axis;
         }
-        return ret;
-    };
-    return OrdinalAxisAdditions;
-}());
-/**
- * Extends the axis with ordinal support.
- *
- * @private
- */
-var OrdinalAxis = /** @class */ (function () {
-    function OrdinalAxis() {
-    }
-    /**
-     * Extends the axis with ordinal support.
-     *
-     * @private
-     *
-     * @param AxisClass
-     * Axis class to extend.
-     *
-     * @param ChartClass
-     * Chart class to use.
-     *
-     * @param SeriesClass
-     * Series class to use.
-     */
-    OrdinalAxis.compose = function (AxisClass, ChartClass, SeriesClass) {
-        AxisClass.keepProps.push('ordinal');
-        var axisProto = AxisClass.prototype;
+        /* *
+        *
+        *  Functions
+        *
+        * */
         /**
          * Calculate the ordinal positions before tick positions are calculated.
          *
          * @private
          */
-        axisProto.beforeSetTickPositions = function () {
-            var axis = this, ordinal = axis.ordinal, len, ordinalPositions = [], uniqueOrdinalPositions, useOrdinal = false, dist, extremes = axis.getExtremes(), min = extremes.min, max = extremes.max, minIndex, maxIndex, slope, hasBreaks = axis.isXAxis && !!axis.options.breaks, isOrdinal = axis.options.ordinal, overscrollPointsRange = Number.MAX_VALUE, ignoreHiddenSeries = axis.chart.options.chart.ignoreHiddenSeries, i, hasBoostedSeries;
+        Composition.prototype.beforeSetTickPositions = function () {
+            var axis = this.axis, ordinal = axis.ordinal, len, ordinalPositions = [], uniqueOrdinalPositions, useOrdinal = false, dist, extremes = axis.getExtremes(), min = extremes.min, max = extremes.max, minIndex, maxIndex, slope, hasBreaks = axis.isXAxis && !!axis.options.breaks, isOrdinal = axis.options.ordinal, overscrollPointsRange = Number.MAX_VALUE, ignoreHiddenSeries = axis.chart.options.chart.ignoreHiddenSeries, i, hasBoostedSeries;
             // Apply the ordinal logic
             if (isOrdinal || hasBreaks) { // #4167 YAxis is never ordinal ?
                 axis.series.forEach(function (series, i) {
@@ -358,6 +170,204 @@ var OrdinalAxis = /** @class */ (function () {
             axis.isOrdinal = isOrdinal && useOrdinal; // #3818, #4196, #4926
             ordinal.groupIntervalFactor = null; // reset for next run
         };
+        /**
+         * Get the ordinal positions for the entire data set. This is necessary
+         * in chart panning because we need to find out what points or data
+         * groups are available outside the visible range. When a panning
+         * operation starts, if an index for the given grouping does not exists,
+         * it is created and cached. This index is deleted on updated data, so
+         * it will be regenerated the next time a panning operation starts.
+         *
+         * @private
+         */
+        Composition.prototype.getExtendedPositions = function () {
+            var ordinal = this, axis = ordinal.axis, axisProto = axis.constructor.prototype, chart = axis.chart, grouping = axis.series[0].currentDataGrouping, ordinalIndex = ordinal.index, key = grouping ?
+                grouping.count + grouping.unitName :
+                'raw', overscroll = axis.options.overscroll, extremes = axis.getExtremes(), fakeAxis, fakeSeries;
+            // If this is the first time, or the ordinal index is deleted by
+            // updatedData,
+            // create it.
+            if (!ordinalIndex) {
+                ordinalIndex = ordinal.index = {};
+            }
+            if (!ordinalIndex[key]) {
+                // Create a fake axis object where the extended ordinal
+                // positions are emulated
+                fakeAxis = {
+                    series: [],
+                    chart: chart,
+                    getExtremes: function () {
+                        return {
+                            min: extremes.dataMin,
+                            max: extremes.dataMax + overscroll
+                        };
+                    },
+                    options: {
+                        ordinal: true
+                    },
+                    ordinal: {},
+                    ordinal2lin: axisProto.ordinal2lin,
+                    val2lin: axisProto.val2lin // #2590
+                };
+                fakeAxis.ordinal.axis = fakeAxis;
+                // Add the fake series to hold the full data, then apply
+                // processData to it
+                axis.series.forEach(function (series) {
+                    fakeSeries = {
+                        xAxis: fakeAxis,
+                        xData: series.xData.slice(),
+                        chart: chart,
+                        destroyGroupedData: H.noop,
+                        getProcessedData: CartesianSeries.prototype.getProcessedData
+                    };
+                    fakeSeries.xData = fakeSeries.xData.concat(ordinal.getOverscrollPositions());
+                    fakeSeries.options = {
+                        dataGrouping: grouping ? {
+                            enabled: true,
+                            forced: true,
+                            // doesn't matter which, use the fastest
+                            approximation: 'open',
+                            units: [[
+                                    grouping.unitName,
+                                    [grouping.count]
+                                ]]
+                        } : {
+                            enabled: false
+                        }
+                    };
+                    series.processData.apply(fakeSeries);
+                    fakeAxis.series.push(fakeSeries);
+                });
+                // Run beforeSetTickPositions to compute the ordinalPositions
+                axis.ordinal.beforeSetTickPositions.apply({ axis: fakeAxis });
+                // Cache it
+                ordinalIndex[key] = fakeAxis.ordinal.positions;
+            }
+            return ordinalIndex[key];
+        };
+        /**
+         * Find the factor to estimate how wide the plot area would have been if
+         * ordinal gaps were included. This value is used to compute an imagined
+         * plot width in order to establish the data grouping interval.
+         *
+         * A real world case is the intraday-candlestick example. Without this
+         * logic, it would show the correct data grouping when viewing a range
+         * within each day, but once moving the range to include the gap between
+         * two days, the interval would include the cut-away night hours and the
+         * data grouping would be wrong. So the below method tries to compensate
+         * by identifying the most common point interval, in this case days.
+         *
+         * An opposite case is presented in issue #718. We have a long array of
+         * daily data, then one point is appended one hour after the last point.
+         * We expect the data grouping not to change.
+         *
+         * In the future, if we find cases where this estimation doesn't work
+         * optimally, we might need to add a second pass to the data grouping
+         * logic, where we do another run with a greater interval if the number
+         * of data groups is more than a certain fraction of the desired group
+         * count.
+         *
+         * @private
+         */
+        Composition.prototype.getGroupIntervalFactor = function (xMin, xMax, series) {
+            var ordinal = this, axis = ordinal.axis, i, processedXData = series.processedXData, len = processedXData.length, distances = [], median, groupIntervalFactor = ordinal.groupIntervalFactor;
+            // Only do this computation for the first series, let the other
+            // inherit it (#2416)
+            if (!groupIntervalFactor) {
+                // Register all the distances in an array
+                for (i = 0; i < len - 1; i++) {
+                    distances[i] =
+                        processedXData[i + 1] - processedXData[i];
+                }
+                // Sort them and find the median
+                distances.sort(function (a, b) {
+                    return a - b;
+                });
+                median = distances[Math.floor(len / 2)];
+                // Compensate for series that don't extend through the entire
+                // axis extent. #1675.
+                xMin = Math.max(xMin, processedXData[0]);
+                xMax = Math.min(xMax, processedXData[len - 1]);
+                ordinal.groupIntervalFactor = groupIntervalFactor =
+                    (len * median) / (xMax - xMin);
+            }
+            // Return the factor needed for data grouping
+            return groupIntervalFactor;
+        };
+        /**
+         * Get ticks for an ordinal axis within a range where points don't
+         * exist. It is required when overscroll is enabled. We can't base on
+         * points, because we may not have any, so we use approximated
+         * pointRange and generate these ticks between Axis.dataMax,
+         * Axis.dataMax + Axis.overscroll evenly spaced. Used in panning and
+         * navigator scrolling.
+         *
+         * @private
+         */
+        Composition.prototype.getOverscrollPositions = function () {
+            var ordinal = this, axis = ordinal.axis, extraRange = axis.options.overscroll, distance = ordinal.overscrollPointsRange, positions = [], max = axis.dataMax;
+            if (defined(distance)) {
+                // Max + pointRange because we need to scroll to the last
+                positions.push(max);
+                while (max <= axis.dataMax + extraRange) {
+                    max += distance;
+                    positions.push(max);
+                }
+            }
+            return positions;
+        };
+        /**
+         * Make the tick intervals closer because the ordinal gaps make the
+         * ticks spread out or cluster.
+         *
+         * @private
+         */
+        Composition.prototype.postProcessTickInterval = function (tickInterval) {
+            // Problem: https://jsfiddle.net/highcharts/FQm4E/1/
+            // This is a case where this algorithm doesn't work optimally. In
+            // this case, the tick labels are spread out per week, but all the
+            // gaps reside within weeks. So we have a situation where the labels
+            // are courser than the ordinal gaps, and thus the tick interval
+            // should not be altered.
+            var ordinal = this, axis = ordinal.axis, ordinalSlope = ordinal.slope, ret;
+            if (ordinalSlope) {
+                if (!axis.options.breaks) {
+                    ret = tickInterval / (ordinalSlope / axis.closestPointRange);
+                }
+                else {
+                    ret = axis.closestPointRange || tickInterval; // #7275
+                }
+            }
+            else {
+                ret = tickInterval;
+            }
+            return ret;
+        };
+        return Composition;
+    }());
+    OrdinalAxis.Composition = Composition;
+    /* *
+     *
+     *  Functions
+     *
+     * */
+    /**
+     * Extends the axis with ordinal support.
+     *
+     * @private
+     *
+     * @param AxisClass
+     * Axis class to extend.
+     *
+     * @param ChartClass
+     * Chart class to use.
+     *
+     * @param SeriesClass
+     * Series class to use.
+     */
+    function compose(AxisClass, ChartClass, SeriesClass) {
+        AxisClass.keepProps.push('ordinal');
+        var axisProto = AxisClass.prototype;
         /**
          * In an ordinal axis, there might be areas with dense consentrations of
          * points, then large gaps between some. Creating equally distributed
@@ -630,7 +640,7 @@ var OrdinalAxis = /** @class */ (function () {
         addEvent(AxisClass, 'afterInit', function () {
             var axis = this;
             if (!axis.ordinal) {
-                axis.ordinal = new OrdinalAxisAdditions(axis);
+                axis.ordinal = new OrdinalAxis.Composition(axis);
             }
         });
         addEvent(AxisClass, 'foundExtremes', function () {
@@ -664,6 +674,13 @@ var OrdinalAxis = /** @class */ (function () {
                     !axis.chart.navigator.adaptToUpdatedData;
             }
         });
+        addEvent(AxisClass, 'initialAxisTranslation', function () {
+            var axis = this;
+            if (axis.ordinal) {
+                axis.ordinal.beforeSetTickPositions();
+                axis.tickInterval = axis.ordinal.postProcessTickInterval(axis.tickInterval);
+            }
+        });
         // Extending the Chart.pan method for ordinal axes
         addEvent(ChartClass, 'pan', function (e) {
             var chart = this, xAxis = chart.xAxis[0], overscroll = xAxis.options.overscroll, chartX = e.originalEvent.chartX, panning = chart.options.chart &&
@@ -752,8 +769,8 @@ var OrdinalAxis = /** @class */ (function () {
             }
         });
         /* eslint-enable no-invalid-this */
-    };
-    return OrdinalAxis;
-}());
-OrdinalAxis.compose(Axis, Chart, Series); // @todo move to StockChart, remove from master
+    }
+    OrdinalAxis.compose = compose;
+})(OrdinalAxis || (OrdinalAxis = {}));
+OrdinalAxis.compose(Axis, Chart, CartesianSeries); // @todo move to StockChart, remove from master
 export default OrdinalAxis;

package/es-modules/{parts → Core/Axis}/PlotLineOrBand.js

@@ -8,8 +8,8 @@
  *
  * */
 'use strict';
-import H from './Globals.js';
 import Axis from './Axis.js';
+import H from '../Globals.js';
 /**
  * Options for plot bands on axes.
  *
@@ -30,8 +30,8 @@ import Axis from './Axis.js';
  *
  * @typedef {Highcharts.XAxisPlotLinesLabelOptions|Highcharts.YAxisPlotLinesLabelOptions|Highcharts.ZAxisPlotLinesLabelOptions} Highcharts.AxisPlotLinesLabelOptions
  */
-import U from './Utilities.js';
-var arrayMax = U.arrayMax, arrayMin = U.arrayMin, defined = U.defined, destroyObjectProperties = U.destroyObjectProperties, erase = U.erase, extend = U.extend, fireEvent = U.fireEvent, merge = U.merge, objectEach = U.objectEach, pick = U.pick;
+import U from '../Utilities.js';
+var arrayMax = U.arrayMax, arrayMin = U.arrayMin, defined = U.defined, destroyObjectProperties = U.destroyObjectProperties, erase = U.erase, extend = U.extend, merge = U.merge, objectEach = U.objectEach, pick = U.pick;
 /* eslint-disable no-invalid-this, valid-jsdoc */
 /**
  * The object wrapper for plot lines and plot bands
@@ -126,16 +126,17 @@ var PlotLineOrBand = /** @class */ (function () {
             return;
         }
         // common for lines and bands
+        // Add events only if they were not added before.
+        if (!plotLine.eventsAdded && events) {
+            objectEach(events, function (event, eventType) {
+                svgElem.on(eventType, function (e) {
+                    events[eventType].apply(plotLine, [e]);
+                });
+            });
+            plotLine.eventsAdded = true;
+        }
         if ((isNew || !svgElem.d) && path && path.length) {
             svgElem.attr({ d: path });
-            // events
-            if (events) {
-                objectEach(events, function (event, eventType) {
-                    svgElem.on(eventType, function (e) {
-                        events[eventType].apply(plotLine, [e]);
-                    });
-                });
-            }
         }
         else if (svgElem) {
             if (path) {
@@ -845,18 +846,22 @@ extend(Axis.prototype, /** @lends Highcharts.Axis.prototype */ {
      * @param {number} to
      *        The axis value to end on.
      *
+     * @param {Highcharts.AxisPlotBandsOptions|Highcharts.AxisPlotLinesOptions} options
+     *        The plotBand or plotLine configuration object.
+     *
      * @return {Highcharts.SVGPathArray}
      *         The SVG path definition in array form.
      */
-    getPlotBandPath: function (from, to) {
+    getPlotBandPath: function (from, to, options) {
+        if (options === void 0) { options = this.options; }
         var toPath = this.getPlotLinePath({
             value: to,
             force: true,
-            acrossPanes: this.options.acrossPanes
+            acrossPanes: options.acrossPanes
         }), path = this.getPlotLinePath({
             value: from,
             force: true,
-            acrossPanes: this.options.acrossPanes
+            acrossPanes: options.acrossPanes
         }), result = [], i, 
         // #4964 check if chart is inverted or plotband is on yAxis
         horiz = this.horiz, plus = 1, isFlat, outside = (from < this.min && to < this.min) ||
@@ -946,7 +951,10 @@ extend(Axis.prototype, /** @lends Highcharts.Axis.prototype */ {
      * @return {Highcharts.PlotLineOrBand|undefined}
      */
     addPlotBandOrLine: function (options, coll) {
-        var obj = new PlotLineOrBand(this, options).render(), userOptions = this.userOptions;
+        var obj = new H.PlotLineOrBand(this, options), userOptions = this.userOptions;
+        if (this.visible) {
+            obj = obj.render();
+        }
         if (obj) { // #2189
             // Add it to the user options for exporting and Axis.update
             if (coll) {
@@ -956,6 +964,7 @@ extend(Axis.prototype, /** @lends Highcharts.Axis.prototype */ {
                 userOptions[coll] = updatedOptions;
             }
             this.plotLinesAndBands.push(obj);
+            this._addedPlotLB = true;
         }
         return obj;
     },