handsontable 15.2.0 → 15.3.0-next-6f5f494-20250424

package/core/viewportScroll/utils.mjs

@@ -0,0 +1,106 @@
+import { isHTMLElement } from "../../helpers/dom/element.mjs";
+/**
+ * Scrolls the browser's viewport to the specified element.
+ *
+ * @param {HTMLElement} element The element to scroll.
+ */
+export function scrollWindowToCell(element) {
+  if (isHTMLElement(element)) {
+    element.scrollIntoView({
+      block: 'nearest',
+      inline: 'nearest'
+    });
+  }
+}
+
+/**
+ * Creates a scroll target calculator that calculates the target row and column best viewport
+ * scroll position based on the current selection.
+ *
+ * @param {Core} hotInstance The Handsontable instance.
+ * @returns {{ getComputedColumnTarget: Function, getComputedRowTarget: Function }}
+ */
+export function createScrollTargetCalculator(hotInstance) {
+  const {
+    selection,
+    view
+  } = hotInstance;
+  const cellRange = hotInstance.getSelectedRangeLast();
+  const source = selection.getSelectionSource();
+  const firstVisibleColumn = view.getFirstFullyVisibleColumn();
+  const lastVisibleColumn = view.getLastFullyVisibleColumn();
+  const selectionFirstColumn = cellRange.getTopStartCorner().col;
+  const selectionLastColumn = cellRange.getBottomEndCorner().col;
+  const isSelectionOutsideStartViewport = selectionFirstColumn <= firstVisibleColumn;
+  const isSelectionOutsideEndViewport = selectionLastColumn >= lastVisibleColumn;
+  const firstVisibleRow = view.getFirstFullyVisibleRow();
+  const lastVisibleRow = view.getLastFullyVisibleRow();
+  const selectionFirstRow = cellRange.getTopStartCorner().row;
+  const selectionLastRow = cellRange.getBottomEndCorner().row;
+  const isSelectionOutsideTopViewport = selectionFirstRow <= firstVisibleRow;
+  const isSelectionOutsideBottomViewport = selectionLastRow >= lastVisibleRow;
+  return {
+    /**
+     * Calculates the target column for scrolling.
+     *
+     * @param {CellCoords} lastSelectionCoords The last selection coordinates.
+     * @returns {number}
+     */
+    getComputedColumnTarget(lastSelectionCoords) {
+      if (source === 'mouse' || source === 'keyboard') {
+        // For mouse or keyboard selection, always scroll to the last column
+        // defined by the last selection coords
+        return lastSelectionCoords.col;
+      }
+      if (isSelectionOutsideStartViewport && isSelectionOutsideEndViewport) {
+        // If the selection is outside both ends of the viewport, scroll to the
+        // column where the focused cell is located
+        return cellRange.highlight.col;
+      }
+      if (isSelectionOutsideStartViewport) {
+        // If the selection is outside the start (left) of the viewport, scroll to
+        // the first column of the selection range
+        return selectionFirstColumn;
+      }
+      if (isSelectionOutsideEndViewport) {
+        // If the selection is outside the end (right) of the viewport, scroll to
+        // the last column of the selection range
+        return selectionLastColumn;
+      }
+
+      // For other cases, scroll to the column defined by the last selection coords
+      return lastSelectionCoords.col;
+    },
+    /**
+     * Calculates the target row for scrolling.
+     *
+     * @param {CellCoords} lastSelectionCoords The last selection coordinates.
+     * @returns {number}
+     */
+    getComputedRowTarget(lastSelectionCoords) {
+      if (source === 'mouse' || source === 'keyboard') {
+        // For mouse or keyboard selection, always scroll to the last row
+        // defined by the coords
+        return lastSelectionCoords.row;
+      }
+      if (isSelectionOutsideTopViewport && isSelectionOutsideBottomViewport) {
+        // If the selection is outside both ends of the viewport, scroll to the
+        // row where the focused cell is located
+        return cellRange.highlight.row;
+      }
+      if (isSelectionOutsideTopViewport) {
+        // If the selection is outside the top of the viewport, scroll to
+        // the first row of the selection range
+        return selectionFirstRow;
+      }
+      if (isSelectionOutsideBottomViewport) {
+        // If the selection is outside the bottom of the viewport, scroll to
+        // the last row of the selection range
+        return selectionLastRow;
+      }
+
+      // For other cases, scroll to the row defined by the last selection coords
+      return lastSelectionCoords.row;
+    }
+  };
+}

