aw-highstock_rails 7.0.3

data/vendor/assets/javascripts/highstock/es-modules/modules/variwide.src.js

@@ -0,0 +1,350 @@
+/* *
+ * Highcharts variwide module
+ *
+ * (c) 2010-2019 Torstein Honsi
+ *
+ * License: www.highcharts.com/license
+ */
+
+'use strict';
+
+import H from '../parts/Globals.js';
+import '../parts/AreaSeries.js';
+
+var addEvent = H.addEvent,
+    seriesType = H.seriesType,
+    seriesTypes = H.seriesTypes,
+    pick = H.pick;
+
+/**
+ * @private
+ * @class
+ * @name Highcharts.seriesTypes.variwide
+ *
+ * @augments Highcharts.Series
+ */
+seriesType('variwide', 'column'
+
+    /**
+ * A variwide chart (related to marimekko chart) is a column chart with a
+ * variable width expressing a third dimension.
+ *
+ * @sample {highcharts} highcharts/demo/variwide/
+ *         Variwide chart
+ * @sample {highcharts} highcharts/series-variwide/inverted/
+ *         Inverted variwide chart
+ * @sample {highcharts} highcharts/series-variwide/datetime/
+ *         Variwide columns on a datetime axis
+ *
+ * @extends      plotOptions.column
+ * @since        6.0.0
+ * @product      highcharts
+ * @excluding    boostThreshold, crisp, depth, edgeColor, edgeWidth,
+ *               groupZPadding
+ * @optionparent plotOptions.variwide
+ */
+    , {
+    /**
+     * In a variwide chart, the point padding is 0 in order to express the
+     * horizontal stacking of items.
+     */
+        pointPadding: 0,
+        /**
+     * In a variwide chart, the group padding is 0 in order to express the
+     * horizontal stacking of items.
+     */
+        groupPadding: 0
+    }, {
+        pointArrayMap: ['y', 'z'],
+        parallelArrays: ['x', 'y', 'z'],
+        processData: function (force) {
+            this.totalZ = 0;
+            this.relZ = [];
+            seriesTypes.column.prototype.processData.call(this, force);
+
+            (this.xAxis.reversed ?
+                this.zData.slice().reverse() :
+                this.zData).forEach(
+                function (z, i) {
+                    this.relZ[i] = this.totalZ;
+                    this.totalZ += z;
+                },
+                this
+            );
+
+            if (this.xAxis.categories) {
+                this.xAxis.variwide = true;
+                this.xAxis.zData = this.zData; // Used for label rank
+            }
+        },
+
+        /**
+     * Translate an x value inside a given category index into the distorted
+     * axis translation.
+     *
+     * @private
+     * @function Highcharts.Series#postTranslate
+     *
+     * @param {number} index
+     *        The category index
+     *
+     * @param {number} x
+     *        The X pixel position in undistorted axis pixels
+     *
+     * @return {number}
+     *         Distorted X position
+     */
+        postTranslate: function (index, x, point) {
+
+            var axis = this.xAxis,
+                relZ = this.relZ,
+                i = axis.reversed ? relZ.length - index : index,
+                goRight = axis.reversed ? -1 : 1,
+                len = axis.len,
+                totalZ = this.totalZ,
+                linearSlotLeft = i / relZ.length * len,
+                linearSlotRight = (i + goRight) / relZ.length * len,
+                slotLeft = (pick(relZ[i], totalZ) / totalZ) * len,
+                slotRight = (pick(relZ[i + goRight], totalZ) / totalZ) * len,
+                xInsideLinearSlot = x - linearSlotLeft,
+                ret;
+
+            // Set crosshairWidth for every point (#8173)
+            if (point) {
+                point.crosshairWidth = slotRight - slotLeft;
+            }
+
+            ret = slotLeft +
+            xInsideLinearSlot * (slotRight - slotLeft) /
+            (linearSlotRight - linearSlotLeft);
+
+            return ret;
+        },
+
+        // Extend translation by distoring X position based on Z.
+        translate: function () {
+
+            // Temporarily disable crisping when computing original shapeArgs
+            var crispOption = this.options.crisp,
+                xAxis = this.xAxis;
+
+            this.options.crisp = false;
+
+            seriesTypes.column.prototype.translate.call(this);
+
+            // Reset option
+            this.options.crisp = crispOption;
+
+            var inverted = this.chart.inverted,
+                crisp = this.borderWidth % 2 / 2;
+
+            // Distort the points to reflect z dimension
+            this.points.forEach(function (point, i) {
+                var left, right;
+
+                if (xAxis.variwide) {
+                    left = this.postTranslate(
+                        i,
+                        point.shapeArgs.x,
+                        point
+                    );
+
+                    right = this.postTranslate(
+                        i,
+                        point.shapeArgs.x + point.shapeArgs.width
+                    );
+
+                    // For linear or datetime axes, the variwide column should
+                    // start with X and extend Z units, without modifying the
+                    // axis.
+                } else {
+                    left = point.plotX;
+                    right = xAxis.translate(
+                        point.x + point.z,
+                        0,
+                        0,
+                        0,
+                        1
+                    );
+                }
+
+                if (this.options.crisp) {
+                    left = Math.round(left) - crisp;
+                    right = Math.round(right) - crisp;
+                }
+
+                point.shapeArgs.x = left;
+                point.shapeArgs.width = right - left;
+
+                // Crosshair position (#8083)
+                point.plotX = (left + right) / 2;
+
+                // Adjust the tooltip position
+                if (!inverted) {
+                    point.tooltipPos[0] =
+                    point.shapeArgs.x + point.shapeArgs.width / 2;
+                } else {
+                    point.tooltipPos[1] =
+                    xAxis.len - point.shapeArgs.x - point.shapeArgs.width / 2;
+                }
+            }, this);
+        }
+
+        // Point functions
+    }, {
+        isValid: function () {
+            return H.isNumber(this.y, true) && H.isNumber(this.z, true);
+        }
+    });
+
+H.Tick.prototype.postTranslate = function (xy, xOrY, index) {
+    var axis = this.axis,
+        pos = xy[xOrY] - axis.pos;
+
+    if (!axis.horiz) {
+        pos = axis.len - pos;
+    }
+    pos = axis.series[0].postTranslate(index, pos);
+
+    if (!axis.horiz) {
+        pos = axis.len - pos;
+    }
+    xy[xOrY] = axis.pos + pos;
+};
+
+// Same width as the category (#8083)
+addEvent(H.Axis, 'afterDrawCrosshair', function (e) {
+    if (this.variwide && this.cross) {
+        this.cross.attr('stroke-width', e.point && e.point.crosshairWidth);
+    }
+});
+
+// On a vertical axis, apply anti-collision logic to the labels.
+addEvent(H.Axis, 'afterRender', function () {
+    var axis = this;
+
+    if (!this.horiz && this.variwide) {
+        this.chart.labelCollectors.push(function () {
+            return axis.tickPositions.map(function (pos, i) {
+                var label = axis.ticks[pos].label;
+
+                label.labelrank = axis.zData[i];
+                return label;
+            });
+        });
+    }
+});
+
+addEvent(H.Tick, 'afterGetPosition', function (e) {
+    var axis = this.axis,
+        xOrY = axis.horiz ? 'x' : 'y';
+
+    if (axis.variwide) {
+        this[xOrY + 'Orig'] = e.pos[xOrY];
+        this.postTranslate(e.pos, xOrY, this.pos);
+    }
+});
+
+H.wrap(H.Tick.prototype, 'getLabelPosition', function (
+    proceed,
+    x,
+    y,
+    label,
+    horiz,
+    labelOptions,
+    tickmarkOffset,
+    index
+) {
+    var args = Array.prototype.slice.call(arguments, 1),
+        xy,
+        xOrY = horiz ? 'x' : 'y';
+
+    // Replace the x with the original x
+    if (this.axis.variwide && typeof this[xOrY + 'Orig'] === 'number') {
+        args[horiz ? 0 : 1] = this[xOrY + 'Orig'];
+    }
+
+    xy = proceed.apply(this, args);
+
+    // Post-translate
+    if (this.axis.variwide && this.axis.categories) {
+        this.postTranslate(xy, xOrY, index);
+    }
+    return xy;
+});
+
+
+/**
+ * A `variwide` series. If the [type](#series.variwide.type) option is not
+ * specified, it is inherited from [chart.type](#chart.type).
+ *
+ * @extends   series,plotOptions.variwide
+ * @product   highcharts
+ * @apioption series.variwide
+ */
+
+/**
+ * An array of data points for the series. For the `variwide` series type,
+ * points can be given in the following ways:
+ *
+ * 1. An array of arrays with 3 or 2 values. In this case, the values correspond
+ *    to `x,y,z`. If the first value is a string, it is applied as the name of
+ *    the point, and the `x` value is inferred. The `x` value can also be
+ *    omitted, in which case the inner arrays should be of length 2. Then the
+ *    `x` value is automatically calculated, either starting at 0 and
+ *    incremented by 1, or from `pointStart` and `pointInterval` given in the
+ *    series options.
+ *    ```js
+ *       data: [
+ *           [0, 1, 2],
+ *           [1, 5, 5],
+ *           [2, 0, 2]
+ *       ]
+ *    ```
+ *
+ * 2. 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.variwide.turboThreshold), this option is not
+ *    available.
+ *    ```js
+ *       data: [{
+ *           x: 1,
+ *           y: 1,
+ *           z: 1,
+ *           name: "Point2",
+ *           color: "#00FF00"
+ *       }, {
+ *           x: 1,
+ *           y: 5,
+ *           z: 4,
+ *           name: "Point1",
+ *           color: "#FF00FF"
+ *       }]
+ *    ```
+ *
+ * @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<Array<(number|string),number>|Array<(number|string),number,number>|*>}
+ * @extends   series.line.data
+ * @excluding marker
+ * @product   highcharts
+ * @apioption series.variwide.data
+ */
+
+/**
+ * The relative width for each column. On a category axis, the widths are
+ * distributed so they sum up to the X axis length. On linear and datetime axes,
+ * the columns will be laid out from the X value and Z units along the axis.
+ *
+ * @type      {number}
+ * @product   highcharts
+ * @apioption series.variwide.data.z
+ */

