highcharts-rails 4.2.0 → 4.2.2

data/app/assets/javascripts/highcharts/highcharts-3d.js

@@ -2,7 +2,7 @@
 // @compilation_level SIMPLE_OPTIMIZATIONS
 
 /**
- * @license Highcharts JS v4.2.0 (2105-12-15)
+ * @license Highcharts JS v4.2.2 (2016-02-04)
  *
  * 3D features for Highcharts JS
  *
@@ -251,7 +251,7 @@
                 this.top.attr({ d: paths[1], zIndex: paths[4] });
                 this.side.attr({ d: paths[2], zIndex: paths[5] });
             } else {
-                Highcharts.SVGElement.prototype.attr.call(this, args);
+                return Highcharts.SVGElement.prototype.attr.call(this, args); // getter returns value
             }
 
             return this;
@@ -263,6 +263,9 @@
                 this.front.attr({ zIndex: paths[3] }).animate({ d: paths[0] }, duration, complete);
                 this.top.attr({ zIndex: paths[4] }).animate({ d: paths[1] }, duration, complete);
                 this.side.attr({ zIndex: paths[5] }).animate({ d: paths[2] }, duration, complete);
+                this.attr({
+                    zIndex: -paths[6] // #4774
+                });
             } else if (args.opacity) {
                 this.front.animate(args, duration, complete);
                 this.top.animate(args, duration, complete);
@@ -283,7 +286,7 @@
         };
 
         // Apply the Z index to the cuboid group
-        result.attr({ zIndex: -paths[3] });
+        result.attr({ zIndex: -paths[6] });
 
         return result;
     };
@@ -321,15 +324,13 @@
             return pArr[i];
         }
         var pickShape = function (path1, path2) {
-            var ret;
+            var ret = [];
             path1 = map(path1, mapPath);
             path2 = map(path2, mapPath);
             if (shapeArea(path1) < 0) {
                 ret = path1;
             } else if (shapeArea(path2) < 0) {
                 ret = path2;
-            } else {
-                ret = [];
             }
             return ret;
         };
@@ -349,7 +350,7 @@
         var left = [0, 7, 4, 3];
         var path3 = pickShape(right, left);
 
-        return [this.toLinePath(path1, true), this.toLinePath(path2, true), this.toLinePath(path3, true), averageZ(path1), averageZ(path2), averageZ(path3)];
+        return [this.toLinePath(path1, true), this.toLinePath(path2, true), this.toLinePath(path3, true), averageZ(path1), averageZ(path2), averageZ(path3), averageZ(map(bottom, mapPath)) * 9e9]; // #4774
     };
 
     ////// SECTORS //////
@@ -747,7 +748,7 @@
             plotOptions,
             pieOptions;
 
-        if (args[0].chart.options3d && args[0].chart.options3d.enabled) {
+        if (args[0].chart && args[0].chart.options3d && args[0].chart.options3d.enabled) {
             // Normalize alpha and beta to (-360, 360) range
             args[0].chart.options3d.alpha = (args[0].chart.options3d.alpha || 0) % 360;
             args[0].chart.options3d.beta = (args[0].chart.options3d.beta || 0) % 360;

data/app/assets/javascripts/highcharts/highcharts-more.js

@@ -2,9 +2,9 @@
 // @compilation_level SIMPLE_OPTIMIZATIONS
 
 /**
- * @license Highcharts JS v4.2.0 (2105-12-15)
+ * @license Highcharts JS v4.2.2 (2016-02-04)
  *
- * (c) 2009-2014 Torstein Honsi
+ * (c) 2009-2016 Torstein Honsi
  *
  * License: www.highcharts.com/license
  */
@@ -563,6 +563,17 @@ var arrayMin = Highcharts.arrayMin,
 
     });
 
