highcharts 9.1.1 → 9.2.2

package/es-modules/Core/Geometry/CircleUtilities.js

@@ -0,0 +1,385 @@
+/* *
+ *
+ *  (c) 2010-2021 Highsoft AS
+ *
+ *  License: www.highcharts.com/license
+ *
+ *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+ *
+ * */
+'use strict';
+import Geometry from './GeometryUtilities.js';
+var getAngleBetweenPoints = Geometry.getAngleBetweenPoints, getCenterOfPoints = Geometry.getCenterOfPoints, getDistanceBetweenPoints = Geometry.getDistanceBetweenPoints;
+/* *
+ *
+ *  Namespace
+ *
+ * */
+var CircleUtilities;
+(function (CircleUtilities) {
+    /* *
+     *
+     *  Functions
+     *
+     * */
+    /**
+     * @private
+     *
+     * @param {number} x
+     * Number to round
+     *
+     * @param {number} decimals
+     * Number of decimals to round to
+     *
+     * @return {number}
+     * Rounded number
+     */
+    function round(x, decimals) {
+        var a = Math.pow(10, decimals);
+        return Math.round(x * a) / a;
+    }
+    CircleUtilities.round = round;
+    /**
+     * Calculates the area of a circle based on its radius.
+     *
+     * @private
+     *
+     * @param {number} r
+     * The radius of the circle.
+     *
+     * @return {number}
+     * Returns the area of the circle.
+     */
+    function getAreaOfCircle(r) {
+        if (r <= 0) {
+            throw new Error('radius of circle must be a positive number.');
+        }
+        return Math.PI * r * r;
+    }
+    CircleUtilities.getAreaOfCircle = getAreaOfCircle;
+    /**
+     * 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
+     *
+     * @private
+     *
+     * @param {number} r
+     * The radius of the circle.
+     *
+     * @param {number} h
+     * The height of the circular segment.
+     *
+     * @return {number}
+     * Returns the area of the circular segment.
+     */
+    function getCircularSegmentArea(r, h) {
+        return r * r * Math.acos(1 - h / r) - (r - h) * Math.sqrt(h * (2 * r - h));
+    }
+    CircleUtilities.getCircularSegmentArea = getCircularSegmentArea;
+    /**
+     * 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
+     *
+     * @private
+     *
+     * @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.
+     *
+     * @return {number}
+     * Returns the area of overlap between the two circles.
+     */
+    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) {
+            if (d <= Math.abs(r2 - r1)) {
+                // If the circles are completely overlapping, then the overlap
+                // equals the area of the smallest circle.
+                overlap = getAreaOfCircle(r1 < r2 ? r1 : r2);
+            }
+            else {
+                // Height of first triangle segment.
+                var d1 = (r1 * r1 - r2 * r2 + 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;
+    }
+    CircleUtilities.getOverlapBetweenCircles = getOverlapBetweenCircles;
+    /**
+     * Calculates the intersection points of two circles.
+     *
+     * NOTE: does not handle floating errors well.
+     *
+     * @private
+     *
+     * @param {Highcharts.CircleObject} c1
+     * The first circle.
+     *
+     * @param {Highcharts.CircleObject} c2
+     * The second sircle.
+     *
+     * @return {Array<Highcharts.PositionObject>}
+     * Returns the resulting intersection points.
+     */
+    function getCircleCircleIntersection(c1, c2) {
+        var d = getDistanceBetweenPoints(c1, c2), r1 = c1.r, r2 = c2.r;
+        var 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;
+    }
+    CircleUtilities.getCircleCircleIntersection = getCircleCircleIntersection;
+    /**
+     * Calculates all the intersection points for between a list of circles.
+     *
+     * @private
+     *
+     * @param {Array<Highcharts.CircleObject>} circles
+     * The circles to calculate the points from.
+     *
+     * @return {Array<Highcharts.GeometryObject>}
+     * Returns a list of intersection points.
+     */
+    function getCirclesIntersectionPoints(circles) {
+        return circles.reduce(function (points, c1, i, arr) {
+            var additional = arr
+                .slice(i + 1)
+                .reduce(function (points, c2, j, arr) {
+                var indexes = [i, j + i + 1];
+                return points.concat(getCircleCircleIntersection(c1, c2).map(function (p) {
+                    p.indexes = indexes;
+                    return p;
+                }));
+            }, []);
+            return points.concat(additional);
+        }, []);
+    }
+    CircleUtilities.getCirclesIntersectionPoints = getCirclesIntersectionPoints;
+    /**
+     * Tests wether the first circle is completely overlapping the second
+     * circle.
+     *
+     * @private
+     *
+     * @param {Highcharts.CircleObject} circle1
+     * The first circle.
+     *
+     * @param {Highcharts.CircleObject} circle2
+     * The The second circle.
+     *
+     * @return {boolean}
+     * Returns true if circle1 is completely overlapping circle2, false if not.
+     */
+    function isCircle1CompletelyOverlappingCircle2(circle1, circle2) {
+        return getDistanceBetweenPoints(circle1, circle2) + circle2.r < circle1.r + 1e-10;
+    }
+    CircleUtilities.isCircle1CompletelyOverlappingCircle2 = isCircle1CompletelyOverlappingCircle2;
+    /**
+     * Tests wether a point lies within a given circle.
+     * @private
+     * @param {Highcharts.PositionObject} point
+     * The point to test for.
+     *
+     * @param {Highcharts.CircleObject} circle
+     * The circle to test if the point is within.
+     *
+     * @return {boolean}
+     * Returns true if the point is inside, false if outside.
+     */
+    function isPointInsideCircle(point, circle) {
+        return getDistanceBetweenPoints(point, circle) <= circle.r + 1e-10;
+    }
+    CircleUtilities.isPointInsideCircle = isPointInsideCircle;
+    /**
+     * Tests wether a point lies within a set of circles.
+     *
+     * @private
+     *
+     * @param {Highcharts.PositionObject} point
+     * The point to test.
+     *
+     * @param {Array<Highcharts.CircleObject>} circles
+     * The list of circles to test against.
+     *
+     * @return {boolean}
+     * Returns true if the point is inside all the circles, false if not.
+     */
+    function isPointInsideAllCircles(point, circles) {
+        return !circles.some(function (circle) {
+            return !isPointInsideCircle(point, circle);
+        });
+    }
+    CircleUtilities.isPointInsideAllCircles = isPointInsideAllCircles;
+    /**
+     * Tests wether a point lies outside a set of circles.
+     *
+     * TODO: add unit tests.
+     *
+     * @private
+     *
+     * @param {Highcharts.PositionObject} point
+     * The point to test.
+     *
+     * @param {Array<Highcharts.CircleObject>} circles
+     * The list of circles to test against.
+     *
+     * @return {boolean}
+     * Returns true if the point is outside all the circles, false if not.
+     */
+    function isPointOutsideAllCircles(point, circles) {
+        return !circles.some(function (circle) {
+            return isPointInsideCircle(point, circle);
+        });
+    }
+    CircleUtilities.isPointOutsideAllCircles = isPointOutsideAllCircles;
+    /**
+     * Calculates the points for the polygon of the intersection area between
+     * a set of circles.
+     *
+     * @private
+     *
+     * @param {Array<Highcharts.CircleObject>} circles
+     * List of circles to calculate polygon of.
+     *
+     * @return {Array<Highcharts.GeometryObject>}
+     * Return list of points in the intersection polygon.
+     */
+    function getCirclesIntersectionPolygon(circles) {
+        return getCirclesIntersectionPoints(circles)
+            .filter(function (p) {
+            return isPointInsideAllCircles(p, circles);
+        });
+    }
+    CircleUtilities.getCirclesIntersectionPolygon = getCirclesIntersectionPolygon;
+    /**
+     * Calculate the path for the area of overlap between a set of circles.
+     *
+     * @todo handle cases with only 1 or 0 arcs.
+     *
+     * @private
+     *
+     * @param {Array<Highcharts.CircleObject>} circles
+     * List of circles to calculate area of.
+     *
+     * @return {Highcharts.GeometryIntersectionObject|undefined}
+     * Returns the path for the area of overlap. Returns an empty string if
+     * there are no intersection between all the circles.
+     */
+    function getAreaOfIntersectionBetweenCircles(circles) {
+        var intersectionPoints = getCirclesIntersectionPolygon(circles), result;
+        if (intersectionPoints.length > 1) {
+            // Calculate the center of the intersection points.
+            var center_1 = getCenterOfPoints(intersectionPoints);
+            intersectionPoints = intersectionPoints
+                // Calculate the angle between the center and the points.
+                .map(function (p) {
+                p.angle = getAngleBetweenPoints(center_1, 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;
+                    var width = getDistanceBetweenPoints(midPoint, {
+                        x: circle.x + circle.r * Math.sin(angle),
+                        y: circle.y + circle.r * Math.cos(angle)
+                    });
+                    var 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) {
+                // empty
+            }
+            else if (arcs.length === 1) {
+                // empty
+            }
+            else {
+                arcs.unshift(['M', startPoint.x, startPoint.y]);
+                result = {
+                    center: center_1,
+                    d: arcs
+                };
+            }
+        }
+        return result;
+    }
+    CircleUtilities.getAreaOfIntersectionBetweenCircles = getAreaOfIntersectionBetweenCircles;
+})(CircleUtilities || (CircleUtilities = {}));
+/* *
+ *
+ *  Default Export
+ *
+ * */
+export default CircleUtilities;

package/es-modules/Core/Geometry/GeometryUtilities.js

@@ -0,0 +1,83 @@
+/* *
+ *
+ *  (c) 2010-2021 Highsoft AS
+ *
+ *  License: www.highcharts.com/license
+ *
+ *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+ *
+ * */
+'use strict';
+/* *
+ *
+ *  Namespace
+ *
+ * */
+var GeometryUtilities;
+(function (GeometryUtilities) {
+    /* *
+     *
+     *  Functions
+     *
+     * */
+    /**
+     * Calculates the center between a list of points.
+     *
+     * @private
+     *
+     * @param {Array<Highcharts.PositionObject>} points
+     * A list of points to calculate the center of.
+     *
+     * @return {Highcharts.PositionObject}
+     * Calculated center
+     */
+    function getCenterOfPoints(points) {
+        var sum = points.reduce(function (sum, point) {
+            sum.x += point.x;
+            sum.y += point.y;
+            return sum;
+        }, { x: 0, y: 0 });
+        return {
+            x: sum.x / points.length,
+            y: sum.y / points.length
+        };
+    }
+    GeometryUtilities.getCenterOfPoints = getCenterOfPoints;
+    /**
+     * Calculates the distance between two points based on their x and y
+     * coordinates.
+     *
+     * @private
+     *
+     * @param {Highcharts.PositionObject} p1
+     * The x and y coordinates of the first point.
+     *
+     * @param {Highcharts.PositionObject} p2
+     * The x and y coordinates of the second point.
+     *
+     * @return {number}
+     * Returns the distance between the points.
+     */
+    function getDistanceBetweenPoints(p1, p2) {
+        return Math.sqrt(Math.pow(p2.x - p1.x, 2) + Math.pow(p2.y - p1.y, 2));
+    }
+    GeometryUtilities.getDistanceBetweenPoints = getDistanceBetweenPoints;
+    /**
+     * Calculates the angle between two points.
+     * @todo add unit tests.
+     * @private
+     * @param {Highcharts.PositionObject} p1 The first point.
+     * @param {Highcharts.PositionObject} p2 The second point.
+     * @return {number} Returns the angle in radians.
+     */
+    function getAngleBetweenPoints(p1, p2) {
+        return Math.atan2(p2.x - p1.x, p2.y - p1.y);
+    }
+    GeometryUtilities.getAngleBetweenPoints = getAngleBetweenPoints;
+})(GeometryUtilities || (GeometryUtilities = {}));
+/* *
+ *
+ *  Default Export
+ *
+ * */
+export default GeometryUtilities;

package/es-modules/Core/Globals.js

@@ -40,7 +40,7 @@ var Globals;
      *  Constants
      *
      * */
-    Globals.SVG_NS = 'http://www.w3.org/2000/svg', Globals.product = 'Highcharts', Globals.version = '9.1.1', Globals.win = w, Globals.doc = Globals.win.document, Globals.svg = (Globals.doc &&
+    Globals.SVG_NS = 'http://www.w3.org/2000/svg', Globals.product = 'Highcharts', Globals.version = '9.2.2', Globals.win = w, Globals.doc = Globals.win.document, Globals.svg = (Globals.doc &&
         Globals.doc.createElementNS &&
         !!Globals.doc.createElementNS(Globals.SVG_NS, 'svg').createSVGRect), Globals.userAgent = (Globals.win.navigator && Globals.win.navigator.userAgent) || '', Globals.isChrome = Globals.userAgent.indexOf('Chrome') !== -1, Globals.isFirefox = Globals.userAgent.indexOf('Firefox') !== -1, Globals.isMS = /(edge|msie|trident)/i.test(Globals.userAgent) && !Globals.win.opera, Globals.isSafari = !Globals.isChrome && Globals.userAgent.indexOf('Safari') !== -1, Globals.isTouchDevice = /(Mobile|Android|Windows Phone)/.test(Globals.userAgent), Globals.isWebKit = Globals.userAgent.indexOf('AppleWebKit') !== -1, Globals.deg2rad = Math.PI * 2 / 360, Globals.hasBidiBug = (Globals.isFirefox &&
         parseInt(Globals.userAgent.split('Firefox/')[1], 10) < 4 // issue #38
@@ -100,6 +100,13 @@ var Globals;
      * @private
      */
     Globals.symbolSizes = {};
+    /* *
+     *
+     *  Properties
+     *
+     * */
+    // eslint-disable-next-line prefer-const
+    Globals.chartCount = 0;
 })(Globals || (Globals = {}));
 /* *
  *
@@ -107,3 +114,18 @@ var Globals;
  *
  * */
 export default Globals;
+/* *
+ *
+ *  API Declarations
+ *
+ * */
+/**
+ * Theme options that should get applied to the chart. In module mode it
+ * might not be possible to change this property because of read-only
+ * restrictions, instead use {@link Highcharts.setOptions}.
+ *
+ * @deprecated
+ * @name Highcharts.theme
+ * @type {Highcharts.Options}
+ */
+(''); // keeps doclets above in JS file

package/es-modules/{Extensions/Ajax.js → Core/HttpUtilities.js}

@@ -8,41 +8,10 @@
  *
  * */
 'use strict';
-import H from '../Core/Globals.js';
+import G from '../Core/Globals.js';
+var doc = G.doc;
 import U from '../Core/Utilities.js';
-var merge = U.merge, objectEach = U.objectEach;
-/**
- * @interface Highcharts.AjaxSettingsObject
- */ /**
-* The payload to send.
-*
-* @name Highcharts.AjaxSettingsObject#data
-* @type {string|Highcharts.Dictionary<any>}
-*/ /**
-* The data type expected.
-* @name Highcharts.AjaxSettingsObject#dataType
-* @type {"json"|"xml"|"text"|"octet"}
-*/ /**
-* Function to call on error.
-* @name Highcharts.AjaxSettingsObject#error
-* @type {Function}
-*/ /**
-* The headers; keyed on header name.
-* @name Highcharts.AjaxSettingsObject#headers
-* @type {Highcharts.Dictionary<string>}
-*/ /**
-* Function to call on success.
-* @name Highcharts.AjaxSettingsObject#success
-* @type {Function}
-*/ /**
-* The HTTP method to use. For example GET or POST.
-* @name Highcharts.AjaxSettingsObject#type
-* @type {string}
-*/ /**
-* The URL to call.
-* @name Highcharts.AjaxSettingsObject#url
-* @type {string}
-*/
+var createElement = U.createElement, discardElement = U.discardElement, merge = U.merge, objectEach = U.objectEach;
 /**
  * Perform an Ajax call.
  *
@@ -54,7 +23,7 @@ var merge = U.merge, objectEach = U.objectEach;
  * @return {false|undefined}
  *         Returns false, if error occured.
  */
-H.ajax = function (attr) {
+function ajax(attr) {
     var options = merge(true, {
         url: false,
         type: 'get',
@@ -119,7 +88,7 @@ H.ajax = function (attr) {
         // empty
     }
     r.send(options.data || true);
-};
+}
 /**
  * Get a JSON resource over XHR, also supporting CORS without preflight.
  *
@@ -129,10 +98,9 @@ H.ajax = function (attr) {
  * @param {Function} success
  *        The success callback. For error handling, use the `Highcharts.ajax`
  *        function instead.
- * @return {void}
  */
-H.getJSON = function (url, success) {
-    H.ajax({
+function getJSON(url, success) {
+    exports.ajax({
         url: url,
         success: success,
         dataType: 'json',
@@ -142,9 +110,85 @@ H.getJSON = function (url, success) {
             'Content-Type': 'text/plain'
         }
     });
-};
+}
+/**
+ * The post utility
+ *
+ * @private
+ * @function Highcharts.post
+ *
+ * @param {string} url
+ * Post URL
+ *
+ * @param {object} data
+ * Post data
+ *
+ * @param {Highcharts.Dictionary<string>} [formAttributes]
+ * Additional attributes for the post request
+ */
+function post(url, data, formAttributes) {
+    // create the form
+    var form = createElement('form', merge({
+        method: 'post',
+        action: url,
+        enctype: 'multipart/form-data'
+    }, formAttributes), {
+        display: 'none'
+    }, doc.body);
+    // add the data
+    objectEach(data, function (val, name) {
+        createElement('input', {
+            type: 'hidden',
+            name: name,
+            value: val
+        }, null, form);
+    });
+    // submit
+    form.submit();
+    // clean up
+    discardElement(form);
+}
+/* *
+ *
+ *  Default Export
+ *
+ * */
 var exports = {
-    ajax: H.ajax,
-    getJSON: H.getJSON
+    ajax: ajax,
+    getJSON: getJSON,
+    post: post
 };
 export default exports;
+/**
+ * @interface Highcharts.AjaxSettingsObject
+ */ /**
+* The payload to send.
+*
+* @name Highcharts.AjaxSettingsObject#data
+* @type {string|Highcharts.Dictionary<any>}
+*/ /**
+* The data type expected.
+* @name Highcharts.AjaxSettingsObject#dataType
+* @type {"json"|"xml"|"text"|"octet"}
+*/ /**
+* Function to call on error.
+* @name Highcharts.AjaxSettingsObject#error
+* @type {Function}
+*/ /**
+* The headers; keyed on header name.
+* @name Highcharts.AjaxSettingsObject#headers
+* @type {Highcharts.Dictionary<string>}
+*/ /**
+* Function to call on success.
+* @name Highcharts.AjaxSettingsObject#success
+* @type {Function}
+*/ /**
+* The HTTP method to use. For example GET or POST.
+* @name Highcharts.AjaxSettingsObject#type
+* @type {string}
+*/ /**
+* The URL to call.
+* @name Highcharts.AjaxSettingsObject#url
+* @type {string}
+*/
+(''); // keeps doclets above in JS file