highcharts 9.2.1 → 9.3.2

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

@@ -0,0 +1,211 @@
+/* *
+ *
+ *  Authors: Rafal Sebestjanski and Pawel Lysy
+ *
+ *  !!!!!!! 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 ControlPoint from '../ControlPoint.js';
+import U from '../../../Core/Utilities.js';
+var merge = U.merge, isNumber = U.isNumber, defined = U.defined;
+/**
+ * Function to create start of the path.
+ * @param {number} x x position of the TimeCycles
+ * @param {number} y y position of the TimeCycles
+ * @return {string} path
+ */
+function getStartingPath(x, y) {
+    return ['M', x, y];
+}
+/**
+ * Function which generates the path of the halfcircle.
+ *
+ * @param {number} pixelInterval diameter of the circle in pixels
+ * @param {number} numberOfCircles number of cricles
+ * @param {number} startX x position of the first circle
+ * @param {number} y y position of the bottom of the timeCycles
+ * @return {string} path
+ *
+ */
+function getCirclePath(pixelInterval, numberOfCircles, startX, y) {
+    var strToRepeat = function (i) { return [
+        'A',
+        pixelInterval / 2,
+        pixelInterval / 2,
+        0,
+        1,
+        1,
+        startX + i * pixelInterval,
+        y
+    ]; };
+    var path = [];
+    for (var i = 1; i <= numberOfCircles; i++) {
+        path.push(strToRepeat(i));
+    }
+    return path;
+}
+/* *
+ *
+ *  Class
+ *
+ * */
+/* eslint-disable no-invalid-this, valid-jsdoc */
+var TimeCycles = /** @class */ (function (_super) {
+    __extends(TimeCycles, _super);
+    function TimeCycles() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    TimeCycles.prototype.init = function (annotation, options, index) {
+        if (defined(options.yAxis)) {
+            options.points.forEach(function (point) {
+                point.yAxis = options.yAxis;
+            });
+        }
+        if (defined(options.xAxis)) {
+            options.points.forEach(function (point) {
+                point.xAxis = options.xAxis;
+            });
+        }
+        _super.prototype.init.call(this, annotation, options, index);
+    };
+    TimeCycles.prototype.setPath = function () {
+        this.shapes[0].options.d = this.getPath();
+    };
+    TimeCycles.prototype.getPath = function () {
+        return [getStartingPath(this.startX, this.y)].concat(getCirclePath(this.pixelInterval, this.numberOfCircles, this.startX, this.y));
+    };
+    TimeCycles.prototype.addShapes = function () {
+        var typeOptions = this.options.typeOptions;
+        this.setPathProperties();
+        var shape = this.initShape(merge(typeOptions.line, {
+            type: 'path',
+            d: this.getPath(),
+            points: this.options.points
+        }), 0);
+        typeOptions.line = shape.options;
+    };
+    TimeCycles.prototype.addControlPoints = function () {
+        var _this = this;
+        var options = this.options, typeOptions = options.typeOptions;
+        options.controlPointOptions.style.cursor = this.chart.inverted ?
+            'ns-resize' :
+            'ew-resize';
+        typeOptions.controlPointOptions.forEach(function (option) {
+            var controlPointsOptions = merge(options.controlPointOptions, option);
+            var controlPoint = new ControlPoint(_this.chart, _this, controlPointsOptions, 0);
+            _this.controlPoints.push(controlPoint);
+        });
+    };
+    TimeCycles.prototype.setPathProperties = function () {
+        var options = this.options.typeOptions, points = options.points;
+        if (!points) {
+            return;
+        }
+        var point1 = points[0], point2 = points[1], xAxisNumber = options.xAxis || 0, yAxisNumber = options.yAxis || 0, xAxis = this.chart.xAxis[xAxisNumber], yAxis = this.chart.yAxis[yAxisNumber], xValue1 = point1.x, yValue = point1.y, xValue2 = point2.x;
+        if (!xValue1 || !xValue2) {
+            return;
+        }
+        var y = isNumber(yValue) ?
+            yAxis.toPixels(yValue) :
+            yAxis.top + yAxis.height, x = isNumber(xValue1) ? xAxis.toPixels(xValue1) : xAxis.left, x2 = isNumber(xValue2) ? xAxis.toPixels(xValue2) : xAxis.left + 30, xAxisLength = xAxis.len, pixelInterval = Math.round(Math.max(Math.abs(x2 - x), 2)), 
+        // There can be 2 not full circles on the chart, so add 2.
+        numberOfCircles = Math.floor(xAxisLength / pixelInterval) + 2, 
+        // Calculate where the annotation should start drawing relative to
+        // first point.
+        pixelShift = (Math.floor((x - xAxis.left) / pixelInterval) + 1) * pixelInterval;
+        this.startX = x - pixelShift;
+        this.y = y;
+        this.pixelInterval = pixelInterval;
+        this.numberOfCircles = numberOfCircles;
+    };
+    TimeCycles.prototype.redraw = function (animation) {
+        this.setPathProperties();
+        this.setPath();
+        _super.prototype.redraw.call(this, animation);
+    };
+    return TimeCycles;
+}(CrookedLine));
+TimeCycles.prototype.defaultOptions = merge(CrookedLine.prototype.defaultOptions, {
+    typeOptions: {
+        controlPointOptions: [{
+                positioner: function (target) {
+                    var point = target.points[0], position = target.anchor(point).absolutePosition;
+                    return {
+                        x: position.x - this.graphic.width / 2,
+                        y: target.y - this.graphic.height
+                    };
+                },
+                events: {
+                    drag: function (e, target) {
+                        var position = target.anchor(target.points[0]).absolutePosition;
+                        target.translatePoint(e.chartX - position.x, 0, 0);
+                        target.redraw(false);
+                    }
+                }
+            }, {
+                positioner: function (target) {
+                    var point = target.points[1], position = target.anchor(point).absolutePosition;
+                    return {
+                        x: position.x - this.graphic.width / 2,
+                        y: target.y - this.graphic.height
+                    };
+                },
+                events: {
+                    drag: function (e, target) {
+                        var position = target.anchor(target.points[1]).absolutePosition;
+                        target.translatePoint(e.chartX - position.x, 0, 1);
+                        target.redraw(false);
+                    }
+                }
+            }]
+    }
+});
+/* *
+ *
+ *  Registry
+ *
+ * */
+Annotation.types.timeCycles = TimeCycles;
+/* *
+ *
+ *  Default Export
+ *
+ * */
+export default TimeCycles;
+/* *
+ *
+ *  API Declarations
+ *
+ * */
+/**
+ * The TimeCycles Annotation
+ * @sample highcharts/annotations-advanced/time-cycles/
+ *     Time Cycles annotation
+ *
+ * @extends   annotations.crookedLine
+ * @product   highstock
+ * @exclude  labelOptions
+ * @apioption annotations.timeCycles
+ */
+/**
+ * @exclude   y
+ * @product   highstock
+ * @apioption annotations.timeCycles.typeOptions.points
+ */
+(''); // keeps doclets above in transpiled file

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

