highcharts 10.2.1 → 10.3.1

package/es-modules/Extensions/DataGrouping/DataGroupingSeriesComposition.js

@@ -0,0 +1,479 @@
+/* *
+ *
+ *  (c) 2010-2021 Torstein Honsi
+ *
+ *  License: www.highcharts.com/license
+ *
+ *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+ *
+ * */
+'use strict';
+import ApproximationRegistry from './ApproximationRegistry.js';
+import DataGroupingDefaults from './DataGroupingDefaults.js';
+import DateTimeAxis from '../../Core/Axis/DateTimeAxis.js';
+import D from '../../Core/Defaults.js';
+import SeriesRegistry from '../../Core/Series/SeriesRegistry.js';
+var seriesProto = SeriesRegistry.series.prototype;
+import U from '../../Core/Utilities.js';
+var addEvent = U.addEvent, defined = U.defined, error = U.error, extend = U.extend, isNumber = U.isNumber, merge = U.merge, pick = U.pick;
+/* *
+ *
+ *  Constants
+ *
+ * */
+var baseGeneratePoints = seriesProto.generatePoints;
+var composedMembers = [];
+/* *
+ *
+ *  Functions
+ *
+ * */
+/**
+ * @private
+ */
+function adjustExtremes(xAxis, groupedXData) {
+    // Make sure the X axis extends to show the first group (#2533)
+    // But only for visible series (#5493, #6393)
+    if (defined(groupedXData[0]) &&
+        isNumber(xAxis.min) &&
+        isNumber(xAxis.dataMin) &&
+        groupedXData[0] < xAxis.min) {
+        if ((!defined(xAxis.options.min) &&
+            xAxis.min <= xAxis.dataMin) ||
+            xAxis.min === xAxis.dataMin) {
+            xAxis.min = Math.min(groupedXData[0], xAxis.min);
+        }
+        xAxis.dataMin = Math.min(groupedXData[0], xAxis.dataMin);
+    }
+    // When the last anchor set, change the extremes that
+    // the last point is visible (#12455).
+    if (defined(groupedXData[groupedXData.length - 1]) &&
+        isNumber(xAxis.max) &&
+        isNumber(xAxis.dataMax) &&
+        groupedXData[groupedXData.length - 1] > xAxis.max) {
+        if ((!defined(xAxis.options.max) &&
+            isNumber(xAxis.dataMax) &&
+            xAxis.max >= xAxis.dataMax) || xAxis.max === xAxis.dataMax) {
+            xAxis.max = Math.max(groupedXData[groupedXData.length - 1], xAxis.max);
+        }
+        xAxis.dataMax = Math.max(groupedXData[groupedXData.length - 1], xAxis.dataMax);
+    }
+}
+/**
+ * @private
+ */
+function anchorPoints(series, groupedXData, xMax) {
+    var options = series.options, dataGroupingOptions = options.dataGrouping, totalRange = (series.currentDataGrouping && series.currentDataGrouping.gapSize);
+    var i;
+    // DataGrouping x-coordinates.
+    if (dataGroupingOptions && series.xData && totalRange && series.groupMap) {
+        var groupedDataLength = groupedXData.length - 1, anchor = dataGroupingOptions.anchor, firstAnchor = pick(dataGroupingOptions.firstAnchor, anchor), lastAnchor = pick(dataGroupingOptions.lastAnchor, anchor);
+        // Anchor points that are not extremes.
+        if (anchor && anchor !== 'start') {
+            var shiftInterval = (totalRange *
+                { middle: 0.5, end: 1 }[anchor]);
+            i = groupedXData.length - 1;
+            while (i-- && i > 0) {
+                groupedXData[i] += shiftInterval;
+            }
+        }
+        // Change the first point position, but only when it is
+        // the first point in the data set not in the current zoom.
+        if (firstAnchor &&
+            firstAnchor !== 'start' &&
+            series.xData[0] >= groupedXData[0]) {
+            var groupStart = series.groupMap[0].start, groupLength = series.groupMap[0].length;
+            var firstGroupstEnd = void 0;
+            if (isNumber(groupStart) && isNumber(groupLength)) {
+                firstGroupstEnd = groupStart + (groupLength - 1);
+            }
+            groupedXData[0] = {
+                middle: groupedXData[0] + 0.5 * totalRange,
+                end: groupedXData[0] + totalRange,
+                firstPoint: series.xData[0],
+                lastPoint: firstGroupstEnd && series.xData[firstGroupstEnd]
+            }[firstAnchor];
+        }
+        // Change the last point position but only when it is
+        // the last point in the data set not in the current zoom.
+        if (lastAnchor &&
+            lastAnchor !== 'start' &&
+            totalRange &&
+            groupedXData[groupedDataLength] >= xMax - totalRange) {
+            var lastGroupStart = series.groupMap[series.groupMap.length - 1].start;
+            groupedXData[groupedDataLength] = {
+                middle: groupedXData[groupedDataLength] + 0.5 * totalRange,
+                end: groupedXData[groupedDataLength] + totalRange,
+                firstPoint: lastGroupStart && series.xData[lastGroupStart],
+                lastPoint: series.xData[series.xData.length - 1]
+            }[lastAnchor];
+        }
+    }
+}
+/**
+ * For the processed data, calculate the grouped data if needed.
+ *
+ * @private
+ * @function Highcharts.Series#applyGrouping
+ */
+function applyGrouping(hasExtremesChanged) {
+    var series = this, chart = series.chart, options = series.options, dataGroupingOptions = options.dataGrouping, groupingEnabled = series.allowDG !== false && dataGroupingOptions &&
+        pick(dataGroupingOptions.enabled, chart.options.isStock), visible = (series.visible || !chart.options.chart.ignoreHiddenSeries), lastDataGrouping = this.currentDataGrouping;
+    var currentDataGrouping, croppedData, revertRequireSorting = false;
+    // Data needs to be sorted for dataGrouping
+    if (groupingEnabled && !series.requireSorting) {
+        series.requireSorting = revertRequireSorting = true;
+    }
+    // Skip if skipDataGrouping method returns false or if grouping is disabled
+    // (in that order).
+    var skip = skipDataGrouping(series, hasExtremesChanged) === false || !groupingEnabled;
+    // Revert original requireSorting value if changed
+    if (revertRequireSorting) {
+        series.requireSorting = false;
+    }
+    if (!skip) {
+        series.destroyGroupedData();
+        var processedXData = dataGroupingOptions.groupAll ?
+            series.xData :
+            series.processedXData, processedYData = dataGroupingOptions.groupAll ?
+            series.yData :
+            series.processedYData, plotSizeX = chart.plotSizeX, xAxis = series.xAxis, ordinal = xAxis.options.ordinal, groupPixelWidth = series.groupPixelWidth;
+        var i = void 0, hasGroupedData = void 0;
+        // Execute grouping if the amount of points is greater than the limit
+        // defined in groupPixelWidth
+        if (groupPixelWidth &&
+            processedXData &&
+            processedXData.length) {
+            hasGroupedData = true;
+            // Force recreation of point instances in series.translate, #5699
+            series.isDirty = true;
+            series.points = null; // #6709
+            var extremes = xAxis.getExtremes(), xMin = extremes.min, xMax = extremes.max, groupIntervalFactor = (ordinal &&
+                xAxis.ordinal &&
+                xAxis.ordinal.getGroupIntervalFactor(xMin, xMax, series)) || 1, interval = (groupPixelWidth * (xMax - xMin) / plotSizeX) *
+                groupIntervalFactor, groupPositions = xAxis.getTimeTicks(DateTimeAxis.Additions.prototype.normalizeTimeTickInterval(interval, dataGroupingOptions.units ||
+                DataGroupingDefaults.units), 
+            // Processed data may extend beyond axis (#4907)
+            Math.min(xMin, processedXData[0]), Math.max(xMax, processedXData[processedXData.length - 1]), xAxis.options.startOfWeek, processedXData, series.closestPointRange), groupedData = seriesProto.groupData.apply(series, [
+                processedXData,
+                processedYData,
+                groupPositions,
+                dataGroupingOptions.approximation
+            ]);
+            var groupedXData = groupedData.groupedXData, groupedYData = groupedData.groupedYData, gapSize = 0;
+            // The smoothed option is deprecated, instead, there is a fallback
+            // to the new anchoring mechanism. #12455.
+            if (dataGroupingOptions &&
+                dataGroupingOptions.smoothed &&
+                groupedXData.length) {
+                dataGroupingOptions.firstAnchor = 'firstPoint';
+                dataGroupingOptions.anchor = 'middle';
+                dataGroupingOptions.lastAnchor = 'lastPoint';
+                error(32, false, chart, {
+                    'dataGrouping.smoothed': 'use dataGrouping.anchor'
+                });
+            }
+            anchorPoints(series, groupedXData, xMax);
+            // Record what data grouping values were used
+            for (i = 1; i < groupPositions.length; i++) {
+                // The grouped gapSize needs to be the largest distance between
+                // the group to capture varying group sizes like months or DST
+                // crossing (#10000). Also check that the gap is not at the
+                // start of a segment.
+                if (!groupPositions.info.segmentStarts ||
+                    groupPositions.info.segmentStarts.indexOf(i) === -1) {
+                    gapSize = Math.max(groupPositions[i] - groupPositions[i - 1], gapSize);
+                }
+            }
+            currentDataGrouping = groupPositions.info;
+            currentDataGrouping.gapSize = gapSize;
+            series.closestPointRange = groupPositions.info.totalRange;
+            series.groupMap = groupedData.groupMap;
+            if (visible) {
+                adjustExtremes(xAxis, groupedXData);
+            }
+            // We calculated all group positions but we should render
+            // only the ones within the visible range
+            if (dataGroupingOptions.groupAll) {
+                // Keep the reference to all grouped points
+                // for further calculation (eg. heikinashi).
+                series.allGroupedData = groupedYData;
+                croppedData = series.cropData(groupedXData, groupedYData, xAxis.min, xAxis.max, 1 // Ordinal xAxis will remove left-most points otherwise
+                );
+                groupedXData = croppedData.xData;
+                groupedYData = croppedData.yData;
+                series.cropStart = croppedData.start; // #15005
+            }
+            // Set series props
+            series.processedXData = groupedXData;
+            series.processedYData = groupedYData;
+        }
+        else {
+            series.groupMap = null;
+        }
+        series.hasGroupedData = hasGroupedData;
+        series.currentDataGrouping = currentDataGrouping;
+        series.preventGraphAnimation =
+            (lastDataGrouping && lastDataGrouping.totalRange) !==
+                (currentDataGrouping && currentDataGrouping.totalRange);
+    }
+}
+/**
+ * @private
+ */
+function compose(SeriesClass) {
+    var PointClass = SeriesClass.prototype.pointClass;
+    if (composedMembers.indexOf(PointClass) === -1) {
+        composedMembers.push(PointClass);
+        // Override point prototype to throw a warning when trying to update
+        // grouped points.
+        addEvent(PointClass, 'update', function () {
+            if (this.dataGroup) {
+                error(24, false, this.series.chart);
+                return false;
+            }
+        });
+    }
+    if (composedMembers.indexOf(SeriesClass) === -1) {
+        composedMembers.push(SeriesClass);
+        addEvent(SeriesClass, 'afterSetOptions', onAfterSetOptions);
+        addEvent(SeriesClass, 'destroy', destroyGroupedData);
+        extend(SeriesClass.prototype, {
+            applyGrouping: applyGrouping,
+            destroyGroupedData: destroyGroupedData,
+            generatePoints: generatePoints,
+            getDGApproximation: getDGApproximation,
+            groupData: groupData
+        });
+    }
+}
+/**
+ * Destroy the grouped data points. #622, #740
+ * @private
+ */
+function destroyGroupedData() {
+    // Clear previous groups
+    if (this.groupedData) {
+        this.groupedData.forEach(function (point, i) {
+            if (point) {
+                this.groupedData[i] = point.destroy ?
+                    point.destroy() : null;
+            }
+        }, this);
+        // Clears all:
+        // - `this.groupedData`
+        // - `this.points`
+        // - `preserve` object in series.update()
+        this.groupedData.length = 0;
+    }
+}
+/**
+ * Override the generatePoints method by adding a reference to grouped data
+ * @private
+ */
+function generatePoints() {
+    baseGeneratePoints.apply(this);
+    // Record grouped data in order to let it be destroyed the next time
+    // processData runs
+    this.destroyGroupedData(); // #622
+    this.groupedData = this.hasGroupedData ? this.points : null;
+}
+/**
+ * Set default approximations to the prototypes if present. Properties are
+ * inherited down. Can be overridden for individual series types.
+ * @private
+ */
+function getDGApproximation() {
+    if (this.is('arearange')) {
+        return 'range';
+    }
+    if (this.is('ohlc')) {
+        return 'ohlc';
+    }
+    if (this.is('hlc')) {
+        return 'hlc';
+    }
+    if (this.is('column')) {
+        return 'sum';
+    }
+    return 'average';
+}
+/**
+ * Highcharts Stock only. Takes parallel arrays of x and y data and groups the
+ * data into intervals defined by groupPositions, a collection of starting x
+ * values for each group.
+ *
+ * @product highstock
+ *
+ * @function Highcharts.Series#groupData
+ * @param {Array<number>} xData
+ *        Parallel array of x data.
+ * @param {Array<(number|null|undefined)>|Array<Array<(number|null|undefined)>>} yData
+ *        Parallel array of y data.
+ * @param {Array<number>} groupPositions
+ *        Group positions.
+ * @param {string|Function} [approximation]
+ *        Approximation to use.
+ * @return {Highcharts.DataGroupingResultObject}
+ *         Mapped groups.
+ */
+function groupData(xData, yData, groupPositions, approximation) {
+    var series = this, data = series.data, dataOptions = series.options && series.options.data, groupedXData = [], groupedYData = [], groupMap = [], dataLength = xData.length, 
+    // when grouping the fake extended axis for panning,
+    // we don't need to consider y
+    handleYData = !!yData, values = [], pointArrayMap = series.pointArrayMap, pointArrayMapLength = pointArrayMap && pointArrayMap.length, extendedPointArrayMap = ['x'].concat(pointArrayMap || ['y']), groupAll = (this.options.dataGrouping &&
+        this.options.dataGrouping.groupAll);
+    var pointX, pointY, groupedY, pos = 0, start = 0;
+    var approximationFn = (typeof approximation === 'function' ?
+        approximation :
+        approximation && ApproximationRegistry[approximation] ?
+            ApproximationRegistry[approximation] :
+            ApproximationRegistry[(series.getDGApproximation && series.getDGApproximation() ||
+                'average')]);
+    // Calculate values array size from pointArrayMap length
+    if (pointArrayMapLength) {
+        var len = pointArrayMap.length;
+        while (len--) {
+            values.push([]);
+        }
+    }
+    else {
+        values.push([]);
+    }
+    var valuesLen = pointArrayMapLength || 1;
+    for (var i = 0; i <= dataLength; i++) {
+        // Start with the first point within the X axis range (#2696)
+        if (xData[i] < groupPositions[0]) {
+            continue; // with next point
+        }
+        // when a new group is entered, summarize and initialize
+        // the previous group
+        while ((typeof groupPositions[pos + 1] !== 'undefined' &&
+            xData[i] >= groupPositions[pos + 1]) ||
+            i === dataLength) { // get the last group
+            // get group x and y
+            pointX = groupPositions[pos];
+            series.dataGroupInfo = {
+                start: groupAll ? start : (series.cropStart + start),
+                length: values[0].length
+            };
+            groupedY = approximationFn.apply(series, values);
+            // By default, let options of the first grouped point be passed over
+            // to the grouped point. This allows preserving properties like
+            // `name` and `color` or custom properties. Implementers can
+            // override this from the approximation function, where they can
+            // write custom options to `this.dataGroupInfo.options`.
+            if (series.pointClass && !defined(series.dataGroupInfo.options)) {
+                // Convert numbers and arrays into objects
+                series.dataGroupInfo.options = merge(series.pointClass.prototype
+                    .optionsToObject.call({ series: series }, series.options.data[series.cropStart + start]));
+                // Make sure the raw data (x, y, open, high etc) is not copied
+                // over and overwriting approximated data.
+                extendedPointArrayMap.forEach(function (key) {
+                    delete series.dataGroupInfo.options[key];
+                });
+            }
+            // push the grouped data
+            if (typeof groupedY !== 'undefined') {
+                groupedXData.push(pointX);
+                groupedYData.push(groupedY);
+                groupMap.push(series.dataGroupInfo);
+            }
+            // reset the aggregate arrays
+            start = i;
+            for (var j = 0; j < valuesLen; j++) {
+                values[j].length = 0; // faster than values[j] = []
+                values[j].hasNulls = false;
+            }
+            // Advance on the group positions
+            pos += 1;
+            // don't loop beyond the last group
+            if (i === dataLength) {
+                break;
+            }
+        }
+        // break out
+        if (i === dataLength) {
+            break;
+        }
+        // for each raw data point, push it to an array that contains all values
+        // for this specific group
+        if (pointArrayMap) {
+            var index = (series.options.dataGrouping &&
+                series.options.dataGrouping.groupAll ?
+                i : series.cropStart + i), point = (data && data[index]) ||
+                series.pointClass.prototype.applyOptions.apply({
+                    series: series
+                }, [dataOptions[index]]);
+            var val = void 0;
+            for (var j = 0; j < pointArrayMapLength; j++) {
+                val = point[pointArrayMap[j]];
+                if (isNumber(val)) {
+                    values[j].push(val);
+                }
+                else if (val === null) {
+                    values[j].hasNulls = true;
+                }
+            }
+        }
+        else {
+            pointY = handleYData ? yData[i] : null;
+            if (isNumber(pointY)) {
+                values[0].push(pointY);
+            }
+            else if (pointY === null) {
+                values[0].hasNulls = true;
+            }
+        }
+    }
+    return {
+        groupedXData: groupedXData,
+        groupedYData: groupedYData,
+        groupMap: groupMap
+    };
+}
+/**
+ * Handle default options for data grouping. This must be set at runtime because
+ * some series types are defined after this.
+ * @private
+ */
+function onAfterSetOptions(e) {
+    var options = e.options, type = this.type, plotOptions = this.chart.options.plotOptions, 
+    // External series, for example technical indicators should also inherit
+    // commonOptions which are not available outside this module
+    baseOptions = (this.useCommonDataGrouping &&
+        DataGroupingDefaults.common), seriesSpecific = DataGroupingDefaults.seriesSpecific;
+    var defaultOptions = D.defaultOptions.plotOptions[type].dataGrouping;
+    if (plotOptions && (seriesSpecific[type] || baseOptions)) { // #1284
+        var rangeSelector = this.chart.rangeSelector;
+        if (!defaultOptions) {
+            defaultOptions = merge(DataGroupingDefaults.common, seriesSpecific[type]);
+        }
+        options.dataGrouping = merge(baseOptions, defaultOptions, plotOptions.series && plotOptions.series.dataGrouping, // #1228
+        // Set by the StockChart constructor:
+        plotOptions[type].dataGrouping, this.userOptions.dataGrouping, !options.isInternal &&
+            rangeSelector &&
+            isNumber(rangeSelector.selected) &&
+            rangeSelector.buttonOptions[rangeSelector.selected].dataGrouping);
+    }
+}
+/**
+ * @private
+ */
+function skipDataGrouping(series, force) {
+    return !(series.isCartesian &&
+        !series.isDirty &&
+        !series.xAxis.isDirty &&
+        !series.yAxis.isDirty &&
+        !force);
+}
+/* *
+ *
+ *  Default Export
+ *
+ * */
+var DataGroupingSeriesComposition = {
+    compose: compose,
+    groupData: groupData
+};
+export default DataGroupingSeriesComposition;

