handsontable 18.0.0 → 18.1.0-rc7

package/dataMap/metaManager/mods/dynamicCellMeta.mjs

@@ -1,6 +1,112 @@
+function _check_private_redeclaration(obj, privateCollection) {
+    if (privateCollection.has(obj)) {
+        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");
+    }
+    return fn;
+}
+function _class_private_method_init(obj, privateSet) {
+    _check_private_redeclaration(obj, privateSet);
+    privateSet.add(obj);
+}
 import { Hooks } from '../../../core/hooks/index.mjs';
-import { hasOwnProperty } from '../../../helpers/object.mjs';
+import { hasOwnProperty, extend } from '../../../helpers/object.mjs';
 import { isFunction } from '../../../helpers/function.mjs';
+import { extendByMetaType } from '../utils.mjs';
+var /**
+   * The lowest visual row index of the meta "keep band" tracked by the previous eviction pass - the
+   * viewport plus a one-viewport hysteresis margin. The next pass evicts the visual rows that fall
+   * between this band and the new one (the rows that just scrolled out), so the work is proportional
+   * to the scroll distance, not the number of materialized rows.
+   *
+   * @type {number}
+   */ _keepBandStart = /*#__PURE__*/ new WeakMap(), /**
+   * The highest visual row index of the meta "keep band". See `#keepBandStart`.
+   *
+   * @type {number}
+   */ _keepBandEnd = /*#__PURE__*/ new WeakMap(), /**
+   * Whether a keep band has been recorded yet. A separate flag (rather than a sentinel value) is
+   * required because a valid `#keepBandStart` is often negative near the top of the grid (the
+   * viewport start minus the hysteresis margin), so no numeric sentinel is safe.
+   *
+   * @type {boolean}
+   */ _keepBandInitialized = /*#__PURE__*/ new WeakMap(), /**
+   * Runs the dynamic-extension sequence on a cell meta object: resolves `prop`, fires
+   * `beforeGetCellMeta`, evaluates the `cells` function and the `type` value it (or the hook)
+   * produced, hands the resulting settings to the caller-provided applier, and fires
+   * `afterGetCellMeta`. The applier is the only step that differs between the stored path
+   * (persist through `updateCellMeta`) and the transient path (extend the throwaway object).
+   *
+   * @param {object} cellMeta The cell meta object to extend.
+   * @param {Function} applyCellSettings Receives the resolved `cells`/`type` settings object.
+   */ _runMetaExtension = /*#__PURE__*/ new WeakSet(), /**
+   * Evicts render-derived cell meta for rows that scrolled out of the viewport, bounding meta
+   * retention to roughly the visible rows plus a one-viewport hysteresis margin on each side ("keep
+   * band"). Only the visual rows that fall between the previous keep band and the new one are visited
+   * (the rows that just left), so the cost is proportional to the scroll distance, NOT to the number
+   * of materialized rows - a grid with many `setCellMeta`/`cell`-option rows pays nothing extra here.
+   * The band is tracked in visual space and never reset, so a full render that does not move the
+   * viewport produces an empty diff (no work). Row-axis only - the vertical axis is the large one;
+   * horizontal scrolling does not evict.
+   */ _evictMetaOutsideViewport = /*#__PURE__*/ new WeakSet(), /**
+   * Evicts render-derived cell meta for an inclusive range of visual rows. Each visual row is
+   * translated to its physical index (cell meta is keyed physically) reading the mapping fresh, so a
+   * sort or move that happened since the band was recorded resolves correctly. Only the active
+   * editor's row is skipped - the selection highlight (focus) cell, where the prepared or active
+   * editor holds the cell meta object by reference (see `BaseEditor#cellProperties`). The remaining
+   * rows of a wide selection (whole column, multi-row) must stay evictable, or they would pin their
+   * cell meta and defeat the viewport bound.
+   *
+   * @param {number} fromVisualRow The first visual row index in the range (inclusive).
+   * @param {number} toVisualRow The last visual row index in the range (inclusive).
+   */ _evictVisualRowRange = /*#__PURE__*/ new WeakSet(), /**
+   * Evicts the render-derived cell meta of a single physical row and prunes the matching
+   * `metaSyncMemo` entries for ONLY the columns that were actually evicted. A re-minted cell then
+   * re-runs its dynamic extension, while persisted/invalid cells kept on the same row retain their
+   * memo - so they are not needlessly re-extended (which could let a `cells()` result overwrite a
+   * `setCellMeta` value). The whole memo row is dropped once empty, keeping the memo bounded.
+   *
+   * @param {number} physicalRow The physical row index to evict.
+   */ _evictRowAndPruneMemo = /*#__PURE__*/ new WeakSet();
 /**
  * Modifier that extends cell meta objects dynamically through Handsontable hooks and the `cells` option,
  * memoizing results per render cycle to avoid redundant work.
@@ -21,47 +127,165 @@ import { isFunction } from '../../../helpers/function.mjs';
         if (this.metaSyncMemo.get(physicalRow)?.has(physicalColumn)) {
             return;
         }
-        const visualRow = cellMeta.visualRow;
-        const visualCol = cellMeta.visualCol;
-        const hot = this.metaManager.hot;
-        const prop = hot.colToProp(visualCol);
-        cellMeta.prop = prop;
-        hot.runHooks('beforeGetCellMeta', visualRow, visualCol, cellMeta);
-        // extend a `type` value, added or changed in the `beforeGetCellMeta` hook
-        const cellType = hasOwnProperty(cellMeta, 'type') ? cellMeta.type : null;
-        let cellSettings = isFunction(cellMeta.cells) ? cellMeta.cells(physicalRow, physicalColumn, prop) : null;
-        if (cellType) {
-            if (cellSettings) {
-                cellSettings.type = cellSettings.type ?? cellType;
-            } else {
-                cellSettings = {
-                    type: cellType
-                };
-            }
-        }
-        if (cellSettings) {
+        _class_private_method_get(this, _runMetaExtension, runMetaExtension).call(this, cellMeta, (cellSettings)=>{
             this.metaManager.updateCellMeta(physicalRow, physicalColumn, cellSettings);
+        });
+        let memoRow = this.metaSyncMemo.get(physicalRow);
+        if (memoRow === undefined) {
+            memoRow = new Set();
+            this.metaSyncMemo.set(physicalRow, memoRow);
         }
-        hot.runHooks('afterGetCellMeta', visualRow, visualCol, cellMeta);
-        if (!this.metaSyncMemo.has(physicalRow)) {
-            this.metaSyncMemo.set(physicalRow, new Set());
-        }
-        this.metaSyncMemo.get(physicalRow).add(physicalColumn);
+        memoRow.add(physicalColumn);
     }
     /**
-   * Initializes the modifier, registers the `afterGetCellMeta` local hook, and subscribes to `beforeRender` to clear the memo on full renders.
+   * Extends a transient (not stored) cell meta object by the same user-specific properties as
+   * `extendCellMeta`, with two deliberate differences. The `cells`/`type` settings are applied
+   * directly on the transient object - never through `updateCellMeta`, which would permanently
+   * materialize the cell. And `metaSyncMemo` is neither read nor written: the memo must reflect only
+   * STORED meta objects, or a stored cell created later would skip its extension (a rendering bug),
+   * and memo growth would defeat the point of a retention-free scan.
+   *
+   * @param {object} cellMeta The transient cell meta object.
+   */ extendTransientCellMeta(cellMeta) {
+        _class_private_method_get(this, _runMetaExtension, runMetaExtension).call(this, cellMeta, (cellSettings)=>{
+            extend(cellMeta, cellSettings);
+            extendByMetaType(cellMeta, cellSettings);
+        });
+    }
+    /**
+   * Initializes the modifier, registers the `afterGetCellMeta` local hook, subscribes to `beforeRender`
+   * to clear the memo on full renders, and subscribes to `afterScrollVertically` and `afterViewRender`
+   * to evict render-derived cell meta for rows that left the viewport.
    */ constructor(metaManager){
+        _class_private_method_init(this, _runMetaExtension);
+        _class_private_method_init(this, _evictMetaOutsideViewport);
+        _class_private_method_init(this, _evictVisualRowRange);
+        _class_private_method_init(this, _evictRowAndPruneMemo);
+        _class_private_field_init(this, _keepBandStart, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _keepBandEnd, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _keepBandInitialized, {
+            writable: true,
+            value: void 0
+        });
         /**
-   * @type {Map}
+   * Per-render-cycle memo of cells already extended by `extendCellMeta`, keyed by physical row to a
+   * set of physical columns.
+   *
+   * @type {Map<number, Set<number>>}
    */ this.metaSyncMemo = new Map();
+        _class_private_field_set(this, _keepBandStart, 0);
+        _class_private_field_set(this, _keepBandEnd, 0);
+        _class_private_field_set(this, _keepBandInitialized, false);
         this.metaManager = metaManager;
-        metaManager.addLocalHook('afterGetCellMeta', (...args)=>{
-            this.extendCellMeta(args[0]);
+        metaManager.addLocalHook('afterGetCellMeta', (cellMeta)=>{
+            this.extendCellMeta(cellMeta);
+        });
+        metaManager.addLocalHook('extendTransientCellMeta', (cellMeta)=>{
+            this.extendTransientCellMeta(cellMeta);
         });
+        // These hooks are registered through `Hooks.getSingleton().add(..., hot)` rather than
+        // `hot.addHook(...)` on purpose: this modifier is constructed from the `MetaManager`
+        // constructor, which runs early in `Core` setup - before `hot.addHook` is defined. The
+        // singleton form binds the callback to the `hot` instance and is cleaned up on `hot.destroy()`
+        // exactly like `hot.addHook` would be, so this is equivalent once the instance is ready.
         Hooks.getSingleton().add('beforeRender', (forceFullRender)=>{
             if (forceFullRender) {
                 this.metaSyncMemo.clear();
             }
         }, this.metaManager.hot);
+        const evict = ()=>_class_private_method_get(this, _evictMetaOutsideViewport, evictMetaOutsideViewport).call(this);
+        // Scrolling materializes cell meta for newly visible rows; evict the rows that left the viewport.
+        Hooks.getSingleton().add('afterScrollVertically', evict, this.metaManager.hot);
+        // A full render (for example after a sort or filter) can leave behind meta for rows that are no
+        // longer in view; run the same pass so retention stays bounded regardless of what triggered it.
+        Hooks.getSingleton().add('afterViewRender', evict, this.metaManager.hot);
+    }
+}
+function runMetaExtension(cellMeta, applyCellSettings) {
+    const physicalRow = cellMeta.row;
+    const physicalColumn = cellMeta.col;
+    const visualRow = cellMeta.visualRow;
+    const visualCol = cellMeta.visualCol;
+    const hot = this.metaManager.hot;
+    const prop = hot.colToProp(visualCol);
+    cellMeta.prop = prop;
+    hot.runHooks('beforeGetCellMeta', visualRow, visualCol, cellMeta);
+    // extend a `type` value, added or changed in the `beforeGetCellMeta` hook
+    const cellType = hasOwnProperty(cellMeta, 'type') ? cellMeta.type : null;
+    let cellSettings = isFunction(cellMeta.cells) ? cellMeta.cells(physicalRow, physicalColumn, prop) : null;
+    if (cellType) {
+        if (cellSettings) {
+            cellSettings.type = cellSettings.type ?? cellType;
+        } else {
+            cellSettings = {
+                type: cellType
+            };
+        }
+    }
+    if (cellSettings) {
+        applyCellSettings(cellSettings);
+    }
+    hot.runHooks('afterGetCellMeta', visualRow, visualCol, cellMeta);
+}
+function evictMetaOutsideViewport() {
+    const hot = this.metaManager.hot;
+    const firstVisibleRow = hot.getFirstRenderedVisibleRow();
+    const lastVisibleRow = hot.getLastRenderedVisibleRow();
+    // The render-range getters are typed `number` but return `null` when the viewport is not yet
+    // calculated; `Number.isInteger` rejects that case without a type-level null comparison.
+    if (!Number.isInteger(firstVisibleRow) || !Number.isInteger(lastVisibleRow) || lastVisibleRow < firstVisibleRow) {
+        return;
+    }
+    const viewportSize = lastVisibleRow - firstVisibleRow + 1;
+    const keepStart = firstVisibleRow - viewportSize;
+    const keepEnd = lastVisibleRow + viewportSize;
+    const previousStart = _class_private_field_get(this, _keepBandStart);
+    const previousEnd = _class_private_field_get(this, _keepBandEnd);
+    if (_class_private_field_get(this, _keepBandInitialized)) {
+        // Previously-kept rows now above the band (visual index below the new keep-band start).
+        _class_private_method_get(this, _evictVisualRowRange, evictVisualRowRange).call(this, previousStart, Math.min(previousEnd, keepStart - 1));
+        // Previously-kept rows now below the band (visual index above the new keep-band end).
+        _class_private_method_get(this, _evictVisualRowRange, evictVisualRowRange).call(this, Math.max(previousStart, keepEnd + 1), previousEnd);
+    }
+    _class_private_field_set(this, _keepBandStart, keepStart);
+    _class_private_field_set(this, _keepBandEnd, keepEnd);
+    _class_private_field_set(this, _keepBandInitialized, true);
+}
+function evictVisualRowRange(fromVisualRow, toVisualRow) {
+    if (fromVisualRow > toVisualRow) {
+        return;
+    }
+    const hot = this.metaManager.hot;
+    const selectedRange = hot.getSelectedRangeLast();
+    const activeEditorRow = selectedRange ? selectedRange.highlight.row : null;
+    for(let visualRow = fromVisualRow; visualRow <= toVisualRow; visualRow++){
+        const physicalRow = hot.toPhysicalRow(visualRow);
+        // `toPhysicalRow` is typed `number` but returns `null` for an out-of-range visual row (for
+        // example after trimming); `Number.isInteger` filters that without a type-level null compare.
+        if (visualRow !== activeEditorRow && Number.isInteger(physicalRow)) {
+            _class_private_method_get(this, _evictRowAndPruneMemo, evictRowAndPruneMemo).call(this, physicalRow);
+        }
+    }
+}
+function evictRowAndPruneMemo(physicalRow) {
+    const evictedColumns = this.metaManager.cellMeta.evictRow(physicalRow);
+    if (evictedColumns.length === 0) {
+        return;
+    }
+    const memoRow = this.metaSyncMemo.get(physicalRow);
+    if (memoRow === undefined) {
+        return;
+    }
+    for(let i = 0; i < evictedColumns.length; i++){
+        memoRow.delete(evictedColumns[i]);
+    }
+    if (memoRow.size === 0) {
+        this.metaSyncMemo.delete(physicalRow);
     }
 }

package/dataMap/sourceDataValidator.d.ts

@@ -1,19 +1,5 @@
 import type { HotInstance } from '../core/types';
-type SourceDataValidatorFn = {
-    (value: unknown, cellMeta: CellMeta, source?: string): boolean;
-    /**
-     * When `true`, the validator's result depends only on the value and column/global-level meta, never
-     * on per-row meta — so a single column-level meta object can validate every row of the column.
-     */
-    rowIndependent?: boolean;
-};
-type CellMeta = Record<string, unknown> & {
-    sourceDataValidator?: SourceDataValidatorFn;
-    sourceDataWarningMessage?: string;
-    allowInvalid?: boolean;
-    row?: number;
-    col?: number;
-};
+import type { CellProperties } from '../settings';
 /**
  * Runs source-data validator for a single cell.
  *
@@ -22,18 +8,24 @@ type CellMeta = Record<string, unknown> & {
  * @param {string} [source] The source identifier of the operation.
  * @returns {boolean} `true` when the value is valid (or no validator is configured).
  */
-export declare function runSourceDataValidator(value: unknown, cellMeta: CellMeta, source?: string): boolean;
+export declare function runSourceDataValidator(value: unknown, cellMeta: CellProperties, source?: string): boolean;
 /**
  * Runs source-data validators for all cells and emits one aggregated warning per cell type.
  *
- * For the common case (no `cells` function, no `cell` array, no `before`/`afterGetCellMeta` hooks, no
- * imperatively-set cell meta, and only row-independent built-in source validators such as `date`/`time`),
- * validation reuses one column-level meta per column — avoiding the O(rows*cols) cell-meta
- * materialization that otherwise retains a meta object for every cell at load.
+ * Meta is resolved with `getCellMetaUncached`, so validation considers the global and column layers,
+ * the declarative `cell` option, and imperative `setCellMeta` overrides — but never a `cells` function
+ * or the `before`/`afterGetCellMeta` hooks. A cheap O(cols) column probe decides the path:
+ *
+ * - No column exposes a `sourceDataValidator` and no cell carries persistent per-cell meta — there is
+ *   nothing to validate, so the scan is skipped entirely. This is what keeps a large grid with a
+ *   `cells` function (but no validators) from resolving meta for the whole dataset on every load.
+ * - Only row-independent built-in validators (`date`/`time`/`intlDate`/`intlTime`) and no persistent
+ *   per-cell meta — validation reuses one column-level meta per column (O(cols)).
+ * - A row-dependent custom validator, or persistent per-cell meta (`cell`/`setCellMeta`) — validation
+ *   resolves each cell uncached (O(rows*cols) work, but no retained per-cell meta objects).
  *
  * @param {HotInstance} hotInstance The Handsontable instance.
  * @param {string} [source] The source identifier of the operation.
  * @returns {void}
  */
 export declare function runSourceDataValidators(hotInstance: HotInstance, source?: string): void;
-export {};

package/dataMap/sourceDataValidator.js

@@ -77,29 +77,29 @@ function runSourceDataValidator(value, cellMeta, source) {
     }
 }
 /**
- * Inspects column-level meta (one sample cell per column, O(cols)) to decide how source-data
- * validation should run. Returns the columns whose validator is row-independent (safe to validate by
- * reusing one column meta), or signals a full per-cell scan when any column carries a validator that
- * may depend on per-row meta.
+ * Inspects column-level meta (one uncached sample per column, O(cols)) to decide how source-data
+ * validation should run. Meta is resolved through `getCellMetaUncached`, so the sample reflects the
+ * global and column layers only — the `cells` function and the `before`/`afterGetCellMeta` hooks are
+ * never run here (see `runSourceDataValidators`). Because column meta does not vary by row, the sample
+ * is taken at physical row 0 regardless of trimming. Returns the columns whose validator is
+ * row-independent (safe to validate by reusing one column meta), or signals a full per-cell scan when
+ * any column carries a validator that may depend on per-row meta.
  *
  * @param {HotInstance} hotInstance The Handsontable instance.
  * @param {number} colSourceCount The number of physical source columns.
  * @returns {object} `{ fullScan, columns }` — when `fullScan` is `true`, `columns` is empty.
  */ function collectColumnValidators(hotInstance, colSourceCount) {
-    const sampleVisualRow = hotInstance.rowIndexMapper.getVisualFromPhysicalIndex(0);
-    if (sampleVisualRow === null) {
-        return {
-            fullScan: true,
-            columns: []
-        };
-    }
+    const metaManager = hotInstance._getMetaManager();
     const columns = [];
     for(let physicalColumn = 0; physicalColumn < colSourceCount; physicalColumn += 1){
         const visualColumn = hotInstance.columnIndexMapper.getVisualFromPhysicalIndex(physicalColumn);
         if (visualColumn === null) {
             continue;
         }
-        const cellMeta = hotInstance.getCellMeta(sampleVisualRow, visualColumn);
+        const cellMeta = metaManager.getCellMetaUncached(0, physicalColumn, {
+            visualRow: 0,
+            visualColumn
+        });
         const validator = cellMeta.sourceDataValidator;
         if (!(0, _function.isFunction)(validator)) {
             continue;
@@ -123,8 +123,11 @@ function runSourceDataValidator(value, cellMeta, source) {
     };
 }
 /**
- * Validates every source cell by resolving meta per cell (O(rows*cols) meta). Used when per-cell meta
- * can vary by row (a `cells` function, a `cell` array, or a row-dependent custom validator).
+ * Validates every source cell by resolving meta per cell (O(rows*cols) meta). Used when a
+ * row-dependent custom validator is configured, or when a cell carries persistent per-cell meta (the
+ * `cell` option or `setCellMeta`) that a single column sample cannot represent. Meta is resolved with
+ * `getCellMetaUncached`, so no per-cell meta object is retained (the scan does not grow the meta cache
+ * to O(rows*cols)) and the `cells` function / `before`/`afterGetCellMeta` hooks are not run.
  *
  * @param {HotInstance} hotInstance The Handsontable instance.
  * @param {DataSource} dataSource The data source.
@@ -135,6 +138,7 @@ function runSourceDataValidator(value, cellMeta, source) {
  * @returns {void}
  */ function validatePerCell(hotInstance, dataSource, rowSourceCount, colSourceCount, invalidByMessageType, source) {
     const { rowIndexMapper, columnIndexMapper } = hotInstance;
+    const metaManager = hotInstance._getMetaManager();
     for(let row = 0; row < rowSourceCount; row += 1){
         for(let col = 0; col < colSourceCount; col += 1){
             const visualRow = rowIndexMapper.getVisualFromPhysicalIndex(row);
@@ -142,7 +146,10 @@ function runSourceDataValidator(value, cellMeta, source) {
             if (visualRow === null || visualColumn === null) {
                 continue;
             }
-            const cellMeta = hotInstance.getCellMeta(visualRow, visualColumn);
+            const cellMeta = metaManager.getCellMetaUncached(row, col, {
+                visualRow,
+                visualColumn
+            });
             if (!(0, _function.isFunction)(cellMeta.sourceDataValidator)) {
                 continue;
             }
@@ -180,16 +187,18 @@ function runSourceDataValidator(value, cellMeta, source) {
     }
 }
 /**
- * Detects whether per-cell meta can vary by row, which makes the row-0 sample unsafe to reuse for the
- * whole column. Meta varies through a `cells` function, an explicit `cell` array, the
- * `beforeGetCellMeta`/`afterGetCellMeta` hooks (a row-dependent `type`/validator/`allowInvalid` can be
- * applied there), or any imperatively-set cell meta (`setCellMeta`) that survives `updateData`.
+ * Detects whether any cell carries persistent per-cell meta that a single column sample cannot
+ * represent — the declarative `cell` option or imperatively-set cell meta (`setCellMeta`). These are
+ * the only per-row sources that `getCellMetaUncached` resolves, so they force the per-cell scan. The
+ * `cells` function and the `before`/`afterGetCellMeta` hooks are deliberately NOT considered here:
+ * source-data validation resolves meta uncached and never runs them, so they cannot change which
+ * cells carry a `sourceDataValidator`.
  *
  * @param {HotInstance} hotInstance The Handsontable instance.
  * @param {GridSettings} settings The resolved grid settings.
  * @returns {boolean} `true` when meta must be resolved per cell.
- */ function hasRowVaryingMeta(hotInstance, settings) {
-    return (0, _function.isFunction)(settings.cells) || Array.isArray(settings.cell) && settings.cell.length > 0 || hotInstance.hasHook('beforeGetCellMeta') || hotInstance.hasHook('afterGetCellMeta') || hotInstance._getMetaManager().getUserDefinedCellMetas().length > 0;
+ */ function hasStoredPerCellMeta(hotInstance, settings) {
+    return Array.isArray(settings.cell) && settings.cell.length > 0 || hotInstance._getMetaManager().getUserDefinedCellMetas().length > 0;
 }
 function runSourceDataValidators(hotInstance, source) {
     const rowSourceCount = hotInstance.countSourceRows();
@@ -200,16 +209,17 @@ function runSourceDataValidators(hotInstance, source) {
     const settings = hotInstance.getSettings();
     const dataSource = hotInstance._getDataSource();
     const invalidByMessageType = new Map();
-    if (hasRowVaryingMeta(hotInstance, settings)) {
+    const { fullScan, columns } = collectColumnValidators(hotInstance, colSourceCount);
+    const hasStoredMeta = hasStoredPerCellMeta(hotInstance, settings);
+    // Nothing carries (or could carry) a source-data validator — skip the scan entirely.
+    if (!fullScan && columns.length === 0 && !hasStoredMeta) {
+        return;
+    }
+    if (fullScan || hasStoredMeta) {
         validatePerCell(hotInstance, dataSource, rowSourceCount, colSourceCount, invalidByMessageType, source);
     } else {
-        const { fullScan, columns } = collectColumnValidators(hotInstance, colSourceCount);
-        if (fullScan) {
-            validatePerCell(hotInstance, dataSource, rowSourceCount, colSourceCount, invalidByMessageType, source);
-        } else {
-            const toVisualRow = (row)=>hotInstance.rowIndexMapper.getVisualFromPhysicalIndex(row);
-            validateBatched(columns, dataSource, rowSourceCount, toVisualRow, invalidByMessageType, source);
-        }
+        const toVisualRow = (row)=>hotInstance.rowIndexMapper.getVisualFromPhysicalIndex(row);
+        validateBatched(columns, dataSource, rowSourceCount, toVisualRow, invalidByMessageType, source);
     }
     invalidByMessageType.forEach((items, message)=>{
         logSourceDataWarning(message, items);

package/dataMap/sourceDataValidator.mjs

@@ -66,29 +66,29 @@ import { stringify } from '../helpers/mixed.mjs';
     }
 }
 /**
- * Inspects column-level meta (one sample cell per column, O(cols)) to decide how source-data
- * validation should run. Returns the columns whose validator is row-independent (safe to validate by
- * reusing one column meta), or signals a full per-cell scan when any column carries a validator that
- * may depend on per-row meta.
+ * Inspects column-level meta (one uncached sample per column, O(cols)) to decide how source-data
+ * validation should run. Meta is resolved through `getCellMetaUncached`, so the sample reflects the
+ * global and column layers only — the `cells` function and the `before`/`afterGetCellMeta` hooks are
+ * never run here (see `runSourceDataValidators`). Because column meta does not vary by row, the sample
+ * is taken at physical row 0 regardless of trimming. Returns the columns whose validator is
+ * row-independent (safe to validate by reusing one column meta), or signals a full per-cell scan when
+ * any column carries a validator that may depend on per-row meta.
  *
  * @param {HotInstance} hotInstance The Handsontable instance.
  * @param {number} colSourceCount The number of physical source columns.
  * @returns {object} `{ fullScan, columns }` — when `fullScan` is `true`, `columns` is empty.
  */ function collectColumnValidators(hotInstance, colSourceCount) {
-    const sampleVisualRow = hotInstance.rowIndexMapper.getVisualFromPhysicalIndex(0);
-    if (sampleVisualRow === null) {
-        return {
-            fullScan: true,
-            columns: []
-        };
-    }
+    const metaManager = hotInstance._getMetaManager();
     const columns = [];
     for(let physicalColumn = 0; physicalColumn < colSourceCount; physicalColumn += 1){
         const visualColumn = hotInstance.columnIndexMapper.getVisualFromPhysicalIndex(physicalColumn);
         if (visualColumn === null) {
             continue;
         }
-        const cellMeta = hotInstance.getCellMeta(sampleVisualRow, visualColumn);
+        const cellMeta = metaManager.getCellMetaUncached(0, physicalColumn, {
+            visualRow: 0,
+            visualColumn
+        });
         const validator = cellMeta.sourceDataValidator;
         if (!isFunction(validator)) {
             continue;
@@ -112,8 +112,11 @@ import { stringify } from '../helpers/mixed.mjs';
     };
 }
 /**
- * Validates every source cell by resolving meta per cell (O(rows*cols) meta). Used when per-cell meta
- * can vary by row (a `cells` function, a `cell` array, or a row-dependent custom validator).
+ * Validates every source cell by resolving meta per cell (O(rows*cols) meta). Used when a
+ * row-dependent custom validator is configured, or when a cell carries persistent per-cell meta (the
+ * `cell` option or `setCellMeta`) that a single column sample cannot represent. Meta is resolved with
+ * `getCellMetaUncached`, so no per-cell meta object is retained (the scan does not grow the meta cache
+ * to O(rows*cols)) and the `cells` function / `before`/`afterGetCellMeta` hooks are not run.
  *
  * @param {HotInstance} hotInstance The Handsontable instance.
  * @param {DataSource} dataSource The data source.
@@ -124,6 +127,7 @@ import { stringify } from '../helpers/mixed.mjs';
  * @returns {void}
  */ function validatePerCell(hotInstance, dataSource, rowSourceCount, colSourceCount, invalidByMessageType, source) {
     const { rowIndexMapper, columnIndexMapper } = hotInstance;
+    const metaManager = hotInstance._getMetaManager();
     for(let row = 0; row < rowSourceCount; row += 1){
         for(let col = 0; col < colSourceCount; col += 1){
             const visualRow = rowIndexMapper.getVisualFromPhysicalIndex(row);
@@ -131,7 +135,10 @@ import { stringify } from '../helpers/mixed.mjs';
             if (visualRow === null || visualColumn === null) {
                 continue;
             }
-            const cellMeta = hotInstance.getCellMeta(visualRow, visualColumn);
+            const cellMeta = metaManager.getCellMetaUncached(row, col, {
+                visualRow,
+                visualColumn
+            });
             if (!isFunction(cellMeta.sourceDataValidator)) {
                 continue;
             }
@@ -169,24 +176,33 @@ import { stringify } from '../helpers/mixed.mjs';
     }
 }
 /**
- * Detects whether per-cell meta can vary by row, which makes the row-0 sample unsafe to reuse for the
- * whole column. Meta varies through a `cells` function, an explicit `cell` array, the
- * `beforeGetCellMeta`/`afterGetCellMeta` hooks (a row-dependent `type`/validator/`allowInvalid` can be
- * applied there), or any imperatively-set cell meta (`setCellMeta`) that survives `updateData`.
+ * Detects whether any cell carries persistent per-cell meta that a single column sample cannot
+ * represent — the declarative `cell` option or imperatively-set cell meta (`setCellMeta`). These are
+ * the only per-row sources that `getCellMetaUncached` resolves, so they force the per-cell scan. The
+ * `cells` function and the `before`/`afterGetCellMeta` hooks are deliberately NOT considered here:
+ * source-data validation resolves meta uncached and never runs them, so they cannot change which
+ * cells carry a `sourceDataValidator`.
  *
  * @param {HotInstance} hotInstance The Handsontable instance.
  * @param {GridSettings} settings The resolved grid settings.
  * @returns {boolean} `true` when meta must be resolved per cell.
- */ function hasRowVaryingMeta(hotInstance, settings) {
-    return isFunction(settings.cells) || Array.isArray(settings.cell) && settings.cell.length > 0 || hotInstance.hasHook('beforeGetCellMeta') || hotInstance.hasHook('afterGetCellMeta') || hotInstance._getMetaManager().getUserDefinedCellMetas().length > 0;
+ */ function hasStoredPerCellMeta(hotInstance, settings) {
+    return Array.isArray(settings.cell) && settings.cell.length > 0 || hotInstance._getMetaManager().getUserDefinedCellMetas().length > 0;
 }
 /**
  * Runs source-data validators for all cells and emits one aggregated warning per cell type.
  *
- * For the common case (no `cells` function, no `cell` array, no `before`/`afterGetCellMeta` hooks, no
- * imperatively-set cell meta, and only row-independent built-in source validators such as `date`/`time`),
- * validation reuses one column-level meta per column — avoiding the O(rows*cols) cell-meta
- * materialization that otherwise retains a meta object for every cell at load.
+ * Meta is resolved with `getCellMetaUncached`, so validation considers the global and column layers,
+ * the declarative `cell` option, and imperative `setCellMeta` overrides — but never a `cells` function
+ * or the `before`/`afterGetCellMeta` hooks. A cheap O(cols) column probe decides the path:
+ *
+ * - No column exposes a `sourceDataValidator` and no cell carries persistent per-cell meta — there is
+ *   nothing to validate, so the scan is skipped entirely. This is what keeps a large grid with a
+ *   `cells` function (but no validators) from resolving meta for the whole dataset on every load.
+ * - Only row-independent built-in validators (`date`/`time`/`intlDate`/`intlTime`) and no persistent
+ *   per-cell meta — validation reuses one column-level meta per column (O(cols)).
+ * - A row-dependent custom validator, or persistent per-cell meta (`cell`/`setCellMeta`) — validation
+ *   resolves each cell uncached (O(rows*cols) work, but no retained per-cell meta objects).
  *
  * @param {HotInstance} hotInstance The Handsontable instance.
  * @param {string} [source] The source identifier of the operation.
@@ -200,16 +216,17 @@ import { stringify } from '../helpers/mixed.mjs';
     const settings = hotInstance.getSettings();
     const dataSource = hotInstance._getDataSource();
     const invalidByMessageType = new Map();
-    if (hasRowVaryingMeta(hotInstance, settings)) {
+    const { fullScan, columns } = collectColumnValidators(hotInstance, colSourceCount);
+    const hasStoredMeta = hasStoredPerCellMeta(hotInstance, settings);
+    // Nothing carries (or could carry) a source-data validator — skip the scan entirely.
+    if (!fullScan && columns.length === 0 && !hasStoredMeta) {
+        return;
+    }
+    if (fullScan || hasStoredMeta) {
         validatePerCell(hotInstance, dataSource, rowSourceCount, colSourceCount, invalidByMessageType, source);
     } else {
-        const { fullScan, columns } = collectColumnValidators(hotInstance, colSourceCount);
-        if (fullScan) {
-            validatePerCell(hotInstance, dataSource, rowSourceCount, colSourceCount, invalidByMessageType, source);
-        } else {
-            const toVisualRow = (row)=>hotInstance.rowIndexMapper.getVisualFromPhysicalIndex(row);
-            validateBatched(columns, dataSource, rowSourceCount, toVisualRow, invalidByMessageType, source);
-        }
+        const toVisualRow = (row)=>hotInstance.rowIndexMapper.getVisualFromPhysicalIndex(row);
+        validateBatched(columns, dataSource, rowSourceCount, toVisualRow, invalidByMessageType, source);
     }
     invalidByMessageType.forEach((items, message)=>{
         logSourceDataWarning(message, items);