handsontable 18.0.0-rc4 → 18.0.0

package/dataMap/sourceDataValidator.js

@@ -40,45 +40,175 @@ function runSourceDataValidator(value, cellMeta, source) {
     }
     return allowInvalid === true;
 }
-function runSourceDataValidators(hotInstance, source) {
-    const rowSourceCount = hotInstance.countSourceRows();
-    const colSourceCount = hotInstance.countSourceCols();
-    if (rowSourceCount === 0 || colSourceCount === 0) {
+/**
+ * Validates a single source cell against its (already resolved) cell meta, blanking the value when it
+ * is invalid and `allowInvalid` is `false`, and collecting an aggregated-warning entry.
+ *
+ * @param {object} cellMeta The resolved cell meta (its `sourceDataValidator` must be a function).
+ * @param {unknown} value The source value to validate.
+ * @param {number} physicalRow The physical row index.
+ * @param {number} physicalColumn The physical column index.
+ * @param {object} dataSource The data source used to blank invalid values.
+ * @param {Map} invalidByMessageType The accumulator of invalid entries keyed by warning message.
+ * @param {string} [source] The source identifier of the operation.
+ * @returns {void}
+ */ function validateSourceCell(cellMeta, value, physicalRow, physicalColumn, dataSource, invalidByMessageType, source) {
+    const validator = cellMeta.sourceDataValidator;
+    if (!(0, _function.isFunction)(validator)) {
         return;
     }
-    const invalidByMessageType = new Map();
+    const isValid = validator(value, cellMeta, source);
+    if (isValid === true) {
+        return;
+    }
+    if (cellMeta.allowInvalid === false) {
+        dataSource.setAtCell(physicalRow, physicalColumn, null);
+    }
+    const message = cellMeta.sourceDataWarningMessage;
+    if (message) {
+        const list = invalidByMessageType.get(message) ?? [];
+        list.push({
+            row: physicalRow,
+            col: physicalColumn,
+            value,
+            message
+        });
+        invalidByMessageType.set(message, list);
+    }
+}
+/**
+ * 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.
+ *
+ * @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 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 validator = cellMeta.sourceDataValidator;
+        if (!(0, _function.isFunction)(validator)) {
+            continue;
+        }
+        // A validator that may read per-row meta cannot be batched with a single column meta — fall back
+        // to the per-cell scan for the whole dataset to preserve exact behavior.
+        if (validator.rowIndependent !== true) {
+            return {
+                fullScan: true,
+                columns: []
+            };
+        }
+        columns.push({
+            physicalColumn,
+            cellMeta
+        });
+    }
+    return {
+        fullScan: false,
+        columns
+    };
+}
+/**
+ * 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).
+ *
+ * @param {HotInstance} hotInstance The Handsontable instance.
+ * @param {DataSource} dataSource The data source.
+ * @param {number} rowSourceCount The number of physical source rows.
+ * @param {number} colSourceCount The number of physical source columns.
+ * @param {Map} invalidByMessageType The accumulator of invalid entries keyed by warning message.
+ * @param {string} [source] The source identifier of the operation.
+ * @returns {void}
+ */ function validatePerCell(hotInstance, dataSource, rowSourceCount, colSourceCount, invalidByMessageType, source) {
+    const { rowIndexMapper, columnIndexMapper } = hotInstance;
     for(let row = 0; row < rowSourceCount; row += 1){
         for(let col = 0; col < colSourceCount; col += 1){
-            const visualRow = hotInstance.toVisualRow(row);
-            const visualColumn = hotInstance.toVisualColumn(col);
+            const visualRow = rowIndexMapper.getVisualFromPhysicalIndex(row);
+            const visualColumn = columnIndexMapper.getVisualFromPhysicalIndex(col);
             if (visualRow === null || visualColumn === null) {
                 continue;
             }
             const cellMeta = hotInstance.getCellMeta(visualRow, visualColumn);
-            const { sourceDataWarningMessage, sourceDataValidator, allowInvalid } = cellMeta;
-            if (!(0, _function.isFunction)(sourceDataValidator)) {
+            if (!(0, _function.isFunction)(cellMeta.sourceDataValidator)) {
                 continue;
             }
-            const dataSource = hotInstance._getDataSource();
-            const value = dataSource.getAtCell(row, col, null);
-            const isValid = sourceDataValidator(value, cellMeta, source);
-            if (isValid === true) {
-                continue;
-            }
-            if (allowInvalid === false) {
-                dataSource.setAtCell(row, col, null);
-            }
-            if (sourceDataWarningMessage) {
-                const message = sourceDataWarningMessage;
-                const list = invalidByMessageType.get(message) ?? [];
-                list.push({
-                    row,
-                    col,
-                    value,
-                    message
-                });
-                invalidByMessageType.set(message, list);
-            }
+            const value = dataSource.getAtCell(row, col);
+            validateSourceCell(cellMeta, value, row, col, dataSource, invalidByMessageType, source);
+        }
+    }
+}
+/**
+ * Validates source cells while reusing one column-level meta object per column instead of
+ * materializing a meta object per cell (O(cols) meta instead of O(rows*cols)).
+ *
+ * Iterates row by row (column inner) so each physical row is translated to its visual index once and
+ * the aggregated-warning order stays row-major (matching the per-cell scan).
+ *
+ * @param {Array} columns The columns whose (row-independent) validator should run.
+ * @param {DataSource} dataSource The data source.
+ * @param {number} rowSourceCount The number of physical source rows.
+ * @param {Function} toVisualRow Translates a physical row index to its visual index (or `null`).
+ * @param {Map} invalidByMessageType The accumulator of invalid entries keyed by warning message.
+ * @param {string} [source] The source identifier of the operation.
+ * @returns {void}
+ */ function validateBatched(columns, dataSource, rowSourceCount, toVisualRow, invalidByMessageType, source) {
+    for(let row = 0; row < rowSourceCount; row += 1){
+        // Skip rows that have no visual index (trimmed rows) to match the per-cell scan, which never
+        // validates or blanks source values for rows that map to `null`.
+        if (toVisualRow(row) === null) {
+            continue;
+        }
+        for(let i = 0; i < columns.length; i += 1){
+            const { physicalColumn, cellMeta } = columns[i];
+            const value = dataSource.getAtCell(row, physicalColumn);
+            validateSourceCell(cellMeta, value, row, physicalColumn, dataSource, invalidByMessageType, 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`.
+ *
+ * @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 runSourceDataValidators(hotInstance, source) {
+    const rowSourceCount = hotInstance.countSourceRows();
+    const colSourceCount = hotInstance.countSourceCols();
+    if (rowSourceCount === 0 || colSourceCount === 0) {
+        return;
+    }
+    const settings = hotInstance.getSettings();
+    const dataSource = hotInstance._getDataSource();
+    const invalidByMessageType = new Map();
+    if (hasRowVaryingMeta(hotInstance, settings)) {
+        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);
         }
     }
     invalidByMessageType.forEach((items, message)=>{
@@ -86,7 +216,11 @@ function runSourceDataValidators(hotInstance, source) {
     });
 }
 /**
+ * Emits one aggregated console warning for a group of invalid source-data cells.
  *
+ * @param {string} message The warning message template.
+ * @param {Array} items The invalid cell entries to report.
+ * @returns {void}
  */ function logSourceDataWarning(message, items) {
     (0, _console.logAggregatedItems)({
         logFunction: _console.warn,

package/dataMap/sourceDataValidator.mjs

@@ -3,6 +3,11 @@ import { isFunction } from '../helpers/function.mjs';
 import { stringify } from '../helpers/mixed.mjs';
 /**
  * Runs source-data validator for a single cell.
+ *
+ * @param {unknown} value The value to validate.
+ * @param {object} cellMeta The cell meta object.
+ * @param {string} [source] The source identifier of the operation.
+ * @returns {boolean} `true` when the value is valid (or no validator is configured).
  */ export function runSourceDataValidator(value, cellMeta, source) {
     const validator = cellMeta.sourceDataValidator;
     if (!isFunction(validator)) {
@@ -25,46 +30,185 @@ import { stringify } from '../helpers/mixed.mjs';
     return allowInvalid === true;
 }
 /**
- * Runs source-data validators for all cells and emits one aggregated warning per cell type.
- */ export function runSourceDataValidators(hotInstance, source) {
-    const rowSourceCount = hotInstance.countSourceRows();
-    const colSourceCount = hotInstance.countSourceCols();
-    if (rowSourceCount === 0 || colSourceCount === 0) {
+ * Validates a single source cell against its (already resolved) cell meta, blanking the value when it
+ * is invalid and `allowInvalid` is `false`, and collecting an aggregated-warning entry.
+ *
+ * @param {object} cellMeta The resolved cell meta (its `sourceDataValidator` must be a function).
+ * @param {unknown} value The source value to validate.
+ * @param {number} physicalRow The physical row index.
+ * @param {number} physicalColumn The physical column index.
+ * @param {object} dataSource The data source used to blank invalid values.
+ * @param {Map} invalidByMessageType The accumulator of invalid entries keyed by warning message.
+ * @param {string} [source] The source identifier of the operation.
+ * @returns {void}
+ */ function validateSourceCell(cellMeta, value, physicalRow, physicalColumn, dataSource, invalidByMessageType, source) {
+    const validator = cellMeta.sourceDataValidator;
+    if (!isFunction(validator)) {
         return;
     }
-    const invalidByMessageType = new Map();
+    const isValid = validator(value, cellMeta, source);
+    if (isValid === true) {
+        return;
+    }
+    if (cellMeta.allowInvalid === false) {
+        dataSource.setAtCell(physicalRow, physicalColumn, null);
+    }
+    const message = cellMeta.sourceDataWarningMessage;
+    if (message) {
+        const list = invalidByMessageType.get(message) ?? [];
+        list.push({
+            row: physicalRow,
+            col: physicalColumn,
+            value,
+            message
+        });
+        invalidByMessageType.set(message, list);
+    }
+}
+/**
+ * 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.
+ *
+ * @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 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 validator = cellMeta.sourceDataValidator;
+        if (!isFunction(validator)) {
+            continue;
+        }
+        // A validator that may read per-row meta cannot be batched with a single column meta — fall back
+        // to the per-cell scan for the whole dataset to preserve exact behavior.
+        if (validator.rowIndependent !== true) {
+            return {
+                fullScan: true,
+                columns: []
+            };
+        }
+        columns.push({
+            physicalColumn,
+            cellMeta
+        });
+    }
+    return {
+        fullScan: false,
+        columns
+    };
+}
+/**
+ * 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).
+ *
+ * @param {HotInstance} hotInstance The Handsontable instance.
+ * @param {DataSource} dataSource The data source.
+ * @param {number} rowSourceCount The number of physical source rows.
+ * @param {number} colSourceCount The number of physical source columns.
+ * @param {Map} invalidByMessageType The accumulator of invalid entries keyed by warning message.
+ * @param {string} [source] The source identifier of the operation.
+ * @returns {void}
+ */ function validatePerCell(hotInstance, dataSource, rowSourceCount, colSourceCount, invalidByMessageType, source) {
+    const { rowIndexMapper, columnIndexMapper } = hotInstance;
     for(let row = 0; row < rowSourceCount; row += 1){
         for(let col = 0; col < colSourceCount; col += 1){
-            const visualRow = hotInstance.toVisualRow(row);
-            const visualColumn = hotInstance.toVisualColumn(col);
+            const visualRow = rowIndexMapper.getVisualFromPhysicalIndex(row);
+            const visualColumn = columnIndexMapper.getVisualFromPhysicalIndex(col);
             if (visualRow === null || visualColumn === null) {
                 continue;
             }
             const cellMeta = hotInstance.getCellMeta(visualRow, visualColumn);
-            const { sourceDataWarningMessage, sourceDataValidator, allowInvalid } = cellMeta;
-            if (!isFunction(sourceDataValidator)) {
-                continue;
-            }
-            const dataSource = hotInstance._getDataSource();
-            const value = dataSource.getAtCell(row, col, null);
-            const isValid = sourceDataValidator(value, cellMeta, source);
-            if (isValid === true) {
+            if (!isFunction(cellMeta.sourceDataValidator)) {
                 continue;
             }
-            if (allowInvalid === false) {
-                dataSource.setAtCell(row, col, null);
-            }
-            if (sourceDataWarningMessage) {
-                const message = sourceDataWarningMessage;
-                const list = invalidByMessageType.get(message) ?? [];
-                list.push({
-                    row,
-                    col,
-                    value,
-                    message
-                });
-                invalidByMessageType.set(message, list);
-            }
+            const value = dataSource.getAtCell(row, col);
+            validateSourceCell(cellMeta, value, row, col, dataSource, invalidByMessageType, source);
+        }
+    }
+}
+/**
+ * Validates source cells while reusing one column-level meta object per column instead of
+ * materializing a meta object per cell (O(cols) meta instead of O(rows*cols)).
+ *
+ * Iterates row by row (column inner) so each physical row is translated to its visual index once and
+ * the aggregated-warning order stays row-major (matching the per-cell scan).
+ *
+ * @param {Array} columns The columns whose (row-independent) validator should run.
+ * @param {DataSource} dataSource The data source.
+ * @param {number} rowSourceCount The number of physical source rows.
+ * @param {Function} toVisualRow Translates a physical row index to its visual index (or `null`).
+ * @param {Map} invalidByMessageType The accumulator of invalid entries keyed by warning message.
+ * @param {string} [source] The source identifier of the operation.
+ * @returns {void}
+ */ function validateBatched(columns, dataSource, rowSourceCount, toVisualRow, invalidByMessageType, source) {
+    for(let row = 0; row < rowSourceCount; row += 1){
+        // Skip rows that have no visual index (trimmed rows) to match the per-cell scan, which never
+        // validates or blanks source values for rows that map to `null`.
+        if (toVisualRow(row) === null) {
+            continue;
+        }
+        for(let i = 0; i < columns.length; i += 1){
+            const { physicalColumn, cellMeta } = columns[i];
+            const value = dataSource.getAtCell(row, physicalColumn);
+            validateSourceCell(cellMeta, value, row, physicalColumn, dataSource, invalidByMessageType, 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`.
+ *
+ * @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;
+}
+/**
+ * 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.
+ *
+ * @param {HotInstance} hotInstance The Handsontable instance.
+ * @param {string} [source] The source identifier of the operation.
+ * @returns {void}
+ */ export function runSourceDataValidators(hotInstance, source) {
+    const rowSourceCount = hotInstance.countSourceRows();
+    const colSourceCount = hotInstance.countSourceCols();
+    if (rowSourceCount === 0 || colSourceCount === 0) {
+        return;
+    }
+    const settings = hotInstance.getSettings();
+    const dataSource = hotInstance._getDataSource();
+    const invalidByMessageType = new Map();
+    if (hasRowVaryingMeta(hotInstance, settings)) {
+        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);
         }
     }
     invalidByMessageType.forEach((items, message)=>{
@@ -72,7 +216,11 @@ import { stringify } from '../helpers/mixed.mjs';
     });
 }
 /**
+ * Emits one aggregated console warning for a group of invalid source-data cells.
  *
+ * @param {string} message The warning message template.
+ * @param {Array} items The invalid cell entries to report.
+ * @returns {void}
  */ function logSourceDataWarning(message, items) {
     logAggregatedItems({
         logFunction: warn,