highcharts 9.1.1 → 9.2.2

package/es-modules/Series/HollowCandlestick/HollowCandlestickPoint.js

@@ -0,0 +1,83 @@
+/* *
+ *
+ *  (c) 2010-2021 Torstein Honsi
+ *
+ *  License: www.highcharts.com/license
+ *
+ *  !!!!!!! 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 __());
+    };
+})();
+/* *
+ *
+ *  Imports
+ *
+ * */
+import SeriesRegistry from '../../Core/Series/SeriesRegistry.js';
+var CandlestickSeries = SeriesRegistry.seriesTypes.candlestick;
+/* *
+ *
+ *  Class
+ *
+ * */
+var HollowCandlestickPoint = /** @class */ (function (_super) {
+    __extends(HollowCandlestickPoint, _super);
+    function HollowCandlestickPoint() {
+        /* *
+         *
+         *  Properties
+         *
+         * */
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.series = void 0;
+        return _this;
+        /* eslint-enable valid-jsdoc */
+    }
+    /* *
+     *
+     *  Functions
+     *
+     * */
+    /* eslint-disable valid-jsdoc */
+    /**
+     * Update class name if needed.
+     *
+     * @function Highcharts.seriesTypes.hollowcandlestick#getClassName
+     *
+     * @return {string}
+     *
+     */
+    HollowCandlestickPoint.prototype.getClassName = function () {
+        var className = _super.prototype.getClassName.apply(this);
+        var point = this, index = point.index, currentPoint = point.series.hollowCandlestickData[index];
+        if (!currentPoint.isBullish && currentPoint.trendDirection === 'up') {
+            className += '-bearish-up';
+        }
+        return className;
+    };
+    return HollowCandlestickPoint;
+}(CandlestickSeries.prototype.pointClass));
+/* *
+ *
+ *  Class Namespace
+ *
+ * */
+/* *
+ *
+ *  Default Export
+ *
+ * */
+export default HollowCandlestickPoint;

package/es-modules/Series/HollowCandlestick/HollowCandlestickSeries.js