@@ -82,22 +82,25 @@ var Tunnel = /** @class */ (function (_super) {
                 },
                 this.points[3]
             ]
-        }), false);
+        }), 0);
         this.options.typeOptions.line = line.options;
     };
     Tunnel.prototype.addBackground = function () {
         var background = this.initShape(merge(this.options.typeOptions.background, {
             type: 'path',
             points: this.points.slice()
-        }));
+        }), 1);
         this.options.typeOptions.background = background.options;
     };
     /**
      * Translate start or end ("left" or "right") side of the tunnel.
      * @private
-     * @param {number} dx - the amount of x translation
-     * @param {number} dy - the amount of y translation
-     * @param {boolean} [end] - whether to translate start or end side
+     * @param {number} dx
+     * the amount of x translation
+     * @param {number} dy
+     * the amount of y translation
+     * @param {boolean} [end]
+     * whether to translate start or end side
      */
     Tunnel.prototype.translateSide = function (dx, dy, end) {
         var topIndex = Number(end), bottomIndex = topIndex === 0 ? 3 : 2;
@@ -107,12 +110,14 @@ var Tunnel = /** @class */ (function (_super) {
     /**
      * Translate height of the tunnel.
      * @private
-     * @param {number} dh - the amount of height translation
+     * @param {number} dh
+     * the amount of height translation
      */
     Tunnel.prototype.translateHeight = function (dh) {
         this.translatePoint(0, dh, 2);
         this.translatePoint(0, dh, 3);
-        this.options.typeOptions.height = this.points[3].y - this.points[0].y;
+        this.options.typeOptions.height = this.points[3].y -
+            this.points[0].y;
     };
     return Tunnel;
 }(CrookedLine));
@@ -128,8 +133,6 @@ Tunnel.prototype.defaultOptions = merge(CrookedLine.prototype.defaultOptions,
  */
 {
     typeOptions: {
-        xAxis: 0,
-        yAxis: 0,
         /**
          * Background options.
          *
@@ -187,7 +190,7 @@ Tunnel.prototype.defaultOptions = merge(CrookedLine.prototype.defaultOptions,
                     visiblePlotOnly: true
                 })) {
                     var translation = this.mouseMoveToTranslation(e);
-                    target.translateSide(translation.x, translation.y, this.index);
+                    target.translateSide(translation.x, translation.y, !!this.index);
                     target.redraw(false);
                 }
             }

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

@@ -73,7 +73,7 @@ var VerticalLine = /** @class */ (function (_super) {
                 VerticalLine.connectorFirstPoint,
                 VerticalLine.connectorSecondPoint
             ]
-        }), false);
+        }), 0);
         typeOptions.connector = connector.options;
     };
     VerticalLine.prototype.addLabels = function () {

package/es-modules/Extensions/Boost/BoostOptions.js

@@ -65,8 +65,8 @@ import '../../Core/Globals.js';
  * a significant speed improvment in charts with a very high
  * amount of series.
  *
- * @type      {number|null}
- * @default   null
+ * @type      {number}
+ * @default   50
  * @apioption boost.seriesThreshold
  */
 /**

package/es-modules/Extensions/Boost/BoostOverrides.js

@@ -49,10 +49,6 @@ Chart.prototype.isChartSeriesBoosting = function () {
  *
  * @private
  * @function Highcharts.Chart#getBoostClipRect
- *
- * @param {Highcharts.Chart} target
- *
- * @return {Highcharts.BBoxObject}
  */
 Chart.prototype.getBoostClipRect = function (target) {
     var clipBox = {
@@ -65,7 +61,9 @@ Chart.prototype.getBoostClipRect = function (target) {
         var verticalAxes = this.inverted ? this.xAxis : this.yAxis; // #14444
         if (verticalAxes.length <= 1) {
             clipBox.y = Math.min(verticalAxes[0].pos, clipBox.y);
-            clipBox.height = verticalAxes[0].pos - this.plotTop + verticalAxes[0].len;
+            clipBox.height = (verticalAxes[0].pos -
+                this.plotTop +
+                verticalAxes[0].len);
         }
         else {
             clipBox.height = this.plotHeight;
@@ -220,7 +218,8 @@ wrap(Series.prototype, 'getExtremes', function (proceed) {
 // If the series is a heatmap or treemap, or if the series is not boosting
 // do the default behaviour. Otherwise, process if the series has no extremes.
 wrap(Series.prototype, 'processData', function (proceed) {
-    var series = this, dataToMeasure = this.options.data, firstPoint;
+    var series = this;
+    var dataToMeasure = this.options.data;
     /**
      * Used twice in this function, first on this.options.data, the second
      * time it runs the check again after processedXData is built.
@@ -254,6 +253,7 @@ wrap(Series.prototype, 'processData', function (proceed) {
         // Enter or exit boost mode
         if (this.isSeriesBoosting) {
             // Force turbo-mode:
+            var firstPoint = void 0;
             if (this.options.data && this.options.data.length) {
                 firstPoint = this.getFirstValidPoint(this.options.data);
                 if (!isNumber(firstPoint) && !isArray(firstPoint)) {
@@ -330,10 +330,6 @@ Series.prototype.exitBoost = function () {
 /**
  * @private
  * @function Highcharts.Series#hasExtremes
- *
- * @param {boolean} checkX
- *
- * @return {boolean}
  */
 Series.prototype.hasExtremes = function (checkX) {
     var options = this.options, data = options.data, xAxis = this.xAxis && this.xAxis.options, yAxis = this.yAxis && this.yAxis.options, colorAxis = this.colorAxis && this.colorAxis.options;

package/es-modules/Extensions/Boost/BoostUtils.js

@@ -194,8 +194,6 @@ function eachAsync(arr, fn, finalFunc, chunkSize, i, noTimeout) {
  *
  * @private
  * @function hasWebGLSupport
- *
- * @return {boolean}
  */
 function hasWebGLSupport() {
     var i = 0, canvas, contexts = ['webgl', 'experimental-webgl', 'moz-webgl', 'webkit-3d'], context = false;
@@ -221,10 +219,6 @@ function hasWebGLSupport() {
  *
  * @private
  * @function pointDrawHandler
- *
- * @param {Function} proceed
- *
- * @return {*}
  */
 function pointDrawHandler(proceed) {
     var enabled = true, renderer;

package/es-modules/Extensions/Boost/WGLRenderer.js

@@ -29,10 +29,6 @@ var isNumber = U.isNumber, isObject = U.isObject, merge = U.merge, objectEach =
  *
  * @private
  * @function GLRenderer
- *
- * @param {Function} postRenderCallback
- *
- * @return {*}
  */
 function GLRenderer(postRenderCallback) {
     //  // Shader
@@ -149,8 +145,10 @@ function GLRenderer(postRenderCallback) {
     /**
      * Returns an orthographic perspective matrix
      * @private
-     * @param {number} width - the width of the viewport in pixels
-     * @param {number} height - the height of the viewport in pixels
+     * @param {number} width
+     * the width of the viewport in pixels
+     * @param {number} height
+     * the height of the viewport in pixels
      */
     function orthoMatrix(width, height) {
         var near = 0, far = 1;
@@ -171,7 +169,8 @@ function GLRenderer(postRenderCallback) {
     /**
      * Get the WebGL context
      * @private
-     * @returns {WebGLContext} - the context
+     * @return {WebGLContext}
+     * the context
      */
     function getGL() {
         return gl;
@@ -530,8 +529,10 @@ function GLRenderer(postRenderCallback) {
                 zone, i) {
                     var last = zones[i - 1];
                     if (zoneAxis === 'x') {
-                        if (typeof zone.value !== 'undefined' && x <= zone.value) {
-                            if (zoneColors[i] && (!last || x >= last.value)) {
+                        if (typeof zone.value !== 'undefined' &&
+                            x <= zone.value) {
+                            if (zoneColors[i] &&
+                                (!last || x >= last.value)) {
                                 zoneColor_1 = zoneColors[i];
                             }
                             return true;
@@ -539,7 +540,8 @@ function GLRenderer(postRenderCallback) {
                         return false;
                     }
                     if (typeof zone.value !== 'undefined' && y <= zone.value) {
-                        if (zoneColors[i] && (!last || y >= last.value)) {
+                        if (zoneColors[i] &&
+                            (!last || y >= last.value)) {
                             zoneColor_1 = zoneColors[i];
                         }
                         return true;
@@ -1128,7 +1130,8 @@ function GLRenderer(postRenderCallback) {
     /**
      * Check if we have a valid OGL context
      * @private
-     * @returns {Boolean} - true if the context is valid
+     * @return {boolean}
+     * true if the context is valid
      */
     function valid() {
         return gl !== false;
@@ -1136,7 +1139,8 @@ function GLRenderer(postRenderCallback) {
     /**
      * Check if the renderer has been initialized
      * @private
-     * @returns {Boolean} - true if it has, false if not
+     * @return {boolean}
+     * true if it has, false if not
      */
     function inited() {
         return isInited;

package/es-modules/Extensions/Boost/WGLShader.js

@@ -20,9 +20,7 @@ var clamp = U.clamp, error = U.error, pick = U.pick;
  * @function GLShader
  *
  * @param {WebGLContext} gl
- *        the context in which the shader is active
- *
- * @return {*}
+ * the context in which the shader is active
  */
 function GLShader(gl) {
     var vertShade = [
@@ -231,9 +229,10 @@ function GLShader(gl) {
     /**
      * String to shader program
      * @private
-     * @param {string} str - the program source
-     * @param {string} type - the program type: either `vertex` or `fragment`
-     * @returns {bool|shader}
+     * @param {string} str
+     * the program source
+     * @param {string} type
+     * the program type: either `vertex` or `fragment`
      */
     function stringToProgram(str, type) {
         var t = type === 'vertex' ? gl.VERTEX_SHADER : gl.FRAGMENT_SHADER, shader = gl.createShader(t);
@@ -328,7 +327,8 @@ function GLShader(gl) {
     /**
      * Set the active texture
      * @private
-     * @param texture - the texture
+     * @param texture
+     * the texture
      */
     function setTexture(texture) {
         if (gl && shaderProgram) {
@@ -338,7 +338,8 @@ function GLShader(gl) {
     /**
      * Set if inversion state
      * @private
-     * @flag is the state
+     * @param {number} flag
+     * is the state
      */
     function setInverted(flag) {
         if (gl && shaderProgram) {
@@ -371,7 +372,8 @@ function GLShader(gl) {
      */
     function setBubbleUniforms(series, zCalcMin, zCalcMax) {
         var seriesOptions = series.options, zMin = Number.MAX_VALUE, zMax = -Number.MAX_VALUE;
-        if (gl && shaderProgram && series.type === 'bubble') {
+        if (gl && shaderProgram && series.is('bubble')) {
+            var pxSizes = series.getPxExtremes();
             zMin = pick(seriesOptions.zMin, clamp(zCalcMin, seriesOptions.displayNegative === false ?
                 seriesOptions.zThreshold : -Number.MAX_VALUE, zMin));
             zMax = pick(seriesOptions.zMax, Math.max(zMax, zCalcMax));
@@ -383,8 +385,8 @@ function GLShader(gl) {
             setUniform('bubbleZMin', zMin);
             setUniform('bubbleZMax', zMax);
             setUniform('bubbleZThreshold', series.options.zThreshold);
-            setUniform('bubbleMinSize', series.minPxSize);
-            setUniform('bubbleMaxSize', series.maxPxSize);
+            setUniform('bubbleMinSize', pxSizes.minPxSize);
+            setUniform('bubbleMaxSize', pxSizes.maxPxSize);
         }
     }
     /**

package/es-modules/Extensions/Boost/WGLVBuffer.js

@@ -18,14 +18,10 @@
  *
  * @private
  * @function GLVertexBuffer
- *
  * @param {WebGLContext} gl
- *        the context in which to create the buffer
- *
+ * the context in which to create the buffer
  * @param {GLShader} shader
- *        the shader to use
- *
- * @return {*}
+ * the shader to use
  */
 function GLVertexBuffer(gl, shader, dataComponents
 /* , type */
@@ -101,7 +97,8 @@ function GLVertexBuffer(gl, shader, dataComponents
      * @param drawMode {String} - the draw mode
      */
     function render(from, to, drawMode) {
-        var length = preAllocated ? preAllocated.length : data.length;
+        var length = preAllocated ?
+            preAllocated.length : data.length;
         if (!buffer) {
             return false;
         }

package/es-modules/Extensions/BoostCanvas.js

@@ -18,7 +18,6 @@ import Color from '../Core/Color/Color.js';
 var color = Color.parse;
 import H from '../Core/Globals.js';
 var doc = H.doc, noop = H.noop;
-import palette from '../Core/Color/Palette.js';
 import Series from '../Core/Series/Series.js';
 import SeriesRegistry from '../Core/Series/SeriesRegistry.js';
 var seriesTypes = SeriesRegistry.seriesTypes;
@@ -295,7 +294,7 @@ var initCanvasBoost = function () {
             if (rawData.length > 99999) {
                 chart.options.loading = merge(loadingOptions, {
                     labelStyle: {
-                        backgroundColor: color(palette.backgroundColor).setOpacity(0.75).get(),
+                        backgroundColor: color("#ffffff" /* backgroundColor */).setOpacity(0.75).get(),
                         padding: '1em',
                         borderRadius: '0.5em'
                     },

package/es-modules/Extensions/CurrentDateIndication.js

@@ -11,7 +11,6 @@
  * */
 'use strict';
 import Axis from '../Core/Axis/Axis.js';
-import Palette from '../Core/Color/Palette.js';
 import PlotLineOrBand from '../Core/Axis/PlotLineOrBand/PlotLineOrBand.js';
 import U from '../Core/Utilities.js';
 var addEvent = U.addEvent, merge = U.merge, wrap = U.wrap;
@@ -34,7 +33,7 @@ var addEvent = U.addEvent, merge = U.merge, wrap = U.wrap;
  * @apioption xAxis.currentDateIndicator
  */
 var defaultOptions = {
-    color: Palette.highlightColor20,
+    color: "#ccd6eb" /* highlightColor20 */,
     width: 2,
     /**
      * @declare Highcharts.AxisCurrentDateIndicatorLabelOptions
@@ -42,7 +41,7 @@ var defaultOptions = {
     label: {
         /**
          * Format of the label. This options is passed as the fist argument to
-         * [dateFormat](/class-reference/Highcharts#.dateFormat) function.
+         * [dateFormat](/class-reference/Highcharts.Time#dateFormat) function.
          *
          * @type      {string}
          * @default   %a, %b %d %Y, %H:%M