handsontable 0.0.0-next-200799f-20240311 → 0.0.0-next-bff5041-20240315

package/selection/selection.mjs

@@ -4,11 +4,9 @@ function _checkPrivateRedeclaration(obj, privateCollection) { if (privateCollect
 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(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : String(i); }
 function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
-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 _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; } }
+function _classPrivateFieldGet(s, a) { return s.get(_assertClassBrand(s, a)); }
+function _classPrivateFieldSet(s, a, r) { return s.set(_assertClassBrand(s, a), r), r; }
+function _assertClassBrand(e, t, n) { if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n; throw new TypeError("Private element is not present on this object"); }
 import Highlight, { AREA_TYPE, HEADER_TYPE, FOCUS_TYPE } from "./highlight/highlight.mjs";
 import SelectionRange from "./range.mjs";
 import { createObjectPropListener, mixin } from "./../helpers/object.mjs";
@@ -24,9 +22,6 @@ 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();
@@ -66,23 +61,11 @@ class Selection {
      */
     _defineProperty(this, "highlight", void 0);
     /**
-     * The module for modifying coordinates of the start and end selection.
+     * The module for modifying coordinates.
      *
      * @type {Transformation}
      */
-    _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
-    });
+    _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.
@@ -97,43 +80,25 @@ 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.
      *
      * @type {boolean}
      */
-    _classPrivateFieldInitSpec(this, _disableHeadersHighlight, {
-      writable: true,
-      value: false
-    });
+    _classPrivateFieldInitSpec(this, _disableHeadersHighlight, false);
     /**
      * The source of the selection. It can be one of the following values: `mouse`, `unknown` or any other string.
      *
      * @type {'mouse' | 'unknown' | string}
      */
-    _classPrivateFieldInitSpec(this, _selectionSource, {
-      writable: true,
-      value: 'unknown'
-    });
+    _classPrivateFieldInitSpec(this, _selectionSource, 'unknown');
     /**
      * The number of expected layers. It is used mostly to track when the last selection layer of non-contiguous
      * selection is applied, thus the viewport scroll is triggered.
      *
      * @param {number}
      */
-    _classPrivateFieldInitSpec(this, _expectedLayersCount, {
-      writable: true,
-      value: -1
-    });
+    _classPrivateFieldInitSpec(this, _expectedLayersCount, -1);
     this.settings = settings;
     this.tableProps = tableProps;
     this.highlight = new Highlight({
@@ -156,118 +121,71 @@ class Selection {
       createCellCoords: (row, column) => this.tableProps.createCellCoords(row, column),
       createCellRange: (highlight, from, to) => this.tableProps.createCellRange(highlight, from, to)
     });
-    _classPrivateFieldSet(this, _transformation, new Transformation(this.selectedRange, {
+    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),
-      findFirstNonHiddenRenderableRow: function () {
-        return _this.tableProps.findFirstNonHiddenRenderableRow(...arguments);
-      },
-      findFirstNonHiddenRenderableColumn: function () {
-        return _this.tableProps.findFirstNonHiddenRenderableColumn(...arguments);
-      },
       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
-    }));
-    _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),
-      findFirstNonHiddenRenderableRow: function () {
-        return _this.tableProps.findFirstNonHiddenRenderableRow(...arguments);
-      },
-      findFirstNonHiddenRenderableColumn: function () {
-        return _this.tableProps.findFirstNonHiddenRenderableColumn(...arguments);
-      },
-      createCellCoords: (row, column) => this.tableProps.createCellCoords(row, column),
-      fixedRowsBottom: () => 0,
-      minSpareRows: () => 0,
-      minSpareCols: () => 0,
-      autoWrapRow: () => true,
-      autoWrapCol: () => true
-    }));
-    _classPrivateFieldGet(this, _transformation).addLocalHook('beforeTransformStart', function () {
+    });
+    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);
     });
-    _classPrivateFieldGet(this, _transformation).addLocalHook('afterTransformStart', function () {
+    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);
     });
-    _classPrivateFieldGet(this, _transformation).addLocalHook('beforeTransformEnd', function () {
+    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);
     });
