aw-highstock_rails 7.0.3

data/vendor/assets/javascripts/highstock/es-modules/parts/Responsive.js

@@ -0,0 +1,295 @@
+/**
+ * (c) 2010-2019 Torstein Honsi
+ *
+ * License: www.highcharts.com/license
+ */
+
+/**
+ * A callback function to gain complete control on when the responsive rule
+ * applies.
+ *
+ * @callback Highcharts.ResponsiveCallbackFunction
+ *
+ * @return {boolean}
+ *         Return `true` if it applies.
+ */
+
+'use strict';
+
+import H from './Globals.js';
+import './Chart.js';
+import './Utilities.js';
+
+var Chart = H.Chart,
+    isArray = H.isArray,
+    isObject = H.isObject,
+    pick = H.pick,
+    splat = H.splat;
+
+/**
+ * Allows setting a set of rules to apply for different screen or chart
+ * sizes. Each rule specifies additional chart options.
+ *
+ * @sample {highstock} stock/demo/responsive/
+ *         Stock chart
+ * @sample highcharts/responsive/axis/
+ *         Axis
+ * @sample highcharts/responsive/legend/
+ *         Legend
+ * @sample highcharts/responsive/classname/
+ *         Class name
+ *
+ * @since     5.0.0
+ * @apioption responsive
+ */
+
+/**
+ * A set of rules for responsive settings. The rules are executed from
+ * the top down.
+ *
+ * @sample {highcharts} highcharts/responsive/axis/
+ *         Axis changes
+ * @sample {highstock} highcharts/responsive/axis/
+ *         Axis changes
+ * @sample {highmaps} highcharts/responsive/axis/
+ *         Axis changes
+ *
+ * @type      {Array<*>}
+ * @since     5.0.0
+ * @apioption responsive.rules
+ */
+
+/**
+ * A full set of chart options to apply as overrides to the general
+ * chart options. The chart options are applied when the given rule
+ * is active.
+ *
+ * A special case is configuration objects that take arrays, for example
+ * [xAxis](#xAxis), [yAxis](#yAxis) or [series](#series). For these
+ * collections, an `id` option is used to map the new option set to
+ * an existing object. If an existing object of the same id is not found,
+ * the item of the same indexupdated. So for example, setting `chartOptions`
+ * with two series items without an `id`, will cause the existing chart's
+ * two series to be updated with respective options.
+ *
+ * @sample {highstock} stock/demo/responsive/
+ *         Stock chart
+ * @sample highcharts/responsive/axis/
+ *         Axis
+ * @sample highcharts/responsive/legend/
+ *         Legend
+ * @sample highcharts/responsive/classname/
+ *         Class name
+ *
+ * @type      {Highcharts.Options}
+ * @since     5.0.0
+ * @apioption responsive.rules.chartOptions
+ */
+
+/**
+ * Under which conditions the rule applies.
+ *
+ * @since     5.0.0
+ * @apioption responsive.rules.condition
+ */
+
+/**
+ * A callback function to gain complete control on when the responsive
+ * rule applies. Return `true` if it applies. This opens for checking
+ * against other metrics than the chart size, or example the document
+ * size or other elements.
+ *
+ * @type      {Highcharts.ResponsiveCallbackFunction}
+ * @since     5.0.0
+ * @context   Highcharts.Chart
+ * @apioption responsive.rules.condition.callback
+ */
+
+/**
+ * The responsive rule applies if the chart height is less than this.
+ *
+ * @type      {number}
+ * @since     5.0.0
+ * @apioption responsive.rules.condition.maxHeight
+ */
+
+/**
+ * The responsive rule applies if the chart width is less than this.
+ *
+ * @sample highcharts/responsive/axis/
+ *         Max width is 500
+ *
+ * @type      {number}
+ * @since     5.0.0
+ * @apioption responsive.rules.condition.maxWidth
+ */
+
+/**
+ * The responsive rule applies if the chart height is greater than this.
+ *
+ * @type      {number}
+ * @default   0
+ * @since     5.0.0
+ * @apioption responsive.rules.condition.minHeight
+ */
+
+/**
+ * The responsive rule applies if the chart width is greater than this.
+ *
+ * @type      {number}
+ * @default   0
+ * @since     5.0.0
+ * @apioption responsive.rules.condition.minWidth
+ */
+
+/**
+ * Update the chart based on the current chart/document size and options for
+ * responsiveness.
+ *
+ * @private
+ * @function Highcharts.Chart#setResponsive
+ *
+ * @param  {boolean} [redraw=true]
+ * @param  {Array} [reset=false]
+ *         Reset by un-applying all rules. Chart.update resets all rules before
+ *         applying updated options.
+ */
+Chart.prototype.setResponsive = function (redraw, reset) {
+    var options = this.options.responsive,
+        ruleIds = [],
+        currentResponsive = this.currentResponsive,
+        currentRuleIds,
+        undoOptions;
+
+    if (!reset && options && options.rules) {
+        options.rules.forEach(function (rule) {
+            if (rule._id === undefined) {
+                rule._id = H.uniqueKey();
+            }
+
+            this.matchResponsiveRule(rule, ruleIds, redraw);
+        }, this);
+    }
+
+    // Merge matching rules
+    var mergedOptions = H.merge.apply(0, ruleIds.map(function (ruleId) {
+        return H.find(options.rules, function (rule) {
+            return rule._id === ruleId;
+        }).chartOptions;
+    }));
+
+    mergedOptions.isResponsiveOptions = true;
+
+    // Stringified key for the rules that currently apply.
+    ruleIds = ruleIds.toString() || undefined;
+    currentRuleIds = currentResponsive && currentResponsive.ruleIds;
+
+    // Changes in what rules apply
+    if (ruleIds !== currentRuleIds) {
+
+        // Undo previous rules. Before we apply a new set of rules, we need to
+        // roll back completely to base options (#6291).
+        if (currentResponsive) {
+            this.update(currentResponsive.undoOptions, redraw);
+        }
+
+        if (ruleIds) {
+            // Get undo-options for matching rules
+            undoOptions = this.currentOptions(mergedOptions);
+            undoOptions.isResponsiveOptions = true;
+            this.currentResponsive = {
+                ruleIds: ruleIds,
+                mergedOptions: mergedOptions,
+                undoOptions: undoOptions
+            };
+
+            this.update(mergedOptions, redraw);
+
+        } else {
+            this.currentResponsive = undefined;
+        }
+    }
+};
+
+/**
+ * Handle a single responsiveness rule.
+ *
+ * @private
+ * @function Highcharts.Chart#matchResponsiveRule
+ *
+ * @param {Highcharts.ResponsiveRulesConditionOptions} rule
+ *
+ * @param {Array<number>} matches
+ */
+Chart.prototype.matchResponsiveRule = function (rule, matches) {
+
+    var condition = rule.condition,
+        fn = condition.callback || function () {
+            return (
+                this.chartWidth <= pick(condition.maxWidth, Number.MAX_VALUE) &&
+                this.chartHeight <=
+                    pick(condition.maxHeight, Number.MAX_VALUE) &&
+                this.chartWidth >= pick(condition.minWidth, 0) &&
+                this.chartHeight >= pick(condition.minHeight, 0)
+            );
+        };
+
+    if (fn.call(this)) {
+        matches.push(rule._id);
+    }
+};
+
+/**
+ * Get the current values for a given set of options. Used before we update
+ * the chart with a new responsiveness rule.
+ * TODO: Restore axis options (by id?)
+ *
+ * @private
+ * @function Highcharts.Chart#currentOptions
+ *
+ * @param {Highcharts.Options} options
+ *
+ * @return {Highcharts.Options}
+ */
+Chart.prototype.currentOptions = function (options) {
+
+    var ret = {};
+
+    /**
+     * Recurse over a set of options and its current values,
+     * and store the current values in the ret object.
+     */
+    function getCurrent(options, curr, ret, depth) {
+        var i;
+
+        H.objectEach(options, function (val, key) {
+            if (!depth && ['series', 'xAxis', 'yAxis'].indexOf(key) > -1) {
+                val = splat(val);
+
+                ret[key] = [];
+
+                // Iterate over collections like series, xAxis or yAxis and map
+                // the items by index.
+                for (i = 0; i < val.length; i++) {
+                    if (curr[key][i]) { // Item exists in current data (#6347)
+                        ret[key][i] = {};
+                        getCurrent(
+                            val[i],
+                            curr[key][i],
+                            ret[key][i],
+                            depth + 1
+                        );
+                    }
+                }
+            } else if (isObject(val)) {
+                ret[key] = isArray(val) ? [] : {};
+                getCurrent(val, curr[key] || {}, ret[key], depth + 1);
+            } else {
+                ret[key] = curr[key] || null;
+            }
+        });
+    }
+
+    getCurrent(options, this.options, ret, 0);
+    return ret;
+};