package/es-modules/Extensions/Debugger/Debugger.js

@@ -10,7 +10,7 @@
 'use strict';
 import ErrorMessages from './ErrorMessages.js';
 import H from '../../Core/Globals.js';
-import D from '../../Core/DefaultOptions.js';
+import D from '../../Core/Defaults.js';
 var setOptions = D.setOptions;
 import U from '../../Core/Utilities.js';
 var addEvent = U.addEvent, find = U.find, isNumber = U.isNumber;

package/es-modules/Extensions/DraggablePoints.js

@@ -534,7 +534,9 @@ if (seriesTypes.arearange) {
             resize: true,
             resizeSide: 'bottom',
             handlePositioner: function (point) {
-                var bBox = point.lowerGraphic && point.lowerGraphic.getBBox();
+                var bBox = (point.graphics &&
+                    point.graphics[0] &&
+                    point.graphics[0].getBBox());
                 return bBox ? {
                     x: bBox.x + bBox.width / 2,
                     y: bBox.y + bBox.height / 2
@@ -558,7 +560,9 @@ if (seriesTypes.arearange) {
             resize: true,
             resizeSide: 'top',
             handlePositioner: function (point) {
-                var bBox = point.upperGraphic && point.upperGraphic.getBBox();
+                var bBox = (point.graphics &&
+                    point.graphics[1] &&
+                    point.graphics[1].getBBox());
                 return bBox ? {
                     x: bBox.x + bBox.width / 2,
                     y: bBox.y + bBox.height / 2

package/es-modules/Extensions/Drilldown.js

@@ -16,11 +16,9 @@ import Axis from '../Core/Axis/Axis.js';
 import Chart from '../Core/Chart/Chart.js';
 import Color from '../Core/Color/Color.js';
 import ColumnSeries from '../Series/Column/ColumnSeries.js';
-import F from '../Core/FormatUtilities.js';
-var format = F.format;
 import H from '../Core/Globals.js';
 var noop = H.noop;
-import D from '../Core/DefaultOptions.js';
+import D from '../Core/Defaults.js';
 var defaultOptions = D.defaultOptions;
 import Point from '../Core/Series/Point.js';
 import Series from '../Core/Series/Series.js';
@@ -281,12 +279,12 @@ defaultOptions.drilldown = {
      *   object. See
      *   [the easing demo](https://jsfiddle.net/gh/get/library/pure/highcharts/highcharts/tree/master/samples/highcharts/plotoptions/series-animation-easing/).
      *
-     * @type    {boolean|Partial<Highcharts.AnimationOptionsObject>}
+     * @type    {boolean|Highcharts.AnimationOptionsObject}
      * @since   3.0.8
      * @product highcharts highmaps
      */
     animation: {
-        /** @internal */
+        /** @ignore-option */
         duration: 500
     },
     /**

package/es-modules/Extensions/ExportData/ExportData.js

@@ -26,7 +26,7 @@ import AST from '../../Core/Renderer/HTML/AST.js';
 import ExportDataDefaults from './ExportDataDefaults.js';
 import H from '../../Core/Globals.js';
 var doc = H.doc, win = H.win;
-import D from '../../Core/DefaultOptions.js';
+import D from '../../Core/Defaults.js';
 var getOptions = D.getOptions, setOptions = D.setOptions;
 import DownloadURL from '../DownloadURL.js';
 var downloadURL = DownloadURL.downloadURL;
@@ -262,7 +262,8 @@ function chartGetDataRows(multiLevelHeaders) {
                 chart: series.chart,
                 autoIncrement: series.autoIncrement,
                 options: series.options,
-                pointArrayMap: series.pointArrayMap
+                pointArrayMap: series.pointArrayMap,
+                index: series.index
             };
             // Export directly from options.data because we need the uncropped
             // data (#7913), and we need to support Boost (#7026).
@@ -276,6 +277,20 @@ function chartGetDataRows(multiLevelHeaders) {
                 }
                 series.pointClass.prototype.applyOptions.apply(mockPoint, [options]);
                 key = mockPoint.x;
+                if (defined(rows[key]) &&
+                    rows[key].seriesIndices.includes(mockSeries.index)) {
+                    // find keys, which belong to actual series
+                    var keysFromActualSeries = Object.keys(rows).filter(function (i) {
+                        return rows[i].seriesIndices.includes(mockSeries.index) &&
+                            key;
+                    }), 
+                    // find all properties, which start with actual key
+                    existingKeys = keysFromActualSeries
+                        .filter(function (propertyName) {
+                        return propertyName.indexOf(String(key)) === 0;
+                    });
+                    key = key.toString() + ',' + existingKeys.length;
+                }
                 var name = series.data[pIdx] && series.data[pIdx].name;
                 j = 0;
                 // Pies, funnels, geo maps etc. use point name in X row
@@ -299,6 +314,12 @@ function chartGetDataRows(multiLevelHeaders) {
                 rows[key].x = mockPoint.x;
                 rows[key].name = name;
                 rows[key].xValues[xAxisIndex] = mockPoint.x;
+                if (!defined(rows[key].seriesIndices)) {
+                    rows[key].seriesIndices = [];
+                }
+                rows[key].seriesIndices = __spreadArray(__spreadArray([], rows[key].seriesIndices, true), [
+                    mockSeries.index
+                ], false);
                 while (j < valueCount) {
                     prop = pointArrayMap[j]; // y, z etc
                     val = mockPoint[prop];
@@ -609,7 +630,8 @@ function chartHideData() {
 function chartToggleDataTable(show) {
     show = pick(show, !this.isDataTableVisible);
     // Create the div
-    if (show && !this.dataTableDiv) {
+    var createContainer = show && !this.dataTableDiv;
+    if (createContainer) {
         this.dataTableDiv = doc.createElement('div');
         this.dataTableDiv.className = 'highcharts-data-table';
         // Insert after the chart container
@@ -617,13 +639,17 @@ function chartToggleDataTable(show) {
     }
     // Toggle the visibility
     if (this.dataTableDiv) {
-        this.dataTableDiv.style.display = show ? 'block' : 'none';
+        var style = this.dataTableDiv.style, oldDisplay = style.display;
+        style.display = show ? 'block' : 'none';
         // Generate the data table
         if (show) {
             this.dataTableDiv.innerHTML = AST.emptyHTML;
             var ast = new AST([this.getTableAST()]);
             ast.addToDOM(this.dataTableDiv);
-            fireEvent(this, 'afterViewData', this.dataTableDiv);
+            fireEvent(this, 'afterViewData', {
+                element: this.dataTableDiv,
+                wasHidden: createContainer || oldDisplay !== style.display
+            });
         }
     }
     // Set the flag