aw-highstock_rails 7.0.3

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

@@ -0,0 +1,150 @@
+'use strict';
+
+import H from '../parts/Globals.js';
+import '../parts/Series.js';
+
+var Series = H.Series,
+    addEvent = H.addEvent,
+    noop = H.noop;
+
+
+/* ************************************************************************** *
+ *
+ * DERIVED SERIES MIXIN
+ *
+ * ************************************************************************** */
+
+/**
+ * Provides methods for auto setting/updating series data based on the based
+ * series data.
+ *
+ * @private
+ * @mixin derivedSeriesMixin
+ */
+var derivedSeriesMixin = {
+    /**
+     * Initialise series
+     *
+     * @private
+     * @function derivedSeriesMixin.init
+     */
+    init: function () {
+        Series.prototype.init.apply(this, arguments);
+
+        this.initialised = false;
+        this.baseSeries = null;
+        this.eventRemovers = [];
+
+        this.addEvents();
+    },
+
+    /**
+     * Method to be implemented - inside the method the series has already
+     * access to the base series via m `this.baseSeries` and the bases data is
+     * initialised. It should return data in the format accepted by
+     * `Series.setData()` method
+     *
+     * @private
+     * @function derivedSeriesMixin.setDerivedData
+     *
+     * @return {Array<*>}
+     *         An array of data
+     */
+    setDerivedData: noop,
+
+    /**
+     * Sets base series for the series
+     *
+     * @private
+     * @function derivedSeriesMixin.setBaseSeries
+     */
+    setBaseSeries: function () {
+        var chart = this.chart,
+            baseSeriesOptions = this.options.baseSeries,
+            baseSeries =
+        baseSeriesOptions &&
+        (chart.series[baseSeriesOptions] || chart.get(baseSeriesOptions));
+
+        this.baseSeries = baseSeries || null;
+    },
+
+    /**
+     * Adds events for the series
+     *
+     * @private
+     * @function derivedSeriesMixin.addEvents
+     */
+    addEvents: function () {
+        var derivedSeries = this,
+            chartSeriesLinked;
+
+        chartSeriesLinked = addEvent(
+            this.chart,
+            'afterLinkSeries',
+            function () {
+                derivedSeries.setBaseSeries();
+
+                if (derivedSeries.baseSeries && !derivedSeries.initialised) {
+                    derivedSeries.setDerivedData();
+                    derivedSeries.addBaseSeriesEvents();
+                    derivedSeries.initialised = true;
+                }
+            }
+        );
+
+        this.eventRemovers.push(
+            chartSeriesLinked
+        );
+    },
+
+    /**
+     * Adds events to the base series - it required for recalculating the data
+     * in the series if the base series is updated / removed / etc.
+     *
+     * @private
+     * @function derivedSeriesMixin.addBaseSeriesEvents
+     */
+    addBaseSeriesEvents: function () {
+        var derivedSeries = this,
+            updatedDataRemover,
+            destroyRemover;
+
+        updatedDataRemover = addEvent(
+            derivedSeries.baseSeries,
+            'updatedData',
+            function () {
+                derivedSeries.setDerivedData();
+            }
+        );
+
+        destroyRemover = addEvent(
+            derivedSeries.baseSeries,
+            'destroy',
+            function () {
+                derivedSeries.baseSeries = null;
+                derivedSeries.initialised = false;
+            }
+        );
+
+        derivedSeries.eventRemovers.push(
+            updatedDataRemover,
+            destroyRemover
+        );
+    },
+
+    /**
+     * Destroys the series
+     *
+     * @private
+     * @function derivedSeriesMixin.destroy
+     */
+    destroy: function () {
+        this.eventRemovers.forEach(function (remover) {
+            remover();
+        });
+
+        Series.prototype.destroy.apply(this, arguments);
+    }
+};
+
+export default derivedSeriesMixin;

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

