highcharts 8.1.0 → 8.2.2

package/es-modules/{annotations → Extensions/Annotations}/ControlPoint.js

@@ -11,9 +11,9 @@
  * @param {Highcharts.AnnotationControllable} target
  * @return {Highcharts.PositionObject}
  */
-import U from './../parts/Utilities.js';
+import U from '../../Core/Utilities.js';
 var extend = U.extend, merge = U.merge, pick = U.pick;
-import eventEmitterMixin from './eventEmitterMixin.js';
+import eventEmitterMixin from './Mixins/EventEmitterMixin.js';
 /* eslint-disable no-invalid-this, valid-jsdoc */
 /**
  * A control point class which is a connection between controllable

package/es-modules/Extensions/Annotations/Controllables/ControllableCircle.js

@@ -0,0 +1,117 @@
+/* *
+ *
+ *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+ *
+ * */
+'use strict';
+import ControllableMixin from '../Mixins/ControllableMixin.js';
+import ControllablePath from './ControllablePath.js';
+import U from '../../../Core/Utilities.js';
+var merge = U.merge;
+/* eslint-disable no-invalid-this, valid-jsdoc */
+/**
+ * A controllable circle class.
+ *
+ * @requires modules/annotations
+ *
+ * @private
+ * @class
+ * @name Highcharts.AnnotationControllableCircle
+ *
+ * @param {Highcharts.Annotation} annotation an annotation instance
+ * @param {Highcharts.AnnotationsShapeOptions} options a shape's options
+ * @param {number} index of the circle
+ */
+var ControllableCircle = /** @class */ (function () {
+    /* *
+     *
+     *  Constructors
+     *
+     * */
+    function ControllableCircle(annotation, options, index) {
+        /* *
+         *
+         *  Properties
+         *
+         * */
+        this.addControlPoints = ControllableMixin.addControlPoints;
+        this.anchor = ControllableMixin.anchor;
+        this.attr = ControllableMixin.attr;
+        this.attrsFromOptions = ControllableMixin.attrsFromOptions;
+        this.destroy = ControllableMixin.destroy;
+        this.getPointsOptions = ControllableMixin.getPointsOptions;
+        this.init = ControllableMixin.init;
+        this.linkPoints = ControllableMixin.linkPoints;
+        this.point = ControllableMixin.point;
+        this.rotate = ControllableMixin.rotate;
+        this.scale = ControllableMixin.scale;
+        this.setControlPointsVisibility = ControllableMixin.setControlPointsVisibility;
+        this.shouldBeDrawn = ControllableMixin.shouldBeDrawn;
+        this.transform = ControllableMixin.transform;
+        this.transformPoint = ControllableMixin.transformPoint;
+        this.translatePoint = ControllableMixin.translatePoint;
+        this.translateShape = ControllableMixin.translateShape;
+        this.update = ControllableMixin.update;
+        /**
+         * @type 'circle'
+         */
+        this.type = 'circle';
+        this.translate = ControllableMixin.translateShape;
+        this.init(annotation, options, index);
+        this.collection = 'shapes';
+    }
+    /* *
+     *
+     *  Functions
+     *
+     * */
+    ControllableCircle.prototype.render = function (parent) {
+        var attrs = this.attrsFromOptions(this.options);
+        this.graphic = this.annotation.chart.renderer
+            .circle(0, -9e9, 0)
+            .attr(attrs)
+            .add(parent);
+        ControllableMixin.render.call(this);
+    };
+    ControllableCircle.prototype.redraw = function (animation) {
+        var position = this.anchor(this.points[0]).absolutePosition;
+        if (position) {
+            this.graphic[animation ? 'animate' : 'attr']({
+                x: position.x,
+                y: position.y,
+                r: this.options.r
+            });
+        }
+        else {
+            this.graphic.attr({
+                x: 0,
+                y: -9e9
+            });
+        }
+        this.graphic.placed = Boolean(position);
+        ControllableMixin.redraw.call(this, animation);
+    };
+    /**
+     * Set the radius.
+     *
+     * @param {number} r a radius to be set
+     */
+    ControllableCircle.prototype.setRadius = function (r) {
+        this.options.r = r;
+    };
+    /* *
+     *
+     *  Static Properties
+     *
+     * */
+    /**
+     * A map object which allows to map options attributes to element
+     * attributes.
+     *
+     * @name Highcharts.AnnotationControllableCircle.attrsMap
+     * @type {Highcharts.Dictionary<string>}
+     */
+    ControllableCircle.attrsMap = merge(ControllablePath.attrsMap, { r: 'r' });
+    return ControllableCircle;
+}());
+export default ControllableCircle;

