handsontable 13.1.0 → 14.0.0-next-d97b156-20231027

package/selection/transformation.mjs

@@ -1,156 +1,296 @@
+import "core-js/modules/es.error.cause.js";
+function _classPrivateMethodInitSpec(obj, privateSet) { _checkPrivateRedeclaration(obj, privateSet); privateSet.add(obj); }
+function _classPrivateFieldInitSpec(obj, privateMap, value) { _checkPrivateRedeclaration(obj, privateMap); privateMap.set(obj, value); }
+function _checkPrivateRedeclaration(obj, privateCollection) { if (privateCollection.has(obj)) { throw new TypeError("Cannot initialize the same private elements twice on an object"); } }
+function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); }
+function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; }
+function _classPrivateMethodGet(receiver, privateSet, fn) { if (!privateSet.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return fn; }
+function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set"); _classApplyDescriptorSet(receiver, descriptor, value); return value; }
+function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); }
+function _classApplyDescriptorSet(receiver, descriptor, value) { if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } }
 import { mixin } from "../helpers/object.mjs";
 import localHooks from "./../mixins/localHooks.mjs";
 /**
  * The Transformation class implements algorithms for transforming coordinates based on current settings
- * passed to the Handsontable.
+ * passed to the Handsontable. The class performs the calculations based on the renderable indexes.
  *
  * Transformation is always applied relative to the current selection.
  *
+ * The class operates on a table size defined by the renderable indexes. If the `navigableHeaders`
+ * option is enabled, the table size is increased by the number of row and/or column headers.
+ * Because the headers are treated as cells as part of the table size (indexes always go from 0 to N),
+ * the algorithm can be written as simply as possible (without new if's that distinguish the headers
+ * logic).
+ *
  * @class Transformation
  * @util
  */
