handsontable 16.0.1-next-eee5f08-20250710 → 16.1.0-next-abd8f2e-20250904

package/selection/selection.mjs

@@ -1,4 +1,5 @@
 import "core-js/modules/es.error.cause.js";
+import "core-js/modules/es.array.push.js";
 import "core-js/modules/es.set.difference.v2.js";
 import "core-js/modules/es.set.intersection.v2.js";
 import "core-js/modules/es.set.is-disjoint-from.v2.js";
@@ -25,20 +26,30 @@ 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 { ExtenderTransformation, FocusTransformation } from "./transformation/index.mjs";
 import { detectSelectionType, normalizeSelectionFactory, SELECTION_TYPE_EMPTY, SELECTION_TYPE_UNRECOGNIZED } from "./utils.mjs";
 import { toSingleLine } from "./../helpers/templateLiteralTag.mjs";
 import { A11Y_SELECTED } from "../helpers/a11y.mjs";
+/**
+ * @typedef {object} SelectionState
+ * @property {CellRange[]} ranges The array of all ranges.
+ * @property {CellRange} activeRange The active range.
+ * @property {number} activeSelectionLayer The active selection layer.
+ * @property {number[]} selectedByRowHeader The state of the selected row headers.
+ * @property {number[]} selectedByColumnHeader The state of the selected column headers.
+ * @property {boolean} disableHeadersHighlight The state of the disable headers highlight.
+ */
 /**
  * @class Selection
  * @util
  */