package/es-modules/Extensions/Annotations/Controllables/ControllableImage.js

@@ -0,0 +1,111 @@
+/* *
+ *
+ *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+ *
+ * */
+'use strict';
+import ControllableLabel from './ControllableLabel.js';
+import ControllableMixin from '../Mixins/ControllableMixin.js';
+/* eslint-disable no-invalid-this, valid-jsdoc */
+/**
+ * A controllable image class.
+ *
+ * @requires modules/annotations
+ *
+ * @private
+ * @class
+ * @name Highcharts.AnnotationControllableImage
+ *
+ * @param {Highcharts.Annotation} annotation
+ * An annotation instance.
+ *
+ * @param {Highcharts.AnnotationsShapeOptions} options
+ * A controllable's options.
+ *
+ * @param {number} index
+ * Index of the image.
+ */
+var ControllableImage = /** @class */ (function () {
+    /* *
+     *
+     *  Constructors
+     *
+     * */
+    function ControllableImage(annotation, options, index) {
+        /* *
+         *
+         *  Properties
+         *
+         * */
+        this.addControlPoints = ControllableMixin.addControlPoints;
+        this.anchor = ControllableMixin.anchor;
+        this.attr = ControllableMixin.attr;
+        this.attrsFromOptions = ControllableMixin.attrsFromOptions;
+        this.destroy = ControllableMixin.destroy;
+        this.getPointsOptions = ControllableMixin.getPointsOptions;
+        this.init = ControllableMixin.init;
+        this.linkPoints = ControllableMixin.linkPoints;
+        this.point = ControllableMixin.point;
+        this.rotate = ControllableMixin.rotate;
+        this.scale = ControllableMixin.scale;
+        this.setControlPointsVisibility = ControllableMixin.setControlPointsVisibility;
+        this.shouldBeDrawn = ControllableMixin.shouldBeDrawn;
+        this.transform = ControllableMixin.transform;
+        this.transformPoint = ControllableMixin.transformPoint;
+        this.translatePoint = ControllableMixin.translatePoint;
+        this.translateShape = ControllableMixin.translateShape;
+        this.update = ControllableMixin.update;
+        /**
+         * @type 'image'
+         */
+        this.type = 'image';
+        this.translate = ControllableMixin.translateShape;
+        this.init(annotation, options, index);
+        this.collection = 'shapes';
+    }
+    ControllableImage.prototype.render = function (parent) {
+        var attrs = this.attrsFromOptions(this.options), options = this.options;
+        this.graphic = this.annotation.chart.renderer
+            .image(options.src, 0, -9e9, options.width, options.height)
+            .attr(attrs)
+            .add(parent);
+        this.graphic.width = options.width;
+        this.graphic.height = options.height;
+        ControllableMixin.render.call(this);
+    };
+    ControllableImage.prototype.redraw = function (animation) {
+        var anchor = this.anchor(this.points[0]), position = ControllableLabel.prototype.position.call(this, anchor);
+        if (position) {
+            this.graphic[animation ? 'animate' : 'attr']({
+                x: position.x,
+                y: position.y
+            });
+        }
+        else {
+            this.graphic.attr({
+                x: 0,
+                y: -9e9
+            });
+        }
+        this.graphic.placed = Boolean(position);
+        ControllableMixin.redraw.call(this, animation);
+    };
+    /* *
+     *
+     *  Static Properties
+     *
+     * */
+    /**
+     * A map object which allows to map options attributes to element attributes
+     *
+     * @name Highcharts.AnnotationControllableImage.attrsMap
+     * @type {Highcharts.Dictionary<string>}
+     */
+    ControllableImage.attrsMap = {
+        width: 'width',
+        height: 'height',
+        zIndex: 'zIndex'
+    };
+    return ControllableImage;
+}());
+export default ControllableImage;

