aw-highstock_rails 7.0.3

data/vendor/assets/javascripts/highstock/es-modules/mixins/on-series.js

@@ -0,0 +1,167 @@
+/* *
+ * (c) 2010-2019 Torstein Honsi
+ *
+ * License: www.highcharts.com/license
+ */
+
+'use strict';
+
+import H from '../parts/Globals.js';
+
+var defined = H.defined,
+    seriesTypes = H.seriesTypes,
+    stableSort = H.stableSort;
+
+/**
+ * @private
+ * @mixin onSeriesMixin
+ */
+var onSeriesMixin = {
+
+    /**
+     * Override getPlotBox. If the onSeries option is valid, return the plot box
+     * of the onSeries, otherwise proceed as usual.
+     *
+     * @private
+     * @function onSeriesMixin.getPlotBox
+     *
+     * @return {Highcharts.SeriesPlotBoxObject}
+     */
+    getPlotBox: function () {
+        return H.Series.prototype.getPlotBox.call(
+            (
+                this.options.onSeries &&
+                this.chart.get(this.options.onSeries)
+            ) || this
+        );
+    },
+
+    /**
+     * Extend the translate method by placing the point on the related series
+     *
+     * @private
+     * @function onSeriesMixin.translate
+     */
+    translate: function () {
+
+        seriesTypes.column.prototype.translate.apply(this);
+
+        var series = this,
+            options = series.options,
+            chart = series.chart,
+            points = series.points,
+            cursor = points.length - 1,
+            point,
+            lastPoint,
+            optionsOnSeries = options.onSeries,
+            onSeries = optionsOnSeries && chart.get(optionsOnSeries),
+            onKey = options.onKey || 'y',
+            step = onSeries && onSeries.options.step,
+            onData = onSeries && onSeries.points,
+            i = onData && onData.length,
+            inverted = chart.inverted,
+            xAxis = series.xAxis,
+            yAxis = series.yAxis,
+            xOffset = 0,
+            leftPoint,
+            lastX,
+            rightPoint,
+            currentDataGrouping,
+            distanceRatio;
+
+        // relate to a master series
+        if (onSeries && onSeries.visible && i) {
+            xOffset = (onSeries.pointXOffset || 0) + (onSeries.barW || 0) / 2;
+            currentDataGrouping = onSeries.currentDataGrouping;
+            lastX = (
+                onData[i - 1].x +
+                (currentDataGrouping ? currentDataGrouping.totalRange : 0)
+            ); // #2374
+
+            // sort the data points
+            stableSort(points, function (a, b) {
+                return (a.x - b.x);
+            });
+
+            onKey = 'plot' + onKey[0].toUpperCase() + onKey.substr(1);
+            while (i-- && points[cursor]) {
+                leftPoint = onData[i];
+                point = points[cursor];
+                point.y = leftPoint.y;
+
+                if (leftPoint.x <= point.x && leftPoint[onKey] !== undefined) {
+                    if (point.x <= lastX) { // #803
+
+                        point.plotY = leftPoint[onKey];
+
+                        // interpolate between points, #666
+                        if (leftPoint.x < point.x && !step) {
+                            rightPoint = onData[i + 1];
+                            if (rightPoint && rightPoint[onKey] !== undefined) {
+                                // the distance ratio, between 0 and 1
+                                distanceRatio = (point.x - leftPoint.x) /
+                                    (rightPoint.x - leftPoint.x);
+                                point.plotY +=
+                                    distanceRatio *
+                                    // the plotY distance
+                                    (rightPoint[onKey] - leftPoint[onKey]);
+                                point.y +=
+                                    distanceRatio *
+                                    (rightPoint.y - leftPoint.y);
+                            }
+                        }
+                    }
+                    cursor--;
+                    i++; // check again for points in the same x position
+                    if (cursor < 0) {
+                        break;
+                    }
+                }
+            }
+        }
+
+        // Add plotY position and handle stacking
+        points.forEach(function (point, i) {
+
+            var stackIndex;
+
+            point.plotX += xOffset; // #2049
+
+            // Undefined plotY means the point is either on axis, outside series
+            // range or hidden series. If the series is outside the range of the
+            // x axis it should fall through with an undefined plotY, but then
+            // we must remove the shapeArgs (#847). For inverted charts, we need
+            // to calculate position anyway, because series.invertGroups is not
+            // defined
+            if (point.plotY === undefined || inverted) {
+                if (point.plotX >= 0 && point.plotX <= xAxis.len) {
+                    // We're inside xAxis range
+                    if (inverted) {
+                        point.plotY = xAxis.translate(point.x, 0, 1, 0, 1);
+                        point.plotX = defined(point.y) ?
+                            yAxis.translate(point.y, 0, 0, 0, 1) : 0;
+                    } else {
+                        point.plotY = (xAxis.opposite ? 0 : series.yAxis.len) +
+                            xAxis.offset; // For the windbarb demo
+                    }
+                } else {
+                    point.shapeArgs = {}; // 847
+                }
+            }
+
+            // if multiple flags appear at the same x, order them into a stack
+            lastPoint = points[i - 1];
+            if (lastPoint && lastPoint.plotX === point.plotX) {
+                if (lastPoint.stackIndex === undefined) {
+                    lastPoint.stackIndex = 0;
+                }
+                stackIndex = lastPoint.stackIndex + 1;
+            }
+            point.stackIndex = stackIndex; // #3639
+        });
+
+        this.onSeries = onSeries;
+    }
+};
+
+export default onSeriesMixin;