-var _transformation = /*#__PURE__*/new WeakMap();
+var _extenderTransformation = /*#__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();
+var _activeSelectionLayer = /*#__PURE__*/new WeakMap();
 class Selection {
   constructor(settings, tableProps) {
     var _this = this;
@@ -77,13 +88,13 @@ class Selection {
     /**
      * The module for modifying coordinates of the start and end selection.
      *
-     * @type {Transformation}
+     * @type {ExtenderTransformation}
      */
-    _classPrivateFieldInitSpec(this, _transformation, void 0);
+    _classPrivateFieldInitSpec(this, _extenderTransformation, void 0);
     /**
      * The module for modifying coordinates of the focus selection.
      *
-     * @type {Transformation}
+     * @type {FocusTransformation}
      */
     _classPrivateFieldInitSpec(this, _focusTransformation, void 0);
     /**
@@ -125,6 +136,13 @@ class Selection {
      * @param {number}
      */
     _classPrivateFieldInitSpec(this, _expectedLayersCount, -1);
+    /**
+     * The index of the active range layer. Active range layer is the layer that has visible focus highlight.
+     * Focus highlight may jump between selection range layers.
+     *
+     * @type {number}
+     */
+    _classPrivateFieldInitSpec(this, _activeSelectionLayer, 0);
     this.settings = settings;
     this.tableProps = tableProps;
     this.highlight = new Highlight({
@@ -147,95 +165,67 @@ class Selection {
       createCellCoords: (row, column) => this.tableProps.createCellCoords(row, column),
       createCellRange: (highlight, from, to) => this.tableProps.createCellRange(highlight, from, to)
     });
-    _classPrivateFieldSet(_transformation, this, new Transformation(this.selectedRange, {
-      rowIndexMapper: this.tableProps.rowIndexMapper,
-      columnIndexMapper: this.tableProps.columnIndexMapper,
-      countRenderableRows: () => this.tableProps.countRenderableRows(),
-      countRenderableColumns: () => this.tableProps.countRenderableColumns(),
-      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),
+    _classPrivateFieldSet(_extenderTransformation, this, new ExtenderTransformation(this.selectedRange, {
+      ...this.tableProps,
+      navigableHeaders: () => settings.navigableHeaders,
       fixedRowsBottom: () => settings.fixedRowsBottom,
       minSpareRows: () => settings.minSpareRows,
       minSpareCols: () => settings.minSpareCols,
       autoWrapRow: () => settings.autoWrapRow,
       autoWrapCol: () => settings.autoWrapCol
     }));
-    _classPrivateFieldSet(_focusTransformation, this, 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),
+    _classPrivateFieldSet(_focusTransformation, this, new FocusTransformation(this.selectedRange, {
+      ...this.tableProps,
+      navigableHeaders: () => settings.navigableHeaders,
       fixedRowsBottom: () => 0,
       minSpareRows: () => 0,
       minSpareCols: () => 0,
       autoWrapRow: () => true,
       autoWrapCol: () => true
     }));
-    _classPrivateFieldGet(_transformation, this).addLocalHook('beforeTransformStart', function () {
+    _classPrivateFieldGet(_extenderTransformation, this).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(_transformation, this).addLocalHook('afterTransformStart', function () {
+    _classPrivateFieldGet(_extenderTransformation, this).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(_transformation, this).addLocalHook('beforeTransformEnd', function () {
+    _classPrivateFieldGet(_extenderTransformation, this).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(_transformation, this).addLocalHook('afterTransformEnd', function () {
+    _classPrivateFieldGet(_extenderTransformation, this).addLocalHook('afterTransformEnd', function () {
       for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
         args[_key4] = arguments[_key4];
       }
       return _this.runLocalHooks('afterModifyTransformEnd', ...args);
     });
-    _classPrivateFieldGet(_transformation, this).addLocalHook('insertRowRequire', function () {
+    _classPrivateFieldGet(_extenderTransformation, this).addLocalHook('insertRowRequire', function () {
       for (var _len5 = arguments.length, args = new Array(_len5), _key5 = 0; _key5 < _len5; _key5++) {
         args[_key5] = arguments[_key5];
       }
       return _this.runLocalHooks('insertRowRequire', ...args);
     });
-    _classPrivateFieldGet(_transformation, this).addLocalHook('insertColRequire', function () {
+    _classPrivateFieldGet(_extenderTransformation, this).addLocalHook('insertColRequire', function () {
       for (var _len6 = arguments.length, args = new Array(_len6), _key6 = 0; _key6 < _len6; _key6++) {
         args[_key6] = arguments[_key6];
       }
       return _this.runLocalHooks('insertColRequire', ...args);
     });
-    _classPrivateFieldGet(_transformation, this).addLocalHook('beforeRowWrap', function () {
+    _classPrivateFieldGet(_extenderTransformation, this).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);
     });
-    _classPrivateFieldGet(_transformation, this).addLocalHook('beforeColumnWrap', function () {
+    _classPrivateFieldGet(_extenderTransformation, this).addLocalHook('beforeColumnWrap', function () {
       for (var _len8 = arguments.length, args = new Array(_len8), _key8 = 0; _key8 < _len8; _key8++) {
         args[_key8] = arguments[_key8];
       }
@@ -256,7 +246,7 @@ class Selection {
   }
 
   /**
-   * Get data layer for current selection.
+   * Gets all selection range layers of the selection.
    *
    * @returns {SelectionRange}
    */
@@ -264,6 +254,33 @@ class Selection {
     return this.selectedRange;
   }
 
+  /**
+   * Gets the active selection range layer.
+   *
+   * @returns {CellRange}
+   */
+  getActiveSelectedRange() {
+    return this.selectedRange.peekByIndex(_classPrivateFieldGet(_activeSelectionLayer, this));
+  }
+
+  /**
+   * Gets the index of the active selection range layer.
+   *
+   * @returns {number}
+   */
+  getActiveSelectionLayerIndex() {
+    return _classPrivateFieldGet(_activeSelectionLayer, this);
+  }
+
+  /**
+   * Sets the index of the active selection range layer.
+   *
+   * @param {number} layerIndex The index of the active selection range layer.
+   */
+  setActiveSelectionLayerIndex(layerIndex) {
+    _classPrivateFieldSet(_activeSelectionLayer, this, layerIndex);
+  }
+
   /**
    * Marks the source of the selection. It can be one of the following values: `mouse`, or any other string.
    *
@@ -343,10 +360,20 @@ 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(_disableHeadersHighlight, this, false);
     _classPrivateFieldSet(_isFocusSelectionChanged, this, false);
     this.runLocalHooks(`beforeSetRangeStart${fragment ? 'Only' : ''}`, coordsClone);
     if (!isMultipleMode || isMultipleMode && !isMultipleSelection && isUndefined(multipleSelection)) {
       this.selectedRange.clear();
+      arrayEach(this.highlight.getAreas(), highlight => void highlight.clear());
+      arrayEach(this.highlight.getLayeredAreas(), highlight => void highlight.clear());
+      arrayEach(this.highlight.getRowHeaders(), highlight => void highlight.clear());
+      arrayEach(this.highlight.getColumnHeaders(), highlight => void highlight.clear());
+      arrayEach(this.highlight.getActiveRowHeaders(), highlight => void highlight.clear());
+      arrayEach(this.highlight.getActiveColumnHeaders(), highlight => void highlight.clear());
+      arrayEach(this.highlight.getActiveCornerHeaders(), highlight => void highlight.clear());
+      arrayEach(this.highlight.getRowHighlights(), highlight => void highlight.clear());
+      arrayEach(this.highlight.getColumnHighlights(), highlight => void highlight.clear());
     }
     this.selectedRange.add(coordsClone).current().setHighlight(highlightCoords.clone());
     if (this.getLayerLevel() === 0) {
@@ -376,15 +403,18 @@ class Selection {
    * Ends selection range on given coordinate object.
    *
    * @param {CellCoords} coords Visual coords.
+   * @param {number} [layerIndex] The layer index to set the end on. If not provided, the current layer level is used.
    */
   setRangeEnd(coords) {
+    let layerIndex = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.getLayerLevel();
     if (this.selectedRange.isEmpty()) {
       return;
     }
+    this.setActiveSelectionLayerIndex(layerIndex);
     const coordsClone = coords.clone();
     const countRows = this.tableProps.countRows();
     const countCols = this.tableProps.countCols();
-    const isSingle = this.selectedRange.current().clone().setTo(coords).isSingleHeader();
+    const isSingle = this.getActiveSelectedRange().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.
@@ -393,7 +423,7 @@ class Selection {
     }
     this.runLocalHooks('beforeSetRangeEnd', coordsClone);
     this.begin();
-    const cellRange = this.selectedRange.current();
+    const cellRange = this.getActiveSelectedRange();
     if (!this.settings.navigableHeaders) {
       cellRange.highlight.normalize();
     }
@@ -424,8 +454,8 @@ class Selection {
       }
     }
     this.runLocalHooks('beforeHighlightSet');
-    this.setRangeFocus(this.selectedRange.current().highlight);
-    this.applyAndCommit();
+    this.setRangeFocus(this.getActiveSelectedRange().highlight, layerIndex);
+    this.applyAndCommit(this.getActiveSelectedRange(), layerIndex);
     const isLastLayer = _classPrivateFieldGet(_expectedLayersCount, this) === -1 || this.selectedRange.size() === _classPrivateFieldGet(_expectedLayersCount, this);
     this.runLocalHooks('afterSetRangeEnd', coords, isLastLayer);
   }
@@ -438,24 +468,10 @@ class Selection {
    * @param {number} [layerLevel] The layer level to apply. If not provided, the current layer level is used.
    */
   applyAndCommit() {
-    let cellRange = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.selectedRange.current();
+    let cellRange = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.getActiveSelectedRange();
     let layerLevel = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.getLayerLevel();
     const countRows = this.tableProps.countRows();
     const countCols = this.tableProps.countCols();
-
-    // If the next layer level is lower than previous then clear all area and header highlights. This is the
-    // indication that the new selection is performing.
-    if (layerLevel < this.highlight.layerLevel) {
-      arrayEach(this.highlight.getAreas(), highlight => void highlight.clear());
-      arrayEach(this.highlight.getLayeredAreas(), highlight => void highlight.clear());
-      arrayEach(this.highlight.getRowHeaders(), highlight => void highlight.clear());
-      arrayEach(this.highlight.getColumnHeaders(), highlight => void highlight.clear());
-      arrayEach(this.highlight.getActiveRowHeaders(), highlight => void highlight.clear());
-      arrayEach(this.highlight.getActiveColumnHeaders(), highlight => void highlight.clear());
-      arrayEach(this.highlight.getActiveCornerHeaders(), highlight => void highlight.clear());
-      arrayEach(this.highlight.getRowHighlights(), highlight => void highlight.clear());
-      arrayEach(this.highlight.getColumnHighlights(), highlight => void highlight.clear());
-    }
     this.highlight.useLayerLevel(layerLevel);
     const areaHighlight = this.highlight.createArea();
     const layeredAreaHighlight = this.highlight.createLayeredArea();
@@ -482,7 +498,7 @@ class Selection {
         // 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();
+        const previousRange = this.selectedRange.peekByIndex(layerLevel - 1);
         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).
@@ -529,12 +545,17 @@ class Selection {
    * Sets the selection focus position at the specified coordinates.
    *
    * @param {CellCoords} coords The CellCoords instance with defined visual coordinates.
+   * @param {number} [layerIndex] The layer index to set the focus on.
    */
   setRangeFocus(coords) {
+    let layerIndex = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.getLayerLevel();
     if (this.selectedRange.isEmpty()) {
       return;
     }
-    const cellRange = this.selectedRange.current();
+    this.setActiveSelectionLayerIndex(layerIndex);
+    _classPrivateFieldGet(_extenderTransformation, this).setActiveLayerIndex(layerIndex);
+    _classPrivateFieldGet(_focusTransformation, this).setActiveLayerIndex(layerIndex);
+    const cellRange = this.getActiveSelectedRange();
     if (!this.inProgress) {
       this.runLocalHooks('beforeSetFocus', coords);
     }
@@ -563,15 +584,10 @@ class Selection {
    */
   transformStart(rowDelta, colDelta) {
     let createMissingRecords = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
-    if (this.settings.navigableHeaders) {
-      _classPrivateFieldGet(_transformation, this).setOffsetSize({
-        x: this.tableProps.countRowHeaders(),
-        y: this.tableProps.countColHeaders()
-      });
-    } else {
-      _classPrivateFieldGet(_transformation, this).resetOffsetSize();
-    }
-    this.setRangeStart(_classPrivateFieldGet(_transformation, this).transformStart(rowDelta, colDelta, createMissingRecords));
+    const {
+      visualCoords
+    } = _classPrivateFieldGet(_extenderTransformation, this).transformStart(rowDelta, colDelta, createMissingRecords);
+    this.setRangeStart(visualCoords);
   }
 
   /**
@@ -581,15 +597,11 @@ class Selection {
    * @param {number} colDelta Columns number to move, value can be passed as negative number.
    */
   transformEnd(rowDelta, colDelta) {
-    if (this.settings.navigableHeaders) {
-      _classPrivateFieldGet(_transformation, this).setOffsetSize({
-        x: this.tableProps.countRowHeaders(),
-        y: this.tableProps.countColHeaders()
-      });
-    } else {
-      _classPrivateFieldGet(_transformation, this).resetOffsetSize();
-    }
-    this.setRangeEnd(_classPrivateFieldGet(_transformation, this).transformEnd(rowDelta, colDelta));
+    const {
+      visualCoords,
+      selectionLayer
+    } = _classPrivateFieldGet(_extenderTransformation, this).transformEnd(rowDelta, colDelta);
+    this.setRangeEnd(visualCoords, selectionLayer);
   }
 
   /**
@@ -599,28 +611,11 @@ class Selection {
    * @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(_focusTransformation, this).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(_focusTransformation, this).setOffsetSize({
-        x: col < 0 ? 0 : -columnsInRange,
-        y: row < 0 ? 0 : -rowsInRange
-      });
-    }
-    const focusCoords = _classPrivateFieldGet(_focusTransformation, this).transformStart(rowDelta, colDelta);
-    this.setRangeFocus(focusCoords.normalize());
+      selectionLayer,
+      visualCoords
+    } = _classPrivateFieldGet(_focusTransformation, this).transformStart(rowDelta, colDelta);
+    this.setRangeFocus(visualCoords.normalize(), selectionLayer);
   }
 
   /**
@@ -633,7 +628,7 @@ class Selection {
     if (!this.isSelected()) {
       return;
     }
-    const range = this.selectedRange.current();
+    const range = this.getActiveSelectedRange();
     if (this.isSelectedByCorner()) {
       this.selectAll(true, true, {
         disableHeadersHighlight: true
@@ -682,7 +677,7 @@ class Selection {
     if (!this.isSelected()) {
       return;
     }
-    const range = this.selectedRange.current();
+    const range = this.getActiveSelectedRange();
     if (this.isSelectedByCorner()) {
       this.selectAll(true, true, {
         disableHeadersHighlight: true
@@ -747,7 +742,7 @@ class Selection {
    * @returns {boolean}
    */
   isMultiple() {
-    let cellRange = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.selectedRange.current();
+    let cellRange = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.getActiveSelectedRange();
     if (!this.isSelected()) {
       return false;
     }
@@ -940,7 +935,7 @@ class Selection {
    * the logical coordinates points on them.
    */
   selectAll() {
-    var _this$getSelectedRang;
+    var _this$getActiveSelect;
     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] : {
@@ -958,19 +953,20 @@ class Selection {
     if (rowFrom === 0 && columnFrom === 0 && (nrOfRows === 0 || nrOfColumns === 0)) {
       return;
     }
-    let highlight = (_this$getSelectedRang = this.getSelectedRange().current()) === null || _this$getSelectedRang === void 0 ? void 0 : _this$getSelectedRang.highlight;
+    let highlight = (_this$getActiveSelect = this.getActiveSelectedRange()) === null || _this$getActiveSelect === void 0 ? void 0 : _this$getActiveSelect.highlight;
     const {
       focusPosition,
       disableHeadersHighlight
     } = options;
-    _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));
     }
     const startCoords = this.tableProps.createCellCoords(rowFrom, columnFrom);
     const endCoords = this.tableProps.createCellCoords(nrOfRows - 1, nrOfColumns - 1);
     this.clear();
+    this.runLocalHooks('beforeSelectAll', startCoords, endCoords, highlight);
     this.setRangeStartOnly(startCoords, undefined, highlight);
+    _classPrivateFieldSet(_disableHeadersHighlight, this, disableHeadersHighlight);
     if (columnFrom < 0) {
       this.selectedByRowHeader.add(this.getLayerLevel());
     }
@@ -978,8 +974,8 @@ class Selection {
       this.selectedByColumnHeader.add(this.getLayerLevel());
     }
     this.setRangeEnd(endCoords);
+    this.runLocalHooks('afterSelectAll', startCoords, endCoords, highlight);
     this.finish();
-    _classPrivateFieldSet(_disableHeadersHighlight, this, false);
   }
 
   /**
@@ -1086,10 +1082,6 @@ class Selection {
       const from = this.tableProps.createCellCoords(fromRow, start);
       const to = this.tableProps.createCellCoords(toRow, end);
       this.runLocalHooks('beforeSelectColumns', from, to, highlight);
-
-      // disallow modifying row axis for that hooks
-      from.row = fromRow;
-      to.row = toRow;
       this.setRangeStartOnly(from, undefined, highlight);
       this.selectedByColumnHeader.add(this.getLayerLevel());
       this.setRangeEnd(to);
@@ -1141,10 +1133,6 @@ class Selection {
       const from = this.tableProps.createCellCoords(startRow, fromColumn);
       const to = this.tableProps.createCellCoords(endRow, toColumn);
       this.runLocalHooks('beforeSelectRows', from, to, highlight);
-
-      // disallow modifying column axis for that hooks
-      from.col = fromColumn;
-      to.col = toColumn;
       this.setRangeStartOnly(from, undefined, highlight);
       this.selectedByRowHeader.add(this.getLayerLevel());
       this.setRangeEnd(to);
@@ -1154,6 +1142,57 @@ class Selection {
     return isValid;
   }
 
+  /**
+   * Allows importing the selection for all layers from the provided array of CellRange objects.
+   * The method clears the current selection and sets the new one without triggering any
+   * selection related hooks.
+   *
+   * @param {SelectionState} selectionState The selection state to import.
+   */
+  importSelection(_ref) {
+    let {
+      ranges,
+      activeRange,
+      activeSelectionLayer,
+      selectedByRowHeader,
+      selectedByColumnHeader,
+      disableHeadersHighlight
+    } = _ref;
+    if (ranges.length === 0) {
+      return;
+    }
+    this.selectedRange.clear();
+    this.highlight.clear();
+    this.inProgress = true;
+    _classPrivateFieldSet(_disableHeadersHighlight, this, disableHeadersHighlight);
+    this.selectedByRowHeader = new Set(selectedByRowHeader);
+    this.selectedByColumnHeader = new Set(selectedByColumnHeader);
+    this.setActiveSelectionLayerIndex(0);
+    ranges.forEach((cellRange, selectionLayerIndex) => {
+      this.selectedRange.push(cellRange);
+      this.applyAndCommit(cellRange, selectionLayerIndex);
+    });
+    this.setRangeFocus(activeRange.highlight, activeSelectionLayer);
+    _classPrivateFieldSet(_disableHeadersHighlight, this, false);
+    this.inProgress = false;
+  }
+
+  /**
+   * Exports all selection layers with other properties related to the selection state.
+   *
+   * @returns {SelectionState}
+   */
+  exportSelection() {
+    return {
+      ranges: Array.from(this.selectedRange).map(range => range.clone()),
+      activeRange: this.getActiveSelectedRange(),
+      activeSelectionLayer: this.getActiveSelectionLayerIndex(),
+      selectedByRowHeader: Array.from(this.selectedByRowHeader),
+      selectedByColumnHeader: Array.from(this.selectedByColumnHeader),
+      disableHeadersHighlight: _classPrivateFieldGet(_disableHeadersHighlight, this)
+    };
+  }
+
   /**
    * Refreshes the whole selection by clearing, reapplying and committing (calculating visual to renderable indexes)
    * the selection by using already added visual ranges. The method can be useful when underneath some indexes
@@ -1220,7 +1259,7 @@ class Selection {
       return;
     }
     const currentLayer = this.getLayerLevel();
-    const cellRange = this.selectedRange.current();
+    const cellRange = this.getActiveSelectedRange();
     if (this.highlight.isEnabledFor(FOCUS_TYPE, cellRange.highlight)) {
       this.highlight.getFocus().commit().syncWith(cellRange);
     }