package/es-modules/{annotations/controllable → Extensions/Annotations/Controllables}/ControllableLabel.js

@@ -4,13 +4,13 @@
  *
  * */
 'use strict';
-import H from './../../parts/Globals.js';
-import U from './../../parts/Utilities.js';
-var extend = U.extend, format = U.format, isNumber = U.isNumber, merge = U.merge, pick = U.pick;
-import './../../parts/SvgRenderer.js';
-import controllableMixin from './controllableMixin.js';
-import MockPoint from './../MockPoint.js';
-import Tooltip from '../../parts/Tooltip.js';
+import ControllableMixin from '../Mixins/ControllableMixin.js';
+import MockPoint from '../MockPoint.js';
+import SVGRenderer from '../../../Core/Renderer/SVG/SVGRenderer.js';
+import Tooltip from '../../../Core/Tooltip.js';
+import U from '../../../Core/Utilities.js';
+var extend = U.extend, format = U.format, isNumber = U.isNumber, pick = U.pick;
+import '../../../Core/Renderer/SVG/SVGRenderer.js';
 /* eslint-disable no-invalid-this, valid-jsdoc */
 /**
  * A controllable label class.
@@ -28,147 +28,162 @@ import Tooltip from '../../parts/Tooltip.js';
  * @param {number} index
  * Index of the label.
  */