+    /**
+     * Wrap auto label align to avoid setting axis-wide rotation on radial axes (#4920)
+     * @param   {Function} proceed
+     * @returns {String} Alignment
+     */
+    wrap(axisProto, 'autoLabelAlign', function (proceed) {
+        if (!this.isRadial) {
+            return proceed.apply(this, [].slice.call(arguments, 1));
+        } // else return undefined
+    });
+
     /**
      * Add special cases within the Tick class' methods for radial axes.
      */
@@ -709,22 +720,6 @@ var arrayMin = Highcharts.arrayMin,
             point.plotHigh = xy.y - chart.plotTop;
         },
 
-        /**
-         * Extend getSegments to force null points if the higher value is null. #1703.
-         */
-        getSegments: function () {
-            var series = this;
-
-            each(series.points, function (point) {
-                if (!series.options.connectNulls && (point.low === null || point.high === null)) {
-                    point.y = null;
-                } else if (point.low === null && point.high !== null) {
-                    point.y = point.high;
-                }
-            });
-            Series.prototype.getSegments.call(this);
-        },
-
         /**
          * Translate data points from raw values x and y to plotX and plotY
          */
@@ -741,14 +736,8 @@ var arrayMin = Highcharts.arrayMin,
                     high = point.high,
                     plotY = point.plotY;
 
