highcharts-rails 6.0.1 → 6.0.2

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

@@ -1,5 +1,5 @@
 /**
- * @license Highcharts JS v6.0.1 (2017-10-05)
+ * @license Highcharts JS v6.0.2 (2017-10-20)
  * Boost module
  *
  * (c) 2010-2017 Highsoft AS
@@ -271,6 +271,7 @@
         var win = H.win,
             doc = win.document,
             noop = function() {},
+            Chart = H.Chart,
             Color = H.Color,
             Series = H.Series,
             seriesTypes = H.seriesTypes,
@@ -460,7 +461,11 @@
                 r = -Number.MAX_VALUE;
 
             each(args, function(t) {
-                if (typeof t !== 'undefined' && typeof t.length !== 'undefined') {
+                if (
+                    typeof t !== 'undefined' &&
+                    t !== null &&
+                    typeof t.length !== 'undefined'
+                ) {
                     // r = r < t.length ? t.length : r;
                     if (t.length > 0) {
                         r = t.length;
@@ -529,29 +534,35 @@
          * @param chart {Highchart.Chart} - the chart to check
          * @returns {Boolean} - true if the chart is in series boost mode
          */
-        function isChartSeriesBoosting(chart) {
+        Chart.prototype.isChartSeriesBoosting = function() {
             var threshold = 50;
 
-            threshold = chart.options.boost && typeof chart.options.boost.seriesThreshold !== 'undefined' ?
-                chart.options.boost.seriesThreshold : threshold;
+            threshold = (
+                    this.options.boost &&
+                    typeof this.options.boost.seriesThreshold !== 'undefined'
+                ) ?
+                this.options.boost.seriesThreshold :
+                threshold;
 
-            return threshold <= chart.series.length ||
-                shouldForceChartSeriesBoosting(chart);
-        }
+            return threshold <= this.series.length ||
+                shouldForceChartSeriesBoosting(this);
+        };
 
         /*
          * Returns true if the series is in boost mode
          * @param series {Highchart.Series} - the series to check
          * @returns {boolean} - true if the series is in boost mode
          */
+        /*
         function isSeriesBoosting(series, overrideThreshold) {
-            return isChartSeriesBoosting(series.chart) ||
-                patientMax(
-                    series.processedXData,
-                    series.options.data,
-                    series.points
-                ) >= (overrideThreshold || series.options.boostThreshold || Number.MAX_VALUE);
+        	return  isChartSeriesBoosting(series.chart) ||
+        			patientMax(
+        				series.processedXData,
+        				series.options.data,
+        				series.points
+        			) >= (overrideThreshold || series.options.boostThreshold || Number.MAX_VALUE);
         }
+        */
 
         // START OF WEBGL ABSTRACTIONS
 
@@ -1239,7 +1250,7 @@
                     xData,
                     s;
 
