highcharts 10.2.0 → 10.2.1

package/es-modules/Extensions/Annotations/{Mixins/ControllableMixin.js → Controllables/Controllable.js}

@@ -9,111 +9,64 @@ import MockPoint from '../MockPoint.js';
 import Tooltip from '../../../Core/Tooltip.js';
 import U from '../../../Core/Utilities.js';
 var isObject = U.isObject, isString = U.isString, merge = U.merge, splat = U.splat;
-/**
- * An object which denots a controllable's anchor positions - relative and
- * absolute.
+/* *
  *
- * @private
- * @interface Highcharts.AnnotationAnchorObject
- */ /**
-* Relative to the plot area position
-* @name Highcharts.AnnotationAnchorObject#relativePosition
-* @type {Highcharts.BBoxObject}
-*/ /**
-* Absolute position
-* @name Highcharts.AnnotationAnchorObject#absolutePosition
-* @type {Highcharts.BBoxObject}
-*/
-/**
- * @interface Highcharts.AnnotationControllable
- */ /**
-* @name Highcharts.AnnotationControllable#annotation
-* @type {Highcharts.Annotation}
-*/ /**
-* @name Highcharts.AnnotationControllable#chart
-* @type {Highcharts.Chart}
-*/ /**
-* @name Highcharts.AnnotationControllable#collection
-* @type {string}
-*/ /**
-* @private
-* @name Highcharts.AnnotationControllable#controlPoints
-* @type {Array<Highcharts.AnnotationControlPoint>}
-*/ /**
-* @name Highcharts.AnnotationControllable#points
-* @type {Array<Highcharts.Point>}
-*/
-/* eslint-disable no-invalid-this, valid-jsdoc */
+ *  Class
+ *
+ * */
 /**
  * It provides methods for handling points, control points
  * and points transformations.
- *
  * @private
- * @mixin
- * @name Highcharts.AnnotationControllableMixin
  */
