handsontable 18.0.0 → 18.1.0-rc7

package/plugins/filters/conditionUpdateObserver.mjs

@@ -3,6 +3,41 @@ function _check_private_redeclaration(obj, privateCollection) {
         throw new TypeError("Cannot initialize the same private elements twice on an object");
     }
 }
+function _class_apply_descriptor_get(receiver, descriptor) {
+    if (descriptor.get) {
+        return descriptor.get.call(receiver);
+    }
+    return descriptor.value;
+}
+function _class_apply_descriptor_set(receiver, descriptor, value) {
+    if (descriptor.set) {
+        descriptor.set.call(receiver, value);
+    } else {
+        if (!descriptor.writable) {
+            throw new TypeError("attempted to set read only private field");
+        }
+        descriptor.value = value;
+    }
+}
+function _class_extract_field_descriptor(receiver, privateMap, action) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to " + action + " private field on non-instance");
+    }
+    return privateMap.get(receiver);
+}
+function _class_private_field_get(receiver, privateMap) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "get");
+    return _class_apply_descriptor_get(receiver, descriptor);
+}
+function _class_private_field_init(obj, privateMap, value) {
+    _check_private_redeclaration(obj, privateMap);
+    privateMap.set(obj, value);
+}
+function _class_private_field_set(receiver, privateMap, value) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "set");
+    _class_apply_descriptor_set(receiver, descriptor, value);
+    return value;
+}
 function _class_private_method_get(receiver, privateSet, fn) {
     if (!privateSet.has(receiver)) {
         throw new TypeError("attempted to get private field on non-instance");
@@ -21,11 +56,34 @@ import ConditionCollection from './conditionCollection.mjs';
 import DataFilter from './dataFilter.mjs';
 import { createArrayAssertion } from './utils.mjs';
 var /**
+   * Memoized full-column results of `columnDataFactory`, keyed by physical column index. Active
+   * (non-null) only for the duration of one state update or one `flush()` batch — reading a column's
+   * data map walks every source row, and one update reads the same columns several times.
+   */ _columnDataCache = /*#__PURE__*/ new WeakMap(), /**
+   * Runs the callback with the full-column data memo active. Source data does not change while
+   * component states are recomputed, so every full-column read within one update (the edited
+   * column, the first dependent column, and each column re-scanned by `DataFilter`) can share
+   * one data map per column. Nested activations reuse the outer cache.
+   *
+   * @param {Function} callback The callback to run with the cache active.
+   */ _withColumnDataCache = /*#__PURE__*/ new WeakSet(), /**
+   * Reads the data map for a column through the active memo. Subset reads (with `physicalRows`)
+   * are already narrowed to surviving rows, so only full-column reads are memoized.
+   *
+   * @param {number} physicalColumn The physical column index.
+   * @param {number[]} [physicalRows] When provided, only these physical rows are read.
+   * @returns {Array} Array of objects with `meta` and `value`, one per read row.
+   */ _getColumnData = /*#__PURE__*/ new WeakSet(), /**
    * On before modify condition (add or remove from collection),.
    *
    * @param {number} column Column index.
    * @private
    */ _onConditionBeforeModify = /*#__PURE__*/ new WeakSet(), /**
+   * Performs the actual state update for the column. Runs with the full-column data memo active.
+   *
+   * @param {number} column The column index.
+   * @param {object} conditionArgsChange Object describing condition changes which can be handled by filters on `update` hook.
+   */ _updateStatesAtColumnInternal = /*#__PURE__*/ new WeakSet(), /**
    * On before conditions clean listener.
    *
    * @private
@@ -54,8 +112,10 @@ var /**
    * Flush all collected changes. This trigger `update` hook for every previously collected change from condition collection.
    */ flush() {
         this.grouping = false;
-        arrayEach(this.changes, (column)=>{
-            this.updateStatesAtColumn(column);
+        _class_private_method_get(this, _withColumnDataCache, withColumnDataCache).call(this, ()=>{
+            arrayEach(this.changes, (column)=>{
+                this.updateStatesAtColumn(column);
+            });
         });
         this.changes.length = 0;
     }
@@ -73,51 +133,7 @@ var /**
             }
             return;
         }
-        const allConditions = this.conditionCollection.exportAllConditions();
-        let editedColumnPosition = this.conditionCollection.getColumnStackPosition(column);
-        if (editedColumnPosition === -1) {
-            editedColumnPosition = this.latestEditedColumnPosition;
-        }
-        // Collection of all conditions defined before currently edited `column` (without edited one)
-        const conditionsBefore = allConditions.slice(0, editedColumnPosition);
-        // Collection of all conditions defined after currently edited `column` (with edited one)
-        const conditionsAfter = allConditions.slice(editedColumnPosition);
-        // Make sure that conditionAfter doesn't contain edited column conditions
-        if (conditionsAfter.length && conditionsAfter[0].column === column) {
-            conditionsAfter.shift();
-        }
-        const visibleDataFactory = curry((curriedConditionsBefore, curriedColumn, conditionsStack = [])=>{
-            const splitConditionCollection = new ConditionCollection(this.hot, false);
-            const curriedConditionsBeforeArray = [].concat(curriedConditionsBefore, conditionsStack);
-            // Create new condition collection to determine what rows should be visible in "filter by value" box
-            // in the next conditions in the chain
-            splitConditionCollection.importAllConditions(curriedConditionsBeforeArray);
-            const allRows = this.columnDataFactory(Number(curriedColumn));
-            let visibleRows;
-            if (splitConditionCollection.isEmpty()) {
-                visibleRows = allRows;
-            } else {
-                visibleRows = new DataFilter(splitConditionCollection, this.columnDataFactory).filter();
-            }
-            visibleRows = arrayMap(visibleRows, (rowData)=>rowData.meta.visualRow);
-            const visibleRowsAssertion = createArrayAssertion(visibleRows);
-            splitConditionCollection.destroy();
-            return arrayFilter(allRows, (rowData)=>{
-                return visibleRowsAssertion(rowData.meta.visualRow);
-            });
-        })(conditionsBefore);
-        const editedConditions = [
-            ...this.conditionCollection.getConditions(column)
-        ];
-        this.runLocalHooks('update', {
-            editedConditionStack: {
-                column,
-                conditions: editedConditions
-            },
-            dependentConditionStacks: conditionsAfter,
-            filteredRowsFactory: visibleDataFactory,
-            conditionArgsChange
-        });
+        _class_private_method_get(this, _withColumnDataCache, withColumnDataCache).call(this, ()=>_class_private_method_get(this, _updateStatesAtColumnInternal, updateStatesAtColumnInternal).call(this, column, conditionArgsChange));
     }
     /**
    * Destroy instance.
@@ -130,9 +146,16 @@ var /**
     /**
    * Initializes the observer with the Handsontable instance, a condition collection to watch, and an optional factory for column source data.
    */ constructor(hot, conditionCollection, columnDataFactory = ()=>[]){
+        _class_private_method_init(this, _withColumnDataCache);
+        _class_private_method_init(this, _getColumnData);
         _class_private_method_init(this, _onConditionBeforeModify);
+        _class_private_method_init(this, _updateStatesAtColumnInternal);
         _class_private_method_init(this, _onConditionBeforeClean);
         _class_private_method_init(this, _onConditionAfterClean);
+        _class_private_field_init(this, _columnDataCache, {
+            writable: true,
+            value: void 0
+        });
         /**
    * Collected changes when grouping is enabled.
    *
@@ -155,6 +178,7 @@ var /**
    *
    * @type {Array}
    */ this.latestOrderStack = [];
+        _class_private_field_set(this, _columnDataCache, null);
         this.hot = hot;
         this.conditionCollection = conditionCollection;
         this.columnDataFactory = columnDataFactory;
@@ -165,15 +189,90 @@ var /**
         this.conditionCollection.addLocalHook('afterClean', ()=>_class_private_method_get(this, _onConditionAfterClean, onConditionAfterClean).call(this));
     }
 }
+function withColumnDataCache(callback) {
+    if (_class_private_field_get(this, _columnDataCache) !== null) {
+        callback();
+        return;
+    }
+    _class_private_field_set(this, _columnDataCache, new Map());
+    try {
+        callback();
+    } finally{
+        _class_private_field_set(this, _columnDataCache, null);
+    }
+}
+function getColumnData(physicalColumn, physicalRows) {
+    if (physicalRows || _class_private_field_get(this, _columnDataCache) === null) {
+        return this.columnDataFactory(physicalColumn, physicalRows);
+    }
+    let columnData = _class_private_field_get(this, _columnDataCache).get(physicalColumn);
+    if (!columnData) {
+        columnData = this.columnDataFactory(physicalColumn);
+        _class_private_field_get(this, _columnDataCache).set(physicalColumn, columnData);
+    }
+    return columnData;
+}
 function onConditionBeforeModify(column) {
     this.latestEditedColumnPosition = this.conditionCollection.getColumnStackPosition(column);
 }
+function updateStatesAtColumnInternal(column, conditionArgsChange) {
+    const allConditions = this.conditionCollection.exportAllConditions();
+    let editedColumnPosition = this.conditionCollection.getColumnStackPosition(column);
+    if (editedColumnPosition === -1) {
+        editedColumnPosition = this.latestEditedColumnPosition;
+    }
+    // Collection of all conditions defined before currently edited `column` (without edited one)
+    const conditionsBefore = allConditions.slice(0, editedColumnPosition);
+    // Collection of all conditions defined after currently edited `column` (with edited one)
+    const conditionsAfter = allConditions.slice(editedColumnPosition);
+    // Make sure that conditionAfter doesn't contain edited column conditions
+    if (conditionsAfter.length && conditionsAfter[0].column === column) {
+        conditionsAfter.shift();
+    }
+    const visibleDataFactory = curry((curriedConditionsBefore, curriedColumn, conditionsStack = [])=>{
+        const splitConditionCollection = new ConditionCollection(this.hot, false);
+        const curriedConditionsBeforeArray = [].concat(curriedConditionsBefore, conditionsStack);
+        // Create new condition collection to determine what rows should be visible in "filter by value" box
+        // in the next conditions in the chain
+        splitConditionCollection.importAllConditions(curriedConditionsBeforeArray);
+        const allRows = _class_private_method_get(this, _getColumnData, getColumnData).call(this, Number(curriedColumn));
+        let visibleRows;
+        if (splitConditionCollection.isEmpty()) {
+            visibleRows = allRows;
+        } else {
+            visibleRows = new DataFilter(splitConditionCollection, (physicalColumn, physicalRows)=>_class_private_method_get(this, _getColumnData, getColumnData).call(this, physicalColumn, physicalRows)).filter();
+        }
+        // Correlate rows through the immutable `row` property of the data-map entries. The coordinate
+        // stamps on `meta` are shared with every other meta reader (each read re-stamps them), so they
+        // must not be used to match rows between two reads.
+        visibleRows = arrayMap(visibleRows, (rowData)=>rowData.row);
+        const visibleRowsAssertion = createArrayAssertion(visibleRows);
+        splitConditionCollection.destroy();
+        return arrayFilter(allRows, (rowData)=>{
+            return visibleRowsAssertion(rowData.row);
+        });
+    })(conditionsBefore);
+    const editedConditions = [
+        ...this.conditionCollection.getConditions(column)
+    ];
+    this.runLocalHooks('update', {
+        editedConditionStack: {
+            column,
+            conditions: editedConditions
+        },
+        dependentConditionStacks: conditionsAfter,
+        filteredRowsFactory: visibleDataFactory,
+        conditionArgsChange
+    });
+}
 function onConditionBeforeClean() {
     this.latestOrderStack = this.conditionCollection.getFilteredColumns();
 }
 function onConditionAfterClean() {
-    arrayEach(this.latestOrderStack, (column)=>{
-        this.updateStatesAtColumn(column);
+    _class_private_method_get(this, _withColumnDataCache, withColumnDataCache).call(this, ()=>{
+        arrayEach(this.latestOrderStack, (column)=>{
+            this.updateStatesAtColumn(column);
+        });
     });
 }
 mixin(ConditionUpdateObserver, localHooks);

package/plugins/filters/constants.d.ts

@@ -32,6 +32,7 @@ export declare const TYPE_TEXT = "text";
 export declare const TYPE_DATE = "date";
 export declare const TYPE_INTL_DATE = "intl-date";
 export declare const TYPE_INTL_TIME = "intl-time";
+export declare const TYPE_INTL_DATETIME = "intl-datetime";
 /**
  * Default types and order for filter conditions.
  *

package/plugins/filters/constants.js

@@ -102,6 +102,9 @@ _export(exports, {
     get TYPE_INTL_DATE () {
         return TYPE_INTL_DATE;
     },
+    get TYPE_INTL_DATETIME () {
+        return TYPE_INTL_DATETIME;
+    },
     get TYPE_INTL_TIME () {
         return TYPE_INTL_TIME;
     },
@@ -159,6 +162,14 @@ const _beforeOrEqual2 = require("./condition/intlTime/beforeOrEqual");
 const _after2 = require("./condition/intlTime/after");
 const _afterOrEqual2 = require("./condition/intlTime/afterOrEqual");
 const _between2 = require("./condition/intlTime/between");
+const _before3 = require("./condition/intlDatetime/before");
+const _beforeOrEqual3 = require("./condition/intlDatetime/beforeOrEqual");
+const _after3 = require("./condition/intlDatetime/after");
+const _afterOrEqual3 = require("./condition/intlDatetime/afterOrEqual");
+const _between3 = require("./condition/intlDatetime/between");
+const _tomorrow2 = require("./condition/intlDatetime/tomorrow");
+const _today2 = require("./condition/intlDatetime/today");
+const _yesterday2 = require("./condition/intlDatetime/yesterday");
 const _false = require("./condition/false");
 const _byValue = require("./condition/byValue");
 const _true = require("./condition/true");
@@ -170,6 +181,7 @@ const TYPE_TEXT = 'text';
 const TYPE_DATE = 'date';
 const TYPE_INTL_DATE = 'intl-date';
 const TYPE_INTL_TIME = 'intl-time';
+const TYPE_INTL_DATETIME = 'intl-datetime';
 const TYPES = {
     [TYPE_NUMERIC]: [
         _none.CONDITION_NAME,
@@ -260,6 +272,25 @@ const TYPES = {
         _after2.CONDITION_NAME,
         _afterOrEqual2.CONDITION_NAME,
         _between2.CONDITION_NAME
+    ],
+    [TYPE_INTL_DATETIME]: [
+        _none.CONDITION_NAME,
+        _predefinedItems.SEPARATOR,
+        _empty.CONDITION_NAME,
+        _notEmpty.CONDITION_NAME,
+        _predefinedItems.SEPARATOR,
+        _equal.CONDITION_NAME,
+        _notEqual.CONDITION_NAME,
+        _predefinedItems.SEPARATOR,
+        _before3.CONDITION_NAME,
+        _beforeOrEqual3.CONDITION_NAME,
+        _after3.CONDITION_NAME,
+        _afterOrEqual3.CONDITION_NAME,
+        _between3.CONDITION_NAME,
+        _predefinedItems.SEPARATOR,
+        _tomorrow2.CONDITION_NAME,
+        _today2.CONDITION_NAME,
+        _yesterday2.CONDITION_NAME
     ]
 };
 function getOptionsList(type) {

package/plugins/filters/constants.mjs

@@ -36,6 +36,14 @@ import { CONDITION_NAME as CONDITION_INTL_TIME_BEFORE_OR_EQUAL } from './conditi
 import { CONDITION_NAME as CONDITION_INTL_TIME_AFTER } from './condition/intlTime/after.mjs';
 import { CONDITION_NAME as CONDITION_INTL_TIME_AFTER_OR_EQUAL } from './condition/intlTime/afterOrEqual.mjs';
 import { CONDITION_NAME as CONDITION_INTL_TIME_BETWEEN } from './condition/intlTime/between.mjs';
+import { CONDITION_NAME as CONDITION_INTL_DATETIME_BEFORE } from './condition/intlDatetime/before.mjs';
+import { CONDITION_NAME as CONDITION_INTL_DATETIME_BEFORE_OR_EQUAL } from './condition/intlDatetime/beforeOrEqual.mjs';
+import { CONDITION_NAME as CONDITION_INTL_DATETIME_AFTER } from './condition/intlDatetime/after.mjs';
+import { CONDITION_NAME as CONDITION_INTL_DATETIME_AFTER_OR_EQUAL } from './condition/intlDatetime/afterOrEqual.mjs';
+import { CONDITION_NAME as CONDITION_INTL_DATETIME_BETWEEN } from './condition/intlDatetime/between.mjs';
+import { CONDITION_NAME as CONDITION_INTL_DATETIME_TOMORROW } from './condition/intlDatetime/tomorrow.mjs';
+import { CONDITION_NAME as CONDITION_INTL_DATETIME_TODAY } from './condition/intlDatetime/today.mjs';
+import { CONDITION_NAME as CONDITION_INTL_DATETIME_YESTERDAY } from './condition/intlDatetime/yesterday.mjs';
 import { CONDITION_NAME as CONDITION_FALSE } from './condition/false.mjs';
 export { CONDITION_NAME as CONDITION_BY_VALUE } from './condition/byValue.mjs';
 export { CONDITION_NAME as CONDITION_TRUE } from './condition/true.mjs';
@@ -48,6 +56,7 @@ export const TYPE_TEXT = 'text';
 export const TYPE_DATE = 'date';
 export const TYPE_INTL_DATE = 'intl-date';
 export const TYPE_INTL_TIME = 'intl-time';
+export const TYPE_INTL_DATETIME = 'intl-datetime';
 /**
  * Default types and order for filter conditions.
  *
@@ -142,6 +151,25 @@ export const TYPE_INTL_TIME = 'intl-time';
         CONDITION_INTL_TIME_AFTER,
         CONDITION_INTL_TIME_AFTER_OR_EQUAL,
         CONDITION_INTL_TIME_BETWEEN
+    ],
+    [TYPE_INTL_DATETIME]: [
+        CONDITION_NONE,
+        SEPARATOR,
+        CONDITION_EMPTY,
+        CONDITION_NOT_EMPTY,
+        SEPARATOR,
+        CONDITION_EQUAL,
+        CONDITION_NOT_EQUAL,
+        SEPARATOR,
+        CONDITION_INTL_DATETIME_BEFORE,
+        CONDITION_INTL_DATETIME_BEFORE_OR_EQUAL,
+        CONDITION_INTL_DATETIME_AFTER,
+        CONDITION_INTL_DATETIME_AFTER_OR_EQUAL,
+        CONDITION_INTL_DATETIME_BETWEEN,
+        SEPARATOR,
+        CONDITION_INTL_DATETIME_TOMORROW,
+        CONDITION_INTL_DATETIME_TODAY,
+        CONDITION_INTL_DATETIME_YESTERDAY
     ]
 };
 /**

package/plugins/filters/dataFilter.d.ts

@@ -13,18 +13,19 @@ declare class DataFilter {
         isMatch: (value: unknown, column: number) => boolean;
     };
     /**
-     * Function which provide source data factory for specified column.
+     * Function which provide source data factory for specified column. The optional second
+     * argument narrows the read to the given physical rows only.
      *
      * @type {Function}
      */
-    columnDataFactory: (column: number) => unknown[];
+    columnDataFactory: (column: number, physicalRows?: number[]) => unknown[];
     /**
      * Initializes the data filter with a condition collection that provides filtering logic and a factory function that supplies column source data.
      */
     constructor(conditionCollection: {
         getFilteredColumns: () => unknown[];
         isMatch: (value: unknown, column: number) => boolean;
-    }, columnDataFactory?: (column: number) => unknown[]);
+    }, columnDataFactory?: (column: number, physicalRows?: number[]) => unknown[]);
     /**
      * Filter data based on the conditions collection.
      *
@@ -39,14 +40,5 @@ declare class DataFilter {
      * @returns {Array} Returns filtered data.
      */
     filterByColumn(column: number, dataSource?: unknown[]): unknown[];
-    /**
-     * Intersect data.
-     *
-     * @private
-     * @param {Array} data The data to intersect.
-     * @param {Array} needles The collection intersected rows with the data.
-     * @returns {Array}
-     */
-    _getIntersectData(data: unknown[], needles: unknown[]): unknown[];
 }
 export default DataFilter;

package/plugins/filters/dataFilter.js

@@ -20,9 +20,14 @@ const _array = require("../../helpers/array");
    */ filter() {
         let filteredData = [];
         (0, _array.arrayEach)(this.conditionCollection.getFilteredColumns(), (physicalColumn, index)=>{
-            let columnData = this.columnDataFactory(physicalColumn);
+            let columnData;
             if (index) {
-                columnData = this._getIntersectData(columnData, filteredData);
+                // Materialize only the rows that survived the previous columns' conditions instead of
+                // re-reading (and re-creating cell meta for) every source row once per filtered column.
+                const survivingRows = (0, _array.arrayMap)(filteredData, (rowData)=>rowData.row);
+                columnData = this.columnDataFactory(physicalColumn, survivingRows);
+            } else {
+                columnData = this.columnDataFactory(physicalColumn);
             }
             filteredData = this.filterByColumn(physicalColumn, columnData);
         });
@@ -44,23 +49,6 @@ const _array = require("../../helpers/array");
         return filteredData;
     }
     /**
-   * Intersect data.
-   *
-   * @private
-   * @param {Array} data The data to intersect.
-   * @param {Array} needles The collection intersected rows with the data.
-   * @returns {Array}
-   */ _getIntersectData(data, needles) {
-        const result = [];
-        (0, _array.arrayEach)(needles, (needleRow)=>{
-            const row = needleRow.meta.row;
-            if (data[row] !== undefined) {
-                result[row] = data[row];
-            }
-        });
-        return result;
-    }
-    /**
    * Initializes the data filter with a condition collection that provides filtering logic and a factory function that supplies column source data.
    */ constructor(conditionCollection, columnDataFactory = ()=>[]){
         this.conditionCollection = conditionCollection;

package/plugins/filters/dataFilter.mjs

@@ -1,4 +1,4 @@
-import { arrayEach } from '../../helpers/array.mjs';
+import { arrayEach, arrayMap } from '../../helpers/array.mjs';
 /**
  * @private
  * @class DataFilter
@@ -10,9 +10,14 @@ import { arrayEach } from '../../helpers/array.mjs';
    */ filter() {
         let filteredData = [];
         arrayEach(this.conditionCollection.getFilteredColumns(), (physicalColumn, index)=>{
-            let columnData = this.columnDataFactory(physicalColumn);
+            let columnData;
             if (index) {
-                columnData = this._getIntersectData(columnData, filteredData);
+                // Materialize only the rows that survived the previous columns' conditions instead of
+                // re-reading (and re-creating cell meta for) every source row once per filtered column.
+                const survivingRows = arrayMap(filteredData, (rowData)=>rowData.row);
+                columnData = this.columnDataFactory(physicalColumn, survivingRows);
+            } else {
+                columnData = this.columnDataFactory(physicalColumn);
             }
             filteredData = this.filterByColumn(physicalColumn, columnData);
         });
@@ -34,23 +39,6 @@ import { arrayEach } from '../../helpers/array.mjs';
         return filteredData;
     }
     /**
-   * Intersect data.
-   *
-   * @private
-   * @param {Array} data The data to intersect.
-   * @param {Array} needles The collection intersected rows with the data.
-   * @returns {Array}
-   */ _getIntersectData(data, needles) {
-        const result = [];
-        arrayEach(needles, (needleRow)=>{
-            const row = needleRow.meta.row;
-            if (data[row] !== undefined) {
-                result[row] = data[row];
-            }
-        });
-        return result;
-    }
-    /**
    * Initializes the data filter with a condition collection that provides filtering logic and a factory function that supplies column source data.
    */ constructor(conditionCollection, columnDataFactory = ()=>[]){
         this.conditionCollection = conditionCollection;

package/plugins/filters/filters.d.ts

@@ -4,7 +4,7 @@ import ConditionCollection from './conditionCollection';
 import DataFilter from './dataFilter';
 import ConditionUpdateObserver from './conditionUpdateObserver';
 import type { DropdownMenu } from '../dropdownMenu/dropdownMenu';
-import { TrimmingMap } from '../../translations';
+import type { TrimmingMap } from '../../translations';
 import type { BaseComponent } from './component/_base';
 export type OperationType = 'conjunction' | 'disjunction' | 'disjunctionWithExtraCondition';
 export interface ConditionId {
@@ -204,7 +204,7 @@ export declare class Filters extends 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 | `[]` |
@@ -558,6 +558,9 @@ export declare class Filters extends 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: number): void;
@@ -571,16 +574,18 @@ export declare class Filters extends 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: ColumnConditions[]): void;
     /**
      * 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
      * [
@@ -613,11 +618,11 @@ export declare class Filters extends BasePlugin {
      */
     filter(): void;
     /**
-     * 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(): {
         physicalIndex: number;
@@ -626,12 +631,16 @@ export declare class Filters extends 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.
+     * @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: number): Record<string, unknown>[];
+    getDataMapAtColumn(physicalColumn: number, physicalRows?: number[]): Record<string, unknown>[];
     /**
      * Update the condition of ValueComponent, based on the handled changes.
      *
@@ -670,6 +679,21 @@ export declare class Filters extends BasePlugin {
      * @private
      */
     updateDependentComponentsVisibility(): void;
+    /**
+     * 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: number): Record<string, unknown>[];
     /**
      * Creates DataFilter instance based on condition collection.
      *