handsontable 0.0.0-next-2b3d6d8-20230623 → 0.0.0-next-74a68c1-20230627

package/selection/selection.mjs

@@ -1,11 +1,5 @@
 function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
 var _templateObject;
-function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
-function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
-function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
-function _iterableToArrayLimit(arr, i) { var _i = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"]; if (null != _i) { var _s, _e, _x, _r, _arr = [], _n = !0, _d = !1; try { if (_x = (_i = _i.call(arr)).next, 0 === i) { if (Object(_i) !== _i) return; _n = !1; } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0); } catch (err) { _d = !0, _e = err; } finally { try { if (!_n && null != _i.return && (_r = _i.return(), Object(_r) !== _r)) return; } finally { if (_d) throw _e; } } return _arr; } }
-function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
 function _taggedTemplateLiteral(strings, raw) { if (!raw) { raw = strings.slice(0); } return Object.freeze(Object.defineProperties(strings, { raw: { value: Object.freeze(raw) } })); }
 import "core-js/modules/es.array.iterator.js";
 import "core-js/modules/es.object.to-string.js";
@@ -26,23 +20,22 @@ import "core-js/modules/es.symbol.description.js";
 import "core-js/modules/es.array.slice.js";
 import "core-js/modules/es.object.freeze.js";
 import "core-js/modules/es.symbol.iterator.js";
-import "core-js/modules/es.regexp.to-string.js";
-import "core-js/modules/es.function.name.js";
-import "core-js/modules/es.regexp.exec.js";
 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
 function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
 function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
-import Highlight from "./highlight/highlight.mjs";
-import { AREA_TYPE, HEADER_TYPE, CELL_TYPE } from "./highlight/constants.mjs";
+import { CellCoords, CellRange } from "./../3rdparty/walkontable/src/index.mjs";
+import Highlight, { AREA_TYPE, HEADER_TYPE, FOCUS_TYPE } from "./highlight/highlight.mjs";
 import SelectionRange from "./range.mjs";
 import { createObjectPropListener, mixin } from "./../helpers/object.mjs";
 import { isUndefined } from "./../helpers/mixed.mjs";
+import { clamp } from "./../helpers/number.mjs";
 import { arrayEach } from "./../helpers/array.mjs";
 import localHooks from "./../mixins/localHooks.mjs";
 import Transformation from "./transformation.mjs";
-import { detectSelectionType, isValidCoord, normalizeSelectionFactory, SELECTION_TYPE_EMPTY, SELECTION_TYPE_UNRECOGNIZED } from "./utils.mjs";
+import { detectSelectionType, normalizeSelectionFactory, SELECTION_TYPE_EMPTY, SELECTION_TYPE_UNRECOGNIZED } from "./utils.mjs";
 import { toSingleLine } from "./../helpers/templateLiteralTag.mjs";
 /**
  * @class Selection
@@ -57,57 +50,62 @@ var Selection = /*#__PURE__*/function () {
      *
      * @type {GridSettings}
      */
-    this.settings = settings;
+    _defineProperty(this, "settings", void 0);
     /**
      * An additional object with dynamically defined properties which describes table state.
      *
      * @type {object}
      */
-    this.tableProps = tableProps;
+    _defineProperty(this, "tableProps", void 0);
     /**
      * The flag which determines if the selection is in progress.
      *
      * @type {boolean}
      */
-    this.inProgress = false;
+    _defineProperty(this, "inProgress", false);
     /**
-     * The flag indicates that selection was performed by clicking the corner overlay.
+     * Selection data layer (handle visual coordinates).
      *
-     * @type {boolean}
+     * @type {SelectionRange}
      */
-    this.selectedByCorner = false;
+    _defineProperty(this, "selectedRange", new SelectionRange(function (highlight, from, to) {
+      return _this.tableProps.createCellRange(highlight, from, to);
+    }));
     /**
-     * The collection of the selection layer levels where the whole row was selected using the row header or
-     * the corner header.
+     * Visualization layer.
      *
-     * @type {Set.<number>}
+     * @type {Highlight}
      */
-    this.selectedByRowHeader = new Set();
+    _defineProperty(this, "highlight", void 0);
     /**
-     * The collection of the selection layer levels where the whole column was selected using the column header or
-     * the corner header.
+     * The module for modifying coordinates.
      *
-     * @type {Set.<number>}
+     * @type {Transformation}
      */
-    this.selectedByColumnHeader = new Set();
+    _defineProperty(this, "transformation", void 0);
     /**
-     * Selection data layer (handle visual coordinates).
+     * The collection of the selection layer levels where the whole row was selected using the row header or
+     * the corner header.
      *
-     * @type {SelectionRange}
+     * @type {Set<number>}
      */
-    this.selectedRange = new SelectionRange(function (highlight, from, to) {
-      return _this.tableProps.createCellRange(highlight, from, to);
-    });
+    _defineProperty(this, "selectedByRowHeader", new Set());
     /**
-     * Visualization layer.
+     * The collection of the selection layer levels where the whole column was selected using the column header or
+     * the corner header.
      *
-     * @type {Highlight}
+     * @type {Set<number>}
      */
+    _defineProperty(this, "selectedByColumnHeader", new Set());
+    this.settings = settings;
+    this.tableProps = tableProps;
     this.highlight = new Highlight({
       headerClassName: settings.currentHeaderClassName,
       activeHeaderClassName: settings.activeHeaderClassName,
       rowClassName: settings.currentRowClassName,
       columnClassName: settings.currentColClassName,
+      rowIndexMapper: this.tableProps.rowIndexMapper,
+      columnIndexMapper: this.tableProps.columnIndexMapper,
       disabledCellSelection: function disabledCellSelection(row, column) {
         return _this.tableProps.isDisabledCellSelection(row, column);
       },
@@ -128,25 +126,22 @@ var Selection = /*#__PURE__*/function () {
       },
       createCellRange: function createCellRange(highlight, from, to) {
         return _this.tableProps.createCellRange(highlight, from, to);
-      },
-      rowIndexMapper: function rowIndexMapper() {
-        return _this.tableProps.rowIndexMapper();
-      },
-      columnIndexMapper: function columnIndexMapper() {
-        return _this.tableProps.columnIndexMapper();
       }
     });
-    /**
-     * The module for modifying coordinates.
-     *
-     * @type {Transformation}
-     */
     this.transformation = new Transformation(this.selectedRange, {
-      countRows: function countRows() {
-        return _this.tableProps.countRowsTranslated();
+      rowIndexMapper: this.tableProps.rowIndexMapper,
+      columnIndexMapper: this.tableProps.columnIndexMapper,
+      countRenderableRows: function countRenderableRows() {
+        return _this.tableProps.countRenderableRows();
+      },
+      countRenderableColumns: function countRenderableColumns() {
+        return _this.tableProps.countRenderableColumns();
+      },
+      countRowHeaders: function countRowHeaders() {
+        return _this.tableProps.countRowHeaders();
       },
-      countCols: function countCols() {
-        return _this.tableProps.countColsTranslated();
+      countColHeaders: function countColHeaders() {
+        return _this.tableProps.countColHeaders();
       },
       visualToRenderableCoords: function visualToRenderableCoords(coords) {
         return _this.tableProps.visualToRenderableCoords(coords);
@@ -157,6 +152,9 @@ var Selection = /*#__PURE__*/function () {
       createCellCoords: function createCellCoords(row, column) {
         return _this.tableProps.createCellCoords(row, column);
       },
+      navigableHeaders: function navigableHeaders() {
+        return settings.navigableHeaders;
+      },
       fixedRowsBottom: function fixedRowsBottom() {
         return settings.fixedRowsBottom;
       },
@@ -223,7 +221,7 @@ var Selection = /*#__PURE__*/function () {
     }
 
     /**
-     * Indicate that selection process began. It sets internaly `.inProgress` property to `true`.
+     * Indicate that selection process began. It sets internally `.inProgress` property to `true`.
      */
   }, {
     key: "begin",
@@ -232,7 +230,7 @@ var Selection = /*#__PURE__*/function () {
     }
 
     /**
-     * Indicate that selection process finished. It sets internaly `.inProgress` property to `false`.
+     * Indicate that selection process finished. It sets internally `.inProgress` property to `false`.
      */
   }, {
     key: "finish",
@@ -261,35 +259,27 @@ var Selection = /*#__PURE__*/function () {
      *                                      the default trigger will be used.
      * @param {boolean} [fragment=false] If `true`, the selection will be treated as a partial selection where the
      *                                   `setRangeEnd` method won't be called on every `setRangeStart` call.
+     * @param {CellCoords} [highlightCoords] If set, allows changing the coordinates of the highlight/focus cell.
      */
   }, {
     key: "setRangeStart",
     value: function setRangeStart(coords, multipleSelection) {
       var fragment = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+      var highlightCoords = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : coords;
       var isMultipleMode = this.settings.selectionMode === 'multiple';
       var isMultipleSelection = isUndefined(multipleSelection) ? this.tableProps.getShortcutManager().isCtrlPressed() : multipleSelection;
-      var isRowNegative = coords.row < 0;
-      var isColumnNegative = coords.col < 0;
-      var selectedByCorner = isRowNegative && isColumnNegative;
       // 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.
       var coordsClone = coords.clone();
-      this.selectedByCorner = selectedByCorner;
       this.runLocalHooks("beforeSetRangeStart".concat(fragment ? 'Only' : ''), coordsClone);
       if (!isMultipleMode || isMultipleMode && !isMultipleSelection && isUndefined(multipleSelection)) {
         this.selectedRange.clear();
       }
-      this.selectedRange.add(coordsClone);
+      this.selectedRange.add(coordsClone).current().setHighlight(highlightCoords.clone());
       if (this.getLayerLevel() === 0) {
         this.selectedByRowHeader.clear();
         this.selectedByColumnHeader.clear();
       }
-      if (!selectedByCorner && isColumnNegative) {
-        this.selectedByRowHeader.add(this.getLayerLevel());
-      }
-      if (!selectedByCorner && isRowNegative) {
-        this.selectedByColumnHeader.add(this.getLayerLevel());
-      }
       if (!fragment) {
         this.setRangeEnd(coords);
       }
@@ -302,11 +292,13 @@ var Selection = /*#__PURE__*/function () {
      * @param {boolean} [multipleSelection] If `true`, selection will be worked in 'multiple' mode. This option works
      *                                      only when 'selectionMode' is set as 'multiple'. If the argument is not defined
      *                                      the default trigger will be used.
+     * @param {CellCoords} [highlightCoords] If set, allows changing the coordinates of the highlight/focus cell.
      */
   }, {
     key: "setRangeStartOnly",
     value: function setRangeStartOnly(coords, multipleSelection) {
-      this.setRangeStart(coords, multipleSelection, true);
+      var highlightCoords = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : coords;
+      this.setRangeStart(coords, multipleSelection, true, highlightCoords);
     }
 
     /**
@@ -320,21 +312,39 @@ var Selection = /*#__PURE__*/function () {
       if (this.selectedRange.isEmpty()) {
         return;
       }
-
-      // We are creating copy. We would like to modify just the end of the selection by below hook. Then original coords
-      // should be handled by next methods.
       var coordsClone = coords.clone();
+      var countRows = this.tableProps.countRows();
+      var countCols = this.tableProps.countCols();
+      var isSingle = this.selectedRange.current().clone().setTo(coords).isSingleHeader();
+
+      // Ignore processing the end range when the header selection starts overlapping the corner and
+      // the selection is not a single header highlight.
+      if ((countRows > 0 || countCols > 0) && (countRows === 0 && coordsClone.col < 0 && !isSingle || countCols === 0 && coordsClone.row < 0 && !isSingle)) {
+        return;
+      }
       this.runLocalHooks('beforeSetRangeEnd', coordsClone);
       this.begin();
       var cellRange = this.selectedRange.current();
-      if (this.settings.selectionMode !== 'single') {
-        cellRange.setTo(this.tableProps.createCellCoords(coordsClone.row, coordsClone.col));
+      if (!this.settings.navigableHeaders) {
+        cellRange.highlight.normalize();
+      }
+      if (this.settings.selectionMode === 'single') {
+        cellRange.setFrom(cellRange.highlight);
+        cellRange.setTo(cellRange.highlight);
+      } else {
+        cellRange.setTo(coordsClone);
       }
 
-      // Set up current selection.
-      this.highlight.getCell().clear();
-      if (this.highlight.isEnabledFor(CELL_TYPE, cellRange.highlight)) {
-        this.highlight.getCell().add(this.selectedRange.current().highlight).commit().syncWith(cellRange);
+      // Prevent creating "area" selection that overlaps headers.
+      if (countRows > 0 && countCols > 0) {
+        if (!this.settings.navigableHeaders || this.settings.navigableHeaders && !cellRange.isSingleHeader()) {
+          cellRange.to.normalize();
+        }
+      }
+      var focusHighlight = this.highlight.getFocus();
+      focusHighlight.clear();
+      if (this.highlight.isEnabledFor(FOCUS_TYPE, cellRange.highlight)) {
+        focusHighlight.add(this.selectedRange.current().highlight).commit().syncWith(cellRange);
       }
       var layerLevel = this.getLayerLevel();
 
@@ -344,73 +354,96 @@ var Selection = /*#__PURE__*/function () {
         arrayEach(this.highlight.getAreas(), function (highlight) {
           return void highlight.clear();
         });
-        arrayEach(this.highlight.getHeaders(), function (highlight) {
+        arrayEach(this.highlight.getLayeredAreas(), function (highlight) {
+          return void highlight.clear();
+        });
+        arrayEach(this.highlight.getRowHeaders(), function (highlight) {
+          return void highlight.clear();
+        });
+        arrayEach(this.highlight.getColumnHeaders(), function (highlight) {
+          return void highlight.clear();
+        });
+        arrayEach(this.highlight.getActiveRowHeaders(), function (highlight) {
+          return void highlight.clear();
+        });
+        arrayEach(this.highlight.getActiveColumnHeaders(), function (highlight) {
+          return void highlight.clear();
+        });
+        arrayEach(this.highlight.getActiveCornerHeaders(), function (highlight) {
           return void highlight.clear();
         });
-        arrayEach(this.highlight.getActiveHeaders(), function (highlight) {
+        arrayEach(this.highlight.getRowHighlights(), function (highlight) {
+          return void highlight.clear();
+        });
+        arrayEach(this.highlight.getColumnHighlights(), function (highlight) {
           return void highlight.clear();
         });
       }
       this.highlight.useLayerLevel(layerLevel);
-      var areaHighlight = this.highlight.createOrGetArea();
-      var headerHighlight = this.highlight.createOrGetHeader();
-      var activeHeaderHighlight = this.highlight.createOrGetActiveHeader();
+      var areaHighlight = this.highlight.createArea();
+      var layeredAreaHighlight = this.highlight.createLayeredArea();
+      var rowHeaderHighlight = this.highlight.createRowHeader();
+      var columnHeaderHighlight = this.highlight.createColumnHeader();
+      var activeRowHeaderHighlight = this.highlight.createActiveRowHeader();
+      var activeColumnHeaderHighlight = this.highlight.createActiveColumnHeader();
+      var activeCornerHeaderHighlight = this.highlight.createActiveCornerHeader();
+      var rowHighlight = this.highlight.createRowHighlight();
+      var columnHighlight = this.highlight.createColumnHighlight();
       areaHighlight.clear();
-      headerHighlight.clear();
-      activeHeaderHighlight.clear();
+      layeredAreaHighlight.clear();
+      rowHeaderHighlight.clear();
+      columnHeaderHighlight.clear();
+      activeRowHeaderHighlight.clear();
+      activeColumnHeaderHighlight.clear();
+      activeCornerHeaderHighlight.clear();
+      rowHighlight.clear();
+      columnHighlight.clear();
       if (this.highlight.isEnabledFor(AREA_TYPE, cellRange.highlight) && (this.isMultiple() || layerLevel >= 1)) {
         areaHighlight.add(cellRange.from).add(cellRange.to).commit();
+        layeredAreaHighlight.add(cellRange.from).add(cellRange.to).commit();
         if (layerLevel === 1) {
           // For single cell selection in the same layer, we do not create area selection to prevent blue background.
           // When non-consecutive selection is performed we have to add that missing area selection to the previous layer
           // based on previous coordinates. It only occurs when the previous selection wasn't select multiple cells.
           var previousRange = this.selectedRange.previous();
-          this.highlight.useLayerLevel(layerLevel - 1).createOrGetArea().add(previousRange.from).commit()
+          this.highlight.useLayerLevel(layerLevel - 1);
+          this.highlight.createArea().add(previousRange.from).commit()
+          // Range may start with hidden indexes. Commit would not found start point (as we add just the `from` coords).
+          .syncWith(previousRange);
+          this.highlight.createLayeredArea().add(previousRange.from).commit()
           // Range may start with hidden indexes. Commit would not found start point (as we add just the `from` coords).
           .syncWith(previousRange);
           this.highlight.useLayerLevel(layerLevel);
         }
       }
       if (this.highlight.isEnabledFor(HEADER_TYPE, cellRange.highlight)) {
-        // The header selection generally contains cell selection. In a case when all rows (or columns)
-        // are hidden that visual coordinates are translated to renderable coordinates that do not exist.
-        // Hence no header highlight is generated. In that case, to make a column (or a row) header
-        // highlight, the row and column index has to point to the header (the negative value). See #7052.
-        var areAnyRowsRendered = this.tableProps.countRowsTranslated() === 0;
-        var areAnyColumnsRendered = this.tableProps.countColsTranslated() === 0;
-        var headerCellRange = cellRange;
-        if (areAnyRowsRendered || areAnyColumnsRendered) {
-          headerCellRange = cellRange.clone();
-        }
-        if (areAnyRowsRendered) {
-          headerCellRange.from.row = -1;
-        }
-        if (areAnyColumnsRendered) {
-          headerCellRange.from.col = -1;
-        }
-        if (this.settings.selectionMode === 'single') {
-          if (this.isSelectedByAnyHeader()) {
-            headerCellRange.from.normalize();
+        if (!cellRange.isSingleHeader()) {
+          var rowCoordsFrom = this.tableProps.createCellCoords(Math.max(cellRange.from.row, 0), -1);
+          var rowCoordsTo = this.tableProps.createCellCoords(cellRange.to.row, -1);
+          var columnCoordsFrom = this.tableProps.createCellCoords(-1, Math.max(cellRange.from.col, 0));
+          var columnCoordsTo = this.tableProps.createCellCoords(-1, cellRange.to.col);
+          if (this.settings.selectionMode === 'single') {
+            rowHeaderHighlight.add(rowCoordsFrom).commit();
+            columnHeaderHighlight.add(columnCoordsFrom).commit();
+            rowHighlight.add(rowCoordsFrom).commit();
+            columnHighlight.add(columnCoordsFrom).commit();
+          } else {
+            rowHeaderHighlight.add(rowCoordsFrom).add(rowCoordsTo).commit();
+            columnHeaderHighlight.add(columnCoordsFrom).add(columnCoordsTo).commit();
+            rowHighlight.add(rowCoordsFrom).add(rowCoordsTo).commit();
+            columnHighlight.add(columnCoordsFrom).add(columnCoordsTo).commit();
           }
-          headerHighlight.add(headerCellRange.from).commit();
-        } else {
-          headerHighlight.add(headerCellRange.from).add(headerCellRange.to).commit();
         }
-        if (this.isEntireRowSelected()) {
-          var isRowSelected = this.tableProps.countCols() === cellRange.getWidth();
-
-          // Make sure that the whole row is selected (in case where selectionMode is set to 'single')
-          if (isRowSelected) {
-            activeHeaderHighlight.add(this.tableProps.createCellCoords(cellRange.from.row, -1)).add(this.tableProps.createCellCoords(cellRange.to.row, -1)).commit();
-          }
+        var highlightRowHeaders = this.isEntireRowSelected() && (countCols > 0 && countCols === cellRange.getWidth() || countCols === 0 && (this.isSelectedByRowHeader() || this.isSelectedByCorner()));
+        var highlightColumnHeaders = this.isEntireColumnSelected() && (countRows > 0 && countRows === cellRange.getHeight() || countRows === 0 && (this.isSelectedByColumnHeader() || this.isSelectedByCorner()));
+        if (highlightRowHeaders) {
+          activeRowHeaderHighlight.add(this.tableProps.createCellCoords(Math.max(cellRange.from.row, 0), Math.min(-this.tableProps.countRowHeaders(), -1))).add(this.tableProps.createCellCoords(Math.max(cellRange.to.row, 0), -1)).commit();
         }
-        if (this.isEntireColumnSelected()) {
-          var isColumnSelected = this.tableProps.countRows() === cellRange.getHeight();
-
-          // Make sure that the whole column is selected (in case where selectionMode is set to 'single')
-          if (isColumnSelected) {
-            activeHeaderHighlight.add(this.tableProps.createCellCoords(-1, cellRange.from.col)).add(this.tableProps.createCellCoords(-1, cellRange.to.col)).commit();
-          }
+        if (highlightColumnHeaders) {
+          activeColumnHeaderHighlight.add(this.tableProps.createCellCoords(Math.min(-this.tableProps.countColHeaders(), -1), Math.max(cellRange.from.col, 0))).add(this.tableProps.createCellCoords(-1, Math.max(cellRange.to.col, 0))).commit();
+        }
+        if (highlightRowHeaders && highlightColumnHeaders) {
+          activeCornerHeaderHighlight.add(this.tableProps.createCellCoords(-this.tableProps.countColHeaders(), -this.tableProps.countRowHeaders())).add(this.tableProps.createCellCoords(-1, -1)).commit();
         }
       }
       this.runLocalHooks('afterSetRangeEnd', coords);
@@ -435,14 +468,14 @@ var Selection = /*#__PURE__*/function () {
      *
      * @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.
-     * @param {boolean} [force=false] If `true` the new rows/columns will be created if necessary. Otherwise, row/column will
-     *                        be created according to `minSpareRows/minSpareCols` settings of Handsontable.
+     * @param {boolean} [createMissingRecords=false] If `true` the new rows/columns will be created if necessary.
+     * Otherwise, row/column will be created according to `minSpareRows/minSpareCols` settings of Handsontable.
      */
   }, {
     key: "transformStart",
     value: function transformStart(rowDelta, colDelta) {
-      var force = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
-      this.setRangeStart(this.transformation.transformStart(rowDelta, colDelta, force));
+      var createMissingRecords = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+      this.setRangeStart(this.transformation.transformStart(rowDelta, colDelta, createMissingRecords));
     }
 
     /**
@@ -491,7 +524,7 @@ var Selection = /*#__PURE__*/function () {
     key: "isSelectedByRowHeader",
     value: function isSelectedByRowHeader() {
       var layerLevel = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.getLayerLevel();
-      return !this.isSelectedByCorner(layerLevel) && this.isEntireRowSelected(layerLevel);
+      return !this.isSelectedByCorner(layerLevel) && (layerLevel === -1 ? this.selectedByRowHeader.size > 0 : this.selectedByRowHeader.has(layerLevel));
     }
 
     /**
@@ -504,8 +537,22 @@ var Selection = /*#__PURE__*/function () {
   }, {
     key: "isEntireRowSelected",
     value: function isEntireRowSelected() {
+      var _this2 = this;
       var layerLevel = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.getLayerLevel();
-      return layerLevel === -1 ? this.selectedByRowHeader.size > 0 : this.selectedByRowHeader.has(layerLevel);
+      var tester = function tester(range) {
+        var _range$getOuterTopSta = range.getOuterTopStartCorner(),
+          col = _range$getOuterTopSta.col;
+        var rowHeaders = _this2.tableProps.countRowHeaders();
+        var countCols = _this2.tableProps.countCols();
+        return (rowHeaders > 0 && col < 0 || rowHeaders === 0) && range.getWidth() === countCols;
+      };
+      if (layerLevel === -1) {
+        return Array.from(this.selectedRange).some(function (range) {
+          return tester(range);
+        });
+      }
+      var range = this.selectedRange.peekByIndex(layerLevel);
+      return range ? tester(range) : false;
     }
 
     /**
@@ -520,7 +567,7 @@ var Selection = /*#__PURE__*/function () {
     key: "isSelectedByColumnHeader",
     value: function isSelectedByColumnHeader() {
       var layerLevel = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.getLayerLevel();
-      return !this.isSelectedByCorner() && this.isEntireColumnSelected(layerLevel);
+      return !this.isSelectedByCorner() && (layerLevel === -1 ? this.selectedByColumnHeader.size > 0 : this.selectedByColumnHeader.has(layerLevel));
     }
 
     /**
@@ -533,8 +580,22 @@ var Selection = /*#__PURE__*/function () {
   }, {
     key: "isEntireColumnSelected",
     value: function isEntireColumnSelected() {
+      var _this3 = this;
       var layerLevel = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.getLayerLevel();
-      return layerLevel === -1 ? this.selectedByColumnHeader.size > 0 : this.selectedByColumnHeader.has(layerLevel);
+      var tester = function tester(range) {
+        var _range$getOuterTopSta2 = range.getOuterTopStartCorner(),
+          row = _range$getOuterTopSta2.row;
+        var colHeaders = _this3.tableProps.countColHeaders();
+        var countRows = _this3.tableProps.countRows();
+        return (colHeaders > 0 && row < 0 || colHeaders === 0) && range.getHeight() === countRows;
+      };
+      if (layerLevel === -1) {
+        return Array.from(this.selectedRange).some(function (range) {
+          return tester(range);
+        });
+      }
+      var range = this.selectedRange.peekByIndex(layerLevel);
+      return range ? tester(range) : false;
     }
 
     /**
@@ -556,7 +617,7 @@ var Selection = /*#__PURE__*/function () {
   }, {
     key: "isSelectedByCorner",
     value: function isSelectedByCorner() {
-      return this.selectedByCorner;
+      return this.selectedByColumnHeader.has(this.getLayerLevel()) && this.selectedByRowHeader.has(this.getLayerLevel());
     }
 
     /**
@@ -625,31 +686,49 @@ var Selection = /*#__PURE__*/function () {
     }
 
     /**
-     * Select all cells.
+     * Selects all cells and headers.
      *
-     * @param {boolean} [includeRowHeaders=false] `true` If the selection should include the row headers, `false`
-     * otherwise.
-     * @param {boolean} [includeColumnHeaders=false] `true` If the selection should include the column headers, `false`
-     * otherwise.
+     * @param {boolean} [includeRowHeaders=false] `true` If the selection should include the row headers,
+     * `false` otherwise.
+     * @param {boolean} [includeColumnHeaders=false] `true` If the selection should include the column
+     * headers, `false` otherwise.
+     * @param {{row: number, col: number}} [focusPosition] The argument allows changing the cell/header
+     * focus position. The value takes an object with a `row` and `col` properties from -N to N, where
+     * negative values point to the headers and positive values point to the cell range.
      */
   }, {
     key: "selectAll",
     value: function selectAll() {
       var includeRowHeaders = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
       var includeColumnHeaders = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+      var focusPosition = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {
+        row: this.tableProps.countColHeaders() > 0 ? -this.tableProps.countColHeaders() : 0,
+        col: this.tableProps.countRowHeaders() > 0 ? -this.tableProps.countRowHeaders() : 0
+      };
       var nrOfRows = this.tableProps.countRows();
       var nrOfColumns = this.tableProps.countCols();
+      var countRowHeaders = this.tableProps.countRowHeaders();
+      var countColHeaders = this.tableProps.countColHeaders();
+      var rowFrom = includeRowHeaders ? -countColHeaders : 0;
+      var columnFrom = includeColumnHeaders ? -countRowHeaders : 0;
 
       // We can't select cells when there is no data.
-      if (!includeRowHeaders && !includeColumnHeaders && (nrOfRows === 0 || nrOfColumns === 0)) {
+      if (rowFrom === 0 && columnFrom === 0 && (nrOfRows === 0 || nrOfColumns === 0)) {
         return;
       }
-      var startCoords = this.tableProps.createCellCoords(includeColumnHeaders ? -1 : 0, includeRowHeaders ? -1 : 0);
+      var highlightRow = Number.isInteger(focusPosition.row) ? focusPosition.row : 0;
+      var highlightColumn = Number.isInteger(focusPosition.col) ? focusPosition.col : 0;
+      var startCoords = this.tableProps.createCellCoords(rowFrom, columnFrom);
+      var highlight = this.tableProps.createCellCoords(clamp(highlightRow, rowFrom, nrOfRows - 1), clamp(highlightColumn, columnFrom, nrOfColumns - 1));
       var endCoords = this.tableProps.createCellCoords(nrOfRows - 1, nrOfColumns - 1);
       this.clear();
-      this.setRangeStartOnly(startCoords);
-      this.selectedByRowHeader.add(this.getLayerLevel());
-      this.selectedByColumnHeader.add(this.getLayerLevel());
+      this.setRangeStartOnly(startCoords, void 0, highlight);
+      if (columnFrom < 0) {
+        this.selectedByRowHeader.add(this.getLayerLevel());
+      }
+      if (rowFrom < 0) {
+        this.selectedByColumnHeader.add(this.getLayerLevel());
+      }
       this.setRangeEnd(endCoords);
       this.finish();
     }
@@ -666,7 +745,7 @@ var Selection = /*#__PURE__*/function () {
   }, {
     key: "selectCells",
     value: function selectCells(selectionRanges) {
-      var _this2 = this;
+      var _this4 = this;
       var selectionType = detectSelectionType(selectionRanges);
       if (selectionType === SELECTION_TYPE_EMPTY) {
         return false;
@@ -675,36 +754,33 @@ var Selection = /*#__PURE__*/function () {
       }
       var selectionSchemaNormalizer = normalizeSelectionFactory(selectionType, {
         propToCol: function propToCol(prop) {
-          return _this2.tableProps.propToCol(prop);
+          return _this4.tableProps.propToCol(prop);
         },
         keepDirection: true
       });
-      var nrOfRows = this.tableProps.countRows();
-      var nrOfColumns = this.tableProps.countCols();
+      var navigableHeaders = this.settings.navigableHeaders;
+      var tableParams = {
+        countRows: this.tableProps.countRows(),
+        countCols: this.tableProps.countCols(),
+        countRowHeaders: navigableHeaders ? this.tableProps.countRowHeaders() : 0,
+        countColHeaders: navigableHeaders ? this.tableProps.countColHeaders() : 0
+      };
 
       // Check if every layer of the coordinates are valid.
       var isValid = !selectionRanges.some(function (selection) {
-        var _selectionSchemaNorma = selectionSchemaNormalizer(selection),
-          _selectionSchemaNorma2 = _slicedToArray(_selectionSchemaNorma, 4),
-          rowStart = _selectionSchemaNorma2[0],
-          columnStart = _selectionSchemaNorma2[1],
-          rowEnd = _selectionSchemaNorma2[2],
-          columnEnd = _selectionSchemaNorma2[3];
-        var _isValid = isValidCoord(rowStart, nrOfRows) && isValidCoord(columnStart, nrOfColumns) && isValidCoord(rowEnd, nrOfRows) && isValidCoord(columnEnd, nrOfColumns);
-        return !_isValid;
+        var cellRange = selectionSchemaNormalizer(selection);
+        var rangeValidity = cellRange.isValid(tableParams);
+        return !(rangeValidity && !cellRange.containsHeaders() || rangeValidity && cellRange.containsHeaders() && cellRange.isSingleHeader());
       });
       if (isValid) {
         this.clear();
         arrayEach(selectionRanges, function (selection) {
-          var _selectionSchemaNorma3 = selectionSchemaNormalizer(selection),
-            _selectionSchemaNorma4 = _slicedToArray(_selectionSchemaNorma3, 4),
-            rowStart = _selectionSchemaNorma4[0],
-            columnStart = _selectionSchemaNorma4[1],
-            rowEnd = _selectionSchemaNorma4[2],
-            columnEnd = _selectionSchemaNorma4[3];
-          _this2.setRangeStartOnly(_this2.tableProps.createCellCoords(rowStart, columnStart), false);
-          _this2.setRangeEnd(_this2.tableProps.createCellCoords(rowEnd, columnEnd));
-          _this2.finish();
+          var _selectionSchemaNorma = selectionSchemaNormalizer(selection),
+            from = _selectionSchemaNorma.from,
+            to = _selectionSchemaNorma.to;
+          _this4.setRangeStartOnly(from.clone(), false);
+          _this4.setRangeEnd(to.clone());
+          _this4.finish();
         });
       }
       return isValid;
@@ -716,24 +792,45 @@ var Selection = /*#__PURE__*/function () {
      *
      * @param {number|string} startColumn Visual column index or column property from which the selection starts.
      * @param {number|string} [endColumn] Visual column index or column property from to the selection finishes.
-     * @param {number} [headerLevel=-1] A row header index that triggers the column selection. The value can
-     *                                  take -1 to -N, where -1 means the header closest to the cells.
-     *
+     * @param {number} [focusPosition=0] The argument allows changing the cell/header focus position.
+     *                                   The value can take visual row index from -N to N, where negative values
+     *                                   point to the headers and positive values point to the cell range.
      * @returns {boolean} Returns `true` if selection was successful, `false` otherwise.
      */
   }, {
     key: "selectColumns",
     value: function selectColumns(startColumn) {
       var endColumn = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : startColumn;
-      var headerLevel = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : -1;
+      var focusPosition = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
       var start = typeof startColumn === 'string' ? this.tableProps.propToCol(startColumn) : startColumn;
       var end = typeof endColumn === 'string' ? this.tableProps.propToCol(endColumn) : endColumn;
-      var nrOfColumns = this.tableProps.countCols();
-      var nrOfRows = this.tableProps.countRows();
-      var isValid = isValidCoord(start, nrOfColumns) && isValidCoord(end, nrOfColumns);
+      var countRows = this.tableProps.countRows();
+      var countCols = this.tableProps.countCols();
+      var countColHeaders = this.tableProps.countColHeaders();
+      var columnHeaderLastIndex = countColHeaders === 0 ? 0 : -countColHeaders;
+      var fromCoords = new CellCoords(columnHeaderLastIndex, start);
+      var toCoords = new CellCoords(countRows - 1, end);
+      var isValid = new CellRange(fromCoords, fromCoords, toCoords).isValid({
+        countRows: countRows,
+        countCols: countCols,
+        countRowHeaders: 0,
+        countColHeaders: countColHeaders
+      });
       if (isValid) {
-        this.setRangeStartOnly(this.tableProps.createCellCoords(headerLevel, start));
-        this.setRangeEnd(this.tableProps.createCellCoords(nrOfRows - 1, end));
+        var fromRow = countColHeaders === 0 ? 0 : clamp(focusPosition, columnHeaderLastIndex, -1);
+        var toRow = countRows - 1;
+        var from = this.tableProps.createCellCoords(fromRow, start);
+        var to = this.tableProps.createCellCoords(toRow, end);
+        var highlight = this.tableProps.createCellCoords(clamp(focusPosition, columnHeaderLastIndex, countRows - 1), start);
+        this.runLocalHooks('beforeSelectColumns', from, to, highlight);
+
+        // disallow modifying row axis for that hooks
+        from.row = fromRow;
+        to.row = toRow;
+        this.setRangeStartOnly(from, void 0, highlight);
+        this.selectedByColumnHeader.add(this.getLayerLevel());
+        this.setRangeEnd(to);
+        this.runLocalHooks('afterSelectColumns', from, to, highlight);
         this.finish();
       }
       return isValid;
@@ -744,22 +841,43 @@ var Selection = /*#__PURE__*/function () {
      *
      * @param {number} startRow Visual row index from which the selection starts.
      * @param {number} [endRow] Visual row index from to the selection finishes.
-     * @param {number} [headerLevel=-1] A column header index that triggers the row selection.
-     *                                  The value can take -1 to -N, where -1 means the header
-     *                                  closest to the cells.
+     * @param {number} [focusPosition=0] The argument allows changing the cell/header focus position.
+     *                                   The value can take visual column index from -N to N, where negative values
+     *                                   point to the headers and positive values point to the cell range.
      * @returns {boolean} Returns `true` if selection was successful, `false` otherwise.
      */
   }, {
     key: "selectRows",
     value: function selectRows(startRow) {
       var endRow = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : startRow;
-      var headerLevel = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : -1;
-      var nrOfRows = this.tableProps.countRows();
-      var nrOfColumns = this.tableProps.countCols();
-      var isValid = isValidCoord(startRow, nrOfRows) && isValidCoord(endRow, nrOfRows);
+      var focusPosition = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+      var countRows = this.tableProps.countRows();
+      var countCols = this.tableProps.countCols();
+      var countRowHeaders = this.tableProps.countRowHeaders();
+      var rowHeaderLastIndex = countRowHeaders === 0 ? 0 : -countRowHeaders;
+      var fromCoords = new CellCoords(startRow, rowHeaderLastIndex);
+      var toCoords = new CellCoords(endRow, countCols - 1);
+      var isValid = new CellRange(fromCoords, fromCoords, toCoords).isValid({
+        countRows: countRows,
+        countCols: countCols,
+        countRowHeaders: countRowHeaders,
+        countColHeaders: 0
+      });
       if (isValid) {
-        this.setRangeStartOnly(this.tableProps.createCellCoords(startRow, headerLevel));
-        this.setRangeEnd(this.tableProps.createCellCoords(endRow, nrOfColumns - 1));
+        var fromColumn = countRowHeaders === 0 ? 0 : clamp(focusPosition, rowHeaderLastIndex, -1);
+        var toColumn = countCols - 1;
+        var from = this.tableProps.createCellCoords(startRow, fromColumn);
+        var to = this.tableProps.createCellCoords(endRow, toColumn);
+        var highlight = this.tableProps.createCellCoords(startRow, clamp(focusPosition, rowHeaderLastIndex, countCols - 1));
+        this.runLocalHooks('beforeSelectRows', from, to, highlight);
+
+        // disallow modifying column axis for that hooks
+        from.col = fromColumn;
+        to.col = toColumn;
+        this.setRangeStartOnly(from, void 0, highlight);
+        this.selectedByRowHeader.add(this.getLayerLevel());
+        this.setRangeEnd(to);
+        this.runLocalHooks('afterSelectRows', from, to, highlight);
         this.finish();
       }
       return isValid;
@@ -778,19 +896,31 @@ var Selection = /*#__PURE__*/function () {
       if (!this.isSelected()) {
         return;
       }
-      var cellHighlight = this.highlight.getCell();
+      var focusHighlight = this.highlight.getFocus();
       var currentLayer = this.getLayerLevel();
-      cellHighlight.commit().syncWith(this.selectedRange.current());
+      focusHighlight.commit().syncWith(this.selectedRange.current());
 
       // Rewriting rendered ranges going through all layers.
       for (var layerLevel = 0; layerLevel < this.selectedRange.size(); layerLevel += 1) {
         this.highlight.useLayerLevel(layerLevel);
-        var areaHighlight = this.highlight.createOrGetArea();
-        var headerHighlight = this.highlight.createOrGetHeader();
-        var activeHeaderHighlight = this.highlight.createOrGetActiveHeader();
+        var areaHighlight = this.highlight.createArea();
+        var areaLayeredHighlight = this.highlight.createLayeredArea();
+        var rowHeaderHighlight = this.highlight.createRowHeader();
+        var columnHeaderHighlight = this.highlight.createColumnHeader();
+        var activeRowHeaderHighlight = this.highlight.createActiveRowHeader();
+        var activeColumnHeaderHighlight = this.highlight.createActiveColumnHeader();
+        var activeCornerHeaderHighlight = this.highlight.createActiveCornerHeader();
+        var rowHighlight = this.highlight.createRowHighlight();
+        var columnHighlight = this.highlight.createColumnHighlight();
         areaHighlight.commit();
-        headerHighlight.commit();
-        activeHeaderHighlight.commit();
+        areaLayeredHighlight.commit();
+        rowHeaderHighlight.commit();
+        columnHeaderHighlight.commit();
+        activeRowHeaderHighlight.commit();
+        activeColumnHeaderHighlight.commit();
+        activeCornerHeaderHighlight.commit();
+        rowHighlight.commit();
+        columnHighlight.commit();
       }
 
       // Reverting starting layer for the Highlight.