handsontable 11.0.0 → 12.0.0

package/core.js

@@ -6,15 +6,13 @@ require("core-js/modules/es.symbol.description.js");
 
 require("core-js/modules/es.symbol.iterator.js");
 
-require("core-js/modules/es.array.iterator.js");
-
-require("core-js/modules/web.dom-collections.iterator.js");
-
 require("core-js/modules/es.function.name.js");
 
 exports.__esModule = true;
 exports.default = Core;
 
+require("core-js/modules/es.array.includes.js");
+
 require("core-js/modules/es.array.sort.js");
 
 require("core-js/modules/es.array.splice.js");
@@ -51,6 +49,12 @@ require("core-js/modules/web.timers.js");
 
 require("core-js/modules/web.immediate.js");
 
+require("core-js/modules/es.array.iterator.js");
+
+require("core-js/modules/es.map.js");
+
+require("core-js/modules/web.dom-collections.iterator.js");
+
 var _element = require("./helpers/dom/element");
 
 var _function = require("./helpers/function");
@@ -97,17 +101,17 @@ var _registry4 = require("./i18n/registry");
 
 var _utils = require("./i18n/utils");
 
-var _keyStateObserver = require("./utils/keyStateObserver");
-
 var _selection = require("./selection");
 
 var _dataMap = require("./dataMap");
 
 var _uniqueMap = require("./utils/dataStructures/uniqueMap");
 
+var _shortcuts = require("./shortcuts");
+
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+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 _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
 
@@ -129,6 +133,7 @@ function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToAr
 
 function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
 
+var SHORTCUTS_GROUP = 'gridDefault';
 var activeGuid = null;
 /* eslint-disable jsdoc/require-description-complete-sentence */
 
