handsontable 18.0.0 → 18.1.0-rc7

package/dataMap/dataMap.d.ts

@@ -1,15 +1,5 @@
 import type { HotInstance } from '../core/types';
-/**
- * Represents the MetaManager dependency shape used by DataMap.
- */
-interface MetaManagerLike {
-    getTableMeta(): Record<string, unknown>;
-    createRow(physicalIndex: number | null, amount: number): void;
-    createColumn(physicalIndex: number | null, amount: number): void;
-    removeRow(physicalIndex: number, amount: number): void;
-    removeColumn(physicalIndex: number, amount: number): void;
-    getCellMeta(physicalRow: number, physicalColumn: number, options?: object): Record<string, unknown>;
-}
+import type { default as MetaManager } from './metaManager';
 /**
  * Utility class that gets and saves data from/to the data source using mapping of columns numbers to object property names.
  *
@@ -42,7 +32,7 @@ declare class DataMap {
      * @private
      * @type {MetaManager}
      */
-    metaManager: MetaManagerLike | null;
+    metaManager: MetaManager | null;
     /**
      * Instance of {@link TableMeta}.
      *
@@ -90,7 +80,7 @@ declare class DataMap {
      * @param {Array} data Array of arrays or array of objects containing data.
      * @param {MetaManager} metaManager The meta manager instance.
      */
-    constructor(hotInstance: HotInstance, data: (Record<string, unknown> | unknown[])[], metaManager: MetaManagerLike);
+    constructor(hotInstance: HotInstance, data: (Record<string, unknown> | unknown[])[], metaManager: MetaManager);
     /**
      * Generates cache for property to and from column addressation.
      */

package/dataMap/dataMap.js

