handsontable 0.0.0-next-e989337-20240117 → 0.0.0-next-40cdda4-20240118

package/3rdparty/walkontable/src/table.js

@@ -272,6 +272,7 @@ class Table {
       if (this.isMaster) {
         // in case we only scrolled without redraw, update visible rows information in oldRowsCalculator
         wtViewport.createVisibleCalculators();
+        wtViewport.createPartiallyVisibleCalculators();
       }
       if (wtOverlays) {
         wtOverlays.refresh(true);
@@ -315,6 +316,7 @@ class Table {
         }
         if (this.isMaster) {
           this.dataAccessObject.wtViewport.createVisibleCalculators();
+          this.dataAccessObject.wtViewport.createPartiallyVisibleCalculators();
           this.dataAccessObject.wtOverlays.refresh(false);
           this.dataAccessObject.wtOverlays.applyToDOM();
           const hiderWidth = (0, _element.outerWidth)(this.hider);

package/3rdparty/walkontable/src/table.mjs

@@ -268,6 +268,7 @@ class Table {
       if (this.isMaster) {
         // in case we only scrolled without redraw, update visible rows information in oldRowsCalculator
         wtViewport.createVisibleCalculators();
+        wtViewport.createPartiallyVisibleCalculators();
       }
       if (wtOverlays) {
         wtOverlays.refresh(true);
@@ -311,6 +312,7 @@ class Table {
         }
         if (this.isMaster) {
           this.dataAccessObject.wtViewport.createVisibleCalculators();
+          this.dataAccessObject.wtViewport.createPartiallyVisibleCalculators();
           this.dataAccessObject.wtOverlays.refresh(false);
           this.dataAccessObject.wtOverlays.applyToDOM();
           const hiderWidth = outerWidth(this.hider);

package/3rdparty/walkontable/src/viewport.js

@@ -377,6 +377,15 @@ class Viewport {
     this.columnsVisibleCalculator = this.createColumnsCalculator(_calculator.FULLY_VISIBLE_TYPE);
   }
 
+  /**
+   * Creates rowsPartiallyVisibleCalculator and columnsPartiallyVisibleCalculator (after draw, to determine what are
+   * the actually partially visible rows and columns).
+   */
+  createPartiallyVisibleCalculators() {
+    this.rowsPartiallyVisibleCalculator = this.createRowsCalculator(_calculator.PARTIALLY_VISIBLE_TYPE);
+    this.columnsPartiallyVisibleCalculator = this.createColumnsCalculator(_calculator.PARTIALLY_VISIBLE_TYPE);
+  }
+
   /**
    * Returns information whether proposedRowsVisibleCalculator viewport
    * is contained inside rows rendered in previous draw (cached in rowsRenderCalculator).

package/3rdparty/walkontable/src/viewport.mjs

@@ -1,6 +1,6 @@
 import { getScrollbarWidth, getStyle, offset, outerHeight, outerWidth } from "../../../helpers/dom/element.mjs";
 import { objectEach } from "../../../helpers/object.mjs";
-import { RENDER_TYPE, FULLY_VISIBLE_TYPE, RenderAllColumnsCalculator, RenderAllRowsCalculator, ViewportColumnsCalculator, ViewportRowsCalculator } from "./calculator/index.mjs";
+import { RENDER_TYPE, FULLY_VISIBLE_TYPE, PARTIALLY_VISIBLE_TYPE, RenderAllColumnsCalculator, RenderAllRowsCalculator, ViewportColumnsCalculator, ViewportRowsCalculator } from "./calculator/index.mjs";
 /**
  * @class Viewport
  */
@@ -374,6 +374,15 @@ class Viewport {
     this.columnsVisibleCalculator = this.createColumnsCalculator(FULLY_VISIBLE_TYPE);
   }
 
+  /**
+   * Creates rowsPartiallyVisibleCalculator and columnsPartiallyVisibleCalculator (after draw, to determine what are
+   * the actually partially visible rows and columns).
+   */
+  createPartiallyVisibleCalculators() {
+    this.rowsPartiallyVisibleCalculator = this.createRowsCalculator(PARTIALLY_VISIBLE_TYPE);
+    this.columnsPartiallyVisibleCalculator = this.createColumnsCalculator(PARTIALLY_VISIBLE_TYPE);
+  }
+
   /**
    * Returns information whether proposedRowsVisibleCalculator viewport
    * is contained inside rows rendered in previous draw (cached in rowsRenderCalculator).

package/base.js

@@ -45,8 +45,8 @@ Handsontable.hooks = _pluginHooks.default.getSingleton();
 Handsontable.CellCoords = _src.CellCoords;
 Handsontable.CellRange = _src.CellRange;
 Handsontable.packageName = 'handsontable';
-Handsontable.buildDate = "17/01/2024 08:45:08";
-Handsontable.version = "0.0.0-next-e989337-20240117";
+Handsontable.buildDate = "18/01/2024 13:04:28";
+Handsontable.version = "0.0.0-next-40cdda4-20240118";
 Handsontable.languages = {
   dictionaryKeys: _registry.dictionaryKeys,
   getLanguageDictionary: _registry.getLanguageDictionary,

package/base.mjs

@@ -35,8 +35,8 @@ Handsontable.hooks = Hooks.getSingleton();
 Handsontable.CellCoords = CellCoords;
 Handsontable.CellRange = CellRange;
 Handsontable.packageName = 'handsontable';
-Handsontable.buildDate = "17/01/2024 08:45:14";
-Handsontable.version = "0.0.0-next-e989337-20240117";
+Handsontable.buildDate = "18/01/2024 13:04:34";
+Handsontable.version = "0.0.0-next-40cdda4-20240118";
 Handsontable.languages = {
   dictionaryKeys,
   getLanguageDictionary,

package/core/index.js

@@ -6,4 +6,10 @@ Object.keys(_focusCatcher).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
   if (key in exports && exports[key] === _focusCatcher[key]) return;
   exports[key] = _focusCatcher[key];
+});
+var _viewportScroll = require("./viewportScroll");
+Object.keys(_viewportScroll).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _viewportScroll[key]) return;
+  exports[key] = _viewportScroll[key];
 });

package/core/index.mjs

@@ -1 +1,2 @@
-export * from "./focusCatcher/index.mjs";
+export * from "./focusCatcher/index.mjs";
+export * from "./viewportScroll/index.mjs";

package/core/viewportScroll/index.js

@@ -0,0 +1,65 @@
+"use strict";
+
+exports.__esModule = true;
+exports.createViewportScroller = createViewportScroller;
+var _columnHeaderScroll = require("./scrollStrategies/columnHeaderScroll");
+var _cornerHeaderScroll = require("./scrollStrategies/cornerHeaderScroll");
+var _multipleScroll = require("./scrollStrategies/multipleScroll");
+var _noncontiguousScroll = require("./scrollStrategies/noncontiguousScroll");
+var _rowHeaderScroll = require("./scrollStrategies/rowHeaderScroll");
+var _singleScroll = require("./scrollStrategies/singleScroll");
+/**
+ * @typedef ViewportScroller
+ * @property {function(): void} resume Resumes the viewport scroller.
+ * @property {function(): void} suspend Suspends the viewport scroller until the `resume` method is called.
+ * @property {function(): void} skipNextScrollCycle Skip the next scroll cycle.
+ * @property {function(CellCoords): void} scrollTo Scroll the viewport to a given cell.
+ */
+/**
+ * Installs a viewport scroller module. The module is responsible for scrolling the viewport to a given cell
+ * based on the selection type (single cell selection, multiple cells selection, header selection etc.).
+ * It's triggered by the selection module via the `afterSetRangeEnd` hook every time the selection changes.
+ *
+ * @param {Core} hot The Handsontable instance.
+ * @returns {ViewportScroller} The viewport scroller module.
+ */
+function createViewportScroller(hot) {
+  const {
+    selection
+  } = hot;
+  let skipNextCall = false;
+  let isSuspended = false;
+  return {
+    resume() {
+      isSuspended = false;
+    },
+    suspend() {
+      isSuspended = true;
+    },
+    skipNextScrollCycle() {
+      skipNextCall = true;
+    },
+    scrollTo(cellCoords) {
+      var _scrollStrategy;
+      if (skipNextCall || isSuspended) {
+        skipNextCall = false;
+        return;
+      }
+      let scrollStrategy;
+      if (selection.isSelectedByCorner()) {
+        scrollStrategy = (0, _cornerHeaderScroll.cornerHeaderScrollStrategy)(hot);
+      } else if (selection.isSelectedByRowHeader()) {
+        scrollStrategy = (0, _rowHeaderScroll.rowHeaderScrollStrategy)(hot);
+      } else if (selection.isSelectedByColumnHeader()) {
+        scrollStrategy = (0, _columnHeaderScroll.columnHeaderScrollStrategy)(hot);
+      } else if (selection.getSelectedRange().size() === 1 && selection.isMultiple()) {
+        scrollStrategy = (0, _multipleScroll.multipleScrollStrategy)(hot);
+      } else if (selection.getSelectedRange().size() === 1 && !selection.isMultiple()) {
+        scrollStrategy = (0, _singleScroll.singleScrollStrategy)(hot);
+      } else if (selection.getSelectedRange().size() > 1) {
+        scrollStrategy = (0, _noncontiguousScroll.noncontiguousScrollStrategy)(hot);
+      }
+      (_scrollStrategy = scrollStrategy) === null || _scrollStrategy === void 0 || _scrollStrategy(cellCoords);
+    }
+  };
+}

package/core/viewportScroll/index.mjs

@@ -0,0 +1,61 @@
+import { columnHeaderScrollStrategy } from "./scrollStrategies/columnHeaderScroll.mjs";
+import { cornerHeaderScrollStrategy } from "./scrollStrategies/cornerHeaderScroll.mjs";
+import { multipleScrollStrategy } from "./scrollStrategies/multipleScroll.mjs";
+import { noncontiguousScrollStrategy } from "./scrollStrategies/noncontiguousScroll.mjs";
+import { rowHeaderScrollStrategy } from "./scrollStrategies/rowHeaderScroll.mjs";
+import { singleScrollStrategy } from "./scrollStrategies/singleScroll.mjs";
+/**
+ * @typedef ViewportScroller
+ * @property {function(): void} resume Resumes the viewport scroller.
+ * @property {function(): void} suspend Suspends the viewport scroller until the `resume` method is called.
+ * @property {function(): void} skipNextScrollCycle Skip the next scroll cycle.
+ * @property {function(CellCoords): void} scrollTo Scroll the viewport to a given cell.
+ */
+/**
+ * Installs a viewport scroller module. The module is responsible for scrolling the viewport to a given cell
+ * based on the selection type (single cell selection, multiple cells selection, header selection etc.).
+ * It's triggered by the selection module via the `afterSetRangeEnd` hook every time the selection changes.
+ *
+ * @param {Core} hot The Handsontable instance.
+ * @returns {ViewportScroller} The viewport scroller module.
+ */
+export function createViewportScroller(hot) {
+  const {
+    selection
+  } = hot;
+  let skipNextCall = false;
+  let isSuspended = false;
+  return {
+    resume() {
+      isSuspended = false;
+    },
+    suspend() {
+      isSuspended = true;
+    },
+    skipNextScrollCycle() {
+      skipNextCall = true;
+    },
+    scrollTo(cellCoords) {
+      var _scrollStrategy;
+      if (skipNextCall || isSuspended) {
+        skipNextCall = false;
+        return;
+      }
+      let scrollStrategy;
+      if (selection.isSelectedByCorner()) {
+        scrollStrategy = cornerHeaderScrollStrategy(hot);
+      } else if (selection.isSelectedByRowHeader()) {
+        scrollStrategy = rowHeaderScrollStrategy(hot);
+      } else if (selection.isSelectedByColumnHeader()) {
+        scrollStrategy = columnHeaderScrollStrategy(hot);
+      } else if (selection.getSelectedRange().size() === 1 && selection.isMultiple()) {
+        scrollStrategy = multipleScrollStrategy(hot);
+      } else if (selection.getSelectedRange().size() === 1 && !selection.isMultiple()) {
+        scrollStrategy = singleScrollStrategy(hot);
+      } else if (selection.getSelectedRange().size() > 1) {
+        scrollStrategy = noncontiguousScrollStrategy(hot);
+      }
+      (_scrollStrategy = scrollStrategy) === null || _scrollStrategy === void 0 || _scrollStrategy(cellCoords);
+    }
+  };
+}

package/core/viewportScroll/scrollStrategies/columnHeaderScroll.js

@@ -0,0 +1,20 @@
+"use strict";
+
+exports.__esModule = true;
+exports.columnHeaderScrollStrategy = columnHeaderScrollStrategy;
+/**
+ * Scroll strategy for column header selection.
+ *
+ * @param {Core} hot Handsontable instance.
+ * @returns {function(): function(CellCoords): void}
+ */
+function columnHeaderScrollStrategy(hot) {
+  return _ref => {
+    let {
+      col
+    } = _ref;
+    hot.scrollViewportTo({
+      col
+    });
+  };
+}

package/core/viewportScroll/scrollStrategies/columnHeaderScroll.mjs

@@ -0,0 +1,16 @@
+/**
+ * Scroll strategy for column header selection.
+ *
+ * @param {Core} hot Handsontable instance.
+ * @returns {function(): function(CellCoords): void}
+ */
+export function columnHeaderScrollStrategy(hot) {
+  return _ref => {
+    let {
+      col
+    } = _ref;
+    hot.scrollViewportTo({
+      col
+    });
+  };
+}

package/core/viewportScroll/scrollStrategies/cornerHeaderScroll.js

@@ -0,0 +1,14 @@
+"use strict";
+
+exports.__esModule = true;
+exports.cornerHeaderScrollStrategy = cornerHeaderScrollStrategy;
+/**
+ * Scroll strategy for corner header selection.
+ *
+ * @returns {function(): function(CellCoords): void}
+ */
+function cornerHeaderScrollStrategy() {
+  return () => {
+    // do not scroll the viewport when the corner is clicked
+  };
+}

package/core/viewportScroll/scrollStrategies/cornerHeaderScroll.mjs

@@ -0,0 +1,10 @@
+/**
+ * Scroll strategy for corner header selection.
+ *
+ * @returns {function(): function(CellCoords): void}
+ */
+export function cornerHeaderScrollStrategy() {
+  return () => {
+    // do not scroll the viewport when the corner is clicked
+  };
+}

package/core/viewportScroll/scrollStrategies/multipleScroll.js

@@ -0,0 +1,15 @@
+"use strict";
+
+exports.__esModule = true;
+exports.multipleScrollStrategy = multipleScrollStrategy;
+/**
+ * Scroll strategy for multiple selections.
+ *
+ * @param {Core} hot Handsontable instance.
+ * @returns {function(): function(CellCoords): void}
+ */
+function multipleScrollStrategy(hot) {
+  return cellCoords => {
+    hot.scrollViewportTo(cellCoords.toObject());
+  };
+}

package/core/viewportScroll/scrollStrategies/multipleScroll.mjs

@@ -0,0 +1,11 @@
+/**
+ * Scroll strategy for multiple selections.
+ *
+ * @param {Core} hot Handsontable instance.
+ * @returns {function(): function(CellCoords): void}
+ */
+export function multipleScrollStrategy(hot) {
+  return cellCoords => {
+    hot.scrollViewportTo(cellCoords.toObject());
+  };
+}

package/core/viewportScroll/scrollStrategies/noncontiguousScroll.js

@@ -0,0 +1,15 @@
+"use strict";
+
+exports.__esModule = true;
+exports.noncontiguousScrollStrategy = noncontiguousScrollStrategy;
+/**
+ * Scroll strategy for non-contiguous selections.
+ *
+ * @param {Core} hot Handsontable instance.
+ * @returns {function(): function(CellCoords): void}
+ */
+function noncontiguousScrollStrategy(hot) {
+  return cellCoords => {
+    hot.scrollViewportTo(cellCoords.toObject());
+  };
+}

package/core/viewportScroll/scrollStrategies/noncontiguousScroll.mjs

@@ -0,0 +1,11 @@
+/**
+ * Scroll strategy for non-contiguous selections.
+ *
+ * @param {Core} hot Handsontable instance.
+ * @returns {function(): function(CellCoords): void}
+ */
+export function noncontiguousScrollStrategy(hot) {
+  return cellCoords => {
+    hot.scrollViewportTo(cellCoords.toObject());
+  };
+}

package/core/viewportScroll/scrollStrategies/rowHeaderScroll.js

@@ -0,0 +1,20 @@
+"use strict";
+
+exports.__esModule = true;
+exports.rowHeaderScrollStrategy = rowHeaderScrollStrategy;
+/**
+ * Scroll strategy for row header selection.
+ *
+ * @param {Core} hot Handsontable instance.
+ * @returns {function(): function(CellCoords): void}
+ */
+function rowHeaderScrollStrategy(hot) {
+  return _ref => {
+    let {
+      row
+    } = _ref;
+    hot.scrollViewportTo({
+      row
+    });
+  };
+}

package/core/viewportScroll/scrollStrategies/rowHeaderScroll.mjs

@@ -0,0 +1,16 @@
+/**
+ * Scroll strategy for row header selection.
+ *
+ * @param {Core} hot Handsontable instance.
+ * @returns {function(): function(CellCoords): void}
+ */
+export function rowHeaderScrollStrategy(hot) {
+  return _ref => {
+    let {
+      row
+    } = _ref;
+    hot.scrollViewportTo({
+      row
+    });
+  };
+}

package/core/viewportScroll/scrollStrategies/singleScroll.js

@@ -0,0 +1,46 @@
+"use strict";
+
+exports.__esModule = true;
+exports.singleScrollStrategy = singleScrollStrategy;
+/**
+ * Scroll strategy for single cell selection.
+ *
+ * @param {Core} hot Handsontable instance.
+ * @returns {function(): function(CellCoords): { row: number, col: number } | void }
+ */
+function singleScrollStrategy(hot) {
+  return cellCoords => {
+    const selectionSource = hot.selection.getSelectionSource();
+    const {
+      row,
+      col
+    } = cellCoords;
+
+    // navigating through the column headers (when `navigableHeaders` is enabled)
+    // scrolls the viewport horizontally only
+    if (row < 0 && col >= 0) {
+      hot.scrollViewportTo({
+        col
+      });
+
+      // navigating through the row headers (when `navigableHeaders` is enabled)
+      // scrolls the viewport vertically only
+    } else if (col < 0 && row >= 0) {
+      hot.scrollViewportTo({
+        row
+      });
+
+      // navigating through the cells
+    } else {
+      if (selectionSource === 'mouse') {
+        if (col === hot.view.getLastPartiallyVisibleColumn() || row === hot.view.getLastPartiallyVisibleRow()) {
+          return;
+        }
+      }
+      hot.scrollViewportTo({
+        row,
+        col
+      });
+    }
+  };
+}

package/core/viewportScroll/scrollStrategies/singleScroll.mjs

@@ -0,0 +1,42 @@
+/**
+ * Scroll strategy for single cell selection.
+ *
+ * @param {Core} hot Handsontable instance.
+ * @returns {function(): function(CellCoords): { row: number, col: number } | void }
+ */
+export function singleScrollStrategy(hot) {
+  return cellCoords => {
+    const selectionSource = hot.selection.getSelectionSource();
+    const {
+      row,
+      col
+    } = cellCoords;
+
+    // navigating through the column headers (when `navigableHeaders` is enabled)
+    // scrolls the viewport horizontally only
+    if (row < 0 && col >= 0) {
+      hot.scrollViewportTo({
+        col
+      });
+
+      // navigating through the row headers (when `navigableHeaders` is enabled)
+      // scrolls the viewport vertically only
+    } else if (col < 0 && row >= 0) {
+      hot.scrollViewportTo({
+        row
+      });
+
+      // navigating through the cells
+    } else {
+      if (selectionSource === 'mouse') {
+        if (col === hot.view.getLastPartiallyVisibleColumn() || row === hot.view.getLastPartiallyVisibleRow()) {
+          return;
+        }
+      }
+      hot.scrollViewportTo({
+        row,
+        col
+      });
+    }
+  };
+}

package/core.js

@@ -110,7 +110,6 @@ function Core(rootElement, userSettings) {
   var _userSettings$layoutD,
     _this = this;
   let rootInstanceSymbol = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
-  let preventScrollingToCell = false;
   let instance = this;
   const eventManager = new _eventManager.default(instance);
   let datamap;
@@ -118,6 +117,7 @@ function Core(rootElement, userSettings) {
   let grid;
   let editorManager;
   let focusManager;
+  let viewportScroller;
   let firstRun = true;
   if ((0, _rootInstance.hasValidParameter)(rootInstanceSymbol)) {
     (0, _rootInstance.registerAsRootInstance)(this);
@@ -307,7 +307,7 @@ function Core(rootElement, userSettings) {
   };
   this.columnIndexMapper.addLocalHook('cacheUpdated', onIndexMapperCacheUpdate);
   this.rowIndexMapper.addLocalHook('cacheUpdated', onIndexMapperCacheUpdate);
-  this.selection.addLocalHook('afterSetRangeEnd', cellCoords => {
+  this.selection.addLocalHook('afterSetRangeEnd', (cellCoords, isLastSelectionLayer) => {
     const preventScrolling = (0, _object.createObjectPropListener)(false);
     const selectionRange = this.selection.getSelectedRange();
     const {
@@ -316,53 +316,12 @@ function Core(rootElement, userSettings) {
     } = selectionRange.current();
     const selectionLayerLevel = selectionRange.size() - 1;
     this.runHooks('afterSelection', from.row, from.col, to.row, to.col, preventScrolling, selectionLayerLevel);
-    this.runHooks('afterSelectionByProp', from.row, instance.colToProp(from.col), to.row, instance.colToProp(to.col), preventScrolling, selectionLayerLevel); // eslint-disable-line max-len
-
-    let scrollToCell = true;
-    if (preventScrollingToCell) {
-      scrollToCell = false;
-    }
-    if (preventScrolling.isTouched()) {
-      scrollToCell = !preventScrolling.value;
-    }
-    const currentSelectedRange = this.selection.selectedRange.current();
-    const isSelectedByAnyHeader = this.selection.isSelectedByAnyHeader();
-    const isSelectedByRowHeader = this.selection.isSelectedByRowHeader();
-    const isSelectedByColumnHeader = this.selection.isSelectedByColumnHeader();
-    if (scrollToCell !== false) {
-      if (!isSelectedByAnyHeader) {
-        if (currentSelectedRange && !this.selection.isMultiple()) {
-          const {
-            row,
-            col
-          } = currentSelectedRange.from;
-          if (row < 0 && col >= 0) {
-            this.scrollViewportTo({
-              col
-            });
-          } else if (col < 0 && row >= 0) {
-            this.scrollViewportTo({
-              row
-            });
-          } else {
-            this.scrollViewportTo({
-              row,
-              col
-            });
-          }
-        } else {
-          this.scrollViewportTo(cellCoords.toObject());
-        }
-      } else if (isSelectedByRowHeader) {
-        this.scrollViewportTo({
-          row: cellCoords.row
-        });
-      } else if (isSelectedByColumnHeader) {
-        this.scrollViewportTo({
-          col: cellCoords.col
-        });
-      }
+    this.runHooks('afterSelectionByProp', from.row, instance.colToProp(from.col), to.row, instance.colToProp(to.col), preventScrolling, selectionLayerLevel);
+    if (isLastSelectionLayer && (!preventScrolling.isTouched() || preventScrolling.isTouched() && !preventScrolling.value)) {
+      viewportScroller.scrollTo(cellCoords);
     }
+    const isSelectedByRowHeader = selection.isSelectedByRowHeader();
+    const isSelectedByColumnHeader = selection.isSelectedByColumnHeader();
 
     // @TODO: These CSS classes are no longer needed anymore. They are used only as a indicator of the selected
     // rows/columns in the MergedCells plugin (via border.js#L520 in the walkontable module). After fixing
@@ -1098,6 +1057,7 @@ function Core(rootElement, userSettings) {
     this.updateSettings(tableMeta, true);
     this.view = new _tableView.default(this);
     editorManager = _editorManager.default.getInstance(instance, tableMeta, selection);
+    viewportScroller = (0, _index3.createViewportScroller)(instance);
     focusManager = new _focusManager.FocusManager(instance);
     if ((0, _rootInstance.isRootInstance)(this)) {
       (0, _index3.installFocusCatcher)(instance);
@@ -3915,13 +3875,13 @@ function Core(rootElement, userSettings) {
     let scrollToCell = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
     let changeListener = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
     if (scrollToCell === false) {
-      preventScrollingToCell = true;
+      viewportScroller.suspend();
     }
     const wasSelected = selection.selectCells(coords);
     if (wasSelected && changeListener) {
       instance.listen();
     }
-    preventScrollingToCell = false;
+    viewportScroller.resume();
     return wasSelected;
   };
 
@@ -4053,9 +4013,8 @@ function Core(rootElement, userSettings) {
     let includeRowHeaders = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
     let includeColumnHeaders = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : includeRowHeaders;
     let options = arguments.length > 2 ? arguments[2] : undefined;
-    preventScrollingToCell = true;
+    viewportScroller.skipNextScrollCycle();
     selection.selectAll(includeRowHeaders, includeColumnHeaders, options);
-    preventScrollingToCell = false;
   };
   const getIndexToScroll = (indexMapper, visualIndex) => {
     // Looking for a visual index on the right and then (when not found) on the left.