-var controllableMixin = {
-    /**
-     * Init the controllable
-     */
-    init: function (annotation, options, index) {
+var Controllable = /** @class */ (function () {
+    /* *
+     *
+     *  Constructor
+     *
+     * */
+    function Controllable(annotation, options, index, itemType) {
+        this.graphic = void 0;
         this.annotation = annotation;
         this.chart = annotation.chart;
+        this.collection = (itemType === 'label' ? 'labels' : 'shapes');
         this.options = options;
         this.points = [];
         this.controlPoints = [];
         this.index = index;
-        this.linkPoints();
-        this.addControlPoints();
-    },
-    /**
-     * Redirect attr usage on the controllable graphic element.
-     */
-    attr: function () {
-        this.graphic.attr.apply(this.graphic, arguments);
-    },
-    /**
-     * Get the controllable's points options.
-     *
-     * @return {Array<Highcharts.PointOptionsObject>}
-     * An array of points' options.
-     */
-    getPointsOptions: function () {
-        var options = this.options;
-        return (options.points ||
-            (options.point && splat(options.point)));
-    },
-    /**
-     * Utility function for mapping item's options
-     * to element's attribute
+        this.itemType = itemType;
+        this.init(annotation, options, index);
+    }
+    /* *
      *
-     * @param {Highcharts.AnnotationsLabelsOptions|Highcharts.AnnotationsShapesOptions} options
+     *  Functions
      *
-     * @return {Highcharts.SVGAttributes}
-     * Mapped options.
+     * */
+    /**
+     * Add control points to a controllable.
+     * @private
      */
-    attrsFromOptions: function (options) {
-        var map = this.constructor.attrsMap, attrs = {}, key, mappedKey, styledMode = this.chart.styledMode;
-        for (key in options) { // eslint-disable-line guard-for-in
-            mappedKey = map[key];
-            if (mappedKey &&
-                (!styledMode ||
-                    ['fill', 'stroke', 'stroke-width']
-                        .indexOf(mappedKey) === -1)) {
-                attrs[mappedKey] = options[key];
+    Controllable.prototype.addControlPoints = function () {
+        var _this = this;
+        var controlPoints = this.controlPoints, controlPointsOptions = this.options.controlPoints || [];
+        controlPointsOptions.forEach(function (controlPointOptions, i) {
+            var options = merge(_this.options.controlPointOptions, controlPointOptions);
+            if (!options.index) {
+                options.index = i;
             }
-        }
-        return attrs;
-    },
+            controlPointsOptions[i] = options;
+            controlPoints.push(new ControlPoint(_this.chart, _this, options));
+        });
+    };
     /**
      * Returns object which denotes anchor position - relative and absolute.
-     *
+     * @private
      * @param {Highcharts.AnnotationPointType} point
-     * A point like object.
-     *
-     * @return {Highcharts.AnnotationAnchorObject} a controllable anchor
+     *        A point like object.
+     * @return {Highcharts.AnnotationAnchorObject}
+     *         A controllable anchor
      */
-    anchor: function (point) {
+    Controllable.prototype.anchor = function (point) {
         var plotBox = point.series.getPlotBox(), chart = point.series.chart, box = point.mock ?
             point.toAnchor() :
             Tooltip.prototype.getAnchor.call({
@@ -131,20 +84,118 @@ var controllableMixin = {
                 y: anchor.y + (point.mock ? plotBox.translateY : chart.plotTop)
             })
         };
-    },
+    };
+    /**
+     * Redirect attr usage on the controllable graphic element.
+     * @private
+     */
+    Controllable.prototype.attr = function () {
+        var _args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            _args[_i] = arguments[_i];
+        }
+        this.graphic.attr.apply(this.graphic, arguments);
+    };
+    /**
+     * Utility function for mapping item's options
+     * to element's attribute
+     * @private
+     * @param {Highcharts.AnnotationsLabelsOptions|Highcharts.AnnotationsShapesOptions} options
+     * @return {Highcharts.SVGAttributes}
+     *         Mapped options.
+     */
+    Controllable.prototype.attrsFromOptions = function (options) {
+        var map = this.constructor.attrsMap, attrs = {}, styledMode = this.chart.styledMode;
+        var key, mappedKey;
+        for (key in options) { // eslint-disable-line guard-for-in
+            mappedKey = map[key];
+            if (typeof map[key] !== 'undefined' &&
+                (!styledMode ||
+                    ['fill', 'stroke', 'stroke-width']
+                        .indexOf(mappedKey) === -1)) {
+                attrs[mappedKey] = options[key];
+            }
+        }
+        return attrs;
+    };
+    /**
+     * Destroy a controllable.
+     * @private
+     */
+    Controllable.prototype.destroy = function () {
+        if (this.graphic) {
+            this.graphic = this.graphic.destroy();
+        }
+        if (this.tracker) {
+            this.tracker = this.tracker.destroy();
+        }
+        this.controlPoints.forEach(function (controlPoint) { return controlPoint.destroy(); });
+        this.chart = null;
+        this.points = null;
+        this.controlPoints = null;
+        this.options = null;
+        if (this.annotation) {
+            this.annotation = null;
+        }
+    };
+    /**
+     * Get the controllable's points options.
+     * @private
+     * @return {Array<Highcharts.PointOptionsObject>}
+     *         An array of points' options.
+     */
+    Controllable.prototype.getPointsOptions = function () {
+        var options = this.options;
+        return (options.points ||
+            (options.point && splat(options.point)));
+    };
+    /**
+     * Init the controllable
+     * @private
+     */
+    Controllable.prototype.init = function (annotation, options, index) {
+        this.annotation = annotation;
+        this.chart = annotation.chart;
+        this.options = options;
+        this.points = [];
+        this.controlPoints = [];
+        this.index = index;
+        this.linkPoints();
+        this.addControlPoints();
+    };
+    /**
+     * Find point-like objects based on points options.
+     * @private
+     * @return {Array<Annotation.PointLike>}
+     *         An array of point-like objects.
+     */
+    Controllable.prototype.linkPoints = function () {
+        var pointsOptions = this.getPointsOptions(), points = this.points, len = (pointsOptions && pointsOptions.length) || 0;
+        var i, point;
+        for (i = 0; i < len; i++) {
+            point = this.point(pointsOptions[i], points[i]);
+            if (!point) {
+                points.length = 0;
+                return;
+            }
+            if (point.mock) {
+                point.refresh();
+            }
+            points[i] = point;
+        }
+        return points;
+    };
     /**
      * Map point's options to a point-like object.
-     *
+     * @private
      * @param {string|Function|Highcharts.AnnotationMockPointOptionsObject|Highcharts.AnnotationPointType} pointOptions
-     * Point's options.
-     *
+     *        Point's options.
      * @param {Highcharts.AnnotationPointType} point
-     * A point-like instance.
-     *
+     *        A point-like instance.
      * @return {Highcharts.AnnotationPointType|null}
-     *         if the point is found/set returns this point, otherwise null
+     *         If the point is found/set returns this point, otherwise null
      */
-    point: function (pointOptions, point) {
+    Controllable.prototype.point = function (pointOptions, point) {
         if (pointOptions && pointOptions.series) {
             return pointOptions;
         }
@@ -163,136 +214,151 @@ var controllableMixin = {
             }
         }
         return point;
-    },
+    };
     /**
-     * Find point-like objects based on points options.
-     *
-     * @return {Array<Annotation.PointLike>} an array of point-like objects
+     * Render a controllable.
+     * @private
      */
-    linkPoints: function () {
-        var pointsOptions = this.getPointsOptions(), points = this.points, len = (pointsOptions && pointsOptions.length) || 0, i, point;
-        for (i = 0; i < len; i++) {
-            point = this.point(pointsOptions[i], points[i]);
-            if (!point) {
-                points.length = 0;
-                return;
-            }
-            if (point.mock) {
-                point.refresh();
-            }
-            points[i] = point;
-        }
-        return points;
-    },
+    Controllable.prototype.render = function (_parentGroup) {
+        this.controlPoints.forEach(function (controlPoint) { return controlPoint.render(); });
+    };
     /**
-     * Add control points to a controllable.
+     * Redraw a controllable.
+     * @private
      */
-    addControlPoints: function () {
-        var controlPointsOptions = this.options.controlPoints;
-        (controlPointsOptions || []).forEach(function (controlPointOptions, i) {
-            var options = merge(this.options.controlPointOptions, controlPointOptions);
-            if (!options.index) {
-                options.index = i;
-            }
-            controlPointsOptions[i] = options;
-            this.controlPoints.push(new ControlPoint(this.chart, this, options));
-        }, this);
-    },
+    Controllable.prototype.redraw = function (animation) {
+        this.controlPoints.forEach(function (controlPoint) { return controlPoint.redraw(animation); });
+    };
     /**
-     * Check if a controllable should be rendered/redrawn.
-     *
-     * @return {boolean}
-     * Whether a controllable should be drawn.
+     * Rotate a controllable.
+     * @private
+     * @param {number} cx
+     *        Origin x rotation
+     * @param {number} cy
+     *        Origin y rotation
+     * @param {number} radians
+     **/
+    Controllable.prototype.rotate = function (cx, cy, radians) {
+        this.transform('rotate', cx, cy, radians);
+    };
+    /**
+     * Scale a controllable.
+     * @private
+     * @param {number} cx
+     *        Origin x rotation
+     * @param {number} cy
+     *        Origin y rotation
+     * @param {number} sx
+     *        Scale factor x
+     * @param {number} sy
+     *        Scale factor y
      */
-    shouldBeDrawn: function () {
-        return Boolean(this.points.length);
-    },
+    Controllable.prototype.scale = function (cx, cy, sx, sy) {
+        this.transform('scale', cx, cy, sx, sy);
+    };
     /**
-     * Render a controllable.
+     * Set control points' visibility.
+     * @private
      */
-    render: function (_parentGroup) {
+    Controllable.prototype.setControlPointsVisibility = function (visible) {
         this.controlPoints.forEach(function (controlPoint) {
-            controlPoint.render();
+            controlPoint.setVisibility(visible);
         });
-    },
+    };
     /**
-     * Redraw a controllable.
-     *
-     * @param {boolean} [animation]
+     * Check if a controllable should be rendered/redrawn.
+     * @private
+     * @return {boolean}
+     *         Whether a controllable should be drawn.
      */
-    redraw: function (animation) {
-        this.controlPoints.forEach(function (controlPoint) {
-            controlPoint.redraw(animation);
-        });
-    },
+    Controllable.prototype.shouldBeDrawn = function () {
+        return !!this.points.length;
+    };
     /**
      * Transform a controllable with a specific transformation.
-     *
-     * @param {string} transformation a transformation name
-     * @param {number|null} cx origin x transformation
-     * @param {number|null} cy origin y transformation
-     * @param {number} p1 param for the transformation
-     * @param {number} [p2] param for the transformation
+     * @private
+     * @param {string} transformation
+     *        A transformation name
+     * @param {number|null} cx
+     *        Origin x transformation
+     * @param {number|null} cy
+     *        Origin y transformation
+     * @param {number} p1
+     *        Param for the transformation
+     * @param {number} [p2]
+     *        Param for the transformation
      */
-    transform: function (transformation, cx, cy, p1, p2) {
+    Controllable.prototype.transform = function (transformation, cx, cy, p1, p2) {
+        var _this = this;
         if (this.chart.inverted) {
             var temp = cx;
             cx = cy;
             cy = temp;
         }
-        this.points.forEach(function (point, i) {
-            this.transformPoint(transformation, cx, cy, p1, p2, i);
-        }, this);
-    },
+        this.points.forEach(function (_point, i) { return (_this.transformPoint(transformation, cx, cy, p1, p2, i)); }, this);
+    };
     /**
      * Transform a point with a specific transformation
      * If a transformed point is a real point it is replaced with
      * the mock point.
-     *
-     * @param {string} transformation a transformation name
-     * @param {number|null} cx origin x transformation
-     * @param {number|null} cy origin y transformation
-     * @param {number} p1 param for the transformation
-     * @param {number|undefined} p2 param for the transformation
-     * @param {number} i index of the point
+     * @private
+     * @param {string} transformation
+     *        A transformation name
+     * @param {number|null} cx
+     *        Origin x transformation
+     * @param {number|null} cy
+     *        Origin y transformation
+     * @param {number} p1
+     *        Param for the transformation
+     * @param {number|undefined} p2
+     *        Param for the transformation
+     * @param {number} i
+     *        Index of the point
      */
-    transformPoint: function (transformation, cx, cy, p1, p2, i) {
+    Controllable.prototype.transformPoint = function (transformation, cx, cy, p1, p2, i) {
         var point = this.points[i];
         if (!point.mock) {
             point = this.points[i] = MockPoint.fromPoint(point);
         }
         point[transformation](cx, cy, p1, p2);
-    },
+    };
     /**
      * Translate a controllable.
-     *
-     * @param {number} dx translation for x coordinate
-     * @param {number} dy translation for y coordinate
+     * @private
+     * @param {number} dx
+     *        Translation for x coordinate
+     * @param {number} dy
+     *        Translation for y coordinate
      **/
-    translate: function (dx, dy) {
+    Controllable.prototype.translate = function (dx, dy) {
         this.transform('translate', null, null, dx, dy);
-    },
+    };
     /**
      * Translate a specific point within a controllable.
-     *
-     * @param {number} dx translation for x coordinate
-     * @param {number} dy translation for y coordinate
-     * @param {number} i index of the point
+     * @private
+     * @param {number} dx
+     *        Translation for x coordinate
+     * @param {number} dy
+     *        Translation for y coordinate
+     * @param {number} i
+     *        Index of the point
      **/
-    translatePoint: function (dx, dy, i) {
+    Controllable.prototype.translatePoint = function (dx, dy, i) {
         this.transformPoint('translate', null, null, dx, dy, i);
-    },
+    };
     /**
      * Translate shape within controllable item.
      * Replaces `controllable.translate` method.
-     *
-     * @param {number} dx translation for x coordinate
-     * @param {number} dy translation for y coordinate
-     * @param {boolean|undefined} translateSecondPoint If the shape has two
-     * points attached to it, this option allows you to translate also
-     * the second point
+     * @private
+     * @param {number} dx
+     *        Translation for x coordinate
+     * @param {number} dy
+     *        Translation for y coordinate
+     * @param {boolean|undefined} translateSecondPoint
+     *        If the shape has two points attached to it, this option allows you
+     *        to translate also the second point.
      */
-    translateShape: function (dx, dy, translateSecondPoint) {
+    Controllable.prototype.translateShape = function (dx, dy, translateSecondPoint) {
         var chart = this.annotation.chart, 
         // Annotation.options
         shapeOptions = this.annotation.userOptions, 
@@ -309,70 +375,63 @@ var controllableMixin = {
             .point = this.options.point;
         shapeOptions[this.collection][this.index]
             .point = this.options.point;
-    },
-    /**
-     * Rotate a controllable.
-     *
-     * @param {number} cx origin x rotation
-     * @param {number} cy origin y rotation
-     * @param {number} radians
-     **/
-    rotate: function (cx, cy, radians) {
-        this.transform('rotate', cx, cy, radians);
-    },
-    /**
-     * Scale a controllable.
-     *
-     * @param {number} cx origin x rotation
-     * @param {number} cy origin y rotation
-     * @param {number} sx scale factor x
-     * @param {number} sy scale factor y
-     */
-    scale: function (cx, cy, sx, sy) {
-        this.transform('scale', cx, cy, sx, sy);
-    },
-    /**
-     * Set control points' visibility.
-     *
-     * @param {boolean} visible
-     */
-    setControlPointsVisibility: function (visible) {
-        this.controlPoints.forEach(function (controlPoint) {
-            controlPoint.setVisibility(visible);
-        });
-    },
-    /**
-     * Destroy a controllable.
-     */
-    destroy: function () {
-        if (this.graphic) {
-            this.graphic = this.graphic.destroy();
-        }
-        if (this.tracker) {
-            this.tracker = this.tracker.destroy();
-        }
-        this.controlPoints.forEach(function (controlPoint) {
-            controlPoint.destroy();
-        });
-        this.chart = null;
-        this.points = null;
-        this.controlPoints = null;
-        this.options = null;
-        if (this.annotation) {
-            this.annotation = null;
-        }
-    },
+    };
     /**
      * Update a controllable.
-     *
-     * @param {Object} newOptions
+     * @private
      */
-    update: function (newOptions) {
+    Controllable.prototype.update = function (newOptions) {
         var annotation = this.annotation, options = merge(true, this.options, newOptions), parentGroup = this.graphic.parentGroup;
         this.destroy();
-        this.constructor(annotation, options, this.index);
+        this.constructor(annotation, options, this.index, this.itemType);
         this.render(parentGroup);
         this.redraw();
-    }
-};
-export default controllableMixin;
+    };
+    return Controllable;
+}());
+/* *
+ *
+ *  Default Export
+ *
+ * */
+export default Controllable;
+/* *
+ *
+ *  API Declarations
+ *
+ * */
+/**
+ * An object which denots a controllable's anchor positions - relative and
+ * absolute.
+ *
+ * @private
+ * @interface Highcharts.AnnotationAnchorObject
+ */ /**
+* Relative to the plot area position
+* @name Highcharts.AnnotationAnchorObject#relativePosition
+* @type {Highcharts.BBoxObject}
+*/ /**
+* Absolute position
+* @name Highcharts.AnnotationAnchorObject#absolutePosition
+* @type {Highcharts.BBoxObject}
+*/
+/**
+ * @interface Highcharts.AnnotationControllable
+ */ /**
+* @name Highcharts.AnnotationControllable#annotation
+* @type {Highcharts.Annotation}
+*/ /**
+* @name Highcharts.AnnotationControllable#chart
+* @type {Highcharts.Chart}
+*/ /**
+* @name Highcharts.AnnotationControllable#collection
+* @type {string}
+*/ /**
+* @private
+* @name Highcharts.AnnotationControllable#controlPoints
+* @type {Array<Highcharts.AnnotationControlPoint>}
+*/ /**
+* @name Highcharts.AnnotationControllable#points
+* @type {Array<Highcharts.Point>}
+*/
+(''); // keeps doclets above in JS file