highcharts-rails 5.0.12 → 5.0.13

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

@@ -1,5 +1,5 @@
 /**
- * @license Highcharts JS v5.0.12 (2017-05-24)
+ * @license Highcharts JS v5.0.13 (2017-07-27)
  * Highcharts funnel module
  *
  * (c) 2010-2017 Torstein Honsi
@@ -32,27 +32,127 @@
             each = Highcharts.each;
 
 
-        seriesType('funnel', 'pie', {
+        seriesType('funnel', 'pie',
+            /**
+             * Funnel charts are a type of chart often used to visualize stages in a sales 
+             * project, where the top are the initial stages with the most clients. 
+             * It requires that the modules/funnel.js file is loaded.
+             *
+             * @sample highcharts/demo/funnel/ Funnel demo
+             * @extends {plotOptions.pie}
+             * @optionparent plotOptions.funnel
+             */
+            {
+
+                /**
+                 */
                 animation: false,
+
+                /**
+                 * The center of the series. By default, it is centered in the middle
+                 * of the plot area, so it fills the plot area height.
+                 * 
+                 * @type {Array<String|Number>}
+                 * @default ["50%", "50%"]
+                 * @since 3.0
+                 * @product highcharts
+                 */
                 center: ['50%', '50%'],
+
+                /**
+                 * The width of the funnel compared to the width of the plot area,
+                 * or the pixel width if it is a number.
+                 * 
+                 * @type {Number|String}
+                 * @default 90%
+                 * @since 3.0
+                 * @product highcharts
+                 */
                 width: '90%',
+
+                /**
+                 * The width of the neck, the lower part of the funnel. A number defines
+                 * pixel width, a percentage string defines a percentage of the plot
+                 * area width.
+                 * 
+                 * @type {Number|String}
+                 * @sample {highcharts} highcharts/demo/funnel/ Funnel demo
+                 * @default 30%
+                 * @since 3.0
+                 * @product highcharts
+                 */
                 neckWidth: '30%',
+
+                /**
+                 * The height of the funnel or pyramid. If it is a number it defines
+                 * the pixel height, if it is a percentage string it is the percentage
+                 * of the plot area height.
+                 * 
+                 * @type {Number|String}
+                 * @sample {highcharts} highcharts/demo/funnel/ Funnel demo
+                 * @since 3.0
+                 * @product highcharts
+                 */
                 height: '100%',
+
+                /**
+                 * The height of the neck, the lower part of the funnel. A number defines
+                 * pixel width, a percentage string defines a percentage of the plot
+                 * area height.
+                 * 
+                 * @type {Number|String}
+                 * @default 25%
+                 * @product highcharts
+                 */
                 neckHeight: '25%',
+
+                /**
+                 * A reversed funnel has the widest area down. A reversed funnel with
+                 * no neck width and neck height is a pyramid.
+                 * 
+                 * @type {Boolean}
+                 * @default false
+                 * @since 3.0.10
+                 * @product highcharts
+                 */
                 reversed: false,
+
+                /**
+                 */
                 size: true, // to avoid adapting to data label size in Pie.drawDataLabels
 
 
                 // Presentational
+
+                /**
+                 */
                 dataLabels: {
                     //position: 'right',
+
+                    /**
+                     */
                     connectorWidth: 1
                     //connectorColor: null
                 },
+
+                /**
+                 */
                 states: {
+
+                    /**
+                     */
                     select: {
+
+                        /**
+                         */
                         color: '#cccccc',
+
+                        /**
+                         */
                         borderColor: '#000000',
+
+                        /**
+                         */
                         shadow: false
                     }
                 }
@@ -293,13 +393,34 @@
 
         /** 
          * Pyramid series type.
-         * A pyramid series is a special type of funnel, without neck and reversed by default.
          */
-        seriesType('pyramid', 'funnel', {
-            neckWidth: '0%',
-            neckHeight: '0%',
-            reversed: true
-        });
+        seriesType('pyramid', 'funnel',
+            /** 
+             * A pyramid series is a special type of funnel, without neck and reversed by default.
+             * @extends funnel
+             * @optionparent plotOptions.pyramid
+             */
+            {
+
+                /**
+                 */
+                neckWidth: '0%',
+
+                /**
+                 */
+                neckHeight: '0%',
+
+                /**
+                 * The pyramid is reversed by default, as opposed to the funnel, which
+                 * shares the layout engine, and is not reversed.
+                 * 
+                 * @type {Boolean}
+                 * @default true
+                 * @since 3.0.10
+                 * @product highcharts
+                 */
+                reversed: true
+            });
 
     }(Highcharts));
 }));

