highcharts 9.2.0 → 9.3.1

package/es-modules/Data/Modifiers/GroupModifier.js

@@ -0,0 +1,144 @@
+/* *
+ *
+ *  (c) 2020-2021 Highsoft AS
+ *
+ *  License: www.highcharts.com/license
+ *
+ *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+ *
+ *  Authors:
+ *  - 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 __());
+    };
+})();
+import DataModifier from './DataModifier.js';
+import DataTable from '../DataTable.js';
+import U from '../../Core/Utilities.js';
+var merge = U.merge;
+/* *
+ *
+ *  Class
+ *
+ * */
+/**
+ * Groups table rows into subtables depending on column values.
+ *
+ * @private
+ */
+var GroupModifier = /** @class */ (function (_super) {
+    __extends(GroupModifier, _super);
+    /* *
+     *
+     *  Constructors
+     *
+     * */
+    /**
+     * Constructs an instance of the group modifier.
+     *
+     * @param {GroupModifier.Options} [options]
+     * Options to configure the group modifier.
+     */
+    function GroupModifier(options) {
+        var _this = _super.call(this) || this;
+        _this.options = merge(GroupModifier.defaultOptions, options);
+        return _this;
+    }
+    /* *
+     *
+     *  Functions
+     *
+     * */
+    /**
+     * Applies modifications to the table rows and returns a new table with
+     * subtable, containing the grouped rows. The rows of the new table contain
+     * three columns:
+     * - `groupBy`: Column name used to group rows by.
+     * - `table`: Subtable containing the grouped rows.
+     * - `value`: containing the common value of the group
+     *
+     * @param {DataTable} table
+     * Table to modify.
+     *
+     * @param {DataEventEmitter.EventDetail} [eventDetail]
+     * Custom information for pending events.
+     *
+     * @return {DataTable}
+     * Table with `modified` property as a reference.
+     */
+    GroupModifier.prototype.modifyTable = function (table, eventDetail) {
+        var modifier = this;
+        modifier.emit({ type: 'modify', detail: eventDetail, table: table });
+        var byGroups = [], tableGroups = [], valueGroups = [], groupColumn = (modifier.options.groupColumn ||
+            table.getColumnNames()[0]), valueColumn = (table.getColumn(groupColumn) ||
+            []), _a = modifier.options, invalidValues = _a.invalidValues, validValues = _a.validValues, modified = table.modified = table.clone(true, eventDetail);
+        var value, valueIndex;
+        for (var i = 0, iEnd = valueColumn.length; i < iEnd; ++i) {
+            value = valueColumn[i];
+            if (typeof value !== 'undefined') {
+                if (value instanceof DataTable ||
+                    (invalidValues &&
+                        invalidValues.indexOf(value) >= 0) || (validValues &&
+                    validValues.indexOf(value) === -1)) {
+                    continue;
+                }
+                valueIndex = valueGroups.indexOf(value);
+                if (valueIndex === -1) {
+                    var newTable = new DataTable();
+                    newTable.setRows([table.getRowObject(i) || {}]);
+                    byGroups.push(groupColumn);
+                    tableGroups.push(newTable);
+                    valueGroups.push(value);
+                }
+                else {
+                    tableGroups[valueIndex].setRows([table.getRow(i) || []]);
+                }
+            }
+        }
+        modified.deleteColumns();
+        modified.setColumns({
+            groupBy: byGroups,
+            table: tableGroups,
+            value: valueGroups
+        });
+        modifier.emit({ type: 'afterModify', detail: eventDetail, table: table });
+        return table;
+    };
+    /* *
+     *
+     *  Static Properties
+     *
+     * */
+    /**
+     * Default options to group table rows.
+     */
+    GroupModifier.defaultOptions = {
+        modifier: 'Group',
+        groupColumn: ''
+    };
+    return GroupModifier;
+}(DataModifier));
+/* *
+ *
+ *  Register
+ *
+ * */
+DataModifier.addModifier(GroupModifier);
+/* *
+ *
+ *  Export
+ *
+ * */
+export default GroupModifier;

package/es-modules/Data/Modifiers/InvertModifier.js

