handsontable 18.0.0 → 18.1.0-rc7

package/translations/indexMapper.js

@@ -71,12 +71,6 @@ function _interop_require_default(obj) {
         default: obj
     };
 }
-/**
- * A set of deprecated feature names.
- *
- * @type {Set<string>}
- */ // eslint-disable-next-line no-unused-vars
-const deprecationWarns = new Set();
 var /**
    * Map of observed IndexMap instances to their registered callback sets.
    * Used by {@link IndexMapper#observeMapChange} to track which maps are being
@@ -94,7 +88,15 @@ var /**
    * @param {IndexMap} map The map whose observers to notify.
    */ _notifyMapObservers = /*#__PURE__*/ new WeakSet(), /**
    * Flushes all dirty observed maps collected during a batch, notifying their observers.
-   */ _flushDirtyObservedMaps = /*#__PURE__*/ new WeakSet();
+   */ _flushDirtyObservedMaps = /*#__PURE__*/ new WeakSet(), /**
+   * Returns a `-1`-filled `Int32Array` of the given length, reusing the passed one when its length
+   * matches so a cache rebuild does not allocate a new buffer.
+   *
+   * @private
+   * @param {Int32Array} cache The existing cache to reuse when possible.
+   * @param {number} length The required length.
+   * @returns {Int32Array}
+   */ _allocateIndexCache = /*#__PURE__*/ new WeakSet();
 class IndexMapper {
     /**
    * Suspends the cache update for this map. The method is helpful to group multiple
@@ -124,8 +126,8 @@ class IndexMapper {
         }
         return this.hidingChangesObservable.createObserver();
     }
-    createAndRegisterIndexMap(indexName, mapType, initValueOrFn) {
-        return this.registerMap(indexName, (0, _maps.createIndexMap)(mapType, initValueOrFn));
+    createAndRegisterIndexMap(indexName, mapType, initValueOrFn, options) {
+        return this.registerMap(indexName, (0, _maps.createIndexMap)(mapType, initValueOrFn, options));
     }
     /* eslint-enable jsdoc/require-jsdoc */ /**
    * Register map which provide some index mappings. Type of map determining to which collection it will be added.
@@ -204,9 +206,15 @@ class IndexMapper {
    * @param {number} physicalIndex Physical index to search.
    * @returns {number|null} Returns a visual index of the index mapper.
    */ getVisualFromPhysicalIndex(physicalIndex) {
-        const visualIndex = this.fromPhysicalToVisualIndexesCache.get(physicalIndex);
-        // Index in the table boundaries provided by the `DataMap`.
-        return visualIndex ?? null;
+        // The typed-array cache coerces non-integer keys: a string like `'0'` would index slot 0 and
+        // `'__proto__'`/`'constructor'` would return prototype-chain values. The previous `Map` treated those
+        // as misses, so reject any non-integer key here to keep that exact-key semantics.
+        if (!Number.isInteger(physicalIndex)) {
+            return null;
+        }
+        const visualIndex = this.fromPhysicalToVisualIndexesCache[physicalIndex];
+        // Index in the table boundaries provided by the `DataMap`. `-1`/`undefined` means no mapping.
+        return visualIndex === undefined || visualIndex === -1 ? null : visualIndex;
     }
     /**
    * Get a visual index corresponding to the given renderable index.
@@ -222,9 +230,14 @@ class IndexMapper {
    * @param {number} visualIndex Visual index.
    * @returns {null|number}
    */ getRenderableFromVisualIndex(visualIndex) {
-        const renderableIndex = this.fromVisualToRenderableIndexesCache.get(visualIndex);
-        // Index in the renderable table boundaries.
-        return renderableIndex ?? null;
+        // Reject non-integer keys (string-numeric, `'__proto__'`, etc.) to keep the previous `Map`'s
+        // exact-key semantics — see getVisualFromPhysicalIndex.
+        if (!Number.isInteger(visualIndex)) {
+            return null;
+        }
+        const renderableIndex = this.fromVisualToRenderableIndexesCache[visualIndex];
+        // Index in the renderable table boundaries. `-1`/`undefined` means no mapping.
+        return renderableIndex === undefined || renderableIndex === -1 ? null : renderableIndex;
     }
     /**
    * Search for the nearest not-hidden row or column.
@@ -242,23 +255,25 @@ class IndexMapper {
         if (physicalIndex === null) {
             return null;
         }
-        if (this.fromVisualToRenderableIndexesCache.has(fromVisualIndex)) {
+        const renderableCache = this.fromVisualToRenderableIndexesCache;
+        const fromRenderableIndex = renderableCache[fromVisualIndex];
+        // The visual index is already visible when it has a renderable mapping. The `typeof number` check
+        // keeps non-integer keys (e.g. `'__proto__'`) from matching prototype-chain values.
+        if (typeof fromRenderableIndex === 'number' && fromRenderableIndex !== -1) {
             return fromVisualIndex;
         }
-        const visibleIndexes = Array.from(this.fromVisualToRenderableIndexesCache.keys());
-        let index = -1;
-        if (searchDirection > 0) {
-            index = visibleIndexes.findIndex((visualIndex)=>visualIndex !== null && visualIndex > fromVisualIndex);
-        } else {
-            index = visibleIndexes.reverse().findIndex((visualIndex)=>visualIndex !== null && visualIndex < fromVisualIndex);
-        }
-        if (index === -1) {
-            if (searchAlsoOtherWayAround) {
-                return this.getNearestNotHiddenIndex(fromVisualIndex, -searchDirection, false);
+        // Scan outward for the nearest visible visual index in the requested direction
+        // (`searchDirection` is `1` or `-1`, so the same loop covers both directions).
+        const length = renderableCache.length;
+        for(let visualIndex = fromVisualIndex + searchDirection; visualIndex >= 0 && visualIndex < length; visualIndex += searchDirection){
+            if (renderableCache[visualIndex] !== -1) {
+                return visualIndex;
             }
-            return null;
         }
-        return visibleIndexes[index];
+        if (searchAlsoOtherWayAround) {
+            return this.getNearestNotHiddenIndex(fromVisualIndex, -searchDirection, false);
+        }
+        return null;
     }
     /**
    * Set default values for all indexes in registered index maps.
@@ -333,7 +348,18 @@ class IndexMapper {
             return this.notTrimmedIndexesCache;
         }
         const indexesSequence = this.getIndexesSequence();
-        return indexesSequence.filter((physicalIndex)=>this.isTrimmed(physicalIndex) === false);
+        // Read the merged trimming cache directly instead of calling `isTrimmed()` per element (which
+        // resolves through getMergedValueAtIndex → getMergedValues on every index). Same semantics:
+        // `isTrimmed(i) === false` ⟺ the merged value is not strictly `true`.
+        const trimmedValues = this.trimmingMapsCollection.getMergedValues();
+        const notTrimmedIndexes = [];
+        for(let i = 0; i < indexesSequence.length; i += 1){
+            const physicalIndex = indexesSequence[i];
+            if (trimmedValues[physicalIndex] !== true) {
+                notTrimmedIndexes.push(physicalIndex);
+            }
+        }
+        return notTrimmedIndexes;
     }
     /**
    * Get length of all NOT trimmed indexes.
@@ -356,7 +382,15 @@ class IndexMapper {
             return this.notHiddenIndexesCache;
         }
         const indexesSequence = this.getIndexesSequence();
-        return indexesSequence.filter((physicalIndex)=>this.isHidden(physicalIndex) === false);
+        const hiddenValues = this.hidingMapsCollection.getMergedValues();
+        const notHiddenIndexes = [];
+        for(let i = 0; i < indexesSequence.length; i += 1){
+            const physicalIndex = indexesSequence[i];
+            if (hiddenValues[physicalIndex] !== true) {
+                notHiddenIndexes.push(physicalIndex);
+            }
+        }
+        return notHiddenIndexes;
     }
     /**
    * Get length of all NOT hidden indexes.
@@ -378,7 +412,15 @@ class IndexMapper {
             return this.renderablePhysicalIndexesCache;
         }
         const notTrimmedIndexes = this.getNotTrimmedIndexes();
-        return notTrimmedIndexes.filter((physicalIndex)=>this.isHidden(physicalIndex) === false);
+        const hiddenValues = this.hidingMapsCollection.getMergedValues();
+        const renderableIndexes = [];
+        for(let i = 0; i < notTrimmedIndexes.length; i += 1){
+            const physicalIndex = notTrimmedIndexes[i];
+            if (hiddenValues[physicalIndex] !== true) {
+                renderableIndexes.push(physicalIndex);
+            }
+        }
+        return renderableIndexes;
     }
     /**
    * Get length of all NOT trimmed and NOT hidden indexes.
@@ -542,13 +584,16 @@ class IndexMapper {
    * @private
    */ cacheFromPhysicalToVisualIndexes() {
         const nrOfNotTrimmedIndexes = this.getNotTrimmedIndexesLength();
-        this.fromPhysicalToVisualIndexesCache.clear();
+        const cache = _class_private_method_get(this, _allocateIndexCache, allocateIndexCache).call(this, this.fromPhysicalToVisualIndexesCache, this.getNumberOfIndexes());
         for(let visualIndex = 0; visualIndex < nrOfNotTrimmedIndexes; visualIndex += 1){
             const physicalIndex = this.getPhysicalFromVisualIndex(visualIndex);
-            // Every visual index have corresponding physical index, but some physical indexes may don't have
-            // corresponding visual indexes (physical indexes may represent trimmed indexes, beyond the table boundaries)
-            this.fromPhysicalToVisualIndexesCache.set(physicalIndex, visualIndex);
+            // Every visual index has a corresponding physical index. Physical indexes with no visual index
+            // (trimmed indexes, beyond the table boundaries) keep the `-1` sentinel.
+            if (physicalIndex !== null) {
+                cache[physicalIndex] = visualIndex;
+            }
         }
+        this.fromPhysicalToVisualIndexesCache = cache;
     }
     /**
    * Update cache for translations from visual to renderable indexes.
@@ -556,13 +601,17 @@ class IndexMapper {
    * @private
    */ cacheFromVisualToRenderableIndexes() {
         const nrOfRenderableIndexes = this.getRenderableIndexesLength();
-        this.fromVisualToRenderableIndexesCache.clear();
+        const cache = _class_private_method_get(this, _allocateIndexCache, allocateIndexCache).call(this, this.fromVisualToRenderableIndexesCache, this.getNotTrimmedIndexesLength());
         for(let renderableIndex = 0; renderableIndex < nrOfRenderableIndexes; renderableIndex += 1){
             // Can't use getRenderableFromVisualIndex here because we're building the cache here
             const physicalIndex = this.getPhysicalFromRenderableIndex(renderableIndex);
             const visualIndex = this.getVisualFromPhysicalIndex(physicalIndex);
-            this.fromVisualToRenderableIndexesCache.set(visualIndex, renderableIndex);
+            // Visual indexes with no renderable index (hidden indexes) keep the `-1` sentinel.
+            if (visualIndex !== null) {
+                cache[visualIndex] = renderableIndex;
+            }
         }
+        this.fromVisualToRenderableIndexesCache = cache;
     }
     /**
    * Destroys the IndexMapper instance. Clears all registered map observers
@@ -578,6 +627,7 @@ class IndexMapper {
         _class_private_method_init(this, _handleObservedMapChange);
         _class_private_method_init(this, _notifyMapObservers);
         _class_private_method_init(this, _flushDirtyObservedMaps);
+        _class_private_method_init(this, _allocateIndexCache);
         _class_private_field_init(this, _mapObservers, {
             writable: true,
             value: void 0
@@ -682,17 +732,21 @@ class IndexMapper {
    * @type {Array}
    */ this.renderablePhysicalIndexesCache = [];
         /**
-   * Visual indexes (native map's value) corresponding to physical indexes (native map's index).
+   * Visual indexes (typed array value) corresponding to physical indexes (typed array index).
+   * `-1` marks a physical index with no visual index (trimmed). Backed by a typed array instead of a
+   * `Map` to avoid per-rebuild hashing churn on large datasets.
    *
    * @private
-   * @type {Map}
-   */ this.fromPhysicalToVisualIndexesCache = new Map();
+   * @type {Int32Array}
+   */ this.fromPhysicalToVisualIndexesCache = new Int32Array(0);
         /**
-   * Visual indexes (native map's value) corresponding to physical indexes (native map's index).
+   * Renderable indexes (typed array value) corresponding to visual indexes (typed array index).
+   * `-1` marks a visual index with no renderable index (hidden). Backed by a typed array instead of a
+   * `Map` to avoid per-rebuild hashing churn on large datasets.
    *
    * @private
-   * @type {Map}
-   */ this.fromVisualToRenderableIndexesCache = new Map();
+   * @type {Int32Array}
+   */ this.fromVisualToRenderableIndexesCache = new Int32Array(0);
         _class_private_field_set(this, _mapObservers, new WeakMap());
         _class_private_field_set(this, _dirtyObservedMaps, new Set());
         this.indexesSequence.addLocalHook('change', ()=>{
@@ -741,4 +795,11 @@ function flushDirtyObservedMaps() {
         _class_private_field_get(this, _dirtyObservedMaps).clear();
     }
 }
+function allocateIndexCache(cache, length) {
+    if (cache.length === length) {
+        cache.fill(-1);
+        return cache;
+    }
+    return new Int32Array(length).fill(-1);
+}
 (0, _object.mixin)(IndexMapper, _localHooks.default);

package/translations/indexMapper.mjs

@@ -56,12 +56,6 @@ import { mixin } from '../helpers/object.mjs';
 import { isDefined } from '../helpers/mixed.mjs';
 import { ChangesObservable } from './changesObservable/observable.mjs';
 import { throwWithCause } from '../helpers/errors.mjs';
-/**
- * A set of deprecated feature names.
- *
- * @type {Set<string>}
- */ // eslint-disable-next-line no-unused-vars
-const deprecationWarns = new Set();
 var /**
    * Map of observed IndexMap instances to their registered callback sets.
    * Used by {@link IndexMapper#observeMapChange} to track which maps are being
@@ -79,7 +73,15 @@ var /**
    * @param {IndexMap} map The map whose observers to notify.
    */ _notifyMapObservers = /*#__PURE__*/ new WeakSet(), /**
    * Flushes all dirty observed maps collected during a batch, notifying their observers.
-   */ _flushDirtyObservedMaps = /*#__PURE__*/ new WeakSet();
+   */ _flushDirtyObservedMaps = /*#__PURE__*/ new WeakSet(), /**
+   * Returns a `-1`-filled `Int32Array` of the given length, reusing the passed one when its length
+   * matches so a cache rebuild does not allocate a new buffer.
+   *
+   * @private
+   * @param {Int32Array} cache The existing cache to reuse when possible.
+   * @param {number} length The required length.
+   * @returns {Int32Array}
+   */ _allocateIndexCache = /*#__PURE__*/ new WeakSet();
 /**
  * @class IndexMapper
  * @description
@@ -127,8 +129,8 @@ var /**
         }
         return this.hidingChangesObservable.createObserver();
     }
-    createAndRegisterIndexMap(indexName, mapType, initValueOrFn) {
-        return this.registerMap(indexName, createIndexMap(mapType, initValueOrFn));
+    createAndRegisterIndexMap(indexName, mapType, initValueOrFn, options) {
+        return this.registerMap(indexName, createIndexMap(mapType, initValueOrFn, options));
     }
     /* eslint-enable jsdoc/require-jsdoc */ /**
    * Register map which provide some index mappings. Type of map determining to which collection it will be added.
@@ -207,9 +209,15 @@ var /**
    * @param {number} physicalIndex Physical index to search.
    * @returns {number|null} Returns a visual index of the index mapper.
    */ getVisualFromPhysicalIndex(physicalIndex) {
-        const visualIndex = this.fromPhysicalToVisualIndexesCache.get(physicalIndex);
-        // Index in the table boundaries provided by the `DataMap`.
-        return visualIndex ?? null;
+        // The typed-array cache coerces non-integer keys: a string like `'0'` would index slot 0 and
+        // `'__proto__'`/`'constructor'` would return prototype-chain values. The previous `Map` treated those
+        // as misses, so reject any non-integer key here to keep that exact-key semantics.
+        if (!Number.isInteger(physicalIndex)) {
+            return null;
+        }
+        const visualIndex = this.fromPhysicalToVisualIndexesCache[physicalIndex];
+        // Index in the table boundaries provided by the `DataMap`. `-1`/`undefined` means no mapping.
+        return visualIndex === undefined || visualIndex === -1 ? null : visualIndex;
     }
     /**
    * Get a visual index corresponding to the given renderable index.
@@ -225,9 +233,14 @@ var /**
    * @param {number} visualIndex Visual index.
    * @returns {null|number}
    */ getRenderableFromVisualIndex(visualIndex) {
-        const renderableIndex = this.fromVisualToRenderableIndexesCache.get(visualIndex);
-        // Index in the renderable table boundaries.
-        return renderableIndex ?? null;
+        // Reject non-integer keys (string-numeric, `'__proto__'`, etc.) to keep the previous `Map`'s
+        // exact-key semantics — see getVisualFromPhysicalIndex.
+        if (!Number.isInteger(visualIndex)) {
+            return null;
+        }
+        const renderableIndex = this.fromVisualToRenderableIndexesCache[visualIndex];
+        // Index in the renderable table boundaries. `-1`/`undefined` means no mapping.
+        return renderableIndex === undefined || renderableIndex === -1 ? null : renderableIndex;
     }
     /**
    * Search for the nearest not-hidden row or column.
@@ -245,23 +258,25 @@ var /**
         if (physicalIndex === null) {
             return null;
         }
-        if (this.fromVisualToRenderableIndexesCache.has(fromVisualIndex)) {
+        const renderableCache = this.fromVisualToRenderableIndexesCache;
+        const fromRenderableIndex = renderableCache[fromVisualIndex];
+        // The visual index is already visible when it has a renderable mapping. The `typeof number` check
+        // keeps non-integer keys (e.g. `'__proto__'`) from matching prototype-chain values.
+        if (typeof fromRenderableIndex === 'number' && fromRenderableIndex !== -1) {
             return fromVisualIndex;
         }
-        const visibleIndexes = Array.from(this.fromVisualToRenderableIndexesCache.keys());
-        let index = -1;
-        if (searchDirection > 0) {
-            index = visibleIndexes.findIndex((visualIndex)=>visualIndex !== null && visualIndex > fromVisualIndex);
-        } else {
-            index = visibleIndexes.reverse().findIndex((visualIndex)=>visualIndex !== null && visualIndex < fromVisualIndex);
-        }
-        if (index === -1) {
-            if (searchAlsoOtherWayAround) {
-                return this.getNearestNotHiddenIndex(fromVisualIndex, -searchDirection, false);
+        // Scan outward for the nearest visible visual index in the requested direction
+        // (`searchDirection` is `1` or `-1`, so the same loop covers both directions).
+        const length = renderableCache.length;
+        for(let visualIndex = fromVisualIndex + searchDirection; visualIndex >= 0 && visualIndex < length; visualIndex += searchDirection){
+            if (renderableCache[visualIndex] !== -1) {
+                return visualIndex;
             }
-            return null;
         }
-        return visibleIndexes[index];
+        if (searchAlsoOtherWayAround) {
+            return this.getNearestNotHiddenIndex(fromVisualIndex, -searchDirection, false);
+        }
+        return null;
     }
     /**
    * Set default values for all indexes in registered index maps.
@@ -336,7 +351,18 @@ var /**
             return this.notTrimmedIndexesCache;
         }
         const indexesSequence = this.getIndexesSequence();
-        return indexesSequence.filter((physicalIndex)=>this.isTrimmed(physicalIndex) === false);
+        // Read the merged trimming cache directly instead of calling `isTrimmed()` per element (which
+        // resolves through getMergedValueAtIndex → getMergedValues on every index). Same semantics:
+        // `isTrimmed(i) === false` ⟺ the merged value is not strictly `true`.
+        const trimmedValues = this.trimmingMapsCollection.getMergedValues();
+        const notTrimmedIndexes = [];
+        for(let i = 0; i < indexesSequence.length; i += 1){
+            const physicalIndex = indexesSequence[i];
+            if (trimmedValues[physicalIndex] !== true) {
+                notTrimmedIndexes.push(physicalIndex);
+            }
+        }
+        return notTrimmedIndexes;
     }
     /**
    * Get length of all NOT trimmed indexes.
@@ -359,7 +385,15 @@ var /**
             return this.notHiddenIndexesCache;
         }
         const indexesSequence = this.getIndexesSequence();
-        return indexesSequence.filter((physicalIndex)=>this.isHidden(physicalIndex) === false);
+        const hiddenValues = this.hidingMapsCollection.getMergedValues();
+        const notHiddenIndexes = [];
+        for(let i = 0; i < indexesSequence.length; i += 1){
+            const physicalIndex = indexesSequence[i];
+            if (hiddenValues[physicalIndex] !== true) {
+                notHiddenIndexes.push(physicalIndex);
+            }
+        }
+        return notHiddenIndexes;
     }
     /**
    * Get length of all NOT hidden indexes.
@@ -381,7 +415,15 @@ var /**
             return this.renderablePhysicalIndexesCache;
         }
         const notTrimmedIndexes = this.getNotTrimmedIndexes();
-        return notTrimmedIndexes.filter((physicalIndex)=>this.isHidden(physicalIndex) === false);
+        const hiddenValues = this.hidingMapsCollection.getMergedValues();
+        const renderableIndexes = [];
+        for(let i = 0; i < notTrimmedIndexes.length; i += 1){
+            const physicalIndex = notTrimmedIndexes[i];
+            if (hiddenValues[physicalIndex] !== true) {
+                renderableIndexes.push(physicalIndex);
+            }
+        }
+        return renderableIndexes;
     }
     /**
    * Get length of all NOT trimmed and NOT hidden indexes.
@@ -545,13 +587,16 @@ var /**
    * @private
    */ cacheFromPhysicalToVisualIndexes() {
         const nrOfNotTrimmedIndexes = this.getNotTrimmedIndexesLength();
-        this.fromPhysicalToVisualIndexesCache.clear();
+        const cache = _class_private_method_get(this, _allocateIndexCache, allocateIndexCache).call(this, this.fromPhysicalToVisualIndexesCache, this.getNumberOfIndexes());
         for(let visualIndex = 0; visualIndex < nrOfNotTrimmedIndexes; visualIndex += 1){
             const physicalIndex = this.getPhysicalFromVisualIndex(visualIndex);
-            // Every visual index have corresponding physical index, but some physical indexes may don't have
-            // corresponding visual indexes (physical indexes may represent trimmed indexes, beyond the table boundaries)
-            this.fromPhysicalToVisualIndexesCache.set(physicalIndex, visualIndex);
+            // Every visual index has a corresponding physical index. Physical indexes with no visual index
+            // (trimmed indexes, beyond the table boundaries) keep the `-1` sentinel.
+            if (physicalIndex !== null) {
+                cache[physicalIndex] = visualIndex;
+            }
         }
+        this.fromPhysicalToVisualIndexesCache = cache;
     }
     /**
    * Update cache for translations from visual to renderable indexes.
@@ -559,13 +604,17 @@ var /**
    * @private
    */ cacheFromVisualToRenderableIndexes() {
         const nrOfRenderableIndexes = this.getRenderableIndexesLength();
-        this.fromVisualToRenderableIndexesCache.clear();
+        const cache = _class_private_method_get(this, _allocateIndexCache, allocateIndexCache).call(this, this.fromVisualToRenderableIndexesCache, this.getNotTrimmedIndexesLength());
         for(let renderableIndex = 0; renderableIndex < nrOfRenderableIndexes; renderableIndex += 1){
             // Can't use getRenderableFromVisualIndex here because we're building the cache here
             const physicalIndex = this.getPhysicalFromRenderableIndex(renderableIndex);
             const visualIndex = this.getVisualFromPhysicalIndex(physicalIndex);
-            this.fromVisualToRenderableIndexesCache.set(visualIndex, renderableIndex);
+            // Visual indexes with no renderable index (hidden indexes) keep the `-1` sentinel.
+            if (visualIndex !== null) {
+                cache[visualIndex] = renderableIndex;
+            }
         }
+        this.fromVisualToRenderableIndexesCache = cache;
     }
     /**
    * Destroys the IndexMapper instance. Clears all registered map observers
@@ -581,6 +630,7 @@ var /**
         _class_private_method_init(this, _handleObservedMapChange);
         _class_private_method_init(this, _notifyMapObservers);
         _class_private_method_init(this, _flushDirtyObservedMaps);
+        _class_private_method_init(this, _allocateIndexCache);
         _class_private_field_init(this, _mapObservers, {
             writable: true,
             value: void 0
@@ -685,17 +735,21 @@ var /**
    * @type {Array}
    */ this.renderablePhysicalIndexesCache = [];
         /**
-   * Visual indexes (native map's value) corresponding to physical indexes (native map's index).
+   * Visual indexes (typed array value) corresponding to physical indexes (typed array index).
+   * `-1` marks a physical index with no visual index (trimmed). Backed by a typed array instead of a
+   * `Map` to avoid per-rebuild hashing churn on large datasets.
    *
    * @private
-   * @type {Map}
-   */ this.fromPhysicalToVisualIndexesCache = new Map();
+   * @type {Int32Array}
+   */ this.fromPhysicalToVisualIndexesCache = new Int32Array(0);
         /**
-   * Visual indexes (native map's value) corresponding to physical indexes (native map's index).
+   * Renderable indexes (typed array value) corresponding to visual indexes (typed array index).
+   * `-1` marks a visual index with no renderable index (hidden). Backed by a typed array instead of a
+   * `Map` to avoid per-rebuild hashing churn on large datasets.
    *
    * @private
-   * @type {Map}
-   */ this.fromVisualToRenderableIndexesCache = new Map();
+   * @type {Int32Array}
+   */ this.fromVisualToRenderableIndexesCache = new Int32Array(0);
         _class_private_field_set(this, _mapObservers, new WeakMap());
         _class_private_field_set(this, _dirtyObservedMaps, new Set());
         this.indexesSequence.addLocalHook('change', ()=>{
@@ -744,4 +798,11 @@ function flushDirtyObservedMaps() {
         _class_private_field_get(this, _dirtyObservedMaps).clear();
     }
 }
+function allocateIndexCache(cache, length) {
+    if (cache.length === length) {
+        cache.fill(-1);
+        return cache;
+    }
+    return new Int32Array(length).fill(-1);
+}
 mixin(IndexMapper, localHooks);

package/translations/mapCollections/aggregatedCollection.js

@@ -21,45 +21,30 @@ class AggregatedCollection extends _mapCollection.MapCollection {
         if (readFromCache === true) {
             return this.mergedValuesCache;
         }
-        if (this.getLength() === 0) {
+        const maps = this.get();
+        const numberOfMaps = maps.length;
+        if (numberOfMaps === 0) {
             return [];
         }
-        // Below variable stores values for every particular map. Example describing situation when we have 2 registered maps,
-        // with length equal to 5.
-        //
-        // +---------+---------------------------------------------+
-        // |         |                  indexes                    |
-        // +---------+---------------------------------------------+
-        // |   maps  |     0    |   1   |    2  |   3   |    4     |
-        // +---------+----------+-------+-------+-------+----------+
-        // |    0    | [[ value,  value,  value,  value,  value ], |
-        // |    1    | [  value,  value,  value,  value,  value ]] |
-        // +---------+----------+-------+-------+-------+----------+
-        const mapsValuesMatrix = (0, _array.arrayMap)(this.get(), (map)=>map.getValues());
-        // Below variable stores values for every particular index. Example describing situation when we have 2 registered maps,
-        // with length equal to 5.
-        //
-        // +---------+---------------------+
-        // |         |         maps        |
-        // +---------+---------------------+
-        // | indexes |     0    |    1     |
-        // +---------+----------+----------+
-        // |    0    | [[ value,  value ], |
-        // |    1    | [  value,  value ], |
-        // |    2    | [  value,  value ], |
-        // |    3    | [  value,  value ], |
-        // |    4    | [  value,  value ]] |
-        // +---------+----------+----------+
-        const indexesValuesMatrix = [];
-        const mapsLength = (0, _mixed.isDefined)(mapsValuesMatrix[0]) && mapsValuesMatrix[0].length || 0;
-        for(let index = 0; index < mapsLength; index += 1){
-            const valuesForIndex = [];
-            for(let mapIndex = 0; mapIndex < this.getLength(); mapIndex += 1){
-                valuesForIndex.push(mapsValuesMatrix[mapIndex][index]);
+        // Per-map value arrays. For 2 maps of length 5:
+        //   maps 0 | [ value, value, value, value, value ]
+        //   maps 1 | [ value, value, value, value, value ]
+        const mapsValuesMatrix = (0, _array.arrayMap)(maps, (map)=>map.getValues());
+        const indexesLength = (0, _mixed.isDefined)(mapsValuesMatrix[0]) && mapsValuesMatrix[0].length || 0;
+        const mergedValues = new Array(indexesLength);
+        // A single scratch row, reused for every index, is passed to the aggregation function instead
+        // of allocating one `[value, value, ...]` array per index. The previous matrix approach built
+        // O(rows) throwaway sub-arrays on every sort/trim/hide rebuild (the dominant cost of updateCache
+        // on large datasets). The aggregation functions read this array synchronously and never retain
+        // it, so reuse is safe.
+        const valuesForIndex = new Array(numberOfMaps);
+        for(let index = 0; index < indexesLength; index += 1){
+            for(let mapIndex = 0; mapIndex < numberOfMaps; mapIndex += 1){
+                valuesForIndex[mapIndex] = mapsValuesMatrix[mapIndex][index];
             }
-            indexesValuesMatrix.push(valuesForIndex);
+            mergedValues[index] = this.aggregationFunction(valuesForIndex);
         }
-        return (0, _array.arrayMap)(indexesValuesMatrix, this.aggregationFunction);
+        return mergedValues;
     }
     /**
    * Get merged value for particular index.

package/translations/mapCollections/aggregatedCollection.mjs

@@ -14,45 +14,30 @@ import { isDefined } from '../../helpers/mixed.mjs';
         if (readFromCache === true) {
             return this.mergedValuesCache;
         }
-        if (this.getLength() === 0) {
+        const maps = this.get();
+        const numberOfMaps = maps.length;
+        if (numberOfMaps === 0) {
             return [];
         }
-        // Below variable stores values for every particular map. Example describing situation when we have 2 registered maps,
-        // with length equal to 5.
-        //
-        // +---------+---------------------------------------------+
-        // |         |                  indexes                    |
-        // +---------+---------------------------------------------+
-        // |   maps  |     0    |   1   |    2  |   3   |    4     |
-        // +---------+----------+-------+-------+-------+----------+
-        // |    0    | [[ value,  value,  value,  value,  value ], |
-        // |    1    | [  value,  value,  value,  value,  value ]] |
-        // +---------+----------+-------+-------+-------+----------+
-        const mapsValuesMatrix = arrayMap(this.get(), (map)=>map.getValues());
-        // Below variable stores values for every particular index. Example describing situation when we have 2 registered maps,
-        // with length equal to 5.
-        //
-        // +---------+---------------------+
-        // |         |         maps        |
-        // +---------+---------------------+
-        // | indexes |     0    |    1     |
-        // +---------+----------+----------+
-        // |    0    | [[ value,  value ], |
-        // |    1    | [  value,  value ], |
-        // |    2    | [  value,  value ], |
-        // |    3    | [  value,  value ], |
-        // |    4    | [  value,  value ]] |
-        // +---------+----------+----------+
-        const indexesValuesMatrix = [];
-        const mapsLength = isDefined(mapsValuesMatrix[0]) && mapsValuesMatrix[0].length || 0;
-        for(let index = 0; index < mapsLength; index += 1){
-            const valuesForIndex = [];
-            for(let mapIndex = 0; mapIndex < this.getLength(); mapIndex += 1){
-                valuesForIndex.push(mapsValuesMatrix[mapIndex][index]);
+        // Per-map value arrays. For 2 maps of length 5:
+        //   maps 0 | [ value, value, value, value, value ]
+        //   maps 1 | [ value, value, value, value, value ]
+        const mapsValuesMatrix = arrayMap(maps, (map)=>map.getValues());
+        const indexesLength = isDefined(mapsValuesMatrix[0]) && mapsValuesMatrix[0].length || 0;
+        const mergedValues = new Array(indexesLength);
+        // A single scratch row, reused for every index, is passed to the aggregation function instead
+        // of allocating one `[value, value, ...]` array per index. The previous matrix approach built
+        // O(rows) throwaway sub-arrays on every sort/trim/hide rebuild (the dominant cost of updateCache
+        // on large datasets). The aggregation functions read this array synchronously and never retain
+        // it, so reuse is safe.
+        const valuesForIndex = new Array(numberOfMaps);
+        for(let index = 0; index < indexesLength; index += 1){
+            for(let mapIndex = 0; mapIndex < numberOfMaps; mapIndex += 1){
+                valuesForIndex[mapIndex] = mapsValuesMatrix[mapIndex][index];
             }
-            indexesValuesMatrix.push(valuesForIndex);
+            mergedValues[index] = this.aggregationFunction(valuesForIndex);
         }
-        return arrayMap(indexesValuesMatrix, this.aggregationFunction);
+        return mergedValues;
     }
     /**
    * Get merged value for particular index.