data/app/assets/javascripts/highcharts/modules/grid-axis.js

@@ -1,5 +1,5 @@
 /**
- * @license Highcharts JS v5.0.12 (2017-05-24)
+ * @license Highcharts JS v5.0.13 (2017-07-27)
  * GridAxis
  *
  * (c) 2016 Lars A. V. Cabrera

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

@@ -1,5 +1,5 @@
 /**
- * @license Highcharts JS v5.0.12 (2017-05-24)
+ * @license Highcharts JS v5.0.13 (2017-07-27)
  *
  * (c) 2009-2017 Torstein Honsi
  *
@@ -41,31 +41,198 @@
         };
         extend(ColorAxis.prototype, Axis.prototype);
         extend(ColorAxis.prototype, {
+            /**	 
+             * @extends {xAxis}
+             * @optionparent colorAxis
+             */
             defaultColorAxisOptions: {
+
+                /**
+                 */
                 lineWidth: 0,
+
+                /**
+                 * Padding of the min value relative to the length of the axis. A
+                 * padding of 0.05 will make a 100px axis 5px longer.
+                 * 
+                 * @type {Number}
+                 * @product highmaps
+                 */
                 minPadding: 0,
+
+                /**
+                 * Padding of the max value relative to the length of the axis. A
+                 * padding of 0.05 will make a 100px axis 5px longer.
+                 * 
+                 * @type {Number}
+                 * @product highmaps
+                 */
                 maxPadding: 0,
+
+                /**
+                 * The width of the grid lines extending from the axis across the
+                 * gradient of a scalar color axis.
+                 * 
+                 * @type {Number}
+                 * @sample {highmaps} maps/coloraxis/gridlines/ Grid lines demonstrated
+                 * @default 1
+                 * @product highmaps
+                 */
                 gridLineWidth: 1,
+
+                /**
+                 * If [tickInterval](#colorAxis.tickInterval) is `null` this option
+                 * sets the approximate pixel interval of the tick marks.
+                 * 
+                 * @type {Number}
+                 * @default 72
+                 * @product highmaps
+                 */
                 tickPixelInterval: 72,
+
+                /**
+                 * Whether to force the axis to start on a tick. Use this option with
+                 * the `maxPadding` option to control the axis start.
+                 * 
+                 * @type {Boolean}
+                 * @default true
+                 * @product highmaps
+                 */
                 startOnTick: true,
+
+                /**
+                 * Whether to force the axis to end on a tick. Use this option with
+                 * the [maxPadding](#colorAxis.maxPadding) option to control the axis
+                 * end.
+                 * 
+                 * @type {Boolean}
+                 * @default true
+                 * @product highmaps
+                 */
                 endOnTick: true,
+
+                /**
+                 */
                 offset: 0,
+
+                /**
+                 * The triangular marker on a scalar color axis that points to the
+                 * value of the hovered area. To disable the marker, set `marker:
+                 * null`.
+                 * 
+                 * @type {Object}
+                 * @sample {highmaps} maps/coloraxis/marker/ Black marker
+                 * @product highmaps
+                 */
                 marker: {
+
+                    /**
+                     * Animation for the marker as it moves between values. Set to `false`
+                     * to disable animation. Defaults to `{ duration: 50 }`.
+                     * 
+                     * @type {Object|Boolean}
+                     * @product highmaps
+                     */
                     animation: {
+
+                        /**
+                         */
                         duration: 50
                     },
+
+                    /**
+                     */
                     width: 0.01,
 
+
+                    /**
+                     * The color of the marker.
+                     * 
+                     * @type {Color}
+                     * @default #999999
+                     * @product highmaps
+                     */
                     color: '#999999'
 
                 },
+
+                /**
+                 * The axis labels show the number for each tick.
+                 * 
+                 * For more live examples on label options, see [xAxis.labels in the
+                 * Highcharts API.](/highcharts#xAxis.labels)
+                 * 
+                 * @type {Object}
+                 * @extends xAxis.labels
+                 * @product highmaps
+                 */
                 labels: {
+
+                    /**
+                     * How to handle overflowing labels on horizontal axis. Can be undefined
+                     * or "justify". If "justify", labels will not render outside the
+                     * plot area. If there is room to move it, it will be aligned to
+                     * the edge, else it will be removed.
+                     * 
+                     * @validvalue [null, "justify"]
+                     * @type {String}
+                     * @default justify
+                     * @product highmaps
+                     */
                     overflow: 'justify',
+
+                    /**
+                     */
                     rotation: 0
                 },
+
+                /**
+                 * The color to represent the minimum of the color axis. Unless [dataClasses](#colorAxis.
+                 * dataClasses) or [stops](#colorAxis.stops) are set, the gradient
+                 * starts at this value.
+                 * 
+                 * If dataClasses are set, the color is based on minColor and maxColor
+                 * unless a color is set for each data class, or the [dataClassColor](#colorAxis.
+                 * dataClassColor) is set.
+                 * 
+                 * @type {Color}
+                 * @sample {highmaps} maps/coloraxis/mincolor-maxcolor/ Min and max colors on scalar (gradient) axis
+                 * @sample {highmaps} maps/coloraxis/mincolor-maxcolor-dataclasses/ On data classes
+                 * @default #e6ebf5
+                 * @product highmaps
+                 */
                 minColor: '#e6ebf5',
+
+                /**
+                 * The color to represent the maximum of the color axis. Unless [dataClasses](#colorAxis.
+                 * dataClasses) or [stops](#colorAxis.stops) are set, the gradient
+                 * ends at this value.
+                 * 
+                 * If dataClasses are set, the color is based on minColor and maxColor
+                 * unless a color is set for each data class, or the [dataClassColor](#colorAxis.
+                 * dataClassColor) is set.
+                 * 
+                 * @type {Color}
+                 * @sample {highmaps} maps/coloraxis/mincolor-maxcolor/ Min and max colors on scalar (gradient) axis
+                 * @sample {highmaps} maps/coloraxis/mincolor-maxcolor-dataclasses/ On data classes
+                 * @default #003399
+                 * @product highmaps
+                 */
                 maxColor: '#003399',
+
+                /**
+                 */
                 tickLength: 5,
+
+                /**
+                 * Whether to display the colorAxis in the legend.
+                 * 
+                 * @type {Boolean}
+                 * @see [heatmap.showInLegend](#series<heatmap>.showInLegend)
+                 * @default true
+                 * @since 4.2.7
+                 * @product highmaps
+                 */
                 showInLegend: true
             },
 
