handsontable 0.0.0-next-ba17d71-20240207 → 0.0.0-next-a2cc849-20240208

package/selection/selection.mjs

@@ -24,6 +24,9 @@ import { A11Y_SELECTED } from "../helpers/a11y.mjs";
  * @class Selection
  * @util
  */
+var _transformation = /*#__PURE__*/new WeakMap();
+var _focusTransformation = /*#__PURE__*/new WeakMap();
+var _isFocusSelectionChanged = /*#__PURE__*/new WeakMap();
 var _disableHeadersHighlight = /*#__PURE__*/new WeakMap();
 var _selectionSource = /*#__PURE__*/new WeakMap();
 var _expectedLayersCount = /*#__PURE__*/new WeakMap();
@@ -63,11 +66,23 @@ class Selection {
      */
     _defineProperty(this, "highlight", void 0);
     /**
-     * The module for modifying coordinates.
+     * The module for modifying coordinates of the start and end selection.
      *
      * @type {Transformation}
      */
-    _defineProperty(this, "transformation", void 0);
+    _classPrivateFieldInitSpec(this, _transformation, {
+      writable: true,
+      value: void 0
+    });
+    /**
+     * The module for modifying coordinates of the focus selection.
+     *
+     * @type {Transformation}
+     */
+    _classPrivateFieldInitSpec(this, _focusTransformation, {
+      writable: true,
+      value: void 0
+    });
     /**
      * The collection of the selection layer levels where the whole row was selected using the row header or
      * the corner header.
@@ -82,6 +97,15 @@ class Selection {
      * @type {Set<number>}
      */
     _defineProperty(this, "selectedByColumnHeader", new Set());
+    /**
+     * The flag which determines if the focus selection was changed.
+     *
+     * @type {boolean}
+     */
+    _classPrivateFieldInitSpec(this, _isFocusSelectionChanged, {
+      writable: true,
+      value: false
+    });
     /**
      * When sets disable highlighting the headers even when the logical coordinates points on them.
      *
@@ -132,71 +156,100 @@ class Selection {
       createCellCoords: (row, column) => this.tableProps.createCellCoords(row, column),
       createCellRange: (highlight, from, to) => this.tableProps.createCellRange(highlight, from, to)
     });
-    this.transformation = new Transformation(this.selectedRange, {
+    _classPrivateFieldSet(this, _transformation, new Transformation(this.selectedRange, {
       rowIndexMapper: this.tableProps.rowIndexMapper,
       columnIndexMapper: this.tableProps.columnIndexMapper,
       countRenderableRows: () => this.tableProps.countRenderableRows(),
       countRenderableColumns: () => this.tableProps.countRenderableColumns(),
-      countRowHeaders: () => this.tableProps.countRowHeaders(),
-      countColHeaders: () => this.tableProps.countColHeaders(),
       visualToRenderableCoords: coords => this.tableProps.visualToRenderableCoords(coords),
       renderableToVisualCoords: coords => this.tableProps.renderableToVisualCoords(coords),
       createCellCoords: (row, column) => this.tableProps.createCellCoords(row, column),
-      navigableHeaders: () => settings.navigableHeaders,
       fixedRowsBottom: () => settings.fixedRowsBottom,
       minSpareRows: () => settings.minSpareRows,
       minSpareCols: () => settings.minSpareCols,
       autoWrapRow: () => settings.autoWrapRow,
       autoWrapCol: () => settings.autoWrapCol
-    });
-    this.transformation.addLocalHook('beforeTransformStart', function () {
+    }));
+    _classPrivateFieldSet(this, _focusTransformation, new Transformation(this.selectedRange, {
+      rowIndexMapper: this.tableProps.rowIndexMapper,
+      columnIndexMapper: this.tableProps.columnIndexMapper,
+      countRenderableRows: () => {
+        const range = this.selectedRange.current();
+        return this.tableProps.countRenderableRowsInRange(0, range.getOuterBottomEndCorner().row);
+      },
+      countRenderableColumns: () => {
+        const range = this.selectedRange.current();
+        return this.tableProps.countRenderableColumnsInRange(0, range.getOuterBottomEndCorner().col);
+      },
+      visualToRenderableCoords: coords => this.tableProps.visualToRenderableCoords(coords),
+      renderableToVisualCoords: coords => this.tableProps.renderableToVisualCoords(coords),
+      createCellCoords: (row, column) => this.tableProps.createCellCoords(row, column),
+      fixedRowsBottom: () => 0,
+      minSpareRows: () => 0,
+      minSpareCols: () => 0,
+      autoWrapRow: () => true,
+      autoWrapCol: () => true
+    }));
+    _classPrivateFieldGet(this, _transformation).addLocalHook('beforeTransformStart', function () {
       for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
         args[_key] = arguments[_key];
       }
       return _this.runLocalHooks('beforeModifyTransformStart', ...args);
     });
-    this.transformation.addLocalHook('afterTransformStart', function () {
+    _classPrivateFieldGet(this, _transformation).addLocalHook('afterTransformStart', function () {
       for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
         args[_key2] = arguments[_key2];
       }
       return _this.runLocalHooks('afterModifyTransformStart', ...args);
     });
-    this.transformation.addLocalHook('beforeTransformEnd', function () {
+    _classPrivateFieldGet(this, _transformation).addLocalHook('beforeTransformEnd', function () {
       for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
         args[_key3] = arguments[_key3];
       }
       return _this.runLocalHooks('beforeModifyTransformEnd', ...args);
     });
-    this.transformation.addLocalHook('afterTransformEnd', function () {
+    _classPrivateFieldGet(this, _transformation).addLocalHook('afterTransformEnd', function () {
       for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
         args[_key4] = arguments[_key4];
       }
       return _this.runLocalHooks('afterModifyTransformEnd', ...args);
     });
-    this.transformation.addLocalHook('insertRowRequire', function () {
+    _classPrivateFieldGet(this, _transformation).addLocalHook('insertRowRequire', function () {
       for (var _len5 = arguments.length, args = new Array(_len5), _key5 = 0; _key5 < _len5; _key5++) {
         args[_key5] = arguments[_key5];
       }
       return _this.runLocalHooks('insertRowRequire', ...args);
     });
-    this.transformation.addLocalHook('insertColRequire', function () {
+    _classPrivateFieldGet(this, _transformation).addLocalHook('insertColRequire', function () {
       for (var _len6 = arguments.length, args = new Array(_len6), _key6 = 0; _key6 < _len6; _key6++) {
         args[_key6] = arguments[_key6];
       }
       return _this.runLocalHooks('insertColRequire', ...args);
     });
-    this.transformation.addLocalHook('beforeRowWrap', function () {
+    _classPrivateFieldGet(this, _transformation).addLocalHook('beforeRowWrap', function () {
       for (var _len7 = arguments.length, args = new Array(_len7), _key7 = 0; _key7 < _len7; _key7++) {
         args[_key7] = arguments[_key7];
       }
       return _this.runLocalHooks('beforeRowWrap', ...args);
     });
-    this.transformation.addLocalHook('beforeColumnWrap', function () {
+    _classPrivateFieldGet(this, _transformation).addLocalHook('beforeColumnWrap', function () {
       for (var _len8 = arguments.length, args = new Array(_len8), _key8 = 0; _key8 < _len8; _key8++) {
         args[_key8] = arguments[_key8];
       }
       return _this.runLocalHooks('beforeColumnWrap', ...args);
     });
+    _classPrivateFieldGet(this, _focusTransformation).addLocalHook('beforeTransformStart', function () {
+      for (var _len9 = arguments.length, args = new Array(_len9), _key9 = 0; _key9 < _len9; _key9++) {
+        args[_key9] = arguments[_key9];
+      }
+      return _this.runLocalHooks('beforeModifyTransformStart', ...args);
+    });
+    _classPrivateFieldGet(this, _focusTransformation).addLocalHook('afterTransformStart', function () {
+      for (var _len10 = arguments.length, args = new Array(_len10), _key10 = 0; _key10 < _len10; _key10++) {
+        args[_key10] = arguments[_key10];
+      }
+      return _this.runLocalHooks('afterModifyTransformStart', ...args);
+    });
   }
 
   /**
@@ -287,6 +340,7 @@ class Selection {
     // We are creating copy. We would like to modify just the start of the selection by below hook. Then original coords
     // should be handled by next methods.
     const coordsClone = coords.clone();
+    _classPrivateFieldSet(this, _isFocusSelectionChanged, false);
     this.runLocalHooks(`beforeSetRangeStart${fragment ? 'Only' : ''}`, coordsClone);
     if (!isMultipleMode || isMultipleMode && !isMultipleSelection && isUndefined(multipleSelection)) {
       this.selectedRange.clear();
@@ -354,11 +408,7 @@ class Selection {
       }
     }
     this.runLocalHooks('beforeHighlightSet');
-    const focusHighlight = this.highlight.getFocus();
-    focusHighlight.clear();
-    if (this.highlight.isEnabledFor(FOCUS_TYPE, cellRange.highlight)) {
-      focusHighlight.add(this.selectedRange.current().highlight).commit().syncWith(cellRange);
-    }
+    this.setRangeFocus(this.selectedRange.current().highlight);
     const layerLevel = this.getLayerLevel();
 
     // If the next layer level is lower than previous then clear all area and header highlights. This is the
@@ -446,15 +496,24 @@ class Selection {
   }
 
   /**
-   * Returns information if we have a multiselection. This method check multiselection only on the latest layer of
-   * the selection.
+   * Sets the selection focus position at the specified coordinates.
    *
-   * @returns {boolean}
+   * @param {CellCoords} coords The CellCoords instance with defined visual coordinates.
    */
-  isMultiple() {
-    const isMultipleListener = createObjectPropListener(!this.selectedRange.current().isSingle());
-    this.runLocalHooks('afterIsMultipleSelection', isMultipleListener);
-    return isMultipleListener.value;
+  setRangeFocus(coords) {
+    if (this.selectedRange.isEmpty()) {
+      return;
+    }
+    const cellRange = this.selectedRange.current();
+    const focusHighlight = this.highlight.getFocus();
+    focusHighlight.clear();
+    if (this.highlight.isEnabledFor(FOCUS_TYPE, cellRange.highlight)) {
+      focusHighlight.add(coords).commit().syncWith(cellRange);
+    }
+    if (!this.inProgress) {
+      _classPrivateFieldSet(this, _isFocusSelectionChanged, true);
+      this.runLocalHooks('afterSetFocus', coords);
+    }
   }
 
   /**
@@ -467,7 +526,13 @@ class Selection {
    */
   transformStart(rowDelta, colDelta) {
     let createMissingRecords = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
-    this.setRangeStart(this.transformation.transformStart(rowDelta, colDelta, createMissingRecords));
+    if (this.settings.navigableHeaders) {
+      _classPrivateFieldGet(this, _transformation).setOffsetSize({
+        x: this.tableProps.countRowHeaders(),
+        y: this.tableProps.countColHeaders()
+      });
+    }
+    this.setRangeStart(_classPrivateFieldGet(this, _transformation).transformStart(rowDelta, colDelta, createMissingRecords));
   }
 
   /**
@@ -477,7 +542,44 @@ class Selection {
    * @param {number} colDelta Columns number to move, value can be passed as negative number.
    */
   transformEnd(rowDelta, colDelta) {
-    this.setRangeEnd(this.transformation.transformEnd(rowDelta, colDelta));
+    if (this.settings.navigableHeaders) {
+      _classPrivateFieldGet(this, _transformation).setOffsetSize({
+        x: this.tableProps.countRowHeaders(),
+        y: this.tableProps.countColHeaders()
+      });
+    }
+    this.setRangeEnd(_classPrivateFieldGet(this, _transformation).transformEnd(rowDelta, colDelta));
+  }
+
+  /**
+   * Transforms the focus cell selection relative to the current focus position.
+   *
+   * @param {number} rowDelta Rows number to move, value can be passed as negative number.
+   * @param {number} colDelta Columns number to move, value can be passed as negative number.
+   */
+  transformFocus(rowDelta, colDelta) {
+    const range = this.selectedRange.current();
+    const {
+      row,
+      col
+    } = range.getOuterTopStartCorner();
+    const columnsInRange = this.tableProps.countRenderableColumnsInRange(0, col - 1);
+    const rowsInRange = this.tableProps.countRenderableRowsInRange(0, row - 1);
+    if (range.highlight.isHeader()) {
+      // for header focus selection calculate the new coords based on the selection including headers
+      _classPrivateFieldGet(this, _focusTransformation).setOffsetSize({
+        x: col < 0 ? Math.abs(col) : -columnsInRange,
+        y: row < 0 ? Math.abs(row) : -rowsInRange
+      });
+    } else {
+      // for focus selection in cells calculate the new coords only based on the selected cells
+      _classPrivateFieldGet(this, _focusTransformation).setOffsetSize({
+        x: col < 0 ? 0 : -columnsInRange,
+        y: row < 0 ? 0 : -rowsInRange
+      });
+    }
+    const focusCoords = _classPrivateFieldGet(this, _focusTransformation).transformStart(rowDelta, colDelta);
+    this.setRangeFocus(focusCoords.normalize());
   }
 
   /**
@@ -498,6 +600,30 @@ class Selection {
     return !this.selectedRange.isEmpty();
   }
 
+  /**
+   * Returns information if we have a multi-selection. This method check multi-selection only on the latest layer of
+   * the selection.
+   *
+   * @returns {boolean}
+   */
+  isMultiple() {
+    if (!this.isSelected()) {
+      return false;
+    }
+    const isMultipleListener = createObjectPropListener(!this.selectedRange.current().isSingle());
+    this.runLocalHooks('afterIsMultipleSelection', isMultipleListener);
+    return isMultipleListener.value;
+  }
+
+  /**
+   * Checks if the last selection involves changing the focus cell position only.
+   *
+   * @returns {boolean}
+   */
+  isFocusSelectionChanged() {
+    return this.isSelected() && _classPrivateFieldGet(this, _isFocusSelectionChanged);
+  }
+
   /**
    * Returns `true` if the selection was applied by clicking to the row header. If the `layerLevel`
    * argument is passed then only that layer will be checked. Otherwise, it checks if any row header

package/selection/transformation.js

@@ -8,9 +8,9 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
 function _classPrivateMethodInitSpec(obj, privateSet) { _checkPrivateRedeclaration(obj, privateSet); privateSet.add(obj); }
 function _classPrivateFieldInitSpec(obj, privateMap, value) { _checkPrivateRedeclaration(obj, privateMap); privateMap.set(obj, value); }
 function _checkPrivateRedeclaration(obj, privateCollection) { if (privateCollection.has(obj)) { throw new TypeError("Cannot initialize the same private elements twice on an object"); } }
+function _classPrivateMethodGet(receiver, privateSet, fn) { if (!privateSet.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return fn; }
 function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); }
 function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; }
-function _classPrivateMethodGet(receiver, privateSet, fn) { if (!privateSet.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return fn; }
 function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set"); _classApplyDescriptorSet(receiver, descriptor, value); return value; }
 function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); }
 function _classApplyDescriptorSet(receiver, descriptor, value) { if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } }
@@ -32,7 +32,6 @@ function _classApplyDescriptorSet(receiver, descriptor, value) { if (descriptor.
 var _range = /*#__PURE__*/new WeakMap();
 var _options = /*#__PURE__*/new WeakMap();
 var _offset = /*#__PURE__*/new WeakMap();
-var _setOffsetSize = /*#__PURE__*/new WeakSet();
 var _clampCoords = /*#__PURE__*/new WeakSet();
 var _getTableSize = /*#__PURE__*/new WeakSet();
 var _visualToZeroBasedCoords = /*#__PURE__*/new WeakSet();
@@ -67,13 +66,6 @@ class Transformation {
      * @returns {{rowDir: 1|0|-1, colDir: 1|0|-1}}
      */
     _classPrivateMethodInitSpec(this, _clampCoords);
-    /**
-     * Sets the additional offset in table size that may occur when the `navigableHeaders` option
-     * is enabled.
-     *
-     * @param {{x: number, y: number}} offset Offset as x and y properties.
-     */
-    _classPrivateMethodInitSpec(this, _setOffsetSize);
     /**
      * Instance of the SelectionRange, holder for visual coordinates applied to the table.
      *
@@ -121,10 +113,6 @@ class Transformation {
    */
   transformStart(rowDelta, colDelta) {
     let createMissingRecords = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
-    _classPrivateMethodGet(this, _setOffsetSize, _setOffsetSize2).call(this, {
-      x: _classPrivateFieldGet(this, _options).navigableHeaders() ? _classPrivateFieldGet(this, _options).countRowHeaders() : 0,
-      y: _classPrivateFieldGet(this, _options).navigableHeaders() ? _classPrivateFieldGet(this, _options).countColHeaders() : 0
-    });
     const delta = _classPrivateFieldGet(this, _options).createCellCoords(rowDelta, colDelta);
     let visualCoords = _classPrivateFieldGet(this, _range).current().highlight;
     const highlightRenderableCoords = _classPrivateFieldGet(this, _options).visualToRenderableCoords(visualCoords);
@@ -204,10 +192,6 @@ class Transformation {
    * @returns {CellCoords} Visual coordinates after transformation.
    */
   transformEnd(rowDelta, colDelta) {
-    _classPrivateMethodGet(this, _setOffsetSize, _setOffsetSize2).call(this, {
-      x: _classPrivateFieldGet(this, _options).navigableHeaders() ? _classPrivateFieldGet(this, _options).countRowHeaders() : 0,
-      y: _classPrivateFieldGet(this, _options).navigableHeaders() ? _classPrivateFieldGet(this, _options).countColHeaders() : 0
-    });
     const delta = _classPrivateFieldGet(this, _options).createCellCoords(rowDelta, colDelta);
     const cellRange = _classPrivateFieldGet(this, _range).current();
     const highlightRenderableCoords = _classPrivateFieldGet(this, _options).visualToRenderableCoords(cellRange.highlight);
@@ -240,16 +224,23 @@ class Transformation {
     this.runLocalHooks('afterTransformEnd', visualCoords, rowTransformDir, colTransformDir);
     return visualCoords;
   }
-}
-function _setOffsetSize2(_ref) {
-  let {
-    x,
-    y
-  } = _ref;
-  _classPrivateFieldSet(this, _offset, {
-    x,
-    y
-  });
+
+  /**
+   * Sets the additional offset in table size that may occur when the `navigableHeaders` option
+   * is enabled.
+   *
+   * @param {{x: number, y: number}} offset Offset as x and y properties.
+   */
+  setOffsetSize(_ref) {
+    let {
+      x,
+      y
+    } = _ref;
+    _classPrivateFieldSet(this, _offset, {
+      x,
+      y
+    });
+  }
 }
 function _clampCoords2(zeroBasedCoords) {
   const {

package/selection/transformation.mjs

@@ -2,9 +2,9 @@ import "core-js/modules/es.error.cause.js";
 function _classPrivateMethodInitSpec(obj, privateSet) { _checkPrivateRedeclaration(obj, privateSet); privateSet.add(obj); }
 function _classPrivateFieldInitSpec(obj, privateMap, value) { _checkPrivateRedeclaration(obj, privateMap); privateMap.set(obj, value); }
 function _checkPrivateRedeclaration(obj, privateCollection) { if (privateCollection.has(obj)) { throw new TypeError("Cannot initialize the same private elements twice on an object"); } }
+function _classPrivateMethodGet(receiver, privateSet, fn) { if (!privateSet.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return fn; }
 function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); }
 function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; }
-function _classPrivateMethodGet(receiver, privateSet, fn) { if (!privateSet.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return fn; }
 function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set"); _classApplyDescriptorSet(receiver, descriptor, value); return value; }
 function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); }
 function _classApplyDescriptorSet(receiver, descriptor, value) { if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } }
@@ -28,7 +28,6 @@ import localHooks from "./../mixins/localHooks.mjs";
 var _range = /*#__PURE__*/new WeakMap();
 var _options = /*#__PURE__*/new WeakMap();
 var _offset = /*#__PURE__*/new WeakMap();
-var _setOffsetSize = /*#__PURE__*/new WeakSet();
 var _clampCoords = /*#__PURE__*/new WeakSet();
 var _getTableSize = /*#__PURE__*/new WeakSet();
 var _visualToZeroBasedCoords = /*#__PURE__*/new WeakSet();
@@ -63,13 +62,6 @@ class Transformation {
      * @returns {{rowDir: 1|0|-1, colDir: 1|0|-1}}
      */
     _classPrivateMethodInitSpec(this, _clampCoords);
-    /**
-     * Sets the additional offset in table size that may occur when the `navigableHeaders` option
-     * is enabled.
-     *
-     * @param {{x: number, y: number}} offset Offset as x and y properties.
-     */
-    _classPrivateMethodInitSpec(this, _setOffsetSize);
     /**
      * Instance of the SelectionRange, holder for visual coordinates applied to the table.
      *
@@ -117,10 +109,6 @@ class Transformation {
    */
   transformStart(rowDelta, colDelta) {
     let createMissingRecords = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
-    _classPrivateMethodGet(this, _setOffsetSize, _setOffsetSize2).call(this, {
-      x: _classPrivateFieldGet(this, _options).navigableHeaders() ? _classPrivateFieldGet(this, _options).countRowHeaders() : 0,
-      y: _classPrivateFieldGet(this, _options).navigableHeaders() ? _classPrivateFieldGet(this, _options).countColHeaders() : 0
-    });
     const delta = _classPrivateFieldGet(this, _options).createCellCoords(rowDelta, colDelta);
     let visualCoords = _classPrivateFieldGet(this, _range).current().highlight;
     const highlightRenderableCoords = _classPrivateFieldGet(this, _options).visualToRenderableCoords(visualCoords);
@@ -200,10 +188,6 @@ class Transformation {
    * @returns {CellCoords} Visual coordinates after transformation.
    */
   transformEnd(rowDelta, colDelta) {
-    _classPrivateMethodGet(this, _setOffsetSize, _setOffsetSize2).call(this, {
-      x: _classPrivateFieldGet(this, _options).navigableHeaders() ? _classPrivateFieldGet(this, _options).countRowHeaders() : 0,
-      y: _classPrivateFieldGet(this, _options).navigableHeaders() ? _classPrivateFieldGet(this, _options).countColHeaders() : 0
-    });
     const delta = _classPrivateFieldGet(this, _options).createCellCoords(rowDelta, colDelta);
     const cellRange = _classPrivateFieldGet(this, _range).current();
     const highlightRenderableCoords = _classPrivateFieldGet(this, _options).visualToRenderableCoords(cellRange.highlight);
@@ -236,16 +220,23 @@ class Transformation {
     this.runLocalHooks('afterTransformEnd', visualCoords, rowTransformDir, colTransformDir);
     return visualCoords;
   }
-}
-function _setOffsetSize2(_ref) {
-  let {
-    x,
-    y
-  } = _ref;
-  _classPrivateFieldSet(this, _offset, {
-    x,
-    y
-  });
+
+  /**
+   * Sets the additional offset in table size that may occur when the `navigableHeaders` option
+   * is enabled.
+   *
+   * @param {{x: number, y: number}} offset Offset as x and y properties.
+   */
+  setOffsetSize(_ref) {
+    let {
+      x,
+      y
+    } = _ref;
+    _classPrivateFieldSet(this, _offset, {
+      x,
+      y
+    });
+  }
 }
 function _clampCoords2(zeroBasedCoords) {
   const {

package/shortcutContexts/commands/editor/closeAndSave.js

@@ -3,9 +3,9 @@
 exports.__esModule = true;
 const command = exports.command = {
   name: 'editorCloseAndSave',
-  callback(hot, event, keys) {
+  callback(hot, event) {
     const editorManager = hot._getEditorManager();
     editorManager.closeEditorAndSaveChanges(event.ctrlKey || event.metaKey);
-    editorManager.moveSelectionAfterEnter(keys.includes('shift'));
+    editorManager.moveSelectionAfterEnter(event);
   }
 };

package/shortcutContexts/commands/editor/closeAndSave.mjs

@@ -1,8 +1,8 @@
 export const command = {
   name: 'editorCloseAndSave',
-  callback(hot, event, keys) {
+  callback(hot, event) {
     const editorManager = hot._getEditorManager();
     editorManager.closeEditorAndSaveChanges(event.ctrlKey || event.metaKey);
-    editorManager.moveSelectionAfterEnter(keys.includes('shift'));
+    editorManager.moveSelectionAfterEnter(event);
   }
 };

package/shortcutContexts/commands/editor/open.js

@@ -6,20 +6,35 @@ const command = exports.command = {
   name: 'editorOpen',
   callback(hot, event, keys) {
     const editorManager = hot._getEditorManager();
+    const selectedRange = hot.getSelectedRangeLast();
     const {
       highlight
-    } = hot.getSelectedRangeLast();
+    } = selectedRange;
+
+    // supports for navigating with enter key when multiple cells are selected
+    if (hot.selection.isMultiple() && !selectedRange.isHeader() && hot.countRenderedCols() > 0 && hot.countRenderedRows() > 0) {
+      const settings = hot.getSettings();
+      const enterMoves = typeof settings.enterMoves === 'function' ? settings.enterMoves(event) : settings.enterMoves;
+      if (keys.includes('shift')) {
+        hot.selection.transformFocus(-enterMoves.row, -enterMoves.col);
+      } else {
+        hot.selection.transformFocus(enterMoves.row, enterMoves.col);
+      }
+      return;
+    }
     if (highlight.isHeader()) {
       return;
     }
+
+    // supports editor opening with enter key
     if (hot.getSettings().enterBeginsEditing) {
       if (editorManager.cellProperties.readOnly) {
-        editorManager.moveSelectionAfterEnter();
+        editorManager.moveSelectionAfterEnter(event);
       } else {
         editorManager.openEditor(null, event, true);
       }
     } else {
-      editorManager.moveSelectionAfterEnter(keys.includes('shift'));
+      editorManager.moveSelectionAfterEnter(event);
     }
     (0, _event.stopImmediatePropagation)(event); // required by HandsontableEditor
   }

package/shortcutContexts/commands/editor/open.mjs

@@ -3,20 +3,35 @@ export const command = {
   name: 'editorOpen',
   callback(hot, event, keys) {
     const editorManager = hot._getEditorManager();
+    const selectedRange = hot.getSelectedRangeLast();
     const {
       highlight
-    } = hot.getSelectedRangeLast();
+    } = selectedRange;
+
+    // supports for navigating with enter key when multiple cells are selected
+    if (hot.selection.isMultiple() && !selectedRange.isHeader() && hot.countRenderedCols() > 0 && hot.countRenderedRows() > 0) {
+      const settings = hot.getSettings();
+      const enterMoves = typeof settings.enterMoves === 'function' ? settings.enterMoves(event) : settings.enterMoves;
+      if (keys.includes('shift')) {
+        hot.selection.transformFocus(-enterMoves.row, -enterMoves.col);
+      } else {
+        hot.selection.transformFocus(enterMoves.row, enterMoves.col);
+      }
+      return;
+    }
     if (highlight.isHeader()) {
       return;
     }
+
+    // supports editor opening with enter key
     if (hot.getSettings().enterBeginsEditing) {
       if (editorManager.cellProperties.readOnly) {
-        editorManager.moveSelectionAfterEnter();
+        editorManager.moveSelectionAfterEnter(event);
       } else {
         editorManager.openEditor(null, event, true);
       }
     } else {
-      editorManager.moveSelectionAfterEnter(keys.includes('shift'));
+      editorManager.moveSelectionAfterEnter(event);
     }
     stopImmediatePropagation(event); // required by HandsontableEditor
   }

package/shortcutContexts/commands/moveCellSelection/inlineEnd.js

@@ -5,7 +5,12 @@ const command = exports.command = {
   name: 'moveCellSelectionInlineEnd',
   callback(hot, event) {
     const settings = hot.getSettings();
+    const selectedRange = hot.getSelectedRangeLast();
     const tabMoves = typeof settings.tabMoves === 'function' ? settings.tabMoves(event) : settings.tabMoves;
-    hot.selection.transformStart(-tabMoves.row, -tabMoves.col);
+    if (hot.selection.isMultiple() && !selectedRange.isHeader() && hot.countRenderedCols() > 0 && hot.countRenderedRows() > 0) {
+      hot.selection.transformFocus(-tabMoves.row, -tabMoves.col);
+    } else {
+      hot.selection.transformStart(-tabMoves.row, -tabMoves.col);
+    }
   }
 };

package/shortcutContexts/commands/moveCellSelection/inlineEnd.mjs

@@ -2,7 +2,12 @@ export const command = {
   name: 'moveCellSelectionInlineEnd',
   callback(hot, event) {
     const settings = hot.getSettings();
+    const selectedRange = hot.getSelectedRangeLast();
     const tabMoves = typeof settings.tabMoves === 'function' ? settings.tabMoves(event) : settings.tabMoves;
-    hot.selection.transformStart(-tabMoves.row, -tabMoves.col);
+    if (hot.selection.isMultiple() && !selectedRange.isHeader() && hot.countRenderedCols() > 0 && hot.countRenderedRows() > 0) {
+      hot.selection.transformFocus(-tabMoves.row, -tabMoves.col);
+    } else {
+      hot.selection.transformStart(-tabMoves.row, -tabMoves.col);
+    }
   }
 };

package/shortcutContexts/commands/moveCellSelection/inlineStart.js

@@ -5,7 +5,12 @@ const command = exports.command = {
   name: 'moveCellSelectionInlineStart',
   callback(hot, event) {
     const settings = hot.getSettings();
+    const selectedRange = hot.getSelectedRangeLast();
     const tabMoves = typeof settings.tabMoves === 'function' ? settings.tabMoves(event) : settings.tabMoves;
-    hot.selection.transformStart(tabMoves.row, tabMoves.col);
+    if (hot.selection.isMultiple() && !selectedRange.isHeader() && hot.countRenderedCols() > 0 && hot.countRenderedRows() > 0) {
+      hot.selection.transformFocus(tabMoves.row, tabMoves.col);
+    } else {
+      hot.selection.transformStart(tabMoves.row, tabMoves.col);
+    }
   }
 };

package/shortcutContexts/commands/moveCellSelection/inlineStart.mjs

@@ -2,7 +2,12 @@ export const command = {
   name: 'moveCellSelectionInlineStart',
   callback(hot, event) {
     const settings = hot.getSettings();
+    const selectedRange = hot.getSelectedRangeLast();
     const tabMoves = typeof settings.tabMoves === 'function' ? settings.tabMoves(event) : settings.tabMoves;
-    hot.selection.transformStart(tabMoves.row, tabMoves.col);
+    if (hot.selection.isMultiple() && !selectedRange.isHeader() && hot.countRenderedCols() > 0 && hot.countRenderedRows() > 0) {
+      hot.selection.transformFocus(tabMoves.row, tabMoves.col);
+    } else {
+      hot.selection.transformStart(tabMoves.row, tabMoves.col);
+    }
   }
 };