-                if (isSeriesBoosting(series)) {
+                if (series.isSeriesBoosting) {
                     isStacked = !!series.options.stacking;
                     xData = series.xData || series.options.xData || series.processedXData;
                     s = (isStacked ? series.data : (xData || series.options.data)).length;
@@ -1267,7 +1278,7 @@
                 }
 
                 each(chart.series, function(series) {
-                    if (isSeriesBoosting(series)) {
+                    if (series.isSeriesBoosting) {
                         s += seriesPointCount(series);
                     }
                 });
@@ -1282,7 +1293,7 @@
                     return;
                 }
 
-                if (isSeriesBoosting(series)) {
+                if (series.isSeriesBoosting) {
                     s = seriesPointCount(series);
                 }
 
@@ -2305,7 +2316,7 @@
                     '1.1'
                 );
 
-            if (isChartSeriesBoosting(chart)) {
+            if (chart.isChartSeriesBoosting()) {
                 target = chart;
             } else {
                 target = series;
@@ -2451,7 +2462,7 @@
             if (renderer &&
                 series.renderTarget &&
                 series.canvas &&
-                !isChartSeriesBoosting(chart || series.chart)
+                !(chart || series.chart).isChartSeriesBoosting()
             ) {
                 renderer.render(chart || series.chart);
             }
@@ -2461,23 +2472,24 @@
             if (renderer &&
                 series.renderTarget &&
                 series.canvas &&
-                !isChartSeriesBoosting(series.chart)
+                !series.chart.isChartSeriesBoosting()
             ) {
                 renderer.allocateBufferForSingleSeries(series);
             }
         }
 
         /*
-         * An "async" foreach loop.
-         * Uses a setTimeout to keep the loop from blocking the UI thread
+         * An "async" foreach loop. Uses a setTimeout to keep the loop from blocking the
+         * UI thread.
+         * 
          * @param arr {Array} - the array to loop through
          * @param fn {Function} - the callback to call for each item
          * @param finalFunc {Function} - the callback to call when done
-         * @param chunkSize {Number} - the number of iterations per. timeout
+         * @param chunkSize {Number} - the number of iterations per timeout
          * @param i {Number} - the current index
          * @param noTimeout {Boolean} - set to true to skip timeouts
          */
-        function eachAsync(arr, fn, finalFunc, chunkSize, i, noTimeout) {
+        H.eachAsync = function(arr, fn, finalFunc, chunkSize, i, noTimeout) {
             i = i || 0;
             chunkSize = chunkSize || CHUNK_SIZE;
 
@@ -2493,15 +2505,15 @@
                 if (i < arr.length) {
 
                     if (noTimeout) {
-                        eachAsync(arr, fn, finalFunc, chunkSize, i, noTimeout);
+                        H.eachAsync(arr, fn, finalFunc, chunkSize, i, noTimeout);
                     } else if (win.requestAnimationFrame) {
                         // If available, do requestAnimationFrame - shaves off a few ms
                         win.requestAnimationFrame(function() {
-                            eachAsync(arr, fn, finalFunc, chunkSize, i);
+                            H.eachAsync(arr, fn, finalFunc, chunkSize, i);
                         });
                     } else {
                         setTimeout(function() {
-                            eachAsync(arr, fn, finalFunc, chunkSize, i);
+                            H.eachAsync(arr, fn, finalFunc, chunkSize, i);
                         });
                     }
 
@@ -2509,7 +2521,7 @@
                     finalFunc();
                 }
             }
-        }
+        };
 
         // /////////////////////////////////////////////////////////////////////////////
         // Following is the parts of the boost that's common between OGL/Legacy
@@ -2584,7 +2596,7 @@
          * to hasExtremes to the methods directly.
          */
         wrap(Series.prototype, 'getExtremes', function(proceed) {
-            if (!isSeriesBoosting(this) || (!this.hasExtremes || !this.hasExtremes())) {
+            if (!this.isSeriesBoosting || (!this.hasExtremes || !this.hasExtremes())) {
                 return proceed.apply(this, Array.prototype.slice.call(arguments, 1));
             }
         });
@@ -2626,37 +2638,13 @@
                         this.chart.options.boost.enabled;
                 }
 
-                if (!isSeriesBoosting(this) ||
+                if (!this.isSeriesBoosting ||
                     letItPass ||
                     !enabled ||
                     this.type === 'heatmap' ||
                     this.type === 'treemap'
                 ) {
 
-                    // Clear image
-                    if (method === 'render') {
-                        this.stickyTracking = (this.options || {}).stickyTracking;
-
-                        if (this.boostClear) {
-                            this.boostClear();
-                            this.animate = null; // We're zooming in, don't run animation
-                        }
-                    }
-
-                    if (!this.options.stacking && method === 'translate' &&
-                        this.type !== 'treemap' &&
-                        this.type !== 'heatmap') {
-                        // We call generate points and check if we're now boosting
-                        // so that we don't have to call series.translate
-                        // when zooming out from SVG mode (which is very, very expensive)
-
-                        this.generatePoints();
-
-                        if (isSeriesBoosting(this)) {
-                            return;
-                        }
-                    }
-
                     proceed.call(this);
 
                     // If a canvas version of the method exists, like renderCanvas(), run
@@ -2691,6 +2679,158 @@
             }
         });
 