@@ -100,7 +267,7 @@
                 Axis.prototype.init.call(this, chart, options);
 
                 // Base init() pushes it to the xAxis array, now pop it again
-                //chart[this.isXAxis ? 'xAxis' : 'yAxis'].pop();
+                // chart[this.isXAxis ? 'xAxis' : 'yAxis'].pop();
 
                 // Prepare data classes
                 if (userOptions.dataClasses) {
@@ -131,30 +298,44 @@
 
                     dataClass = merge(dataClass);
                     dataClasses.push(dataClass);
-                    if (!dataClass.color) {
-                        if (options.dataClassColor === 'category') {
 
-                            colors = chart.options.colors;
-                            colorCount = colors.length;
-                            dataClass.color = colors[colorCounter];
 
-                            dataClass.colorIndex = colorCounter;
+                    if (dataClass.color) {
+                        return;
+                    }
 
-                            // increase and loop back to zero
-                            colorCounter++;
-                            if (colorCounter === colorCount) {
-                                colorCounter = 0;
-                            }
-                        } else {
-                            dataClass.color = color(options.minColor).tweenTo(
-                                color(options.maxColor),
-                                len < 2 ? 0.5 : i / (len - 1) // #3219
-                            );
+                    if (options.dataClassColor === 'category') {
+
+                        colors = chart.options.colors;
+                        colorCount = colors.length;
+                        dataClass.color = colors[colorCounter];
+
+                        dataClass.colorIndex = colorCounter;
+
+                        // increase and loop back to zero
+                        colorCounter++;
+                        if (colorCounter === colorCount) {
+                            colorCounter = 0;
                         }
+                    } else {
+                        dataClass.color = color(options.minColor).tweenTo(
+                            color(options.maxColor),
+                            len < 2 ? 0.5 : i / (len - 1) // #3219
+                        );
                     }
                 });
             },
 
