handsontable 13.1.0-next-e1a7d2c-20230831 → 14.0.0-next-d97b156-20231027

package/selection/selection.js

@@ -2,21 +2,36 @@
 
 exports.__esModule = true;
 require("core-js/modules/es.error.cause.js");
-var _highlight = _interopRequireDefault(require("./highlight/highlight"));
-var _constants = require("./highlight/constants");
+var _src = require("./../3rdparty/walkontable/src");
+var _highlight = _interopRequireWildcard(require("./highlight/highlight"));
 var _range = _interopRequireDefault(require("./range"));
 var _object = require("./../helpers/object");
 var _mixed = require("./../helpers/mixed");
+var _number = require("./../helpers/number");
 var _array = require("./../helpers/array");
 var _localHooks = _interopRequireDefault(require("./../mixins/localHooks"));
 var _transformation = _interopRequireDefault(require("./transformation"));
 var _utils = require("./utils");
 var _templateLiteralTag = require("./../helpers/templateLiteralTag");
+var _a11y = require("../helpers/a11y");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+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 _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); }
+function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set"); _classApplyDescriptorSet(receiver, descriptor, value); return value; }
+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; } }
+function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); }
+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 _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; }
 /**
  * @class Selection
  * @util
  */
+var _disableHeadersHighlight = /*#__PURE__*/new WeakMap();
 class Selection {
   constructor(settings, tableProps) {
     var _this = this;
@@ -25,57 +40,73 @@ class Selection {
      *
      * @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}
+     */
+    _defineProperty(this, "selectedRange", new _range.default((highlight, from, to) => {
+      return this.tableProps.createCellRange(highlight, from, to);
+    }));
+    /**
+     * Visualization layer.
+     *
+     * @type {Highlight}
+     */
+    _defineProperty(this, "highlight", void 0);
+    /**
+     * The module for modifying coordinates.
+     *
+     * @type {Transformation}
      */
-    this.selectedByCorner = false;
+    _defineProperty(this, "transformation", void 0);
     /**
      * The collection of the selection layer levels where the whole row was selected using the row header or
      * the corner header.
      *
-     * @type {Set.<number>}
+     * @type {Set<number>}
      */
-    this.selectedByRowHeader = new Set();
+    _defineProperty(this, "selectedByRowHeader", new Set());
     /**
      * The collection of the selection layer levels where the whole column was selected using the column header or
      * the corner header.
      *
-     * @type {Set.<number>}
+     * @type {Set<number>}
      */
-    this.selectedByColumnHeader = new Set();
+    _defineProperty(this, "selectedByColumnHeader", new Set());
     /**
-     * Selection data layer (handle visual coordinates).
+     * When sets disable highlighting the headers even when the logical coordinates points on them.
      *
-     * @type {SelectionRange}
+     * @type {boolean}
      */
-    this.selectedRange = new _range.default((highlight, from, to) => {
-      return this.tableProps.createCellRange(highlight, from, to);
+    _classPrivateFieldInitSpec(this, _disableHeadersHighlight, {
+      writable: true,
+      value: false
     });
-    /**
-     * Visualization layer.
-     *
-     * @type {Highlight}
-     */
+    this.settings = settings;
+    this.tableProps = tableProps;
     this.highlight = new _highlight.default({
       headerClassName: settings.currentHeaderClassName,
+      headerAttributes: [(0, _a11y.A11Y_SELECTED)()],
       activeHeaderClassName: settings.activeHeaderClassName,
       rowClassName: settings.currentRowClassName,
       columnClassName: settings.currentColClassName,
+      cellAttributes: [(0, _a11y.A11Y_SELECTED)()],
+      rowIndexMapper: this.tableProps.rowIndexMapper,
+      columnIndexMapper: this.tableProps.columnIndexMapper,
       disabledCellSelection: (row, column) => this.tableProps.isDisabledCellSelection(row, column),
       cellCornerVisible: function () {
         return _this.isCellCornerVisible(...arguments);
@@ -86,21 +117,19 @@ class Selection {
       visualToRenderableCoords: coords => this.tableProps.visualToRenderableCoords(coords),
       renderableToVisualCoords: coords => this.tableProps.renderableToVisualCoords(coords),
       createCellCoords: (row, column) => this.tableProps.createCellCoords(row, column),
-      createCellRange: (highlight, from, to) => this.tableProps.createCellRange(highlight, from, to),
-      rowIndexMapper: () => this.tableProps.rowIndexMapper(),
-      columnIndexMapper: () => this.tableProps.columnIndexMapper()
+      createCellRange: (highlight, from, to) => this.tableProps.createCellRange(highlight, from, to)
     });
-    /**
-     * The module for modifying coordinates.
-     *
-     * @type {Transformation}
-     */
     this.transformation = new _transformation.default(this.selectedRange, {
-      countRows: () => this.tableProps.countRowsTranslated(),
-      countCols: () => this.tableProps.countColsTranslated(),
+      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,
@@ -143,6 +172,18 @@ class Selection {
       }
       return _this.runLocalHooks('insertColRequire', ...args);
     });
+    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 () {
+      for (var _len8 = arguments.length, args = new Array(_len8), _key8 = 0; _key8 < _len8; _key8++) {
+        args[_key8] = arguments[_key8];
+      }
+      return _this.runLocalHooks('beforeColumnWrap', ...args);
+    });
   }
 
   /**
@@ -155,14 +196,14 @@ class Selection {
   }
 
   /**
-   * Indicate that selection process began. It sets internaly `.inProgress` property to `true`.
+   * Indicate that selection process began. It sets internally `.inProgress` property to `true`.
    */
   begin() {
     this.inProgress = true;
   }
 
   /**
-   * Indicate that selection process finished. It sets internaly `.inProgress` property to `false`.
+   * Indicate that selection process finished. It sets internally `.inProgress` property to `false`.
    */
   finish() {
     this.runLocalHooks('afterSelectionFinished', Array.from(this.selectedRange));
@@ -187,33 +228,25 @@ class Selection {
    *                                      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.
    */
   setRangeStart(coords, multipleSelection) {
     let fragment = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+    let highlightCoords = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : coords;
     const isMultipleMode = this.settings.selectionMode === 'multiple';
     const isMultipleSelection = (0, _mixed.isUndefined)(multipleSelection) ? this.tableProps.getShortcutManager().isCtrlPressed() : multipleSelection;
-    const isRowNegative = coords.row < 0;
-    const isColumnNegative = coords.col < 0;
-    const 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.
     const coordsClone = coords.clone();
-    this.selectedByCorner = selectedByCorner;
     this.runLocalHooks(`beforeSetRangeStart${fragment ? 'Only' : ''}`, coordsClone);
     if (!isMultipleMode || isMultipleMode && !isMultipleSelection && (0, _mixed.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);
     }
@@ -226,9 +259,11 @@ class Selection {
    * @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.
    */
   setRangeStartOnly(coords, multipleSelection) {
-    this.setRangeStart(coords, multipleSelection, true);
+    let highlightCoords = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : coords;
+    this.setRangeStart(coords, multipleSelection, true, highlightCoords);
   }
 
   /**
@@ -240,21 +275,40 @@ class Selection {
     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.
     const coordsClone = coords.clone();
+    const countRows = this.tableProps.countRows();
+    const countCols = this.tableProps.countCols();
+    const 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();
     const 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(_constants.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();
+      }
+    }
+    this.runLocalHooks('beforeHighlightSet');
+    const focusHighlight = this.highlight.getFocus();
+    focusHighlight.clear();
+    if (this.highlight.isEnabledFor(_highlight.FOCUS_TYPE, cellRange.highlight)) {
+      focusHighlight.add(this.selectedRange.current().highlight).commit().syncWith(cellRange);
     }
     const layerLevel = this.getLayerLevel();
 
@@ -262,69 +316,80 @@ class Selection {
     // indication that the new selection is performing.
     if (layerLevel < this.highlight.layerLevel) {
       (0, _array.arrayEach)(this.highlight.getAreas(), highlight => void highlight.clear());
-      (0, _array.arrayEach)(this.highlight.getHeaders(), highlight => void highlight.clear());
-      (0, _array.arrayEach)(this.highlight.getActiveHeaders(), highlight => void highlight.clear());
+      (0, _array.arrayEach)(this.highlight.getLayeredAreas(), highlight => void highlight.clear());
+      (0, _array.arrayEach)(this.highlight.getRowHeaders(), highlight => void highlight.clear());
+      (0, _array.arrayEach)(this.highlight.getColumnHeaders(), highlight => void highlight.clear());
+      (0, _array.arrayEach)(this.highlight.getActiveRowHeaders(), highlight => void highlight.clear());
+      (0, _array.arrayEach)(this.highlight.getActiveColumnHeaders(), highlight => void highlight.clear());
+      (0, _array.arrayEach)(this.highlight.getActiveCornerHeaders(), highlight => void highlight.clear());
+      (0, _array.arrayEach)(this.highlight.getRowHighlights(), highlight => void highlight.clear());
+      (0, _array.arrayEach)(this.highlight.getColumnHighlights(), highlight => void highlight.clear());
     }
     this.highlight.useLayerLevel(layerLevel);
-    const areaHighlight = this.highlight.createOrGetArea();
-    const headerHighlight = this.highlight.createOrGetHeader();
-    const activeHeaderHighlight = this.highlight.createOrGetActiveHeader();
+    const areaHighlight = this.highlight.createArea();
+    const layeredAreaHighlight = this.highlight.createLayeredArea();
+    const rowHeaderHighlight = this.highlight.createRowHeader();
+    const columnHeaderHighlight = this.highlight.createColumnHeader();
+    const activeRowHeaderHighlight = this.highlight.createActiveRowHeader();
+    const activeColumnHeaderHighlight = this.highlight.createActiveColumnHeader();
+    const activeCornerHeaderHighlight = this.highlight.createActiveCornerHeader();
+    const rowHighlight = this.highlight.createRowHighlight();
+    const columnHighlight = this.highlight.createColumnHighlight();
     areaHighlight.clear();
-    headerHighlight.clear();
-    activeHeaderHighlight.clear();
-    if (this.highlight.isEnabledFor(_constants.AREA_TYPE, cellRange.highlight) && (this.isMultiple() || layerLevel >= 1)) {
+    layeredAreaHighlight.clear();
+    rowHeaderHighlight.clear();
+    columnHeaderHighlight.clear();
+    activeRowHeaderHighlight.clear();
+    activeColumnHeaderHighlight.clear();
+    activeCornerHeaderHighlight.clear();
+    rowHighlight.clear();
+    columnHighlight.clear();
+    if (this.highlight.isEnabledFor(_highlight.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.
         const 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(_constants.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.
-      const areAnyRowsRendered = this.tableProps.countRowsTranslated() === 0;
-      const areAnyColumnsRendered = this.tableProps.countColsTranslated() === 0;
-      let 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 (this.highlight.isEnabledFor(_highlight.HEADER_TYPE, cellRange.highlight)) {
+      if (!cellRange.isSingleHeader()) {
+        const rowCoordsFrom = this.tableProps.createCellCoords(Math.max(cellRange.from.row, 0), -1);
+        const rowCoordsTo = this.tableProps.createCellCoords(cellRange.to.row, -1);
+        const columnCoordsFrom = this.tableProps.createCellCoords(-1, Math.max(cellRange.from.col, 0));
+        const 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()) {
-        const 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();
-        }
+      const highlightRowHeaders = !_classPrivateFieldGet(this, _disableHeadersHighlight) && this.isEntireRowSelected() && (countCols > 0 && countCols === cellRange.getWidth() || countCols === 0 && this.isSelectedByRowHeader());
+      const highlightColumnHeaders = !_classPrivateFieldGet(this, _disableHeadersHighlight) && this.isEntireColumnSelected() && (countRows > 0 && countRows === cellRange.getHeight() || countRows === 0 && this.isSelectedByColumnHeader());
+      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()) {
-        const 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);
@@ -347,12 +412,12 @@ class Selection {
    *
    * @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.
    */
   transformStart(rowDelta, colDelta) {
-    let force = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
-    this.setRangeStart(this.transformation.transformStart(rowDelta, colDelta, force));
+    let createMissingRecords = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+    this.setRangeStart(this.transformation.transformStart(rowDelta, colDelta, createMissingRecords));
   }
 
   /**
@@ -393,7 +458,7 @@ class Selection {
    */
   isSelectedByRowHeader() {
     let 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));
   }
 
   /**
@@ -405,7 +470,19 @@ class Selection {
    */
   isEntireRowSelected() {
     let layerLevel = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.getLayerLevel();
-    return layerLevel === -1 ? this.selectedByRowHeader.size > 0 : this.selectedByRowHeader.has(layerLevel);
+    const tester = range => {
+      const {
+        col
+      } = range.getOuterTopStartCorner();
+      const rowHeaders = this.tableProps.countRowHeaders();
+      const countCols = this.tableProps.countCols();
+      return (rowHeaders > 0 && col < 0 || rowHeaders === 0) && range.getWidth() === countCols;
+    };
+    if (layerLevel === -1) {
+      return Array.from(this.selectedRange).some(range => tester(range));
+    }
+    const range = this.selectedRange.peekByIndex(layerLevel);
+    return range ? tester(range) : false;
   }
 
   /**
@@ -418,7 +495,7 @@ class Selection {
    */
   isSelectedByColumnHeader() {
     let 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));
   }
 
   /**
@@ -430,7 +507,19 @@ class Selection {
    */
   isEntireColumnSelected() {
     let layerLevel = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.getLayerLevel();
-    return layerLevel === -1 ? this.selectedByColumnHeader.size > 0 : this.selectedByColumnHeader.has(layerLevel);
+    const tester = range => {
+      const {
+        row
+      } = range.getOuterTopStartCorner();
+      const colHeaders = this.tableProps.countColHeaders();
+      const countRows = this.tableProps.countRows();
+      return (colHeaders > 0 && row < 0 || colHeaders === 0) && range.getHeight() === countRows;
+    };
+    if (layerLevel === -1) {
+      return Array.from(this.selectedRange).some(range => tester(range));
+    }
+    const range = this.selectedRange.peekByIndex(layerLevel);
+    return range ? tester(range) : false;
   }
 
   /**
@@ -448,7 +537,7 @@ class Selection {
    * @returns {boolean}
    */
   isSelectedByCorner() {
-    return this.selectedByCorner;
+    return this.selectedByColumnHeader.has(this.getLayerLevel()) && this.selectedByRowHeader.has(this.getLayerLevel());
   }
 
   /**
@@ -507,31 +596,61 @@ class Selection {
   }
 
   /**
-   * 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 {object} [options] Additional object with options.
+   * @param {{row: number, col: number} | boolean} [options.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. If `false`, the focus
+   * position won't be changed.
+   * @param {boolean} [options.disableHeadersHighlight] If `true`, disables highlighting the headers even when
+   * the logical coordinates points on them.
    */
   selectAll() {
+    var _this$getSelectedRang;
     let includeRowHeaders = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
     let includeColumnHeaders = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {
+      focusPosition: false,
+      disableHeadersHighlight: false
+    };
     const nrOfRows = this.tableProps.countRows();
     const nrOfColumns = this.tableProps.countCols();
+    const countRowHeaders = this.tableProps.countRowHeaders();
+    const countColHeaders = this.tableProps.countColHeaders();
+    const rowFrom = includeColumnHeaders ? -countColHeaders : 0;
+    const columnFrom = includeRowHeaders ? -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;
     }
-    const startCoords = this.tableProps.createCellCoords(includeColumnHeaders ? -1 : 0, includeRowHeaders ? -1 : 0);
+    let highlight = (_this$getSelectedRang = this.getSelectedRange().current()) === null || _this$getSelectedRang === void 0 ? void 0 : _this$getSelectedRang.highlight;
+    const {
+      focusPosition,
+      disableHeadersHighlight
+    } = options;
+    _classPrivateFieldSet(this, _disableHeadersHighlight, disableHeadersHighlight);
+    if (focusPosition && Number.isInteger(focusPosition === null || focusPosition === void 0 ? void 0 : focusPosition.row) && Number.isInteger(focusPosition === null || focusPosition === void 0 ? void 0 : focusPosition.col)) {
+      highlight = this.tableProps.createCellCoords((0, _number.clamp)(focusPosition.row, rowFrom, nrOfRows - 1), (0, _number.clamp)(focusPosition.col, columnFrom, nrOfColumns - 1));
+    }
+    const startCoords = this.tableProps.createCellCoords(rowFrom, columnFrom);
     const 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();
+    _classPrivateFieldSet(this, _disableHeadersHighlight, false);
   }
 
   /**
@@ -556,21 +675,29 @@ class Selection {
       propToCol: prop => this.tableProps.propToCol(prop),
       keepDirection: true
     });
-    const nrOfRows = this.tableProps.countRows();
-    const nrOfColumns = this.tableProps.countCols();
+    const navigableHeaders = this.settings.navigableHeaders;
+    const 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.
     const isValid = !selectionRanges.some(selection => {
-      const [rowStart, columnStart, rowEnd, columnEnd] = selectionSchemaNormalizer(selection);
-      const _isValid = (0, _utils.isValidCoord)(rowStart, nrOfRows) && (0, _utils.isValidCoord)(columnStart, nrOfColumns) && (0, _utils.isValidCoord)(rowEnd, nrOfRows) && (0, _utils.isValidCoord)(columnEnd, nrOfColumns);
-      return !_isValid;
+      const cellRange = selectionSchemaNormalizer(selection);
+      const rangeValidity = cellRange.isValid(tableParams);
+      return !(rangeValidity && !cellRange.containsHeaders() || rangeValidity && cellRange.containsHeaders() && cellRange.isSingleHeader());
     });
     if (isValid) {
       this.clear();
       (0, _array.arrayEach)(selectionRanges, selection => {
-        const [rowStart, columnStart, rowEnd, columnEnd] = selectionSchemaNormalizer(selection);
-        this.setRangeStartOnly(this.tableProps.createCellCoords(rowStart, columnStart), false);
-        this.setRangeEnd(this.tableProps.createCellCoords(rowEnd, columnEnd));
+        const {
+          from,
+          to
+        } = selectionSchemaNormalizer(selection);
+        this.setRangeStartOnly(from.clone(), false);
+        this.setRangeEnd(to.clone());
         this.finish();
       });
     }
@@ -583,22 +710,43 @@ class Selection {
    *
    * @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.
    */
   selectColumns(startColumn) {
     let endColumn = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : startColumn;
-    let headerLevel = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : -1;
+    let focusPosition = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
     const start = typeof startColumn === 'string' ? this.tableProps.propToCol(startColumn) : startColumn;
     const end = typeof endColumn === 'string' ? this.tableProps.propToCol(endColumn) : endColumn;
-    const nrOfColumns = this.tableProps.countCols();
-    const nrOfRows = this.tableProps.countRows();
-    const isValid = (0, _utils.isValidCoord)(start, nrOfColumns) && (0, _utils.isValidCoord)(end, nrOfColumns);
+    const countRows = this.tableProps.countRows();
+    const countCols = this.tableProps.countCols();
+    const countColHeaders = this.tableProps.countColHeaders();
+    const columnHeaderLastIndex = countColHeaders === 0 ? 0 : -countColHeaders;
+    const fromCoords = new _src.CellCoords(columnHeaderLastIndex, start);
+    const toCoords = new _src.CellCoords(countRows - 1, end);
+    const isValid = new _src.CellRange(fromCoords, fromCoords, toCoords).isValid({
+      countRows,
+      countCols,
+      countRowHeaders: 0,
+      countColHeaders
+    });
     if (isValid) {
-      this.setRangeStartOnly(this.tableProps.createCellCoords(headerLevel, start));
-      this.setRangeEnd(this.tableProps.createCellCoords(nrOfRows - 1, end));
+      const fromRow = countColHeaders === 0 ? 0 : (0, _number.clamp)(focusPosition, columnHeaderLastIndex, -1);
+      const toRow = countRows - 1;
+      const from = this.tableProps.createCellCoords(fromRow, start);
+      const to = this.tableProps.createCellCoords(toRow, end);
+      const highlight = this.tableProps.createCellCoords((0, _number.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;
@@ -609,20 +757,41 @@ class Selection {
    *
    * @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.
    */
   selectRows(startRow) {
     let endRow = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : startRow;
-    let headerLevel = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : -1;
-    const nrOfRows = this.tableProps.countRows();
-    const nrOfColumns = this.tableProps.countCols();
-    const isValid = (0, _utils.isValidCoord)(startRow, nrOfRows) && (0, _utils.isValidCoord)(endRow, nrOfRows);
+    let focusPosition = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+    const countRows = this.tableProps.countRows();
+    const countCols = this.tableProps.countCols();
+    const countRowHeaders = this.tableProps.countRowHeaders();
+    const rowHeaderLastIndex = countRowHeaders === 0 ? 0 : -countRowHeaders;
+    const fromCoords = new _src.CellCoords(startRow, rowHeaderLastIndex);
+    const toCoords = new _src.CellCoords(endRow, countCols - 1);
+    const isValid = new _src.CellRange(fromCoords, fromCoords, toCoords).isValid({
+      countRows,
+      countCols,
+      countRowHeaders,
+      countColHeaders: 0
+    });
     if (isValid) {
-      this.setRangeStartOnly(this.tableProps.createCellCoords(startRow, headerLevel));
-      this.setRangeEnd(this.tableProps.createCellCoords(endRow, nrOfColumns - 1));
+      const fromColumn = countRowHeaders === 0 ? 0 : (0, _number.clamp)(focusPosition, rowHeaderLastIndex, -1);
+      const toColumn = countCols - 1;
+      const from = this.tableProps.createCellCoords(startRow, fromColumn);
+      const to = this.tableProps.createCellCoords(endRow, toColumn);
+      const highlight = this.tableProps.createCellCoords(startRow, (0, _number.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;
@@ -639,19 +808,31 @@ class Selection {
     if (!this.isSelected()) {
       return;
     }
-    const cellHighlight = this.highlight.getCell();
+    const focusHighlight = this.highlight.getFocus();
     const currentLayer = this.getLayerLevel();
-    cellHighlight.commit().syncWith(this.selectedRange.current());
+    focusHighlight.commit().syncWith(this.selectedRange.current());
 
     // Rewriting rendered ranges going through all layers.
     for (let layerLevel = 0; layerLevel < this.selectedRange.size(); layerLevel += 1) {
       this.highlight.useLayerLevel(layerLevel);
-      const areaHighlight = this.highlight.createOrGetArea();
-      const headerHighlight = this.highlight.createOrGetHeader();
-      const activeHeaderHighlight = this.highlight.createOrGetActiveHeader();
+      const areaHighlight = this.highlight.createArea();
+      const areaLayeredHighlight = this.highlight.createLayeredArea();
+      const rowHeaderHighlight = this.highlight.createRowHeader();
+      const columnHeaderHighlight = this.highlight.createColumnHeader();
+      const activeRowHeaderHighlight = this.highlight.createActiveRowHeader();
+      const activeColumnHeaderHighlight = this.highlight.createActiveColumnHeader();
+      const activeCornerHeaderHighlight = this.highlight.createActiveCornerHeader();
+      const rowHighlight = this.highlight.createRowHighlight();
+      const 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.
@@ -659,5 +840,4 @@ class Selection {
   }
 }
 (0, _object.mixin)(Selection, _localHooks.default);
-var _default = Selection;
-exports.default = _default;
+var _default = exports.default = Selection;