-    _classPrivateFieldGet(this, _transformation).addLocalHook('modifyTransformEndRestDelta', function () {
+    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('modifyTransformEndRestDelta', ...args);
+      return _this.runLocalHooks('afterModifyTransformEnd', ...args);
     });
-    _classPrivateFieldGet(this, _transformation).addLocalHook('afterTransformEnd', function () {
+    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('afterModifyTransformEnd', ...args);
+      return _this.runLocalHooks('insertRowRequire', ...args);
     });
-    _classPrivateFieldGet(this, _transformation).addLocalHook('insertRowRequire', function () {
+    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('insertRowRequire', ...args);
+      return _this.runLocalHooks('insertColRequire', ...args);
     });
-    _classPrivateFieldGet(this, _transformation).addLocalHook('insertColRequire', function () {
+    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('insertColRequire', ...args);
+      return _this.runLocalHooks('beforeRowWrap', ...args);
     });
-    _classPrivateFieldGet(this, _transformation).addLocalHook('beforeRowWrap', function () {
+    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('beforeRowWrap', ...args);
-    });
-    _classPrivateFieldGet(this, _transformation).addLocalHook('beforeColumnWrap', function () {
-      for (var _len9 = arguments.length, args = new Array(_len9), _key9 = 0; _key9 < _len9; _key9++) {
-        args[_key9] = arguments[_key9];
-      }
       return _this.runLocalHooks('beforeColumnWrap', ...args);
     });
