handsontable 18.0.0 → 18.1.0-rc1

package/dataMap/metaManager/mods/extendMetaProperties.js

@@ -15,15 +15,12 @@ function _check_private_redeclaration(obj, privateCollection) {
     }
 }
 function _class_apply_descriptor_get(receiver, descriptor) {
-    if (descriptor.get) {
-        return descriptor.get.call(receiver);
-    }
+    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.set) descriptor.set.call(receiver, value);
+    else {
         if (!descriptor.writable) {
             throw new TypeError("attempted to set read only private field");
         }
@@ -31,9 +28,7 @@ function _class_apply_descriptor_set(receiver, descriptor, value) {
     }
 }
 function _class_extract_field_descriptor(receiver, privateMap, action) {
-    if (!privateMap.has(receiver)) {
-        throw new TypeError("attempted to " + action + " private field on non-instance");
-    }
+    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) {

package/dataMap/metaManager/mods/extendMetaProperties.mjs

@@ -4,15 +4,12 @@ function _check_private_redeclaration(obj, privateCollection) {
     }
 }
 function _class_apply_descriptor_get(receiver, descriptor) {
-    if (descriptor.get) {
-        return descriptor.get.call(receiver);
-    }
+    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.set) descriptor.set.call(receiver, value);
+    else {
         if (!descriptor.writable) {
             throw new TypeError("attempted to set read only private field");
         }
@@ -20,9 +17,7 @@ function _class_apply_descriptor_set(receiver, descriptor, value) {
     }
 }
 function _class_extract_field_descriptor(receiver, privateMap, action) {
-    if (!privateMap.has(receiver)) {
-        throw new TypeError("attempted to " + action + " private field on non-instance");
-    }
+    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) {

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);