highcharts 9.2.1 → 9.3.2

package/es-modules/Data/Stores/CSVStore.js

@@ -0,0 +1,317 @@
+/* *
+ *
+ *  (c) 2012-2021 Highsoft AS
+ *
+ *  License: www.highcharts.com/license
+ *
+ *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+ *
+ *  Authors:
+ *  - Torstein Hønsi
+ *  - Christer Vasseng
+ *  - Gøran Slettemark
+ *  - Sophie Bremer
+ *
+ * */
+'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 __());
+    };
+})();
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import CSVParser from '../Parsers/CSVParser.js';
+import DataStore from './DataStore.js';
+import DataTable from '../DataTable.js';
+import HU from '../../Core/HttpUtilities.js';
+var ajax = HU.ajax;
+import U from '../../Core/Utilities.js';
+var merge = U.merge, objectEach = U.objectEach;
+/* *
+ *
+ *  Class
+ *
+ * */
+/* eslint-disable no-invalid-this, require-jsdoc, valid-jsdoc */
+/**
+ * Class that handles creating a datastore from CSV
+ *
+ * @private
+ */
+var CSVStore = /** @class */ (function (_super) {
+    __extends(CSVStore, _super);
+    /* *
+    *
+    *  Constructors
+    *
+    * */
+    /**
+     * Constructs an instance of CSVDataStore.
+     *
+     * @param {DataTable} table
+     * Optional table to create the store from.
+     *
+     * @param {CSVStore.OptionsType} options
+     * Options for the store and parser.
+     *
+     * @param {DataParser} parser
+     * Optional parser to replace the default parser.
+     */
+    function CSVStore(table, options, parser) {
+        if (table === void 0) { table = new DataTable(); }
+        if (options === void 0) { options = {}; }
+        var _this = _super.call(this, table) || this;
+        var csv = options.csv, csvURL = options.csvURL, enablePolling = options.enablePolling, dataRefreshRate = options.dataRefreshRate, parserOptions = __rest(options, ["csv", "csvURL", "enablePolling", "dataRefreshRate"]);
+        _this.parserOptions = parserOptions;
+        _this.options = merge(CSVStore.defaultOptions, { csv: csv, csvURL: csvURL, enablePolling: enablePolling, dataRefreshRate: dataRefreshRate });
+        _this.parser = parser || new CSVParser(parserOptions);
+        return _this;
+    }
+    /**
+     * Handles polling of live data
+     */
+    CSVStore.prototype.poll = function () {
+        var _this = this;
+        var _a = this.options, dataRefreshRate = _a.dataRefreshRate, enablePolling = _a.enablePolling, csvURL = _a.csvURL;
+        var updateIntervalMs = (dataRefreshRate > 1 ? dataRefreshRate : 1) * 1000;
+        if (enablePolling && csvURL === this.liveDataURL) {
+            // We need to stop doing this if the URL has changed
+            this.liveDataTimeout = setTimeout(function () {
+                _this.fetchCSV();
+            }, updateIntervalMs);
+        }
+    };
+    /**
+     * Fetches CSV from external source
+     *
+     * @param {boolean} initialFetch
+     * Indicates whether this is a single fetch or a repeated fetch
+     *
+     * @param {DataEventEmitter.EventDetail} [eventDetail]
+     * Custom information for pending events.
+     *
+     * @emits CSVDataStore#load
+     * @emits CSVDataStore#afterLoad
+     * @emits CSVDataStore#loadError
+     */
+    CSVStore.prototype.fetchCSV = function (initialFetch, eventDetail) {
+        var store = this, maxRetries = 3, csvURL = store.options.csvURL;
+        var currentRetries;
+        // Clear the table
+        store.table.deleteColumns();
+        if (initialFetch) {
+            clearTimeout(store.liveDataTimeout);
+            store.liveDataURL = csvURL;
+        }
+        store.emit({ type: 'load', detail: eventDetail, table: store.table });
+        ajax({
+            url: store.liveDataURL,
+            dataType: 'text',
+            success: function (csv) {
+                store.parser.parse({ csv: csv });
+                // On inital fetch we need to set the columns
+                store.table.setColumns(store.parser.getTable().getColumns());
+                if (store.liveDataURL) {
+                    store.poll();
+                }
+                store.emit({
+                    type: 'afterLoad',
+                    csv: csv,
+                    detail: eventDetail,
+                    table: store.table
+                });
+            },
+            error: function (xhr, error) {
+                if (++currentRetries < maxRetries) {
+                    store.poll();
+                }
+                store.emit({
+                    type: 'loadError',
+                    detail: eventDetail,
+                    error: error,
+                    table: store.table,
+                    xhr: xhr
+                });
+            }
+        });
+    };
+    /**
+     * Initiates the loading of the CSV source to the store
+     *
+     * @param {DataEventEmitter.EventDetail} [eventDetail]
+     * Custom information for pending events.
+     *
+     * @emits CSVParser#load
+     * @emits CSVParser#afterLoad
+     */
+    CSVStore.prototype.load = function (eventDetail) {
+        var store = this, parser = store.parser, table = store.table, _a = store.options, csv = _a.csv, csvURL = _a.csvURL;
+        if (csv) {
+            // If already loaded, clear the current rows
+            table.deleteRows();
+            store.emit({
+                type: 'load',
+                csv: csv,
+                detail: eventDetail,
+                table: table
+            });
+            parser.parse({ csv: csv });
+            table.setColumns(parser.getTable().getColumns());
+            store.emit({
+                type: 'afterLoad',
+                csv: csv,
+                detail: eventDetail,
+                table: table
+            });
+        }
+        else if (csvURL) {
+            store.fetchCSV(true, eventDetail);
+        }
+        else {
+            store.emit({
+                type: 'loadError',
+                detail: eventDetail,
+                error: 'Unable to load: no CSV string or URL was provided',
+                table: table
+            });
+        }
+    };
+    /**
+     * Creates a CSV string from the datatable on the store instance.
+     *
+     * @param {CSVStore.ExportOptions} exportOptions
+     * The options used for the export.
+     *
+     * @return {string}
+     * A CSV string from the table.
+     */
+    CSVStore.prototype.getCSVForExport = function (exportOptions) {
+        var useLocalDecimalPoint = exportOptions.useLocalDecimalPoint, lineDelimiter = exportOptions.lineDelimiter, exportNames = (this.parserOptions.firstRowAsNames !== false);
+        var decimalPoint = exportOptions.decimalPoint, itemDelimiter = exportOptions.itemDelimiter;
+        if (!decimalPoint) {
+            decimalPoint = itemDelimiter !== ',' && useLocalDecimalPoint ?
+                (1.1).toLocaleString()[1] :
+                '.';
+        }
+        if (!itemDelimiter) {
+            itemDelimiter = decimalPoint === ',' ? ';' : ',';
+        }
+        var _a = this.getColumnsForExport(exportOptions.usePresentationOrder), columnNames = _a.columnNames, columnValues = _a.columnValues;
+        var csvRows = [], columnsCount = columnNames.length;
+        var rowArray = [];
+        // Add the names as the first row if they should be exported
+        if (exportNames) {
+            csvRows.push(columnNames.map(function (columnName) { return "\"" + columnName + "\""; }).join(itemDelimiter));
+        }
+        for (var columnIndex = 0; columnIndex < columnsCount; columnIndex++) {
+            var columnName = columnNames[columnIndex], column = columnValues[columnIndex], columnLength = column.length;
+            var columnMeta = this.whatIs(columnName);
+            var columnDataType = void 0;
+            if (columnMeta) {
+                columnDataType = columnMeta.dataType;
+            }
+            for (var rowIndex = 0; rowIndex < columnLength; rowIndex++) {
+                var cellValue = column[rowIndex];
+                if (!rowArray[rowIndex]) {
+                    rowArray[rowIndex] = [];
+                }
+                // Prefer datatype from metadata
+                if (columnDataType === 'string') {
+                    cellValue = "\"" + cellValue + "\"";
+                }
+                else if (typeof cellValue === 'number') {
+                    cellValue = String(cellValue).replace('.', decimalPoint);
+                }
+                else if (typeof cellValue === 'string') {
+                    cellValue = "\"" + cellValue + "\"";
+                }
+                rowArray[rowIndex][columnIndex] = cellValue;
+                // On the final column, push the row to the CSV
+                if (columnIndex === columnsCount - 1) {
+                    // Trim repeated undefined values starting at the end
+                    // Currently, we export the first "comma" even if the
+                    // second value is undefined
+                    var i = columnIndex;
+                    while (rowArray[rowIndex].length > 2) {
+                        var cellVal = rowArray[rowIndex][i];
+                        if (cellVal !== void 0) {
+                            break;
+                        }
+                        rowArray[rowIndex].pop();
+                        i--;
+                    }
+                    csvRows.push(rowArray[rowIndex].join(itemDelimiter));
+                }
+            }
+        }
+        return csvRows.join(lineDelimiter);
+    };
+    /**
+     * Exports the datastore as a CSV string, using the options
+     * provided on import unless other options are provided.
+     *
+     * @param {CSVStore.ExportOptions} [csvExportOptions]
+     * Options to use instead of those used on import.
+     *
+     * @return {string}
+     * CSV from the store's current table.
+     *
+     */
+    CSVStore.prototype.save = function (csvExportOptions) {
+        var exportOptions = CSVStore.defaultExportOptions;
+        // Merge in the provided parser options
+        objectEach(this.parserOptions, function (value, key) {
+            if (key in exportOptions) {
+                exportOptions[key] = value;
+            }
+        });
+        return this.getCSVForExport(merge(exportOptions, csvExportOptions));
+    };
+    /* *
+     *
+     *  Static Properties
+     *
+     * */
+    CSVStore.defaultOptions = {
+        csv: '',
+        csvURL: '',
+        enablePolling: false,
+        dataRefreshRate: 1
+    };
+    CSVStore.defaultExportOptions = {
+        decimalPoint: null,
+        itemDelimiter: null,
+        lineDelimiter: '\n'
+    };
+    return CSVStore;
+}(DataStore));
+/* *
+ *
+ *  Registry
+ *
+ * */
+DataStore.addStore(CSVStore);
+/* *
+ *
+ *  Export
+ *
+ * */
+export default CSVStore;