@@ -0,0 +1,254 @@
+/* *
+ *
+ *  (c) 2020-2021 Highsoft AS
+ *
+ *  License: www.highcharts.com/license
+ *
+ *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+ *
+ *  Authors:
+ *  - Wojciech Chmiel
+ *  - 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 __());
+    };
+})();
+import DataModifier from './DataModifier.js';
+import U from '../../Core/Utilities.js';
+var merge = U.merge;
+/* *
+ *
+ *  Class
+ *
+ * */
+/**
+ * Inverts columns and rows in a table.
+ *
+ * @private
+ */
+var InvertModifier = /** @class */ (function (_super) {
+    __extends(InvertModifier, _super);
+    /* *
+     *
+     *  Constructor
+     *
+     * */
+    /**
+     * Constructs an instance of the invert modifier.
+     *
+     * @param {InvertModifier.Options} [options]
+     * Options to configure the invert modifier.
+     */
+    function InvertModifier(options) {
+        var _this = _super.call(this) || this;
+        _this.options = merge(InvertModifier.defaultOptions, options);
+        return _this;
+    }
+    /* *
+     *
+     *  Functions
+     *
+     * */
+    /**
+     * Applies partial modifications of a cell change to the property `modified`
+     * of the given modified table.
+     *
+     * @param {Highcharts.DataTable} table
+     * Modified table.
+     *
+     * @param {string} columnName
+     * Column name of changed cell.
+     *
+     * @param {number|undefined} rowIndex
+     * Row index of changed cell.
+     *
+     * @param {Highcharts.DataTableCellType} cellValue
+     * Changed cell value.
+     *
+     * @param {Highcharts.DataTableEventDetail} [eventDetail]
+     * Custom information for pending events.
+     *
+     * @return {Highcharts.DataTable}
+     * Table with `modified` property as a reference.
+     */
+    InvertModifier.prototype.modifyCell = function (table, columnName, rowIndex, cellValue, eventDetail) {
+        var modified = table.modified, modifiedRowIndex = modified.getRowIndexBy('columnNames', columnName);
+        if (typeof modifiedRowIndex === 'undefined') {
+            modified.setColumns(this.modifyTable(table.clone()).getColumns(), void 0, eventDetail);
+        }
+        else {
+            modified.setCell("" + rowIndex, modifiedRowIndex, cellValue, eventDetail);
+        }
+        return table;
+    };
+    /**
+     * Applies partial modifications of column changes to the property
+     * `modified` of the given table.
+     *
+     * @param {Highcharts.DataTable} table
+     * Modified table.
+     *
+     * @param {Highcharts.DataTableColumnCollection} columns
+     * Changed columns as a collection, where the keys are the column names.
+     *
+     * @param {number} [rowIndex=0]
+     * Index of the first changed row.
+     *
+     * @param {Highcharts.DataTableEventDetail} [eventDetail]
+     * Custom information for pending events.
+     *
+     * @return {Highcharts.DataTable}
+     * Table with `modified` property as a reference.
+     */
+    InvertModifier.prototype.modifyColumns = function (table, columns, rowIndex, eventDetail) {
+        var modified = table.modified, modifiedColumnNames = (modified.getColumn('columnNames') || []);
+        var columnNames = table.getColumnNames(), reset = (table.getRowCount() !== modifiedColumnNames.length);
+        if (!reset) {
+            for (var i = 0, iEnd = columnNames.length; i < iEnd; ++i) {
+                if (columnNames[i] !== modifiedColumnNames[i]) {
+                    reset = true;
+                    break;
+                }
+            }
+        }
+        if (reset) {
+            return this.modifyTable(table, eventDetail);
+        }
+        columnNames = Object.keys(columns);
+        for (var i = 0, iEnd = columnNames.length, column = void 0, columnName = void 0, modifiedRowIndex = void 0; i < iEnd; ++i) {
+            columnName = columnNames[i];
+            column = columns[columnName];
+            modifiedRowIndex = (modified.getRowIndexBy('columnNames', columnName) ||
+                modified.getRowCount());
+            for (var j = 0, j2 = rowIndex, jEnd = column.length; j < jEnd; ++j, ++j2) {
+                modified.setCell("" + j2, modifiedRowIndex, column[j], eventDetail);
+            }
+        }
+        return table;
+    };
+    /**
+     * Applies partial modifications of row changes to the property `modified`
+     * of the given table.
+     *
+     * @param {Highcharts.DataTable} table
+     * Modified table.
+     *
+     * @param {Array<(Highcharts.DataTableRow|Highcharts.DataTableRowObject)>} rows
+     * Changed rows.
+     *
+     * @param {number} [rowIndex]
+     * Index of the first changed row.
+     *
+     * @param {Highcharts.DataTableEventDetail} [eventDetail]
+     * Custom information for pending events.
+     *
+     * @return {Highcharts.DataTable}
+     * Table with `modified` property as a reference.
+     */
+    InvertModifier.prototype.modifyRows = function (table, rows, rowIndex, eventDetail) {
+        var columnNames = table.getColumnNames(), modified = table.modified, modifiedColumnNames = (modified.getColumn('columnNames') || []);
+        var reset = (table.getRowCount() !== modifiedColumnNames.length);
+        if (!reset) {
+            for (var i = 0, iEnd = columnNames.length; i < iEnd; ++i) {
+                if (columnNames[i] !== modifiedColumnNames[i]) {
+                    reset = true;
+                    break;
+                }
+            }
+        }
+        if (reset) {
+            return this.modifyTable(table, eventDetail);
+        }
+        for (var i = 0, i2 = rowIndex, iEnd = rows.length, row = void 0; i < iEnd; ++i, ++i2) {
+            row = rows[i];
+            if (row instanceof Array) {
+                modified.setColumn("" + i2, row);
+            }
+            else {
+                for (var j = 0, jEnd = columnNames.length; j < jEnd; ++j) {
+                    modified.setCell("" + i2, j, row[columnNames[j]], eventDetail);
+                }
+            }
+        }
+        return table;
+    };
+    /**
+     * Inverts rows and columns in the table.
+     *
+     * @param {DataTable} table
+     * Table to invert.
+     *
+     * @param {DataEventEmitter.EventDetail} [eventDetail]
+     * Custom information for pending events.
+     *
+     * @return {DataTable}
+     * Table with inverted `modified` property as a reference.
+     */
+    InvertModifier.prototype.modifyTable = function (table, eventDetail) {
+        var modifier = this;
+        modifier.emit({ type: 'modify', detail: eventDetail, table: table });
+        var modified = table.modified;
+        if (table.hasColumns(['columnNames'])) { // inverted table
+            var columnNames = ((table.deleteColumns(['columnNames']) || {})
+                .columnNames || []).map(function (column) { return "" + column; }), columns = {};
+            for (var i = 0, iEnd = table.getRowCount(), row = void 0; i < iEnd; ++i) {
+                row = table.getRow(i);
+                if (row) {
+                    columns[columnNames[i]] = row;
+                }
+            }
+            modified.deleteColumns();
+            modified.setColumns(columns);
+        }
+        else { // regular table
+            var columns = {};
+            for (var i = 0, iEnd = table.getRowCount(), row = void 0; i < iEnd; ++i) {
+                row = table.getRow(i);
+                if (row) {
+                    columns["" + i] = row;
+                }
+            }
+            columns.columnNames = table.getColumnNames();
+            modified.deleteColumns();
+            modified.setColumns(columns);
+        }
+        modifier.emit({ type: 'afterModify', detail: eventDetail, table: table });
+        return table;
+    };
+    /* *
+     *
+     *  Static Properties
+     *
+     * */
+    /**
+     * Default options for the invert modifier.
+     */
+    InvertModifier.defaultOptions = {
+        modifier: 'InvertModifier'
+    };
+    return InvertModifier;
+}(DataModifier));
+/* *
+ *
+ *  Register
+ *
+ * */
+DataModifier.addModifier(InvertModifier);
+/* *
+ *
+ *  Export
+ *
+ * */
+export default InvertModifier;

