handsontable 18.0.0 → 18.1.0-rc1

package/plugins/autoRowSize/autoRowSize.d.ts

@@ -2,7 +2,7 @@ import type { HotInstance } from '../../core/types';
 import { BasePlugin } from '../base';
 import GhostTable from '../../utils/ghostTable';
 import SamplesGenerator from '../../utils/samplesGenerator';
-import { PhysicalIndexToValueMap as IndexToValueMap } from '../../translations';
+import type { PhysicalIndexToValueMap as IndexToValueMap } from '../../translations';
 export declare const PLUGIN_KEY = "autoRowSize";
 export declare const PLUGIN_PRIORITY = 40;
 /**
@@ -30,19 +30,44 @@ export declare const PLUGIN_PRIORITY = 40;
  *
  * // as a string (percent)
  * autoRowSize: {syncLimit: '40%'},
+ * ```
+ *
+ * To speed up the calculations, the plugin samples a subset of rows rather than measuring every row. By default, it
+ * skips rows whose value it has already sampled, on the assumption that identical values render at the same height.
  *
- * // allow sample duplication
- * autoRowSize: {syncLimit: '40%', allowSampleDuplicates: true},
+ * Sampling accepts additional options:
+ * - *samplingRatio* - Defines how many samples for the same length will be used to calculate. Default is `3`.
+ *
+ * ```js
+ *   autoRowSize: {
+ *     samplingRatio: 10,
+ *   }
  * ```
  *
- * You can also use the `allowSampleDuplicates` option to allow sampling duplicate values when calculating the row
- * height. __Note__, that this might have a negative impact on performance.
+ * Set the `allowSampleDuplicates` option to `true` to sample duplicate values as well:
+ *
+ * ```js
+ * autoRowSize: {allowSampleDuplicates: true},
+ * ```
+ *
+ * Enable this option when rows with the same value can still render at different heights - for example, with multiline
+ * text, or with custom renderers that vary a row's height based on its position or other data. Without it, the plugin
+ * may sample only one of those rows and apply its height to the rest, leading to incorrect row heights.
+ *
+ * The tradeoff is performance: allowing duplicates increases the number of rows measured, which lengthens the
+ * calculation and can block the UI for longer on large data sets.
  *
  * ::: tip
  * Note: Updating some of the table's settings can cause the row heights to change (e.g. `wordWrap`, `textEllipsis`, renderers etc.).
  * In those cases, to ensure that the row heights are properly recalculated, you need to call the {@link AutoRowSize#recalculateAllRowsHeight} method after calling {@link Core#updateSettings}.
  * :::
  *
+ * ::: tip
+ * If you use custom renderers, multiline text, or custom styles that produce non-standard row heights, and you call
+ * {@link Core#scrollViewportTo}, you must enable `AutoRowSize`. Without it, `scrollViewportTo()` calculates scroll
+ * positions based on the default row height and may scroll to an incorrect position.
+ * :::
+ *
  * To configure this plugin see {@link Options#autoRowSize}.
  *
  * @example
@@ -288,12 +313,22 @@ export declare class AutoRowSize extends BasePlugin {
     /**
      * Get the first visible row.
      *
+     * When the {@link MergeCells} plugin is enabled with its default `virtualized: false` setting, a merged
+     * cell that crosses the viewport edge extends the rendered row range. In that case this method can
+     * return a row index outside the strictly visible viewport. To read the actual visible viewport, use
+     * {@link Core#getFirstFullyVisibleRow} or {@link Core#getFirstPartiallyVisibleRow}.
+     *
      * @returns {number} Returns row index, -1 if table is not rendered or if there are no rows to base the the calculations on.
      */
     getFirstVisibleRow(): number;
     /**
      * Gets the last visible row.
      *
+     * When the {@link MergeCells} plugin is enabled with its default `virtualized: false` setting, a merged
+     * cell that crosses the viewport edge extends the rendered row range. In that case this method can
+     * return a row index outside the strictly visible viewport. To read the actual visible viewport, use
+     * {@link Core#getLastFullyVisibleRow} or {@link Core#getLastPartiallyVisibleRow}.
+     *
      * @returns {number} Returns row index or -1 if table is not rendered.
      */
     getLastVisibleRow(): number;