+        /** If the series is a heatmap or treemap, or if the series is not boosting
+         *  do the default behaviour. Otherwise, process if the series has no
+         *  extremes.
+         */
+        wrap(Series.prototype, 'processData', function(proceed) {
+
+            var series = this,
+                dataToMeasure = this.options.data;
+
+            // Used twice in this function, first on this.options.data, the second
+            // time it runs the check again after processedXData is built.
+            // @todo Check what happens with data grouping
+            function getSeriesBoosting(data) {
+                return series.chart.isChartSeriesBoosting() || (
+                    (data ? data.length : 0) >=
+                    (series.options.boostThreshold || Number.MAX_VALUE)
+                );
+            }
+
+            // If there are no extremes given in the options, we also need to process
+            // the data to read the data extremes. If this is a heatmap, do default
+            // behaviour. 
+            if (!getSeriesBoosting(dataToMeasure) || // First pass with options.data
+                this.type === 'heatmap' ||
+                this.type === 'treemap' ||
+                !this.hasExtremes ||
+                !this.hasExtremes(true)
+            ) {
+                proceed.apply(this, Array.prototype.slice.call(arguments, 1));
+                dataToMeasure = this.processedXData;
+            }
+
+            /*
+            if (!this.hasExtremes || !this.hasExtremes(true)) {
+            	proceed.apply(this, Array.prototype.slice.call(arguments, 1));
+            }
+            */
+
+            // Set the isBoosting flag, second pass with processedXData to see if we
+            // have zoomed.
+            this.isSeriesBoosting = getSeriesBoosting(dataToMeasure);
+
+            // Enter or exit boost mode
+            if (this.isSeriesBoosting) {
+                this.enterBoost();
+            } else if (this.exitBoost) {
+                this.exitBoost();
+            }
+        });
+
+        wrap(Series.prototype, 'setVisible', function(proceed, vis, redraw) {
+            proceed.call(this, vis, redraw);
+            if (this.visible === false && this.canvas && this.renderTarget) {
+                if (this.ogl) {
+                    this.ogl.clear();
+                }
+                this.boostClear();
+            }
+        });
+
+        /**
+         * Enter boost mode and apply boost-specific properties.
+         */
+        Series.prototype.enterBoost = function() {
+
+            this.alteredByBoost = [];
+
+            // Save the original values, including whether it was an own property or
+            // inherited from the prototype.
+            each(['allowDG', 'directTouch', 'stickyTracking'], function(prop) {
+                this.alteredByBoost.push({
+                    prop: prop,
+                    val: this[prop],
+                    own: this.hasOwnProperty(prop)
+                });
+            }, this);
+
+            this.allowDG = false;
+            this.directTouch = false;
+            this.stickyTracking = true;
+
+            // Once we've been in boost mode, we don't want animation when returning to
+            // vanilla mode.
+            this.animate = null;
+
+            // Hide series label if any
+            if (this.labelBySeries) {
+                this.labelBySeries = this.labelBySeries.destroy();
+            }
+        };
+
+        /**
+         * Exit from boost mode and restore non-boost properties.
+         */
+        Series.prototype.exitBoost = function() {
+            // Reset instance properties and/or delete instance properties and go back
+            // to prototype
+            each(this.alteredByBoost || [], function(setting) {
+                if (setting.own) {
+                    this[setting.prop] = setting.val;
+                } else {
+                    // Revert to prototype
+                    delete this[setting.prop];
+                }
+            }, this);
+
+            // Clear previous run
+            if (this.boostClear) {
+                this.boostClear();
+            }
+
+        };
+
+        Series.prototype.hasExtremes = function(checkX) {
+            var options = this.options,
+                data = options.data,
+                xAxis = this.xAxis && this.xAxis.options,
+                yAxis = this.yAxis && this.yAxis.options;
+
+            return data.length > (options.boostThreshold || Number.MAX_VALUE) &&
+                isNumber(yAxis.min) && isNumber(yAxis.max) &&
+                (!checkX || (isNumber(xAxis.min) && isNumber(xAxis.max)));
+        };
+
+        /**
+         * If implemented in the core, parts of this can probably be
+         * shared with other similar methods in Highcharts.
+         */
+        Series.prototype.destroyGraphics = function() {
+            var series = this,
+                points = this.points,
+                point,
+                i;
+
+            if (points) {
+                for (i = 0; i < points.length; i = i + 1) {
+                    point = points[i];
+                    if (point && point.graphic) {
+                        point.graphic = point.graphic.destroy();
+                    }
+                }
+            }
+
+            each(['graph', 'area', 'tracker'], function(prop) {
+                if (series[prop]) {
+                    series[prop] = series[prop].destroy();
+                }
+            });
+        };
+
+
+
         /*
          * Returns true if the current browser supports webgl
          */
@@ -2729,7 +2869,7 @@
                     this.chart.options.boost.enabled;
             }
 