-                if (high === null && low === null) {
-                    point.y = null;
-                } else if (low === null) {
-                    point.plotLow = point.plotY = null;
-                    point.plotHigh = yAxis.translate(high, 0, 1, 0, 1);
-                } else if (high === null) {
-                    point.plotLow = plotY;
-                    point.plotHigh = null;
+                if (high === null || low === null) {
+                    point.isNull = true;
                 } else {
                     point.plotLow = plotY;
                     point.plotHigh = yAxis.translate(high, 0, 1, 0, 1);
@@ -767,44 +756,60 @@ var arrayMin = Highcharts.arrayMin,
          * Extend the line series' getSegmentPath method by applying the segment
          * path to both lower and higher values of the range
          */
-        getSegmentPath: function (segment) {
-
-            var lowSegment,
-                highSegment = [],
-                i = segment.length,
-                baseGetSegmentPath = Series.prototype.getSegmentPath,
+        getGraphPath: function () {
+        
+            var points = this.points,
+                highPoints = [],
+                highAreaPoints = [],
+                i = points.length,
+                getGraphPath = Series.prototype.getGraphPath,
                 point,
+                pointShim,
                 linePath,
                 lowerPath,
                 options = this.options,
                 step = options.step,
-                higherPath;
-
-            // Remove nulls from low segment
-            lowSegment = Highcharts.grep(segment, function (point) {
-                return point.plotLow !== null;
-            });
+                higherPath,
+                higherAreaPath;
 
-            // Make a segment with plotX and plotY for the top values
+            // Create the top line and the top part of the area fill. The area fill compensates for 
+            // null points by drawing down to the lower graph, moving across the null gap and 
+            // starting again at the lower graph.
+            i = points.length;
             while (i--) {
-                point = segment[i];
-                if (point.plotHigh !== null) {
-                    highSegment.push({
-                        plotX: point.plotHighX || point.plotX, // plotHighX is for polar charts
-                        plotY: point.plotHigh
+                point = points[i];
+        
+                if (!point.isNull && (!points[i + 1] || points[i + 1].isNull)) {
+                    highAreaPoints.push({
+                        plotX: point.plotX,
+                        plotY: point.plotLow
+                    });
+                }
+                pointShim = {
+                    plotX: point.plotX,
+                    plotY: point.plotHigh,
+                    isNull: point.isNull
+                };
+                highAreaPoints.push(pointShim);
+                highPoints.push(pointShim);
+                if (!point.isNull && (!points[i - 1] || points[i - 1].isNull)) {
+                    highAreaPoints.push({
+                        plotX: point.plotX,
+                        plotY: point.plotLow
                     });
                 }
             }
 
             // Get the paths
-            lowerPath = baseGetSegmentPath.call(this, lowSegment);
+            lowerPath = getGraphPath.call(this, points);
             if (step) {
                 if (step === true) {
                     step = 'left';
                 }
-                options.step = { left: 'right', center: 'center', right: 'left' }[step]; // swap for reading in getSegmentPath
+                options.step = { left: 'right', center: 'center', right: 'left' }[step]; // swap for reading in getGraphPath
             }
-            higherPath = baseGetSegmentPath.call(this, highSegment);
+            higherPath = getGraphPath.call(this, highPoints);
+            higherAreaPath = getGraphPath.call(this, highAreaPoints);
             options.step = step;
 
             // Create a line on both top and bottom of the range
@@ -812,10 +817,10 @@ var arrayMin = Highcharts.arrayMin,
 
             // For the area path, we need to change the 'move' statement into 'lineTo' or 'curveTo'
             if (!this.chart.polar) {
-                higherPath[0] = 'L'; // this probably doesn't work for spline
+                higherAreaPath[0] = 'L'; // this probably doesn't work for spline        
             }
-            this.areaPath = this.areaPath.concat(lowerPath, higherPath);
-
+            this.areaPath = this.areaPath.concat(lowerPath, higherAreaPath);
+        
             return linePath;
         },
 
@@ -1289,7 +1294,7 @@ var arrayMin = Highcharts.arrayMin,
         //stemWidth: null,
         threshold: null,
         tooltip: {
-            pointFormat: '<span style="color:{point.color}">\u25CF</span> <b> {series.name}</b><br/>' + // docs
+            pointFormat: '<span style="color:{point.color}">\u25CF</span> <b> {series.name}</b><br/>' +
                 'Maximum: {point.high}<br/>' +
                 'Upper quartile: {point.q3}<br/>' +
                 'Median: {point.median}<br/>' +
@@ -1551,7 +1556,7 @@ var arrayMin = Highcharts.arrayMin,
         grouping: false,
         linkedTo: ':previous',
         tooltip: {
-            pointFormat: '<span style="color:{point.color}">\u25CF</span> {series.name}: <b>{point.low}</b> - <b>{point.high}</b><br/>' // docs
+            pointFormat: '<span style="color:{point.color}">\u25CF</span> {series.name}: <b>{point.low}</b> - <b>{point.high}</b><br/>'
         },
         whiskerWidth: null
     });
@@ -1627,12 +1632,14 @@ var arrayMin = Highcharts.arrayMin,
                 previousY,
                 previousIntermediate,
                 range,
+                minPointLength = pick(options.minPointLength, 5),
                 threshold = options.threshold,
                 stacking = options.stacking,
                 tooltipY;
 
             // run column series translate
             seriesTypes.column.prototype.translate.apply(this);
+            series.minPointLengthOffset = 0;
 
             previousY = previousIntermediate = threshold;
             points = series.points;
@@ -1664,11 +1671,11 @@ var arrayMin = Highcharts.arrayMin,
                 // sum points
                 if (point.isSum) {
                     shapeArgs.y = yAxis.translate(range[1], 0, 1);
-                    shapeArgs.height = Math.min(yAxis.translate(range[0], 0, 1), yAxis.len) - shapeArgs.y; // #4256
+                    shapeArgs.height = Math.min(yAxis.translate(range[0], 0, 1), yAxis.len) - shapeArgs.y + series.minPointLengthOffset; // #4256
 
                 } else if (point.isIntermediateSum) {
                     shapeArgs.y = yAxis.translate(range[1], 0, 1);
-                    shapeArgs.height = Math.min(yAxis.translate(previousIntermediate, 0, 1), yAxis.len) - shapeArgs.y;
+                    shapeArgs.height = Math.min(yAxis.translate(previousIntermediate, 0, 1), yAxis.len) - shapeArgs.y + series.minPointLengthOffset;
                     previousIntermediate = range[1];
 
                 // If it's not the sum point, update previous stack end position and get
@@ -1691,8 +1698,15 @@ var arrayMin = Highcharts.arrayMin,
                 shapeArgs.height = mathMax(mathRound(shapeArgs.height), 0.001); // #3151
                 point.yBottom = shapeArgs.y + shapeArgs.height;
 
+                if (shapeArgs.height <= minPointLength) {
+                    shapeArgs.height = minPointLength;
+                    series.minPointLengthOffset += minPointLength;
+                }
+
+                shapeArgs.y -= series.minPointLengthOffset;
+
                 // Correct tooltip placement (#3014)
-                tooltipY = point.plotY + (point.negative ? shapeArgs.height : 0);
+                tooltipY = point.plotY + (point.negative ? shapeArgs.height : 0) - series.minPointLengthOffset;
                 if (series.chart.inverted) {
                     point.tooltipPos[0] = yAxis.len - tooltipY;
                 } else {
@@ -2283,40 +2297,6 @@ var arrayMin = Highcharts.arrayMin,
             }
         };
 
-        /**
-         * Add some special init logic to areas and areasplines
-         */
-        function initArea(proceed, chart, options) {
-            proceed.call(this, chart, options);
-            if (this.chart.polar) {
-
-                /**
-                 * Overridden method to close a segment path. While in a cartesian plane the area
-                 * goes down to the threshold, in the polar chart it goes to the center.
-                 */
-                this.closeSegment = function (path) {
-                    var center = this.xAxis.center;
-                    path.push(
-                        'L',
-                        center[0],
-                        center[1]
-                    );
-                };
-
-                // Instead of complicated logic to draw an area around the inner area in a stack,
-                // just draw it behind
-                this.closedStacks = true;
-            }
-        }
-
-
-        if (seriesTypes.area) {
-            wrap(seriesTypes.area.prototype, 'init', initArea);
-        }
-        if (seriesTypes.areaspline) {
-            wrap(seriesTypes.areaspline.prototype, 'init', initArea);
-        }
-
         if (seriesTypes.spline) {
             /**
              * Overridden method for calculating a spline from one point to the next
@@ -2455,20 +2435,29 @@ var arrayMin = Highcharts.arrayMin,
          * Extend getSegmentPath to allow connecting ends across 0 to provide a closed circle in
          * line-like series.
          */
-        wrap(seriesProto, 'getSegmentPath', function (proceed, segment) {
-
-            var points = this.points;
-
+        wrap(seriesProto, 'getGraphPath', function (proceed, points) {
+            var series = this;
+        
             // Connect the path
-            if (this.chart.polar && this.options.connectEnds !== false &&
-                    segment[segment.length - 1] === points[points.length - 1] && points[0].y !== null) {
-                this.connectEnds = true; // re-used in splines
-                segment = [].concat(segment, [points[0]]);
+            if (this.chart.polar) {
+                points = points || this.points;
+    
+                if (this.options.connectEnds !== false && points[0].y !== null) {
+                    this.connectEnds = true; // re-used in splines
+                    points.splice(points.length, 0, points[0]);
+                }
+
+                // For area charts, pseudo points are added to the graph, now we need to translate these
+                each(points, function (point) {
+                    if (point.polarPlotY === undefined) {
+                        series.toXY(point);
+                    }
+                });
             }
 
             // Run uber method
-            return proceed.call(this, segment);
-
+            return proceed.apply(this, [].slice.call(arguments, 1));
+    
         });
 
 

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

@@ -68,18 +68,28 @@
         pick = H.pick,
         wrap = H.wrap,
         plotOptions = H.getOptions().plotOptions,
-        CHUNK_SIZE = 50000;
+        CHUNK_SIZE = 50000,
+        destroyLoadingDiv;
 
     function eachAsync(arr, fn, finalFunc, chunkSize, i) {
         i = i || 0;
         chunkSize = chunkSize || CHUNK_SIZE;
-        each(arr.slice(i, i + chunkSize), fn);
-        if (i + chunkSize < arr.length) {
-            setTimeout(function () {
-                eachAsync(arr, fn, finalFunc, chunkSize, i + chunkSize);
-            });
-        } else if (finalFunc) {
-            finalFunc();
+        
+        var threshold = i + chunkSize,
+            proceed = true;
+
+        while (proceed && i < threshold && i < arr.length) {
+            proceed = fn(arr[i], i);
+            i = i + 1;
+        }
+        if (proceed) {
+            if (i < arr.length) {
+                setTimeout(function () {
+                    eachAsync(arr, fn, finalFunc, chunkSize, i);
+                });
+            } else if (finalFunc) {
+                finalFunc();
+            }
         }
     }
 
@@ -240,7 +250,6 @@
                 xAxis = this.xAxis,
                 yAxis = this.yAxis,
                 ctx,
-                i,
                 c = 0,
                 xData = series.processedXData,
                 yData = series.processedYData,
@@ -382,112 +391,106 @@
                         opacity: 1
                     }
                 });
+                clearTimeout(destroyLoadingDiv);
                 chart.showLoading('Drawing...');
                 chart.options.loading = loadingOptions; // reset
-                if (chart.loadingShown === true) {
-                    chart.loadingShown = 1;
-                } else {
-                    chart.loadingShown = chart.loadingShown + 1;
-                }
             }
 
             // Loop over the points
-            i = 0;
-            eachAsync(isStacked ? series.data : (xData || rawData), function (d) {
-
+            eachAsync(isStacked ? series.data : (xData || rawData), function (d, i) {
                 var x,
                     y,
                     clientX,
                     plotY,
                     isNull,
                     low,
+                    chartDestroyed = typeof chart.index === 'undefined',
                     isYInside = true;
 
-                if (useRaw) {
-                    x = d[0];
-                    y = d[1];
-                } else {
-                    x = d;
-                    y = yData[i];
-                }
-
-                // Resolve low and high for range series
-                if (isRange) {
+                if (!chartDestroyed) {
                     if (useRaw) {
-                        y = d.slice(1, 3);
+                        x = d[0];
+                        y = d[1];
+                    } else {
+                        x = d;
+                        y = yData[i];
                     }
-                    low = y[0];
-                    y = y[1];
-                } else if (isStacked) {
-                    x = d.x;
-                    y = d.stackY;
-                    low = y - d.y;
-                }
 
-                isNull = y === null;
+                    // Resolve low and high for range series
+                    if (isRange) {
+                        if (useRaw) {
+                            y = d.slice(1, 3);
+                        }
+                        low = y[0];
+                        y = y[1];
+                    } else if (isStacked) {
+                        x = d.x;
+                        y = d.stackY;
+                        low = y - d.y;
+                    }
 
-                // Optimize for scatter zooming
-                if (!requireSorting) {
-                    isYInside = y >= yMin && y <= yMax;
-                }
+                    isNull = y === null;
 
-                if (!isNull && x >= xMin && x <= xMax && isYInside) {
+                    // Optimize for scatter zooming
+                    if (!requireSorting) {
+                        isYInside = y >= yMin && y <= yMax;
+                    }
 
-                    clientX = Math.round(xAxis.toPixels(x, true));
+                    if (!isNull && x >= xMin && x <= xMax && isYInside) {
 
-                    if (sampling) {
-                        if (minI === undefined || clientX === lastClientX) {
-                            if (!isRange) {
-                                low = y;
-                            }
-                            if (maxI === undefined || y > maxVal) {
-                                maxVal = y;
-                                maxI = i;
-                            }
-                            if (minI === undefined || low < minVal) {
-                                minVal = low;
-                                minI = i;
-                            }
+                        clientX = Math.round(xAxis.toPixels(x, true));
 
-                        }
-                        if (clientX !== lastClientX) { // Add points and reset
-                            if (minI !== undefined) { // then maxI is also a number
-                                plotY = yAxis.toPixels(maxVal, true);
-                                yBottom = yAxis.toPixels(minVal, true);
-                                drawPoint(
-                                    clientX,
-                                    hasThreshold ? Math.min(plotY, translatedThreshold) : plotY,
-                                    hasThreshold ? Math.max(yBottom, translatedThreshold) : yBottom
-                                );
-                                addKDPoint(clientX, plotY, maxI);
-                                if (yBottom !== plotY) {
-                                    addKDPoint(clientX, yBottom, minI);
+                        if (sampling) {
+                            if (minI === undefined || clientX === lastClientX) {
+                                if (!isRange) {
+                                    low = y;
+                                }
+                                if (maxI === undefined || y > maxVal) {
+                                    maxVal = y;
+                                    maxI = i;
                                 }
+                                if (minI === undefined || low < minVal) {
+                                    minVal = low;
+                                    minI = i;
+                                }
+
                             }
+                            if (clientX !== lastClientX) { // Add points and reset
+                                if (minI !== undefined) { // then maxI is also a number
+                                    plotY = yAxis.toPixels(maxVal, true);
+                                    yBottom = yAxis.toPixels(minVal, true);
+                                    drawPoint(
+                                        clientX,
+                                        hasThreshold ? Math.min(plotY, translatedThreshold) : plotY,
+                                        hasThreshold ? Math.max(yBottom, translatedThreshold) : yBottom
+                                    );
+                                    addKDPoint(clientX, plotY, maxI);
+                                    if (yBottom !== plotY) {
+                                        addKDPoint(clientX, yBottom, minI);
+                                    }
+                                }
 
 
-                            minI = maxI = undefined;
-                            lastClientX = clientX;
+                                minI = maxI = undefined;
+                                lastClientX = clientX;
+                            }
+                        } else {
+                            plotY = Math.round(yAxis.toPixels(y, true));
+                            drawPoint(clientX, plotY, yBottom);
+                            addKDPoint(clientX, plotY, i);
                         }
-                    } else {
-                        plotY = Math.round(yAxis.toPixels(y, true));
-                        drawPoint(clientX, plotY, yBottom);
-                        addKDPoint(clientX, plotY, i);
                     }
-                }
-                wasNull = isNull && !connectNulls;
+                    wasNull = isNull && !connectNulls;
 
-                i = i + 1;
-
-                if (i % CHUNK_SIZE === 0) {
-                    series.canvasToSVG();
+                    if (i % CHUNK_SIZE === 0) {
+                        series.canvasToSVG();
+                    }
                 }
 
+                return !chartDestroyed;
             }, function () {
-
                 var loadingDiv = chart.loadingDiv,
-                    loadingShown = +chart.loadingShown;
-
+                    loadingShown = chart.loadingShown;
                 stroke();
                 series.canvasToSVG();
 
@@ -496,23 +499,19 @@
                 // Do not use chart.hideLoading, as it runs JS animation and will be blocked by buildKDTree.
                 // CSS animation looks good, but then it must be deleted in timeout. If we add the module to core,
                 // change hideLoading so we can skip this block.
-                if (loadingShown === 1) {
+                if (loadingShown) {
                     extend(loadingDiv.style, {
                         transition: 'opacity 250ms',
                         opacity: 0
                     });
-
                     chart.loadingShown = false;
-                    setTimeout(function () {
+                    destroyLoadingDiv = setTimeout(function () {
                         if (loadingDiv.parentNode) { // In exporting it is falsy
                             loadingDiv.parentNode.removeChild(loadingDiv);
                         }
                         chart.loadingDiv = chart.loadingSpan = null;
                     }, 250);
                 }
-                if (loadingShown) {
-                    chart.loadingShown = loadingShown - 1;
-                }
 
                 // Pass tests in Pointer. 
                 // Replace this with a single property, and replace when zooming in