@@ -0,0 +1,370 @@
+/* *
+ *
+ *  (c) 2010-2021 Torstein Honsi
+ *
+ *  License: www.highcharts.com/license
+ *
+ *  !!!!!!! 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 __());
+    };
+})();
+/* *
+ *
+ *  Imports
+ *
+ * */
+import HollowCandlestickPoint from './HollowCandlestickPoint.js';
+import SeriesRegistry from '../../Core/Series/SeriesRegistry.js';
+import U from '../../Core/Utilities.js';
+import palette from '../../Core/Color/Palette.js';
+import Axis from '../../Core/Axis/Axis.js';
+var CandlestickSeries = SeriesRegistry.seriesTypes.candlestick;
+var addEvent = U.addEvent, merge = U.merge;
+/* *
+ *
+ *  Code
+ *
+ * */
+/**
+ * The hollowcandlestick series.
+ *
+ * @private
+ * @class
+ * @name Highcharts.seriesTypes.hollowcandlestick
+ *
+ * @augments Highcharts.seriesTypes.candlestick
+ */
+var HollowCandlestickSeries = /** @class */ (function (_super) {
+    __extends(HollowCandlestickSeries, _super);
+    function HollowCandlestickSeries() {
+        /* *
+         *
+         * Static properties
+         *
+         * */
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        /* *
+         *
+         * Properties
+         *
+         * */
+        _this.data = void 0;
+        _this.hollowCandlestickData = [];
+        _this.options = void 0;
+        _this.points = void 0;
+        return _this;
+        /* eslint-disable valid-jsdoc */
+    }
+    /* *
+     *
+     * Functions
+     *
+     * */
+    /**
+     * Iterate through all points and get their type.
+     * @private
+     *
+     * @function Highcharts.seriesTypes.hollowcandlestick#getPriceMovement
+     *
+     * @return {void}
+     *
+     */
+    HollowCandlestickSeries.prototype.getPriceMovement = function () {
+        var series = this, processedYData = series.allGroupedData || series.yData, // procesed and grouped data
+        hollowCandlestickData = this.hollowCandlestickData;
+        if (!hollowCandlestickData.length && processedYData && processedYData.length) {
+            // First point is allways bullish (transparent).
+            hollowCandlestickData.push({
+                isBullish: true,
+                trendDirection: 'up'
+            });
+            for (var i = 1; i < processedYData.length; i++) {
+                var dataPoint = processedYData[i], previousDataPoint = processedYData[i - 1];
+                hollowCandlestickData.push(series.isBullish(dataPoint, previousDataPoint));
+            }
+        }
+    };
+    /**
+     * Return line color based on candle type.
+     * @private
+     *
+     * @function Highcharts.seriesTypes.hollowcandlestick#getLineColor
+     *
+     * @param {string} trendDirection
+     *        Type of candle direction (bearish/bullish)(down/up).
+     *
+     * @return {ColorType}
+     *
+     */
+    HollowCandlestickSeries.prototype.getLineColor = function (trendDirection) {
+        var series = this;
+        // Return line color based on trend direction
+        return trendDirection === 'up' ?
+            series.options.upColor || palette.positiveColor :
+            series.options.color || palette.negativeColor;
+    };
+    /**
+     * Return fill color based on candle type.
+     * @private
+     *
+     * @function Highcharts.seriesTypes.hollowcandlestick#getPointFill
+     *
+     * @param {HollowcandleInfo} hollowcandleInfo
+     *        Information about the current candle.
+     *
+     * @return {ColorType}
+     *
+     */
+    HollowCandlestickSeries.prototype.getPointFill = function (hollowcandleInfo) {
+        var series = this;
+        // Return fill color only for bearish candles.
+        if (hollowcandleInfo.isBullish) {
+            return 'transparent';
+        }
+        return hollowcandleInfo.trendDirection === 'up' ?
+            series.options.upColor || palette.positiveColor :
+            series.options.color || palette.negativeColor;
+    };
+    /**
+     * @private
+     * @function Highcarts.seriesTypes.hollowcandlestick#init
+     * @return {void}
+     */
+    HollowCandlestickSeries.prototype.init = function () {
+        _super.prototype.init.apply(this, arguments);
+        this.hollowCandlestickData = [];
+    };
+    /**
+     * Check if the candle is bearish or bullish. For bullish one, return true.
+     * For bearish, return string depending on the previous point.
+     *
+     * @function Highcharts.seriesTypes.hollowcandlestick#isBullish
+     *
+     * @param {Array<(number)>} dataPoint
+     *        Current point which we calculate.
+
+      * @param {Array<(number)>} previousDataPoint
+     *        Previous point.
+     *
+     * @return {HollowcandleInfo}
+     *
+     */
+    HollowCandlestickSeries.prototype.isBullish = function (dataPoint, previousDataPoint) {
+        return {
+            // Compare points' open and close value.
+            isBullish: dataPoint[0] <= dataPoint[3],
+            // For bearish candles.
+            trendDirection: dataPoint[3] < previousDataPoint[3] ? 'down' : 'up'
+        };
+    };
+    /**
+     * Add color and fill attribute for each point.
+     *
+     * @function Highcharts.seriesTypes.hollowcandlestick#pointAttribs
+     *
+     * @param {HollowCandlestickPoint} point
+     *        Point to which we are adding attributes.
+     * @param {StatesOptionsKey} state
+     *        Current point state.
+     *
+     * @return {SVGAttributes}
+     *
+     */
+    HollowCandlestickSeries.prototype.pointAttribs = function (point, state) {
+        var attribs = _super.prototype.pointAttribs.call(this, point, state), stateOptions;
+        var index = point.index, hollowcandleInfo = this.hollowCandlestickData[index];
+        attribs.fill = this.getPointFill(hollowcandleInfo) || attribs.fill;
+        attribs.stroke = this.getLineColor(hollowcandleInfo.trendDirection) || attribs.stroke;
+        // Select or hover states
+        if (state) {
+            stateOptions = this.options.states[state];
+            attribs.fill = stateOptions.color || attribs.fill;
+            attribs.stroke = stateOptions.lineColor || attribs.stroke;
+            attribs['stroke-width'] =
+                stateOptions.lineWidth || attribs['stroke-width'];
+        }
+        return attribs;
+    };
+    /**
+     * A hollow candlestick chart is a style of financial chart used to
+     * describe price movements over time.
+     *
+     * @sample stock/demo/hollow-candlestick/
+     *         Hollow Candlestick chart
+     *
+     * @extends      plotOptions.candlestick
+     * @product      highstock
+     * @requires     modules/hollowcandlestick
+     * @optionparent plotOptions.hollowcandlestick
+     */
+    HollowCandlestickSeries.defaultOptions = merge(CandlestickSeries.defaultOptions, {
+        /**
+         * The fill color of the candlestick when the current
+         * close is lower than the previous one.
+         *
+         * @sample stock/plotoptions/hollow-candlestick-color/
+         *     Custom colors
+         * @sample {highstock} highcharts/css/hollow-candlestick/
+         *         Colors in styled mode
+         *
+         * @type    {ColorType}
+         * @product highstock
+         */
+        color: palette.negativeColor,
+        dataGrouping: {
+            groupAll: true,
+            groupPixelWidth: 10
+        },
+        /**
+         * The color of the line/border of the hollow candlestick when
+         * the current close is lower than the previous one.
+         *
+         * @sample stock/plotoptions/hollow-candlestick-color/
+         *     Custom colors
+         * @sample {highstock} highcharts/css/hollow-candlestick/
+         *         Colors in styled mode
+         *
+         * @type    {ColorType}
+         * @product highstock
+         */
+        lineColor: palette.negativeColor,
+        /**
+         * The fill color of the candlestick when the current
+         * close is higher than the previous one.
+         *
+         * @sample stock/plotoptions/hollow-candlestick-color/
+         *     Custom colors
+         * @sample {highstock} highcharts/css/hollow-candlestick/
+         *         Colors in styled mode
+         *
+         * @type    {ColorType}
+         * @product highstock
+         */
+        upColor: palette.positiveColor,
+        /**
+         * The color of the line/border of the hollow candlestick when
+         * the current close is higher than the previous one.
+         *
+         * @sample stock/plotoptions/hollow-candlestick-color/
+         *     Custom colors
+         * @sample {highstock} highcharts/css/hollow-candlestick/
+         *         Colors in styled mode
+         *
+         * @type    {ColorType}
+         * @product highstock
+         */
+        upLineColor: palette.positiveColor
+    });
+    return HollowCandlestickSeries;
+}(CandlestickSeries));
+// Force to recalculate the hollowcandlestick data set after updating data.
+addEvent(HollowCandlestickSeries, 'updatedData', function () {
+    if (this.hollowCandlestickData.length) {
+        this.hollowCandlestickData.length = 0;
+    }
+});
+// After processing and grouping the data,
+// check if the candle is bearish or bullish.
+// Required for further calculation.
+addEvent(Axis, 'postProcessData', function () {
+    var axis = this, series = axis.series;
+    series.forEach(function (series) {
+        if (series.is('hollowcandlestick')) {
+            var hollowcandlestickSeries = series;
+            hollowcandlestickSeries.getPriceMovement();
+        }
+    });
+});
+/* *
+ *
+ *  Prototype Properties
+ *
+ * */
+HollowCandlestickSeries.prototype.pointClass = HollowCandlestickPoint;
+SeriesRegistry.registerSeriesType('hollowcandlestick', HollowCandlestickSeries);
+/* *
+ *
+ * Default Export
+ *
+ * */
+export default HollowCandlestickSeries;
+/* *
+ *
+ * API Options
+ *
+ * */
+/**
+ * A `hollowcandlestick` series. If the [type](#series.candlestick.type)
+ * option is not specified, it is inherited from [chart.type](
+ * #chart.type).
+ *
+ * @type      {*}
+ * @extends   series,plotOptions.hollowcandlestick
+ * @excluding dataParser, dataURL, marker
+ * @product   highstock
+ * @apioption series.hollowcandlestick
+ */
+/**
+ * An array of data points for the series. For the `hollowcandlestick` series
+ * type, points can be given in the following ways:
+ *
+ * 1. An array of arrays with 5 or 4 values. In this case, the values correspond
+ *    to `x,open,high,low,close`. If the first value is a string, it is applied
+ *    as the name of the point, and the `x` value is inferred. The `x` value can
+ *    also be omitted, in which case the inner arrays should be of length 4.
+ *    Then the `x` value is automatically calculated, either starting at 0 and
+ *    incremented by 1, or from `pointStart` and `pointInterval` given in the
+ *    series options.
+ *    ```js
+ *    data: [
+ *        [0, 7, 2, 0, 4],
+ *        [1, 1, 4, 2, 8],
+ *        [2, 3, 3, 9, 3]
+ *    ]
+ *    ```
+ *
+ * 2. An array of objects with named values. The following snippet shows only a
+ *    few settings, see the complete options set below. If the total number of
+ *    data points exceeds the series'
+ *    [turboThreshold](#series.hollowcandlestick.turboThreshold), this option is not
+ *    available.
+ *    ```js
+ *    data: [{
+ *        x: 1,
+ *        open: 9,
+ *        high: 2,
+ *        low: 4,
+ *        close: 6,
+ *        name: "Point2",
+ *        color: "#00FF00"
+ *    }, {
+ *        x: 1,
+ *        open: 1,
+ *        high: 4,
+ *        low: 7,
+ *        close: 7,
+ *        name: "Point1",
+ *        color: "#FF00FF"
+ *    }]
+ *    ```
+ *
+ * @type      {Array<Array<(number|string),number,number,number>|Array<(number|string),number,number,number,number>|*>}
+ * @extends   series.candlestick.data
+ * @excluding y
+ * @product   highstock
+ * @apioption series.hollowcandlestick.data
+ */
+''; // adds doclets above to transpilat

