handsontable 18.0.0 → 18.1.0-rc7

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)) {
@@ -101,6 +101,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 +123,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 +199,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 +267,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 +318,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 +328,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 +425,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 +437,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 +503,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 +552,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 +564,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 +583,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 +591,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 +612,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 +644,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

@@ -49,13 +49,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 +75,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 +97,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 +141,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.
+ *
+ * Sampling accepts additional options:
+ * - *samplingRatio* - Defines how many samples for the same length will be used to calculate. Default is `3`.
  *
- * // allow sample duplication
- * autoRowSize: {syncLimit: '40%', allowSampleDuplicates: true},
+ * ```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
@@ -291,7 +328,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 +396,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 +447,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 +457,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 +554,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 +566,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 +632,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 +681,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 +693,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 +712,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 +720,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 +741,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 +773,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));

package/plugins/autofill/autofill.js

@@ -91,9 +91,11 @@ var /**
    *
    * @type {string|null}
    */ _currentDragDirection = /*#__PURE__*/ new WeakMap(), /**
-   * Last mouse client position.
+   * Last mouse client position. Stays `null` until the first `mousemove` of a drag, so a scroll
+   * that happens after pressing the fill handle but before any drag move is not replayed with a
+   * stale or default position.
    *
-   * @type {{ clientX: number, clientY: number }}
+   * @type {{ clientX: number, clientY: number } | null}
    */ _lastMouseClientPosition = /*#__PURE__*/ new WeakMap(), /**
    * Adjusts fill data for reverse drag directions ('up' or 'left') by reordering rows or columns.
    *
@@ -138,6 +140,10 @@ var /**
    * On mouse move listener.
    *
    * @param {MouseEvent} event `mousemove` event properties.
+   * @param {boolean} [countDragStep=true] Whether a move onto a new cell should be counted as a
+   * drag step. Only genuine pointer moves count; a scroll replay (see `#onAfterScroll`) redraws
+   * the border without counting, otherwise a scroll that shifts the cell under a resting pointer
+   * would register a drag that never happened.
    */ _onMouseMove = /*#__PURE__*/ new WeakSet(), /**
    * Refreshes the autofill borders using the last mouse client position after scroll.
    */ _onAfterScroll = /*#__PURE__*/ new WeakMap();
@@ -253,15 +259,19 @@ class Autofill extends _base.BasePlugin {
         ]);
         const copyableRows = [];
         const copyableColumns = [];
+        const seenRows = new Set();
+        const seenColumns = new Set();
         const data = [];
         (0, _array.arrayEach)(copyableRanges, (range)=>{
             for(let visualRow = range.startRow; visualRow <= range.endRow; visualRow += 1){
-                if (copyableRows.indexOf(visualRow) === -1) {
+                if (!seenRows.has(visualRow)) {
+                    seenRows.add(visualRow);
                     copyableRows.push(visualRow);
                 }
             }
             for(let visualColumn = range.startCol; visualColumn <= range.endCol; visualColumn += 1){
-                if (copyableColumns.indexOf(visualColumn) === -1) {
+                if (!seenColumns.has(visualColumn)) {
+                    seenColumns.add(visualColumn);
                     copyableColumns.push(visualColumn);
                 }
             }
@@ -619,10 +629,7 @@ class Autofill extends _base.BasePlugin {
    *
    * @private
    * @type {boolean}
-   */ this.autoInsertRow = false, _class_private_field_set(this, _currentDragDirection, null), _class_private_field_set(this, _lastMouseClientPosition, {
-            clientX: 0,
-            clientY: 0
-        }), _class_private_field_set(this, _onCellCornerDblClick, ()=>{
+   */ this.autoInsertRow = false, _class_private_field_set(this, _currentDragDirection, null), _class_private_field_set(this, _lastMouseClientPosition, null), _class_private_field_set(this, _onCellCornerDblClick, ()=>{
             const selectionApplied = this.selectAdjacent();
             if (selectionApplied) {
                 this.fillIn();
@@ -631,9 +638,10 @@ class Autofill extends _base.BasePlugin {
             this.handleDraggedCells = 1;
             this.mouseDownOnCellCorner = true;
             _class_private_field_set(this, _currentDragDirection, null);
+            _class_private_field_set(this, _lastMouseClientPosition, null);
         }), _class_private_field_set(this, _onAfterScroll, ()=>{
-            if (this.mouseDownOnCellCorner) {
-                _class_private_method_get(this, _onMouseMove, onMouseMove).call(this, _class_private_field_get(this, _lastMouseClientPosition));
+            if (this.mouseDownOnCellCorner && _class_private_field_get(this, _lastMouseClientPosition)) {
+                _class_private_method_get(this, _onMouseMove, onMouseMove).call(this, _class_private_field_get(this, _lastMouseClientPosition), false);
             }
         });
     }
@@ -675,7 +683,9 @@ function extendFillDataWithSourceData(fillData, selectionSourceData, startOfDrag
         fullFillData.push([]);
         for(let columnIndex = Math.min(startOfDragCoords.col, endOfDragCoords.col); columnIndex <= Math.max(startOfDragCoords.col, endOfDragCoords.col); columnIndex += 1){
             const targetCellSourceData = this.hot.getSourceDataAtCell(rowIndex, columnIndex);
-            const cellMeta = this.hot.getCellMeta(rowIndex, columnIndex);
+            // The transient read keeps a large drag-fill or fill-down from permanently materializing
+            // one meta object per filled cell - the loop only reads `source`/`_complexDataFormat`.
+            const cellMeta = this.hot.getCellMetaTransient(rowIndex, columnIndex);
             const cellSource = cellMeta.source;
             const cellSourceFirstItem = Array.isArray(cellSource) ? cellSource[0] : undefined;
             const isComplexDataFormatCell = cellMeta._complexDataFormat || (0, _object.isObject)(cellSourceFirstItem) || Array.isArray(cellSourceFirstItem);
@@ -713,14 +723,22 @@ function onMouseUp() {
         _class_private_field_set(this, _currentDragDirection, null);
     }
 }
-function onMouseMove(event) {
+function onMouseMove(event, countDragStep = true) {
     if (this.mouseDownOnCellCorner) {
         const { clientX, clientY } = event;
         const cellCoords = (0, _cellCoords.getCellCoordsFromMousePosition)(this.hot, clientX, clientY);
+        const selectedRange = this.hot.getSelectedRangeLast();
         _class_private_field_set(this, _lastMouseClientPosition, {
             clientX,
             clientY
         });
+        // The `beforeOnCellMouseOver`-based counting doesn't fire when the pointer leaves
+        // the table element (e.g. dragging the last column's fill handle at a slight angle,
+        // past the table's edge), so count the drag here as well. Otherwise the fill made
+        // with such a drag would never be committed on mouseup.
+        if (countDragStep && this.handleDraggedCells > 0 && selectedRange && !selectedRange.includes(cellCoords)) {
+            this.handleDraggedCells += 1;
+        }
         this.redrawBorders(cellCoords);
     }
     const mouseWasDraggedOutside = this.getIfMouseWasDraggedOutside(event);