package/plugins/autoRowSize/autoRowSize.js

@@ -26,7 +26,7 @@ const _object = require("../../helpers/object");
 const _number = require("../../helpers/number");
 const _samplesGenerator = /*#__PURE__*/ _interop_require_default(require("../../utils/samplesGenerator"));
 const _string = require("../../helpers/string");
-const _translations = require("../../translations");
+const _renderCell = require("../../renderers/renderCell");
 const _element = require("../../helpers/dom/element");
 function _check_private_redeclaration(obj, privateCollection) {
     if (privateCollection.has(obj)) {
@@ -34,15 +34,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");
         }
@@ -50,9 +47,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) {
@@ -69,9 +64,7 @@ function _class_private_field_set(receiver, privateMap, value) {
     return value;
 }
 function _class_private_method_get(receiver, privateSet, fn) {
-    if (!privateSet.has(receiver)) {
-        throw new TypeError("attempted to get private field on non-instance");
-    }
+    if (!privateSet.has(receiver)) throw new TypeError("attempted to get private field on non-instance");
     return fn;
 }
 function _class_private_method_init(obj, privateSet) {
@@ -101,6 +94,13 @@ var /**
    *
    * @type {boolean}
    */ _isInitialized = /*#__PURE__*/ new WeakMap(), /**
+   * `true` when a full row-height recalculation is already scheduled for the current
+   * column-resize gesture. Resizing several selected columns fires `beforeColumnResize` once
+   * per column in one synchronous loop — the flag coalesces those calls into a single
+   * recalculation that runs after every new width has been applied.
+   *
+   * @type {boolean}
+   */ _columnResizeRecalcScheduled = /*#__PURE__*/ new WeakMap(), /**
    * Calculates specific rows height (overwrite cache values).
    *
    * @param {number[]} visualRows List of visual rows to calculate.
@@ -116,6 +116,11 @@ var /**
    * Recalculates heights for currently visible rows and processes any rows queued by data
    * changes before the next render.
    */ _onBeforeRender = /*#__PURE__*/ new WeakMap(), /**
+   * Schedules a single full row-height recalculation per column-resize gesture. The hook fires
+   * once per selected column, so the recalculation is deferred until the gesture's synchronous
+   * loop (and the render that applies the new widths) has finished — the heights are then
+   * measured once, against the final column widths.
+   */ _onBeforeColumnResize = /*#__PURE__*/ new WeakMap(), /**
    * Recalculates the row height from content on a double-click and returns it as the new
    * size; returns the user-dragged size otherwise.
    */ _onBeforeRowResize = /*#__PURE__*/ new WeakMap(), /**
@@ -187,7 +192,7 @@ class AutoRowSize extends _base.BasePlugin {
         }
         this.addHook('afterLoadData', _class_private_field_get(this, _onAfterLoadData));
         this.addHook('beforeChangeRender', _class_private_field_get(this, _onBeforeChange));
-        this.addHook('beforeColumnResize', ()=>this.recalculateAllRowsHeight());
+        this.addHook('beforeColumnResize', _class_private_field_get(this, _onBeforeColumnResize));
         this.addHook('afterFormulasValuesUpdate', _class_private_field_get(this, _onAfterFormulasValuesUpdate));
         this.addHook('beforeViewRender', _class_private_field_get(this, _onBeforeViewRender));
         this.addHook('beforeRender', _class_private_field_get(this, _onBeforeRender));
@@ -255,7 +260,11 @@ class AutoRowSize extends _base.BasePlugin {
             from: colRange,
             to: colRange
         } : colRange;
-        if (this.hot.getColHeader(0) !== null) {
+        // The cached header height is reused unless the caller explicitly overwrites the cache
+        // (full renders triggered by data or settings changes do). Without this guard, every
+        // render — including selection-driven ones — would re-sample the header row across all
+        // columns and force a ghost-table reflow even when every height is already cached.
+        if ((overwriteCache || this.headerHeight === null) && this.hot.getColHeader(0) !== null) {
             const samples = this.samplesGenerator.generateRowSamples(-1, columnsRange);
             this.ghostTable.addColumnHeadersRow(samples.get(-1));
         }
@@ -302,7 +311,7 @@ class AutoRowSize extends _base.BasePlugin {
         const loop = ()=>{
             // When hot was destroyed after calculating finished cancel frame
             if (!this.hot) {
-                (0, _feature.cancelAnimationFrame)(timer);
+                (0, _feature.cancelIdleTask)(timer);
                 this.inProgress = false;
                 return;
             }
@@ -312,9 +321,9 @@ class AutoRowSize extends _base.BasePlugin {
             }, colRange, overwriteCache);
             current = current + AutoRowSize.CALCULATION_STEP + 1;
             if (current < length) {
-                timer = (0, _feature.requestAnimationFrame)(loop);
+                timer = (0, _feature.requestIdleTask)(loop);
             } else {
-                (0, _feature.cancelAnimationFrame)(timer);
+                (0, _feature.cancelIdleTask)(timer);
                 this.inProgress = false;
                 // @TODO Should call once per render cycle, currently fired separately in different plugins
                 this.hot.view.adjustElementsSize();
@@ -409,6 +418,11 @@ class AutoRowSize extends _base.BasePlugin {
     /**
    * Get the first visible row.
    *
+   * When the {@link MergeCells} plugin is enabled with its default `virtualized: false` setting, a merged
+   * cell that crosses the viewport edge extends the rendered row range. In that case this method can
+   * return a row index outside the strictly visible viewport. To read the actual visible viewport, use
+   * {@link Core#getFirstFullyVisibleRow} or {@link Core#getFirstPartiallyVisibleRow}.
+   *
    * @returns {number} Returns row index, -1 if table is not rendered or if there are no rows to base the the calculations on.
    */ getFirstVisibleRow() {
         return this.hot.getFirstRenderedVisibleRow() ?? -1;
@@ -416,6 +430,11 @@ class AutoRowSize extends _base.BasePlugin {
     /**
    * Gets the last visible row.
    *
+   * When the {@link MergeCells} plugin is enabled with its default `virtualized: false` setting, a merged
+   * cell that crosses the viewport edge extends the rendered row range. In that case this method can
+   * return a row index outside the strictly visible viewport. To read the actual visible viewport, use
+   * {@link Core#getLastFullyVisibleRow} or {@link Core#getLastPartiallyVisibleRow}.
+   *
    * @returns {number} Returns row index or -1 if table is not rendered.
    */ getLastVisibleRow() {
         return this.hot.getLastRenderedVisibleRow() ?? -1;
@@ -477,12 +496,18 @@ class AutoRowSize extends _base.BasePlugin {
         }), _class_private_field_init(this, _isInitialized, {
             writable: true,
             value: void 0
+        }), _class_private_field_init(this, _columnResizeRecalcScheduled, {
+            writable: true,
+            value: void 0
         }), _class_private_field_init(this, _onBeforeViewRender, {
             writable: true,
             value: void 0
         }), _class_private_field_init(this, _onBeforeRender, {
             writable: true,
             value: void 0
+        }), _class_private_field_init(this, _onBeforeColumnResize, {
+            writable: true,
+            value: void 0
         }), _class_private_field_init(this, _onBeforeRowResize, {
             writable: true,
             value: void 0
@@ -520,7 +545,10 @@ class AutoRowSize extends _base.BasePlugin {
             }
             let cellMeta;
             if (row >= 0 && column >= 0) {
-                cellMeta = this.hot.getCellMeta(row, column);
+                // The transient read resolves the full dynamic meta (hooks + `cells`, so `hidden` from
+                // merged cells works) without storing anything - this sampler sweeps every row, and the
+                // eager `getCellMeta` would permanently materialize one meta per visited cell.
+                cellMeta = this.hot.getCellMetaTransient(row, column);
                 if (cellMeta.hidden) {
                     // do not generate samples for cells that are covered by merged cell (null values)
                     return false;
@@ -529,8 +557,10 @@ class AutoRowSize extends _base.BasePlugin {
             let cellValue;
             if (row >= 0) {
                 cellValue = this.hot.getDataAtCell(row, column);
-                if (typeof cellMeta?.valueFormatter === 'function') {
-                    cellValue = cellMeta.valueFormatter(cellValue, cellMeta);
+                if (cellMeta) {
+                    // Format through the same precedence as the render path (cell-level `valueFormatter`, then
+                    // the renderer's own static), so the measured string matches what the renderer produces.
+                    cellValue = (0, _renderCell.formatCellValue)(cellValue, cellMeta, this.hot.getCellRenderer(cellMeta));
                 }
             } else if (row === -1) {
                 cellValue = this.hot.getColHeader(column);
@@ -546,12 +576,7 @@ class AutoRowSize extends _base.BasePlugin {
    * Number of already measured rows (we already know their sizes).
    *
    * @type {number}
-   */ this.measuredRows = 0, /**
-   * PhysicalIndexToValueMap to keep and track heights for physical row indexes.
-   *
-   * @private
-   * @type {PhysicalIndexToValueMap}
-   */ this.rowHeightsMap = new _translations.PhysicalIndexToValueMap(), _class_private_field_set(this, _visualRowsToRefresh, []), _class_private_field_set(this, _disposeMapObserver, null), _class_private_field_set(this, _isInitialized, false), _class_private_field_set(this, _onBeforeViewRender, ()=>{
+   */ this.measuredRows = 0, _class_private_field_set(this, _visualRowsToRefresh, []), _class_private_field_set(this, _disposeMapObserver, null), _class_private_field_set(this, _isInitialized, false), _class_private_field_set(this, _columnResizeRecalcScheduled, false), _class_private_field_set(this, _onBeforeViewRender, ()=>{
             _class_private_method_get(this, _toggleFirstDatasetColumnRenderedClassName, toggleFirstDatasetColumnRenderedClassName).call(this);
         }), _class_private_field_set(this, _onBeforeRender, ()=>{
             this.calculateVisibleRowsHeight();
@@ -559,6 +584,15 @@ class AutoRowSize extends _base.BasePlugin {
                 _class_private_method_get(this, _calculateSpecificRowsHeight, calculateSpecificRowsHeight).call(this, _class_private_field_get(this, _visualRowsToRefresh));
                 _class_private_field_set(this, _visualRowsToRefresh, []);
             }
+        }), _class_private_field_set(this, _onBeforeColumnResize, ()=>{
+            if (_class_private_field_get(this, _columnResizeRecalcScheduled)) {
+                return;
+            }
+            _class_private_field_set(this, _columnResizeRecalcScheduled, true);
+            this.hot._registerTimeout(()=>{
+                _class_private_field_set(this, _columnResizeRecalcScheduled, false);
+                this.recalculateAllRowsHeight();
+            }, 0);
         }), _class_private_field_set(this, _onBeforeRowResize, (size, row, isDblClick)=>{
             let newSize = size;
             if (isDblClick) {
@@ -571,14 +605,13 @@ class AutoRowSize extends _base.BasePlugin {
                 this.recalculateAllRowsHeight();
             }
         }), _class_private_field_set(this, _onBeforeChange, (changes)=>{
-            const changedRows = changes.reduce((acc, [row])=>{
-                const rowIndex = Number(row);
-                if (acc.indexOf(rowIndex) === -1) {
-                    acc.push(rowIndex);
-                }
-                return acc;
-            }, []);
-            _class_private_field_get(this, _visualRowsToRefresh).push(...changedRows);
+            const changedRows = new Set();
+            changes.forEach(([row])=>{
+                changedRows.add(Number(row));
+            });
+            changedRows.forEach((rowIndex)=>{
+                _class_private_field_get(this, _visualRowsToRefresh).push(rowIndex);
+            });
         }), _class_private_field_set(this, _onInit, ()=>{
             this.recalculateAllRowsHeight();
             _class_private_field_set(this, _isInitialized, true);
@@ -604,7 +637,11 @@ class AutoRowSize extends _base.BasePlugin {
             }, []);
             _class_private_field_get(this, _visualRowsToRefresh).push(...changedRows);
         });
-        this.hot.rowIndexMapper.registerMap(ROW_WIDTHS_MAP_NAME, this.rowHeightsMap);
+        // The map holds numbers only, so re-writing an unchanged height is a no-op that must not
+        // invalidate the row-height position cache.
+        this.rowHeightsMap = this.hot.rowIndexMapper.createAndRegisterIndexMap(ROW_WIDTHS_MAP_NAME, 'physicalIndexToValue', null, {
+            skipUnchangedWrites: true
+        });
         // Leave the listener active to allow auto-sizing the rows when the plugin is disabled.
         // This is necessary for height recalculation for resize handler doubleclick (ManualRowResize).
         this.addHook('beforeRowResize', _class_private_field_get(this, _onBeforeRowResize));

package/plugins/autoRowSize/autoRowSize.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) {
@@ -39,9 +34,7 @@ function _class_private_field_set(receiver, privateMap, value) {
     return value;
 }
 function _class_private_method_get(receiver, privateSet, fn) {
-    if (!privateSet.has(receiver)) {
-        throw new TypeError("attempted to get private field on non-instance");
-    }
+    if (!privateSet.has(receiver)) throw new TypeError("attempted to get private field on non-instance");
     return fn;
 }
 function _class_private_method_init(obj, privateSet) {
@@ -49,13 +42,13 @@ function _class_private_method_init(obj, privateSet) {
     privateSet.add(obj);
 }
 import { BasePlugin } from '../base/index.mjs';
-import { cancelAnimationFrame, requestAnimationFrame } from '../../helpers/feature.mjs';
+import { cancelIdleTask, requestIdleTask } from '../../helpers/feature.mjs';
 import GhostTable from '../../utils/ghostTable.mjs';
 import { isObject } from '../../helpers/object.mjs';
 import { valueAccordingPercent, rangeEach } from '../../helpers/number.mjs';
 import SamplesGenerator from '../../utils/samplesGenerator.mjs';
 import { isPercentValue } from '../../helpers/string.mjs';
-import { PhysicalIndexToValueMap as IndexToValueMap } from '../../translations/index.mjs';
+import { formatCellValue } from '../../renderers/renderCell.mjs';
 import { addClass, removeClass } from '../../helpers/dom/element.mjs';
 export const PLUGIN_KEY = 'autoRowSize';
 export const PLUGIN_PRIORITY = 40;
@@ -75,6 +68,13 @@ var /**
    *
    * @type {boolean}
    */ _isInitialized = /*#__PURE__*/ new WeakMap(), /**
+   * `true` when a full row-height recalculation is already scheduled for the current
+   * column-resize gesture. Resizing several selected columns fires `beforeColumnResize` once
+   * per column in one synchronous loop — the flag coalesces those calls into a single
+   * recalculation that runs after every new width has been applied.
+   *
+   * @type {boolean}
+   */ _columnResizeRecalcScheduled = /*#__PURE__*/ new WeakMap(), /**
    * Calculates specific rows height (overwrite cache values).
    *
    * @param {number[]} visualRows List of visual rows to calculate.
@@ -90,6 +90,11 @@ var /**
    * Recalculates heights for currently visible rows and processes any rows queued by data
    * changes before the next render.
    */ _onBeforeRender = /*#__PURE__*/ new WeakMap(), /**
+   * Schedules a single full row-height recalculation per column-resize gesture. The hook fires
+   * once per selected column, so the recalculation is deferred until the gesture's synchronous
+   * loop (and the render that applies the new widths) has finished — the heights are then
+   * measured once, against the final column widths.
+   */ _onBeforeColumnResize = /*#__PURE__*/ new WeakMap(), /**
    * Recalculates the row height from content on a double-click and returns it as the new
    * size; returns the user-dragged size otherwise.
    */ _onBeforeRowResize = /*#__PURE__*/ new WeakMap(), /**
@@ -129,19 +134,44 @@ var /**
  *
  * // as a string (percent)
  * autoRowSize: {syncLimit: '40%'},
+ * ```
+ *
+ * To speed up the calculations, the plugin samples a subset of rows rather than measuring every row. By default, it
+ * skips rows whose value it has already sampled, on the assumption that identical values render at the same height.
  *
- * // allow sample duplication
- * autoRowSize: {syncLimit: '40%', allowSampleDuplicates: true},
+ * Sampling accepts additional options:
+ * - *samplingRatio* - Defines how many samples for the same length will be used to calculate. Default is `3`.
+ *
+ * ```js
+ *   autoRowSize: {
+ *     samplingRatio: 10,
+ *   }
+ * ```
+ *
+ * Set the `allowSampleDuplicates` option to `true` to sample duplicate values as well:
+ *
+ * ```js
+ * autoRowSize: {allowSampleDuplicates: true},
  * ```
  *
- * You can also use the `allowSampleDuplicates` option to allow sampling duplicate values when calculating the row
- * height. __Note__, that this might have a negative impact on performance.
+ * Enable this option when rows with the same value can still render at different heights - for example, with multiline
+ * text, or with custom renderers that vary a row's height based on its position or other data. Without it, the plugin
+ * may sample only one of those rows and apply its height to the rest, leading to incorrect row heights.
+ *
+ * The tradeoff is performance: allowing duplicates increases the number of rows measured, which lengthens the
+ * calculation and can block the UI for longer on large data sets.
  *
  * ::: tip
  * Note: Updating some of the table's settings can cause the row heights to change (e.g. `wordWrap`, `textEllipsis`, renderers etc.).
  * In those cases, to ensure that the row heights are properly recalculated, you need to call the {@link AutoRowSize#recalculateAllRowsHeight} method after calling {@link Core#updateSettings}.
  * :::
  *
+ * ::: tip
+ * If you use custom renderers, multiline text, or custom styles that produce non-standard row heights, and you call
+ * {@link Core#scrollViewportTo}, you must enable `AutoRowSize`. Without it, `scrollViewportTo()` calculates scroll
+ * positions based on the default row height and may scroll to an incorrect position.
+ * :::
+ *
  * To configure this plugin see {@link Options#autoRowSize}.
  *
  * @example
@@ -291,7 +321,7 @@ var /**
         }
         this.addHook('afterLoadData', _class_private_field_get(this, _onAfterLoadData));
         this.addHook('beforeChangeRender', _class_private_field_get(this, _onBeforeChange));
-        this.addHook('beforeColumnResize', ()=>this.recalculateAllRowsHeight());
+        this.addHook('beforeColumnResize', _class_private_field_get(this, _onBeforeColumnResize));
         this.addHook('afterFormulasValuesUpdate', _class_private_field_get(this, _onAfterFormulasValuesUpdate));
         this.addHook('beforeViewRender', _class_private_field_get(this, _onBeforeViewRender));
         this.addHook('beforeRender', _class_private_field_get(this, _onBeforeRender));
@@ -359,7 +389,11 @@ var /**
             from: colRange,
             to: colRange
         } : colRange;
-        if (this.hot.getColHeader(0) !== null) {
+        // The cached header height is reused unless the caller explicitly overwrites the cache
+        // (full renders triggered by data or settings changes do). Without this guard, every
+        // render — including selection-driven ones — would re-sample the header row across all
+        // columns and force a ghost-table reflow even when every height is already cached.
+        if ((overwriteCache || this.headerHeight === null) && this.hot.getColHeader(0) !== null) {
             const samples = this.samplesGenerator.generateRowSamples(-1, columnsRange);
             this.ghostTable.addColumnHeadersRow(samples.get(-1));
         }
@@ -406,7 +440,7 @@ var /**
         const loop = ()=>{
             // When hot was destroyed after calculating finished cancel frame
             if (!this.hot) {
-                cancelAnimationFrame(timer);
+                cancelIdleTask(timer);
                 this.inProgress = false;
                 return;
             }
@@ -416,9 +450,9 @@ var /**
             }, colRange, overwriteCache);
             current = current + AutoRowSize.CALCULATION_STEP + 1;
             if (current < length) {
-                timer = requestAnimationFrame(loop);
+                timer = requestIdleTask(loop);
             } else {
-                cancelAnimationFrame(timer);
+                cancelIdleTask(timer);
                 this.inProgress = false;
                 // @TODO Should call once per render cycle, currently fired separately in different plugins
                 this.hot.view.adjustElementsSize();
@@ -513,6 +547,11 @@ var /**
     /**
    * Get the first visible row.
    *
+   * When the {@link MergeCells} plugin is enabled with its default `virtualized: false` setting, a merged
+   * cell that crosses the viewport edge extends the rendered row range. In that case this method can
+   * return a row index outside the strictly visible viewport. To read the actual visible viewport, use
+   * {@link Core#getFirstFullyVisibleRow} or {@link Core#getFirstPartiallyVisibleRow}.
+   *
    * @returns {number} Returns row index, -1 if table is not rendered or if there are no rows to base the the calculations on.
    */ getFirstVisibleRow() {
         return this.hot.getFirstRenderedVisibleRow() ?? -1;
@@ -520,6 +559,11 @@ var /**
     /**
    * Gets the last visible row.
    *
+   * When the {@link MergeCells} plugin is enabled with its default `virtualized: false` setting, a merged
+   * cell that crosses the viewport edge extends the rendered row range. In that case this method can
+   * return a row index outside the strictly visible viewport. To read the actual visible viewport, use
+   * {@link Core#getLastFullyVisibleRow} or {@link Core#getLastPartiallyVisibleRow}.
+   *
    * @returns {number} Returns row index or -1 if table is not rendered.
    */ getLastVisibleRow() {
         return this.hot.getLastRenderedVisibleRow() ?? -1;
@@ -581,12 +625,18 @@ var /**
         }), _class_private_field_init(this, _isInitialized, {
             writable: true,
             value: void 0
+        }), _class_private_field_init(this, _columnResizeRecalcScheduled, {
+            writable: true,
+            value: void 0
         }), _class_private_field_init(this, _onBeforeViewRender, {
             writable: true,
             value: void 0
         }), _class_private_field_init(this, _onBeforeRender, {
             writable: true,
             value: void 0
+        }), _class_private_field_init(this, _onBeforeColumnResize, {
+            writable: true,
+            value: void 0
         }), _class_private_field_init(this, _onBeforeRowResize, {
             writable: true,
             value: void 0
@@ -624,7 +674,10 @@ var /**
             }
             let cellMeta;
             if (row >= 0 && column >= 0) {
-                cellMeta = this.hot.getCellMeta(row, column);
+                // The transient read resolves the full dynamic meta (hooks + `cells`, so `hidden` from
+                // merged cells works) without storing anything - this sampler sweeps every row, and the
+                // eager `getCellMeta` would permanently materialize one meta per visited cell.
+                cellMeta = this.hot.getCellMetaTransient(row, column);
                 if (cellMeta.hidden) {
                     // do not generate samples for cells that are covered by merged cell (null values)
                     return false;
@@ -633,8 +686,10 @@ var /**
             let cellValue;
             if (row >= 0) {
                 cellValue = this.hot.getDataAtCell(row, column);
-                if (typeof cellMeta?.valueFormatter === 'function') {
-                    cellValue = cellMeta.valueFormatter(cellValue, cellMeta);
+                if (cellMeta) {
+                    // Format through the same precedence as the render path (cell-level `valueFormatter`, then
+                    // the renderer's own static), so the measured string matches what the renderer produces.
+                    cellValue = formatCellValue(cellValue, cellMeta, this.hot.getCellRenderer(cellMeta));
                 }
             } else if (row === -1) {
                 cellValue = this.hot.getColHeader(column);
@@ -650,12 +705,7 @@ var /**
    * Number of already measured rows (we already know their sizes).
    *
    * @type {number}
-   */ this.measuredRows = 0, /**
-   * PhysicalIndexToValueMap to keep and track heights for physical row indexes.
-   *
-   * @private
-   * @type {PhysicalIndexToValueMap}
-   */ this.rowHeightsMap = new IndexToValueMap(), _class_private_field_set(this, _visualRowsToRefresh, []), _class_private_field_set(this, _disposeMapObserver, null), _class_private_field_set(this, _isInitialized, false), _class_private_field_set(this, _onBeforeViewRender, ()=>{
+   */ this.measuredRows = 0, _class_private_field_set(this, _visualRowsToRefresh, []), _class_private_field_set(this, _disposeMapObserver, null), _class_private_field_set(this, _isInitialized, false), _class_private_field_set(this, _columnResizeRecalcScheduled, false), _class_private_field_set(this, _onBeforeViewRender, ()=>{
             _class_private_method_get(this, _toggleFirstDatasetColumnRenderedClassName, toggleFirstDatasetColumnRenderedClassName).call(this);
         }), _class_private_field_set(this, _onBeforeRender, ()=>{
             this.calculateVisibleRowsHeight();
@@ -663,6 +713,15 @@ var /**
                 _class_private_method_get(this, _calculateSpecificRowsHeight, calculateSpecificRowsHeight).call(this, _class_private_field_get(this, _visualRowsToRefresh));
                 _class_private_field_set(this, _visualRowsToRefresh, []);
             }
+        }), _class_private_field_set(this, _onBeforeColumnResize, ()=>{
+            if (_class_private_field_get(this, _columnResizeRecalcScheduled)) {
+                return;
+            }
+            _class_private_field_set(this, _columnResizeRecalcScheduled, true);
+            this.hot._registerTimeout(()=>{
+                _class_private_field_set(this, _columnResizeRecalcScheduled, false);
+                this.recalculateAllRowsHeight();
+            }, 0);
         }), _class_private_field_set(this, _onBeforeRowResize, (size, row, isDblClick)=>{
             let newSize = size;
             if (isDblClick) {
@@ -675,14 +734,13 @@ var /**
                 this.recalculateAllRowsHeight();
             }
         }), _class_private_field_set(this, _onBeforeChange, (changes)=>{
-            const changedRows = changes.reduce((acc, [row])=>{
-                const rowIndex = Number(row);
-                if (acc.indexOf(rowIndex) === -1) {
-                    acc.push(rowIndex);
-                }
-                return acc;
-            }, []);
-            _class_private_field_get(this, _visualRowsToRefresh).push(...changedRows);
+            const changedRows = new Set();
+            changes.forEach(([row])=>{
+                changedRows.add(Number(row));
+            });
+            changedRows.forEach((rowIndex)=>{
+                _class_private_field_get(this, _visualRowsToRefresh).push(rowIndex);
+            });
         }), _class_private_field_set(this, _onInit, ()=>{
             this.recalculateAllRowsHeight();
             _class_private_field_set(this, _isInitialized, true);
@@ -708,7 +766,11 @@ var /**
             }, []);
             _class_private_field_get(this, _visualRowsToRefresh).push(...changedRows);
         });
-        this.hot.rowIndexMapper.registerMap(ROW_WIDTHS_MAP_NAME, this.rowHeightsMap);
+        // The map holds numbers only, so re-writing an unchanged height is a no-op that must not
+        // invalidate the row-height position cache.
+        this.rowHeightsMap = this.hot.rowIndexMapper.createAndRegisterIndexMap(ROW_WIDTHS_MAP_NAME, 'physicalIndexToValue', null, {
+            skipUnchangedWrites: true
+        });
         // Leave the listener active to allow auto-sizing the rows when the plugin is disabled.
         // This is necessary for height recalculation for resize handler doubleclick (ManualRowResize).
         this.addHook('beforeRowResize', _class_private_field_get(this, _onBeforeRowResize));