package/es-modules/Series/Line/LineSeries.js

@@ -21,7 +21,7 @@ var __extends = (this && this.__extends) || (function () {
         d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
     };
 })();
-import palette from '../../Core/Color/Palette.js';
+import Palette from '../../Core/Color/Palette.js';
 import Series from '../../Core/Series/Series.js';
 import SeriesRegistry from '../../Core/Series/SeriesRegistry.js';
 import U from '../../Core/Utilities.js';
@@ -70,7 +70,8 @@ var LineSeries = /** @class */ (function (_super) {
      * @function Highcharts.Series#drawGraph
      */
     LineSeries.prototype.drawGraph = function () {
-        var series = this, options = this.options, graphPath = (this.gappedPath || this.getGraphPath).call(this), styledMode = this.chart.styledMode, props = [[
+        var series = this, options = this.options, graphPath = (this.gappedPath || this.getGraphPath).call(this), styledMode = this.chart.styledMode;
+        var props = [[
                 'graph',
                 'highcharts-graph'
             ]];
@@ -78,13 +79,15 @@ var LineSeries = /** @class */ (function (_super) {
         if (!styledMode) {
             props[0].push((options.lineColor ||
                 this.color ||
-                palette.neutralColor20 // when colorByPoint = true
+                Palette.neutralColor20 // when colorByPoint = true
             ), options.dashStyle);
         }
         props = series.getZonesGraphs(props);
         // Draw the graph
         props.forEach(function (prop, i) {
-            var graphKey = prop[0], graph = series[graphKey], verb = graph ? 'animate' : 'attr', attribs;
+            var graphKey = prop[0];
+            var attribs, graph = series[graphKey];
+            var verb = graph ? 'animate' : 'attr';
             if (graph) {
                 graph.endX = series.preventGraphAnimation ?
                     null :
@@ -151,10 +154,11 @@ var LineSeries = /** @class */ (function (_super) {
      * @private
      */
     LineSeries.prototype.getGraphPath = function (points, nullsAsZeroes, connectCliffs) {
-        var series = this, options = series.options, step = options.step, reversed, graphPath = [], xMap = [], gap;
+        var series = this, options = series.options, graphPath = [], xMap = [];
+        var gap, step = options.step;
         points = points || series.points;
         // Bottom of a stack is reversed
-        reversed = points.reversed;
+        var reversed = points.reversed;
         if (reversed) {
             points.reverse();
         }
@@ -170,9 +174,9 @@ var LineSeries = /** @class */ (function (_super) {
         points = this.getValidPoints(points, false, !(options.connectNulls && !nullsAsZeroes && !connectCliffs));
         // Build the line
         points.forEach(function (point, i) {
-            var plotX = point.plotX, plotY = point.plotY, lastPoint = points[i - 1], 
+            var plotX = point.plotX, plotY = point.plotY, lastPoint = points[i - 1];
             // the path to this point from the previous
-            pathToPoint;
+            var pathToPoint;
             if ((point.leftCliff || (lastPoint && lastPoint.rightCliff)) &&
                 !connectCliffs) {
                 gap = true; // ... and continue

package/es-modules/Series/Map/MapSeries.js

@@ -25,7 +25,7 @@ import ColorMapMixin from '../../Mixins/ColorMapSeries.js';
 var colorMapSeriesMixin = ColorMapMixin.colorMapSeriesMixin;
 import H from '../../Core/Globals.js';
 var noop = H.noop;
-import LegendSymbolMixin from '../../Mixins/LegendSymbol.js';
+import LegendSymbol from '../../Core/Legend/LegendSymbol.js';
 import MapChart from '../../Core/Chart/MapChart.js';
 var maps = MapChart.maps, splitPath = MapChart.splitPath;
 import MapPoint from './MapPoint.js';
@@ -696,7 +696,9 @@ var MapSeries = /** @class */ (function (_super) {
         dataLabels: {
             crop: false,
             formatter: function () {
-                return this.point.value;
+                var numberFormatter = this.series.chart.numberFormatter;
+                var value = this.point.value;
+                return isNumber(value) ? numberFormatter(value, -1) : '';
             },
             inside: true,
             overflow: false,
@@ -933,7 +935,7 @@ extend(MapSeries.prototype, {
     drawDataLabels: noop,
     // No graph for the map series
     drawGraph: noop,
-    drawLegendSymbol: LegendSymbolMixin.drawRectangle,
+    drawLegendSymbol: LegendSymbol.drawRectangle,
     forceDL: true,
     getExtremesFromAll: true,
     getSymbol: colorMapSeriesMixin.getSymbol,

package/es-modules/Series/MapBubble/MapBubbleSeries.js

@@ -45,11 +45,6 @@ import '../Map/MapSeries.js';
 var MapBubbleSeries = /** @class */ (function (_super) {
     __extends(MapBubbleSeries, _super);
     function MapBubbleSeries() {
-        /* *
-         *
-         *  Static Properties
-         *
-         * */
         var _this = _super !== null && _super.apply(this, arguments) || this;
         /* *
          *
@@ -61,6 +56,12 @@ var MapBubbleSeries = /** @class */ (function (_super) {
         _this.points = void 0;
         return _this;
     }
+    /* *
+     *
+     *  Static Properties
+     *
+     * */
+    MapBubbleSeries.compose = BubbleSeries.compose;
     /**
      * A map bubble series is a bubble series laid out on top of a map
      * series, where each bubble is tied to a specific map area.

package/es-modules/Series/OHLC/OHLCPoint.js

@@ -100,6 +100,17 @@ var OHLCPoint = /** @class */ (function (_super) {
         this.resolveUpColor();
         return zone;
     };
+    /**
+     * Extend the parent method by resolving up/down colors (#15849)
+     * @private
+     **/
+    OHLCPoint.prototype.applyOptions = function () {
+        _super.prototype.applyOptions.apply(this, arguments);
+        if (this.resolveColor) {
+            this.resolveColor();
+        }
+        return this;
+    };
     return OHLCPoint;
 }(ColumnSeries.prototype.pointClass));
 /* *

package/es-modules/Series/PackedBubble/PackedBubbleSeries.js

@@ -901,7 +901,9 @@ var PackedBubbleSeries = /** @class */ (function (_super) {
              * @since 7.0.0
              */
             formatter: function () {
-                return this.point.value;
+                var numberFormatter = this.series.chart.numberFormatter;
+                var value = this.point.value;
+                return isNumber(value) ? numberFormatter(value, -1) : '';
             },
             /**
              * @type      {string}