@@ -0,0 +1,103 @@
+/* *
+ * Mixin for downloading content in the browser
+ *
+ * (c) 2015-2019 Oystein Moseng
+ *
+ * License: www.highcharts.com/license
+ */
+
+'use strict';
+
+import Highcharts from '../parts/Globals.js';
+
+var win = Highcharts.win,
+    nav = win.navigator,
+    doc = win.document,
+    domurl = win.URL || win.webkitURL || win,
+    isEdgeBrowser = /Edge\/\d+/.test(nav.userAgent);
+
+// Convert base64 dataURL to Blob if supported, otherwise returns undefined
+Highcharts.dataURLtoBlob = function (dataURL) {
+    var parts = dataURL.match(/data:([^;]*)(;base64)?,([0-9A-Za-z+/]+)/);
+
+    if (
+        parts &&
+        parts.length > 3 &&
+        win.atob &&
+        win.ArrayBuffer &&
+        win.Uint8Array &&
+        win.Blob &&
+        domurl.createObjectURL
+    ) {
+        // Try to convert data URL to Blob
+        var binStr = win.atob(parts[3]),
+            buf = new win.ArrayBuffer(binStr.length),
+            binary = new win.Uint8Array(buf),
+            blob;
+
+        for (var i = 0; i < binary.length; ++i) {
+            binary[i] = binStr.charCodeAt(i);
+        }
+
+        blob = new win.Blob([binary], { 'type': parts[1] });
+        return domurl.createObjectURL(blob);
+    }
+};
+
+
+/**
+ * Download a data URL in the browser. Can also take a blob as first param.
+ *
+ * @private
+ * @function Highcharts.downloadURL
+ *
+ * @param {string|object} dataURL
+ *        The dataURL/Blob to download
+ *
+ * @param {string} filename
+ *        The name of the resulting file (w/extension)
+ */
+Highcharts.downloadURL = function (dataURL, filename) {
+    var a = doc.createElement('a'),
+        windowRef;
+
+    // IE specific blob implementation
+    // Don't use for normal dataURLs
+    if (
+        typeof dataURL !== 'string' &&
+        !(dataURL instanceof String) &&
+        nav.msSaveOrOpenBlob
+    ) {
+        nav.msSaveOrOpenBlob(dataURL, filename);
+        return;
+    }
+
+    // Some browsers have limitations for data URL lengths. Try to convert to
+    // Blob or fall back. Edge always needs that blob.
+    if (isEdgeBrowser || dataURL.length > 2000000) {
+        dataURL = Highcharts.dataURLtoBlob(dataURL);
+        if (!dataURL) {
+            throw new Error('Failed to convert to blob');
+        }
+    }
+
+    // Try HTML5 download attr if supported
+    if (a.download !== undefined) {
+        a.href = dataURL;
+        a.download = filename; // HTML5 download attribute
+        doc.body.appendChild(a);
+        a.click();
+        doc.body.removeChild(a);
+    } else {
+        // No download attr, just opening data URI
+        try {
+            windowRef = win.open(dataURL, 'chart');
+            if (windowRef === undefined || windowRef === null) {
+                throw new Error('Failed to open window');
+            }
+        } catch (e) {
+            // window.open failed, trying location.href
+            win.location.href = dataURL;
+        }
+    }
+};

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

@@ -0,0 +1,51 @@
+var isFn = function (x) {
+    return typeof x === 'function';
+};
+
+/**
+ * Handles the drawing of a point.
+ *
+ * @private
+ * @function draw
+ *
+ * @param {object} params
+ *        Parameters.
+ *
+ * @todo
+ * - add type checking.
+ */
+var draw = function draw(params) {
+    var point = this,
+        graphic = point.graphic,
+        animatableAttribs = params.animatableAttribs,
+        onComplete = params.onComplete,
+        css = params.css,
+        renderer = params.renderer;
+
+    if (point.shouldDraw()) {
+        if (!graphic) {
+            point.graphic = graphic =
+                renderer[params.shapeType](params.shapeArgs).add(params.group);
+        }
+        graphic
+            .css(css)
+            .attr(params.attribs)
+            .animate(
+                animatableAttribs,
+                params.isNew ? false : undefined,
+                onComplete
+            );
+    } else if (graphic) {
+        graphic.animate(animatableAttribs, undefined, function () {
+            point.graphic = graphic = graphic.destroy();
+            if (isFn(onComplete)) {
+                onComplete();
+            }
+        });
+    }
+    if (graphic) {
+        graphic.addClass(point.getClassName(), true);
+    }
+};
+
+export default draw;

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