package/es-modules/Data/Stores/DataStore.js

@@ -0,0 +1,276 @@
+/* *
+ *
+ *  (c) 2020-2021 Highsoft AS
+ *
+ *  License: www.highcharts.com/license
+ *
+ *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+ *
+ *  Authors:
+ *  - Sophie Bremer
+ *  - Wojciech Chmiel
+ *  - Gøran Slettemark
+ *
+ * */
+'use strict';
+import DataTable from '../DataTable.js';
+import U from '../../Core/Utilities.js';
+var addEvent = U.addEvent, fireEvent = U.fireEvent, merge = U.merge, pick = U.pick;
+/* *
+ *
+ *  Class
+ *
+ * */
+/**
+ * Abstract class providing an interface for managing a DataStore.
+ *
+ * @private
+ */
+var DataStore = /** @class */ (function () {
+    /* *
+     *
+     *  Constructor
+     *
+     * */
+    /**
+     * Constructor for the store class.
+     *
+     * @param {DataTable} table
+     * Optional table to use in the store.
+     *
+     * @param {DataStore.Metadata} metadata
+     * Optional metadata to use in the store.
+     */
+    function DataStore(table, metadata) {
+        if (table === void 0) { table = new DataTable(); }
+        if (metadata === void 0) { metadata = { columns: {} }; }
+        this.table = table;
+        this.metadata = metadata;
+    }
+    /* *
+     *
+     *  Static Functions
+     *
+     * */
+    /**
+     * Adds a store class to the registry. The store has to provide the
+     * `DataStore.options` property and the `DataStore.load` method to
+     * modify the table.
+     *
+     * @param {DataStore} dataStore
+     * Store class (aka class constructor) to register.
+     *
+     * @return {boolean}
+     * Returns true, if the registration was successful. False is returned, if
+     * their is already a store registered with this name.
+     */
+    DataStore.addStore = function (dataStore) {
+        var name = DataStore.getName(dataStore), registry = DataStore.registry;
+        if (typeof name === 'undefined' ||
+            registry[name]) {
+            return false;
+        }
+        registry[name] = dataStore;
+        return true;
+    };
+    /**
+     * Returns all registered dataStore names.
+     *
+     * @return {Array<string>}
+     * All registered store names.
+     */
+    DataStore.getAllStoreNames = function () {
+        return Object.keys(DataStore.registry);
+    };
+    /**
+     * Returns a copy of the dataStore registry as record object with
+     * dataStore names and their dataStore class.
+     *
+     * @return {Record<string,DataStoreRegistryType>}
+     * Copy of the dataStore registry.
+     */
+    DataStore.getAllStores = function () {
+        return merge(DataStore.registry);
+    };
+    /**
+     * Extracts the name from a given dataStore class.
+     *
+     * @param {DataStore} dataStore
+     * DataStore class to extract the name from.
+     *
+     * @return {string}
+     * DataStore name, if the extraction was successful, otherwise an empty
+     * string.
+     */
+    DataStore.getName = function (dataStore) {
+        return (dataStore.toString().match(DataStore.nameRegExp) ||
+            ['', ''])[1];
+    };
+    /**
+     * Returns a dataStore class (aka class constructor) of the given dataStore
+     * name.
+     *
+     * @param {string} name
+     * Registered class name of the class type.
+     *
+     * @return {DataStoreRegistryType|undefined}
+     * Class type, if the class name was found, otherwise `undefined`.
+     */
+    DataStore.getStore = function (name) {
+        return DataStore.registry[name];
+    };
+    /* *
+     *
+     *  Functions
+     *
+     * */
+    /**
+     * Method for adding metadata for a single column.
+     *
+     * @param {string} name
+     * The name of the column to be described.
+     *
+     * @param {DataStore.MetaColumn} columnMeta
+     * The metadata to apply to the column.
+     */
+    DataStore.prototype.describeColumn = function (name, columnMeta) {
+        var store = this, columns = store.metadata.columns;
+        columns[name] = merge(columns[name] || {}, columnMeta);
+    };
+    /**
+     * Method for applying columns meta information to the whole datastore.
+     *
+     * @param {Record<string, DataStore.MetaColumn>} columns
+     * Pairs of column names and MetaColumn objects.
+     */
+    DataStore.prototype.describeColumns = function (columns) {
+        var store = this, columnNames = Object.keys(columns);
+        var columnName;
+        while (typeof (columnName = columnNames.pop()) === 'string') {
+            store.describeColumn(columnName, columns[columnName]);
+        }
+    };
+    /**
+     * Emits an event on the store to all registered callbacks of this event.
+     *
+     * @param {DataStore.Event} [e]
+     * Event object containing additional event information.
+     */
+    DataStore.prototype.emit = function (e) {
+        fireEvent(this, e.type, e);
+    };
+    /**
+     * Returns the order of columns.
+     *
+     * @param {boolean} [usePresentationState]
+     * Whether to use the column order of the presentation state of the table.
+     *
+     * @return {Array<string>}
+     * Order of columns.
+     */
+    DataStore.prototype.getColumnOrder = function (usePresentationState) {
+        var store = this, metadata = store.metadata, columns = metadata.columns, columnNames = Object.keys(columns), columnOrder = [];
+        var columnName;
+        for (var i = 0, iEnd = columnNames.length; i < iEnd; ++i) {
+            columnName = columnNames[i];
+            columnOrder[pick(columns[columnName].index, i)] = columnName;
+        }
+        return columnOrder;
+    };
+    /**
+     * Retrieves the columns of the the dataTable,
+     * applies column order from meta.
+     *
+     * @param {boolean} [usePresentationOrder]
+     * Whether to use the column order of the presentation state of the table.
+     *
+     * @return {{}}
+     * An object with the properties `columnNames` and `columnValues`
+     */
+    DataStore.prototype.getColumnsForExport = function (usePresentationOrder) {
+        var table = this.table, columnsRecord = table.getColumns(), columnNames = table.getColumnNames();
+        var columnOrder = this.getColumnOrder(usePresentationOrder);
+        if (columnOrder.length) {
+            columnNames.sort(function (a, b) {
+                if (columnOrder.indexOf(a) < columnOrder.indexOf(b)) {
+                    return 1;
+                }
+                if (columnOrder.indexOf(a) > columnOrder.indexOf(b)) {
+                    return -1;
+                }
+                return 0;
+            });
+        }
+        return ({
+            columnNames: columnNames,
+            columnValues: columnNames.map(function (name) { return columnsRecord[name]; })
+        });
+    };
+    /**
+     * The default load method, which fires the `afterLoad` event
+     * @emits DataStore#afterLoad
+     */
+    DataStore.prototype.load = function () {
+        fireEvent(this, 'afterLoad', { table: this.table });
+    };
+    /**
+     * Registers a callback for a specific store event.
+     *
+     * @param {string} type
+     * Event type as a string.
+     *
+     * @param {DataEventEmitter.EventCallback} callback
+     * Function to register for the store callback.
+     *
+     * @return {Function}
+     * Function to unregister callback from the store event.
+     */
+    DataStore.prototype.on = function (type, callback) {
+        return addEvent(this, type, callback);
+    };
+    /**
+     * Sets the index and order of columns.
+     *
+     * @param {Array<string>} columnNames
+     * Order of columns.
+     */
+    DataStore.prototype.setColumnOrder = function (columnNames) {
+        var store = this;
+        for (var i = 0, iEnd = columnNames.length; i < iEnd; ++i) {
+            store.describeColumn(columnNames[i], { index: i });
+        }
+    };
+    /**
+     * Method for retriving metadata from a single column.
+     *
+     * @param {string} name
+     * The identifier for the column that should be described
+     *
+     * @return {DataStore.MetaColumn | undefined}
+     * Returns a MetaColumn object if found.
+     */
+    DataStore.prototype.whatIs = function (name) {
+        return this.metadata.columns[name];
+    };
+    /* *
+     *
+     *  Static Properties
+     *
+     * */
+    /**
+     * Registry as a record object with store names and their class.
+     */
+    DataStore.registry = {};
+    /**
+     * Regular expression to extract the store name (group 1) from the
+     * stringified class type.
+     */
+    DataStore.nameRegExp = (/^function\s+(\w*?)(?:DataStore)?\s*\(/);
+    return DataStore;
+}());
+/* *
+ *
+ *  Export
+ *
+ * */
+export default DataStore;