data/vendor/assets/javascripts/highstock/es-modules/parts/ScatterSeries.js

@@ -0,0 +1,278 @@
+/* *
+ * (c) 2010-2019 Torstein Honsi
+ *
+ * License: www.highcharts.com/license
+ */
+
+'use strict';
+
+import H from './Globals.js';
+import './Utilities.js';
+import './Options.js';
+import './Series.js';
+
+var Series = H.Series,
+    seriesType = H.seriesType;
+
+/**
+ * Scatter series type.
+ *
+ * @private
+ * @class
+ * @name Highcharts.seriesTypes.scatter
+ *
+ * @augments Highcharts.Series
+ */
+seriesType(
+    'scatter',
+    'line',
+
+    /**
+     * A scatter plot uses cartesian coordinates to display values for two
+     * variables for a set of data.
+     *
+     * @sample {highcharts} highcharts/demo/scatter/
+     *         Scatter plot
+     *
+     * @extends      plotOptions.line
+     * @excluding    pointPlacement, shadow, useOhlcData
+     * @product      highcharts highstock
+     * @optionparent plotOptions.scatter
+     */
+    {
+
+        /**
+         * The width of the line connecting the data points.
+         *
+         * @sample {highcharts} highcharts/plotoptions/scatter-linewidth-none/
+         *         0 by default
+         * @sample {highcharts} highcharts/plotoptions/scatter-linewidth-1/
+         *         1px
+         *
+         * @product highcharts highstock
+         */
+        lineWidth: 0,
+
+        findNearestPointBy: 'xy',
+
+        /**
+         * Apply a jitter effect for the rendered markers. When plotting
+         * discrete values, a little random noise may help telling the points
+         * apart. The jitter setting applies a random displacement of up to `n`
+         * axis units in either direction. So for example on a horizontal X
+         * axis, setting the `jitter.x` to 0.24 will render the point in a
+         * random position between 0.24 units to the left and 0.24 units to the
+         * right of the true axis position. On a category axis, setting it to
+         * 0.5 will fill up the bin and make the data appear continuous.
+         *
+         * When rendered on top of a box plot or a column series, a jitter value
+         * of 0.24 will correspond to the underlying series' default
+         * [groupPadding](
+         * https://api.highcharts.com/highcharts/plotOptions.column.groupPadding)
+         * and [pointPadding](
+         * https://api.highcharts.com/highcharts/plotOptions.column.pointPadding)
+         * settings.
+         *
+         * @sample {highcharts} highcharts/series-scatter/jitter
+         *         Jitter on a scatter plot
+         *
+         * @sample {highcharts} highcharts/series-scatter/jitter-boxplot
+         *         Jittered scatter plot on top of a box plot
+         *
+         * @product highcharts highstock
+         * @since 7.0.2
+         */
+        jitter: {
+            /**
+             * The maximal X offset for the random jitter effect.
+             */
+            x: 0,
+            /**
+             * The maximal Y offset for the random jitter effect.
+             */
+            y: 0
+        },
+
+        marker: {
+
+            enabled: true // Overrides auto-enabling in line series (#3647)
+        },
+
+        /**
+         * Sticky tracking of mouse events. When true, the `mouseOut` event
+         * on a series isn't triggered until the mouse moves over another
+         * series, or out of the plot area. When false, the `mouseOut` event on
+         * a series is triggered when the mouse leaves the area around the
+         * series' graph or markers. This also implies the tooltip. When
+         * `stickyTracking` is false and `tooltip.shared` is false, the tooltip
+         * will be hidden when moving the mouse between series.
+         *
+         * @type      {boolean}
+         * @default   false
+         * @product   highcharts highstock
+         * @apioption plotOptions.scatter.stickyTracking
+         */
+
+        /**
+         * A configuration object for the tooltip rendering of each single
+         * series. Properties are inherited from [tooltip](#tooltip).
+         * Overridable properties are `headerFormat`, `pointFormat`,
+         * `yDecimals`, `xDateFormat`, `yPrefix` and `ySuffix`. Unlike other
+         * series, in a scatter plot the series.name by default shows in the
+         * headerFormat and point.x and point.y in the pointFormat.
+         *
+         * @product highcharts highstock
+         */
+        tooltip: {
+            headerFormat:
+            '<span style="color:{point.color}">\u25CF</span> ' +
+            '<span style="font-size: 10px"> {series.name}</span><br/>',
+            pointFormat: 'x: <b>{point.x}</b><br/>y: <b>{point.y}</b><br/>'
+        }
+
+        // Prototype members
+    }, {
+        sorted: false,
+        requireSorting: false,
+        noSharedTooltip: true,
+        trackerGroups: ['group', 'markerGroup', 'dataLabelsGroup'],
+        takeOrdinalPosition: false, // #2342
+
+        /**
+         * @private
+         * @function Highcharts.seriesTypes.scatter#drawGraph
+         */
+        drawGraph: function () {
+            if (this.options.lineWidth) {
+                Series.prototype.drawGraph.call(this);
+            }
+        },
+
+        // Optionally add the jitter effect
+        applyJitter: function () {
+            var series = this,
+                jitter = this.options.jitter,
+                len = this.points.length;
+
+            // Return a repeatable, pseudo-random number based on an integer
+            // seed
+            function unrandom(seed) {
+                var rand = Math.sin(seed) * 10000;
+                return rand - Math.floor(rand);
+            }
+
+            if (jitter) {
+                this.points.forEach(function (point, i) {
+                    ['x', 'y'].forEach(function (dim, j) {
+                        var axis,
+                            plotProp = 'plot' + dim.toUpperCase(),
+                            min,
+                            max,
+                            translatedJitter;
+                        if (jitter[dim] && !point.isNull) {
+                            axis = series[dim + 'Axis'];
+                            translatedJitter = jitter[dim] * axis.transA;
+                            if (axis && !axis.isLog) {
+
+                                // Identify the outer bounds of the jitter range
+                                min = Math.max(
+                                    0,
+                                    point[plotProp] - translatedJitter
+                                );
+                                max = Math.min(
+                                    axis.len,
+                                    point[plotProp] + translatedJitter
+                                );
+
+                                // Find a random position within this range
+                                point[plotProp] = min +
+                                    (max - min) * unrandom(i + j * len);
+
+                                // Update clientX for the tooltip k-d-tree
+                                if (dim === 'x') {
+                                    point.clientX = point.plotX;
+                                }
+                            }
+                        }
+                    });
+                });
+            }
+        }
+    }
+);
+
+H.addEvent(Series, 'afterTranslate', function () {
+    if (this.applyJitter) {
+        this.applyJitter();
+    }
+});
+
+/**
+ * A `scatter` series. If the [type](#series.scatter.type) option is
+ * not specified, it is inherited from [chart.type](#chart.type).
+ *
+ * @extends   series,plotOptions.scatter
+ * @excluding dataParser, dataURL, useOhlcData
+ * @product   highcharts highstock
+ * @apioption series.scatter
+ */
+
+/**
+ * An array of data points for the series. For the `scatter` series
+ * type, points can be given in the following ways:
+ *
+ * 1. An array of numerical values. In this case, the numerical values will be
+ *    interpreted as `y` options. The `x` values will be automatically
+ *    calculated, either starting at 0 and incremented by 1, or from
+ *    `pointStart` and `pointInterval` given in the series options. If the axis
+ *    has categories, these will be used. Example:
+ *    ```js
+ *    data: [0, 5, 3, 5]
+ *    ```
+ *
+ * 2. An array of arrays with 2 values. In this case, the values correspond to
+ *    `x,y`. If the first value is a string, it is applied as the name of the
+ *    point, and the `x` value is inferred.
+ *    ```js
+ *    data: [
+ *        [0, 0],
+ *        [1, 8],
+ *        [2, 9]
+ *    ]
+ *    ```
+ *
+ * 3. An array of objects with named values. The following snippet shows only a
+ *    few settings, see the complete options set below. If the total number of
+ *    data points exceeds the series'
+ *    [turboThreshold](#series.scatter.turboThreshold), this option is not
+ *    available.
+ *    ```js
+ *    data: [{
+ *        x: 1,
+ *        y: 2,
+ *        name: "Point2",
+ *        color: "#00FF00"
+ *    }, {
+ *        x: 1,
+ *        y: 4,
+ *        name: "Point1",
+ *        color: "#FF00FF"
+ *    }]
+ *    ```
+ *
+ * @sample {highcharts} highcharts/chart/reflow-true/
+ *         Numerical values
+ * @sample {highcharts} highcharts/series/data-array-of-arrays/
+ *         Arrays of numeric x and y
+ * @sample {highcharts} highcharts/series/data-array-of-arrays-datetime/
+ *         Arrays of datetime x and y
+ * @sample {highcharts} highcharts/series/data-array-of-name-value/
+ *         Arrays of point.name and y
+ * @sample {highcharts} highcharts/series/data-array-of-objects/
+ *         Config objects
+ *
+ * @type      {Array<number|Array<(number|string),number>|*>}
+ * @extends   series.line.data
+ * @product   highcharts highstock
+ * @apioption series.scatter.data
+ */