package/es-modules/Data/Modifiers/RangeModifier.js

@@ -0,0 +1,143 @@
+/* *
+ *
+ *  (c) 2020-2021 Highsoft AS
+ *
+ *  License: www.highcharts.com/license
+ *
+ *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+ *
+ *  Authors:
+ *  - 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 __());
+    };
+})();
+import DataModifier from './DataModifier.js';
+import U from '../../Core/Utilities.js';
+var merge = U.merge;
+/* *
+ *
+ *  Class
+ *
+ * */
+/**
+ * Filters out table rows with a specific value range.
+ *
+ * @private
+ */
+var RangeModifier = /** @class */ (function (_super) {
+    __extends(RangeModifier, _super);
+    /* *
+     *
+     *  Constructor
+     *
+     * */
+    /**
+     * Constructs an instance of the range modifier.
+     *
+     * @param {RangeModifier.Options} [options]
+     * Options to configure the range modifier.
+     */
+    function RangeModifier(options) {
+        var _this = _super.call(this) || this;
+        _this.options = merge(RangeModifier.defaultOptions, options);
+        return _this;
+    }
+    /* *
+     *
+     *  Functions
+     *
+     * */
+    /**
+     * Replaces table rows with filtered rows.
+     *
+     * @param {DataTable} table
+     * Table to modify.
+     *
+     * @param {DataEventEmitter.EventDetail} [eventDetail]
+     * Custom information for pending events.
+     *
+     * @return {DataTable}
+     * Table with `modified` property as a reference.
+     */
+    RangeModifier.prototype.modifyTable = function (table, eventDetail) {
+        var modifier = this;
+        modifier.emit({ type: 'modify', detail: eventDetail, table: table });
+        var _a = modifier.options, ranges = _a.ranges, strict = _a.strict;
+        if (ranges.length) {
+            var columns = table.getColumns(), rows = [], modified = table.modified;
+            for (var i = 0, iEnd = ranges.length, range = void 0, rangeColumn = void 0; i < iEnd; ++i) {
+                range = ranges[i];
+                if (strict &&
+                    typeof range.minValue !== typeof range.maxValue) {
+                    continue;
+                }
+                rangeColumn = (columns[range.column] || []);
+                for (var j = 0, jEnd = rangeColumn.length, cell = void 0, row = void 0; j < jEnd; ++j) {
+                    cell = rangeColumn[j];
+                    switch (typeof cell) {
+                        default:
+                            continue;
+                        case 'boolean':
+                        case 'number':
+                        case 'string':
+                            break;
+                    }
+                    if (strict &&
+                        typeof cell !== typeof range.minValue) {
+                        continue;
+                    }
+                    if (cell >= range.minValue &&
+                        cell <= range.maxValue) {
+                        row = table.getRow(j);
+                        if (row) {
+                            rows.push(row);
+                        }
+                    }
+                }
+            }
+            modified.deleteRows();
+            modified.setRows(rows);
+        }
+        modifier.emit({ type: 'afterModify', detail: eventDetail, table: table });
+        return table;
+    };
+    /* *
+     *
+     *  Static Properties
+     *
+     * */
+    /**
+     * Default options for the range modifier.
+     */
+    RangeModifier.defaultOptions = {
+        modifier: 'Range',
+        strict: false,
+        ranges: []
+    };
+    return RangeModifier;
+}(DataModifier));
+/* *
+ *
+ *  Register
+ *
+ * */
+DataModifier.addModifier(RangeModifier);
+/* *
+ *
+ *  Export
+ *
+ * */
+export default RangeModifier;