package/core.d.ts

@@ -59,7 +59,7 @@ export default class Core {
   getCell(row: number, column: number, topmost?: boolean): HTMLTableCellElement | null;
   getCellEditor(cellMeta: CellMeta): BaseEditor;
   getCellEditor(row: number, column: number): BaseEditor;
-  getCellMeta(row: number, column: number): CellProperties;
+  getCellMeta(row: number, column: number, options?: { skipMetaExtension: boolean }): CellProperties;
   getCellMetaAtRow(row: number): CellProperties[];
   getCellRenderer(cellMeta: CellMeta): BaseRenderer;
   getCellRenderer(row: number, column: number): BaseRenderer;
@@ -140,7 +140,6 @@ export default class Core {
   removeCellMeta(row: number, column: number, key: (keyof CellMeta) | string): void;
   removeHook<K extends keyof Events>(key: K, callback: Events[K]): void;
   render(): void;
-  renderCall: boolean;
   resumeExecution(): void;
   resumeRender(): void;
   rootDocument: Document;
@@ -148,7 +147,7 @@ export default class Core {
   rootWindow: Window;
   rowIndexMapper: IndexMapper;
   runHooks(key: keyof Events, p1?: any, p2?: any, p3?: any, p4?: any, p5?: any, p6?: any): any;
-  scrollViewportTo(options: { row?: number, col?: number, verticalSnap?: 'top' | 'bottom', horizontalSnap?: 'start' | 'end', considerHiddenIndexes?: boolean }): boolean;
+  scrollViewportTo(options: { row?: number, col?: number, verticalSnap?: 'top' | 'bottom', horizontalSnap?: 'start' | 'end', considerHiddenIndexes?: boolean }, callback?: () => void): boolean;
   scrollViewportTo(row?: number, column?: number, snapToBottom?: boolean, snapToRight?: boolean, considerHiddenIndexes?: boolean): boolean;
   scrollToFocusedCell(callback?: () => void): void;
   selectAll(includeRowHeaders?: boolean, includeColumnHeaders?: boolean, options?: { focusPosition?: SimpleCellCoords | CellCoords, disableHeadersHighlight?: boolean }): void;

package/core.js

@@ -4,6 +4,7 @@ exports.__esModule = true;
 exports.default = Core;
 require("core-js/modules/es.error.cause.js");
 require("core-js/modules/es.array.push.js");
+require("core-js/modules/es.object.from-entries.js");
 require("core-js/modules/es.set.difference.v2.js");
 require("core-js/modules/es.set.intersection.v2.js");
 require("core-js/modules/es.set.is-disjoint-from.v2.js");
@@ -226,12 +227,15 @@ function Core(rootElement, userSettings) {
     return instance.isLtr() ? 1 : -1;
   };
   userSettings.language = (0, _registry5.getValidLanguageCode)(userSettings.language);
-  const metaManager = new _dataMap.MetaManager(instance, userSettings, [_dataMap.DynamicCellMetaMod, _dataMap.ExtendMetaPropertiesMod]);
+  const settingsWithoutHooks = Object.fromEntries(Object.entries(userSettings).filter(_ref => {
+    let [key] = _ref;
+    return !(_hooks.Hooks.getSingleton().isRegistered(key) || _hooks.Hooks.getSingleton().isDeprecated(key));
+  }));
+  const metaManager = new _dataMap.MetaManager(instance, settingsWithoutHooks, [_dataMap.DynamicCellMetaMod, _dataMap.ExtendMetaPropertiesMod]);
   const tableMeta = metaManager.getTableMeta();
   const globalMeta = metaManager.getGlobalMeta();
   const pluginsRegistry = (0, _uniqueMap.createUniqueMap)();
   this.container = this.rootDocument.createElement('div');
-  this.renderCall = false;
   rootElement.insertBefore(this.container, rootElement.firstChild);
   if ((0, _rootInstance.isRootInstance)(this)) {
     (0, _mixed._injectProductInfo)(userSettings.licenseKey, rootElement);
@@ -263,6 +267,9 @@ function Core(rootElement, userSettings) {
   this.rowIndexMapper.addLocalHook('indexesSequenceChange', source => {
     instance.runHooks('afterRowSequenceChange', source);
   });
+  eventManager.addEventListener(this.rootDocument.documentElement, 'compositionstart', event => {
+    instance.runHooks('beforeCompositionStart', event);
+  });
   dataSource = new _dataSource.default(instance);
   if (!this.rootElement.id || this.rootElement.id.substring(0, 3) === 'ht_') {
     this.rootElement.id = this.guid; // if root element does not have an id, assign a random id
@@ -338,10 +345,11 @@ function Core(rootElement, userSettings) {
     }
   });
   this.selection = selection;
-  const onIndexMapperCacheUpdate = _ref => {
+  const onIndexMapperCacheUpdate = _ref2 => {
     let {
       hiddenIndexesChanged
-    } = _ref;
+    } = _ref2;
+    this.forceFullRender = true;
     if (hiddenIndexesChanged) {
       this.selection.commit();
     }
@@ -520,9 +528,9 @@ function Core(rootElement, userSettings) {
         const sortedIndexes = [...indexes];
 
         // Sort the indexes in ascending order.
-        sortedIndexes.sort((_ref2, _ref3) => {
-          let [indexA] = _ref2;
-          let [indexB] = _ref3;
+        sortedIndexes.sort((_ref3, _ref4) => {
+          let [indexA] = _ref3;
+          let [indexB] = _ref4;
           if (indexA === indexB) {
             return 0;
           }
@@ -530,8 +538,8 @@ function Core(rootElement, userSettings) {
         });
 
         // Normalize the {index, amount} groups into bigger groups.
-        const normalizedIndexes = (0, _array.arrayReduce)(sortedIndexes, (acc, _ref4) => {
-          let [groupIndex, groupAmount] = _ref4;
+        const normalizedIndexes = (0, _array.arrayReduce)(sortedIndexes, (acc, _ref5) => {
+          let [groupIndex, groupAmount] = _ref5;
           const previousItem = acc[acc.length - 1];
           const [prevIndex, prevAmount] = previousItem;
           const prevLastIndex = prevIndex + prevAmount;
@@ -599,8 +607,8 @@ function Core(rootElement, userSettings) {
             let offset = 0;
 
             // Normalize the {index, amount} groups into bigger groups.
-            (0, _array.arrayEach)(indexes, _ref5 => {
-              let [groupIndex, groupAmount] = _ref5;
+            (0, _array.arrayEach)(indexes, _ref6 => {
+              let [groupIndex, groupAmount] = _ref6;
               const calcIndex = (0, _mixed.isEmpty)(groupIndex) ? instance.countRows() - 1 : Math.max(groupIndex - offset, 0);
 
               // If the 'index' is an integer decrease it by 'offset' otherwise pass it through to make the value
@@ -625,13 +633,6 @@ function Core(rootElement, userSettings) {
                 }
               }
               const totalRows = instance.countRows();
-              if (totalRows === 0) {
-                selection.deselect();
-              } else if (source === 'ContextMenu.removeRow') {
-                selection.refresh();
-              } else {
-                selection.shiftRows(groupIndex, -groupAmount);
-              }
               const fixedRowsTop = tableMeta.fixedRowsTop;
               if (fixedRowsTop >= calcIndex + 1) {
                 tableMeta.fixedRowsTop -= Math.min(groupAmount, fixedRowsTop - calcIndex);
@@ -640,6 +641,13 @@ function Core(rootElement, userSettings) {
               if (fixedRowsBottom && calcIndex >= totalRows - fixedRowsBottom) {
                 tableMeta.fixedRowsBottom -= Math.min(groupAmount, fixedRowsBottom);
               }
+              if (totalRows === 0) {
+                selection.deselect();
+              } else if (source === 'ContextMenu.removeRow') {
+                selection.refresh();
+              } else {
+                selection.shiftRows(groupIndex, -groupAmount);
+              }
               offset += groupAmount;
             });
           };
@@ -654,8 +662,8 @@ function Core(rootElement, userSettings) {
             let offset = 0;
 
             // Normalize the {index, amount} groups into bigger groups.
-            (0, _array.arrayEach)(indexes, _ref6 => {
-              let [groupIndex, groupAmount] = _ref6;
+            (0, _array.arrayEach)(indexes, _ref7 => {
+              let [groupIndex, groupAmount] = _ref7;
               const calcIndex = (0, _mixed.isEmpty)(groupIndex) ? instance.countCols() - 1 : Math.max(groupIndex - offset, 0);
               let physicalColumnIndex = instance.toPhysicalColumn(calcIndex);
 
@@ -1033,7 +1041,7 @@ function Core(rootElement, userSettings) {
     if ((0, _browser.isMobileBrowser)() || (0, _browser.isIpadOS)()) {
       (0, _element.addClass)(instance.rootElement, 'mobile');
     }
-    this.updateSettings(tableMeta, true);
+    this.updateSettings(userSettings, true);
     this.view = new _tableView.default(this);
     const themeName = tableMeta.themeName || (0, _themes.getThemeClassName)(instance.rootElement);
 
@@ -1049,8 +1057,7 @@ function Core(rootElement, userSettings) {
       (0, _index.installFocusCatcher)(instance);
     }
     instance.runHooks('init');
-    this.forceFullRender = true; // used when data was changed
-    this.view.render();
+    this.render();
 
     // Run the logic only if it's the table's initialization and the root element is not visible.
     if (!!firstRun && instance.rootElement.offsetParent === null) {
@@ -1223,13 +1230,11 @@ function Core(rootElement, userSettings) {
       datamap.set(changes[i][0], changes[i][1], changes[i][3]);
     }
     const hasChanges = changes.length > 0;
-    instance.forceFullRender = true; // used when data was changed or when all cells need to be re-rendered
-
     if (hasChanges) {
       grid.adjustRowsAndCols();
       instance.runHooks('beforeChangeRender', changes, source);
       editorManager.closeEditor();
-      instance.view.render();
+      instance.render();
       editorManager.prepareEditor();
       instance.view.adjustElementsSize();
       instance.runHooks('afterChange', changes, source || 'edit');
@@ -1238,7 +1243,7 @@ function Core(rootElement, userSettings) {
         activeEditor.refreshValue();
       }
     } else {
-      instance.view.render();
+      instance.render();
     }
   }
 
@@ -1388,9 +1393,22 @@ function Core(rootElement, userSettings) {
           ...tableMeta
         };
       }
-      if (cellProperties.type === 'numeric' && typeof newValue === 'string' && (0, _number.isNumericLike)(newValue)) {
+      const {
+        type,
+        checkedTemplate,
+        uncheckedTemplate
+      } = cellProperties;
+      if (type === 'numeric' && typeof newValue === 'string' && (0, _number.isNumericLike)(newValue)) {
         filteredChanges[i][3] = getParsedNumber(newValue);
       }
+      if (type === 'checkbox') {
+        const stringifiedValue = (0, _mixed.stringify)(newValue);
+        const isChecked = stringifiedValue === (0, _mixed.stringify)(checkedTemplate);
+        const isUnchecked = stringifiedValue === (0, _mixed.stringify)(uncheckedTemplate);
+        if (isChecked || isUnchecked) {
+          filteredChanges[i][3] = isChecked ? checkedTemplate : uncheckedTemplate;
+        }
+      }
     }
     return filteredChanges;
   }
@@ -1614,11 +1632,11 @@ function Core(rootElement, userSettings) {
   this.getSelected = function () {
     // https://github.com/handsontable/handsontable/issues/44  //cjl
     if (selection.isSelected()) {
-      return (0, _array.arrayMap)(selection.getSelectedRange(), _ref7 => {
+      return (0, _array.arrayMap)(selection.getSelectedRange(), _ref8 => {
         let {
           from,
           to
-        } = _ref7;
+        } = _ref8;
         return [from.row, from.col, to.row, to.col];
       });
     }
@@ -1792,11 +1810,7 @@ function Core(rootElement, userSettings) {
     const nextValue = this.renderSuspendedCounter - 1;
     this.renderSuspendedCounter = Math.max(nextValue, 0);
     if (!this.isRenderSuspended() && nextValue === this.renderSuspendedCounter) {
-      if (this.renderCall) {
-        this.render();
-      } else {
-        instance.view.render();
-      }
+      instance.view.render();
     }
   };
 
@@ -1812,9 +1826,8 @@ function Core(rootElement, userSettings) {
    */
   this.render = function () {
     if (this.view) {
-      this.renderCall = true;
-      this.forceFullRender = true; // used when data was changed or when all cells need to be re-rendered
-
+      // used when data was changed or when all cells need to be re-rendered (slow render)
+      this.forceFullRender = true;
       if (!this.isRenderSuspended()) {
         instance.view.render();
       }
@@ -2307,23 +2320,27 @@ function Core(rootElement, userSettings) {
     if ((0, _mixed.isDefined)(settings.ganttChart)) {
       throw new Error('Since 8.0.0 the "ganttChart" setting is no longer supported.');
     }
+    if (settings.language) {
+      setLanguage(settings.language);
+    }
 
     // eslint-disable-next-line no-restricted-syntax
     for (i in settings) {
-      if (i === 'data') {
-        // Do nothing. loadData will be triggered later
-      } else if (i === 'language') {
-        setLanguage(settings.language);
+      if (i === 'data' || i === 'language') {
+        // Do nothing. loadData and language change will be triggered later
       } else if (i === 'className') {
         setClassName('className', settings.className);
       } else if (i === 'tableClassName' && instance.table) {
         setClassName('tableClassName', settings.tableClassName);
         instance.view._wt.wtOverlays.syncOverlayTableClassNames();
       } else if (_hooks.Hooks.getSingleton().isRegistered(i) || _hooks.Hooks.getSingleton().isDeprecated(i)) {
-        if ((0, _function.isFunction)(settings[i])) {
-          _hooks.Hooks.getSingleton().addAsFixed(i, settings[i], instance);
-        } else if (Array.isArray(settings[i])) {
-          _hooks.Hooks.getSingleton().add(i, settings[i], instance);
+        const hook = settings[i];
+        if ((0, _function.isFunction)(hook)) {
+          _hooks.Hooks.getSingleton().addAsFixed(i, hook, instance);
+          tableMeta[i] = hook;
+        } else if (Array.isArray(hook)) {
+          _hooks.Hooks.getSingleton().add(i, hook, instance);
+          tableMeta[i] = hook;
         }
       } else if (!init && (0, _object.hasOwnProperty)(settings, i)) {
         // Update settings
@@ -2427,8 +2444,7 @@ function Core(rootElement, userSettings) {
     }
     grid.adjustRowsAndCols();
     if (instance.view && !firstRun) {
-      instance.forceFullRender = true; // used when data was changed
-      instance.view.render();
+      instance.render();
       instance.view._wt.wtOverlays.adjustElementsSize();
     }
     if (!init && instance.view && (currentHeight === '' || height === '' || height === undefined) && currentHeight !== height) {
@@ -2857,15 +2873,15 @@ function Core(rootElement, userSettings) {
     const isThereAnySetSourceListener = this.hasHook('afterSetSourceDataAtCell');
     const changesForHook = [];
     if (isThereAnySetSourceListener) {
-      (0, _array.arrayEach)(input, _ref8 => {
-        let [changeRow, changeProp, changeValue] = _ref8;
+      (0, _array.arrayEach)(input, _ref9 => {
+        let [changeRow, changeProp, changeValue] = _ref9;
         changesForHook.push([changeRow, changeProp, dataSource.getAtCell(changeRow, changeProp),
         // The previous value.
         changeValue]);
       });
     }
-    (0, _array.arrayEach)(input, _ref9 => {
-      let [changeRow, changeProp, changeValue] = _ref9;
+    (0, _array.arrayEach)(input, _ref10 => {
+      let [changeRow, changeProp, changeValue] = _ref10;
       dataSource.setAtCell(changeRow, changeProp, changeValue);
     });
     if (isThereAnySetSourceListener) {
@@ -3085,11 +3101,16 @@ function Core(rootElement, userSettings) {
    * @function getCellMeta
    * @param {number} row Visual row index.
    * @param {number} column Visual column index.
+   * @param {object} options Execution options for the `getCellMeta` method.
+   * @param {boolean} [options.skipMetaExtension=false] If `true`, skips extending the cell meta object. This means, the `cells` function, as well as the `afterGetCellMeta` and `beforeGetCellMeta` hooks, will not be called.
    * @returns {object} The cell properties object.
    * @fires Hooks#beforeGetCellMeta
    * @fires Hooks#afterGetCellMeta
    */
   this.getCellMeta = function (row, column) {
+    let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {
+      skipMetaExtension: false
+    };
     let physicalRow = this.toPhysicalRow(row);
     let physicalColumn = this.toPhysicalColumn(column);
     if (physicalRow === null) {
@@ -3100,7 +3121,8 @@ function Core(rootElement, userSettings) {
     }
     return metaManager.getCellMeta(physicalRow, physicalColumn, {
       visualRow: row,
-      visualColumn: column
+      visualColumn: column,
+      ...options
     });
   };
 
@@ -4077,6 +4099,8 @@ function Core(rootElement, userSettings) {
    *   col: 50,
    *   verticalSnap: 'bottom',
    *   horizontalSnap: 'end',
+   * }, () => {
+   *   // callback function executed after the viewport is scrolled
    * });
    * ```
    *
@@ -4099,9 +4123,10 @@ function Core(rootElement, userSettings) {
    * be positioned at the start or end of the viewport.
    * @param {boolean} [options.considerHiddenIndexes=true] If `true`, we handle visual indexes, otherwise we handle only indexes which
    * may be rendered when they are in the viewport (we don't consider hidden indexes as they aren't rendered).
+   * @param {Function} [callback] The callback function to call after the viewport is scrolled.
    * @returns {boolean} `true` if viewport was scrolled, `false` otherwise.
    */
-  this.scrollViewportTo = function (options) {
+  this.scrollViewportTo = function (options, callback) {
     // Support for backward compatibility arguments: (row, col, snapToBottom, snapToRight, considerHiddenIndexes)
     if (typeof options === 'number') {
       var _arguments$;
@@ -4122,6 +4147,9 @@ function Core(rootElement, userSettings) {
     } = options !== null && options !== void 0 ? options : {};
     let renderableRow = row;
     let renderableColumn = col;
+    if ((0, _function.isFunction)(callback)) {
+      this.addHookOnce('afterScroll', callback);
+    }
     if (considerHiddenIndexes === undefined || considerHiddenIndexes) {
       const isValidRowGrid = Number.isInteger(row) && row >= 0;
       const isValidColumnGrid = Number.isInteger(col) && col >= 0;
@@ -4135,16 +4163,24 @@ function Core(rootElement, userSettings) {
     }
     const isRowInteger = Number.isInteger(renderableRow);
     const isColumnInteger = Number.isInteger(renderableColumn);
+    let isScrolled = false;
     if (isRowInteger && renderableRow >= 0 && isColumnInteger && renderableColumn >= 0) {
-      return instance.view.scrollViewport(instance._createCellCoords(renderableRow, renderableColumn), options.horizontalSnap, options.verticalSnap);
-    }
-    if (isRowInteger && renderableRow >= 0 && (isColumnInteger && renderableColumn < 0 || !isColumnInteger)) {
-      return instance.view.scrollViewportVertically(renderableRow, options.verticalSnap);
-    }
-    if (isColumnInteger && renderableColumn >= 0 && (isRowInteger && renderableRow < 0 || !isRowInteger)) {
-      return instance.view.scrollViewportHorizontally(renderableColumn, options.horizontalSnap);
+      isScrolled = instance.view.scrollViewport(instance._createCellCoords(renderableRow, renderableColumn), options.horizontalSnap, options.verticalSnap);
+    } else if (isRowInteger && renderableRow >= 0 && (isColumnInteger && renderableColumn < 0 || !isColumnInteger)) {
+      isScrolled = instance.view.scrollViewportVertically(renderableRow, options.verticalSnap);
+    } else if (isColumnInteger && renderableColumn >= 0 && (isRowInteger && renderableRow < 0 || !isRowInteger)) {
+      isScrolled = instance.view.scrollViewportHorizontally(renderableColumn, options.horizontalSnap);
+    }
+    if ((0, _function.isFunction)(callback)) {
+      if (isScrolled) {
+        // fast render triggers `afterScroll` hook
+        this.view.render();
+      } else {
+        this.removeHook('afterScroll', callback);
+        this._registerMicrotask(() => callback());
+      }
     }
-    return false;
+    return isScrolled;
   };
 
   /**
@@ -4154,24 +4190,28 @@ function Core(rootElement, userSettings) {
    * @memberof Core#
    * @fires Hooks#afterScroll
    * @function scrollToFocusedCell
-   * @param {Function} callback The callback function to call after the viewport is scrolled.
+   * @param {Function} [callback] The callback function to call after the viewport is scrolled.
+   * @returns {boolean} `true` if the viewport was scrolled, `false` otherwise.
    */
-  this.scrollToFocusedCell = function () {
-    let callback = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : () => {};
+  this.scrollToFocusedCell = function (callback) {
     if (!this.selection.isSelected()) {
-      return;
+      return false;
+    }
+    if ((0, _function.isFunction)(callback)) {
+      this.addHookOnce('afterScroll', callback);
     }
-    this.addHookOnce('afterScroll', callback);
     const {
       highlight
     } = this.getSelectedRangeLast();
     const isScrolled = this.scrollViewportTo(highlight.toObject());
     if (isScrolled) {
+      // fast render triggers `afterScroll` hook
       this.view.render();
-    } else {
+    } else if ((0, _function.isFunction)(callback)) {
       this.removeHook('afterScroll', callback);
-      this._registerImmediate(() => callback());
+      this._registerMicrotask(() => callback());
     }
+    return isScrolled;
   };
 
   /**
@@ -4212,8 +4252,8 @@ function Core(rootElement, userSettings) {
     instance.batchExecution(() => {
       instance.rowIndexMapper.unregisterAll();
       instance.columnIndexMapper.unregisterAll();
-      pluginsRegistry.getItems().forEach(_ref10 => {
-        let [, plugin] = _ref10;
+      pluginsRegistry.getItems().forEach(_ref11 => {
+        let [, plugin] = _ref11;
         plugin.destroy();
       });
       pluginsRegistry.clear();
@@ -4680,6 +4720,20 @@ function Core(rootElement, userSettings) {
     });
   };
 
+  /**
+   * Registers a microtask callback.
+   *
+   * @param {Function} callback Function to be delayed in execution.
+   * @private
+   */
+  this._registerMicrotask = function (callback) {
+    this.rootWindow.queueMicrotask(() => {
+      if (!this.isDestroyed) {
+        callback();
+      }
+    });
+  };
+
   /**
    * Gets the instance of the EditorManager.
    *