handsontable 0.0.0-next-a1e4b4f-20230628 → 0.0.0-next-e697250-20230707

package/core.mjs

@@ -1,11 +1,4 @@
-import "core-js/modules/es.symbol.js";
-import "core-js/modules/es.symbol.description.js";
-import "core-js/modules/es.symbol.iterator.js";
-import "core-js/modules/es.function.name.js";
-import "core-js/modules/es.object.freeze.js";
-var _templateObject, _templateObject2;
 function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
-function _taggedTemplateLiteral(strings, raw) { if (!raw) { raw = strings.slice(0); } return Object.freeze(Object.defineProperties(strings, { raw: { value: Object.freeze(raw) } })); }
 function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
 function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
 function _iterableToArrayLimit(arr, i) { var _i = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"]; if (null != _i) { var _s, _e, _x, _r, _arr = [], _n = !0, _d = !1; try { if (_x = (_i = _i.call(arr)).next, 0 === i) { if (Object(_i) !== _i) return; _n = !1; } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0); } catch (err) { _d = !0, _e = err; } finally { try { if (!_n && null != _i.return && (_r = _i.return(), Object(_r) !== _r)) return; } finally { if (_d) throw _e; } } return _arr; } }
@@ -22,33 +15,35 @@ import "core-js/modules/es.set.js";
 import "core-js/modules/es.string.iterator.js";
 import "core-js/modules/web.dom-collections.iterator.js";
 import "core-js/modules/es.array.includes.js";
+import "core-js/modules/es.array.concat.js";
 import "core-js/modules/es.array.sort.js";
 import "core-js/modules/es.array.splice.js";
 import "core-js/modules/es.number.is-integer.js";
 import "core-js/modules/es.number.constructor.js";
 import "core-js/modules/es.array.slice.js";
-import "core-js/modules/es.array.concat.js";
 import "core-js/modules/es.array.fill.js";
 import "core-js/modules/es.array.map.js";
 import "core-js/modules/es.regexp.exec.js";
 import "core-js/modules/es.string.replace.js";
+import "core-js/modules/es.array.filter.js";
 import "core-js/modules/es.array.from.js";
 import "core-js/modules/es.array.index-of.js";
 import "core-js/modules/es.array.reverse.js";
 import "core-js/modules/web.dom-collections.for-each.js";
 import "core-js/modules/web.timers.js";
 import "core-js/modules/web.immediate.js";
-import "core-js/modules/es.map.js";
+import "core-js/modules/es.symbol.js";
+import "core-js/modules/es.symbol.description.js";
+import "core-js/modules/es.symbol.iterator.js";
+import "core-js/modules/es.regexp.to-string.js";
+import "core-js/modules/es.function.name.js";
 import { addClass, empty, observeVisibilityChangeOnce, removeClass } from "./helpers/dom/element.mjs";
 import { isFunction } from "./helpers/function.mjs";
 import { isDefined, isUndefined, isRegExp, _injectProductInfo, isEmpty } from "./helpers/mixed.mjs";
 import { isMobileBrowser, isIpadOS } from "./helpers/browser.mjs";
-import { warn } from "./helpers/console.mjs";
-import { toSingleLine } from "./helpers/templateLiteralTag.mjs";
 import EditorManager from "./editorManager.mjs";
 import EventManager from "./eventManager.mjs";
 import { deepClone, duckSchema, isObjectEqual, isObject, deepObjectSize, hasOwnProperty, createObjectPropListener, objectEach } from "./helpers/object.mjs";
-import { FocusManager } from "./focusManager.mjs";
 import { arrayMap, arrayEach, arrayReduce, getDifferenceOfArrays, stringToArray, pivot } from "./helpers/array.mjs";
 import { instanceToHTML } from "./utils/parseTable.mjs";
 import { getPlugin, getPluginsNames } from "./plugins/registry.mjs";
@@ -70,8 +65,15 @@ import { Selection } from "./selection/index.mjs";
 import { MetaManager, DynamicCellMetaMod, ExtendMetaPropertiesMod, replaceData } from "./dataMap/index.mjs";
 import { createUniqueMap } from "./utils/dataStructures/uniqueMap.mjs";
 import { createShortcutManager } from "./shortcuts/index.mjs";
-var SHORTCUTS_GROUP = 'gridDefault';
+import { registerAllShortcutContexts } from "./shortcutContexts/index.mjs";
 var activeGuid = null;
+
+/**
+ * A set of deprecated feature names.
+ *
+ * @type {Set<string>}
+ */
+// eslint-disable-next-line no-unused-vars
 var deprecationWarns = new Set();
 
 /* eslint-disable jsdoc/require-description-complete-sentence */
@@ -103,7 +105,7 @@ var deprecationWarns = new Set();
  * :::
  *
  * ::: only-for react
- * ```jsx{3,7,13}
+ * ```jsx
  * import { useRef } from 'react';
  *
  * const hotTableComponent = useRef(null);
@@ -135,7 +137,6 @@ export default function Core(rootElement, userSettings) {
   var dataSource;
   var grid;
   var editorManager;
-  var focusManager;
   var firstRun = true;
   if (hasValidParameter(rootInstanceSymbol)) {
     registerAsRootInstance(this);
@@ -260,6 +261,12 @@ export default function Core(rootElement, userSettings) {
    * @type {IndexMapper}
    */
   this.rowIndexMapper = new IndexMapper();
+  this.columnIndexMapper.addLocalHook('indexesSequenceChange', function (source) {
+    instance.runHooks('afterColumnSequenceChange', source);
+  });
+  this.rowIndexMapper.addLocalHook('indexesSequenceChange', function (source) {
+    instance.runHooks('afterRowSequenceChange', source);
+  });
   dataSource = new DataSource(instance);
   if (!this.rootElement.id || this.rootElement.id.substring(0, 3) === 'ht_') {
     this.rootElement.id = this.guid; // if root element does not have an id, assign a random id
@@ -282,12 +289,8 @@ export default function Core(rootElement, userSettings) {
   };
 
   var selection = new Selection(tableMeta, {
-    rowIndexMapper: function rowIndexMapper() {
-      return instance.rowIndexMapper;
-    },
-    columnIndexMapper: function columnIndexMapper() {
-      return instance.columnIndexMapper;
-    },
+    rowIndexMapper: instance.rowIndexMapper,
+    columnIndexMapper: instance.columnIndexMapper,
     countCols: function countCols() {
       return instance.countCols();
     },
@@ -300,10 +303,10 @@ export default function Core(rootElement, userSettings) {
     isEditorOpened: function isEditorOpened() {
       return instance.getActiveEditor() ? instance.getActiveEditor().isOpened() : false;
     },
-    countColsTranslated: function countColsTranslated() {
+    countRenderableColumns: function countRenderableColumns() {
       return _this.view.countRenderableColumns();
     },
-    countRowsTranslated: function countRowsTranslated() {
+    countRenderableRows: function countRenderableRows() {
       return _this.view.countRenderableRows();
     },
     countRowHeaders: function countRowHeaders() {
@@ -344,12 +347,6 @@ export default function Core(rootElement, userSettings) {
   });
   this.selection.addLocalHook('beforeSetRangeEnd', function (cellCoords) {
     _this.runHooks('beforeSetRangeEnd', cellCoords);
-    if (cellCoords.row < 0) {
-      cellCoords.row = _this.view._wt.wtTable.getFirstVisibleRow();
-    }
-    if (cellCoords.col < 0) {
-      cellCoords.col = _this.view._wt.wtTable.getFirstVisibleColumn();
-    }
   });
   this.selection.addLocalHook('afterSetRangeEnd', function (cellCoords) {
     var preventScrolling = createObjectPropListener(false);
@@ -375,7 +372,14 @@ export default function Core(rootElement, userSettings) {
     if (scrollToCell !== false) {
       if (!isSelectedByAnyHeader) {
         if (currentSelectedRange && !_this.selection.isMultiple()) {
-          _this.view.scrollViewport(visualToRenderableCoords(currentSelectedRange.from));
+          var renderableCoords = visualToRenderableCoords(currentSelectedRange.from);
+          if (renderableCoords.row < 0 && renderableCoords.col >= 0) {
+            _this.view.scrollViewportHorizontally(renderableCoords.col);
+          } else if (renderableCoords.col < 0 && renderableCoords.row >= 0) {
+            _this.view.scrollViewportVertically(renderableCoords.row);
+          } else {
+            _this.view.scrollViewport(renderableCoords);
+          }
         } else {
           _this.view.scrollViewport(visualToRenderableCoords(cellCoords));
         }
@@ -416,6 +420,30 @@ export default function Core(rootElement, userSettings) {
       isMultiple.value = changedIsMultiple;
     }
   });
+  this.selection.addLocalHook('beforeSelectColumns', function () {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    return _this.runHooks.apply(_this, ['beforeSelectColumns'].concat(args));
+  });
+  this.selection.addLocalHook('afterSelectColumns', function () {
+    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+      args[_key2] = arguments[_key2];
+    }
+    return _this.runHooks.apply(_this, ['afterSelectColumns'].concat(args));
+  });
+  this.selection.addLocalHook('beforeSelectRows', function () {
+    for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+      args[_key3] = arguments[_key3];
+    }
+    return _this.runHooks.apply(_this, ['beforeSelectRows'].concat(args));
+  });
+  this.selection.addLocalHook('afterSelectRows', function () {
+    for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
+      args[_key4] = arguments[_key4];
+    }
+    return _this.runHooks.apply(_this, ['afterSelectRows'].concat(args));
+  });
   this.selection.addLocalHook('beforeModifyTransformStart', function (cellCoordsDelta) {
     _this.runHooks('modifyTransformStart', cellCoordsDelta);
   });
@@ -501,13 +529,6 @@ export default function Core(rootElement, userSettings) {
 
       /* eslint-disable no-case-declarations */
       switch (action) {
-        case 'insert_row':
-          // backward compatibility
-          if (!deprecationWarns.has(action)) {
-            deprecationWarns.add(action);
-            warn(toSingleLine(_templateObject || (_templateObject = _taggedTemplateLiteral(["The `", "` action of the `alter()` method is deprecated and will be removed \n                              in the next major release of Handsontable. Use the `insert_row_above` action instead."], ["The \\`", "\\` action of the \\`alter()\\` method is deprecated and will be removed\\x20\n                              in the next major release of Handsontable. Use the \\`insert_row_above\\` action instead."])), action));
-          }
-        // falls through
         case 'insert_row_below':
         case 'insert_row_above':
           var numberOfSourceRows = instance.countSourceRows();
@@ -518,11 +539,9 @@ export default function Core(rootElement, userSettings) {
           // `above` is the default behavior for creating new rows
           var insertRowMode = action === 'insert_row_below' ? 'below' : 'above';
 
-          // The line below ensures backward compatibility of the `alter()` method's `insert_row` action.
-          // Calling the `insert_row` action with no arguments adds a new row at the end of the data set.
           // Calling the `insert_row_above` action adds a new row at the beginning of the data set.
           // eslint-disable-next-line no-param-reassign
-          index = (_index = index) !== null && _index !== void 0 ? _index : action === 'insert_row' || insertRowMode === 'below' ? numberOfSourceRows : 0;
+          index = (_index = index) !== null && _index !== void 0 ? _index : insertRowMode === 'below' ? numberOfSourceRows : 0;
           var _datamap$createRow = datamap.createRow(index, amount, {
               source: source,
               mode: insertRowMode
@@ -561,23 +580,14 @@ export default function Core(rootElement, userSettings) {
           }
 
           break;
-        case 'insert_col':
-          // backward compatibility
-          if (!deprecationWarns.has(action)) {
-            deprecationWarns.add(action);
-            warn(toSingleLine(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["The `", "` action of the `alter()` method is deprecated and will be removed \n                              in the next major release of Handsontable. Use the `insert_col_start` action instead."], ["The \\`", "\\` action of the \\`alter()\\` method is deprecated and will be removed\\x20\n                              in the next major release of Handsontable. Use the \\`insert_col_start\\` action instead."])), action));
-          }
-        // falls through
         case 'insert_col_start':
         case 'insert_col_end':
           // "start" is a default behavior for creating new columns
           var insertColumnMode = action === 'insert_col_end' ? 'end' : 'start';
 
-          // The line below ensures backward compatibility of the `alter()` method's `insert_col` action.
-          // Calling the `insert_col` action with no arguments adds a new column to the right of the data set.
           // Calling the `insert_col_start` action adds a new column to the left of the data set.
           // eslint-disable-next-line no-param-reassign
-          index = (_index2 = index) !== null && _index2 !== void 0 ? _index2 : action === 'insert_col' || insertColumnMode === 'end' ? instance.countSourceCols() : 0;
+          index = (_index2 = index) !== null && _index2 !== void 0 ? _index2 : insertColumnMode === 'end' ? instance.countSourceCols() : 0;
           var _datamap$createCol = datamap.createCol(index, amount, {
               source: source,
               mode: insertColumnMode
@@ -848,13 +858,9 @@ export default function Core(rootElement, userSettings) {
      * @param {object} [end] End selection position (only for drag-down mode). Visual indexes.
      * @param {string} [source="populateFromArray"] Source information string.
      * @param {string} [method="overwrite"] Populate method. Possible options: `shift_down`, `shift_right`, `overwrite`.
-     * @param {string} direction (left|right|up|down) String specifying the direction.
-     * @param {Array} deltas The deltas array. A difference between values of adjacent cells.
-     *                       Useful **only** when the type of handled cells is `numeric`.
      * @returns {object|undefined} Ending td in pasted area (only if any cell was changed).
      */
-    populateFromArray: function populateFromArray(start, input, end, source, method, direction, deltas) {
-      // TODO: either remove or implement the `direction` argument. Currently it's not working at all.
+    populateFromArray: function populateFromArray(start, input, end, source, method) {
       var r;
       var rlen;
       var c;
@@ -942,11 +948,6 @@ export default function Core(rootElement, userSettings) {
           // overwrite and other not specified options
           current.row = start.row;
           current.col = start.col;
-          var selected = {
-            // selected range
-            row: end && start ? end.row - start.row + 1 : 1,
-            col: end && start ? end.col - start.col + 1 : 1
-          };
           var skippedRow = 0;
           var skippedColumn = 0;
           var pushData = true;
@@ -1007,16 +1008,6 @@ export default function Core(rootElement, userSettings) {
               var visualColumn = c - skippedColumn;
               var value = getInputValue(visualRow, visualColumn);
               var orgValue = instance.getDataAtCell(current.row, current.col);
-              var index = {
-                row: visualRow,
-                col: visualColumn
-              };
-              if (source === 'Autofill.fill') {
-                var result = instance.runHooks('beforeAutofillInsidePopulate', index, direction, input, deltas, {}, selected);
-                if (result) {
-                  value = isUndefined(result.value) ? value : result.value;
-                }
-              }
               if (value !== null && _typeof(value) === 'object') {
                 // when 'value' is array and 'orgValue' is null, set 'orgValue' to
                 // an empty array so that the null value can be compared to 'value'
@@ -1110,7 +1101,6 @@ export default function Core(rootElement, userSettings) {
     this.updateSettings(tableMeta, true);
     this.view = new TableView(this);
     editorManager = EditorManager.getInstance(instance, tableMeta, selection);
-    focusManager = new FocusManager(instance);
     instance.runHooks('init');
     this.forceFullRender = true; // used when data was changed
     this.view.render();
@@ -1187,15 +1177,8 @@ export default function Core(rootElement, userSettings) {
       return;
     }
     var activeEditor = instance.getActiveEditor();
-    var beforeChangeResult = instance.runHooks('beforeChange', changes, source || 'edit');
-    var shouldBeCanceled = true;
-    if (beforeChangeResult === false) {
-      if (activeEditor) {
-        activeEditor.cancelChanges();
-      }
-      return;
-    }
     var waitingForValidator = new ValidatorsQueue();
+    var shouldBeCanceled = true;
     waitingForValidator.onQueueEmpty = function (isValid) {
       if (activeEditor && shouldBeCanceled) {
         activeEditor.cancelChanges();
@@ -1204,43 +1187,37 @@ export default function Core(rootElement, userSettings) {
     };
 
     for (var i = changes.length - 1; i >= 0; i--) {
-      if (changes[i] === null) {
-        changes.splice(i, 1);
-      } else {
-        var _changes$i = _slicedToArray(changes[i], 4),
-          row = _changes$i[0],
-          prop = _changes$i[1],
-          newValue = _changes$i[3];
-        var col = datamap.propToCol(prop);
-        var cellProperties = instance.getCellMeta(row, col);
-        if (cellProperties.type === 'numeric' && typeof newValue === 'string' && isNumericLike(newValue)) {
-          changes[i][3] = getParsedNumber(newValue);
-        }
+      var _changes$i = _slicedToArray(changes[i], 4),
+        row = _changes$i[0],
+        prop = _changes$i[1],
+        newValue = _changes$i[3];
+      var col = datamap.propToCol(prop);
+      var cellProperties = instance.getCellMeta(row, col);
+      if (cellProperties.type === 'numeric' && typeof newValue === 'string' && isNumericLike(newValue)) {
+        changes[i][3] = getParsedNumber(newValue);
+      }
 
-        /* eslint-disable no-loop-func */
-        if (instance.getCellValidator(cellProperties)) {
-          waitingForValidator.addValidatorToQueue();
-          instance.validateCell(changes[i][3], cellProperties, function (index, cellPropertiesReference) {
-            return function (result) {
-              if (typeof result !== 'boolean') {
-                throw new Error('Validation error: result is not boolean');
-              }
-              if (result === false && cellPropertiesReference.allowInvalid === false) {
-                shouldBeCanceled = false;
-                changes.splice(index, 1); // cancel the change
-                cellPropertiesReference.valid = true; // we cancelled the change, so cell value is still valid
-
-                var cell = instance.getCell(cellPropertiesReference.visualRow, cellPropertiesReference.visualCol);
-                if (cell !== null) {
-                  removeClass(cell, tableMeta.invalidCellClassName);
-                }
-                // index -= 1;
+      /* eslint-disable no-loop-func */
+      if (instance.getCellValidator(cellProperties)) {
+        waitingForValidator.addValidatorToQueue();
+        instance.validateCell(changes[i][3], cellProperties, function (index, cellPropertiesReference) {
+          return function (result) {
+            if (typeof result !== 'boolean') {
+              throw new Error('Validation error: result is not boolean');
+            }
+            if (result === false && cellPropertiesReference.allowInvalid === false) {
+              shouldBeCanceled = false;
+              changes.splice(index, 1); // cancel the change
+              cellPropertiesReference.valid = true; // we cancelled the change, so cell value is still valid
+
+              var cell = instance.getCell(cellPropertiesReference.visualRow, cellPropertiesReference.visualCol);
+              if (cell !== null) {
+                removeClass(cell, tableMeta.invalidCellClassName);
               }
-
-              waitingForValidator.removeValidatorFormQueue();
-            };
-          }(i, cellProperties), source);
-        }
+            }
+            waitingForValidator.removeValidatorFormQueue();
+          };
+        }(i, cellProperties), source);
       }
     }
     waitingForValidator.checkIfQueueIsEmpty();
@@ -1430,6 +1407,31 @@ export default function Core(rootElement, userSettings) {
     return [[row, propOrCol, value]];
   }
 
+  /**
+   * Process changes prepared for applying to the dataset (unifying list of changes, closing an editor - when needed,
+   * calling a hook).
+   *
+   * @private
+   * @param {Array} changes Array of changes in format `[[row, col, value],...]`.
+   * @param {string} [source] String that identifies how this change will be described in the changes array (useful in afterChange or beforeChange callback). Set to 'edit' if left empty.
+   * @returns {Array} List of changes finally applied to the dataset.
+   */
+  function processChanges(changes, source) {
+    var activeEditor = instance.getActiveEditor();
+    var beforeChangeResult = instance.runHooks('beforeChange', changes, source || 'edit');
+    // The `beforeChange` hook could add a `null` for purpose of cancelling some dataset's change.
+    var filteredChanges = changes.filter(function (change) {
+      return change !== null;
+    });
+    if (beforeChangeResult === false || filteredChanges.length === 0) {
+      if (activeEditor) {
+        activeEditor.cancelChanges();
+      }
+      return [];
+    }
+    return filteredChanges;
+  }
+
   /**
    * @description
    * Set new value to a cell. To change many cells at once (recommended way), pass an array of `changes` in format
@@ -1467,9 +1469,10 @@ export default function Core(rootElement, userSettings) {
     if (!changeSource && _typeof(row) === 'object') {
       changeSource = column;
     }
-    instance.runHooks('afterSetDataAtCell', changes, changeSource);
-    validateChanges(changes, changeSource, function () {
-      applyChanges(changes, changeSource);
+    var processedChanges = processChanges(changes, source);
+    instance.runHooks('afterSetDataAtCell', processedChanges, changeSource);
+    validateChanges(processedChanges, changeSource, function () {
+      applyChanges(processedChanges, changeSource);
     });
   };
 
@@ -1497,9 +1500,10 @@ export default function Core(rootElement, userSettings) {
     if (!changeSource && _typeof(row) === 'object') {
       changeSource = prop;
     }
-    instance.runHooks('afterSetDataAtRowProp', changes, changeSource);
-    validateChanges(changes, changeSource, function () {
-      applyChanges(changes, changeSource);
+    var processedChanges = processChanges(changes, source);
+    instance.runHooks('afterSetDataAtRowProp', processedChanges, changeSource);
+    validateChanges(processedChanges, changeSource, function () {
+      applyChanges(processedChanges, changeSource);
     });
   };
 
@@ -1574,18 +1578,15 @@ export default function Core(rootElement, userSettings) {
    * @param {number} [endCol] End visual column index (use when you want to cut input when certain column is reached).
    * @param {string} [source=populateFromArray] Used to identify this call in the resulting events (beforeChange, afterChange).
    * @param {string} [method=overwrite] Populate method, possible values: `'shift_down'`, `'shift_right'`, `'overwrite'`.
-   * @param {string} direction Populate direction, possible values: `'left'`, `'right'`, `'up'`, `'down'`.
-   * @param {Array} deltas The deltas array. A difference between values of adjacent cells.
-   *                       Useful **only** when the type of handled cells is `numeric`.
    * @returns {object|undefined} Ending td in pasted area (only if any cell was changed).
    */
-  this.populateFromArray = function (row, column, input, endRow, endCol, source, method, direction, deltas) {
+  this.populateFromArray = function (row, column, input, endRow, endCol, source, method) {
     if (!(_typeof(input) === 'object' && _typeof(input[0]) === 'object')) {
       throw new Error('populateFromArray parameter `input` must be an array of arrays'); // API changed in 0.9-beta2, let's check if you use it correctly
     }
 
     var c = typeof endRow === 'number' ? instance._createCellCoords(endRow, endCol) : null;
-    return grid.populateFromArray(instance._createCellCoords(row, column), input, c, source, method, direction, deltas);
+    return grid.populateFromArray(instance._createCellCoords(row, column), input, c, source, method);
   };
 
   /**
@@ -1601,8 +1602,8 @@ export default function Core(rootElement, userSettings) {
    */
   this.spliceCol = function (column, index, amount) {
     var _datamap;
-    for (var _len = arguments.length, elements = new Array(_len > 3 ? _len - 3 : 0), _key = 3; _key < _len; _key++) {
-      elements[_key - 3] = arguments[_key];
+    for (var _len5 = arguments.length, elements = new Array(_len5 > 3 ? _len5 - 3 : 0), _key5 = 3; _key5 < _len5; _key5++) {
+      elements[_key5 - 3] = arguments[_key5];
     }
     return (_datamap = datamap).spliceCol.apply(_datamap, [column, index, amount].concat(elements));
   };
@@ -1620,8 +1621,8 @@ export default function Core(rootElement, userSettings) {
    */
   this.spliceRow = function (row, index, amount) {
     var _datamap2;
-    for (var _len2 = arguments.length, elements = new Array(_len2 > 3 ? _len2 - 3 : 0), _key2 = 3; _key2 < _len2; _key2++) {
-      elements[_key2 - 3] = arguments[_key2];
+    for (var _len6 = arguments.length, elements = new Array(_len6 > 3 ? _len6 - 3 : 0), _key6 = 3; _key6 < _len6; _key6++) {
+      elements[_key6 - 3] = arguments[_key6];
     }
     return (_datamap2 = datamap).spliceRow.apply(_datamap2, [row, index, amount].concat(elements));
   };
@@ -1717,6 +1718,9 @@ export default function Core(rootElement, userSettings) {
     }
     var changes = [];
     arrayEach(selection.getSelectedRange(), function (cellRange) {
+      if (cellRange.isSingleHeader()) {
+        return;
+      }
       var topStart = cellRange.getTopStartCorner();
       var bottomEnd = cellRange.getBottomEndCorner();
       rangeEach(topStart.row, bottomEnd.row, function (row) {
@@ -2446,11 +2450,13 @@ export default function Core(rootElement, userSettings) {
   };
 
   /**
-   * Get value from the selected cell.
+   * Gets the value of the currently focused cell.
+   *
+   * For column headers and row headers, returns `null`.
    *
    * @memberof Core#
    * @function getValue
-   * @returns {*} Value of selected cell.
+   * @returns {*} The value of the focused cell.
    */
   this.getValue = function () {
     var sel = instance.getSelectedLast();
@@ -2509,10 +2515,11 @@ export default function Core(rootElement, userSettings) {
    *  | `'insert_col_start'` | Inserts columns before the `index` column. | Inserts columns before the first column. |
    *  | `'insert_col_end'`   | Inserts columns after the `index` column. | Inserts columns after the last column. |
    *  | `'remove_col'`       | Removes columns, starting from the `index` column. | Removes columns, starting from the last column. |
-   *  | `'insert_row'` (<b>Deprecated</b>) |  Inserts rows above the `index` row. | Inserts rows below the last row. |
-   *  | `'insert_col'` (<b>Deprecated</b>) |  Inserts columns before the `index` column. | Inserts columns after the last column. |
    *
-   * The behavior of `'insert_col_start'`, `'insert_col_end'`, and `'insert_col'` depends on your [`layoutDirection`](@/api/options.md#layoutdirection).
+   * Additional information about `'insert_col_start'` and `'insert_col_end'`:
+   * - Their behavior depends on your [`layoutDirection`](@/api/options.md#layoutdirection).
+   * - If the provided `index` is higher than the actual number of columns, Handsontable doesn't generate
+   * the columns missing in between. Instead, the new columns are inserted next to the last column.
    *
    * @memberof Core#
    * @function alter
@@ -2524,8 +2531,6 @@ export default function Core(rootElement, userSettings) {
    *    <li> `'insert_col_start'` </li>
    *    <li> `'insert_col_end'` </li>
    *    <li> `'remove_col'` </li>
-   *    <li> `'insert_row'` (<b>Deprecated</b>) </li>
-   *    <li> `'insert_col'` (<b>Deprecated</b>) </li>
    * </ul>
    * @param {number|number[]} [index] A visual index of the row/column before or after which the new row/column will be
    *                                inserted or removed. Can also be an array of arrays, in format `[[index, amount],...]`.
@@ -2793,6 +2798,11 @@ export default function Core(rootElement, userSettings) {
    * __Note__: This method does not participate in data transformation. If the visual data of the table is reordered,
    * sorted or trimmed only physical indexes are correct.
    *
+   * __Note__: This method may return incorrect values for cells that contain
+   * [formulas](@/guides/formulas/formula-calculation.md). This is because `getSourceData()`
+   * operates on source data ([physical indexes](@/api/indexMapper.md)),
+   * whereas formulas operate on visual data (visual indexes).
+   *
    * @memberof Core#
    * @function getSourceData
    * @param {number} [row] From physical row index.
@@ -3025,8 +3035,8 @@ export default function Core(rootElement, userSettings) {
   this.spliceCellsMeta = function (visualIndex) {
     var _this5 = this;
     var deleteAmount = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-    for (var _len3 = arguments.length, cellMetaRows = new Array(_len3 > 2 ? _len3 - 2 : 0), _key3 = 2; _key3 < _len3; _key3++) {
-      cellMetaRows[_key3 - 2] = arguments[_key3];
+    for (var _len7 = arguments.length, cellMetaRows = new Array(_len7 > 2 ? _len7 - 2 : 0), _key7 = 2; _key7 < _len7; _key7++) {
+      cellMetaRows[_key7 - 2] = arguments[_key7];
     }
     if (cellMetaRows.length > 0 && !Array.isArray(cellMetaRows[0])) {
       throw new Error('The 3rd argument (cellMetaRows) has to be passed as an array of cell meta objects array.');
@@ -3142,7 +3152,13 @@ export default function Core(rootElement, userSettings) {
   };
 
   /**
-   * Checks if the data format and config allows user to modify the column structure.
+   * Checks if your [data format](@/guides/getting-started/binding-to-data.md#compatible-data-types)
+   * and [configuration options](@/guides/getting-started/configuration-options.md)
+   * allow for changing the number of columns.
+   *
+   * Returns `false` when your data is an array of objects,
+   * or when you use the [`columns`](@/api/options.md#columns) option.
+   * Otherwise, returns `true`.
    *
    * @memberof Core#
    * @function isColumnModificationAllowed
@@ -3225,10 +3241,16 @@ export default function Core(rootElement, userSettings) {
   };
 
   /**
-   * Validates all cells using their validator functions and calls callback when finished.
+   * Validates every cell in the data set,
+   * using a [validator function](@/guides/cell-functions/cell-validator.md) configured for each cell.
    *
-   * If one of the cells is invalid, the callback will be fired with `'valid'` arguments as `false` - otherwise it
-   * would equal `true`.
+   * Doesn't validate cells that are currently [trimmed](@/guides/rows/row-trimming.md),
+   * [hidden](@/guides/rows/row-hiding.md), or [filtered](@/guides/columns/column-filter.md),
+   * as such cells are not included in the data set until you bring them back again.
+   *
+   * After the validation, the `callback` function is fired, with the `valid` argument set to:
+   * - `true` for valid cells
+   * - `false` for invalid cells
    *
    * @memberof Core#
    * @function validateCells
@@ -3711,7 +3733,7 @@ export default function Core(rootElement, userSettings) {
   /**
    * Returns the number of rendered row headers.
    *
-   * @since 13.0.0
+   * @since 14.0.0
    * @memberof Core#
    * @function countRowHeaders
    * @returns {number} Number of row headers.
@@ -3723,7 +3745,7 @@ export default function Core(rootElement, userSettings) {
   /**
    * Returns the number of rendered column headers.
    *
-   * @since 13.0.0
+   * @since 14.0.0
    * @memberof Core#
    * @function countColHeaders
    * @returns {number} Number of column headers.
@@ -3936,6 +3958,10 @@ export default function Core(rootElement, userSettings) {
    * hot.selectColumns('id');
    * // Select range of columns using visual indexes.
    * hot.selectColumns(1, 4);
+   * // Select range of columns using visual indexes and mark the first header as highlighted.
+   * hot.selectColumns(1, 2, -1);
+   * // Select range of columns using visual indexes and mark the second cell as highlighted.
+   * hot.selectColumns(2, 1, 1);
    * // Select range of columns using column properties.
    * hot.selectColumns('id', 'last_name');
    * ```
@@ -3946,11 +3972,15 @@ export default function Core(rootElement, userSettings) {
    * @param {number} startColumn The visual column index from which the selection starts.
    * @param {number} [endColumn=startColumn] The visual column index to which the selection finishes. If `endColumn`
    *                                         is not defined the column defined by `startColumn` will be selected.
+   * @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} `true` if selection was successful, `false` otherwise.
    */
   this.selectColumns = function (startColumn) {
     var endColumn = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : startColumn;
-    return selection.selectColumns(startColumn, endColumn);
+    var focusPosition = arguments.length > 2 ? arguments[2] : undefined;
+    return selection.selectColumns(startColumn, endColumn, focusPosition);
   };
 
   /**
@@ -3960,8 +3990,12 @@ export default function Core(rootElement, userSettings) {
    * ```js
    * // Select row using visual index.
    * hot.selectRows(1);
-   * // Select range of rows using visual indexes.
+   * // select a range of rows, using visual indexes.
    * hot.selectRows(1, 4);
+   * // select a range of rows, using visual indexes, and mark the header as highlighted.
+   * hot.selectRows(1, 2, -1);
+   * // Select range of rows using visual indexes and mark the second cell as highlighted.
+   * hot.selectRows(2, 1, 1);
    * ```
    *
    * @memberof Core#
@@ -3970,11 +4004,15 @@ export default function Core(rootElement, userSettings) {
    * @param {number} startRow The visual row index from which the selection starts.
    * @param {number} [endRow=startRow] The visual row index to which the selection finishes. If `endRow`
    *                                   is not defined the row defined by `startRow` will be selected.
+   * @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} `true` if selection was successful, `false` otherwise.
    */
   this.selectRows = function (startRow) {
     var endRow = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : startRow;
-    return selection.selectRows(startRow, endRow);
+    var focusPosition = arguments.length > 2 ? arguments[2] : undefined;
+    return selection.selectRows(startRow, endRow, focusPosition);
   };
 
   /**
@@ -3993,9 +4031,16 @@ export default function Core(rootElement, userSettings) {
    * The previous selection is overwritten.
    *
    * ```js
-   * // select all cells in the table, including all headers
+   * // select all cells in the table, including all headers and the corner cell
    * hot.selectAll();
    *
+   * // select all cells in the table, including row headers but excluding the corner cell
+   * hot.selectAll(true, false);
+   *
+   * // select all cells in the table, including all headers and the corner cell, but move the focus
+   * // highlight to position -2, -1
+   * hot.selectAll(-2, -1);
+   *
    * // select all cells in the table, without headers
    * hot.selectAll(false);
    * ```
@@ -4003,15 +4048,20 @@ export default function Core(rootElement, userSettings) {
    * @since 0.38.2
    * @memberof Core#
    * @function selectAll
-   * @param {boolean} [includeHeaders=true] `true`: include all row, column and corner headers.
-   * `false`: don't include any 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 {{row: number, col: number}} [focusPosition] The argument allows changing the cell/header
+   * focus position. The value takes an object with a `row` and `col` properties (visual indexes)
+   * from -N to N, where negative values point to the headers and positive values point to the cell range.
    */
   this.selectAll = function () {
-    var includeHeaders = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
-    var includeRowHeaders = includeHeaders && this.hasRowHeaders();
-    var includeColumnHeaders = includeHeaders && this.hasColHeaders();
+    var includeRowHeaders = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+    var includeColumnHeaders = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : includeRowHeaders;
+    var focusPosition = arguments.length > 2 ? arguments[2] : undefined;
     preventScrollingToCell = true;
-    selection.selectAll(includeRowHeaders, includeColumnHeaders);
+    selection.selectAll(includeRowHeaders, includeColumnHeaders, focusPosition);
     preventScrollingToCell = false;
   };
   var getIndexToScroll = function getIndexToScroll(indexMapper, visualIndex) {
@@ -4069,6 +4119,35 @@ export default function Core(rootElement, userSettings) {
     return false;
   };
 
+  /**
+   * Scrolls the viewport to coordinates specified by the currently focused cell.
+   *
+   * @since 14.0.0
+   * @memberof Core#
+   * @function scrollToFocusedCell
+   * @param {Function} callback The callback function to call after the viewport is scrolled.
+   */
+  this.scrollToFocusedCell = function () {
+    var callback = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : function () {};
+    if (!this.selection.isSelected()) {
+      return;
+    }
+    this.addHookOnce('afterScroll', callback);
+    var _this$getSelectedRang = this.getSelectedRangeLast(),
+      highlight = _this$getSelectedRang.highlight;
+    var renderableRowIndex = this.rowIndexMapper.getRenderableFromVisualIndex(highlight.row);
+    var renderableColumnIndex = this.columnIndexMapper.getRenderableFromVisualIndex(highlight.col);
+    var isScrolled = this.view.scrollViewport(this._createCellCoords(renderableRowIndex, renderableColumnIndex));
+    if (isScrolled) {
+      this.view.render();
+    } else {
+      this.removeHook('afterScroll', callback);
+      this._registerImmediate(function () {
+        return callback();
+      });
+    }
+  };
+
   /**
    * Removes the table from the DOM and destroys the instance of the Handsontable.
    *
@@ -4132,8 +4211,6 @@ export default function Core(rootElement, userSettings) {
     if (datamap) {
       datamap.destroy();
     }
-    instance.rowIndexMapper = null;
-    instance.columnIndexMapper = null;
     datamap = null;
     grid = null;
     selection = null;
@@ -4417,6 +4494,16 @@ export default function Core(rootElement, userSettings) {
     }
   };
 
+  /**
+   * Gets the instance of the EditorManager.
+   *
+   * @private
+   * @returns {EditorManager}
+   */
+  this._getEditorManager = function () {
+    return editorManager;
+  };
+
   /**
    * Check if currently it is RTL direction.
    *
@@ -4489,296 +4576,11 @@ export default function Core(rootElement, userSettings) {
   this.getShortcutManager = function () {
     return shortcutManager;
   };
-
-  /**
-   * Return the Focus Manager responsible for managing the browser's focus in the table.
-   *
-   * @memberof Core#
-   * @since 13.0.0
-   * @function getFocusManager
-   * @returns {FocusManager}
-   */
-  this.getFocusManager = function () {
-    return focusManager;
-  };
-  var gridContext = shortcutManager.addContext('grid');
-  var gridConfig = {
-    runOnlyIf: function runOnlyIf() {
-      return isDefined(instance.getSelected()) && instance.countRenderedRows() > 0 && instance.countRenderedCols() > 0;
-    },
-    group: SHORTCUTS_GROUP
-  };
-  shortcutManager.setActiveContextName('grid');
-  gridContext.addShortcuts([{
-    keys: [['Control/Meta', 'A'], ['Control/Meta', 'Shift', 'Space']],
-    callback: function callback() {
-      instance.selectAll();
-    }
-  }, {
-    keys: [['Control/Meta', 'Enter']],
-    callback: function callback() {
-      var selectedRange = instance.getSelectedRange();
-      var _selectedRange$highli = selectedRange[selectedRange.length - 1].highlight,
-        highlightRow = _selectedRange$highli.row,
-        highlightColumn = _selectedRange$highli.col;
-      var valueToPopulate = instance.getDataAtCell(highlightRow, highlightColumn);
-      var cellValues = new Map();
-      for (var i = 0; i < selectedRange.length; i++) {
-        selectedRange[i].forAll(function (row, column) {
-          if (row >= 0 && column >= 0 && (row !== highlightRow || column !== highlightColumn)) {
-            var _instance$getCellMeta = instance.getCellMeta(row, column),
-              readOnly = _instance$getCellMeta.readOnly;
-            if (!readOnly) {
-              cellValues.set("".concat(row, "x").concat(column), [row, column, valueToPopulate]);
-            }
-          }
-        });
-      }
-      instance.setDataAtCell(Array.from(cellValues.values()));
-    },
-    runOnlyIf: function runOnlyIf() {
-      return instance.getSelectedRangeLast().getCellsCount() > 1;
-    }
-  }, {
-    keys: [['ArrowUp']],
-    callback: function callback() {
-      selection.transformStart(-1, 0);
-    }
-  }, {
-    keys: [['ArrowUp', 'Control/Meta']],
-    captureCtrl: true,
-    callback: function callback() {
-      selection.setRangeStart(instance._createCellCoords(instance.rowIndexMapper.getNearestNotHiddenIndex(0, 1), instance.getSelectedRangeLast().highlight.col));
-    }
-  }, {
-    keys: [['ArrowUp', 'Shift']],
-    callback: function callback() {
-      selection.transformEnd(-1, 0);
-    }
-  }, {
-    keys: [['ArrowUp', 'Shift', 'Control/Meta']],
-    captureCtrl: true,
-    callback: function callback() {
-      var _instance$getSelected = instance.getSelectedRangeLast(),
-        from = _instance$getSelected.from,
-        to = _instance$getSelected.to;
-      var row = instance.rowIndexMapper.getNearestNotHiddenIndex(0, 1);
-      selection.setRangeStart(from.clone());
-      selection.setRangeEnd(instance._createCellCoords(row, to.col));
-    },
-    runOnlyIf: function runOnlyIf() {
-      return !(instance.selection.isSelectedByCorner() || instance.selection.isSelectedByColumnHeader());
-    }
-  }, {
-    keys: [['ArrowDown']],
-    callback: function callback() {
-      selection.transformStart(1, 0);
-    }
-  }, {
-    keys: [['ArrowDown', 'Control/Meta']],
-    captureCtrl: true,
-    callback: function callback() {
-      selection.setRangeStart(instance._createCellCoords(instance.rowIndexMapper.getNearestNotHiddenIndex(instance.countRows() - 1, -1), instance.getSelectedRangeLast().highlight.col));
-    }
-  }, {
-    keys: [['ArrowDown', 'Shift']],
-    callback: function callback() {
-      selection.transformEnd(1, 0);
-    }
-  }, {
-    keys: [['ArrowDown', 'Shift', 'Control/Meta']],
-    captureCtrl: true,
-    callback: function callback() {
-      var _instance$getSelected2 = instance.getSelectedRangeLast(),
-        from = _instance$getSelected2.from,
-        to = _instance$getSelected2.to;
-      var row = instance.rowIndexMapper.getNearestNotHiddenIndex(instance.countRows() - 1, -1);
-      selection.setRangeStart(from.clone());
-      selection.setRangeEnd(instance._createCellCoords(row, to.col));
-    },
-    runOnlyIf: function runOnlyIf() {
-      return !(instance.selection.isSelectedByCorner() || instance.selection.isSelectedByColumnHeader());
-    }
-  }, {
-    keys: [['ArrowLeft']],
-    callback: function callback() {
-      selection.transformStart(0, -1 * instance.getDirectionFactor());
-    }
-  }, {
-    keys: [['ArrowLeft', 'Control/Meta']],
-    captureCtrl: true,
-    callback: function callback() {
-      var _instance$columnIndex;
-      var row = instance.getSelectedRangeLast().highlight.row;
-      var column = (_instance$columnIndex = instance.columnIndexMapper).getNearestNotHiddenIndex.apply(_instance$columnIndex, _toConsumableArray(instance.isRtl() ? [instance.countCols() - 1, -1] : [0, 1]));
-      selection.setRangeStart(instance._createCellCoords(row, column));
-    }
-  }, {
-    keys: [['ArrowLeft', 'Shift']],
-    callback: function callback() {
-      selection.transformEnd(0, -1 * instance.getDirectionFactor());
-    }
-  }, {
-    keys: [['ArrowLeft', 'Shift', 'Control/Meta']],
-    captureCtrl: true,
-    callback: function callback() {
-      var _instance$columnIndex2;
-      var _instance$getSelected3 = instance.getSelectedRangeLast(),
-        from = _instance$getSelected3.from,
-        to = _instance$getSelected3.to;
-      var column = (_instance$columnIndex2 = instance.columnIndexMapper).getNearestNotHiddenIndex.apply(_instance$columnIndex2, _toConsumableArray(instance.isRtl() ? [instance.countCols() - 1, -1] : [0, 1]));
-      selection.setRangeStart(from.clone());
-      selection.setRangeEnd(instance._createCellCoords(to.row, column));
-    },
-    runOnlyIf: function runOnlyIf() {
-      return !(instance.selection.isSelectedByCorner() || instance.selection.isSelectedByRowHeader());
-    }
-  }, {
-    keys: [['ArrowRight']],
-    callback: function callback() {
-      selection.transformStart(0, instance.getDirectionFactor());
-    }
-  }, {
-    keys: [['ArrowRight', 'Control/Meta']],
-    captureCtrl: true,
-    callback: function callback() {
-      var _instance$columnIndex3;
-      var row = instance.getSelectedRangeLast().highlight.row;
-      var column = (_instance$columnIndex3 = instance.columnIndexMapper).getNearestNotHiddenIndex.apply(_instance$columnIndex3, _toConsumableArray(instance.isRtl() ? [0, 1] : [instance.countCols() - 1, -1]));
-      selection.setRangeStart(instance._createCellCoords(row, column));
-    }
-  }, {
-    keys: [['ArrowRight', 'Shift']],
-    callback: function callback() {
-      selection.transformEnd(0, instance.getDirectionFactor());
-    }
-  }, {
-    keys: [['ArrowRight', 'Shift', 'Control/Meta']],
-    captureCtrl: true,
-    callback: function callback() {
-      var _instance$columnIndex4;
-      var _instance$getSelected4 = instance.getSelectedRangeLast(),
-        from = _instance$getSelected4.from,
-        to = _instance$getSelected4.to;
-      var column = (_instance$columnIndex4 = instance.columnIndexMapper).getNearestNotHiddenIndex.apply(_instance$columnIndex4, _toConsumableArray(instance.isRtl() ? [0, 1] : [instance.countCols() - 1, -1]));
-      selection.setRangeStart(from.clone());
-      selection.setRangeEnd(instance._createCellCoords(to.row, column));
-    },
-    runOnlyIf: function runOnlyIf() {
-      return !(instance.selection.isSelectedByCorner() || instance.selection.isSelectedByRowHeader());
-    }
-  }, {
-    keys: [['Home']],
-    captureCtrl: true,
-    callback: function callback() {
-      var fixedColumns = parseInt(instance.getSettings().fixedColumnsStart, 10);
-      var row = instance.getSelectedRangeLast().highlight.row;
-      var column = instance.columnIndexMapper.getNearestNotHiddenIndex(fixedColumns, 1);
-      selection.setRangeStart(instance._createCellCoords(row, column));
-    },
-    runOnlyIf: function runOnlyIf() {
-      return instance.view.isMainTableNotFullyCoveredByOverlays();
-    }
-  }, {
-    keys: [['Home', 'Shift']],
-    callback: function callback() {
-      selection.setRangeEnd(instance._createCellCoords(selection.selectedRange.current().from.row, instance.columnIndexMapper.getNearestNotHiddenIndex(0, 1)));
-    }
-  }, {
-    keys: [['Home', 'Control/Meta']],
-    captureCtrl: true,
-    callback: function callback() {
-      var fixedRows = parseInt(instance.getSettings().fixedRowsTop, 10);
-      var fixedColumns = parseInt(instance.getSettings().fixedColumnsStart, 10);
-      var row = instance.rowIndexMapper.getNearestNotHiddenIndex(fixedRows, 1);
-      var column = instance.columnIndexMapper.getNearestNotHiddenIndex(fixedColumns, 1);
-      selection.setRangeStart(instance._createCellCoords(row, column));
-    },
-    runOnlyIf: function runOnlyIf() {
-      return instance.view.isMainTableNotFullyCoveredByOverlays();
-    }
-  }, {
-    keys: [['End']],
-    captureCtrl: true,
-    callback: function callback() {
-      selection.setRangeStart(instance._createCellCoords(instance.getSelectedRangeLast().highlight.row, instance.columnIndexMapper.getNearestNotHiddenIndex(instance.countCols() - 1, -1)));
-    },
-    runOnlyIf: function runOnlyIf() {
-      return instance.view.isMainTableNotFullyCoveredByOverlays();
-    }
-  }, {
-    keys: [['End', 'Shift']],
-    callback: function callback() {
-      selection.setRangeEnd(instance._createCellCoords(selection.selectedRange.current().from.row, instance.columnIndexMapper.getNearestNotHiddenIndex(instance.countCols() - 1, -1)));
-    }
-  }, {
-    keys: [['End', 'Control/Meta']],
-    captureCtrl: true,
-    callback: function callback() {
-      var fixedRows = parseInt(instance.getSettings().fixedRowsBottom, 10);
-      var row = instance.rowIndexMapper.getNearestNotHiddenIndex(instance.countRows() - fixedRows - 1, -1);
-      var column = instance.columnIndexMapper.getNearestNotHiddenIndex(instance.countCols() - 1, -1);
-      selection.setRangeStart(instance._createCellCoords(row, column));
-    },
-    runOnlyIf: function runOnlyIf() {
-      return instance.view.isMainTableNotFullyCoveredByOverlays();
-    }
-  }, {
-    keys: [['PageUp']],
-    callback: function callback() {
-      selection.transformStart(-instance.countVisibleRows(), 0);
-    }
-  }, {
-    keys: [['PageUp', 'Shift']],
-    callback: function callback() {
-      var _instance$getSelected5 = instance.getSelectedRangeLast(),
-        to = _instance$getSelected5.to;
-      var nextRowIndexToSelect = Math.max(to.row - instance.countVisibleRows(), 0);
-      var row = instance.rowIndexMapper.getNearestNotHiddenIndex(nextRowIndexToSelect, 1);
-      if (row !== null) {
-        var coords = instance._createCellCoords(row, to.col);
-        var scrollPadding = to.row - instance.view.getFirstFullyVisibleRow();
-        var nextVerticalScroll = Math.max(coords.row - scrollPadding, 0);
-        selection.setRangeEnd(coords);
-        instance.scrollViewportTo(nextVerticalScroll);
-      }
-    }
-  }, {
-    keys: [['PageDown']],
-    callback: function callback() {
-      selection.transformStart(instance.countVisibleRows(), 0);
-    }
-  }, {
-    keys: [['PageDown', 'Shift']],
-    callback: function callback() {
-      var _instance$getSelected6 = instance.getSelectedRangeLast(),
-        to = _instance$getSelected6.to;
-      var nextRowIndexToSelect = Math.min(to.row + instance.countVisibleRows(), instance.countRows() - 1);
-      var row = instance.rowIndexMapper.getNearestNotHiddenIndex(nextRowIndexToSelect, -1);
-      if (row !== null) {
-        var coords = instance._createCellCoords(row, to.col);
-        var scrollPadding = to.row - instance.view.getFirstFullyVisibleRow();
-        var nextVerticalScroll = Math.min(coords.row - scrollPadding, instance.countRows() - 1);
-        selection.setRangeEnd(coords);
-        instance.scrollViewportTo(nextVerticalScroll);
-      }
-    }
-  }, {
-    keys: [['Tab']],
-    callback: function callback(event) {
-      var tabMoves = typeof tableMeta.tabMoves === 'function' ? tableMeta.tabMoves(event) : tableMeta.tabMoves;
-      selection.transformStart(tabMoves.row, tabMoves.col, true);
-    }
-  }, {
-    keys: [['Shift', 'Tab']],
-    callback: function callback(event) {
-      var tabMoves = typeof tableMeta.tabMoves === 'function' ? tableMeta.tabMoves(event) : tableMeta.tabMoves;
-      selection.transformStart(-tabMoves.row, -tabMoves.col);
-    }
-  }], gridConfig);
   getPluginsNames().forEach(function (pluginName) {
     var PluginClass = getPlugin(pluginName);
     pluginsRegistry.addItem(pluginName, new PluginClass(_this));
   });
+  registerAllShortcutContexts(instance);
+  shortcutManager.setActiveContextName('grid');
   Hooks.getSingleton().run(instance, 'construct');
 }