package/es-modules/Data/Modifiers/SeriesPointsModifier.js

@@ -0,0 +1,110 @@
+/* *
+ *
+ *  (c) 2020-2021 Highsoft AS
+ *
+ *  License: www.highcharts.com/license
+ *
+ *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+ *
+ *  Authors:
+ *  - Wojciech Chmiel
+ *  - 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 __());
+    };
+})();
+import DataModifier from './DataModifier.js';
+import U from '../../Core/Utilities.js';
+var merge = U.merge;
+/* *
+ *
+ *  Class
+ *
+ * */
+/**
+ * @private
+ */
+var SeriesPointsModifier = /** @class */ (function (_super) {
+    __extends(SeriesPointsModifier, _super);
+    /* *
+     *
+     *  Constructor
+     *
+     * */
+    /**
+     * Constructs an instance of the series points modifier.
+     *
+     * @param {SeriesPointsModifier.Options} [options]
+     * Options to configure the series points modifier.
+     */
+    function SeriesPointsModifier(options) {
+        var _this = _super.call(this) || this;
+        _this.options = merge(SeriesPointsModifier.defaultOptions, options);
+        return _this;
+    }
+    /* *
+     *
+     *  Functions
+     *
+     * */
+    /**
+     * Renames columns to alternative column names (alias) depending on mapping
+     * option.
+     *
+     * @param {DataTable} table
+     * Table to modify.
+     *
+     * @param {DataEventEmitter.EventDetail} [eventDetail]
+     * Custom information for pending events.
+     *
+     * @return {DataTable}
+     * Table with `modified` property as a reference.
+     */
+    SeriesPointsModifier.prototype.modifyTable = function (table, eventDetail) {
+        var modifier = this;
+        modifier.emit({ type: 'modify', detail: eventDetail, table: table });
+        var aliasMap = modifier.options.aliasMap || {}, aliases = Object.keys(aliasMap), modified = table.modified = table.clone(false, eventDetail);
+        for (var i = 0, iEnd = aliases.length, alias = void 0; i < iEnd; ++i) {
+            alias = aliases[i];
+            modified.renameColumn(aliasMap[alias], alias);
+        }
+        modifier.emit({ type: 'afterModify', detail: eventDetail, table: table });
+        return table;
+    };
+    /* *
+     *
+     *  Static Properties
+     *
+     * */
+    /**
+     * Default options for the series points modifier.
+     */
+    SeriesPointsModifier.defaultOptions = {
+        modifier: 'SeriesPoints'
+    };
+    return SeriesPointsModifier;
+}(DataModifier));
+/* *
+ *
+ *  Register
+ *
+ * */
+DataModifier.addModifier(SeriesPointsModifier);
+/* *
+ *
+ *  Export
+ *
+ * */
+export default SeriesPointsModifier;