-            if (!enabled || !isSeriesBoosting(this)) {
+            if (!enabled || !this.isSeriesBoosting) {
                 return proceed.call(this);
             }
 
@@ -2761,63 +2901,9 @@
             // /////////////////////////////////////////////////////////////////////////
             // GL-SPECIFIC WRAPPINGS FOLLOWS
 
-            /** If the series is a heatmap or treemap, or if the series is not boosting
-             *  do the default behaviour. Otherwise, process if the series has no
-             *  extremes.
-             */
-            wrap(Series.prototype, 'processData', function(proceed) {
-                // If this is a heatmap, do default behaviour
-                if (!isSeriesBoosting(this) ||
-                    this.type === 'heatmap' ||
-                    this.type === 'treemap') {
-                    proceed.apply(this, Array.prototype.slice.call(arguments, 1));
-                }
 
-                if (!this.hasExtremes || !this.hasExtremes(true)) {
-                    proceed.apply(this, Array.prototype.slice.call(arguments, 1));
-                }
-            });
 
             H.extend(Series.prototype, {
-                pointRange: 0,
-                directTouch: false,
-                allowDG: false, // No data grouping, let boost handle large data
-                hasExtremes: function(checkX) {
-                    var options = this.options,
-                        data = options.data,
-                        xAxis = this.xAxis && this.xAxis.options,
-                        yAxis = this.yAxis && this.yAxis.options;
-
-                    return data.length > (options.boostThreshold || Number.MAX_VALUE) &&
-                        isNumber(yAxis.min) && isNumber(yAxis.max) &&
-                        (!checkX || (isNumber(xAxis.min) && isNumber(xAxis.max)));
-                },
-
-                /**
-                 * If implemented in the core, parts of this can probably be
-                 * shared with other similar methods in Highcharts.
-                 */
-                destroyGraphics: function() {
-                    var series = this,
-                        points = this.points,
-                        point,
-                        i;
-
-                    if (points) {
-                        for (i = 0; i < points.length; i = i + 1) {
-                            point = points[i];
-                            if (point && point.graphic) {
-                                point.graphic = point.graphic.destroy();
-                            }
-                        }
-                    }
-
-                    each(['graph', 'area', 'tracker'], function(prop) {
-                        if (series[prop]) {
-                            series[prop] = series[prop].destroy();
-                        }
-                    });
-                },
 
                 renderCanvas: function() {
                     var series = this,
@@ -2888,9 +2974,6 @@
 
                     boostOptions = renderer.settings;
 
-                    // Force sticky tracking
-                    this.stickyTracking = true;
-
                     if (!this.visible) {
                         return;
                     }
@@ -2904,7 +2987,7 @@
 
                     // If we're rendering per. series we should create the marker groups
                     // as usual.
-                    if (!isChartSeriesBoosting(chart)) {
+                    if (!chart.isChartSeriesBoosting()) {
                         this.markerGroup = series.plotGroup(
                             'markerGroup',
                             'markers',
@@ -3017,11 +3100,6 @@
 
                     function doneProcessing() {
                         fireEvent(series, 'renderedCanvas');
-                        // Pass tests in Pointer.
-                        // Replace this with a single property, and replace when zooming
-                        // in below boostThreshold.
-                        series.directTouch = false;
-                        series.options.stickyTracking = true;
 
                         // Go back to prototype, ready to build
                         delete series.buildKDTree;
@@ -3038,7 +3116,7 @@
                             console.time('kd tree building'); // eslint-disable-line no-console
                         }
 
-                        eachAsync(
+                        H.eachAsync(
                             isStacked ? series.data : (xData || rawData),
                             processPoint,
                             doneProcessing
@@ -3058,7 +3136,6 @@
                 function(t) {
                     if (seriesTypes[t]) {
                         wrap(seriesTypes[t].prototype, 'drawPoints', pointDrawHandler);
-                        seriesTypes[t].prototype.directTouch = false; // Use k-d-tree
                     }
                 }
             );
@@ -3067,14 +3144,14 @@
                 // By default, the bubble series does not use the KD-tree, so force it
                 // to.
                 delete seriesTypes.bubble.prototype.buildKDTree;
-                seriesTypes.bubble.prototype.directTouch = false;
+                // seriesTypes.bubble.prototype.directTouch = false;
 
                 // Needed for markers to work correctly
                 wrap(
                     seriesTypes.bubble.prototype,
                     'markerAttribs',
                     function(proceed) {
-                        if (isSeriesBoosting(this)) {
+                        if (this.isSeriesBoosting) {
                             return false;
                         }
                         return proceed.apply(this, [].slice.call(arguments, 1));
@@ -3096,16 +3173,6 @@
                 sampling: true
             });
 
-            wrap(Series.prototype, 'setVisible', function(proceed, vis, redraw) {
-                proceed.call(this, vis, redraw);
-                if (this.visible === false && this.canvas && this.renderTarget) {
-                    if (this.ogl) {
-                        this.ogl.clear();
-                    }
-                    this.boostClear();
-                }
-            });
-
             /**
              * Take care of the canvas blitting
              */
@@ -3113,7 +3180,7 @@
 
                 /* Convert chart-level canvas to image */
                 function canvasToSVG() {
-                    if (chart.ogl && isChartSeriesBoosting(chart)) {
+                    if (chart.ogl && chart.isChartSeriesBoosting()) {
                         chart.ogl.render(chart);
                     }
                 }
@@ -3125,7 +3192,7 @@
                     chart.boostForceChartBoost = shouldForceChartSeriesBoosting(chart);
                     chart.isBoosting = false;
 
-                    if (!isChartSeriesBoosting(chart) && chart.didBoost) {
+                    if (!chart.isChartSeriesBoosting() && chart.didBoost) {
                         chart.didBoost = false;
                     }
 
@@ -3134,7 +3201,7 @@
                         chart.boostClear();
                     }
 
-                    if (chart.canvas && chart.ogl && isChartSeriesBoosting(chart)) {
+                    if (chart.canvas && chart.ogl && chart.isChartSeriesBoosting()) {
                         chart.didBoost = true;
 
                         // Allocate