+var _range = /*#__PURE__*/new WeakMap();
+var _options = /*#__PURE__*/new WeakMap();
+var _offset = /*#__PURE__*/new WeakMap();
+var _setOffsetSize = /*#__PURE__*/new WeakSet();
+var _clampCoords = /*#__PURE__*/new WeakSet();
+var _getTableSize = /*#__PURE__*/new WeakSet();
+var _visualToZeroBasedCoords = /*#__PURE__*/new WeakSet();
+var _zeroBasedToVisualCoords = /*#__PURE__*/new WeakSet();
 class Transformation {
   constructor(range, options) {
+    /**
+     * Translates the zero-based coordinates to visual ones.
+     *
+     * @param {CellCoords} zeroBasedCoords The coordinates to process.
+     * @returns {CellCoords}
+     */
+    _classPrivateMethodInitSpec(this, _zeroBasedToVisualCoords);
+    /**
+     * Translates the visual coordinates to zero-based ones.
+     *
+     * @param {CellCoords} visualCoords The visual coords to process.
+     * @returns {CellCoords}
+     */
+    _classPrivateMethodInitSpec(this, _visualToZeroBasedCoords);
+    /**
+     * Gets the table size in number of rows with headers as "height" and number of columns with
+     * headers as "width".
+     *
+     * @returns {{width: number, height: number}}
+     */
+    _classPrivateMethodInitSpec(this, _getTableSize);
+    /**
+     * Clamps the coords to make sure they points to the cell (or header) in the table range.
+     *
+     * @param {CellCoords} zeroBasedCoords The coords object to clamp.
+     * @returns {{rowDir: 1|0|-1, colDir: 1|0|-1}}
+     */
+    _classPrivateMethodInitSpec(this, _clampCoords);
+    /**
+     * Sets the additional offset in table size that may occur when the `navigableHeaders` option
+     * is enabled.
+     *
+     * @param {{x: number, y: number}} offset Offset as x and y properties.
+     */
+    _classPrivateMethodInitSpec(this, _setOffsetSize);
     /**
      * Instance of the SelectionRange, holder for visual coordinates applied to the table.
      *
      * @type {SelectionRange}
      */
-    this.range = range;
+    _classPrivateFieldInitSpec(this, _range, {
+      writable: true,
+      value: void 0
+    });
     /**
      * Additional options which define the state of the settings which can infer transformation and
      * give the possibility to translate indexes.
      *
      * @type {object}
      */
-    this.options = options;
+    _classPrivateFieldInitSpec(this, _options, {
+      writable: true,
+      value: void 0
+    });
+    /**
+     * Increases the table size by applying the offsets. The option is used by the `navigableHeaders`
+     * option.
+     *
+     * @type {{ x: number, y: number }}
+     */
+    _classPrivateFieldInitSpec(this, _offset, {
+      writable: true,
+      value: {
+        x: 0,
+        y: 0
+      }
+    });
+    _classPrivateFieldSet(this, _range, range);
+    _classPrivateFieldSet(this, _options, options);
   }
 
   /**
-   * Selects cell relative to current cell (if possible).
+   * Selects cell relative to the current cell (if possible).
    *
    * @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
+   * @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.
    * @returns {CellCoords} Visual coordinates after transformation.
    */
   transformStart(rowDelta, colDelta) {
-    let force = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
-    const delta = this.options.createCellCoords(rowDelta, colDelta);
-    const highlightCoords = this.range.current().highlight;
-    const {
-      row: renderableRow,
-      col: renderableColumn
-    } = this.options.visualToRenderableCoords(highlightCoords);
-    let visualCoords = highlightCoords;
+    let createMissingRecords = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+    _classPrivateMethodGet(this, _setOffsetSize, _setOffsetSize2).call(this, {
+      x: _classPrivateFieldGet(this, _options).navigableHeaders() ? _classPrivateFieldGet(this, _options).countRowHeaders() : 0,
+      y: _classPrivateFieldGet(this, _options).navigableHeaders() ? _classPrivateFieldGet(this, _options).countColHeaders() : 0
+    });
+    const delta = _classPrivateFieldGet(this, _options).createCellCoords(rowDelta, colDelta);
+    let visualCoords = _classPrivateFieldGet(this, _range).current().highlight;
+    const highlightRenderableCoords = _classPrivateFieldGet(this, _options).visualToRenderableCoords(visualCoords);
     let rowTransformDir = 0;
     let colTransformDir = 0;
     this.runLocalHooks('beforeTransformStart', delta);
-    if (renderableRow !== null && renderableColumn !== null) {
-      let totalRows = this.options.countRows();
-      let totalCols = this.options.countCols();
-      const fixedRowsBottom = this.options.fixedRowsBottom();
-      const minSpareRows = this.options.minSpareRows();
-      const minSpareCols = this.options.minSpareCols();
-      const autoWrapRow = this.options.autoWrapRow();
-      const autoWrapCol = this.options.autoWrapCol();
-      if (renderableRow + rowDelta > totalRows - 1) {
-        if (force && minSpareRows > 0 && !(fixedRowsBottom && renderableRow >= totalRows - fixedRowsBottom - 1)) {
-          this.runLocalHooks('insertRowRequire', totalRows);
-          totalRows = this.options.countRows();
-        } else if (autoWrapCol) {
-          delta.row = 1 - totalRows;
-          delta.col = renderableColumn + delta.col === totalCols - 1 ? 1 - totalCols : 1;
+    if (highlightRenderableCoords.row !== null && highlightRenderableCoords.col !== null) {
+      const {
+        width,
+        height
+      } = _classPrivateMethodGet(this, _getTableSize, _getTableSize2).call(this);
+      const {
+        row,
+        col
+      } = _classPrivateMethodGet(this, _visualToZeroBasedCoords, _visualToZeroBasedCoords2).call(this, visualCoords);
+      const fixedRowsBottom = _classPrivateFieldGet(this, _options).fixedRowsBottom();
+      const minSpareRows = _classPrivateFieldGet(this, _options).minSpareRows();
+      const minSpareCols = _classPrivateFieldGet(this, _options).minSpareCols();
+      const autoWrapRow = _classPrivateFieldGet(this, _options).autoWrapRow();
+      const autoWrapCol = _classPrivateFieldGet(this, _options).autoWrapCol();
+      const zeroBasedCoords = _classPrivateFieldGet(this, _options).createCellCoords(row + delta.row, col + delta.col);
+      if (zeroBasedCoords.row >= height) {
+        const autoInsertingMode = createMissingRecords && minSpareRows > 0 && fixedRowsBottom === 0;
+        const isWrapEnabled = !autoInsertingMode && autoWrapCol;
+        const nextColumn = zeroBasedCoords.col + 1;
+        const newCoords = _classPrivateFieldGet(this, _options).createCellCoords(zeroBasedCoords.row - height, nextColumn >= width ? nextColumn - width : nextColumn);
+        this.runLocalHooks('beforeColumnWrap', isWrapEnabled, _classPrivateMethodGet(this, _zeroBasedToVisualCoords, _zeroBasedToVisualCoords2).call(this, newCoords), nextColumn >= width);
+        if (autoInsertingMode) {
+          this.runLocalHooks('insertRowRequire', _classPrivateFieldGet(this, _options).countRenderableRows());
+        } else if (isWrapEnabled) {
+          zeroBasedCoords.assign(newCoords);
         }
-      } else if (autoWrapCol && renderableRow + delta.row < 0 && renderableColumn + delta.col >= 0) {
-        delta.row = totalRows - 1;
-        delta.col = renderableColumn + delta.col === 0 ? totalCols - 1 : -1;
-      }
-      if (renderableColumn + delta.col > totalCols - 1) {
-        if (force && minSpareCols > 0) {
-          this.runLocalHooks('insertColRequire', totalCols);
-          totalCols = this.options.countCols();
-        } else if (autoWrapRow) {
-          delta.row = renderableRow + delta.row === totalRows - 1 ? 1 - totalRows : 1;
-          delta.col = 1 - totalCols;
+      } else if (zeroBasedCoords.row < 0) {
+        const previousColumn = zeroBasedCoords.col - 1;
+        const newCoords = _classPrivateFieldGet(this, _options).createCellCoords(height + zeroBasedCoords.row, previousColumn < 0 ? width + previousColumn : previousColumn);
+        this.runLocalHooks('beforeColumnWrap', autoWrapCol, _classPrivateMethodGet(this, _zeroBasedToVisualCoords, _zeroBasedToVisualCoords2).call(this, newCoords), previousColumn < 0);
+        if (autoWrapCol) {
+          zeroBasedCoords.assign(newCoords);
         }
-      } else if (autoWrapRow && renderableColumn + delta.col < 0 && renderableRow + delta.row >= 0) {
-        delta.row = renderableRow + delta.row === 0 ? totalRows - 1 : -1;
-        delta.col = totalCols - 1;
-      }
-      const coords = this.options.createCellCoords(renderableRow + delta.row, renderableColumn + delta.col);
-      rowTransformDir = 0;
-      colTransformDir = 0;
-      if (coords.row < 0) {
-        rowTransformDir = -1;
-        coords.row = 0;
-      } else if (coords.row > 0 && coords.row >= totalRows) {
-        rowTransformDir = 1;
-        coords.row = totalRows - 1;
       }
-      if (coords.col < 0) {
-        colTransformDir = -1;
-        coords.col = 0;
-      } else if (coords.col > 0 && coords.col >= totalCols) {
-        colTransformDir = 1;
-        coords.col = totalCols - 1;
+      if (zeroBasedCoords.col >= width) {
+        const autoInsertingMode = createMissingRecords && minSpareCols > 0;
+        const isWrapEnabled = !autoInsertingMode && autoWrapRow;
+        const nextRow = zeroBasedCoords.row + 1;
+        const newCoords = _classPrivateFieldGet(this, _options).createCellCoords(nextRow >= height ? nextRow - height : nextRow, zeroBasedCoords.col - width);
+        this.runLocalHooks('beforeRowWrap', isWrapEnabled, _classPrivateMethodGet(this, _zeroBasedToVisualCoords, _zeroBasedToVisualCoords2).call(this, newCoords), nextRow >= height);
+        if (autoInsertingMode) {
+          this.runLocalHooks('insertColRequire', _classPrivateFieldGet(this, _options).countRenderableColumns());
+        } else if (isWrapEnabled) {
+          zeroBasedCoords.assign(newCoords);
+        }
+      } else if (zeroBasedCoords.col < 0) {
+        const previousRow = zeroBasedCoords.row - 1;
+        const newCoords = _classPrivateFieldGet(this, _options).createCellCoords(previousRow < 0 ? height + previousRow : previousRow, width + zeroBasedCoords.col);
+        this.runLocalHooks('beforeRowWrap', autoWrapRow, _classPrivateMethodGet(this, _zeroBasedToVisualCoords, _zeroBasedToVisualCoords2).call(this, newCoords), previousRow < 0);
+        if (autoWrapRow) {
+          zeroBasedCoords.assign(newCoords);
+        }
       }
-      visualCoords = this.options.renderableToVisualCoords(coords);
+      const {
+        rowDir,
+        colDir
+      } = _classPrivateMethodGet(this, _clampCoords, _clampCoords2).call(this, zeroBasedCoords);
+      rowTransformDir = rowDir;
+      colTransformDir = colDir;
+      visualCoords = _classPrivateMethodGet(this, _zeroBasedToVisualCoords, _zeroBasedToVisualCoords2).call(this, zeroBasedCoords);
     }
     this.runLocalHooks('afterTransformStart', visualCoords, rowTransformDir, colTransformDir);
     return visualCoords;
   }
 
   /**
-   * Sets selection end cell relative to current selection end cell (if possible).
+   * Sets selection end cell relative to the current selection end cell (if possible).
    *
    * @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.
    * @returns {CellCoords} Visual coordinates after transformation.
    */
   transformEnd(rowDelta, colDelta) {
-    const delta = this.options.createCellCoords(rowDelta, colDelta);
-    const cellRange = this.range.current();
-    let visualCoords = cellRange.to;
+    _classPrivateMethodGet(this, _setOffsetSize, _setOffsetSize2).call(this, {
+      x: _classPrivateFieldGet(this, _options).navigableHeaders() ? _classPrivateFieldGet(this, _options).countRowHeaders() : 0,
+      y: _classPrivateFieldGet(this, _options).navigableHeaders() ? _classPrivateFieldGet(this, _options).countColHeaders() : 0
+    });
+    const delta = _classPrivateFieldGet(this, _options).createCellCoords(rowDelta, colDelta);
+    const cellRange = _classPrivateFieldGet(this, _range).current();
+    const highlightRenderableCoords = _classPrivateFieldGet(this, _options).visualToRenderableCoords(cellRange.highlight);
+    const visualCoords = cellRange.to.clone();
     let rowTransformDir = 0;
     let colTransformDir = 0;
     this.runLocalHooks('beforeTransformEnd', delta);
-    const {
-      row: rowHighlight,
-      col: colHighlight
-    } = this.options.visualToRenderableCoords(cellRange.highlight);
-
-    // We have highlight (start point for the selection).
-    if (rowHighlight !== null && colHighlight !== null) {
-      const totalRows = this.options.countRows();
-      const totalCols = this.options.countCols();
+    if (highlightRenderableCoords.row !== null && highlightRenderableCoords.col !== null) {
       const {
-        row: rowTo,
-        col: colTo
-      } = this.options.visualToRenderableCoords(cellRange.to);
-      const coords = this.options.createCellCoords(rowTo + delta.row, colTo + delta.col);
-      rowTransformDir = 0;
-      colTransformDir = 0;
-      if (coords.row < 0) {
-        rowTransformDir = -1;
-        coords.row = 0;
-      } else if (coords.row > 0 && coords.row >= totalRows) {
-        rowTransformDir = 1;
-        coords.row = totalRows - 1;
-      }
-      if (coords.col < 0) {
-        colTransformDir = -1;
-        coords.col = 0;
-      } else if (coords.col > 0 && coords.col >= totalCols) {
-        colTransformDir = 1;
-        coords.col = totalCols - 1;
+        row,
+        col
+      } = _classPrivateMethodGet(this, _visualToZeroBasedCoords, _visualToZeroBasedCoords2).call(this, cellRange.to);
+      const coords = _classPrivateFieldGet(this, _options).createCellCoords(row + delta.row, col + delta.col);
+      const {
+        rowDir,
+        colDir
+      } = _classPrivateMethodGet(this, _clampCoords, _clampCoords2).call(this, coords);
+      rowTransformDir = rowDir;
+      colTransformDir = colDir;
+      const newVisualCoords = _classPrivateMethodGet(this, _zeroBasedToVisualCoords, _zeroBasedToVisualCoords2).call(this, coords);
+      if (delta.row === 0 && delta.col !== 0) {
+        visualCoords.col = newVisualCoords.col;
+      } else if (delta.row !== 0 && delta.col === 0) {
+        visualCoords.row = newVisualCoords.row;
+      } else {
+        visualCoords.row = newVisualCoords.row;
+        visualCoords.col = newVisualCoords.col;
       }
-      visualCoords = this.options.renderableToVisualCoords(coords);
     }
     this.runLocalHooks('afterTransformEnd', visualCoords, rowTransformDir, colTransformDir);
     return visualCoords;
   }
 }
+function _setOffsetSize2(_ref) {
+  let {
+    x,
+    y
+  } = _ref;
+  _classPrivateFieldSet(this, _offset, {
+    x,
+    y
+  });
+}
+function _clampCoords2(zeroBasedCoords) {
+  const {
+    width,
+    height
+  } = _classPrivateMethodGet(this, _getTableSize, _getTableSize2).call(this);
+  let rowDir = 0;
+  let colDir = 0;
+  if (zeroBasedCoords.row < 0) {
+    rowDir = -1;
+    zeroBasedCoords.row = 0;
+  } else if (zeroBasedCoords.row > 0 && zeroBasedCoords.row >= height) {
+    rowDir = 1;
+    zeroBasedCoords.row = height - 1;
+  }
+  if (zeroBasedCoords.col < 0) {
+    colDir = -1;
+    zeroBasedCoords.col = 0;
+  } else if (zeroBasedCoords.col > 0 && zeroBasedCoords.col >= width) {
+    colDir = 1;
+    zeroBasedCoords.col = width - 1;
+  }
+  return {
+    rowDir,
+    colDir
+  };
+}
+function _getTableSize2() {
+  return {
+    width: _classPrivateFieldGet(this, _offset).x + _classPrivateFieldGet(this, _options).countRenderableColumns(),
+    height: _classPrivateFieldGet(this, _offset).y + _classPrivateFieldGet(this, _options).countRenderableRows()
+  };
+}
+function _visualToZeroBasedCoords2(visualCoords) {
+  const {
+    row,
+    col
+  } = _classPrivateFieldGet(this, _options).visualToRenderableCoords(visualCoords);
+  return _classPrivateFieldGet(this, _options).createCellCoords(_classPrivateFieldGet(this, _offset).y + row, _classPrivateFieldGet(this, _offset).x + col);
+}
+function _zeroBasedToVisualCoords2(zeroBasedCoords) {
+  const coords = zeroBasedCoords.clone();
+  coords.col = zeroBasedCoords.col - _classPrivateFieldGet(this, _offset).x;
+  coords.row = zeroBasedCoords.row - _classPrivateFieldGet(this, _offset).y;
+  return _classPrivateFieldGet(this, _options).renderableToVisualCoords(coords);
+}
 mixin(Transformation, localHooks);
 export default Transformation;

package/selection/utils.js

@@ -2,7 +2,6 @@
 
 exports.__esModule = true;
 exports.detectSelectionType = detectSelectionType;
-exports.isValidCoord = isValidCoord;
 exports.normalizeSelectionFactory = normalizeSelectionFactory;
 exports.transformSelectionToColumnDistance = transformSelectionToColumnDistance;
 exports.transformSelectionToRowDistance = transformSelectionToRowDistance;
@@ -11,16 +10,11 @@ require("core-js/modules/es.array.push.js");
 var _src = require("./../3rdparty/walkontable/src");
 var _array = require("./../helpers/array");
 var _mixed = require("./../helpers/mixed");
-const SELECTION_TYPE_UNRECOGNIZED = 0;
-exports.SELECTION_TYPE_UNRECOGNIZED = SELECTION_TYPE_UNRECOGNIZED;
-const SELECTION_TYPE_EMPTY = 1;
-exports.SELECTION_TYPE_EMPTY = SELECTION_TYPE_EMPTY;
-const SELECTION_TYPE_ARRAY = 2;
-exports.SELECTION_TYPE_ARRAY = SELECTION_TYPE_ARRAY;
-const SELECTION_TYPE_OBJECT = 3;
-exports.SELECTION_TYPE_OBJECT = SELECTION_TYPE_OBJECT;
-const SELECTION_TYPES = [SELECTION_TYPE_OBJECT, SELECTION_TYPE_ARRAY];
-exports.SELECTION_TYPES = SELECTION_TYPES;
+const SELECTION_TYPE_UNRECOGNIZED = exports.SELECTION_TYPE_UNRECOGNIZED = 0;
+const SELECTION_TYPE_EMPTY = exports.SELECTION_TYPE_EMPTY = 1;
+const SELECTION_TYPE_ARRAY = exports.SELECTION_TYPE_ARRAY = 2;
+const SELECTION_TYPE_OBJECT = exports.SELECTION_TYPE_OBJECT = 3;
+const SELECTION_TYPES = exports.SELECTION_TYPES = [SELECTION_TYPE_OBJECT, SELECTION_TYPE_ARRAY];
 const ARRAY_TYPE_PATTERN = [['number'], ['number', 'string'], ['number', 'undefined'], ['number', 'string', 'undefined']];
 const rootCall = Symbol('root');
 const childCall = Symbol('child');
@@ -111,7 +105,9 @@ function normalizeSelectionFactory(type) {
       rowEnd = Math.max(origRowStart, origRowEnd);
       columnEnd = Math.max(origColumnStart, origColumnEnd);
     }
-    return [rowStart, columnStart, rowEnd, columnEnd];
+    const from = new _src.CellCoords(rowStart, columnStart);
+    const to = new _src.CellCoords(rowEnd, columnEnd);
+    return new _src.CellRange(from, from, to);
   };
 }
 
@@ -137,9 +133,12 @@ function transformSelectionToColumnDistance(selectionRanges) {
 
   // Iterate through all ranges and collect all column indexes which are not saved yet.
   (0, _array.arrayEach)(selectionRanges, selection => {
-    const [, columnStart,, columnEnd] = selectionSchemaNormalizer(selection);
-    const columnNonHeaderStart = Math.max(columnStart, 0);
-    const amount = columnEnd - columnNonHeaderStart + 1;
+    const {
+      from,
+      to
+    } = selectionSchemaNormalizer(selection);
+    const columnNonHeaderStart = Math.max(from.col, 0);
+    const amount = to.col - columnNonHeaderStart + 1;
     (0, _array.arrayEach)(Array.from(new Array(amount), (_, i) => columnNonHeaderStart + i), index => {
       if (!unorderedIndexes.has(index)) {
         unorderedIndexes.add(index);
@@ -182,9 +181,12 @@ function transformSelectionToRowDistance(selectionRanges) {
 
   // Iterate through all ranges and collect all column indexes which are not saved yet.
   (0, _array.arrayEach)(selectionRanges, selection => {
-    const [rowStart,, rowEnd] = selectionSchemaNormalizer(selection);
-    const rowNonHeaderStart = Math.max(rowStart, 0);
-    const amount = rowEnd - rowNonHeaderStart + 1;
+    const {
+      from,
+      to
+    } = selectionSchemaNormalizer(selection);
+    const rowNonHeaderStart = Math.max(from.row, 0);
+    const amount = to.row - rowNonHeaderStart + 1;
     (0, _array.arrayEach)(Array.from(new Array(amount), (_, i) => rowNonHeaderStart + i), index => {
       if (!unorderedIndexes.has(index)) {
         unorderedIndexes.add(index);
@@ -203,17 +205,4 @@ function transformSelectionToRowDistance(selectionRanges) {
     return acc;
   }, []);
   return normalizedRowRanges;
-}
-
-/**
- * Check if passed value can be treated as valid cell coordinate. The second argument is
- * used to check if the value doesn't exceed the defined max table rows/columns count.
- *
- * @param {number} coord The coordinate to validate (row index or column index).
- * @param {number} maxTableItemsCount The value that declares the maximum coordinate that is still validatable.
- * @returns {boolean}
- */
-function isValidCoord(coord) {
-  let maxTableItemsCount = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : Infinity;
-  return typeof coord === 'number' && coord >= 0 && coord < maxTableItemsCount;
 }

package/selection/utils.mjs

@@ -1,6 +1,6 @@
 import "core-js/modules/es.error.cause.js";
 import "core-js/modules/es.array.push.js";
-import { CellRange } from "./../3rdparty/walkontable/src/index.mjs";
+import { CellRange, CellCoords } from "./../3rdparty/walkontable/src/index.mjs";
 import { arrayEach, arrayReduce } from "./../helpers/array.mjs";
 import { isUndefined } from "./../helpers/mixed.mjs";
 export const SELECTION_TYPE_UNRECOGNIZED = 0;
@@ -98,7 +98,9 @@ export function normalizeSelectionFactory(type) {
       rowEnd = Math.max(origRowStart, origRowEnd);
       columnEnd = Math.max(origColumnStart, origColumnEnd);
     }
-    return [rowStart, columnStart, rowEnd, columnEnd];
+    const from = new CellCoords(rowStart, columnStart);
+    const to = new CellCoords(rowEnd, columnEnd);
+    return new CellRange(from, from, to);
   };
 }
 
@@ -124,9 +126,12 @@ export function transformSelectionToColumnDistance(selectionRanges) {
 
   // Iterate through all ranges and collect all column indexes which are not saved yet.
   arrayEach(selectionRanges, selection => {
-    const [, columnStart,, columnEnd] = selectionSchemaNormalizer(selection);
-    const columnNonHeaderStart = Math.max(columnStart, 0);
-    const amount = columnEnd - columnNonHeaderStart + 1;
+    const {
+      from,
+      to
+    } = selectionSchemaNormalizer(selection);
+    const columnNonHeaderStart = Math.max(from.col, 0);
+    const amount = to.col - columnNonHeaderStart + 1;
     arrayEach(Array.from(new Array(amount), (_, i) => columnNonHeaderStart + i), index => {
       if (!unorderedIndexes.has(index)) {
         unorderedIndexes.add(index);
@@ -169,9 +174,12 @@ export function transformSelectionToRowDistance(selectionRanges) {
 
   // Iterate through all ranges and collect all column indexes which are not saved yet.
   arrayEach(selectionRanges, selection => {
-    const [rowStart,, rowEnd] = selectionSchemaNormalizer(selection);
-    const rowNonHeaderStart = Math.max(rowStart, 0);
-    const amount = rowEnd - rowNonHeaderStart + 1;
+    const {
+      from,
+      to
+    } = selectionSchemaNormalizer(selection);
+    const rowNonHeaderStart = Math.max(from.row, 0);
+    const amount = to.row - rowNonHeaderStart + 1;
     arrayEach(Array.from(new Array(amount), (_, i) => rowNonHeaderStart + i), index => {
       if (!unorderedIndexes.has(index)) {
         unorderedIndexes.add(index);
@@ -190,17 +198,4 @@ export function transformSelectionToRowDistance(selectionRanges) {
     return acc;
   }, []);
   return normalizedRowRanges;
-}
-
-/**
- * Check if passed value can be treated as valid cell coordinate. The second argument is
- * used to check if the value doesn't exceed the defined max table rows/columns count.
- *
- * @param {number} coord The coordinate to validate (row index or column index).
- * @param {number} maxTableItemsCount The value that declares the maximum coordinate that is still validatable.
- * @returns {boolean}
- */
-export function isValidCoord(coord) {
-  let maxTableItemsCount = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : Infinity;
-  return typeof coord === 'number' && coord >= 0 && coord < maxTableItemsCount;
 }

package/settings.d.ts

@@ -93,6 +93,7 @@ export interface GridSettings extends Events {
   allowInvalid?: boolean;
   allowRemoveColumn?: boolean;
   allowRemoveRow?: boolean;
+  ariaTags?: boolean;
   autoColumnSize?: AutoColumnSizeSettings;
   autoRowSize?: AutoRowSizeSettings;
   autoWrapCol?: boolean;
@@ -124,6 +125,7 @@ export interface GridSettings extends Events {
   dateFormat?: string;
   datePickerConfig?: PikadayOptions;
   defaultDate?: string;
+  disableTabNavigation?: boolean;
   disableVisualSelection?: boolean | 'current' | 'area' | 'header' | Array<'current' | 'area' | 'header'>;
   dragToScroll?: boolean;
   dropdownMenu?: DropdownMenuSettings;
@@ -144,6 +146,7 @@ export interface GridSettings extends Events {
   hiddenColumns?: HiddenColumnsSettings;
   hiddenRows?: HiddenRowsSettings;
   invalidCellClassName?: string;
+  imeFastEdit?: boolean;
   isEmptyCol?: (this: Core, col: number) => boolean;
   isEmptyRow?: (this: Core, row: number) => boolean;
   label?: LabelOptions;
@@ -164,6 +167,7 @@ export interface GridSettings extends Events {
   minSpareCols?: number;
   minSpareRows?: number;
   multiColumnSorting?: MultiColumnSortingSettings;
+  navigableHeaders?: boolean;
   nestedHeaders?: NestedHeadersSettings;
   nestedRows?: boolean;
   noWordWrapClassName?: string;

package/shortcutContexts/commands/editor/closeAndSave.js

@@ -0,0 +1,11 @@
+"use strict";
+
+exports.__esModule = true;
+const command = exports.command = {
+  name: 'editorCloseAndSave',
+  callback(hot, event, keys) {
+    const editorManager = hot._getEditorManager();
+    editorManager.closeEditorAndSaveChanges(hot.getShortcutManager().isCtrlPressed());
+    editorManager.moveSelectionAfterEnter(keys.includes('shift'));
+  }
+};

package/shortcutContexts/commands/editor/closeAndSave.mjs

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

package/shortcutContexts/commands/editor/closeWithoutSaving.js

@@ -0,0 +1,11 @@
+"use strict";
+
+exports.__esModule = true;
+const command = exports.command = {
+  name: 'editorCloseWithoutSaving',
+  callback(hot) {
+    const editorManager = hot._getEditorManager();
+    editorManager.closeEditorAndRestoreOriginalValue(hot.getShortcutManager().isCtrlPressed());
+    editorManager.activeEditor.focus();
+  }
+};

package/shortcutContexts/commands/editor/closeWithoutSaving.mjs

@@ -0,0 +1,8 @@
+export const command = {
+  name: 'editorCloseWithoutSaving',
+  callback(hot) {
+    const editorManager = hot._getEditorManager();
+    editorManager.closeEditorAndRestoreOriginalValue(hot.getShortcutManager().isCtrlPressed());
+    editorManager.activeEditor.focus();
+  }
+};

package/shortcutContexts/commands/editor/fastOpen.js

@@ -0,0 +1,15 @@
+"use strict";
+
+exports.__esModule = true;
+const command = exports.command = {
+  name: 'editorFastOpen',
+  callback(hot, event) {
+    const {
+      highlight
+    } = hot.getSelectedRangeLast();
+    if (highlight.isHeader()) {
+      return;
+    }
+    hot._getEditorManager().openEditor(null, event, true);
+  }
+};

package/shortcutContexts/commands/editor/fastOpen.mjs

@@ -0,0 +1,12 @@
+export const command = {
+  name: 'editorFastOpen',
+  callback(hot, event) {
+    const {
+      highlight
+    } = hot.getSelectedRangeLast();
+    if (highlight.isHeader()) {
+      return;
+    }
+    hot._getEditorManager().openEditor(null, event, true);
+  }
+};