highcharts 9.2.2 → 9.3.3

package/es-modules/Data/DataPromise.js

@@ -0,0 +1,252 @@
+/* *
+ *
+ *  (c) 2020-2021 Highsoft AS
+ *
+ *  License: www.highcharts.com/license
+ *
+ *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+ *
+ *  Authors:
+ *  - Sophie Bremer
+ *
+ * */
+'use strict';
+/* *
+ *
+ *  Imports
+ *
+ * */
+import H from '../Core/Globals.js';
+/* *
+ *
+ *  Constants
+ *
+ * */
+var win = H.win;
+var delay = setTimeout;
+/* *
+ *
+ *  Class
+ *
+ * */
+/**
+ * Simplified wrapper for Promise-support in outdated browsers.
+ */
+var DataPromise = /** @class */ (function () {
+    /* *
+     *
+     *  Constructor
+     *
+     * */
+    function DataPromise(executor) {
+        /* *
+         *
+         *  Properties
+         *
+         * */
+        this.jobs = [];
+        this.state = DataPromise.State.Pending;
+        this.value = void 0;
+        if (win.Promise && !DataPromise.onlyPolyfill) {
+            return new win.Promise(executor);
+        }
+        var promise = this;
+        delay(function () {
+            try {
+                executor(function (value) { return promise.resolved(value); }, function (reason) { return promise.rejected(reason); });
+            }
+            catch (e) {
+                promise.rejected(e);
+            }
+        }, 0);
+    }
+    /* *
+     *
+     *  Static Functions
+     *
+     * */
+    DataPromise.isPromiseLike = function (promise) {
+        return (typeof promise === 'object' &&
+            promise !== null &&
+            typeof promise.then === 'function');
+    };
+    DataPromise.reject = function (reason) {
+        if (win.Promise && !DataPromise.onlyPolyfill) {
+            return win.Promise.reject(reason);
+        }
+        return new DataPromise(function (resolve, reject) { return reject(reason); });
+    };
+    DataPromise.resolve = function (value) {
+        if (win.Promise && !DataPromise.onlyPolyfill) {
+            return win.Promise.resolve(value);
+        }
+        if (DataPromise.isPromiseLike(value)) {
+            return new DataPromise(function (resolve, reject) {
+                value.then(resolve, reject);
+            });
+        }
+        return new DataPromise(function (resolve) { return resolve(value); });
+    };
+    /* *
+     *
+     *  Functions
+     *
+     * */
+    DataPromise.prototype['catch'] = function (onrejected) {
+        return this.then(null, onrejected);
+    };
+    DataPromise.prototype.rejected = function (reason) {
+        var promise = this;
+        if (promise.state === DataPromise.State.Pending) {
+            promise.state = DataPromise.State.Rejected;
+            promise.reason = reason;
+            delay(function () { return promise.work(); }, 0);
+        }
+    };
+    DataPromise.prototype.resolved = function (value) {
+        var promise = this;
+        if (promise.state === DataPromise.State.Pending) {
+            if (DataPromise.isPromiseLike(value)) {
+                value.then(function (value) { return promise.resolved(value); }, function (reason) { return promise.rejected(reason); });
+            }
+            else {
+                promise.state = DataPromise.State.Fulfilled;
+                promise.value = value;
+                delay(function () { return promise.work(); }, 0);
+            }
+        }
+    };
+    DataPromise.prototype.then = function (onfulfilled, onrejected) {
+        var promise = this, newPromise = new DataPromise(function () { return void 0; }), rejecter = function (reason) {
+            if (onrejected) {
+                try {
+                    var result = onrejected(reason);
+                    if (result instanceof DataPromise) {
+                        result.then(function (value) {
+                            return newPromise.resolved(value);
+                        }, function (reason) {
+                            return newPromise.rejected(reason);
+                        });
+                    }
+                    else {
+                        newPromise.resolved(result);
+                    }
+                    return;
+                }
+                catch (e) {
+                    reason = e;
+                }
+            }
+            if (newPromise.jobs.length) {
+                newPromise.rejected(reason);
+            }
+            else if (reason) {
+                throw reason;
+            }
+            else {
+                throw new Error('Unhandled exception');
+            }
+        }, resolver = function (value) {
+            if (onfulfilled) {
+                try {
+                    var result = onfulfilled(value);
+                    if (result instanceof DataPromise) {
+                        result.then(function (value) {
+                            return newPromise.resolved(value);
+                        }, function (reason) {
+                            return newPromise.rejected(reason);
+                        });
+                    }
+                    else {
+                        newPromise.resolved(result);
+                    }
+                }
+                catch (e) {
+                    rejecter(e);
+                }
+            }
+            else {
+                newPromise.resolved(value);
+            }
+        };
+        switch (promise.state) {
+            case DataPromise.State.Fulfilled:
+                resolver(promise.value);
+                break;
+            case DataPromise.State.Rejected:
+                rejecter(promise.reason);
+                break;
+            default:
+                promise.jobs.push({
+                    resolve: resolver,
+                    reject: rejecter
+                });
+                break;
+        }
+        return newPromise;
+    };
+    DataPromise.prototype.work = function () {
+        var promise = this, jobs = promise.jobs;
+        var job, rejectHandled;
+        while ((job = jobs.shift())) {
+            try {
+                if (promise.state === DataPromise.State.Fulfilled) {
+                    job.resolve(promise.value);
+                }
+                else if (job.reject) {
+                    rejectHandled = true;
+                    job.reject(promise.reason);
+                }
+            }
+            catch (e) {
+                rejectHandled = false;
+                promise.reason = e;
+                promise.state = DataPromise.State.Rejected;
+            }
+        }
+        if (rejectHandled === false) {
+            if (promise.reason) {
+                throw promise.reason;
+            }
+            else {
+                throw new Error('Unhandled rejection');
+            }
+        }
+    };
+    /* *
+     *
+     *  Static Properties
+     *
+     * */
+    DataPromise.onlyPolyfill = false;
+    return DataPromise;
+}());
+/* *
+ *
+ *  Class Namespace
+ *
+ * */
+(function (DataPromise) {
+    /* *
+     *
+     *  Declarations
+     *
+     * */
+    /* *
+     *
+     *  Enumerations
+     *
+     * */
+    var State;
+    (function (State) {
+        State[State["Fulfilled"] = 2] = "Fulfilled";
+        State[State["Pending"] = 0] = "Pending";
+        State[State["Rejected"] = 1] = "Rejected";
+    })(State = DataPromise.State || (DataPromise.State = {}));
+})(DataPromise || (DataPromise = {}));
+/* *
+ *
+ *  Default Export
+ *
+ * */
+export default DataPromise;