-    _classPrivateFieldGet(this, _focusTransformation).addLocalHook('beforeTransformStart', function () {
-      for (var _len10 = arguments.length, args = new Array(_len10), _key10 = 0; _key10 < _len10; _key10++) {
-        args[_key10] = arguments[_key10];
-      }
-      return _this.runLocalHooks('beforeModifyTransformFocus', ...args);
-    });
-    _classPrivateFieldGet(this, _focusTransformation).addLocalHook('afterTransformStart', function () {
-      for (var _len11 = arguments.length, args = new Array(_len11), _key11 = 0; _key11 < _len11; _key11++) {
-        args[_key11] = arguments[_key11];
-      }
-      return _this.runLocalHooks('afterModifyTransformFocus', ...args);
-    });
   }
 
   /**
@@ -285,14 +203,14 @@ class Selection {
    * @param {'mouse' | 'unknown' | string} sourceName The source name.
    */
   markSource(sourceName) {
-    _classPrivateFieldSet(this, _selectionSource, sourceName);
+    _classPrivateFieldSet(_selectionSource, this, sourceName);
   }
 
   /**
    * Marks end of the selection source. It restores the selection source to default value which is 'unknown'.
    */
   markEndSource() {
-    _classPrivateFieldSet(this, _selectionSource, 'unknown');
+    _classPrivateFieldSet(_selectionSource, this, 'unknown');
   }
 
   /**
@@ -301,7 +219,7 @@ class Selection {
    * @returns {'mouse' | 'unknown' | string}
    */
   getSelectionSource() {
-    return _classPrivateFieldGet(this, _selectionSource);
+    return _classPrivateFieldGet(_selectionSource, this);
   }
 
   /**
@@ -311,7 +229,7 @@ class Selection {
    * @param {number} layersCount The number of expected layers.
    */
   setExpectedLayers(layersCount) {
-    _classPrivateFieldSet(this, _expectedLayersCount, layersCount);
+    _classPrivateFieldSet(_expectedLayersCount, this, layersCount);
   }
 
   /**
@@ -327,7 +245,7 @@ class Selection {
   finish() {
     this.runLocalHooks('afterSelectionFinished', Array.from(this.selectedRange));
     this.inProgress = false;
-    _classPrivateFieldSet(this, _expectedLayersCount, -1);
+    _classPrivateFieldSet(_expectedLayersCount, this, -1);
   }
 
   /**
@@ -358,7 +276,6 @@ 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();
@@ -416,20 +333,7 @@ class Selection {
       cellRange.setFrom(cellRange.highlight);
       cellRange.setTo(cellRange.highlight);
     } else {
-      const horizontalDir = cellRange.getHorizontalDirection();
-      const verticalDir = cellRange.getVerticalDirection();
-      const isMultiple = this.isMultiple();
       cellRange.setTo(coordsClone);
-      if (isMultiple && horizontalDir !== cellRange.getHorizontalDirection()) {
-        cellRange.from.assign({
-          col: cellRange.highlight.col
-        });
-      }
-      if (isMultiple && verticalDir !== cellRange.getVerticalDirection()) {
-        cellRange.from.assign({
-          row: cellRange.highlight.row
-        });
-      }
     }
 
     // Prevent creating "area" selection that overlaps headers.
@@ -439,7 +343,11 @@ class Selection {
       }
     }
     this.runLocalHooks('beforeHighlightSet');
-    this.setRangeFocus(this.selectedRange.current().highlight);
+    const focusHighlight = this.highlight.getFocus();
+    focusHighlight.clear();
+    if (this.highlight.isEnabledFor(FOCUS_TYPE, cellRange.highlight)) {
+      focusHighlight.add(this.selectedRange.current().highlight).commit().syncWith(cellRange);
+    }
     const layerLevel = this.getLayerLevel();
 
     // If the next layer level is lower than previous then clear all area and header highlights. This is the
@@ -510,8 +418,8 @@ class Selection {
           columnHighlight.add(columnCoordsFrom).add(columnCoordsTo).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());
+      const highlightRowHeaders = !_classPrivateFieldGet(_disableHeadersHighlight, this) && this.isEntireRowSelected() && (countCols > 0 && countCols === cellRange.getWidth() || countCols === 0 && this.isSelectedByRowHeader());
+      const highlightColumnHeaders = !_classPrivateFieldGet(_disableHeadersHighlight, this) && 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();
       }
@@ -522,33 +430,20 @@ class Selection {
         activeCornerHeaderHighlight.add(this.tableProps.createCellCoords(-this.tableProps.countColHeaders(), -this.tableProps.countRowHeaders())).add(this.tableProps.createCellCoords(-1, -1)).commit();
       }
     }
-    const isLastLayer = _classPrivateFieldGet(this, _expectedLayersCount) === -1 || this.selectedRange.size() === _classPrivateFieldGet(this, _expectedLayersCount);
+    const isLastLayer = _classPrivateFieldGet(_expectedLayersCount, this) === -1 || this.selectedRange.size() === _classPrivateFieldGet(_expectedLayersCount, this);
     this.runLocalHooks('afterSetRangeEnd', coords, isLastLayer);
   }
 
   /**
-   * Sets the selection focus position at the specified coordinates.
+   * Returns information if we have a multiselection. This method check multiselection only on the latest layer of
+   * the selection.
    *
-   * @param {CellCoords} coords The CellCoords instance with defined visual coordinates.
+   * @returns {boolean}
    */
-  setRangeFocus(coords) {
-    if (this.selectedRange.isEmpty()) {
-      return;
-    }
-    const cellRange = this.selectedRange.current();
-    const focusHighlight = this.highlight.getFocus();
-    focusHighlight.clear();
-    cellRange.setHighlight(coords);
-    if (!this.inProgress) {
-      this.runLocalHooks('beforeHighlightSet');
-    }
-    if (this.highlight.isEnabledFor(FOCUS_TYPE, cellRange.highlight)) {
-      focusHighlight.add(cellRange.highlight).commit().syncWith(cellRange);
-    }
-    if (!this.inProgress) {
-      _classPrivateFieldSet(this, _isFocusSelectionChanged, true);
-      this.runLocalHooks('afterSetFocus', cellRange.highlight);
-    }
+  isMultiple() {
+    const isMultipleListener = createObjectPropListener(!this.selectedRange.current().isSingle());
+    this.runLocalHooks('afterIsMultipleSelection', isMultipleListener);
+    return isMultipleListener.value;
   }
 
   /**
@@ -561,13 +456,7 @@ class Selection {
    */
   transformStart(rowDelta, colDelta) {
     let createMissingRecords = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
-    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));
+    this.setRangeStart(this.transformation.transformStart(rowDelta, colDelta, createMissingRecords));
   }
 
   /**
@@ -577,44 +466,7 @@ class Selection {
    * @param {number} colDelta Columns number to move, value can be passed as negative number.
    */
   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());