data/vendor/assets/javascripts/highstock/es-modules/mixins/polygon.js

@@ -0,0 +1,293 @@
+import H from '../parts/Globals.js';
+import '../parts/Utilities.js';
+
+var deg2rad = H.deg2rad,
+    find = H.find,
+    isArray = H.isArray,
+    isNumber = H.isNumber;
+
+/**
+ * Alternative solution to correctFloat.
+ * E.g H.correctFloat(123, 2) returns 120, when it should be 123.
+ *
+ * @private
+ * @function correctFloat
+ *
+ * @param {number} number
+ *
+ * @param {number} precision
+ *
+ * @return {number}
+ */
+var correctFloat = function (number, precision) {
+    var p = isNumber(precision) ? precision : 14,
+        magnitude = Math.pow(10, p);
+
+    return Math.round(number * magnitude) / magnitude;
+};
+
+/**
+ * Calculates the normals to a line between two points.
+ *
+ * @private
+ * @function getNormals
+ *
+ * @param {Array<number,number>} p1
+ *        Start point for the line. Array of x and y value.
+ *
+ * @param {Array<number,number>} p2
+ *        End point for the line. Array of x and y value.
+ *
+ * @return {Array<Array<number,number>>}
+ *         Returns the two normals in an array.
+ */
+var getNormals = function getNormal(p1, p2) {
+    var dx = p2[0] - p1[0], // x2 - x1
+        dy = p2[1] - p1[1]; // y2 - y1
+
+    return [
+        [-dy, dx],
+        [dy, -dx]
+    ];
+};
+
+/**
+ * Calculates the dot product of two coordinates. The result is a scalar value.
+ *
+ * @private
+ * @function dotProduct
+ *
+ * @param {Array<number,number>} a
+ *        The x and y coordinates of the first point.
+ *
+ * @param {Array<number,number>} b
+ *        The x and y coordinates of the second point.
+ *
+ * @return {number}
+ *         Returns the dot product of a and b.
+ */
+var dotProduct = function dotProduct(a, b) {
+    var ax = a[0],
+        ay = a[1],
+        bx = b[0],
+        by = b[1];
+
+    return ax * bx + ay * by;
+};
+
+/**
+ * Projects a polygon onto a coordinate.
+ *
+ * @private
+ * @function project
+ *
+ * @param {Array<Array<number,number>>} polygon
+ *        Array of points in a polygon.
+ *
+ * @param {Array<number,number>} target
+ *        The coordinate of pr
+ *
+ * @return {object}
+ */
+var project = function project(polygon, target) {
+    var products = polygon.map(function (point) {
+        return dotProduct(point, target);
+    });
+
+    return {
+        min: Math.min.apply(this, products),
+        max: Math.max.apply(this, products)
+    };
+};
+
+/**
+ * Rotates a point clockwise around the origin.
+ *
+ * @private
+ * @function rotate2DToOrigin
+ *
+ * @param {Array<number,number>} point
+ *        The x and y coordinates for the point.
+ *
+ * @param {number} angle
+ *        The angle of rotation.
+ *
+ * @return {Array<number,number>}
+ *         The x and y coordinate for the rotated point.
+ */
+var rotate2DToOrigin = function (point, angle) {
+    var x = point[0],
+        y = point[1],
+        rad = deg2rad * -angle,
+        cosAngle = Math.cos(rad),
+        sinAngle = Math.sin(rad);
+
+    return [
+        correctFloat(x * cosAngle - y * sinAngle),
+        correctFloat(x * sinAngle + y * cosAngle)
+    ];
+};
+
+/**
+ * Rotate a point clockwise around another point.
+ *
+ * @private
+ * @function rotate2DToPoint
+ *
+ * @param {Array<number,number>} point
+ *        The x and y coordinates for the point.
+ *
+ * @param {Array<number,numbner>} origin
+ *        The point to rotate around.
+ *
+ * @param {number} angle
+ *        The angle of rotation.
+ *
+ * @return {Array<number,number>}
+ *         The x and y coordinate for the rotated point.
+ */
+var rotate2DToPoint = function (point, origin, angle) {
+    var x = point[0] - origin[0],
+        y = point[1] - origin[1],
+        rotated = rotate2DToOrigin([x, y], angle);
+
+    return [
+        rotated[0] + origin[0],
+        rotated[1] + origin[1]
+    ];
+};
+
+var isAxesEqual = function (axis1, axis2) {
+    return (
+        axis1[0] === axis2[0] &&
+        axis1[1] === axis2[1]
+    );
+};
+
+var getAxesFromPolygon = function (polygon) {
+    var points,
+        axes = polygon.axes;
+
+    if (!isArray(axes)) {
+        axes = [];
+        points = points = polygon.concat([polygon[0]]);
+        points.reduce(
+            function findAxis(p1, p2) {
+                var normals = getNormals(p1, p2),
+                    axis = normals[0]; // Use the left normal as axis.
+
+                // Check that the axis is unique.
+                if (!find(axes, function (existing) {
+                    return isAxesEqual(existing, axis);
+                })) {
+                    axes.push(axis);
+                }
+
+                // Return p2 to be used as p1 in next iteration.
+                return p2;
+            }
+        );
+        polygon.axes = axes;
+    }
+    return axes;
+};
+
+var getAxes = function (polygon1, polygon2) {
+    // Get the axis from both polygons.
+    var axes1 = getAxesFromPolygon(polygon1),
+        axes2 = getAxesFromPolygon(polygon2);
+
+    return axes1.concat(axes2);
+};
+
+var getPolygon = function (x, y, width, height, rotation) {
+    var origin = [x, y],
+        left = x - (width / 2),
+        right = x + (width / 2),
+        top = y - (height / 2),
+        bottom = y + (height / 2),
+        polygon = [
+            [left, top],
+            [right, top],
+            [right, bottom],
+            [left, bottom]
+        ];
+
+    return polygon.map(function (point) {
+        return rotate2DToPoint(point, origin, -rotation);
+    });
+};
+
+var getBoundingBoxFromPolygon = function (points) {
+    return points.reduce(function (obj, point) {
+        var x = point[0],
+            y = point[1];
+
+        obj.left = Math.min(x, obj.left);
+        obj.right = Math.max(x, obj.right);
+        obj.bottom = Math.max(y, obj.bottom);
+        obj.top = Math.min(y, obj.top);
+        return obj;
+    }, {
+        left: Number.MAX_VALUE,
+        right: -Number.MAX_VALUE,
+        bottom: -Number.MAX_VALUE,
+        top: Number.MAX_VALUE
+    });
+};
+
+var isPolygonsOverlappingOnAxis = function (axis, polygon1, polygon2) {
+    var projection1 = project(polygon1, axis),
+        projection2 = project(polygon2, axis),
+        isOverlapping = !(
+            projection2.min > projection1.max ||
+            projection2.max < projection1.min
+        );
+
+    return !isOverlapping;
+};
+
+/**
+ * Checks wether two convex polygons are colliding by using the Separating Axis
+ * Theorem.
+ *
+ * @private
+ * @function isPolygonsColliding
+ *
+ * @param {Array<Array<number,number>>} polygon1
+ *        First polygon.
+ *
+ * @param {Array<Array<number,number>>} polygon2
+ *        Second polygon.
+ *
+ * @return {boolean}
+ *         Returns true if they are colliding, otherwise false.
+ */
+var isPolygonsColliding = function isPolygonsColliding(polygon1, polygon2) {
+    var axes = getAxes(polygon1, polygon2),
+        overlappingOnAllAxes = !find(axes, function (axis) {
+            return isPolygonsOverlappingOnAxis(axis, polygon1, polygon2);
+        });
+
+    return overlappingOnAllAxes;
+};
+
+var movePolygon = function (deltaX, deltaY, polygon) {
+    return polygon.map(function (point) {
+        return [
+            point[0] + deltaX,
+            point[1] + deltaY
+        ];
+    });
+};
+
+var collision = {
+    getBoundingBoxFromPolygon: getBoundingBoxFromPolygon,
+    getPolygon: getPolygon,
+    isPolygonsColliding: isPolygonsColliding,
+    movePolygon: movePolygon,
+    rotate2DToOrigin: rotate2DToOrigin,
+    rotate2DToPoint: rotate2DToPoint
+};
+
+export default collision;