highcharts 8.1.0 → 8.2.2

package/es-modules/{annotations/types → Extensions/Annotations/Types}/BasicAnnotation.js

@@ -4,14 +4,68 @@
  *
  * */
 'use strict';
-import H from '../../parts/Globals.js';
-var Annotation = H.Annotation;
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+import Annotation from '../Annotations.js';
+import MockPoint from '../MockPoint.js';
+import U from '../../../Core/Utilities.js';
+var merge = U.merge;
 /* eslint-disable no-invalid-this */
-var BasicAnnotation = function () {
-    Annotation.apply(this, arguments);
-};
-H.extendAnnotation(BasicAnnotation, null, {
-    basicControlPoints: {
+var BasicAnnotation = /** @class */ (function (_super) {
+    __extends(BasicAnnotation, _super);
+    /* *
+     *
+     *  Constructors
+     *
+     * */
+    function BasicAnnotation(chart, options) {
+        return _super.call(this, chart, options) || this;
+    }
+    /* *
+     *
+     *  Functions
+     *
+     * */
+    BasicAnnotation.prototype.addControlPoints = function () {
+        var options = this.options, controlPoints = BasicAnnotation.basicControlPoints, annotationType = this.basicType, optionsGroup = options.labels || options.shapes;
+        optionsGroup.forEach(function (group) {
+            group.controlPoints = controlPoints[annotationType];
+        });
+    };
+    BasicAnnotation.prototype.init = function () {
+        var options = this.options;
+        if (options.shapes) {
+            delete options.labelOptions;
+            if (options.shapes[0].type === 'circle') {
+                this.basicType = 'circle';
+            }
+            else {
+                this.basicType = 'rectangle';
+            }
+        }
+        else {
+            delete options.shapes;
+            this.basicType = 'label';
+        }
+        Annotation.prototype.init.apply(this, arguments);
+    };
+    /* *
+     *
+     *  Static Properties
+     *
+     * */
+    BasicAnnotation.basicControlPoints = {
         label: [{
                 symbol: 'triangle-down',
                 positioner: function (target) {
@@ -21,7 +75,7 @@ H.extendAnnotation(BasicAnnotation, null, {
                             y: -9e7
                         };
                     }
-                    var xy = H.Annotation.MockPoint
+                    var xy = MockPoint
                         .pointToPixels(target.points[0]);
                     return {
                         x: xy.x - this.graphic.width / 2,
@@ -68,7 +122,7 @@ H.extendAnnotation(BasicAnnotation, null, {
             }],
         rectangle: [{
                 positioner: function (annotation) {
-                    var xy = H.Annotation.MockPoint
+                    var xy = MockPoint
                         .pointToPixels(annotation.points[2]);
                     return {
                         x: xy.x - 4,
@@ -93,7 +147,7 @@ H.extendAnnotation(BasicAnnotation, null, {
             }],
         circle: [{
                 positioner: function (target) {
-                    var xy = H.Annotation.MockPoint.pointToPixels(target.points[0]), r = target.options.r;
+                    var xy = MockPoint.pointToPixels(target.points[0]), r = target.options.r;
                     return {
                         x: xy.x + r * Math.cos(Math.PI / 4) -
                             this.graphic.width / 2,
@@ -116,15 +170,9 @@ H.extendAnnotation(BasicAnnotation, null, {
                     }
                 }
             }]
-    },
-    addControlPoints: function () {
-        var options = this.options, controlPoints = this.basicControlPoints, langKey = options.langKey, optionsGroup = options.labels || options.shapes;
-        optionsGroup.forEach(function (group) {
-            if (langKey) {
-                group.controlPoints = controlPoints[langKey];
-            }
-        });
-    }
-});
+    };
+    return BasicAnnotation;
+}(Annotation));
+BasicAnnotation.prototype.defaultOptions = merge(Annotation.prototype.defaultOptions, {});
 Annotation.types.basicAnnotation = BasicAnnotation;
 export default BasicAnnotation;

package/es-modules/{annotations/types → Extensions/Annotations/Types}/CrookedLine.js

@@ -4,42 +4,67 @@
  *
  * */
 'use strict';
-import H from '../../parts/Globals.js';
-import U from '../../parts/Utilities.js';
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+import Annotation from '../Annotations.js';
+import ControlPoint from '../ControlPoint.js';
+import MockPoint from '../MockPoint.js';
+import U from '../../../Core/Utilities.js';
 var merge = U.merge;
-var Annotation = H.Annotation, MockPoint = Annotation.MockPoint, ControlPoint = Annotation.ControlPoint;
 /* eslint-disable no-invalid-this, valid-jsdoc */
-var CrookedLine = function () {
-    Annotation.apply(this, arguments);
-};
-H.extendAnnotation(CrookedLine, null, {
+var CrookedLine = /** @class */ (function (_super) {
+    __extends(CrookedLine, _super);
+    /* *
+     *
+     * Constructors
+     *
+     * */
+    function CrookedLine(chart, options) {
+        return _super.call(this, chart, options) || this;
+    }
+    /* *
+     *
+     * Functions
+     *
+     * */
     /**
      * Overrides default setter to get axes from typeOptions.
      * @private
      */
-    setClipAxes: function () {
+    CrookedLine.prototype.setClipAxes = function () {
         this.clipXAxis = this.chart.xAxis[this.options.typeOptions.xAxis];
         this.clipYAxis = this.chart.yAxis[this.options.typeOptions.yAxis];
-    },
-    getPointsOptions: function () {
+    };
+    CrookedLine.prototype.getPointsOptions = function () {
         var typeOptions = this.options.typeOptions;
-        return typeOptions.points.map(function (pointOptions) {
+        return (typeOptions.points || []).map(function (pointOptions) {
             pointOptions.xAxis = typeOptions.xAxis;
             pointOptions.yAxis = typeOptions.yAxis;
             return pointOptions;
         });
-    },
-    getControlPointsOptions: function () {
+    };
+    CrookedLine.prototype.getControlPointsOptions = function () {
         return this.getPointsOptions();
-    },
-    addControlPoints: function () {
+    };
+    CrookedLine.prototype.addControlPoints = function () {
         this.getControlPointsOptions().forEach(function (pointOptions, i) {
             var controlPoint = new ControlPoint(this.chart, this, merge(this.options.controlPointOptions, pointOptions.controlPoint), i);
             this.controlPoints.push(controlPoint);
             pointOptions.controlPoint = controlPoint.options;
         }, this);
-    },
-    addShapes: function () {
+    };
+    CrookedLine.prototype.addShapes = function () {
         var typeOptions = this.options.typeOptions, shape = this.initShape(merge(typeOptions.line, {
             type: 'path',
             points: this.points.map(function (_point, i) {
@@ -49,8 +74,10 @@ H.extendAnnotation(CrookedLine, null, {
             })
         }), false);
         typeOptions.line = shape.options;
-    }
-}, 
+    };
+    return CrookedLine;
+}(Annotation));
+CrookedLine.prototype.defaultOptions = merge(Annotation.prototype.defaultOptions, 
 /**
  * A crooked line annotation.
  *

package/es-modules/{annotations/types → Extensions/Annotations/Types}/ElliottWave.js

@@ -4,27 +4,48 @@
  *
  * */
 'use strict';
-import H from '../../parts/Globals.js';
-import U from '../../parts/Utilities.js';
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+import Annotation from '../Annotations.js';
+import CrookedLine from './CrookedLine.js';
+import U from '../../../Core/Utilities.js';
 var merge = U.merge;
-var Annotation = H.Annotation, CrookedLine = Annotation.types.crookedLine;
 /* eslint-disable no-invalid-this, valid-jsdoc */
-var ElliottWave = function () {
-    CrookedLine.apply(this, arguments);
-};
-H.extendAnnotation(ElliottWave, CrookedLine, {
-    addLabels: function () {
+var ElliottWave = /** @class */ (function (_super) {
+    __extends(ElliottWave, _super);
+    function ElliottWave(chart, options) {
+        return _super.call(this, chart, options) || this;
+    }
+    /* *
+     *
+     * Functions
+     *
+     * */
+    ElliottWave.prototype.addLabels = function () {
         this.getPointsOptions().forEach(function (point, i) {
-            var label = this.initLabel(merge(point.label, {
-                text: this.options.typeOptions.labels[i],
+            var typeOptions = this.options.typeOptions, label = this.initLabel(merge(point.label, {
+                text: typeOptions.labels[i],
                 point: function (target) {
                     return target.annotation.points[i];
                 }
             }), false);
             point.label = label.options;
         }, this);
-    }
-}, 
+    };
+    return ElliottWave;
+}(CrookedLine));
+ElliottWave.prototype.defaultOptions = merge(CrookedLine.prototype.defaultOptions, 
 /**
  * An elliott wave annotation.
  *

package/es-modules/{annotations/types → Extensions/Annotations/Types}/Fibonacci.js

@@ -4,10 +4,24 @@
  *
  * */
 'use strict';
-import H from '../../parts/Globals.js';
-import U from '../../parts/Utilities.js';
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+import Annotation from '../Annotations.js';
+import MockPoint from '../MockPoint.js';
+import Tunnel from './Tunnel.js';
+import U from '../../../Core/Utilities.js';
 var merge = U.merge;
-var Annotation = H.Annotation, MockPoint = Annotation.MockPoint, Tunnel = Annotation.types.tunnel;
 /* eslint-disable no-invalid-this, valid-jsdoc */
 var createPathDGenerator = function (retracementIndex, isBackground) {
     return function () {
@@ -23,27 +37,37 @@ var createPathDGenerator = function (retracementIndex, isBackground) {
         return d;
     };
 };
-var Fibonacci = function () {
-    this.startRetracements = [];
-    this.endRetracements = [];
-    Tunnel.apply(this, arguments);
-};
-Fibonacci.levels = [0, 0.236, 0.382, 0.5, 0.618, 0.786, 1];
-H.extendAnnotation(Fibonacci, Tunnel, {
-    linkPoints: function () {
-        Tunnel.prototype.linkPoints.call(this);
+var Fibonacci = /** @class */ (function (_super) {
+    __extends(Fibonacci, _super);
+    /* *
+     *
+     * Constructors
+     *
+     * */
+    function Fibonacci(chart, options) {
+        return _super.call(this, chart, options) || this;
+    }
+    /* *
+     *
+     * Functions
+     *
+     * */
+    Fibonacci.prototype.linkPoints = function () {
+        _super.prototype.linkPoints.call(this);
         this.linkRetracementsPoints();
         return;
-    },
-    linkRetracementsPoints: function () {
+    };
+    Fibonacci.prototype.linkRetracementsPoints = function () {
         var points = this.points, startDiff = points[0].y - points[3].y, endDiff = points[1].y - points[2].y, startX = points[0].x, endX = points[1].x;
         Fibonacci.levels.forEach(function (level, i) {
             var startRetracement = points[0].y - startDiff * level, endRetracement = points[1].y - endDiff * level;
+            this.startRetracements = this.startRetracements || [];
+            this.endRetracements = this.endRetracements || [];
             this.linkRetracementPoint(i, startX, startRetracement, this.startRetracements);
             this.linkRetracementPoint(i, endX, endRetracement, this.endRetracements);
         }, this);
-    },
-    linkRetracementPoint: function (pointIndex, x, y, retracements) {
+    };
+    Fibonacci.prototype.linkRetracementPoint = function (pointIndex, x, y, retracements) {
         var point = retracements[pointIndex], typeOptions = this.options.typeOptions;
         if (!point) {
             retracements[pointIndex] = new MockPoint(this.chart, this, {
@@ -58,8 +82,8 @@ H.extendAnnotation(Fibonacci, Tunnel, {
             point.options.y = y;
             point.refresh();
         }
-    },
-    addShapes: function () {
+    };
+    Fibonacci.prototype.addShapes = function () {
         Fibonacci.levels.forEach(function (_level, i) {
             this.initShape({
                 type: 'path',
@@ -74,8 +98,8 @@ H.extendAnnotation(Fibonacci, Tunnel, {
                 });
             }
         }, this);
-    },
-    addLabels: function () {
+    };
+    Fibonacci.prototype.addLabels = function () {
         Fibonacci.levels.forEach(function (level, i) {
             var options = this.options.typeOptions, label = this.initLabel(merge(options.labels[i], {
                 point: function (target) {
@@ -86,8 +110,16 @@ H.extendAnnotation(Fibonacci, Tunnel, {
             }));
             options.labels[i] = label.options;
         }, this);
-    }
-}, 
+    };
+    /* *
+     *
+     * Static properties
+     *
+     * */
+    Fibonacci.levels = [0, 0.236, 0.382, 0.5, 0.618, 0.786, 1];
+    return Fibonacci;
+}(Tunnel));
+Fibonacci.prototype.defaultOptions = merge(Tunnel.prototype.defaultOptions, 
 /**
  * A fibonacci annotation.
  *

package/es-modules/Extensions/Annotations/Types/InfinityLine.js

@@ -0,0 +1,147 @@
+/* *
+ *
+ *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+ *
+ * */
+'use strict';
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+import Annotation from '../Annotations.js';
+import CrookedLine from './CrookedLine.js';
+import MockPoint from '../MockPoint.js';
+import U from '../../../Core/Utilities.js';
+var merge = U.merge;
+/* eslint-disable no-invalid-this, valid-jsdoc */
+var InfinityLine = /** @class */ (function (_super) {
+    __extends(InfinityLine, _super);
+    /* *
+     *
+     *  Constructors
+     *
+     * */
+    function InfinityLine(chart, options) {
+        return _super.call(this, chart, options) || this;
+    }
+    /* *
+     *
+     * Static Functions
+     *
+     * */
+    InfinityLine.edgePoint = function (startIndex, endIndex) {
+        return function (target) {
+            var annotation = target.annotation, points = annotation.points, type = annotation.options.typeOptions.type;
+            if (type === 'horizontalLine') {
+                // Horizontal line has only one point,
+                // make a copy of it:
+                points = [
+                    points[0],
+                    new MockPoint(annotation.chart, points[0].target, {
+                        x: points[0].x + 1,
+                        y: points[0].y,
+                        xAxis: points[0].options.xAxis,
+                        yAxis: points[0].options.yAxis
+                    })
+                ];
+            }
+            else if (type === 'verticalLine') {
+                // The same for verticalLine type:
+                points = [
+                    points[0],
+                    new MockPoint(annotation.chart, points[0].target, {
+                        x: points[0].x,
+                        y: points[0].y + 1,
+                        xAxis: points[0].options.xAxis,
+                        yAxis: points[0].options.yAxis
+                    })
+                ];
+            }
+            return InfinityLine.findEdgePoint(points[startIndex], points[endIndex]);
+        };
+    };
+    InfinityLine.findEdgeCoordinate = function (firstPoint, secondPoint, xOrY, edgePointFirstCoordinate) {
+        var xOrYOpposite = xOrY === 'x' ? 'y' : 'x';
+        // solves equation for x or y
+        // y - y1 = (y2 - y1) / (x2 - x1) * (x - x1)
+        return ((secondPoint[xOrY] - firstPoint[xOrY]) *
+            (edgePointFirstCoordinate - firstPoint[xOrYOpposite]) /
+            (secondPoint[xOrYOpposite] - firstPoint[xOrYOpposite]) +
+            firstPoint[xOrY]);
+    };
+    InfinityLine.findEdgePoint = function (firstPoint, secondPoint) {
+        var xAxis = firstPoint.series.xAxis, yAxis = secondPoint.series.yAxis, firstPointPixels = MockPoint.pointToPixels(firstPoint), secondPointPixels = MockPoint.pointToPixels(secondPoint), deltaX = secondPointPixels.x - firstPointPixels.x, deltaY = secondPointPixels.y - firstPointPixels.y, xAxisMin = xAxis.left, xAxisMax = xAxisMin + xAxis.width, yAxisMin = yAxis.top, yAxisMax = yAxisMin + yAxis.height, xLimit = deltaX < 0 ? xAxisMin : xAxisMax, yLimit = deltaY < 0 ? yAxisMin : yAxisMax, edgePoint = {
+            x: deltaX === 0 ? firstPointPixels.x : xLimit,
+            y: deltaY === 0 ? firstPointPixels.y : yLimit
+        }, edgePointX, edgePointY, swap;
+        if (deltaX !== 0 && deltaY !== 0) {
+            edgePointY = InfinityLine.findEdgeCoordinate(firstPointPixels, secondPointPixels, 'y', xLimit);
+            edgePointX = InfinityLine.findEdgeCoordinate(firstPointPixels, secondPointPixels, 'x', yLimit);
+            if (edgePointY >= yAxisMin && edgePointY <= yAxisMax) {
+                edgePoint.x = xLimit;
+                edgePoint.y = edgePointY;
+            }
+            else {
+                edgePoint.x = edgePointX;
+                edgePoint.y = yLimit;
+            }
+        }
+        edgePoint.x -= xAxisMin;
+        edgePoint.y -= yAxisMin;
+        if (firstPoint.series.chart.inverted) {
+            swap = edgePoint.x;
+            edgePoint.x = edgePoint.y;
+            edgePoint.y = swap;
+        }
+        return edgePoint;
+    };
+    /* *
+     *
+     *  Functions
+     *
+     * */
+    InfinityLine.prototype.addShapes = function () {
+        var typeOptions = this.options.typeOptions, points = [
+            this.points[0],
+            InfinityLine.endEdgePoint
+        ];
+        if (typeOptions.type.match(/Line/g)) {
+            points[0] = InfinityLine.startEdgePoint;
+        }
+        var line = this.initShape(merge(typeOptions.line, {
+            type: 'path',
+            points: points
+        }), false);
+        typeOptions.line = line.options;
+    };
+    /**
+     *
+     * Static Properties
+     *
+     */
+    InfinityLine.endEdgePoint = InfinityLine.edgePoint(0, 1);
+    InfinityLine.startEdgePoint = InfinityLine.edgePoint(1, 0);
+    return InfinityLine;
+}(CrookedLine));
+InfinityLine.prototype.defaultOptions = merge(CrookedLine.prototype.defaultOptions, {});
+/**
+ * An infinity line annotation.
+ *
+ * @sample highcharts/annotations-advanced/infinity-line/
+ *         Infinity Line
+ *
+ * @extends   annotations.crookedLine
+ * @product   highstock
+ * @apioption annotations.infinityLine
+ */
+Annotation.types.infinityLine = InfinityLine;
+export default InfinityLine;