highcharts 12.2.0 → 12.4.0

package/esm/modules/data-tools.src.js

@@ -1,5 +1,5 @@
 /**
- * @license Highcharts JS v12.2.0 (2025-04-07)
+ * @license Highcharts JS v12.4.0 (2025-09-04)
  * @module highcharts/modules/data-tools
  * @requires highcharts
  *
@@ -170,7 +170,7 @@ class DataModifier {
                     detail: eventDetail,
                     table
                 });
-                reject(e);
+                reject(e instanceof Error ? e : new Error('' + e));
             }
         });
     }
@@ -1212,8 +1212,7 @@ class DataTable extends Data_DataTableCore {
      * Returns all column names.
      */
     getColumnNames() {
-        const table = this, columnNames = Object.keys(table.columns);
-        return columnNames;
+        return Object.keys(this.columns);
     }
     /**
      * Retrieves all or the given columns.
@@ -1915,10 +1914,38 @@ class DataConnector {
      *
      * @param {DataConnector.UserOptions} [options]
      * Options to use in the connector.
+     *
+     * @param {Array<DataTableOptions>} [dataTables]
+     * Multiple connector data tables options.
      */
-    constructor(options = {}) {
-        this.table = new Data_DataTable(options.dataTable);
+    constructor(options = {}, dataTables = []) {
+        /**
+         * Tables managed by this DataConnector instance.
+         */
+        this.dataTables = {};
+        /**
+         * Helper flag for detecting whether the data connector is loaded.
+         * @internal
+         */
+        this.loaded = false;
         this.metadata = options.metadata || { columns: {} };
+        // Create a data table for each defined in the dataTables user options.
+        let dataTableIndex = 0;
+        if (dataTables?.length > 0) {
+            for (let i = 0, iEnd = dataTables.length; i < iEnd; ++i) {
+                const dataTable = dataTables[i];
+                const key = dataTable?.key;
+                this.dataTables[key ?? dataTableIndex] =
+                    new Data_DataTable(dataTable);
+                if (!key) {
+                    dataTableIndex++;
+                }
+            }
+            // If user options dataTables is not defined, generate a default table.
+        }
+        else {
+            this.dataTables[0] = new Data_DataTable(options.dataTable);
+        }
     }
     /**
      * Poll timer ID, if active.
@@ -1926,6 +1953,15 @@ class DataConnector {
     get polling() {
         return !!this._polling;
     }
+    /**
+     * Gets the first data table.
+     *
+     * @return {DataTable}
+     * The data table instance.
+     */
+    get table() {
+        return this.getTable();
+    }
     /* *
      *
      *  Functions
@@ -1984,6 +2020,22 @@ class DataConnector {
             return names.sort((a, b) => (pick(columns[a].index, 0) - pick(columns[b].index, 0)));
         }
     }
+    /**
+     * Returns a single data table instance based on the provided key.
+     * Otherwise, returns the first data table.
+     *
+     * @param {string} [key]
+     * The data table key.
+     *
+     * @return {DataTable}
+     * The data table instance.
+     */
+    getTable(key) {
+        if (key) {
+            return this.dataTables[key];
+        }
+        return Object.values(this.dataTables)[0];
+    }
     /**
      * Retrieves the columns of the dataTable,
      * applies column order from meta.
@@ -2049,14 +2101,17 @@ class DataConnector {
             connector.describeColumn(columnNames[i], { index: i });
         }
     }
-    setModifierOptions(modifierOptions) {
-        const ModifierClass = (modifierOptions &&
-            Modifiers_DataModifier.types[modifierOptions.type]);
-        return this.table
-            .setModifier(ModifierClass ?
-            new ModifierClass(modifierOptions) :
-            void 0)
-            .then(() => this);
+    async setModifierOptions(modifierOptions, tablesOptions) {
+        for (const [key, table] of Object.entries(this.dataTables)) {
+            const tableOptions = tablesOptions?.find((dataTable) => dataTable.key === key);
+            const mergedModifierOptions = DataConnector_merge(tableOptions?.dataModifier, modifierOptions);
+            const ModifierClass = (mergedModifierOptions &&
+                Modifiers_DataModifier.types[mergedModifierOptions.type]);
+            await table.setModifier(ModifierClass ?
+                new ModifierClass(mergedModifierOptions) :
+                void 0);
+        }
+        return this;
     }
     /**
      * Starts polling new data after the specific time span in milliseconds.
@@ -2066,12 +2121,16 @@ class DataConnector {
      */
     startPolling(refreshTime = 1000) {
         const connector = this;
+        const tables = connector.dataTables;
+        // Assign a new abort controller.
+        this.pollingController = new AbortController();
+        // Clear the polling timeout.
         window.clearTimeout(connector._polling);
         connector._polling = window.setTimeout(() => connector
             .load()['catch']((error) => connector.emit({
             type: 'loadError',
             error,
-            table: connector.table
+            tables
         }))
             .then(() => {
             if (connector._polling) {
@@ -2080,10 +2139,16 @@ class DataConnector {
         }), refreshTime);
     }
     /**
-     * Stops polling data.
+     * Stops polling data. Shouldn't be performed if polling is already stopped.
      */
     stopPolling() {
         const connector = this;
+        if (!connector.polling) {
+            return;
+        }
+        // Abort the existing request.
+        connector?.pollingController?.abort();
+        // Clear the polling timeout.
         window.clearTimeout(connector._polling);
         delete connector._polling;
     }
@@ -2099,6 +2164,35 @@ class DataConnector {
     whatIs(name) {
         return this.metadata.columns[name];
     }
+    /**
+     * Iterates over the dataTables and initiates the corresponding converters.
+     * Updates the dataTables and assigns the first converter.
+     *
+     * @param {T}[data]
+     * Data specific to the corresponding converter.
+     *
+     * @param {DataConnector.CreateConverterFunction}[createConverter]
+     * Creates a specific converter combining the dataTable options.
+     *
+     * @param {DataConnector.ParseDataFunction<T>}[parseData]
+     * Runs the converter parse method with the specific data type.
+     */
+    initConverters(data, createConverter, parseData) {
+        let index = 0;
+        for (const [key, table] of Object.entries(this.dataTables)) {
+            // Create a proper converter and parse its data.
+            const converter = createConverter(key, table);
+            parseData(converter, data);
+            // Update the dataTable.
+            table.deleteColumns();
+            table.setColumns(converter.getTable().getColumns());
+            // Assign the first converter.
+            if (index === 0) {
+                this.converter = converter;
+            }
+            index++;
+        }
+    }
 }
 /* *
  *
@@ -3272,7 +3366,7 @@ class DataPool {
     getConnector(connectorId) {
         const connector = this.connectors[connectorId];
         // Already loaded
-        if (connector) {
+        if (connector?.loaded) {
             return Promise.resolve(connector);
         }
         let waitingList = this.waiting[connectorId];
@@ -3387,12 +3481,14 @@ class DataPool {
             if (!ConnectorClass) {
                 throw new Error(`Connector type not found. (${options.type})`);
             }
-            const connector = new ConnectorClass(options.options);
+            const connector = this.connectors[options.id] = new ConnectorClass(options.options, options.dataTables);
             // eslint-disable-next-line @typescript-eslint/no-floating-promises
             connector
                 .load()
-                .then((connector) => {
-                this.connectors[options.id] = connector;
+                .then(({ converter, dataTables }) => {
+                connector.dataTables = dataTables;
+                connector.converter = converter;
+                connector.loaded = true;
                 this.emit({
                     type: 'afterLoad',
                     options
@@ -3401,6 +3497,15 @@ class DataPool {
             })['catch'](reject);
         });
     }
+    /**
+     * Cancels all data connectors pending requests.
+     */
+    cancelPendingRequests() {
+        const { connectors } = this;
+        for (const connectorKey of Object.keys(connectors)) {
+            connectors[connectorKey].stopPolling();
+        }
+    }
     /**
      * Registers a callback for a specific event.
      *
@@ -3478,6 +3583,8 @@ DataPool.version = '1.0.0';
  *
  * */
 
+
+const { isString } = (external_highcharts_src_js_default_default());
 /* *
  *
  *  Constants
@@ -3757,6 +3864,20 @@ function parseArguments(text, alternativeSeparators) {
     }
     return args;
 }
+/**
+ * Checks if there's one of the following operator before the negative number
+ * value: '*', '/' or '^'.
+ *
+ * Used to properly indicate a negative value reference or negate a directly
+ * passed number value.
+ */
+function negativeReference(formula) {
+    const formulaLength = formula.length;
+    const priorFormula = formula[formulaLength - 2];
+    return (formula[formulaLength - 1] === '-' &&
+        isString(priorFormula) &&
+        !!priorFormula.match(/\*|\/|\^/));
+}
 /**
  * Converts a spreadsheet formula string into a formula array. Throws a
  * `FormulaParserError` when the string can not be parsed.
@@ -3800,6 +3921,10 @@ function parseFormula(text, alternativeSeparators) {
             if (rowRelative) {
                 reference.rowRelative = true;
             }
+            if (negativeReference(formula)) {
+                formula.pop();
+                reference.isNegative = true;
+            }
             formula.push(reference);
             next = next.substring(match[0].length).trim();
             continue;
@@ -3824,6 +3949,10 @@ function parseFormula(text, alternativeSeparators) {
             if (rowRelative) {
                 reference.rowRelative = true;
             }
+            if (negativeReference(formula)) {
+                formula.pop();
+                reference.isNegative = true;
+            }
             formula.push(reference);
             next = next.substring(match[0].length).trim();
             continue;
@@ -3845,7 +3974,15 @@ function parseFormula(text, alternativeSeparators) {
         // Check for a number value
         match = next.match(decimalRegExp);
         if (match) {
-            formula.push(parseFloat(match[0]));
+            let number = parseFloat(match[0]);
+            // If the current value is multiplication-related and the previous
+            // one is a minus sign, set the current value to negative and remove
+            // the minus sign.
+            if (negativeReference(formula)) {
+                formula.pop();
+                number = -number;
+            }
+            formula.push(number);
             next = next.substring(match[0].length).trim();
             continue;
         }
@@ -4075,6 +4212,8 @@ const MathFormula = {
 
 
 const { isFormula: FormulaProcessor_isFormula, isFunction: FormulaProcessor_isFunction, isOperator: FormulaProcessor_isOperator, isRange: FormulaProcessor_isRange, isReference: FormulaProcessor_isReference, isValue: FormulaProcessor_isValue } = FormulaTypes;
+
+const { defined: FormulaProcessor_defined } = (external_highcharts_src_js_default_default());
 /* *
  *
  *  Constants
@@ -4340,14 +4479,57 @@ function getReferenceValue(reference, table) {
             const result = table.modified.getCell(columnName, reference.row);
             return FormulaProcessor_isValue(result) ? result : NaN;
         }
-        return FormulaProcessor_isValue(cell) ? cell : NaN;
+        if (FormulaProcessor_isValue(cell)) {
+            return reference.isNegative ? -cell : cell;
+        }
+        return NaN;
     }
     return NaN;
 }
+/**
+ * Calculates a value based on the two top values and the related operator.
+ *
+ * Used to properly process the formula's values based on its operators.
+ *
+ * @private
+ * @function Highcharts.applyOperator
+ *
+ * @param {Array<Highcharts.Value>} values
+ * Processed formula values.
+ *
+ * @param {Array<Highcharts.Operator>} operators
+ * Processed formula operators.
+ */
+function applyOperator(values, operators) {
+    if (values.length < 2 || operators.length < 1) {
+        values.push(NaN);
+    }
+    const secondValue = values.pop();
+    const firstValue = values.pop();
+    const operator = operators.pop();
+    if (!FormulaProcessor_defined(secondValue) || !FormulaProcessor_defined(firstValue) || !FormulaProcessor_defined(operator)) {
+        values.push(NaN);
+    }
+    else {
+        values.push(basicOperation(operator, firstValue, secondValue));
+    }
+}
 /**
  * Processes a formula array on the given table. If the formula does not contain
  * references or ranges, then no table has to be provided.
  *
+ * Performs formulas considering the operators precedence.
+ *
+ * // Example of the `2 * 3 + 4` formula:
+ * 2 -> values: [2], operators: []
+ * * -> values: [2], operators: [*]
+ * 3 -> values: [2, 3], operators: [*]
+ * // Since the higher precedence operator exists (* > +), perform it first.
+ * + -> values: [6], operators: [+]
+ * 4 -> values: [6, 4], operators: [+]
+ * // When non-higher precedence operators remain, perform rest calculations.
+ * -> values: [10], operators: []
+ *
  * @private
  * @function Highcharts.processFormula
  *
@@ -4361,61 +4543,68 @@ function getReferenceValue(reference, table) {
  * Result value of the process. `NaN` indicates an error.
  */
 function processFormula(formula, table) {
-    let x;
-    for (let i = 0, iEnd = formula.length, item, operator, result, y; i < iEnd; ++i) {
-        item = formula[i];
-        // Remember operator for operation on next item
+    // Keeps all the values to calculate them in a proper priority, based on the
+    // given operators.
+    const values = [];
+    // Keeps all the operators to calculate the values above, following the
+    // proper priority.
+    const operators = [];
+    // Indicates if the next item is a value (not an operator).
+    let expectingValue = true;
+    for (let i = 0, iEnd = formula.length; i < iEnd; ++i) {
+        const item = formula[i];
         if (FormulaProcessor_isOperator(item)) {
-            operator = item;
+            if (expectingValue && item === '-') {
+                // Split the negative values to be handled as a binary
+                // operation if the next item is a value.
+                values.push(0);
+                operators.push('-');
+                expectingValue = true;
+            }
+            else {
+                // Perform if the higher precedence operator exist.
+                while (operators.length &&
+                    operatorPriority[operators[operators.length - 1]] >=
+                        operatorPriority[item]) {
+                    applyOperator(values, operators);
+                }
+                operators.push(item);
+                expectingValue = true;
+            }
             continue;
         }
-        // Next item is a value
+        let value;
+        // Assign the proper value, starting from the most common types.
         if (FormulaProcessor_isValue(item)) {
-            y = item;
-            // Next item is a formula and needs to get processed first
+            value = item;
         }
-        else if (FormulaProcessor_isFormula(item)) {
-            y = processFormula(formula, table);
-            // Next item is a function call and needs to get processed first
+        else if (FormulaProcessor_isReference(item)) {
+            value = table ? getReferenceValue(item, table) : NaN;
         }
         else if (FormulaProcessor_isFunction(item)) {
-            result = processFunction(item, table);
-            y = (FormulaProcessor_isValue(result) ? result : NaN); // Arrays are not allowed here
-            // Next item is a reference and needs to get resolved
+            const result = processFunction(item, table);
+            value = FormulaProcessor_isValue(result) ? result : NaN;
         }
-        else if (FormulaProcessor_isReference(item)) {
-            y = (table && getReferenceValue(item, table));
-        }
-        // If we have a next value, lets do the operation
-        if (typeof y !== 'undefined') {
-            // Next value is our first value
-            if (typeof x === 'undefined') {
-                if (operator) {
-                    x = basicOperation(operator, 0, y);
-                }
-                else {
-                    x = y;
-                }
-                // Fail fast if no operator available
-            }
-            else if (!operator) {
-                return NaN;
-                // Regular next value
-            }
-            else {
-                const operator2 = formula[i + 1];
-                if (FormulaProcessor_isOperator(operator2) &&
-                    operatorPriority[operator2] > operatorPriority[operator]) {
-                    y = basicOperation(operator2, y, processFormula(formula.slice(i + 2)));
-                    i = iEnd;
-                }
-                x = basicOperation(operator, x, y);
-            }
-            operator = void 0;
-            y = void 0;
+        else if (FormulaProcessor_isFormula(item)) {
+            value = processFormula(item, table);
         }
+        if (typeof value !== 'undefined') {
+            values.push(value);
+            expectingValue = false;
+        }
+        else {
+            return NaN;
+        }
+    }
+    // Handle the remaining operators that weren't taken into consideration, due
+    // to non-higher precedence.
+    while (operators.length) {
+        applyOperator(values, operators);
+    }
+    if (values.length !== 1) {
+        return NaN;
     }
-    return FormulaProcessor_isValue(x) ? x : NaN;
+    return values[0];
 }
 /**
  * Process a function on the given table. If the arguments do not contain
@@ -6389,7 +6578,7 @@ Converters_DataConverter.registerType('CSV', CSVConverter);
 
 
 
-const { merge: CSVConnector_merge } = (external_highcharts_src_js_default_default());
+const { merge: CSVConnector_merge, defined: CSVConnector_defined } = (external_highcharts_src_js_default_default());
 /* *
  *
  *  Class
@@ -6411,12 +6600,16 @@ class CSVConnector extends Connectors_DataConnector {
      *
      * @param {CSVConnector.UserOptions} [options]
      * Options for the connector and converter.
+     *
+     * @param {Array<DataTableOptions>} [dataTables]
+     * Multiple connector data tables options.
+     *
      */
-    constructor(options) {
+    constructor(options, dataTables) {
         const mergedOptions = CSVConnector_merge(CSVConnector.defaultOptions, options);
-        super(mergedOptions);
-        this.converter = new Converters_CSVConverter(mergedOptions);
-        this.options = mergedOptions;
+        super(mergedOptions, dataTables);
+        this.options = CSVConnector_defined(dataTables) ?
+            CSVConnector_merge(mergedOptions, { dataTables }) : mergedOptions;
         if (mergedOptions.enablePolling) {
             this.startPolling(Math.max(mergedOptions.dataRefreshRate || 0, 1) * 1000);
         }
@@ -6436,26 +6629,39 @@ class CSVConnector extends Connectors_DataConnector {
      * @emits CSVConnector#afterLoad
      */
     load(eventDetail) {
-        const connector = this, converter = connector.converter, table = connector.table, { csv, csvURL, dataModifier } = connector.options;
+        const connector = this, tables = connector.dataTables, { csv, csvURL, dataModifier, dataTables } = connector.options;
         connector.emit({
             type: 'load',
             csv,
             detail: eventDetail,
-            table
+            tables
         });
         return Promise
             .resolve(csvURL ?
-            fetch(csvURL).then((response) => response.text()) :
+            fetch(csvURL, {
+                signal: connector?.pollingController?.signal
+            }).then((response) => response.text()) :
             csv || '')
             .then((csv) => {
             if (csv) {
-                // If already loaded, clear the current rows
-                table.deleteColumns();
-                converter.parse({ csv });
-                table.setColumns(converter.getTable().getColumns());
+                this.initConverters(csv, (key) => {
+                    const options = this.options;
+                    const tableOptions = dataTables?.find((dataTable) => dataTable.key === key);
+                    // Takes over the connector default options.
+                    const mergedTableOptions = {
+                        dataTableKey: key,
+                        firstRowAsNames: tableOptions?.firstRowAsNames ??
+                            options.firstRowAsNames,
+                        beforeParse: tableOptions?.beforeParse ??
+                            options.beforeParse
+                    };
+                    return new Converters_CSVConverter(CSVConnector_merge(this.options, mergedTableOptions));
+                }, (converter, data) => {
+                    converter.parse({ csv: data });
+                });
             }
             return connector
-                .setModifierOptions(dataModifier)
+                .setModifierOptions(dataModifier, dataTables)
                 .then(() => csv);
         })
             .then((csv) => {
@@ -6463,7 +6669,7 @@ class CSVConnector extends Connectors_DataConnector {
                 type: 'afterLoad',
                 csv,
                 detail: eventDetail,
-                table
+                tables
             });
             return connector;
         })['catch']((error) => {
@@ -6471,7 +6677,7 @@ class CSVConnector extends Connectors_DataConnector {
                 type: 'loadError',
                 detail: eventDetail,
                 error,
-                table
+                tables
             });
             throw error;
         });
@@ -6670,7 +6876,6 @@ class JSONConverter extends Converters_DataConverter {
  */
 JSONConverter.defaultOptions = {
     ...Converters_DataConverter.defaultOptions,
-    data: [],
     orientation: 'rows'
 };
 Converters_DataConverter.registerType('JSON', JSONConverter);
@@ -6698,7 +6903,7 @@ Converters_DataConverter.registerType('JSON', JSONConverter);
 
 
 
-const { merge: JSONConnector_merge } = (external_highcharts_src_js_default_default());
+const { merge: JSONConnector_merge, defined: JSONConnector_defined } = (external_highcharts_src_js_default_default());
 /* *
  *
  *  Class
@@ -6720,12 +6925,15 @@ class JSONConnector extends Connectors_DataConnector {
      *
      * @param {JSONConnector.UserOptions} [options]
      * Options for the connector and converter.
+     *
+     * @param {Array<DataTableOptions>} [dataTables]
+     * Multiple connector data tables options.
      */
-    constructor(options) {
+    constructor(options, dataTables) {
         const mergedOptions = JSONConnector_merge(JSONConnector.defaultOptions, options);
-        super(mergedOptions);
-        this.converter = new Converters_JSONConverter(mergedOptions);
-        this.options = mergedOptions;
+        super(mergedOptions, dataTables);
+        this.options = JSONConnector_defined(dataTables) ?
+            JSONConnector_merge(mergedOptions, { dataTables }) : mergedOptions;
         if (mergedOptions.enablePolling) {
             this.startPolling(Math.max(mergedOptions.dataRefreshRate || 0, 1) * 1000);
         }
@@ -6745,40 +6953,58 @@ class JSONConnector extends Connectors_DataConnector {
      * @emits JSONConnector#afterLoad
      */
     load(eventDetail) {
-        const connector = this, converter = connector.converter, table = connector.table, { data, dataUrl, dataModifier } = connector.options;
+        const connector = this, tables = connector.dataTables, { data, dataUrl, dataModifier, dataTables } = connector.options;
         connector.emit({
             type: 'load',
             data,
             detail: eventDetail,
-            table
+            tables
         });
         return Promise
             .resolve(dataUrl ?
-            fetch(dataUrl).then((response) => response.json())['catch']((error) => {
+            fetch(dataUrl, {
+                signal: connector?.pollingController?.signal
+            }).then((response) => response.json())['catch']((error) => {
                 connector.emit({
                     type: 'loadError',
                     detail: eventDetail,
                     error,
-                    table
+                    tables
                 });
                 console.warn(`Unable to fetch data from ${dataUrl}.`); // eslint-disable-line no-console
             }) :
             data || [])
             .then((data) => {
             if (data) {
-                // If already loaded, clear the current rows
-                table.deleteColumns();
-                converter.parse({ data });
-                table.setColumns(converter.getTable().getColumns());
+                this.initConverters(data, (key) => {
+                    const options = this.options;
+                    const tableOptions = dataTables?.find((dataTable) => dataTable.key === key);
+                    // Takes over the connector default options.
+                    const mergedTableOptions = {
+                        dataTableKey: key,
+                        columnNames: tableOptions?.columnNames ??
+                            options.columnNames,
+                        firstRowAsNames: tableOptions?.firstRowAsNames ??
+                            options.firstRowAsNames,
+                        orientation: tableOptions?.orientation ??
+                            options.orientation,
+                        beforeParse: tableOptions?.beforeParse ??
+                            options.beforeParse
+                    };
+                    return new Converters_JSONConverter(JSONConnector_merge(this.options, mergedTableOptions));
+                }, (converter, data) => {
+                    converter.parse({ data });
+                });
             }
-            return connector.setModifierOptions(dataModifier).then(() => data);
+            return connector.setModifierOptions(dataModifier, dataTables)
+                .then(() => data);
         })
             .then((data) => {
             connector.emit({
                 type: 'afterLoad',
                 data,
                 detail: eventDetail,
-                table
+                tables
             });
             return connector;
         })['catch']((error) => {
@@ -6786,7 +7012,7 @@ class JSONConnector extends Connectors_DataConnector {
                 type: 'loadError',
                 detail: eventDetail,
                 error,
-                table
+                tables
             });
             throw error;
         });
@@ -6798,7 +7024,6 @@ class JSONConnector extends Connectors_DataConnector {
  *
  * */
 JSONConnector.defaultOptions = {
-    data: [],
     enablePolling: false,
     dataRefreshRate: 0,
     firstRowAsNames: true,
@@ -6971,7 +7196,7 @@ Converters_DataConverter.registerType('GoogleSheets', GoogleSheetsConverter);
 
 
 
-const { merge: GoogleSheetsConnector_merge, pick: GoogleSheetsConnector_pick } = (external_highcharts_src_js_default_default());
+const { merge: GoogleSheetsConnector_merge, pick: GoogleSheetsConnector_pick, defined: GoogleSheetsConnector_defined } = (external_highcharts_src_js_default_default());
 /* *
  *
  *  Functions
@@ -7008,12 +7233,16 @@ class GoogleSheetsConnector extends Connectors_DataConnector {
      *
      * @param {GoogleSheetsConnector.UserOptions} [options]
      * Options for the connector and converter.
+     *
+     * @param {Array<DataTableOptions>} [dataTables]
+     * Multiple connector data tables options.
+     *
      */
-    constructor(options) {
+    constructor(options, dataTables) {
         const mergedOptions = GoogleSheetsConnector_merge(GoogleSheetsConnector.defaultOptions, options);
-        super(mergedOptions);
-        this.converter = new Converters_GoogleSheetsConverter(mergedOptions);
-        this.options = mergedOptions;
+        super(mergedOptions, dataTables);
+        this.options = GoogleSheetsConnector_defined(dataTables) ?
+            GoogleSheetsConnector_merge(mergedOptions, { dataTables }) : mergedOptions;
     }
     /* *
      *
@@ -7030,36 +7259,44 @@ class GoogleSheetsConnector extends Connectors_DataConnector {
      * Same connector instance with modified table.
      */
     load(eventDetail) {
-        const connector = this, converter = connector.converter, table = connector.table, { dataModifier, dataRefreshRate, enablePolling, firstRowAsNames, googleAPIKey, googleSpreadsheetKey } = connector.options, url = GoogleSheetsConnector.buildFetchURL(googleAPIKey, googleSpreadsheetKey, connector.options);
+        const connector = this, tables = connector.dataTables, { dataModifier, dataRefreshRate, enablePolling, googleAPIKey, googleSpreadsheetKey, dataTables } = connector.options, url = GoogleSheetsConnector.buildFetchURL(googleAPIKey, googleSpreadsheetKey, connector.options);
         connector.emit({
             type: 'load',
             detail: eventDetail,
-            table,
+            tables,
             url
         });
         if (!URL.canParse(url)) {
             throw new Error('Invalid URL: ' + url);
         }
-        return fetch(url)
+        return fetch(url, { signal: connector?.pollingController?.signal })
             .then((response) => (response.json()))
             .then((json) => {
             if (isGoogleError(json)) {
                 throw new Error(json.error.message);
             }
-            converter.parse({
-                firstRowAsNames,
-                json
+            this.initConverters(json, (key) => {
+                const options = this.options;
+                const tableOptions = dataTables?.find((dataTable) => dataTable.key === key);
+                // Takes over the connector default options.
+                const mergedTableOptions = {
+                    dataTableKey: key,
+                    firstRowAsNames: tableOptions?.firstRowAsNames ??
+                        options.firstRowAsNames,
+                    beforeParse: tableOptions?.beforeParse ??
+                        options.beforeParse
+                };
+                return new Converters_GoogleSheetsConverter(GoogleSheetsConnector_merge(this.options, mergedTableOptions));
+            }, (converter, data) => {
+                converter.parse({ json: data });
             });
-            // If already loaded, clear the current table
-            table.deleteColumns();
-            table.setColumns(converter.getTable().getColumns());
-            return connector.setModifierOptions(dataModifier);
+            return connector.setModifierOptions(dataModifier, dataTables);
         })
             .then(() => {
             connector.emit({
                 type: 'afterLoad',
                 detail: eventDetail,
-                table,
+                tables,
                 url
             });
             // Polling
@@ -7072,7 +7309,7 @@ class GoogleSheetsConnector extends Connectors_DataConnector {
                 type: 'loadError',
                 detail: eventDetail,
                 error,
-                table
+                tables
             });
             throw error;
         });
@@ -7345,7 +7582,7 @@ class HTMLTableConverter extends Converters_DataConverter {
     getTableHeaderHTML(topheaders = [], subheaders = [], options = this.options) {
         const { useMultiLevelHeaders, useRowspanHeaders } = options;
         let html = '<thead>', i = 0, len = subheaders && subheaders.length, next, cur, curColspan = 0, rowspan;
-        // Clean up multiple table headers. Chart.getDataRows() returns two
+        // Clean up multiple table headers. Exporting.getDataRows() returns two
         // levels of headers when using multilevel, not merged. We need to
         // merge identical headers, remove redundant headers, and keep it
         // all marked up nicely.
@@ -7373,7 +7610,7 @@ class HTMLTableConverter extends Converters_DataConverter {
                     if (cur === subheaders[i]) {
                         if (useRowspanHeaders) {
                             rowspan = 2;
-                            delete subheaders[i];
+                            subheaders.splice(i, 1);
                         }
                         else {
                             rowspan = 1;
@@ -7593,7 +7830,7 @@ class HTMLTableConnector extends Connectors_DataConnector {
         connector.emit({
             type: 'load',
             detail: eventDetail,
-            table,
+            tables: { table },
             tableElement: connector.tableElement
         });
         let tableElement;
@@ -7612,7 +7849,7 @@ class HTMLTableConnector extends Connectors_DataConnector {
                 type: 'loadError',
                 detail: eventDetail,
                 error,
-                table
+                tables: { table }
             });
             return Promise.reject(new Error(error));
         }
@@ -7626,7 +7863,7 @@ class HTMLTableConnector extends Connectors_DataConnector {
             connector.emit({
                 type: 'afterLoad',
                 detail: eventDetail,
-                table,
+                tables: { table },
                 tableElement: connector.tableElement
             });
             return connector;
@@ -8572,6 +8809,17 @@ class SortModifier extends Modifiers_DataModifier {
             (b || 0) > (a || 0) ? 1 :
                 0);
     }
+    static compareFactory(direction, customCompare) {
+        if (customCompare) {
+            if (direction === 'desc') {
+                return (a, b) => -customCompare(a, b);
+            }
+            return customCompare;
+        }
+        return (direction === 'asc' ?
+            SortModifier.ascending :
+            SortModifier.descending);
+    }
     /* *
      *
      *  Constructor
@@ -8745,9 +8993,7 @@ class SortModifier extends Modifiers_DataModifier {
     modifyTable(table, eventDetail) {
         const modifier = this;
         modifier.emit({ type: 'modify', detail: eventDetail, table });
-        const columnNames = table.getColumnNames(), rowCount = table.getRowCount(), rowReferences = this.getRowReferences(table), { direction, orderByColumn, orderInColumn } = modifier.options, compare = (direction === 'asc' ?
-            SortModifier.ascending :
-            SortModifier.descending), orderByColumnIndex = columnNames.indexOf(orderByColumn), modified = table.modified;
+        const columnNames = table.getColumnNames(), rowCount = table.getRowCount(), rowReferences = this.getRowReferences(table), { direction, orderByColumn, orderInColumn, compare: customCompare } = modifier.options, compare = SortModifier.compareFactory(direction, customCompare), orderByColumnIndex = columnNames.indexOf(orderByColumn), modified = table.modified;
         if (orderByColumnIndex !== -1) {
             rowReferences.sort((a, b) => compare(a.row[orderByColumnIndex], b.row[orderByColumnIndex]));
         }
@@ -8795,6 +9041,176 @@ Modifiers_DataModifier.registerType('Sort', SortModifier);
  * */
 /* harmony default export */ const Modifiers_SortModifier = ((/* unused pure expression or super */ null && (SortModifier)));
 
+;// ./code/es-modules/Data/Modifiers/FilterModifier.js
+/* *
+ *
+ *  (c) 2009-2025 Highsoft AS
+ *
+ *  License: www.highcharts.com/license
+ *
+ *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+ *
+ *  Authors:
+ *  - Dawid Dragula
+ *
+ * */
+
+
+
+const { isFunction: FilterModifier_isFunction, merge: FilterModifier_merge } = (external_highcharts_src_js_default_default());
+/* *
+ *
+ *  Class
+ *
+ * */
+/**
+ * Filters out table rows matching a given condition.
+ */
+class FilterModifier extends Modifiers_DataModifier {
+    /* *
+     *
+     *  Static Functions
+     *
+     * */
+    /**
+     * Compiles a filter condition into a callback function.
+     *
+     * @param {FilterCondition} condition
+     * Condition to compile.
+     */
+    static compile(condition) {
+        if (FilterModifier_isFunction(condition)) {
+            return condition;
+        }
+        const op = condition.operator;
+        switch (op) {
+            case 'and': {
+                const subs = condition.conditions.map((c) => this.compile(c));
+                return (row, table, i) => subs.every((cond) => cond(row, table, i));
+            }
+            case 'or': {
+                const subs = condition.conditions.map((c) => this.compile(c));
+                return (row, table, i) => subs.some((cond) => cond(row, table, i));
+            }
+            case 'not': {
+                const sub = this.compile(condition.condition);
+                return (row, table, i) => !sub(row, table, i);
+            }
+        }
+        const { columnName: col, value } = condition;
+        switch (op) {
+            case '==':
+                // eslint-disable-next-line eqeqeq
+                return (row) => row[col] == value;
+            case '===':
+                return (row) => row[col] === value;
+            case '!=':
+                // eslint-disable-next-line eqeqeq
+                return (row) => row[col] != value;
+            case '!==':
+                return (row) => row[col] !== value;
+            case '>':
+                return (row) => (row[col] || 0) > (value || 0);
+            case '>=':
+                return (row) => (row[col] || 0) >= (value || 0);
+            case '<':
+                return (row) => (row[col] || 0) < (value || 0);
+            case '<=':
+                return (row) => (row[col] || 0) <= (value || 0);
+        }
+        const { ignoreCase } = condition;
+        const str = (val) => {
+            const s = '' + val;
+            return (ignoreCase ?? true) ? s.toLowerCase() : s;
+        };
+        switch (op) {
+            case 'contains':
+                return (row) => str(row[col]).includes(str(value));
+            default:
+                return (row) => str(row[col])[op](str(value));
+        }
+    }
+    /* *
+     *
+     *  Constructor
+     *
+     * */
+    /**
+     * Constructs an instance of the filter modifier.
+     *
+     * @param {Partial<FilterModifier.Options>} [options]
+     * Options to configure the filter modifier.
+     */
+    constructor(options) {
+        super();
+        this.options = FilterModifier_merge(FilterModifier.defaultOptions, options);
+    }
+    /* *
+     *
+     *  Functions
+     *
+     * */
+    /**
+     * Replaces table rows with filtered rows.
+     *
+     * @param {DataTable} table
+     * Table to modify.
+     *
+     * @param {DataEvent.Detail} [eventDetail]
+     * Custom information for pending events.
+     *
+     * @return {DataTable}
+     * Table with `modified` property as a reference.
+     */
+    modifyTable(table, eventDetail) {
+        const modifier = this;
+        modifier.emit({ type: 'modify', detail: eventDetail, table });
+        const { condition } = modifier.options;
+        if (!condition) {
+            // If no condition is set, return the unmodified table.
+            return table;
+        }
+        const matchRow = FilterModifier.compile(condition);
+        // This line should be investigated further when reworking Data Layer.
+        const modified = table.modified;
+        const rows = [];
+        const indexes = [];
+        for (let i = 0, iEnd = table.getRowCount(); i < iEnd; ++i) {
+            const row = table.getRowObject(i);
+            if (!row) {
+                continue;
+            }
+            if (matchRow(row, table, i)) {
+                rows.push(row);
+                indexes.push(modified.getOriginalRowIndex(i));
+            }
+        }
+        modified.deleteRows();
+        modified.setRows(rows);
+        modified.setOriginalRowIndexes(indexes);
+        modifier.emit({ type: 'afterModify', detail: eventDetail, table });
+        return table;
+    }
+}
+/* *
+ *
+ *  Static Properties
+ *
+ * */
+/**
+ * Default options for the filter modifier.
+ */
+FilterModifier.defaultOptions = {
+    type: 'Filter'
+};
+Modifiers_DataModifier.registerType('Filter', FilterModifier);
+/* *
+ *
+ *  Default Export
+ *
+ * */
+/* harmony default export */ const Modifiers_FilterModifier = ((/* unused pure expression or super */ null && (FilterModifier)));
+
 ;// ./code/es-modules/masters/modules/data-tools.src.js
 
 
@@ -8815,6 +9231,7 @@ Modifiers_DataModifier.registerType('Sort', SortModifier);
 
 
 
+
 const G = (external_highcharts_src_js_default_default());
 G.DataConnector = G.DataConnector || Connectors_DataConnector;
 G.DataConverter = G.DataConverter || Converters_DataConverter;