handsontable 14.1.0 → 14.2.0-next-4873a35-20240228

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

@@ -36,6 +36,16 @@ const stickyRowsTop = {
   getFirstVisibleRow() {
     return this.getFirstRenderedRow();
   },
+  /**
+   * Get the source index of the first row partially visible in the viewport. If no rows are partially visible, returns an error code: -1.
+   * Assumes that all rendered rows are fully visible.
+   *
+   * @returns {number}
+   * @this Table
+   */
+  getFirstPartiallyVisibleRow() {
+    return this.getFirstRenderedRow();
+  },
   /**
    * Get the source index of the last rendered row. If no rows are rendered, returns an error code: -1.
    *
@@ -55,6 +65,16 @@ const stickyRowsTop = {
   getLastVisibleRow() {
     return this.getLastRenderedRow();
   },
+  /**
+   * Get the source index of the last row partially visible in the viewport. If no rows are partially visible, returns an error code: -1.
+   * Assumes that all rendered rows are fully visible.
+   *
+   * @returns {number}
+   * @this Table
+   */
+  getLastPartiallyVisibleRow() {
+    return this.getLastRenderedRow();
+  },
   /**
    * Get the number of rendered rows.
    *

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

@@ -33,6 +33,16 @@ const stickyRowsTop = {
   getFirstVisibleRow() {
     return this.getFirstRenderedRow();
   },
+  /**
+   * Get the source index of the first row partially visible in the viewport. If no rows are partially visible, returns an error code: -1.
+   * Assumes that all rendered rows are fully visible.
+   *
+   * @returns {number}
+   * @this Table
+   */
+  getFirstPartiallyVisibleRow() {
+    return this.getFirstRenderedRow();
+  },
   /**
    * Get the source index of the last rendered row. If no rows are rendered, returns an error code: -1.
    *
@@ -52,6 +62,16 @@ const stickyRowsTop = {
   getLastVisibleRow() {
     return this.getLastRenderedRow();
   },
+  /**
+   * Get the source index of the last row partially visible in the viewport. If no rows are partially visible, returns an error code: -1.
+   * Assumes that all rendered rows are fully visible.
+   *
+   * @returns {number}
+   * @this Table
+   */
+  getLastPartiallyVisibleRow() {
+    return this.getLastRenderedRow();
+  },
   /**
    * Get the number of rendered rows.
    *

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/CHANGELOG.md

@@ -9,6 +9,44 @@ adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 <!-- UNVERSIONED -->
 
+## [14.2.0] - 2024-03-06
+
+### Added
+- Added new `beforeBeginEditing` hook [#10699](https://github.com/handsontable/handsontable/pull/10699)
+- Added an ability to prevent viewport scroll via `beforeViewportScrollVertically` and `beforeViewportScrollHorizontally` hooks. [#10724](https://github.com/handsontable/handsontable/pull/10724)
+- Undo will work for moving columns [#10746](https://github.com/handsontable/handsontable/pull/10746)
+- Added a `modifyFiltersMultiSelectValue` plugin hook and utilized it in the Filters' multi-selection component. [#10756](https://github.com/handsontable/handsontable/pull/10756)
+- Adds localization for Croatian language [#10762](https://github.com/handsontable/handsontable/pull/10762)
+
+### Changed
+- Improved behavior of the viewport scroll after a cell click. [#10709](https://github.com/handsontable/handsontable/pull/10709)
+- Added `pikaday` to `handsontable`'s `dependencies` to ensure the backward compatibility of `14.1.0`. [#10715](https://github.com/handsontable/handsontable/pull/10715)
+- Changed unnatural checkbox behaviour after double click [#10748](https://github.com/handsontable/handsontable/pull/10748)
+- Changed the way checkbox-typed cells react to pressing `SPACE` and `ENTER` keys. [#10802](https://github.com/handsontable/handsontable/pull/10802)
+- React: Improve react portal caching [#10758](https://github.com/handsontable/handsontable/pull/10758)
+
+### Removed
+- removed versioned examples and gh workflow for publishing [#10766](https://github.com/handsontable/handsontable/pull/10766)
+
+### Fixed
+- Fixed propToCol return type inference [#10631](https://github.com/handsontable/handsontable/issues/10631)
+- Fixed row/column size calculations for hidden indexes [#10705](https://github.com/handsontable/handsontable/pull/10705)
+- Execution of data getters in cells method won't throw an error anymore in specific situation [#10710](https://github.com/handsontable/handsontable/pull/10710)
+- Fixed problems related to not syncing sheet rename from HF to HOT [#10719](https://github.com/handsontable/handsontable/pull/10719)
+- Removing all columns/rows when HyperFormula is enabled won't cause an error  [#10720](https://github.com/handsontable/handsontable/pull/10720)
+- Fixed a problem with the text editor missing the vertical scrollbar on cells with larger amounts of content. [#10722](https://github.com/handsontable/handsontable/pull/10722)
+- Fixed the `afterSelectionEnd` and `afterSelectionEndByProp` hooks overcall when the non-contiguous selection was applied [#10725](https://github.com/handsontable/handsontable/pull/10725)
+- Cells pasted from clipboard's tables won't contain unnecessary line breaks [#10745](https://github.com/handsontable/handsontable/pull/10745)
+- Focus on the Handsontable instance within the iframe won't persist for clicking outside the iframe [#10752](https://github.com/handsontable/handsontable/pull/10752)
+- Hovering "handsontable" cell type header handles won't throw an error [#10761](https://github.com/handsontable/handsontable/pull/10761)
+- Fixed a problem with the dropdown editor throwing an error when the cell value was represented by a `td` outside of the initial editor viewport. [#10763](https://github.com/handsontable/handsontable/pull/10763)
+- Fixed input problems when using the browser's autocomplete + fixed an event listener leak. [#10795](https://github.com/handsontable/handsontable/pull/10795)
+- Fixed a problem where the mobile selection handles were displayed on the context menus/dropdown menus. [#10816](https://github.com/handsontable/handsontable/pull/10816)
+- Fixed a problem where the Autofill plugin's double-click feature treated cells filled with `0`s as empty. [#10817](https://github.com/handsontable/handsontable/pull/10817)
+- Vue: chore: update peerDependencies of vue3 wrapper [#10571](https://github.com/handsontable/handsontable/issues/10571)
+- React: Export HotTableClass from React wrapper [#10736](https://github.com/handsontable/handsontable/issues/10736)
+- React: Fixed missing renderer and editor prop in react wrapper [#10768](https://github.com/handsontable/handsontable/pull/10768)
+
 ## [14.1.0] - 2024-01-16
 
 ### Added

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 = "16/01/2024 10:27:11";
-Handsontable.version = "14.1.0";
+Handsontable.buildDate = "28/02/2024 15:23:03";
+Handsontable.version = "14.2.0-next-4873a35-20240228";
 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 = "16/01/2024 10:27:23";
-Handsontable.version = "14.1.0";
+Handsontable.buildDate = "28/02/2024 15:23:08";
+Handsontable.version = "14.2.0-next-4873a35-20240228";
 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.d.ts

@@ -118,7 +118,7 @@ export default class Core {
   loadData(data: CellValue[][] | RowObject[], source?: string): void;
   populateFromArray(row: number, column: number, input: CellValue[][], endRow?: number,
     endColumn?: number, source?: string, method?: 'shift_down' | 'shift_right' | 'overwrite'): void;
-  propToCol(prop: string | number): string | number;
+  propToCol<T extends number | string>(prop: string | number): T;
   redo(): void;
   refreshDimensions(): void;
   removeCellMeta(row: number, column: number, key: (keyof CellMeta) | string): void;