-var ControllableLabel = function (annotation, options, index) {
-    this.init(annotation, options, index);
-    this.collection = 'labels';
-};
-/**
- * Shapes which do not have background - the object is used for proper
- * setting of the contrast color.
- *
- * @type {Array<string>}
- */
-ControllableLabel.shapesWithoutBackground = ['connector'];
-/**
- * Returns new aligned position based alignment options and box to align to.
- * It is almost a one-to-one copy from SVGElement.prototype.align
- * except it does not use and mutate an element
- *
- * @param {Highcharts.AnnotationAlignObject} alignOptions
- *
- * @param {Highcharts.BBoxObject} box
- *
- * @return {Highcharts.PositionObject}
- * Aligned position.
- */
-ControllableLabel.alignedPosition = function (alignOptions, box) {
-    var align = alignOptions.align, vAlign = alignOptions.verticalAlign, x = (box.x || 0) + (alignOptions.x || 0), y = (box.y || 0) + (alignOptions.y || 0), alignFactor, vAlignFactor;
-    if (align === 'right') {
-        alignFactor = 1;
-    }
-    else if (align === 'center') {
-        alignFactor = 2;
-    }
-    if (alignFactor) {
-        x += (box.width - (alignOptions.width || 0)) / alignFactor;
-    }
-    if (vAlign === 'bottom') {
-        vAlignFactor = 1;
-    }
-    else if (vAlign === 'middle') {
-        vAlignFactor = 2;
-    }
-    if (vAlignFactor) {
-        y += (box.height - (alignOptions.height || 0)) / vAlignFactor;
+var ControllableLabel = /** @class */ (function () {
+    /* *
+     *
+     *  Constructors
+     *
+     * */
+    function ControllableLabel(annotation, options, index) {
+        /* *
+         *
+         *  Properties
+         *
+         * */
+        this.addControlPoints = ControllableMixin.addControlPoints;
+        this.attr = ControllableMixin.attr;
+        this.attrsFromOptions = ControllableMixin.attrsFromOptions;
+        this.destroy = ControllableMixin.destroy;
+        this.getPointsOptions = ControllableMixin.getPointsOptions;
+        this.init = ControllableMixin.init;
+        this.linkPoints = ControllableMixin.linkPoints;
+        this.point = ControllableMixin.point;
+        this.rotate = ControllableMixin.rotate;
+        this.scale = ControllableMixin.scale;
+        this.setControlPointsVisibility = ControllableMixin.setControlPointsVisibility;
+        this.shouldBeDrawn = ControllableMixin.shouldBeDrawn;
+        this.transform = ControllableMixin.transform;
+        this.transformPoint = ControllableMixin.transformPoint;
+        this.translateShape = ControllableMixin.translateShape;
+        this.update = ControllableMixin.update;
+        this.init(annotation, options, index);
+        this.collection = 'labels';
     }
-    return {
-        x: Math.round(x),
-        y: Math.round(y)
-    };
-};
-/**
- * Returns new alignment options for a label if the label is outside the
- * plot area. It is almost a one-to-one copy from
- * Series.prototype.justifyDataLabel except it does not mutate the label and
- * it works with absolute instead of relative position.
- */
-ControllableLabel.justifiedOptions = function (chart, label, alignOptions, alignAttr) {
-    var align = alignOptions.align, verticalAlign = alignOptions.verticalAlign, padding = label.box ? 0 : (label.padding || 0), bBox = label.getBBox(), off, 
-    //
-    options = {
-        align: align,
-        verticalAlign: verticalAlign,
-        x: alignOptions.x,
-        y: alignOptions.y,
-        width: label.width,
-        height: label.height
-    }, 
-    //
-    x = alignAttr.x - chart.plotLeft, y = alignAttr.y - chart.plotTop;
-    // Off left
-    off = x + padding;
-    if (off < 0) {
+    /* *
+     *
+     *  Static Functions
+     *
+     * */
+    /**
+     * Returns new aligned position based alignment options and box to align to.
+     * It is almost a one-to-one copy from SVGElement.prototype.align
+     * except it does not use and mutate an element
+     *
+     * @param {Highcharts.AnnotationAlignObject} alignOptions
+     *
+     * @param {Highcharts.BBoxObject} box
+     *
+     * @return {Highcharts.PositionObject}
+     * Aligned position.
+     */
+    ControllableLabel.alignedPosition = function (alignOptions, box) {
+        var align = alignOptions.align, vAlign = alignOptions.verticalAlign, x = (box.x || 0) + (alignOptions.x || 0), y = (box.y || 0) + (alignOptions.y || 0), alignFactor, vAlignFactor;
         if (align === 'right') {
-            options.align = 'left';
+            alignFactor = 1;
         }
-        else {
-            options.x = -off;
+        else if (align === 'center') {
+            alignFactor = 2;
         }
-    }
-    // Off right
-    off = x + bBox.width - padding;
-    if (off > chart.plotWidth) {
-        if (align === 'left') {
-            options.align = 'right';
+        if (alignFactor) {
+            x += (box.width - (alignOptions.width || 0)) / alignFactor;
         }
-        else {
-            options.x = chart.plotWidth - off;
+        if (vAlign === 'bottom') {
+            vAlignFactor = 1;
         }
-    }
-    // Off top
-    off = y + padding;
-    if (off < 0) {
-        if (verticalAlign === 'bottom') {
-            options.verticalAlign = 'top';
+        else if (vAlign === 'middle') {
+            vAlignFactor = 2;
         }
-        else {
-            options.y = -off;
+        if (vAlignFactor) {
+            y += (box.height - (alignOptions.height || 0)) / vAlignFactor;
         }
-    }
-    // Off bottom
-    off = y + bBox.height - padding;
-    if (off > chart.plotHeight) {
-        if (verticalAlign === 'top') {
-            options.verticalAlign = 'bottom';
+        return {
+            x: Math.round(x),
+            y: Math.round(y)
+        };
+    };
+    /**
+     * Returns new alignment options for a label if the label is outside the
+     * plot area. It is almost a one-to-one copy from
+     * Series.prototype.justifyDataLabel except it does not mutate the label and
+     * it works with absolute instead of relative position.
+     */
+    ControllableLabel.justifiedOptions = function (chart, label, alignOptions, alignAttr) {
+        var align = alignOptions.align, verticalAlign = alignOptions.verticalAlign, padding = label.box ? 0 : (label.padding || 0), bBox = label.getBBox(), off, 
+        //
+        options = {
+            align: align,
+            verticalAlign: verticalAlign,
+            x: alignOptions.x,
+            y: alignOptions.y,
+            width: label.width,
+            height: label.height
+        }, 
+        //
+        x = alignAttr.x - chart.plotLeft, y = alignAttr.y - chart.plotTop;
+        // Off left
+        off = x + padding;
+        if (off < 0) {
+            if (align === 'right') {
+                options.align = 'left';
+            }
+            else {
+                options.x = -off;
+            }
         }
-        else {
-            options.y = chart.plotHeight - off;
+        // Off right
+        off = x + bBox.width - padding;
+        if (off > chart.plotWidth) {
+            if (align === 'left') {
+                options.align = 'right';
+            }
+            else {
+                options.x = chart.plotWidth - off;
+            }
         }
-    }
-    return options;
-};
-/**
- * A map object which allows to map options attributes to element attributes
- *
- * @type {Highcharts.Dictionary<string>}
- */
-ControllableLabel.attrsMap = {
-    backgroundColor: 'fill',
-    borderColor: 'stroke',
-    borderWidth: 'stroke-width',
-    zIndex: 'zIndex',
-    borderRadius: 'r',
-    padding: 'padding'
-};
-merge(true, ControllableLabel.prototype, controllableMixin, 
-/** @lends Annotation.ControllableLabel# */ {
+        // Off top
+        off = y + padding;
+        if (off < 0) {
+            if (verticalAlign === 'bottom') {
+                options.verticalAlign = 'top';
+            }
+            else {
+                options.y = -off;
+            }
+        }
+        // Off bottom
+        off = y + bBox.height - padding;
+        if (off > chart.plotHeight) {
+            if (verticalAlign === 'top') {
+                options.verticalAlign = 'bottom';
+            }
+            else {
+                options.y = chart.plotHeight - off;
+            }
+        }
+        return options;
+    };
+    /* *
+     *
+     *  Functions
+     *
+     * */
     /**
      * Translate the point of the label by deltaX and deltaY translations.
      * The point is the label's anchor.
      *
      * @param {number} dx translation for x coordinate
      * @param {number} dy translation for y coordinate
-     **/
-    translatePoint: function (dx, dy) {
-        controllableMixin.translatePoint.call(this, dx, dy, 0);
-    },
+     */
+    ControllableLabel.prototype.translatePoint = function (dx, dy) {
+        ControllableMixin.translatePoint.call(this, dx, dy, 0);
+    };
     /**
      * Translate x and y position relative to the label's anchor.
      *
      * @param {number} dx translation for x coordinate
      * @param {number} dy translation for y coordinate
-     **/
-    translate: function (dx, dy) {
+     */
+    ControllableLabel.prototype.translate = function (dx, dy) {
         var chart = this.annotation.chart, 
         // Annotation.options
         labelOptions = this.annotation.userOptions, 
@@ -187,8 +202,8 @@ merge(true, ControllableLabel.prototype, controllableMixin,
         chartOptions[this.collection][this.index].y = this.options.y;
         labelOptions[this.collection][this.index].x = this.options.x;
         labelOptions[this.collection][this.index].y = this.options.y;
-    },
-    render: function (parent) {
+    };
+    ControllableLabel.prototype.render = function (parent) {
         var options = this.options, attrs = this.attrsFromOptions(options), style = options.style;
         this.graphic = this.annotation.chart.renderer
             .label('', 0, -9999, // #10055
@@ -207,10 +222,10 @@ merge(true, ControllableLabel.prototype, controllableMixin,
             this.graphic.addClass(options.className);
         }
         this.graphic.labelrank = options.labelrank;
-        controllableMixin.render.call(this);
-    },
-    redraw: function (animation) {
-        var options = this.options, text = this.text || options.format || options.text, label = this.graphic, point = this.points[0], show = false, anchor, attrs;
+        ControllableMixin.render.call(this);
+    };
+    ControllableLabel.prototype.redraw = function (animation) {
+        var options = this.options, text = this.text || options.format || options.text, label = this.graphic, point = this.points[0], anchor, attrs;
         label.attr({
             text: text ?
                 format(text, point.getLabelConfig(), this.annotation.chart) :
@@ -218,8 +233,7 @@ merge(true, ControllableLabel.prototype, controllableMixin,
         });
         anchor = this.anchor(point);
         attrs = this.position(anchor);
-        show = attrs;
-        if (show) {
+        if (attrs) {
             label.alignAttr = attrs;
             attrs.anchorX = anchor.absolutePosition.x;
             attrs.anchorY = anchor.absolutePosition.y;
@@ -231,22 +245,22 @@ merge(true, ControllableLabel.prototype, controllableMixin,
                 y: -9999 // #10055
             });
         }
-        label.placed = Boolean(show);
-        controllableMixin.redraw.call(this, animation);
-    },
+        label.placed = !!attrs;
+        ControllableMixin.redraw.call(this, animation);
+    };
     /**
      * All basic shapes don't support alignTo() method except label.
      * For a controllable label, we need to subtract translation from
      * options.
      */
-    anchor: function () {
-        var anchor = controllableMixin.anchor.apply(this, arguments), x = this.options.x || 0, y = this.options.y || 0;
+    ControllableLabel.prototype.anchor = function (_point) {
+        var anchor = ControllableMixin.anchor.apply(this, arguments), x = this.options.x || 0, y = this.options.y || 0;
         anchor.absolutePosition.x -= x;
         anchor.absolutePosition.y -= y;
         anchor.relativePosition.x -= x;
         anchor.relativePosition.y -= y;
         return anchor;
-    },
+    };
     /**
      * Returns the label position relative to its anchor.
      *
@@ -254,7 +268,7 @@ merge(true, ControllableLabel.prototype, controllableMixin,
      *
      * @return {Highcharts.PositionObject|null}
      */
-    position: function (anchor) {
+    ControllableLabel.prototype.position = function (anchor) {
         var item = this.graphic, chart = this.annotation.chart, point = this.points[0], itemOptions = this.options, anchorAbsolutePosition = anchor.absolutePosition, anchorRelativePosition = anchor.relativePosition, itemPosition, alignTo, itemPosRelativeX, itemPosRelativeY, showItem = point.series.visible &&
             MockPoint.prototype.isInsidePlot.call(point);
         if (showItem) {
@@ -297,14 +311,41 @@ merge(true, ControllableLabel.prototype, controllableMixin,
             }
         }
         return showItem ? itemPosition : null;
-    }
-});
+    };
+    /* *
+     *
+     *  Static Properties
+     *
+     * */
+    /**
+     * A map object which allows to map options attributes to element attributes
+     *
+     * @type {Highcharts.Dictionary<string>}
+     */
+    ControllableLabel.attrsMap = {
+        backgroundColor: 'fill',
+        borderColor: 'stroke',
+        borderWidth: 'stroke-width',
+        zIndex: 'zIndex',
+        borderRadius: 'r',
+        padding: 'padding'
+    };
+    /**
+     * Shapes which do not have background - the object is used for proper
+     * setting of the contrast color.
+     *
+     * @type {Array<string>}
+     */
+    ControllableLabel.shapesWithoutBackground = ['connector'];
+    return ControllableLabel;
+}());
+export default ControllableLabel;
 /* ********************************************************************** */
 /**
  * General symbol definition for labels with connector
  * @private
  */
-H.SVGRenderer.prototype.symbols.connector = function (x, y, w, h, options) {
+SVGRenderer.prototype.symbols.connector = function (x, y, w, h, options) {
     var anchorX = options && options.anchorX, anchorY = options && options.anchorY, path, yOffset, lateral = w / 2;
     if (isNumber(anchorX) && isNumber(anchorY)) {
         path = [['M', anchorX, anchorY]];
@@ -335,4 +376,3 @@ H.SVGRenderer.prototype.symbols.connector = function (x, y, w, h, options) {
     }
     return path || [];
 };
-export default ControllableLabel;