+    this.setRangeEnd(this.transformation.transformEnd(rowDelta, colDelta));
   }
 
   /**
@@ -635,30 +487,6 @@ 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
@@ -857,7 +685,7 @@ class Selection {
       focusPosition,
       disableHeadersHighlight
     } = options;
-    _classPrivateFieldSet(this, _disableHeadersHighlight, disableHeadersHighlight);
+    _classPrivateFieldSet(_disableHeadersHighlight, this, 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(clamp(focusPosition.row, rowFrom, nrOfRows - 1), clamp(focusPosition.col, columnFrom, nrOfColumns - 1));
     }
@@ -873,7 +701,7 @@ class Selection {
     }
     this.setRangeEnd(endCoords);
     this.finish();
-    _classPrivateFieldSet(this, _disableHeadersHighlight, false);
+    _classPrivateFieldSet(_disableHeadersHighlight, this, false);
   }
 
   /**
@@ -941,10 +769,9 @@ 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 | { row: number, col: 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. An object with `row` and `col` properties also can be passed to change the focus
-   * position horizontally.
+   * @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) {
@@ -965,20 +792,11 @@ class Selection {
       countColHeaders
     });
     if (isValid) {
-      let highlightRow = 0;
-      let highlightColumn = 0;
-      if (Number.isInteger(focusPosition === null || focusPosition === void 0 ? void 0 : focusPosition.row) && Number.isInteger(focusPosition === null || focusPosition === void 0 ? void 0 : focusPosition.col)) {
-        highlightRow = clamp(focusPosition.row, columnHeaderLastIndex, countRows - 1);
-        highlightColumn = clamp(focusPosition.col, Math.min(start, end), Math.max(start, end));
-      } else {
-        highlightRow = clamp(focusPosition, columnHeaderLastIndex, countRows - 1);
-        highlightColumn = start;
-      }
-      const highlight = this.tableProps.createCellCoords(highlightRow, highlightColumn);
-      const fromRow = countColHeaders === 0 ? 0 : clamp(highlight.row, columnHeaderLastIndex, -1);
+      const fromRow = countColHeaders === 0 ? 0 : 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(clamp(focusPosition, columnHeaderLastIndex, countRows - 1), start);
       this.runLocalHooks('beforeSelectColumns', from, to, highlight);
 
       // disallow modifying row axis for that hooks
@@ -998,10 +816,9 @@ 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 | { row: number, col: 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. An object with `row` and `col` properties also can be passed to change the focus
-   * position horizontally.
+   * @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) {
@@ -1020,20 +837,11 @@ class Selection {
       countColHeaders: 0
     });
     if (isValid) {
-      let highlightRow = 0;
-      let highlightColumn = 0;
-      if (Number.isInteger(focusPosition === null || focusPosition === void 0 ? void 0 : focusPosition.row) && Number.isInteger(focusPosition === null || focusPosition === void 0 ? void 0 : focusPosition.col)) {
-        highlightRow = clamp(focusPosition.row, Math.min(startRow, endRow), Math.max(startRow, endRow));
-        highlightColumn = clamp(focusPosition.col, rowHeaderLastIndex, countCols - 1);
-      } else {
-        highlightRow = startRow;
-        highlightColumn = clamp(focusPosition, rowHeaderLastIndex, countCols - 1);
-      }
-      const highlight = this.tableProps.createCellCoords(highlightRow, highlightColumn);
-      const fromColumn = countRowHeaders === 0 ? 0 : clamp(highlight.col, rowHeaderLastIndex, -1);
+      const fromColumn = countRowHeaders === 0 ? 0 : 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, clamp(focusPosition, rowHeaderLastIndex, countCols - 1));
       this.runLocalHooks('beforeSelectRows', from, to, highlight);
 
       // disallow modifying column axis for that hooks