@@ -37,23 +37,40 @@ var /**
    * @param {Function|Array} columns The columns setting value.
    * @param {unknown} schema The current data schema.
    */ _buildColumnCache = /*#__PURE__*/ new WeakSet(), /**
-   * Inserts a single null column into the data source at the given physical column index.
+   * Inserts the given amount of null columns into the data source in at most two passes over
+   * the rows, instead of one full pass per created column. The previous per-column loop chose
+   * between an append and a middle splice per iteration, based on the visual index against the
+   * growing column count; the same sequence collapses into two batched phases: the first
+   * `appendCount` iterations (while the visual index is at or past the current count) are
+   * end-of-row pushes, and the remaining iterations are single splices at consecutive ascending
+   * positions - which is exactly one block insert at the first of those positions.
    *
    * @param {Array} dataSource The data source array.
-   * @param {number} col The physical column index at which to splice.
+   * @param {number} firstColumn The physical column index at which the first column is inserted.
    * @param {number|undefined} visualColumnIndex The visual column index being inserted.
-   * @param {number} currentVisualColCount The current visual column count including already-created columns.
+   * @param {number} numberOfVisualCols The visual column count before the insertion.
    * @param {number} numberOfSourceRows The number of source rows.
-   */ _insertColumnIntoDataSource = /*#__PURE__*/ new WeakSet(), /**
-   * Splices the removed physical columns from each row in the data source,
-   * updating the meta manager for the first row.
+   * @param {number} amount The number of columns to insert.
+   */ _insertColumnsIntoDataSource = /*#__PURE__*/ new WeakSet(), /**
+   * Removes the given physical columns from each row in the data source and keeps
+   * the meta manager in sync. Rows are mutated in place so external references to
+   * the row arrays stay valid.
    *
    * @param {Array} data The data source array.
    * @param {boolean} isTableUniform Whether the removed columns form a contiguous range.
    * @param {number[]} removedPhysicalIndexes Physical indexes of removed columns in ascending order.
    * @param {number[]} descendingPhysicalColumns Physical indexes of removed columns in descending order.
    * @param {number} amount The number of columns to remove.
-   */ _spliceRemovedColumns = /*#__PURE__*/ new WeakSet();
+   */ _spliceRemovedColumns = /*#__PURE__*/ new WeakSet(), /**
+   * Groups physical indexes sorted in descending order into contiguous runs and invokes the
+   * callback once per run with the run's lowest index and its length. A sequence of
+   * one-at-a-time removals at descending contiguous indexes equals one bulk removal at the
+   * run's lowest index, and each meta-layer removal call pays a fixed walk over the
+   * materialized entries - so collapsing runs removes that per-index constant.
+   *
+   * @param {number[]} descendingIndexes Physical indexes sorted in descending order.
+   * @param {Function} callback Called with `(start, amount)` once per contiguous run.
+   */ _eachDescendingRun = /*#__PURE__*/ new WeakSet();
 /*
 This class contains open-source contributions covered by the MIT license.
 
@@ -316,10 +333,8 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
         }
         const physicalColumnIndex = visualColumnIndex < numberOfVisualCols ? this.hot.toPhysicalColumn(visualColumnIndex) : numberOfSourceCols;
         const firstNewPhysicalColumnIndex = mode === 'end' ? Math.min(physicalColumnIndex + 1, numberOfSourceCols) : physicalColumnIndex;
-        let numberOfCreatedCols = 0;
-        for(let col = firstNewPhysicalColumnIndex; numberOfCreatedCols < amount && numberOfVisualCols + numberOfCreatedCols < (maxCols ?? Infinity); col++, numberOfCreatedCols++){
-            _class_private_method_get(this, _insertColumnIntoDataSource, insertColumnIntoDataSource).call(this, dataSource, col, visualColumnIndex, numberOfVisualCols + numberOfCreatedCols, numberOfSourceRows);
-        }
+        const numberOfCreatedCols = Math.max(0, Math.min(amount, (maxCols ?? Infinity) - numberOfVisualCols));
+        _class_private_method_get(this, _insertColumnsIntoDataSource, insertColumnsIntoDataSource).call(this, dataSource, firstNewPhysicalColumnIndex, visualColumnIndex, numberOfVisualCols, numberOfSourceRows, numberOfCreatedCols);
         if (numberOfCreatedCols > 0) {
             if (index === undefined || index === null) {
                 // Creates the meta columns at the end of the columns collection without shifting the cells
@@ -367,8 +382,8 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
             }
         }
         const descendingPhysicalRows = removedPhysicalIndexes.slice(0).sort((a, b)=>b - a);
-        descendingPhysicalRows.forEach((rowPhysicalIndex)=>{
-            this.metaManager.removeRow(rowPhysicalIndex, 1);
+        _class_private_method_get(this, _eachDescendingRun, eachDescendingRun).call(this, descendingPhysicalRows, (start, runLength)=>{
+            this.metaManager.removeRow(start, runLength);
         });
         this.hot.runHooks('afterRemoveRow', rowIndex, numberOfRemovedIndexes, removedPhysicalIndexes, source);
         return true;
@@ -487,13 +502,21 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
    * @param {number} physicalRows Physical row indexes.
    */ filterData(index, amount, physicalRows) {
         // Custom data filtering (run as a consequence of calling the below hook) provide an array containing new data.
-        let data = this.hot.runHooks('filterData', index, amount, physicalRows);
+        const data = this.hot.runHooks('filterData', index, amount, physicalRows);
         // Hooks by default returns first argument (when there is no callback changing execution result).
-        if (Array.isArray(data) === false) {
-            data = this.dataSource.filter((_row, rowIndex)=>physicalRows.indexOf(rowIndex) === -1);
+        if (Array.isArray(data)) {
+            this.dataSource.length = 0;
+            // Pushing in a loop instead of `push.apply`, which passes one call argument per row and
+            // overflows the call stack on grids with roughly 125k rows or more (same pattern as #7840).
+            data.forEach((row)=>{
+                this.dataSource.push(row);
+            });
+        } else {
+            // One O(source rows) compaction pass with an O(1) Set membership test per row. The previous
+            // `filter` + `indexOf` variant cost O(source rows * removed rows) - a multi-second freeze
+            // when bulk-removing rows from a large grid - and copied the survivors back afterwards.
+            (0, _array.removeIndexesInPlace)(this.dataSource, new Set(physicalRows));
         }
-        this.dataSource.length = 0;
-        Array.prototype.push.apply(this.dataSource, data);
     }
     /**
    * Returns single value from the data array.
@@ -531,11 +554,13 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
         }
         const visualColumnIndex = this.propToCol(prop);
         const physicalColumn = typeof visualColumnIndex === 'number' ? this.hot.toPhysicalColumn(visualColumnIndex) : null;
-        if ((0, _number.isUnsignedNumber)(physicalRow) && (0, _number.isUnsignedNumber)(physicalColumn)) {
-            value = (0, _valueAccessors.getValueGetterValue)(value, this.metaManager.getCellMeta(physicalRow, physicalColumn, {
+        if (typeof visualColumnIndex === 'number' && (0, _number.isUnsignedNumber)(physicalRow) && (0, _number.isUnsignedNumber)(physicalColumn)) {
+            // The uncached read returns the stored meta when the cell carries persisted overrides and a
+            // transient object otherwise - a plain data read must not permanently materialize one meta
+            // object per visited cell (a full-table scan such as sorting would retain O(rows) of them).
+            value = (0, _valueAccessors.getValueGetterValue)(value, this.metaManager.getCellMetaUncached(physicalRow, physicalColumn, {
                 visualRow: row,
-                visualColumn: visualColumnIndex,
-                skipMetaExtension: true
+                visualColumn: visualColumnIndex
             }));
         }
         if (this.hot.hasHook('modifyData')) {
@@ -555,7 +580,10 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
    * @returns {string}
    */ getCopyable(row, prop) {
         const colIndex = this.propToCol(prop);
-        if (typeof colIndex === 'number' && this.hot.getCellMeta(row, colIndex).copyable) {
+        // The transient read honors a `cells()`-driven `copyable: false` (the dynamic extension
+        // runs) without permanently materializing one meta object per copied cell - the copy path
+        // walks the whole copied range through this method.
+        if (typeof colIndex === 'number' && this.hot.getCellMetaTransient(row, colIndex).copyable) {
             return this.get(row, prop);
         }
         return '';
@@ -771,8 +799,9 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
    * @param {MetaManager} metaManager The meta manager instance.
    */ constructor(hotInstance, data, metaManager){
         _class_private_method_init(this, _buildColumnCache);
-        _class_private_method_init(this, _insertColumnIntoDataSource);
+        _class_private_method_init(this, _insertColumnsIntoDataSource);
         _class_private_method_init(this, _spliceRemovedColumns);
+        _class_private_method_init(this, _eachDescendingRun);
         this.hot = hotInstance;
         this.metaManager = metaManager;
         this.tableMeta = metaManager.getTableMeta();
@@ -807,23 +836,39 @@ function buildColumnCache(columns, schema) {
         }
     }
 }
-function insertColumnIntoDataSource(dataSource, col, visualColumnIndex, currentVisualColCount, numberOfSourceRows) {
-    if (typeof visualColumnIndex !== 'number' || visualColumnIndex >= currentVisualColCount) {
+function insertColumnsIntoDataSource(dataSource, firstColumn, visualColumnIndex, numberOfVisualCols, numberOfSourceRows, amount) {
+    if (amount <= 0) {
+        return;
+    }
+    let appendCount = amount;
+    if (typeof visualColumnIndex === 'number') {
+        appendCount = Math.max(0, Math.min(amount, visualColumnIndex - numberOfVisualCols + 1));
+    }
+    const middleCount = amount - appendCount;
+    if (appendCount > 0) {
         if (numberOfSourceRows > 0) {
-            for(let row = 0; row < numberOfSourceRows; row += 1){
+            for(let row = 0; row < numberOfSourceRows; row++){
                 if (typeof dataSource[row] === 'undefined') {
                     dataSource[row] = [];
                 }
-                dataSource[row].push(null);
+                for(let i = 0; i < appendCount; i++){
+                    dataSource[row].push(null);
+                }
             }
         } else {
-            dataSource.push([
-                null
-            ]);
+            for(let i = 0; i < appendCount; i++){
+                dataSource.push([
+                    null
+                ]);
+            }
         }
-    } else {
+    }
+    if (middleCount > 0) {
+        // The insertion index clamps to the row length inside `insertValuesInPlace`, so rows
+        // shorter than the insertion point get the nulls appended at their end - matching what
+        // the previous repeated clamped `splice` calls did.
         for(let row = 0; row < numberOfSourceRows; row++){
-            dataSource[row].splice(col, 0, null);
+            (0, _array.insertValuesInPlace)(dataSource[row], firstColumn + appendCount, middleCount, null);
         }
     }
 }
@@ -836,14 +881,28 @@ function spliceRemovedColumns(data, isTableUniform, removedPhysicalIndexes, desc
             }
         }
     } else {
-        const removedColumnsCount = descendingPhysicalColumns.length;
-        for(let r = 0, rlen = this.hot.countSourceRows(); r < rlen; r++){
-            for(let c = 0; c < removedColumnsCount; c++){
-                data[r].splice(descendingPhysicalColumns[c], 1);
-                if (r === 0) {
-                    this.metaManager.removeColumn(descendingPhysicalColumns[c], 1);
-                }
-            }
+        // One in-place compaction pass per row instead of one `splice` per removed column per row.
+        // The splice variant costs O(rows * removed columns * columns) after any column reorder;
+        // the compaction pass is O(rows * columns) regardless of how many columns are removed.
+        const removedColumns = new Set(removedPhysicalIndexes);
+        const numberOfSourceRows = this.hot.countSourceRows();
+        for(let r = 0; r < numberOfSourceRows; r++){
+            (0, _array.removeIndexesInPlace)(data[r], removedColumns);
+        }
+        if (numberOfSourceRows > 0) {
+            _class_private_method_get(this, _eachDescendingRun, eachDescendingRun).call(this, descendingPhysicalColumns, (start, runLength)=>{
+                this.metaManager.removeColumn(start, runLength);
+            });
+        }
+    }
+}
+function eachDescendingRun(descendingIndexes, callback) {
+    let runStartPosition = 0;
+    for(let i = 0; i < descendingIndexes.length; i++){
+        const isLastOfRun = i + 1 >= descendingIndexes.length || descendingIndexes[i + 1] !== descendingIndexes[i] - 1;
+        if (isLastOfRun) {
+            callback(descendingIndexes[i], i - runStartPosition + 1);
+            runStartPosition = i + 1;
         }
     }
 }

package/dataMap/dataMap.mjs

@@ -16,7 +16,7 @@ function _class_private_method_init(obj, privateSet) {
 import { stringify } from '../3rdparty/SheetClip/index.mjs';
 import { countFirstRowKeys } from '../helpers/data.mjs';
 import { createObjectPropListener, deepClone, deepExtend, deepObjectSize, duckSchema, hasOwnProperty, isObject, objectEach } from '../helpers/object.mjs';
-import { extendArray, to2dArray } from '../helpers/array.mjs';
+import { extendArray, insertValuesInPlace, removeIndexesInPlace, to2dArray } from '../helpers/array.mjs';
 import { rangeEach, isUnsignedNumber } from '../helpers/number.mjs';
 import { isDefined } from '../helpers/mixed.mjs';
 import { getValueGetterValue } from '../utils/valueAccessors.mjs';
@@ -27,23 +27,40 @@ var /**
    * @param {Function|Array} columns The columns setting value.
    * @param {unknown} schema The current data schema.
    */ _buildColumnCache = /*#__PURE__*/ new WeakSet(), /**
-   * Inserts a single null column into the data source at the given physical column index.
+   * Inserts the given amount of null columns into the data source in at most two passes over
+   * the rows, instead of one full pass per created column. The previous per-column loop chose
+   * between an append and a middle splice per iteration, based on the visual index against the
+   * growing column count; the same sequence collapses into two batched phases: the first
+   * `appendCount` iterations (while the visual index is at or past the current count) are
+   * end-of-row pushes, and the remaining iterations are single splices at consecutive ascending
+   * positions - which is exactly one block insert at the first of those positions.
    *
    * @param {Array} dataSource The data source array.
-   * @param {number} col The physical column index at which to splice.
+   * @param {number} firstColumn The physical column index at which the first column is inserted.
    * @param {number|undefined} visualColumnIndex The visual column index being inserted.
-   * @param {number} currentVisualColCount The current visual column count including already-created columns.
+   * @param {number} numberOfVisualCols The visual column count before the insertion.
    * @param {number} numberOfSourceRows The number of source rows.
-   */ _insertColumnIntoDataSource = /*#__PURE__*/ new WeakSet(), /**
-   * Splices the removed physical columns from each row in the data source,
-   * updating the meta manager for the first row.
+   * @param {number} amount The number of columns to insert.
+   */ _insertColumnsIntoDataSource = /*#__PURE__*/ new WeakSet(), /**
+   * Removes the given physical columns from each row in the data source and keeps
+   * the meta manager in sync. Rows are mutated in place so external references to
+   * the row arrays stay valid.
    *
    * @param {Array} data The data source array.
    * @param {boolean} isTableUniform Whether the removed columns form a contiguous range.
    * @param {number[]} removedPhysicalIndexes Physical indexes of removed columns in ascending order.
    * @param {number[]} descendingPhysicalColumns Physical indexes of removed columns in descending order.
    * @param {number} amount The number of columns to remove.
-   */ _spliceRemovedColumns = /*#__PURE__*/ new WeakSet();
+   */ _spliceRemovedColumns = /*#__PURE__*/ new WeakSet(), /**
+   * Groups physical indexes sorted in descending order into contiguous runs and invokes the
+   * callback once per run with the run's lowest index and its length. A sequence of
+   * one-at-a-time removals at descending contiguous indexes equals one bulk removal at the
+   * run's lowest index, and each meta-layer removal call pays a fixed walk over the
+   * materialized entries - so collapsing runs removes that per-index constant.
+   *
+   * @param {number[]} descendingIndexes Physical indexes sorted in descending order.
+   * @param {Function} callback Called with `(start, amount)` once per contiguous run.
+   */ _eachDescendingRun = /*#__PURE__*/ new WeakSet();
 /*
 This class contains open-source contributions covered by the MIT license.
 
@@ -306,10 +323,8 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
         }
         const physicalColumnIndex = visualColumnIndex < numberOfVisualCols ? this.hot.toPhysicalColumn(visualColumnIndex) : numberOfSourceCols;
         const firstNewPhysicalColumnIndex = mode === 'end' ? Math.min(physicalColumnIndex + 1, numberOfSourceCols) : physicalColumnIndex;
-        let numberOfCreatedCols = 0;
-        for(let col = firstNewPhysicalColumnIndex; numberOfCreatedCols < amount && numberOfVisualCols + numberOfCreatedCols < (maxCols ?? Infinity); col++, numberOfCreatedCols++){
-            _class_private_method_get(this, _insertColumnIntoDataSource, insertColumnIntoDataSource).call(this, dataSource, col, visualColumnIndex, numberOfVisualCols + numberOfCreatedCols, numberOfSourceRows);
-        }
+        const numberOfCreatedCols = Math.max(0, Math.min(amount, (maxCols ?? Infinity) - numberOfVisualCols));
+        _class_private_method_get(this, _insertColumnsIntoDataSource, insertColumnsIntoDataSource).call(this, dataSource, firstNewPhysicalColumnIndex, visualColumnIndex, numberOfVisualCols, numberOfSourceRows, numberOfCreatedCols);
         if (numberOfCreatedCols > 0) {
             if (index === undefined || index === null) {
                 // Creates the meta columns at the end of the columns collection without shifting the cells
@@ -357,8 +372,8 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
             }
         }
         const descendingPhysicalRows = removedPhysicalIndexes.slice(0).sort((a, b)=>b - a);
-        descendingPhysicalRows.forEach((rowPhysicalIndex)=>{
-            this.metaManager.removeRow(rowPhysicalIndex, 1);
+        _class_private_method_get(this, _eachDescendingRun, eachDescendingRun).call(this, descendingPhysicalRows, (start, runLength)=>{
+            this.metaManager.removeRow(start, runLength);
         });
         this.hot.runHooks('afterRemoveRow', rowIndex, numberOfRemovedIndexes, removedPhysicalIndexes, source);
         return true;
@@ -477,13 +492,21 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
    * @param {number} physicalRows Physical row indexes.
    */ filterData(index, amount, physicalRows) {
         // Custom data filtering (run as a consequence of calling the below hook) provide an array containing new data.
-        let data = this.hot.runHooks('filterData', index, amount, physicalRows);
+        const data = this.hot.runHooks('filterData', index, amount, physicalRows);
         // Hooks by default returns first argument (when there is no callback changing execution result).
-        if (Array.isArray(data) === false) {
-            data = this.dataSource.filter((_row, rowIndex)=>physicalRows.indexOf(rowIndex) === -1);
+        if (Array.isArray(data)) {
+            this.dataSource.length = 0;
+            // Pushing in a loop instead of `push.apply`, which passes one call argument per row and
+            // overflows the call stack on grids with roughly 125k rows or more (same pattern as #7840).
+            data.forEach((row)=>{
+                this.dataSource.push(row);
+            });
+        } else {
+            // One O(source rows) compaction pass with an O(1) Set membership test per row. The previous
+            // `filter` + `indexOf` variant cost O(source rows * removed rows) - a multi-second freeze
+            // when bulk-removing rows from a large grid - and copied the survivors back afterwards.
+            removeIndexesInPlace(this.dataSource, new Set(physicalRows));
         }
-        this.dataSource.length = 0;
-        Array.prototype.push.apply(this.dataSource, data);
     }
     /**
    * Returns single value from the data array.
@@ -521,11 +544,13 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
         }
         const visualColumnIndex = this.propToCol(prop);
         const physicalColumn = typeof visualColumnIndex === 'number' ? this.hot.toPhysicalColumn(visualColumnIndex) : null;
-        if (isUnsignedNumber(physicalRow) && isUnsignedNumber(physicalColumn)) {
-            value = getValueGetterValue(value, this.metaManager.getCellMeta(physicalRow, physicalColumn, {
+        if (typeof visualColumnIndex === 'number' && isUnsignedNumber(physicalRow) && isUnsignedNumber(physicalColumn)) {
+            // The uncached read returns the stored meta when the cell carries persisted overrides and a
+            // transient object otherwise - a plain data read must not permanently materialize one meta
+            // object per visited cell (a full-table scan such as sorting would retain O(rows) of them).
+            value = getValueGetterValue(value, this.metaManager.getCellMetaUncached(physicalRow, physicalColumn, {
                 visualRow: row,
-                visualColumn: visualColumnIndex,
-                skipMetaExtension: true
+                visualColumn: visualColumnIndex
             }));
         }
         if (this.hot.hasHook('modifyData')) {
@@ -545,7 +570,10 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
    * @returns {string}
    */ getCopyable(row, prop) {
         const colIndex = this.propToCol(prop);
-        if (typeof colIndex === 'number' && this.hot.getCellMeta(row, colIndex).copyable) {
+        // The transient read honors a `cells()`-driven `copyable: false` (the dynamic extension
+        // runs) without permanently materializing one meta object per copied cell - the copy path
+        // walks the whole copied range through this method.
+        if (typeof colIndex === 'number' && this.hot.getCellMetaTransient(row, colIndex).copyable) {
             return this.get(row, prop);
         }
         return '';
@@ -761,8 +789,9 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
    * @param {MetaManager} metaManager The meta manager instance.
    */ constructor(hotInstance, data, metaManager){
         _class_private_method_init(this, _buildColumnCache);
-        _class_private_method_init(this, _insertColumnIntoDataSource);
+        _class_private_method_init(this, _insertColumnsIntoDataSource);
         _class_private_method_init(this, _spliceRemovedColumns);
+        _class_private_method_init(this, _eachDescendingRun);
         this.hot = hotInstance;
         this.metaManager = metaManager;
         this.tableMeta = metaManager.getTableMeta();
@@ -797,23 +826,39 @@ function buildColumnCache(columns, schema) {
         }
     }
 }
-function insertColumnIntoDataSource(dataSource, col, visualColumnIndex, currentVisualColCount, numberOfSourceRows) {
-    if (typeof visualColumnIndex !== 'number' || visualColumnIndex >= currentVisualColCount) {
+function insertColumnsIntoDataSource(dataSource, firstColumn, visualColumnIndex, numberOfVisualCols, numberOfSourceRows, amount) {
+    if (amount <= 0) {
+        return;
+    }
+    let appendCount = amount;
+    if (typeof visualColumnIndex === 'number') {
+        appendCount = Math.max(0, Math.min(amount, visualColumnIndex - numberOfVisualCols + 1));
+    }
+    const middleCount = amount - appendCount;
+    if (appendCount > 0) {
         if (numberOfSourceRows > 0) {
-            for(let row = 0; row < numberOfSourceRows; row += 1){
+            for(let row = 0; row < numberOfSourceRows; row++){
                 if (typeof dataSource[row] === 'undefined') {
                     dataSource[row] = [];
                 }
-                dataSource[row].push(null);
+                for(let i = 0; i < appendCount; i++){
+                    dataSource[row].push(null);
+                }
             }
         } else {
-            dataSource.push([
-                null
-            ]);
+            for(let i = 0; i < appendCount; i++){
+                dataSource.push([
+                    null
+                ]);
+            }
         }
-    } else {
+    }
+    if (middleCount > 0) {
+        // The insertion index clamps to the row length inside `insertValuesInPlace`, so rows
+        // shorter than the insertion point get the nulls appended at their end - matching what
+        // the previous repeated clamped `splice` calls did.
         for(let row = 0; row < numberOfSourceRows; row++){
-            dataSource[row].splice(col, 0, null);
+            insertValuesInPlace(dataSource[row], firstColumn + appendCount, middleCount, null);
         }
     }
 }
@@ -826,14 +871,28 @@ function spliceRemovedColumns(data, isTableUniform, removedPhysicalIndexes, desc
             }
         }
     } else {
-        const removedColumnsCount = descendingPhysicalColumns.length;
-        for(let r = 0, rlen = this.hot.countSourceRows(); r < rlen; r++){
-            for(let c = 0; c < removedColumnsCount; c++){
-                data[r].splice(descendingPhysicalColumns[c], 1);
-                if (r === 0) {
-                    this.metaManager.removeColumn(descendingPhysicalColumns[c], 1);
-                }
-            }
+        // One in-place compaction pass per row instead of one `splice` per removed column per row.
+        // The splice variant costs O(rows * removed columns * columns) after any column reorder;
+        // the compaction pass is O(rows * columns) regardless of how many columns are removed.
+        const removedColumns = new Set(removedPhysicalIndexes);
+        const numberOfSourceRows = this.hot.countSourceRows();
+        for(let r = 0; r < numberOfSourceRows; r++){
+            removeIndexesInPlace(data[r], removedColumns);
+        }
+        if (numberOfSourceRows > 0) {
+            _class_private_method_get(this, _eachDescendingRun, eachDescendingRun).call(this, descendingPhysicalColumns, (start, runLength)=>{
+                this.metaManager.removeColumn(start, runLength);
+            });
+        }
+    }
+}
+function eachDescendingRun(descendingIndexes, callback) {
+    let runStartPosition = 0;
+    for(let i = 0; i < descendingIndexes.length; i++){
+        const isLastOfRun = i + 1 >= descendingIndexes.length || descendingIndexes[i + 1] !== descendingIndexes[i] - 1;
+        if (isLastOfRun) {
+            callback(descendingIndexes[i], i - runStartPosition + 1);
+            runStartPosition = i + 1;
         }
     }
 }

package/dataMap/dataSource.js

@@ -267,7 +267,10 @@ const _function = require("../helpers/function");
    * @returns {string}
    */ getCopyable(row, prop) {
         const visualColumn = this.propToCol(prop);
-        if (typeof visualColumn === 'number' && this.hot.getCellMeta(row, visualColumn).copyable) {
+        // The transient read honors a `cells()`-driven `copyable: false` (the dynamic extension
+        // runs) without permanently materializing one meta object per copied cell - `onCopy` walks
+        // the whole copied range through this method.
+        if (typeof visualColumn === 'number' && this.hot.getCellMetaTransient(row, visualColumn).copyable) {
             return this.getAtCell(this.hot.toPhysicalRow(row), visualColumn);
         }
         return '';

package/dataMap/dataSource.mjs

@@ -257,7 +257,10 @@ import { isFunction } from '../helpers/function.mjs';
    * @returns {string}
    */ getCopyable(row, prop) {
         const visualColumn = this.propToCol(prop);
-        if (typeof visualColumn === 'number' && this.hot.getCellMeta(row, visualColumn).copyable) {
+        // The transient read honors a `cells()`-driven `copyable: false` (the dynamic extension
+        // runs) without permanently materializing one meta object per copied cell - `onCopy` walks
+        // the whole copied range through this method.
+        if (typeof visualColumn === 'number' && this.hot.getCellMetaTransient(row, visualColumn).copyable) {
             return this.getAtCell(this.hot.toPhysicalRow(row), visualColumn);
         }
         return '';