handsontable 18.0.0 → 18.1.0-rc7

package/plugins/filters/filters.js

@@ -23,7 +23,6 @@ const _base = require("../base");
 const _array = require("../../helpers/array");
 const _templateLiteralTag = require("../../helpers/templateLiteralTag");
 const _console = require("../../helpers/console");
-const _number = require("../../helpers/number");
 const _element = require("../../helpers/dom/element");
 const _unicode = require("../../helpers/unicode");
 const _valueAccessors = require("../../utils/valueAccessors");
@@ -41,7 +40,6 @@ const _utils = require("./utils");
 const _sortComparators = require("./sortComparators");
 const _focusController = require("./menu/focusController");
 const _constants1 = require("./constants");
-const _translations = require("../../translations");
 function _check_private_redeclaration(obj, privateCollection) {
     if (privateCollection.has(obj)) {
         throw new TypeError("Cannot initialize the same private elements twice on an object");
@@ -275,7 +273,7 @@ class Filters extends _base.BasePlugin {
             return;
         }
         _class_private_field_set(this, _isDataProviderActive, this.hot.runHooks('hasExternalDataSource') === true);
-        this.filtersRowsMap = this.hot.rowIndexMapper.registerMap(this.pluginName ?? '', new _translations.TrimmingMap());
+        this.filtersRowsMap = this.hot.rowIndexMapper.createAndRegisterIndexMap(this.pluginName ?? '', 'trimming');
         this.dropdownMenuPlugin = this.hot.getPlugin('dropdownMenu');
         const dropdownSettings = this.hot.getSettings().dropdownMenu;
         const uiContainerCandidate = typeof dropdownSettings === 'object' ? dropdownSettings.uiContainer : null;
@@ -333,7 +331,7 @@ class Filters extends _base.BasePlugin {
             this.conditionCollection = new _conditionCollection.default(this.hot);
         }
         if (!this.conditionUpdateObserver) {
-            this.conditionUpdateObserver = new _conditionUpdateObserver.default(this.hot, this.conditionCollection, (physicalColumn)=>this.getDataMapAtColumn(physicalColumn));
+            this.conditionUpdateObserver = new _conditionUpdateObserver.default(this.hot, this.conditionCollection, (physicalColumn, physicalRows)=>this.getDataMapAtColumn(physicalColumn, physicalRows));
             this.conditionUpdateObserver.addLocalHook('update', (conditionState)=>_class_private_method_get(this, _updateComponents, updateComponents).call(this, conditionState));
         }
         this.components.forEach((component)=>component?.show());
@@ -486,7 +484,7 @@ class Filters extends _base.BasePlugin {
    * | `intl_time_between` | Between times (locale-aware) | `[fromTimeString: string, toTimeString: string]`, e.g. `['08:00', '12:00']` |
    * | `lt` | Less than | `[value: number]`, e.g. `[10]` |
    * | `lte` | Less than or equal | `[value: number]`, e.g. `[10]` |
-   * | `none` | None (no filter) | `[]` |
+   * | `none` | None (no filter) | `[]`. Matches every row, so it has no filtering effect. To clear a column's filter, use [`removeConditions()`](@/api/filters.md#removeconditions) instead. |
    * | `not_between` | Not between | `[from: number\|string, to: number\|string]`, e.g. `[10, 50]` |
    * | `not_contains` | Not contains | `[value: string]`, e.g. `['ing']` |
    * | `not_empty` | Not empty | `[]` |
@@ -850,6 +848,9 @@ class Filters extends _base.BasePlugin {
     /**
    * Removes conditions at specified column index.
    *
+   * This is the programmatic equivalent of selecting the `None` operator in the column menu – both
+   * clear the column's filter.
+   *
    * @param {number} column Visual column index.
    */ removeConditions(column) {
         const physicalColumn = this.hot.toPhysicalColumn(column);
@@ -871,17 +872,24 @@ class Filters extends _base.BasePlugin {
     /**
    * Imports filter conditions to all columns to the plugin. The method accepts
    * the array of conditions with the same structure as the {@link Filters#exportConditions} method returns.
+   * The `column` property in each condition object must be a physical column index.
    * Importing conditions will replace the current conditions. Once replaced, the state of the condition
    * will be reflected in the UI. To apply the changes and filter the table, call
    * the {@link Filters#filter} method eventually.
    *
-   * @param {Array} conditions Array of conditions.
+   * @param {Array} conditions Array of conditions keyed by physical column indexes.
    */ importConditions(conditions) {
+        // Group the per-condition `afterAdd`/`afterClean` cascade the same way the action-bar
+        // submit does. Without grouping, every imported condition triggers a full component
+        // update that re-scans the whole dataset once per earlier filtered column.
+        this.conditionUpdateObserver?.groupChanges();
         this.conditionCollection?.importAllConditions(conditions);
+        this.conditionUpdateObserver?.flush();
     }
     /**
    * Exports filter conditions for all columns from the plugin.
-   * The array represents the filter state for each column. For example:
+   * The array represents the filter state for each column and uses physical column indexes in each `column` property.
+   * For example:
    *
    * ```js
    * [
@@ -921,20 +929,20 @@ class Filters extends _base.BasePlugin {
         }
         const allowFiltering = this.hot.runHooks('beforeFilter', conditions, _class_private_field_get(this, _previousConditionStack));
         if (allowFiltering !== false && needToFilter) {
-            const trimmedRows = [];
             const dataFilter = this._createDataFilter();
-            const rowIndexesToShow = (0, _array.arrayMap)(dataFilter.filter(), (rowData)=>rowData.meta.row);
+            const rowIndexesToShow = (0, _array.arrayMap)(dataFilter.filter(), (rowData)=>rowData.row);
             const rowIndexesToShowAssertion = (0, _utils.createArrayAssertion)(rowIndexesToShow);
+            const countSourceRows = this.hot.countSourceRows();
+            // Build the trimmed-state array in a single pass (`true` marks a row hidden by the filter), then
+            // write it to the map in one bulk `setValues` call. The previous approach scanned the dataset
+            // twice (a `clear()` that rebuilt the whole array, then a `rangeEach` pass) and fired a map
+            // `change` per trimmed row; for large datasets that was a measurable share of `filter()` time.
+            const trimmedRowsState = new Array(countSourceRows);
+            for(let physicalRow = 0; physicalRow < countSourceRows; physicalRow++){
+                trimmedRowsState[physicalRow] = !rowIndexesToShowAssertion(physicalRow);
+            }
             this.hot.batchExecution(()=>{
-                this.filtersRowsMap?.clear();
-                (0, _number.rangeEach)(this.hot.countSourceRows() - 1, (row)=>{
-                    if (!rowIndexesToShowAssertion(row)) {
-                        trimmedRows.push(row);
-                    }
-                });
-                (0, _array.arrayEach)(trimmedRows, (physicalRow)=>{
-                    this.filtersRowsMap?.setValueAtIndex(physicalRow, true);
-                });
+                this.filtersRowsMap?.setValues(trimmedRowsState);
             }, true);
             if (!navigableHeaders && !rowIndexesToShow.length) {
                 this.hot.deselectCell();
@@ -961,11 +969,11 @@ class Filters extends _base.BasePlugin {
         }
     }
     /**
-   * Gets last selected column index.
+   * Gets the last selected column as an object with visual and physical indexes.
    *
    * @returns {{visualIndex: number, physicalIndex: number} | null} Returns `null` when a column is
    * not selected. Otherwise, returns an object with `visualIndex` and `physicalIndex` properties containing
-   * the index of the column.
+   * column indexes.
    */ getSelectedColumn() {
         const highlight = this.hot.getSelectedRangeActive()?.highlight;
         if (!highlight || highlight.col === null) {
@@ -979,19 +987,23 @@ class Filters extends _base.BasePlugin {
     /**
    * Returns the full dataset for a column with cell meta for each row. The dataset is independent of
    * any index mapper - no matter if the data is filtered, sorted, or otherwise transformed all rows
-   * are included.
+   * are included, unless `physicalRows` narrows the read to specific rows.
    *
    * @param {number} physicalColumn The physical column index.
-   * @returns {Array<{meta: CellProperties, value: *}>} Array of objects with `meta` and `value`, one per source row.
-   */ getDataMapAtColumn(physicalColumn) {
-        const countSourceRows = this.hot.countSourceRows();
+   * @param {number[]} [physicalRows] When provided, only these physical rows are read (in the given
+   * order) instead of every source row.
+   * @returns {Array<{row: number, meta: CellProperties, value: *}>} Array of objects with `row` (the physical
+   * row index), `meta`, and `value`, one per read row. Consumers correlate rows through the `row` property -
+   * the coordinate stamps on `meta` are shared with other readers and may change after this method returns.
+   */ getDataMapAtColumn(physicalColumn, physicalRows) {
+        const rowsCount = physicalRows ? physicalRows.length : this.hot.countSourceRows();
         const visualColumn = this.hot.toVisualColumn(physicalColumn);
         const data = [];
-        for(let physicalRow = 0; physicalRow < countSourceRows; physicalRow++){
-            const cellMeta = this.hot._getMetaManager().getCellMeta(physicalRow, physicalColumn, {
+        for(let rowIndex = 0; rowIndex < rowsCount; rowIndex++){
+            const physicalRow = physicalRows ? physicalRows[rowIndex] : rowIndex;
+            const cellMeta = this.hot._getMetaManager().getCellMetaUncached(physicalRow, physicalColumn, {
                 visualRow: physicalRow,
-                visualColumn: physicalColumn,
-                skipMetaExtension: true
+                visualColumn: physicalColumn
             });
             let value = (0, _valueAccessors.getValueGetterValue)(this.hot.getSourceDataAtCell(physicalRow, visualColumn), cellMeta);
             if (this.hot.hasHook('modifyData')) {
@@ -1002,6 +1014,7 @@ class Filters extends _base.BasePlugin {
                 }
             }
             data.push({
+                row: physicalRow,
                 meta: cellMeta,
                 value: (0, _utils.toEmptyString)(value)
             });
@@ -1016,7 +1029,7 @@ class Filters extends _base.BasePlugin {
    */ updateValueComponentCondition(columnIndex) {
         const visualColumnIndex = this.hot.toVisualColumn(columnIndex);
         const dataAtCol = this.hot.getDataAtCol(visualColumnIndex);
-        const columnMeta = this.hot.countRows() > 0 ? this.hot.getCellMeta(0, visualColumnIndex) : null;
+        const columnMeta = this.hot.countRows() > 0 ? this.hot.getCellMetaTransient(0, visualColumnIndex) : null;
         const comparator = (0, _sortComparators.getSortComparatorForMeta)(columnMeta);
         const selectedValues = (0, _utils.unifyColumnValues)(dataAtCol, comparator);
         this.conditionUpdateObserver?.updateStatesAtColumn(columnIndex, selectedValues);
@@ -1093,6 +1106,46 @@ class Filters extends _base.BasePlugin {
         }
     }
     /**
+   * Gets the values the "filter by value" list of a column is built from.
+   *
+   * A column that carries conditions of its own reads the rows that survive the conditions of the
+   * columns defined BEFORE it in the filter stack. Its own conditions are deliberately skipped - a
+   * column's filter must not narrow down its own value list, or the values it filters out drop off
+   * the list and become impossible to select again (issue #12226). A column with no conditions of
+   * its own reads the currently visible data, which the other columns' filters already narrowed
+   * down.
+   *
+   * @private
+   * @param {number} column Visual column index.
+   * @returns {Array<{value: *, meta: CellProperties}>} Array of objects with `value` and `meta`, one per row.
+   */ _getValueListDataAtColumn(column) {
+        const physicalColumn = this.hot.toPhysicalColumn(column);
+        const stackPosition = this.conditionCollection?.getColumnStackPosition(physicalColumn) ?? -1;
+        // A data provider filters server-side and the list is hidden anyway, so re-running the
+        // conditions locally would filter data that is already filtered.
+        if (stackPosition === -1 || _class_private_field_get(this, _isDataProviderActive)) {
+            return (0, _array.arrayMap)(this.hot.getDataAtCol(column), (value, rowIndex)=>({
+                    value: (0, _utils.toEmptyString)(value),
+                    meta: this.hot.getCellMetaTransient(rowIndex, column)
+                }));
+        }
+        const allRows = this.getDataMapAtColumn(physicalColumn);
+        const conditionsBefore = (this.conditionCollection?.exportAllConditions() ?? []).slice(0, stackPosition);
+        if (conditionsBefore.length === 0) {
+            return allRows;
+        }
+        const splitConditionCollection = new _conditionCollection.default(this.hot, false);
+        splitConditionCollection.importAllConditions(conditionsBefore);
+        // Rows are correlated through the entry's own `row` property - the coordinate stamps on `meta`
+        // are shared with every other meta reader and may have been overwritten since.
+        // `DataFilter` is typed against `unknown[]` throughout, so its entries are narrowed here - the
+        // same boundary cast `DataFilter.filter()` and `ConditionUpdateObserver` already make.
+        const survivingRows = (0, _array.arrayMap)(this._createDataFilter(splitConditionCollection).filter(), (rowData)=>rowData.row);
+        const survivingRowsAssertion = (0, _utils.createArrayAssertion)(survivingRows);
+        splitConditionCollection.destroy();
+        return (0, _array.arrayFilter)(allRows, (rowData)=>survivingRowsAssertion(rowData.row));
+    }
+    /**
    * Creates DataFilter instance based on condition collection.
    *
    * @private
@@ -1102,7 +1155,7 @@ class Filters extends _base.BasePlugin {
         if (!conditionCollection) {
             conditionCollection = new _conditionCollection.default(this.hot, false);
         }
-        return new _dataFilter.default(conditionCollection, (physicalColumn)=>this.getDataMapAtColumn(physicalColumn));
+        return new _dataFilter.default(conditionCollection, (physicalColumn, physicalRows)=>this.getDataMapAtColumn(physicalColumn, physicalRows));
     }
     /**
    * Returns indexes of passed components inside list of `dropdownMenu` items.
@@ -1269,14 +1322,21 @@ class Filters extends _base.BasePlugin {
    * @type {null|TrimmingMap}
    */ this.filtersRowsMap = null, _class_private_field_set(this, _dropdownMenuTraces, new WeakSet()), _class_private_field_set(this, _previousConditionStack, []), _class_private_field_set(this, _dataProviderFilterRollbackStack, []), _class_private_field_set(this, _isDataProviderActive, false), _class_private_field_set(this, _onAfterChange, (changes)=>{
             if (changes) {
+                // A single batch (paste, fill, undo) can carry thousands of changes that hit the same
+                // column. The value-component refresh reads and sorts the whole column, so run it once
+                // per distinct filtered column instead of once per changed cell.
+                const changedColumns = new Set();
                 (0, _array.arrayEach)(changes, (change)=>{
                     const [, prop] = change;
                     const visualColumnIndex = this.hot.propToCol(prop);
                     const physicalColumnIndex = this.hot.toPhysicalColumn(visualColumnIndex);
                     if (this.conditionCollection?.hasConditions(physicalColumnIndex)) {
-                        this.updateValueComponentCondition(physicalColumnIndex);
+                        changedColumns.add(physicalColumnIndex);
                     }
                 });
+                changedColumns.forEach((physicalColumnIndex)=>{
+                    this.updateValueComponentCondition(physicalColumnIndex);
+                });
             }
         }), _class_private_field_set(this, _onAfterUpdateData, (_data, firstRun)=>{
             if (firstRun || _class_private_field_get(this, _isDataProviderActive) || !this.conditionCollection) {

package/plugins/filters/filters.mjs

@@ -49,10 +49,9 @@ function _class_private_method_init(obj, privateSet) {
     privateSet.add(obj);
 }
 import { BasePlugin } from '../base/index.mjs';
-import { arrayEach, arrayMap } from '../../helpers/array.mjs';
+import { arrayEach, arrayFilter, arrayMap } from '../../helpers/array.mjs';
 import { toSingleLine } from '../../helpers/templateLiteralTag.mjs';
 import { warn } from '../../helpers/console.mjs';
-import { rangeEach } from '../../helpers/number.mjs';
 import { addClass, isBottomMostColumnHeader, isHTMLElement, removeClass } from '../../helpers/dom/element.mjs';
 import { isKey } from '../../helpers/unicode.mjs';
 import { getValueGetterValue } from '../../utils/valueAccessors.mjs';
@@ -70,7 +69,6 @@ import { createArrayAssertion, toEmptyString, unifyColumnValues } from './utils.
 import { getSortComparatorForMeta } from './sortComparators.mjs';
 import { createMenuFocusController } from './menu/focusController.mjs';
 import { CONDITION_NONE, CONDITION_BY_VALUE, OPERATION_AND, OPERATION_OR, OPERATION_OR_THEN_VARIABLE } from './constants.mjs';
-import { TrimmingMap } from '../../translations/index.mjs';
 export const PLUGIN_KEY = 'filters';
 export const PLUGIN_PRIORITY = 250;
 const SHORTCUTS_GROUP = PLUGIN_KEY;
@@ -258,7 +256,7 @@ var /**
             return;
         }
         _class_private_field_set(this, _isDataProviderActive, this.hot.runHooks('hasExternalDataSource') === true);
-        this.filtersRowsMap = this.hot.rowIndexMapper.registerMap(this.pluginName ?? '', new TrimmingMap());
+        this.filtersRowsMap = this.hot.rowIndexMapper.createAndRegisterIndexMap(this.pluginName ?? '', 'trimming');
         this.dropdownMenuPlugin = this.hot.getPlugin('dropdownMenu');
         const dropdownSettings = this.hot.getSettings().dropdownMenu;
         const uiContainerCandidate = typeof dropdownSettings === 'object' ? dropdownSettings.uiContainer : null;
@@ -316,7 +314,7 @@ var /**
             this.conditionCollection = new ConditionCollection(this.hot);
         }
         if (!this.conditionUpdateObserver) {
-            this.conditionUpdateObserver = new ConditionUpdateObserver(this.hot, this.conditionCollection, (physicalColumn)=>this.getDataMapAtColumn(physicalColumn));
+            this.conditionUpdateObserver = new ConditionUpdateObserver(this.hot, this.conditionCollection, (physicalColumn, physicalRows)=>this.getDataMapAtColumn(physicalColumn, physicalRows));
             this.conditionUpdateObserver.addLocalHook('update', (conditionState)=>_class_private_method_get(this, _updateComponents, updateComponents).call(this, conditionState));
         }
         this.components.forEach((component)=>component?.show());
@@ -469,7 +467,7 @@ var /**
    * | `intl_time_between` | Between times (locale-aware) | `[fromTimeString: string, toTimeString: string]`, e.g. `['08:00', '12:00']` |
    * | `lt` | Less than | `[value: number]`, e.g. `[10]` |
    * | `lte` | Less than or equal | `[value: number]`, e.g. `[10]` |
-   * | `none` | None (no filter) | `[]` |
+   * | `none` | None (no filter) | `[]`. Matches every row, so it has no filtering effect. To clear a column's filter, use [`removeConditions()`](@/api/filters.md#removeconditions) instead. |
    * | `not_between` | Not between | `[from: number\|string, to: number\|string]`, e.g. `[10, 50]` |
    * | `not_contains` | Not contains | `[value: string]`, e.g. `['ing']` |
    * | `not_empty` | Not empty | `[]` |
@@ -833,6 +831,9 @@ var /**
     /**
    * Removes conditions at specified column index.
    *
+   * This is the programmatic equivalent of selecting the `None` operator in the column menu – both
+   * clear the column's filter.
+   *
    * @param {number} column Visual column index.
    */ removeConditions(column) {
         const physicalColumn = this.hot.toPhysicalColumn(column);
@@ -854,17 +855,24 @@ var /**
     /**
    * Imports filter conditions to all columns to the plugin. The method accepts
    * the array of conditions with the same structure as the {@link Filters#exportConditions} method returns.
+   * The `column` property in each condition object must be a physical column index.
    * Importing conditions will replace the current conditions. Once replaced, the state of the condition
    * will be reflected in the UI. To apply the changes and filter the table, call
    * the {@link Filters#filter} method eventually.
    *
-   * @param {Array} conditions Array of conditions.
+   * @param {Array} conditions Array of conditions keyed by physical column indexes.
    */ importConditions(conditions) {
+        // Group the per-condition `afterAdd`/`afterClean` cascade the same way the action-bar
+        // submit does. Without grouping, every imported condition triggers a full component
+        // update that re-scans the whole dataset once per earlier filtered column.
+        this.conditionUpdateObserver?.groupChanges();
         this.conditionCollection?.importAllConditions(conditions);
+        this.conditionUpdateObserver?.flush();
     }
     /**
    * Exports filter conditions for all columns from the plugin.
-   * The array represents the filter state for each column. For example:
+   * The array represents the filter state for each column and uses physical column indexes in each `column` property.
+   * For example:
    *
    * ```js
    * [
@@ -904,20 +912,20 @@ var /**
         }
         const allowFiltering = this.hot.runHooks('beforeFilter', conditions, _class_private_field_get(this, _previousConditionStack));
         if (allowFiltering !== false && needToFilter) {
-            const trimmedRows = [];
             const dataFilter = this._createDataFilter();
-            const rowIndexesToShow = arrayMap(dataFilter.filter(), (rowData)=>rowData.meta.row);
+            const rowIndexesToShow = arrayMap(dataFilter.filter(), (rowData)=>rowData.row);
             const rowIndexesToShowAssertion = createArrayAssertion(rowIndexesToShow);
+            const countSourceRows = this.hot.countSourceRows();
+            // Build the trimmed-state array in a single pass (`true` marks a row hidden by the filter), then
+            // write it to the map in one bulk `setValues` call. The previous approach scanned the dataset
+            // twice (a `clear()` that rebuilt the whole array, then a `rangeEach` pass) and fired a map
+            // `change` per trimmed row; for large datasets that was a measurable share of `filter()` time.
+            const trimmedRowsState = new Array(countSourceRows);
+            for(let physicalRow = 0; physicalRow < countSourceRows; physicalRow++){
+                trimmedRowsState[physicalRow] = !rowIndexesToShowAssertion(physicalRow);
+            }
             this.hot.batchExecution(()=>{
-                this.filtersRowsMap?.clear();
-                rangeEach(this.hot.countSourceRows() - 1, (row)=>{
-                    if (!rowIndexesToShowAssertion(row)) {
-                        trimmedRows.push(row);
-                    }
-                });
-                arrayEach(trimmedRows, (physicalRow)=>{
-                    this.filtersRowsMap?.setValueAtIndex(physicalRow, true);
-                });
+                this.filtersRowsMap?.setValues(trimmedRowsState);
             }, true);
             if (!navigableHeaders && !rowIndexesToShow.length) {
                 this.hot.deselectCell();
@@ -944,11 +952,11 @@ var /**
         }
     }
     /**
-   * Gets last selected column index.
+   * Gets the last selected column as an object with visual and physical indexes.
    *
    * @returns {{visualIndex: number, physicalIndex: number} | null} Returns `null` when a column is
    * not selected. Otherwise, returns an object with `visualIndex` and `physicalIndex` properties containing
-   * the index of the column.
+   * column indexes.
    */ getSelectedColumn() {
         const highlight = this.hot.getSelectedRangeActive()?.highlight;
         if (!highlight || highlight.col === null) {
@@ -962,19 +970,23 @@ var /**
     /**
    * Returns the full dataset for a column with cell meta for each row. The dataset is independent of
    * any index mapper - no matter if the data is filtered, sorted, or otherwise transformed all rows
-   * are included.
+   * are included, unless `physicalRows` narrows the read to specific rows.
    *
    * @param {number} physicalColumn The physical column index.
-   * @returns {Array<{meta: CellProperties, value: *}>} Array of objects with `meta` and `value`, one per source row.
-   */ getDataMapAtColumn(physicalColumn) {
-        const countSourceRows = this.hot.countSourceRows();
+   * @param {number[]} [physicalRows] When provided, only these physical rows are read (in the given
+   * order) instead of every source row.
+   * @returns {Array<{row: number, meta: CellProperties, value: *}>} Array of objects with `row` (the physical
+   * row index), `meta`, and `value`, one per read row. Consumers correlate rows through the `row` property -
+   * the coordinate stamps on `meta` are shared with other readers and may change after this method returns.
+   */ getDataMapAtColumn(physicalColumn, physicalRows) {
+        const rowsCount = physicalRows ? physicalRows.length : this.hot.countSourceRows();
         const visualColumn = this.hot.toVisualColumn(physicalColumn);
         const data = [];
-        for(let physicalRow = 0; physicalRow < countSourceRows; physicalRow++){
-            const cellMeta = this.hot._getMetaManager().getCellMeta(physicalRow, physicalColumn, {
+        for(let rowIndex = 0; rowIndex < rowsCount; rowIndex++){
+            const physicalRow = physicalRows ? physicalRows[rowIndex] : rowIndex;
+            const cellMeta = this.hot._getMetaManager().getCellMetaUncached(physicalRow, physicalColumn, {
                 visualRow: physicalRow,
-                visualColumn: physicalColumn,
-                skipMetaExtension: true
+                visualColumn: physicalColumn
             });
             let value = getValueGetterValue(this.hot.getSourceDataAtCell(physicalRow, visualColumn), cellMeta);
             if (this.hot.hasHook('modifyData')) {
@@ -985,6 +997,7 @@ var /**
                 }
             }
             data.push({
+                row: physicalRow,
                 meta: cellMeta,
                 value: toEmptyString(value)
             });
@@ -999,7 +1012,7 @@ var /**
    */ updateValueComponentCondition(columnIndex) {
         const visualColumnIndex = this.hot.toVisualColumn(columnIndex);
         const dataAtCol = this.hot.getDataAtCol(visualColumnIndex);
-        const columnMeta = this.hot.countRows() > 0 ? this.hot.getCellMeta(0, visualColumnIndex) : null;
+        const columnMeta = this.hot.countRows() > 0 ? this.hot.getCellMetaTransient(0, visualColumnIndex) : null;
         const comparator = getSortComparatorForMeta(columnMeta);
         const selectedValues = unifyColumnValues(dataAtCol, comparator);
         this.conditionUpdateObserver?.updateStatesAtColumn(columnIndex, selectedValues);
@@ -1076,6 +1089,46 @@ var /**
         }
     }
     /**
+   * Gets the values the "filter by value" list of a column is built from.
+   *
+   * A column that carries conditions of its own reads the rows that survive the conditions of the
+   * columns defined BEFORE it in the filter stack. Its own conditions are deliberately skipped - a
+   * column's filter must not narrow down its own value list, or the values it filters out drop off
+   * the list and become impossible to select again (issue #12226). A column with no conditions of
+   * its own reads the currently visible data, which the other columns' filters already narrowed
+   * down.
+   *
+   * @private
+   * @param {number} column Visual column index.
+   * @returns {Array<{value: *, meta: CellProperties}>} Array of objects with `value` and `meta`, one per row.
+   */ _getValueListDataAtColumn(column) {
+        const physicalColumn = this.hot.toPhysicalColumn(column);
+        const stackPosition = this.conditionCollection?.getColumnStackPosition(physicalColumn) ?? -1;
+        // A data provider filters server-side and the list is hidden anyway, so re-running the
+        // conditions locally would filter data that is already filtered.
+        if (stackPosition === -1 || _class_private_field_get(this, _isDataProviderActive)) {
+            return arrayMap(this.hot.getDataAtCol(column), (value, rowIndex)=>({
+                    value: toEmptyString(value),
+                    meta: this.hot.getCellMetaTransient(rowIndex, column)
+                }));
+        }
+        const allRows = this.getDataMapAtColumn(physicalColumn);
+        const conditionsBefore = (this.conditionCollection?.exportAllConditions() ?? []).slice(0, stackPosition);
+        if (conditionsBefore.length === 0) {
+            return allRows;
+        }
+        const splitConditionCollection = new ConditionCollection(this.hot, false);
+        splitConditionCollection.importAllConditions(conditionsBefore);
+        // Rows are correlated through the entry's own `row` property - the coordinate stamps on `meta`
+        // are shared with every other meta reader and may have been overwritten since.
+        // `DataFilter` is typed against `unknown[]` throughout, so its entries are narrowed here - the
+        // same boundary cast `DataFilter.filter()` and `ConditionUpdateObserver` already make.
+        const survivingRows = arrayMap(this._createDataFilter(splitConditionCollection).filter(), (rowData)=>rowData.row);
+        const survivingRowsAssertion = createArrayAssertion(survivingRows);
+        splitConditionCollection.destroy();
+        return arrayFilter(allRows, (rowData)=>survivingRowsAssertion(rowData.row));
+    }
+    /**
    * Creates DataFilter instance based on condition collection.
    *
    * @private
@@ -1085,7 +1138,7 @@ var /**
         if (!conditionCollection) {
             conditionCollection = new ConditionCollection(this.hot, false);
         }
-        return new DataFilter(conditionCollection, (physicalColumn)=>this.getDataMapAtColumn(physicalColumn));
+        return new DataFilter(conditionCollection, (physicalColumn, physicalRows)=>this.getDataMapAtColumn(physicalColumn, physicalRows));
     }
     /**
    * Returns indexes of passed components inside list of `dropdownMenu` items.
@@ -1252,14 +1305,21 @@ var /**
    * @type {null|TrimmingMap}
    */ this.filtersRowsMap = null, _class_private_field_set(this, _dropdownMenuTraces, new WeakSet()), _class_private_field_set(this, _previousConditionStack, []), _class_private_field_set(this, _dataProviderFilterRollbackStack, []), _class_private_field_set(this, _isDataProviderActive, false), _class_private_field_set(this, _onAfterChange, (changes)=>{
             if (changes) {
+                // A single batch (paste, fill, undo) can carry thousands of changes that hit the same
+                // column. The value-component refresh reads and sorts the whole column, so run it once
+                // per distinct filtered column instead of once per changed cell.
+                const changedColumns = new Set();
                 arrayEach(changes, (change)=>{
                     const [, prop] = change;
                     const visualColumnIndex = this.hot.propToCol(prop);
                     const physicalColumnIndex = this.hot.toPhysicalColumn(visualColumnIndex);
                     if (this.conditionCollection?.hasConditions(physicalColumnIndex)) {
-                        this.updateValueComponentCondition(physicalColumnIndex);
+                        changedColumns.add(physicalColumnIndex);
                     }
                 });
+                changedColumns.forEach((physicalColumnIndex)=>{
+                    this.updateValueComponentCondition(physicalColumnIndex);
+                });
             }
         }), _class_private_field_set(this, _onAfterUpdateData, (_data, firstRun)=>{
             if (firstRun || _class_private_field_get(this, _isDataProviderActive) || !this.conditionCollection) {

package/plugins/filters/sortComparators.d.ts

@@ -6,11 +6,18 @@
  * @returns {Function}
  */
 export declare function createISODateSortComparator(): (a: unknown, b: unknown) => number;
+/**
+ * Returns a comparator for sorting `intl-datetime` cell values chronologically.
+ *
+ * @returns {Function}
+ */
+export declare function createISODateTimeSortComparator(): (a: unknown, b: unknown) => number;
 /**
  * Returns the appropriate sort comparator for the given column cell meta, or `undefined` if
  * no cell-type-specific comparator is needed (falls back to `unifyColumnValues` default).
  *
- * @param {object|null|undefined} meta The cell meta object for the column.
+ * @param {*} meta The cell meta object for the column. Anything that is not an object carrying a
+ * `type` is treated as "no comparator", so callers may pass a loosely typed data-map entry.
  * @returns {Function|undefined}
  */
-export declare function getSortComparatorForMeta(meta: Record<string, unknown> | null | undefined): ((a: unknown, b: unknown) => number) | undefined;
+export declare function getSortComparatorForMeta(meta: unknown): ((a: unknown, b: unknown) => number) | undefined;

package/plugins/filters/sortComparators.js

@@ -12,6 +12,9 @@ _export(exports, {
     get createISODateSortComparator () {
         return createISODateSortComparator;
     },
+    get createISODateTimeSortComparator () {
+        return createISODateTimeSortComparator;
+    },
     get getSortComparatorForMeta () {
         return getSortComparatorForMeta;
     }
@@ -44,12 +47,42 @@ function createISODateSortComparator() {
         return dateA - dateB;
     };
 }
+function createISODateTimeSortComparator() {
+    return (aVal, bVal)=>{
+        const a = aVal;
+        const b = bVal;
+        if (a === '' && b === '') {
+            return 0;
+        }
+        if (a === '') {
+            return -1;
+        }
+        if (b === '') {
+            return 1;
+        }
+        const dateA = (0, _dateTime.parseToLocalDateTime)(a);
+        const dateB = (0, _dateTime.parseToLocalDateTime)(b);
+        if (dateA === null && dateB === null) {
+            return 0;
+        }
+        if (dateA === null) {
+            return 1;
+        }
+        if (dateB === null) {
+            return -1;
+        }
+        return dateA - dateB;
+    };
+}
 function getSortComparatorForMeta(meta) {
-    if (!meta) {
+    if (meta === null || typeof meta !== 'object' || !('type' in meta)) {
         return undefined;
     }
     if (meta.type === 'date' || meta.type === 'intl-date') {
         return createISODateSortComparator();
     }
+    if (meta.type === 'intl-datetime') {
+        return createISODateTimeSortComparator();
+    }
     return undefined;
 }

package/plugins/filters/sortComparators.mjs

@@ -1,4 +1,4 @@
-import { parseToLocalDate } from '../../helpers/dateTime.mjs';
+import { parseToLocalDate, parseToLocalDateTime } from '../../helpers/dateTime.mjs';
 /**
  * Returns a comparator function for sorting `intl-date` cell type values.
  * Source data for `intl-date` is always ISO 8601 ("YYYY-MM-DD").
@@ -32,18 +32,53 @@ import { parseToLocalDate } from '../../helpers/dateTime.mjs';
         return dateA - dateB;
     };
 }
+/**
+ * Returns a comparator for sorting `intl-datetime` cell values chronologically.
+ *
+ * @returns {Function}
+ */ export function createISODateTimeSortComparator() {
+    return (aVal, bVal)=>{
+        const a = aVal;
+        const b = bVal;
+        if (a === '' && b === '') {
+            return 0;
+        }
+        if (a === '') {
+            return -1;
+        }
+        if (b === '') {
+            return 1;
+        }
+        const dateA = parseToLocalDateTime(a);
+        const dateB = parseToLocalDateTime(b);
+        if (dateA === null && dateB === null) {
+            return 0;
+        }
+        if (dateA === null) {
+            return 1;
+        }
+        if (dateB === null) {
+            return -1;
+        }
+        return dateA - dateB;
+    };
+}
 /**
  * Returns the appropriate sort comparator for the given column cell meta, or `undefined` if
  * no cell-type-specific comparator is needed (falls back to `unifyColumnValues` default).
  *
- * @param {object|null|undefined} meta The cell meta object for the column.
+ * @param {*} meta The cell meta object for the column. Anything that is not an object carrying a
+ * `type` is treated as "no comparator", so callers may pass a loosely typed data-map entry.
  * @returns {Function|undefined}
  */ export function getSortComparatorForMeta(meta) {
-    if (!meta) {
+    if (meta === null || typeof meta !== 'object' || !('type' in meta)) {
         return undefined;
     }
     if (meta.type === 'date' || meta.type === 'intl-date') {
         return createISODateSortComparator();
     }
+    if (meta.type === 'intl-datetime') {
+        return createISODateTimeSortComparator();
+    }
     return undefined;
 }

package/plugins/filters/ui/input.d.ts

@@ -27,6 +27,10 @@ export declare class InputUI extends BaseUI {
      * Update element.
      */
     update(): void;
+    /**
+     * Set the type of the native input element (e.g. `text`, `date`, or `time`).
+     */
+    setType(type: string): void;
     /**
      * Focus element.
      */