data/vendor/assets/javascripts/highstock/es-modules/modules/vector.src.js

@@ -0,0 +1,354 @@
+/* *
+ * Vector plot series module
+ *
+ * (c) 2010-2019 Torstein Honsi
+ *
+ * License: www.highcharts.com/license
+ */
+
+'use strict';
+
+import H from '../parts/Globals.js';
+
+var seriesType = H.seriesType;
+
+/**
+ * The vector series class.
+ *
+ * @private
+ * @class
+ * @name Highcharts.seriesTypes.vector
+ *
+ * @augments Highcharts.seriesTypes.scatter
+ */
+seriesType('vector', 'scatter'
+
+    /**
+ * A vector plot is a type of cartesian chart where each point has an X and Y
+ * position, a length and a direction. Vectors are drawn as arrows.
+ *
+ * @sample {highcharts|highstock} highcharts/demo/vector-plot/
+ *         Vector pot
+ *
+ * @since        6.0.0
+ * @extends      plotOptions.scatter
+ * @excluding    boostThreshold, marker, connectEnds, connectNulls,
+ *               cropThreshold, dashStyle, gapSize, gapUnit, dataGrouping,
+ *               linecap, shadow, stacking, step, jitter
+ * @product      highcharts highstock
+ * @optionparent plotOptions.vector
+ */
+    , {
+
+        /**
+     * The line width for each vector arrow.
+     */
+        lineWidth: 2,
+
+        /**
+     * @ignore
+     */
+        marker: null,
+
+        /**
+     * What part of the vector it should be rotated around. Can be one of
+     * `start`, `center` and `end`. When `start`, the vectors will start from
+     * the given [x, y] position, and when `end` the vectors will end in the
+     * [x, y] position.
+     *
+     * @sample highcharts/plotoptions/vector-rotationorigin-start/
+     *         Rotate from start
+     *
+     * @validvalue ["start", "center", "end"]
+     */
+        rotationOrigin: 'center',
+
+        states: {
+
+            hover: {
+
+                /**
+             * Additonal line width for the vector errors when they are hovered.
+             */
+                lineWidthPlus: 1
+            }
+        },
+
+        tooltip: {
+
+            /**
+         * @default [{point.x}, {point.y}] Length: {point.length} Direction: {point.direction}°
+         */
+            pointFormat: '<b>[{point.x}, {point.y}]</b><br/>Length: <b>{point.length}</b><br/>Direction: <b>{point.direction}\u00B0</b><br/>'
+        },
+
+        /**
+     * Maximum length of the arrows in the vector plot. The individual arrow
+     * length is computed between 0 and this value.
+     */
+        vectorLength: 20
+
+    }, {
+
+        pointArrayMap: ['y', 'length', 'direction'],
+        parallelArrays: ['x', 'y', 'length', 'direction'],
+
+        /**
+     * Get presentational attributes.
+     *
+     * @private
+     * @function Highcharts.seriesTypes.vector#pointAttribs
+     *
+     * @param {Highcharts.Point} point
+     *
+     * @param {string} state
+     *
+     * @return {*}
+     */
+        pointAttribs: function (point, state) {
+            var options = this.options,
+                stroke = point.color || this.color,
+                strokeWidth = this.options.lineWidth;
+
+            if (state) {
+                stroke = options.states[state].color || stroke;
+                strokeWidth =
+                (options.states[state].lineWidth || strokeWidth) +
+                (options.states[state].lineWidthPlus || 0);
+            }
+
+            return {
+                'stroke': stroke,
+                'stroke-width': strokeWidth
+            };
+        },
+
+        /**
+     * @ignore
+     * @deprecated
+     * @function Highcharts.seriesTypes.vector#markerAttribs
+     */
+        markerAttribs: H.noop,
+
+        /**
+     * @ignore
+     * @deprecated
+     * @function Highcharts.seriesTypes.vector#getSymbol
+     */
+        getSymbol: H.noop,
+
+        /**
+     * Create a single arrow. It is later rotated around the zero
+     * centerpoint.
+     *
+     * @private
+     * @function Highcharts.seriesTypes.vector#arrow
+     *
+     * @param {Highcharts.Point} point
+     *
+     * @return {Highcharts.SVGPathArray}
+     */
+        arrow: function (point) {
+            var path,
+                fraction = point.length / this.lengthMax,
+                u = fraction * this.options.vectorLength / 20,
+                o = {
+                    start: 10 * u,
+                    center: 0,
+                    end: -10 * u
+                }[this.options.rotationOrigin] || 0;
+
+            // The stem and the arrow head. Draw the arrow first with rotation
+            // 0, which is the arrow pointing down (vector from north to south).
+            path = [
+                'M', 0, 7 * u + o, // base of arrow
+                'L', -1.5 * u, 7 * u + o,
+                0, 10 * u + o,
+                1.5 * u, 7 * u + o,
+                0, 7 * u + o,
+                0, -10 * u + o// top
+            ];
+
+            return path;
+        },
+
+        /**
+     * @private
+     * @function Highcharts.seriesTypes.vector#translate
+     */
+        translate: function () {
+            H.Series.prototype.translate.call(this);
+
+            this.lengthMax = H.arrayMax(this.lengthData);
+        },
+
+        /**
+     * @private
+     * @function Highcharts.seriesTypes.vector#drawPoints
+     */
+        drawPoints: function () {
+
+            var chart = this.chart;
+
+            this.points.forEach(function (point) {
+                var plotX = point.plotX,
+                    plotY = point.plotY;
+
+                if (chart.isInsidePlot(plotX, plotY, chart.inverted)) {
+
+                    if (!point.graphic) {
+                        point.graphic = this.chart.renderer
+                            .path()
+                            .add(this.markerGroup);
+                    }
+                    point.graphic
+                        .attr({
+                            d: this.arrow(point),
+                            translateX: plotX,
+                            translateY: plotY,
+                            rotation: point.direction
+                        })
+                        .attr(this.pointAttribs(point));
+
+                } else if (point.graphic) {
+                    point.graphic = point.graphic.destroy();
+                }
+
+            }, this);
+        },
+
+        /**
+     * @ignore
+     * @deprecated
+     * @function Highcharts.seriesTypes.vector#drawGraph
+     */
+        drawGraph: H.noop,
+
+        /*
+    drawLegendSymbol: function (legend, item) {
+        var options = legend.options,
+            symbolHeight = legend.symbolHeight,
+            square = options.squareSymbol,
+            symbolWidth = square ? symbolHeight : legend.symbolWidth,
+            path = this.arrow.call({
+                lengthMax: 1,
+                options: {
+                    vectorLength: symbolWidth
+                }
+            }, {
+                length: 1
+            });
+
+        item.legendLine = this.chart.renderer.path(path)
+        .addClass('highcharts-point')
+        .attr({
+            zIndex: 3,
+            translateY: symbolWidth / 2,
+            rotation: 270,
+            'stroke-width': 1,
+            'stroke': 'black'
+        }).add(item.legendGroup);
+
+    },
+    */
+
+        /**
+     * Fade in the arrows on initializing series.
+     *
+     * @private
+     * @function Highcharts.seriesTypes.vector#animate
+     *
+     * @param {boolean} [init]
+     */
+        animate: function (init) {
+            if (init) {
+                this.markerGroup.attr({
+                    opacity: 0.01
+                });
+            } else {
+                this.markerGroup.animate({
+                    opacity: 1
+                }, H.animObject(this.options.animation));
+
+                this.animate = null;
+            }
+        }
+    });
+
+
+/**
+ * A `vector` series. If the [type](#series.vector.type) option is not
+ * specified, it is inherited from [chart.type](#chart.type).
+ *
+ * @extends   series,plotOptions.vector
+ * @excluding dataParser, dataURL
+ * @product   highcharts highstock
+ * @apioption series.vector
+ */
+
+/**
+ * An array of data points for the series. For the `vector` series type,
+ * points can be given in the following ways:
+ *
+ * 1. An array of arrays with 4 values. In this case, the values correspond to
+ *    to `x,y,length,direction`. 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, 10, 90],
+ *        [0, 1, 5, 180],
+ *        [1, 1, 2, 270]
+ *    ]
+ *    ```
+ *
+ * 2. 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.area.turboThreshold), this option is not
+ *    available.
+ *    ```js
+ *    data: [{
+ *        x: 0,
+ *        y: 0,
+ *        name: "Point2",
+ *        length: 10,
+ *        direction: 90
+ *    }, {
+ *        x: 1,
+ *        y: 1,
+ *        name: "Point1",
+ *        direction: 270
+ *    }]
+ *    ```
+ *
+ * @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<Array<(number|string),number,number,number>|*>}
+ * @extends   series.line.data
+ * @product   highcharts highstock
+ * @apioption series.vector.data
+ */
+
+/**
+ * The length of the vector. The rendered length will relate to the
+ * `vectorLength` setting.
+ *
+ * @type      {number}
+ * @product   highcharts highstock
+ * @apioption series.vector.data.length
+ */
+
+/**
+ * The vector direction in degrees, where 0 is north (pointing towards south).
+ *
+ * @type      {number}
+ * @product   highcharts highstock
+ * @apioption series.vector.data.direction
+ */