package/es-modules/Data/DataSeriesConverter.js

@@ -0,0 +1,207 @@
+/* *
+ *
+ *  (c) 2020-2021 Highsoft AS
+ *
+ *  License: www.highcharts.com/license
+ *
+ *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+ *
+ *  Authors:
+ *  - Sebastian Bochan
+ *  - Wojciech Chmiel
+ *  - Sophie Bremer
+ *
+ * */
+'use strict';
+import DataTable from './DataTable.js';
+import U from '../Core/Utilities.js';
+var defined = U.defined, uniqueKey = U.uniqueKey;
+/* *
+ *
+ *  Class
+ *
+ * */
+/**
+ * Class to convert Highcharts series data to table and get series data from the
+ * table.
+ *
+ * @private
+ */
+var DataSeriesConverter = /** @class */ (function () {
+    /* *
+     *
+     *  Constructor
+     *
+     * */
+    /**
+     * Constructs an instance of the DataSeriesConverter class.
+     *
+     * @param {DataTable} [table]
+     * DataSeriesConverter table to store series data.
+     *
+     * @param {DataSeriesConverter.Options} [options]
+     * DataSeriesConverter options.
+     */
+    function DataSeriesConverter(table, options) {
+        if (table === void 0) { table = new DataTable(); }
+        if (options === void 0) { options = {}; }
+        this.table = table;
+        this.options = options;
+        this.seriesIdMap = {};
+        this.seriesMeta = [];
+    }
+    /* *
+     *
+     *  Functions
+     *
+     * */
+    /**
+     * Get the specific series data stored in the converter.
+     *
+     * @param {string} seriesId
+     * The id of the series.
+     *
+     * @return {Array<PointOptions>}
+     * Returns an array of series points opitons.
+     */
+    DataSeriesConverter.prototype.getSeriesData = function (seriesId) {
+        var converter = this, table = converter.table, seriesData = [];
+        var pointOptions, cellName, cell, isCellFound, pointArrayMap;
+        if (seriesId) {
+            pointArrayMap = converter.seriesIdMap[seriesId].pointArrayMap || ['y'];
+            for (var i = 0, iEnd = table.getRowCount(); i < iEnd; i++) {
+                isCellFound = false;
+                pointOptions = {
+                    x: table.getCellAsNumber('x', i, true)
+                };
+                for (var j = 0, jEnd = pointArrayMap.length; j < jEnd; j++) {
+                    cellName = pointArrayMap[j] + '_' + seriesId;
+                    cell = table.getCell(cellName, i);
+                    if (typeof cell !== 'undefined') {
+                        isCellFound = true;
+                        pointOptions[pointArrayMap[j]] = table.getCellAsNumber(cellName, i);
+                    }
+                }
+                if (isCellFound) {
+                    seriesData.push(pointOptions);
+                }
+            }
+        }
+        return seriesData;
+    };
+    /**
+     * Get all series data stored in the converter.
+     *
+     * @return {Array<SeriesOptions>}
+     * Returns an array of series opitons.
+     */
+    DataSeriesConverter.prototype.getAllSeriesData = function () {
+        var converter = this, seriesOptions = [];
+        var id;
+        for (var i = 0, iEnd = converter.seriesMeta.length; i < iEnd; i++) {
+            id = converter.seriesMeta[i].id;
+            seriesOptions.push({
+                id: id,
+                data: converter.getSeriesData(id)
+            });
+        }
+        return seriesOptions;
+    };
+    /**
+     * Update the converter with passed series options.
+     *
+     * @param {Array<LineSeries>} allSeries
+     * Array of series options to store in the converter.
+     *
+     * @param {DataEventEmitter.EventDetail} eventDetail
+     * Custom information for pending events.
+     */
+    DataSeriesConverter.prototype.updateTable = function (allSeries, eventDetail) {
+        var table = this.table;
+        var columns, series, seriesMeta, pointArrayMap, pointArrayMapLength, options, keys, data, elem, rowIndex, y, needsArrayMap, xIndex, yIndex, yValueName, yValueIndex, yValueId, id;
+        if (allSeries && allSeries.length) {
+            this.options.seriesOptions = [];
+            this.seriesMeta = [];
+            this.seriesIdMap = {};
+            for (var i = 0, iEnd = allSeries.length; i < iEnd; i++) {
+                series = allSeries[i];
+                // Add a unique ID to the series if none is assigned.
+                series.id = defined(series.id) ? series.id : uniqueKey();
+                yValueId = '_' + series.id;
+                pointArrayMap = series.pointArrayMap || ['y'];
+                pointArrayMapLength = pointArrayMap.length;
+                options = series.options;
+                keys = options.keys;
+                data = series.options.data || [];
+                seriesMeta = {
+                    id: series.id,
+                    pointArrayMap: pointArrayMap,
+                    options: series.options
+                };
+                this.options.seriesOptions.push(series.options);
+                this.seriesMeta.push(seriesMeta);
+                this.seriesIdMap[series.id] = seriesMeta;
+                for (var j = 0, jEnd = data.length; j < jEnd; j++) {
+                    elem = data[j];
+                    y = 'y' + yValueId;
+                    columns = {};
+                    needsArrayMap = pointArrayMapLength > 1;
+                    if (typeof elem === 'number') {
+                        columns[y] = elem;
+                        columns.x = j;
+                    }
+                    else if (elem instanceof Array) {
+                        xIndex = keys && keys.indexOf('x') > -1 ?
+                            keys.indexOf('x') : 0;
+                        yIndex = keys && keys.indexOf('y') > -1 ?
+                            keys.indexOf('y') : 1;
+                        if (needsArrayMap) {
+                            for (var k = 0; k < pointArrayMapLength; k++) {
+                                yValueIndex = keys && keys.indexOf(pointArrayMap[k]) > -1 ?
+                                    keys.indexOf(pointArrayMap[k]) :
+                                    k + elem.length - pointArrayMapLength;
+                                yValueName = pointArrayMap[k];
+                                columns[yValueName + yValueId] = elem[yValueIndex];
+                            }
+                        }
+                        else {
+                            columns[y] = elem[yIndex];
+                        }
+                        columns.x = elem.length - pointArrayMapLength > 0 ?
+                            elem[xIndex] :
+                            j;
+                    }
+                    else if (elem instanceof Object) {
+                        if (needsArrayMap) {
+                            var elemSet = elem;
+                            for (var k = 0; k < pointArrayMapLength; k++) {
+                                yValueName = pointArrayMap[k];
+                                columns[yValueName + yValueId] = elemSet[yValueName];
+                            }
+                        }
+                        else {
+                            columns[y] = elem.y;
+                        }
+                        columns.x = elem.x || j;
+                    }
+                    id = '' + columns.x;
+                    rowIndex = table.getRowIndexBy('id', id);
+                    if (!rowIndex) {
+                        columns.id = id;
+                        table.setRows([columns], void 0, eventDetail);
+                    }
+                    else if (columns[y]) {
+                        table.setCell(y, rowIndex, columns[y], eventDetail);
+                    }
+                }
+            }
+        }
+    };
+    return DataSeriesConverter;
+}());
+/* *
+ *
+ *  Export
+ *
+ * */
+export default DataSeriesConverter;