@@ -0,0 +1,300 @@
+import geometry from './geometry.js';
+var getAngleBetweenPoints = geometry.getAngleBetweenPoints,
+    getCenterOfPoints = geometry.getCenterOfPoints,
+    getDistanceBetweenPoints = geometry.getDistanceBetweenPoints;
+
+var round = function round(x, decimals) {
+    var a = Math.pow(10, decimals);
+
+    return Math.round(x * a) / a;
+};
+
+/**
+ * Calculates the area of a circular segment based on the radius of the circle
+ * and the height of the segment.
+ * See http://mathworld.wolfram.com/CircularSegment.html
+ *
+ * @param {number} r The radius of the circle.
+ * @param {number} h The height of the circular segment.
+ * @returns {number} Returns the area of the circular segment.
+ */
+var getCircularSegmentArea = function getCircularSegmentArea(r, h) {
+    return r * r * Math.acos(1 - h / r) - (r - h) * Math.sqrt(h * (2 * r - h));
+};
+
+/**
+ * Calculates the area of overlap between two circles based on their radiuses
+ * and the distance between them.
+ * See http://mathworld.wolfram.com/Circle-CircleIntersection.html
+ *
+ * @param {number} r1 Radius of the first circle.
+ * @param {number} r2 Radius of the second circle.
+ * @param {number} d The distance between the two circles.
+ * @returns {number} Returns the area of overlap between the two circles.
+ */
+var getOverlapBetweenCircles =
+function getOverlapBetweenCircles(r1, r2, d) {
+    var overlap = 0;
+
+    // If the distance is larger than the sum of the radiuses then the circles
+    // does not overlap.
+    if (d < r1 + r2) {
+        var r1Square = r1 * r1,
+            r2Square = r2 * r2;
+
+        if (d <= Math.abs(r2 - r1)) {
+            // If the circles are completely overlapping, then the overlap
+            // equals the area of the smallest circle.
+            overlap = Math.PI * Math.min(r1Square, r2Square);
+        } else {
+            // Height of first triangle segment.
+            var d1 = (r1Square - r2Square + d * d) / (2 * d),
+                // Height of second triangle segment.
+                d2 = d - d1;
+
+            overlap = (
+                getCircularSegmentArea(r1, r1 - d1) +
+                getCircularSegmentArea(r2, r2 - d2)
+            );
+        }
+        // Round the result to two decimals.
+        overlap = round(overlap, 14);
+    }
+    return overlap;
+};
+
+/**
+ * Calculates the intersection points of two circles.
+ *
+ * NOTE: does not handle floating errors well.
+ *
+ * @param {object} c1 The first circle.s
+ * @param {object} c2 The second sircle.
+ * @returns {array} Returns the resulting intersection points.
+ */
+var getCircleCircleIntersection =
+function getCircleCircleIntersection(c1, c2) {
+    var d = getDistanceBetweenPoints(c1, c2),
+        r1 = c1.r,
+        r2 = c2.r,
+        points = [];
+
+    if (d < r1 + r2 && d > Math.abs(r1 - r2)) {
+        // If the circles are overlapping, but not completely overlapping, then
+        // it exists intersecting points.
+        var r1Square = r1 * r1,
+            r2Square = r2 * r2,
+            // d^2 - r^2 + R^2 / 2d
+            x = (r1Square - r2Square + d * d) / (2 * d),
+            // y^2 = R^2 - x^2
+            y = Math.sqrt(r1Square - x * x),
+            x1 = c1.x,
+            x2 = c2.x,
+            y1 = c1.y,
+            y2 = c2.y,
+            x0 = x1 + x * (x2 - x1) / d,
+            y0 = y1 + x * (y2 - y1) / d,
+            rx = -(y2 - y1) * (y / d),
+            ry = -(x2 - x1) * (y / d);
+
+        points = [
+            { x: round(x0 + rx, 14), y: round(y0 - ry, 14) },
+            { x: round(x0 - rx, 14), y: round(y0 + ry, 14) }
+        ];
+    }
+    return points;
+};
+
+/**
+ * Calculates all the intersection points for between a list of circles.
+ *
+ * @param {array} circles The circles to calculate the points from.
+ * @returns {array} Returns a list of intersection points.
+ */
+var getCirclesIntersectionPoints = function getIntersectionPoints(circles) {
+    return circles.reduce(function (points, c1, i, arr) {
+        var additional = arr.slice(i + 1)
+            .reduce(function (points, c2, j) {
+                var indexes = [i, j + i + 1];
+
+                return points.concat(
+                    getCircleCircleIntersection(c1, c2)
+                        .map(function (p) {
+                            p.indexes = indexes;
+                            return p;
+                        })
+                );
+            }, []);
+
+        return points.concat(additional);
+    }, []);
+};
+
+/**
+ * Tests wether a point lies within a given circle.
+ *
+ * @param {object} point The point to test for.
+ * @param {object} circle The circle to test if the point is within.
+ * @returns {boolean} Returns true if the point is inside, false if outside.
+ */
+var isPointInsideCircle = function isPointInsideCircle(point, circle) {
+    return getDistanceBetweenPoints(point, circle) <= circle.r + 1e-10;
+};
+
+/**
+ * Tests wether a point lies within a set of circles.
+ *
+ * @param {object} point The point to test.
+ * @param {array} circles The list of circles to test against.
+ * @returns {boolean} Returns true if the point is inside all the circles, false
+ * if not.
+ */
+var isPointInsideAllCircles = function isPointInsideAllCircles(point, circles) {
+    return !circles.some(function (circle) {
+        return !isPointInsideCircle(point, circle);
+    });
+};
+
+/**
+ * Tests wether a point lies outside a set of circles.
+ *
+ * TODO: add unit tests.
+ *
+ * @param {object} point The point to test.
+ * @param {array} circles The list of circles to test against.
+ * @returns {boolean} Returns true if the point is outside all the circles,
+ * false if not.
+ */
+var isPointOutsideAllCircles =
+function isPointOutsideAllCircles(point, circles) {
+    return !circles.some(function (circle) {
+        return isPointInsideCircle(point, circle);
+    });
+};
+
+/**
+ * Calculate the path for the area of overlap between a set of circles.
+ *
+ * TODO: handle cases with only 1 or 0 arcs.
+ *
+ * @param {array} circles List of circles to calculate area of.
+ * @returns {string} Returns the path for the area of overlap. Returns an empty
+ * string if there are no intersection between all the circles.
+ */
+var getAreaOfIntersectionBetweenCircles =
+function getAreaOfIntersectionBetweenCircles(circles) {
+    var intersectionPoints = getCirclesIntersectionPoints(circles)
+            .filter(function (p) {
+                return isPointInsideAllCircles(p, circles);
+            }),
+        result;
+
+    if (intersectionPoints.length > 1) {
+        // Calculate the center of the intersection points.
+        var center = getCenterOfPoints(intersectionPoints);
+
+        intersectionPoints = intersectionPoints
+            // Calculate the angle between the center and the points.
+            .map(function (p) {
+                p.angle = getAngleBetweenPoints(center, p);
+                return p;
+            })
+            // Sort the points by the angle to the center.
+            .sort(function (a, b) {
+                return b.angle - a.angle;
+            });
+
+        var startPoint = intersectionPoints[intersectionPoints.length - 1];
+        var arcs = intersectionPoints
+            .reduce(function (data, p1) {
+                var startPoint = data.startPoint,
+                    midPoint = getCenterOfPoints([startPoint, p1]);
+
+                // Calculate the arc from the intersection points and their
+                // circles.
+                var arc = p1.indexes
+                    // Filter out circles that are not included in both
+                    // intersection points.
+                    .filter(function (index) {
+                        return startPoint.indexes.indexOf(index) > -1;
+                    })
+                    // Iterate the circles of the intersection points and
+                    // calculate arcs.
+                    .reduce(function (arc, index) {
+                        var circle = circles[index],
+                            angle1 = getAngleBetweenPoints(circle, p1),
+                            angle2 = getAngleBetweenPoints(circle, startPoint),
+                            angleDiff = angle2 - angle1 +
+                                (angle2 < angle1 ? 2 * Math.PI : 0),
+                            angle = angle2 - angleDiff / 2,
+                            width = getDistanceBetweenPoints(
+                                midPoint,
+                                {
+                                    x: circle.x + circle.r * Math.sin(angle),
+                                    y: circle.y + circle.r * Math.cos(angle)
+                                }
+                            ),
+                            r = circle.r;
+
+                        // Width can sometimes become to large due to floating
+                        // point errors
+                        if (width > r * 2) {
+                            width = r * 2;
+                        }
+                        // Get the arc with the smallest width.
+                        if (!arc || arc.width > width) {
+                            arc = {
+                                r: r,
+                                largeArc: width > r ? 1 : 0,
+                                width: width,
+                                x: p1.x,
+                                y: p1.y
+                            };
+                        }
+
+                        // Return the chosen arc.
+                        return arc;
+                    }, null);
+
+                // If we find an arc then add it to the list and update p2.
+                if (arc) {
+                    var r = arc.r;
+
+                    data.arcs.push(
+                        ['A', r, r, 0, arc.largeArc, 1, arc.x, arc.y]
+                    );
+                    data.startPoint = p1;
+                }
+                return data;
+            }, {
+                startPoint: startPoint,
+                arcs: []
+            }).arcs;
+
+        if (arcs.length === 0) {
+        } else if (arcs.length === 1) {
+        } else {
+            arcs.unshift(['M', startPoint.x, startPoint.y]);
+            result = {
+                center: center,
+                d: arcs
+            };
+        }
+    }
+
+    return result;
+};
+
+var geometryCircles = {
+    getAreaOfIntersectionBetweenCircles: getAreaOfIntersectionBetweenCircles,
+    getCircleCircleIntersection: getCircleCircleIntersection,
+    getCirclesIntersectionPoints: getCirclesIntersectionPoints,
+    getCircularSegmentArea: getCircularSegmentArea,
+    getOverlapBetweenCircles: getOverlapBetweenCircles,
+    isPointInsideCircle: isPointInsideCircle,
+    isPointInsideAllCircles: isPointInsideAllCircles,
+    isPointOutsideAllCircles: isPointOutsideAllCircles,
+    round: round
+};
+
+export default geometryCircles;