+            /**
+             * Override so that ticks are not added in data class axes (#6914)
+             */
+            setTickPositions: function() {
+                if (!this.dataClasses) {
+                    return Axis.prototype.setTickPositions.call(this);
+                }
+            },
+
+
             initStops: function() {
                 this.stops = this.options.stops || [
                     [0, this.options.minColor],
@@ -195,8 +376,13 @@
                     this.len = this.horiz ? width : height;
                     this.pos = this.horiz ? x : y;
                 } else {
-                    // Fake length for disabled legend to avoid tick issues and such (#5205)
-                    this.len = (this.horiz ? legendOptions.symbolWidth : legendOptions.symbolHeight) || this.defaultLegendLength;
+                    // Fake length for disabled legend to avoid tick issues
+                    // and such (#5205)
+                    this.len = (
+                        this.horiz ?
+                        legendOptions.symbolWidth :
+                        legendOptions.symbolHeight
+                    ) || this.defaultLegendLength;
                 }
             },
 
@@ -226,8 +412,13 @@
                         dataClass = dataClasses[i];
                         from = dataClass.from;
                         to = dataClass.to;
-                        if ((from === undefined || value >= from) && (to === undefined || value <= to)) {
+                        if (
+                            (from === undefined || value >= from) &&
+                            (to === undefined || value <= to)
+                        ) {
+
                             color = dataClass.color;
+
                             if (point) {
                                 point.dataClass = i;
                                 point.colorIndex = dataClass.colorIndex;
@@ -260,7 +451,8 @@
             },
 
             /**
-             * Override the getOffset method to add the whole axis groups inside the legend.
+             * Override the getOffset method to add the whole axis groups inside
+             * the legend.
              */
             getOffset: function() {
                 var group = this.legendGroup,
@@ -316,8 +508,14 @@
                 var padding = legend.padding,
                     legendOptions = legend.options,
                     horiz = this.horiz,
-                    width = pick(legendOptions.symbolWidth, horiz ? this.defaultLegendLength : 12),
-                    height = pick(legendOptions.symbolHeight, horiz ? 12 : this.defaultLegendLength),
+                    width = pick(
+                        legendOptions.symbolWidth,
+                        horiz ? this.defaultLegendLength : 12
+                    ),
+                    height = pick(
+                        legendOptions.symbolHeight,
+                        horiz ? 12 : this.defaultLegendLength
+                    ),
                     labelPadding = pick(legendOptions.labelPadding, horiz ? 16 : 30),
                     itemDistance = pick(legendOptions.itemDistance, 10);
 
@@ -334,7 +532,8 @@
                 }).add(item.legendGroup);
 
                 // Set how much space this legend item takes up
-                this.legendItemWidth = width + padding + (horiz ? itemDistance : labelPadding);
+                this.legendItemWidth = width + padding +
+                    (horiz ? itemDistance : labelPadding);
                 this.legendItemHeight = height + padding + (horiz ? labelPadding : 0);
             },
             /**
@@ -391,8 +590,25 @@
                 }
             },
             getPlotLinePath: function(a, b, c, d, pos) {
-                return isNumber(pos) ? // crosshairs only // #3969 pos can be 0 !!
-                    (this.horiz ? ['M', pos - 4, this.top - 6, 'L', pos + 4, this.top - 6, pos, this.top, 'Z'] : ['M', this.left, pos, 'L', this.left - 6, pos + 6, this.left - 6, pos - 6, 'Z']) :
+                // crosshairs only
+                return isNumber(pos) ? // pos can be 0 (#3969)
+                    (
+                        this.horiz ? [
+                            'M',
+                            pos - 4, this.top - 6,
+                            'L',
+                            pos + 4, this.top - 6,
+                            pos, this.top,
+                            'Z'
+                        ] : [
+                            'M',
+                            this.left, pos,
+                            'L',
+                            this.left - 6, pos + 6,
+                            this.left - 6, pos - 6,
+                            'Z'
+                        ]
+                    ) :
                     Axis.prototype.getPlotLinePath.call(this, a, b, c, d);
             },
 
@@ -401,10 +617,12 @@
                     legend = chart.legend;
 
                 each(this.series, function(series) {
-                    series.isDirtyData = true; // Needed for Axis.update when choropleth colors change
+                    // Needed for Axis.update when choropleth colors change
+                    series.isDirtyData = true;
                 });
 
-                // When updating data classes, destroy old items and make sure new ones are created (#3207)
+                // When updating data classes, destroy old items and make sure new ones
+                // are created (#3207)
                 if (newOptions.dataClasses && legend.allItems) {
                     each(legend.allItems, function(item) {
                         if (item.isDataClass && item.legendGroup) {
@@ -414,8 +632,8 @@
                     chart.isDirtyLegend = true;
                 }
 
-                // Keep the options structure updated for export. Unlike xAxis and yAxis, the colorAxis is
-                // not an array. (#3207)
+                // Keep the options structure updated for export. Unlike xAxis and
+                // yAxis, the colorAxis is not an array. (#3207)
                 chart.options[this.coll] = merge(this.userOptions, newOptions);
 
                 Axis.prototype.update.call(this, newOptions, redraw);
@@ -453,7 +671,8 @@
                             from = dataClass.from,
                             to = dataClass.to;
 
-                        // Assemble the default name. This can be overridden by legend.options.labelFormatter
+                        // Assemble the default name. This can be overridden
+                        // by legend.options.labelFormatter
                         name = '';
                         if (from === undefined) {
                             name = '< ';
@@ -533,8 +752,8 @@
 
 
         /**
-         * Wrap the legend getAllItems method to add the color axis. This also removes the
-         * axis' own series to prevent them from showing up individually.
+         * Wrap the legend getAllItems method to add the color axis. This also removes
+         * the axis' own series to prevent them from showing up individually.
          */
         wrap(Legend.prototype, 'getAllItems', function(proceed) {
             var allItems = [],
@@ -544,7 +763,9 @@
                 if (colorAxis.options.showInLegend) {
                     // Data classes
                     if (colorAxis.options.dataClasses) {
-                        allItems = allItems.concat(colorAxis.getDataClassLegendSymbols());
+                        allItems = allItems.concat(
+                            colorAxis.getDataClassLegendSymbols()
+                        );
                         // Gradient legend
                     } else {
                         // Add this axis on top
@@ -570,6 +791,15 @@
             }
         });
 
+        // Updates in the legend need to be reflected in the color axis (6888)
+        wrap(Legend.prototype, 'update', function(proceed) {
+            proceed.apply(this, [].slice.call(arguments, 1));
+
+            if (this.chart.colorAxis[0]) {
+                this.chart.colorAxis[0].update({}, arguments[2]);
+            }
+        });
+
     }(Highcharts));
     (function(H) {
         /**
@@ -587,7 +817,8 @@
          */
         H.colorPointMixin = {
             /**
-             * Color points have a value option that determines whether or not it is a null point
+             * Color points have a value option that determines whether or not it is
+             * a null point
              */
             isValid: function() {
                 return this.value !== null;
@@ -631,7 +862,8 @@
 
 
             /**
-             * In choropleth maps, the color is a result of the value, so this needs translation too
+             * In choropleth maps, the color is a result of the value, so this needs
+             * translation too
              */
             translateColors: function() {
                 var series = this,
@@ -644,7 +876,13 @@
                         color;
 
                     color = point.options.color ||
-                        (point.isNull ? nullColor : (colorAxis && value !== undefined) ? colorAxis.toColor(value, point) : point.color || series.color);
+                        (
+                            point.isNull ?
+                            nullColor :
+                            (colorAxis && value !== undefined) ?
+                            colorAxis.toColor(value, point) :
+                            point.color || series.color
+                        );
 
                     if (color) {
                         point.color = color;
@@ -683,40 +921,104 @@
             seriesTypes = H.seriesTypes;
 
         // The Heatmap series type
+
+        /**
+         * @extends {plotOptions.scatter}
+         * @optionparent plotOptions.heatmap
+         */
         seriesType('heatmap', 'scatter', {
+
+            /**
+             */
             animation: false,
+
+            /**
+             */
             borderWidth: 0,
 
+
+            /**
+             */
             nullColor: '#f7f7f7',
 
+
+            /**
+             */
             dataLabels: {
+
+                /**
+                 */
                 formatter: function() { // #2945
                     return this.point.value;
                 },
+
+                /**
+                 */
                 inside: true,
+
+                /**
+                 */
                 verticalAlign: 'middle',
+
+                /**
+                 */
                 crop: false,
+
+                /**
+                 */
                 overflow: false,
+
+                /**
+                 */
                 padding: 0 // #3837
             },
+
+            /**
+             */
             marker: null,
+
+            /**
+             */
             pointRange: null, // dynamically set to colsize by default
+
+            /**
+             */
             tooltip: {
+
+                /**
+                 */
                 pointFormat: '{point.x}, {point.y}: {point.value}<br/>'
             },
+
+            /**
+             */
             states: {
+
+                /**
+                 */
                 normal: {
+
+                    /**
+                     */
                     animation: true
                 },
+
+                /**
+                 */
                 hover: {
+
+                    /**
+                     */
                     halo: false, // #3406, halo is not required on heatmaps
+
+                    /**
+                     */
                     brightness: 0.2
                 }
             }
         }, merge(colorSeriesMixin, {
             pointArrayMap: ['y', 'value'],
             hasPointSpecificOptions: true,
-            supportsDrilldown: true,
             getExtremesFromAll: true,
             directTouch: true,
 
@@ -728,7 +1030,8 @@
                 seriesTypes.scatter.prototype.init.apply(this, arguments);
 
                 options = this.options;
-                options.pointRange = pick(options.pointRange, options.colsize || 1); // #3758, prevent resetting in setData
+                // #3758, prevent resetting in setData
+                options.pointRange = pick(options.pointRange, options.colsize || 1);
                 this.yAxis.axisPointRange = options.rowsize || 1; // general point range
             },
             translate: function() {
@@ -745,10 +1048,24 @@
                 each(series.points, function(point) {
                     var xPad = (options.colsize || 1) / 2,
                         yPad = (options.rowsize || 1) / 2,
-                        x1 = between(Math.round(xAxis.len - xAxis.translate(point.x - xPad, 0, 1, 0, 1)), -xAxis.len, 2 * xAxis.len),
-                        x2 = between(Math.round(xAxis.len - xAxis.translate(point.x + xPad, 0, 1, 0, 1)), -xAxis.len, 2 * xAxis.len),
-                        y1 = between(Math.round(yAxis.translate(point.y - yPad, 0, 1, 0, 1)), -yAxis.len, 2 * yAxis.len),
-                        y2 = between(Math.round(yAxis.translate(point.y + yPad, 0, 1, 0, 1)), -yAxis.len, 2 * yAxis.len);
+                        x1 = between(
+                            Math.round(
+                                xAxis.len -
+                                xAxis.translate(point.x - xPad, 0, 1, 0, 1)
+                            ), -xAxis.len, 2 * xAxis.len
+                        ),
+                        x2 = between(
+                            Math.round(
+                                xAxis.len -
+                                xAxis.translate(point.x + xPad, 0, 1, 0, 1)
+                            ), -xAxis.len, 2 * xAxis.len
+                        ),
+                        y1 = between(
+                            Math.round(yAxis.translate(point.y - yPad, 0, 1, 0, 1)), -yAxis.len, 2 * yAxis.len
+                        ),
+                        y2 = between(
+                            Math.round(yAxis.translate(point.y + yPad, 0, 1, 0, 1)), -yAxis.len, 2 * yAxis.len
+                        );
 
                     // Set plotX and plotY for use in K-D-Tree and more
                     point.plotX = point.clientX = (x1 + x2) / 2;