@@ -157,7 +162,8 @@ var activeGuid = null;
  */
 
 function Core(rootElement, userSettings) {
-  var _this = this;
+  var _userSettings$layoutD,
+      _this = this;
 
   var rootInstanceSymbol = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
   var preventScrollingToCell = false;
@@ -168,11 +174,6 @@ function Core(rootElement, userSettings) {
   var grid;
   var editorManager;
   var firstRun = true;
-  userSettings.language = (0, _registry4.getValidLanguageCode)(userSettings.language);
-  var metaManager = new _dataMap.MetaManager(instance, userSettings, [_dataMap.DynamicCellMetaMod]);
-  var tableMeta = metaManager.getTableMeta();
-  var globalMeta = metaManager.getGlobalMeta();
-  var pluginsRegistry = (0, _uniqueMap.createUniqueMap)();
 
   if ((0, _rootInstance.hasValidParameter)(rootInstanceSymbol)) {
     (0, _rootInstance.registerAsRootInstance)(this);
@@ -187,8 +188,6 @@ function Core(rootElement, userSettings) {
 
 
   this.rootElement = rootElement;
-  /* eslint-enable jsdoc/require-description-complete-sentence */
-
   /**
    * The nearest document over container.
    *
@@ -237,7 +236,53 @@ function Core(rootElement, userSettings) {
    */
 
   this.executionSuspendedCounter = 0;
-  (0, _keyStateObserver.startObserving)(this.rootDocument);
+  var layoutDirection = (_userSettings$layoutD = userSettings === null || userSettings === void 0 ? void 0 : userSettings.layoutDirection) !== null && _userSettings$layoutD !== void 0 ? _userSettings$layoutD : 'inherit';
+  var rootElementDirection = ['rtl', 'ltr'].includes(layoutDirection) ? layoutDirection : this.rootWindow.getComputedStyle(this.rootElement).direction;
+  this.rootElement.setAttribute('dir', rootElementDirection);
+  /**
+   * Checks if the grid is rendered using the right-to-left layout direction.
+   *
+   * @since 12.0.0
+   * @memberof Core#
+   * @function isRtl
+   * @returns {boolean} True if RTL.
+   */
+
+  this.isRtl = function () {
+    return rootElementDirection === 'rtl';
+  };
+  /**
+   * Checks if the grid is rendered using the left-to-right layout direction.
+   *
+   * @since 12.0.0
+   * @memberof Core#
+   * @function isLtr
+   * @returns {boolean} True if LTR.
+   */
+
+
+  this.isLtr = function () {
+    return !instance.isRtl();
+  };
+  /**
+   * Returns 1 for LTR; -1 for RTL. Useful for calculations.
+   *
+   * @since 12.0.0
+   * @memberof Core#
+   * @function getDirectionFactor
+   * @returns {number} Returns 1 for LTR; -1 for RTL.
+   */
+
+
+  this.getDirectionFactor = function () {
+    return instance.isLtr() ? 1 : -1;
+  };
+
+  userSettings.language = (0, _registry4.getValidLanguageCode)(userSettings.language);
+  var metaManager = new _dataMap.MetaManager(instance, userSettings, [_dataMap.DynamicCellMetaMod, _dataMap.ExtendMetaPropertiesMod]);
+  var tableMeta = metaManager.getTableMeta();
+  var globalMeta = metaManager.getGlobalMeta();
+  var pluginsRegistry = (0, _uniqueMap.createUniqueMap)();
   this.container = this.rootDocument.createElement('div');
   this.renderCall = false;
   rootElement.insertBefore(this.container, rootElement.firstChild);
@@ -275,14 +320,14 @@ function Core(rootElement, userSettings) {
   var visualToRenderableCoords = function visualToRenderableCoords(coords) {
     var visualRow = coords.row,
         visualColumn = coords.col;
-    return new _src.CellCoords( // We just store indexes for rows and columns without headers.
+    return instance._createCellCoords( // We just store indexes for rows and columns without headers.
     visualRow >= 0 ? instance.rowIndexMapper.getRenderableFromVisualIndex(visualRow) : visualRow, visualColumn >= 0 ? instance.columnIndexMapper.getRenderableFromVisualIndex(visualColumn) : visualColumn);
   };
 
   var renderableToVisualCoords = function renderableToVisualCoords(coords) {
     var renderableRow = coords.row,
         renderableColumn = coords.col;
-    return new _src.CellCoords( // We just store indexes for rows and columns without headers.
+    return instance._createCellCoords( // We just store indexes for rows and columns without headers.
     renderableRow >= 0 ? instance.rowIndexMapper.getVisualFromRenderableIndex(renderableRow) : renderableRow, renderableColumn >= 0 ? instance.columnIndexMapper.getVisualFromRenderableIndex(renderableColumn) : renderableColumn // eslint-disable-line max-len
     );
   };
@@ -306,6 +351,15 @@ function Core(rootElement, userSettings) {
     countRowsTranslated: function countRowsTranslated() {
       return _this.view.countRenderableRows();
     },
+    getShortcutManager: function getShortcutManager() {
+      return instance.getShortcutManager();
+    },
+    createCellCoords: function createCellCoords(row, column) {
+      return instance._createCellCoords(row, column);
+    },
+    createCellRange: function createCellRange(highlight, from, to) {
+      return instance._createCellRange(highlight, from, to);
+    },
     visualToRenderableCoords: visualToRenderableCoords,
     renderableToVisualCoords: renderableToVisualCoords,
     isDisabledCellSelection: function isDisabledCellSelection(visualRow, visualColumn) {
@@ -334,11 +388,11 @@ function Core(rootElement, userSettings) {
     _this.runHooks('beforeSetRangeEnd', cellCoords);
 
     if (cellCoords.row < 0) {
-      cellCoords.row = _this.view.wt.wtTable.getFirstVisibleRow();
+      cellCoords.row = _this.view._wt.wtTable.getFirstVisibleRow();
     }
 
     if (cellCoords.col < 0) {
-      cellCoords.col = _this.view.wt.wtTable.getFirstVisibleColumn();
+      cellCoords.col = _this.view._wt.wtTable.getFirstVisibleColumn();
     }
   });
   this.selection.addLocalHook('afterSetRangeEnd', function (cellCoords) {
@@ -552,8 +606,8 @@ function Core(rootElement, userSettings) {
 
               selection.getSelectedRange().pop(); // I can't use transforms as they don't work in negative indexes.
 
-              selection.setRangeStartOnly(new _src.CellCoords(currentFromRow + delta, currentFromColumn), true);
-              selection.setRangeEnd(new _src.CellCoords(currentToRow + delta, currentToColumn)); // will call render() internally
+              selection.setRangeStartOnly(instance._createCellCoords(currentFromRow + delta, currentFromColumn), true);
+              selection.setRangeEnd(instance._createCellCoords(currentToRow + delta, currentToColumn)); // will call render() internally
             } else {
               instance._refreshBorders(); // it will call render and prepare methods
 
@@ -597,8 +651,8 @@ function Core(rootElement, userSettings) {
 
               selection.getSelectedRange().pop(); // I can't use transforms as they don't work in negative indexes.
 
-              selection.setRangeStartOnly(new _src.CellCoords(_currentFromRow, _currentFromColumn + delta), true);
-              selection.setRangeEnd(new _src.CellCoords(_currentToRow, _currentToColumn + delta)); // will call render() internally
+              selection.setRangeStartOnly(instance._createCellCoords(_currentFromRow, _currentFromColumn + delta), true);
+              selection.setRangeEnd(instance._createCellCoords(_currentToRow, _currentToColumn + delta)); // will call render() internally
             } else {
               instance._refreshBorders(); // it will call render and prepare methods
 
@@ -690,10 +744,10 @@ function Core(rootElement, userSettings) {
               }
 
               metaManager.removeColumn(physicalColumnIndex, groupAmount);
-              var fixedColumnsLeft = tableMeta.fixedColumnsLeft;
+              var fixedColumnsStart = tableMeta.fixedColumnsStart;
 
-              if (fixedColumnsLeft >= calcIndex + 1) {
-                tableMeta.fixedColumnsLeft -= Math.min(groupAmount, fixedColumnsLeft - calcIndex);
+              if (fixedColumnsStart >= calcIndex + 1) {
+                tableMeta.fixedColumnsStart -= Math.min(groupAmount, fixedColumnsStart - calcIndex);
               }
 
               if (Array.isArray(tableMeta.colHeaders)) {
@@ -1401,6 +1455,38 @@ function Core(rootElement, userSettings) {
       activeEditor.refreshValue();
     }
   }
+  /**
+   * Creates and returns the CellCoords object.
+   *
+   * @private
+   * @memberof Core#
+   * @function _createCellCoords
+   * @param {number} row The row index.
+   * @param {number} column The column index.
+   * @returns {CellCoords}
+   */
+
+
+  this._createCellCoords = function (row, column) {
+    return instance.view._wt.createCellCoords(row, column);
+  };
+  /**
+   * Creates and returns the CellRange object.
+   *
+   * @private
+   * @memberof Core#
+   * @function _createCellRange
+   * @param {CellCoords} highlight Defines the border around a cell where selection was started and to edit the cell
+   *                               when you press Enter. The highlight cannot point to headers (negative values).
+   * @param {CellCoords} from Initial coordinates.
+   * @param {CellCoords} to Final coordinates.
+   * @returns {CellRange}
+   */
+
+
+  this._createCellRange = function (highlight, from, to) {
+    return instance.view._wt.createCellRange(highlight, from, to);
+  };
   /**
    * Validate a single cell.
    *
@@ -1439,7 +1525,8 @@ function Core(rootElement, userSettings) {
       if (td && td.nodeName !== 'TH') {
         var renderableRow = instance.rowIndexMapper.getRenderableFromVisualIndex(row);
         var renderableColumn = instance.columnIndexMapper.getRenderableFromVisualIndex(col);
-        instance.view.wt.wtSettings.settings.cellRenderer(renderableRow, renderableColumn, td);
+
+        instance.view._wt.getSetting('cellRenderer', renderableRow, renderableColumn, td);
       }
 
       callback(valid);
@@ -1664,8 +1751,8 @@ function Core(rootElement, userSettings) {
       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' ? new _src.CellCoords(endRow, endCol) : null;
-    return grid.populateFromArray(new _src.CellCoords(row, column), input, c, source, method, direction, deltas);
+    var c = typeof endRow === 'number' ? instance._createCellCoords(endRow, endCol) : null;
+    return grid.populateFromArray(instance._createCellCoords(row, column), input, c, source, method, direction, deltas);
   };
   /**
    * Adds/removes data from the column. This method works the same as Array.splice for arrays.
@@ -1814,10 +1901,10 @@ function Core(rootElement, userSettings) {
 
     var changes = [];
     (0, _array.arrayEach)(selection.getSelectedRange(), function (cellRange) {
-      var topLeft = cellRange.getTopLeftCorner();
-      var bottomRight = cellRange.getBottomRightCorner();
-      (0, _number.rangeEach)(topLeft.row, bottomRight.row, function (row) {
-        (0, _number.rangeEach)(topLeft.col, bottomRight.col, function (column) {
+      var topStart = cellRange.getTopStartCorner();
+      var bottomEnd = cellRange.getBottomEndCorner();
+      (0, _number.rangeEach)(topStart.row, bottomEnd.row, function (row) {
+        (0, _number.rangeEach)(topStart.col, bottomEnd.col, function (column) {
           if (!_this2.getCellMeta(row, column).readOnly) {
             changes.push([row, column, null]);
           }
@@ -2175,7 +2262,7 @@ function Core(rootElement, userSettings) {
       return;
     }
 
-    if (isSizeChanged || instance.view.wt.wtOverlays.scrollableElement === instance.rootWindow) {
+    if (isSizeChanged || instance.view._wt.wtOverlays.scrollableElement === instance.rootWindow) {
       instance.view.setLastSize(width, height);
       instance.render();
     }
@@ -2189,14 +2276,67 @@ function Core(rootElement, userSettings) {
     }, isSizeChanged);
   };
   /**
-   * Loads new data to Handsontable. Loading new data resets the cell meta.
-   * Since 8.0.0 loading new data also resets states corresponding to rows and columns
-   * (for example, row/column sequence, column width, row height, frozen columns etc.).
+   * The `updateData()` method replaces Handsontable's [`data`](@/api/options.md#data) with a new dataset.
+   *
+   * The `updateData()` method:
+   * - Keeps cells' states (e.g. cells' [formatting](@/guides/cell-features/formatting-cells.md) and cells' [`readOnly`](@/api/options.md#readonly) states)
+   * - Keeps rows' states (e.g. row order)
+   * - Keeps columns' states (e.g. column order)
+   *
+   * To replace Handsontable's [`data`](@/api/options.md#data) and reset states, use the [`loadData()`](#loaddata) method.
+   *
+   * Read more:
+   * - [Binding to data &#8594;](@/guides/getting-started/binding-to-data.md)
+   * - [Saving data &#8594;](@/guides/getting-started/saving-data.md)
+   *
+   * @memberof Core#
+   * @function updateData
+   * @since 11.1.0
+   * @param {Array} data An [array of arrays](@/guides/getting-started/binding-to-data.md#array-of-arrays), or an [array of objects](@/guides/getting-started/binding-to-data.md#array-of-objects), that contains Handsontable's data
+   * @param {string} [source] The source of the `updateData()` call
+   * @fires Hooks#beforeUpdateData
+   * @fires Hooks#afterUpdateData
+   * @fires Hooks#afterChange
+   */
+
+
+  this.updateData = function (data, source) {
+    var _this3 = this;
+
+    (0, _dataMap.replaceData)(data, function (newDataMap) {
+      datamap = newDataMap;
+    }, function (newDataMap) {
+      datamap = newDataMap;
+      instance.columnIndexMapper.fitToLength(_this3.getInitialColumnCount());
+      instance.rowIndexMapper.fitToLength(_this3.countSourceRows());
+      grid.adjustRowsAndCols();
+    }, {
+      hotInstance: instance,
+      dataMap: datamap,
+      dataSource: dataSource,
+      internalSource: 'updateData',
+      source: source,
+      firstRun: firstRun
+    });
+  };
+  /**
+   * The `loadData()` method replaces Handsontable's [`data`](@/api/options.md#data) with a new dataset.
+   *
+   * Additionally, the `loadData()` method:
+   * - Resets cells' states (e.g. cells' [formatting](@/guides/cell-features/formatting-cells.md) and cells' [`readOnly`](@/api/options.md#readonly) states)
+   * - Resets rows' states (e.g. row order)
+   * - Resets columns' states (e.g. column order)
+   *
+   * To replace Handsontable's [`data`](@/api/options.md#data) without resetting states, use the [`updateData()`](#updatedata) method.
+   *
+   * Read more:
+   * - [Binding to data &#8594;](@/guides/getting-started/binding-to-data.md)
+   * - [Saving data &#8594;](@/guides/getting-started/saving-data.md)
    *
    * @memberof Core#
    * @function loadData
-   * @param {Array} data Array of arrays or array of objects containing data.
-   * @param {string} [source] Source of the loadData call.
+   * @param {Array} data An [array of arrays](@/guides/getting-started/binding-to-data.md#array-of-arrays), or an [array of objects](@/guides/getting-started/binding-to-data.md#array-of-objects), that contains Handsontable's data
+   * @param {string} [source] The source of the `loadData()` call
    * @fires Hooks#beforeLoadData
    * @fires Hooks#afterLoadData
    * @fires Hooks#afterChange
@@ -2204,88 +2344,34 @@ function Core(rootElement, userSettings) {
 
 
   this.loadData = function (data, source) {
-    if (Array.isArray(tableMeta.dataSchema)) {
-      instance.dataType = 'array';
-    } else if ((0, _function.isFunction)(tableMeta.dataSchema)) {
-      instance.dataType = 'function';
-    } else {
-      instance.dataType = 'object';
-    }
-
-    if (datamap) {
-      datamap.destroy();
-    }
-
-    data = instance.runHooks('beforeLoadData', data, firstRun, source);
-    datamap = new _dataMap.DataMap(instance, data, tableMeta);
-
-    if (_typeof(data) === 'object' && data !== null) {
-      if (!(data.push && data.splice)) {
-        // check if data is array. Must use duck-type check so Backbone Collections also pass it
-        // when data is not an array, attempt to make a single-row array of it
-        // eslint-disable-next-line no-param-reassign
-        data = [data];
-      }
-    } else if (data === null) {
-      var dataSchema = datamap.getSchema(); // eslint-disable-next-line no-param-reassign
-
-      data = [];
-      var row;
-      var r = 0;
-      var rlen = 0;
-
-      for (r = 0, rlen = tableMeta.startRows; r < rlen; r++) {
-        if ((instance.dataType === 'object' || instance.dataType === 'function') && tableMeta.dataSchema) {
-          row = (0, _object.deepClone)(dataSchema);
-          data.push(row);
-        } else if (instance.dataType === 'array') {
-          row = (0, _object.deepClone)(dataSchema[0]);
-          data.push(row);
-        } else {
-          row = [];
-
-          for (var c = 0, clen = tableMeta.startCols; c < clen; c++) {
-            row.push(null);
-          }
+    (0, _dataMap.replaceData)(data, function (newDataMap) {
+      datamap = newDataMap;
+    }, function () {
+      metaManager.clearCellsCache();
+      instance.initIndexMappers();
+      grid.adjustRowsAndCols();
 
-          data.push(row);
-        }
+      if (firstRun) {
+        firstRun = [null, 'loadData'];
       }
-    } else {
-      throw new Error("loadData only accepts array of objects or array of arrays (".concat(_typeof(data), " given)"));
-    }
-
-    if (Array.isArray(data[0])) {
-      instance.dataType = 'array';
-    }
-
-    tableMeta.data = data;
-    datamap.dataSource = data;
-    dataSource.data = data;
-    dataSource.dataType = instance.dataType;
-    dataSource.colToProp = datamap.colToProp.bind(datamap);
-    dataSource.propToCol = datamap.propToCol.bind(datamap);
-    dataSource.countCachedColumns = datamap.countCachedColumns.bind(datamap);
-    metaManager.clearCellsCache();
-    instance.initIndexMappers();
-    grid.adjustRowsAndCols();
-    instance.runHooks('afterLoadData', data, firstRun, source);
-
-    if (firstRun) {
-      firstRun = [null, 'loadData'];
-    } else {
-      instance.runHooks('afterChange', null, 'loadData');
-      instance.render();
-    }
+    }, {
+      hotInstance: instance,
+      dataMap: datamap,
+      dataSource: dataSource,
+      internalSource: 'loadData',
+      source: source,
+      firstRun: firstRun
+    });
   };
   /**
-   * Init index mapper which manage indexes assigned to the data.
+   * Gets the initial column count, calculated based on the `columns` setting.
    *
    * @private
+   * @returns {number} The calculated number of columns.
    */
 
 
-  this.initIndexMappers = function () {
+  this.getInitialColumnCount = function () {
     var columnsSettings = tableMeta.columns;
     var finalNrOfColumns = 0; // We will check number of columns when the `columns` property was defined as an array. Columns option may
     // narrow down or expand displayed dataset in that case.
@@ -2315,7 +2401,17 @@ function Core(rootElement, userSettings) {
       finalNrOfColumns = this.countSourceCols();
     }
 
-    this.columnIndexMapper.initToLength(finalNrOfColumns);
+    return finalNrOfColumns;
+  };
+  /**
+   * Init index mapper which manage indexes assigned to the data.
+   *
+   * @private
+   */
+
+
+  this.initIndexMappers = function () {
+    this.columnIndexMapper.initToLength(this.getInitialColumnCount());
     this.rowIndexMapper.initToLength(this.countSourceRows());
   };
   /**
@@ -2349,7 +2445,7 @@ function Core(rootElement, userSettings) {
       return datamap.getAll();
     }
 
-    return datamap.getRange(new _src.CellCoords(row, column), new _src.CellCoords(row2, column2), datamap.DESTINATION_RENDERER);
+    return datamap.getRange(instance._createCellCoords(row, column), instance._createCellCoords(row2, column2), datamap.DESTINATION_RENDERER);
   };
   /**
    * Returns a string value of the selected range. Each column is separated by tab, each row is separated by a new
@@ -2366,7 +2462,7 @@ function Core(rootElement, userSettings) {
 
 
   this.getCopyableText = function (startRow, startCol, endRow, endCol) {
-    return datamap.getCopyableText(new _src.CellCoords(startRow, startCol), new _src.CellCoords(endRow, endCol));
+    return datamap.getCopyableText(instance._createCellCoords(startRow, startCol), instance._createCellCoords(endRow, endCol));
   };
   /**
    * Returns the data's copyable value at specified `row` and `column` index.
@@ -2396,7 +2492,7 @@ function Core(rootElement, userSettings) {
     return datamap.getSchema();
   };
   /**
-   * Use it if you need to change configuration after initialization. The `settings` argument is an object containing the new
+   * Use it if you need to change configuration after initialization. The `settings` argument is an object containing the changed
    * settings, declared the same way as in the initial settings object.
    *
    * __Note__, that although the `updateSettings` method doesn't overwrite the previously declared settings, it might reset
@@ -2405,9 +2501,12 @@ function Core(rootElement, userSettings) {
    * Since 8.0.0 passing `columns` or `data` inside `settings` objects will result in resetting states corresponding to rows and columns
    * (for example, row/column sequence, column width, row height, frozen columns etc.).
    *
+   * Since 12.0.0 passing `data` inside `settings` objects no longer results in resetting states corresponding to rows and columns
+   * (for example, row/column sequence, column width, row height, frozen columns etc.).
+   *
    * @memberof Core#
    * @function updateSettings
-   * @param {object} settings New settings object (see {@link Options}).
+   * @param {object} settings A settings object (see {@link Options}). Only provide the settings that are changed, not the whole settings object that was used for initialization.
    * @param {boolean} [init=false] Internally used for in initialization mode.
    * @example
    * ```js
@@ -2424,6 +2523,7 @@ function Core(rootElement, userSettings) {
 
   this.updateSettings = function (settings) {
     var init = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    var dataUpdateFunction = (firstRun ? instance.loadData : instance.updateData).bind(this);
     var columnsAsFunc = false;
     var i;
     var j;
@@ -2442,19 +2542,15 @@ function Core(rootElement, userSettings) {
 
 
     for (i in settings) {
-      if (i === 'data') {
-        /* eslint-disable-next-line no-continue */
-        continue; // loadData will be triggered later
+      if (i === 'data') {// Do nothing. loadData will be triggered later
       } else if (i === 'language') {
         setLanguage(settings.language);
-        /* eslint-disable-next-line no-continue */
-
-        continue;
       } else if (i === 'className') {
         setClassName('className', settings.className);
       } else if (i === 'tableClassName' && instance.table) {
         setClassName('tableClassName', settings.tableClassName);
-        instance.view.wt.wtOverlays.syncOverlayTableClassNames();
+
+        instance.view._wt.wtOverlays.syncOverlayTableClassNames();
       } else if (_pluginHooks.default.getSingleton().isRegistered(i) || _pluginHooks.default.getSingleton().isDeprecated(i)) {
         if ((0, _function.isFunction)(settings[i]) || Array.isArray(settings[i])) {
           settings[i].initialHook = true;
@@ -2468,9 +2564,9 @@ function Core(rootElement, userSettings) {
 
 
     if (settings.data === void 0 && tableMeta.data === void 0) {
-      instance.loadData(null, 'updateSettings'); // data source created just now
+      dataUpdateFunction(null, 'updateSettings'); // data source created just now
     } else if (settings.data !== void 0) {
-      instance.loadData(settings.data, 'updateSettings'); // data source given as option
+      dataUpdateFunction(settings.data, 'updateSettings'); // data source given as option
     } else if (settings.columns !== void 0) {
       datamap.createMap(); // The `column` property has changed - dataset may be expanded or narrowed down. The `loadData` do the same.
 
@@ -2557,8 +2653,9 @@ function Core(rootElement, userSettings) {
 
     if (!init) {
       if (instance.view) {
-        instance.view.wt.wtViewport.resetHasOversizedColumnHeadersMarked();
-        instance.view.wt.exportSettingsAsClassNames();
+        instance.view._wt.wtViewport.resetHasOversizedColumnHeadersMarked();
+
+        instance.view._wt.exportSettingsAsClassNames();
       }
 
       instance.runHooks('afterUpdateSettings', settings);
@@ -2573,12 +2670,13 @@ function Core(rootElement, userSettings) {
 
       instance._refreshBorders(null);
 
-      instance.view.wt.wtOverlays.adjustElementsSize();
+      instance.view._wt.wtOverlays.adjustElementsSize();
+
       editorManager.unlockEditor();
     }
 
     if (!init && instance.view && (currentHeight === '' || height === '' || height === void 0) && currentHeight !== height) {
-      instance.view.wt.wtOverlays.updateMainScrollableElements();
+      instance.view._wt.wtOverlays.updateMainScrollableElements();
     }
   };
   /**
@@ -2608,7 +2706,7 @@ function Core(rootElement, userSettings) {
    *
    * @memberof Core#
    * @function getSettings
-   * @returns {object} Object containing the current table settings.
+   * @returns {TableMeta} Object containing the current table settings.
    */
 
 
@@ -2702,7 +2800,7 @@ function Core(rootElement, userSettings) {
       return null;
     }
 
-    return instance.view.getCellAtCoords(new _src.CellCoords(renderableRowIndex, renderableColumnIndex), topmost);
+    return instance.view.getCellAtCoords(instance._createCellCoords(renderableRowIndex, renderableColumnIndex), topmost);
   };
   /**
    * Returns the coordinates of the cell, provided as a HTML table cell element.
@@ -2720,7 +2818,7 @@ function Core(rootElement, userSettings) {
 
 
   this.getCoords = function (element) {
-    var renderableCoords = this.view.wt.wtTable.getCoords(element);
+    var renderableCoords = this.view._wt.wtTable.getCoords(element);
 
     if (renderableCoords === null) {
       return null;
@@ -2739,7 +2837,7 @@ function Core(rootElement, userSettings) {
       visualColumn = this.columnIndexMapper.getVisualFromRenderableIndex(renderableColumn);
     }
 
-    return new _src.CellCoords(visualRow, visualColumn);
+    return instance._createCellCoords(visualRow, visualColumn);
   };
   /**
    * Returns the property name that corresponds with the given column index.
@@ -2881,7 +2979,7 @@ function Core(rootElement, userSettings) {
   this.getDataAtCol = function (column) {
     var _ref13;
 
-    return (_ref13 = []).concat.apply(_ref13, _toConsumableArray(datamap.getRange(new _src.CellCoords(0, column), new _src.CellCoords(tableMeta.data.length - 1, column), datamap.DESTINATION_RENDERER)));
+    return (_ref13 = []).concat.apply(_ref13, _toConsumableArray(datamap.getRange(instance._createCellCoords(0, column), instance._createCellCoords(tableMeta.data.length - 1, column), datamap.DESTINATION_RENDERER)));
   };
   /**
    * Given the object property name (e.g. `'first.name'` or `'0'`), returns an array of column's values from the table data.
@@ -2898,7 +2996,7 @@ function Core(rootElement, userSettings) {
   this.getDataAtProp = function (prop) {
     var _ref14;
 
-    var range = datamap.getRange(new _src.CellCoords(0, datamap.propToCol(prop)), new _src.CellCoords(tableMeta.data.length - 1, datamap.propToCol(prop)), datamap.DESTINATION_RENDERER);
+    var range = datamap.getRange(instance._createCellCoords(0, datamap.propToCol(prop)), instance._createCellCoords(tableMeta.data.length - 1, datamap.propToCol(prop)), datamap.DESTINATION_RENDERER);
     return (_ref14 = []).concat.apply(_ref14, _toConsumableArray(range));
   };
   /**
@@ -2925,7 +3023,7 @@ function Core(rootElement, userSettings) {
     if (row === void 0) {
       data = dataSource.getData();
     } else {
-      data = dataSource.getByRange(new _src.CellCoords(row, column), new _src.CellCoords(row2, column2));
+      data = dataSource.getByRange(instance._createCellCoords(row, column), instance._createCellCoords(row2, column2));
     }
 
     return data;
@@ -2954,7 +3052,7 @@ function Core(rootElement, userSettings) {
     if (row === void 0) {
       data = dataSource.getData(true);
     } else {
-      data = dataSource.getByRange(new _src.CellCoords(row, column), new _src.CellCoords(row2, column2), true);
+      data = dataSource.getByRange(instance._createCellCoords(row, column), instance._createCellCoords(row2, column2), true);
     }
 
     return data;
@@ -3071,7 +3169,7 @@ function Core(rootElement, userSettings) {
 
 
   this.getDataAtRow = function (row) {
-    var data = datamap.getRange(new _src.CellCoords(row, 0), new _src.CellCoords(row, this.countCols() - 1), datamap.DESTINATION_RENDERER);
+    var data = datamap.getRange(instance._createCellCoords(row, 0), instance._createCellCoords(row, this.countCols() - 1), datamap.DESTINATION_RENDERER);
     return data[0] || [];
   };
   /**
@@ -3092,7 +3190,7 @@ function Core(rootElement, userSettings) {
 
 
   this.getDataType = function (rowFrom, columnFrom, rowTo, columnTo) {
-    var _this3 = this;
+    var _this4 = this;
 
     var coords = rowFrom === void 0 ? [0, 0, this.countRows(), this.countCols()] : [rowFrom, columnFrom, rowTo, columnTo];
     var rowStart = coords[0],
@@ -3114,7 +3212,7 @@ function Core(rootElement, userSettings) {
     (0, _number.rangeEach)(Math.max(Math.min(rowStart, rowEnd), 0), Math.max(rowStart, rowEnd), function (row) {
       var isTypeEqual = true;
       (0, _number.rangeEach)(Math.max(Math.min(columnStart, columnEnd), 0), Math.max(columnStart, columnEnd), function (column) {
-        var cellType = _this3.getCellMeta(row, column);
+        var cellType = _this4.getCellMeta(row, column);
 
         currentType = cellType.type;
 
@@ -3171,7 +3269,7 @@ function Core(rootElement, userSettings) {
 
 
   this.spliceCellsMeta = function (visualIndex) {
-    var _this4 = this;
+    var _this5 = this;
 
     var deleteAmount = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
 
@@ -3189,9 +3287,9 @@ function Core(rootElement, userSettings) {
 
     if (cellMetaRows.length > 0) {
       (0, _array.arrayEach)(cellMetaRows.reverse(), function (cellMetaRow) {
-        metaManager.createRow(_this4.toPhysicalRow(visualIndex));
+        metaManager.createRow(_this5.toPhysicalRow(visualIndex));
         (0, _array.arrayEach)(cellMetaRow, function (cellMeta, columnIndex) {
-          return _this4.setCellMetaObject(visualIndex, columnIndex, cellMeta);
+          return _this5.setCellMetaObject(visualIndex, columnIndex, cellMeta);
         });
       });
     }
@@ -3210,11 +3308,11 @@ function Core(rootElement, userSettings) {
 
 
   this.setCellMetaObject = function (row, column, prop) {
-    var _this5 = this;
+    var _this6 = this;
 
     if (_typeof(prop) === 'object') {
       (0, _object.objectEach)(prop, function (value, key) {
-        _this5.setCellMeta(row, column, key, value);
+        _this6.setCellMeta(row, column, key, value);
       });
     }
   };
@@ -3834,7 +3932,8 @@ function Core(rootElement, userSettings) {
     return Math.min(maxCols, dataLen);
   };
   /**
-   * Returns the number of rendered rows (including rows partially or fully rendered outside viewport).
+   * Returns the number of rendered rows including rows that are partially or fully rendered
+   * outside the table viewport.
    *
    * @memberof Core#
    * @function countRenderedRows
@@ -3843,10 +3942,11 @@ function Core(rootElement, userSettings) {
 
 
   this.countRenderedRows = function () {
-    return instance.view.wt.drawn ? instance.view.wt.wtTable.getRenderedRowsCount() : -1;
+    return instance.view._wt.drawn ? instance.view._wt.wtTable.getRenderedRowsCount() : -1;
   };
   /**
-   * Returns the number of visible rows (rendered rows that fully fit inside viewport).
+   * Returns the number of rendered rows that are only visible in the table viewport.
+   * The rows that are partially visible are not counted.
    *
    * @memberof Core#
    * @function countVisibleRows
@@ -3855,10 +3955,11 @@ function Core(rootElement, userSettings) {
 
 
   this.countVisibleRows = function () {
-    return instance.view.wt.drawn ? instance.view.wt.wtTable.getVisibleRowsCount() : -1;
+    return instance.view._wt.drawn ? instance.view._wt.wtTable.getVisibleRowsCount() : -1;
   };
   /**
-   * Returns the number of rendered columns (including columns partially or fully rendered outside viewport).
+   * Returns the number of rendered rows including columns that are partially or fully rendered
+   * outside the table viewport.
    *
    * @memberof Core#
    * @function countRenderedCols
@@ -3867,10 +3968,11 @@ function Core(rootElement, userSettings) {
 
 
   this.countRenderedCols = function () {
-    return instance.view.wt.drawn ? instance.view.wt.wtTable.getRenderedColumnsCount() : -1;
+    return instance.view._wt.drawn ? instance.view._wt.wtTable.getRenderedColumnsCount() : -1;
   };
   /**
-   * Returns the number of visible columns. Returns -1 if table is not visible.
+   * Returns the number of rendered columns that are only visible in the table viewport.
+   * The columns that are partially visible are not counted.
    *
    * @memberof Core#
    * @function countVisibleCols
@@ -3879,7 +3981,7 @@ function Core(rootElement, userSettings) {
 
 
   this.countVisibleCols = function () {
-    return instance.view.wt.drawn ? instance.view.wt.wtTable.getVisibleColumnsCount() : -1;
+    return instance.view._wt.drawn ? instance.view._wt.wtTable.getVisibleColumnsCount() : -1;
   };
   /**
    * Returns the number of empty rows. If the optional ending parameter is `true`, returns the
@@ -4189,7 +4291,7 @@ function Core(rootElement, userSettings) {
     var isColumnInteger = Number.isInteger(renderableColumn);
 
     if (isRowInteger && isColumnInteger) {
-      return instance.view.scrollViewport(new _src.CellCoords(renderableRow, renderableColumn), snapToTop, snapToRight, snapToBottom, snapToLeft);
+      return instance.view.scrollViewport(instance._createCellCoords(renderableRow, renderableColumn), snapToTop, snapToRight, snapToBottom, snapToLeft);
     }
 
     if (isRowInteger && isColumnInteger === false) {
@@ -4226,8 +4328,8 @@ function Core(rootElement, userSettings) {
     }
 
     dataSource = null;
+    this.getShortcutManager().destroy();
     metaManager.clearCache();
-    (0, _keyStateObserver.stopObserving)();
 
     if ((0, _rootInstance.isRootInstance)(instance)) {
       var licenseInfo = this.rootDocument.querySelector('#hot-display-license-info');
@@ -4625,6 +4727,337 @@ function Core(rootElement, userSettings) {
     return instance.isLtr() ? 1 : -1;
   };
 
+  var shortcutManager = (0, _shortcuts.createShortcutManager)({
+    beforeKeyDown: function beforeKeyDown(event) {
+      if (_this.isListening() === false) {
+        // Performing action (executing a callback) and triggering hook only for listening Handsontable.
+        return false;
+      }
+
+      return _this.runHooks('beforeKeyDown', event);
+    },
+    afterKeyDown: function afterKeyDown(event) {
+      if (_this.isDestroyed) {
+        // Handsontable could be destroyed after performing action (executing a callback).
+        return;
+      }
+
+      instance.runHooks('afterDocumentKeyDown', event);
+    },
+    ownerWindow: this.rootWindow
+  });
+  /**
+   * Returns instance of a manager responsible for handling shortcuts stored in some contexts. It run actions after
+   * pressing key combination in active Handsontable instance.
+   *
+   * @memberof Core#
+   * @since 12.0.0
+   * @function getShortcutManager
+   * @returns {ShortcutManager} Instance of {@link ShortcutManager}
+   */
+
+  this.getShortcutManager = function () {
+    return shortcutManager;
+  };
+
+  var gridContext = shortcutManager.addContext('grid');
+  var gridConfig = {
+    runOnlyIf: function runOnlyIf() {
+      return (0, _mixed.isDefined)(instance.getSelected()) && instance.countRenderedRows() > 0 && instance.countRenderedCols() > 0;
+    },
+    group: SHORTCUTS_GROUP
+  };
+  shortcutManager.setActiveContextName('grid');
+  gridContext.addShortcuts([{
+    keys: [['Control/Meta', 'A']],
+    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.getFirstNotHiddenIndex(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.getFirstNotHiddenIndex(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.getFirstNotHiddenIndex(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.getFirstNotHiddenIndex(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).getFirstNotHiddenIndex.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).getFirstNotHiddenIndex.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).getFirstNotHiddenIndex.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).getFirstNotHiddenIndex.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.getFirstNotHiddenIndex(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.getFirstNotHiddenIndex(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.getFirstNotHiddenIndex(fixedRows, 1);
+      var column = instance.columnIndexMapper.getFirstNotHiddenIndex(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.getFirstNotHiddenIndex(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.getFirstNotHiddenIndex(instance.countCols() - 1, -1)));
+    }
+  }, {
+    keys: [['End', 'Control/Meta']],
+    captureCtrl: true,
+    callback: function callback() {
+      var fixedRows = parseInt(instance.getSettings().fixedRowsBottom, 10);
+      var row = instance.rowIndexMapper.getFirstNotHiddenIndex(instance.countRows() - fixedRows - 1, -1);
+      var column = instance.columnIndexMapper.getFirstNotHiddenIndex(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.getFirstNotHiddenIndex(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.getFirstNotHiddenIndex(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);
   (0, _registry.getPluginsNames)().forEach(function (pluginName) {
     var PluginClass = (0, _registry.getPlugin)(pluginName);
     pluginsRegistry.addItem(pluginName, new PluginClass(_this));