handsontable 0.0.0-next-08765b9-20230809 → 0.0.0-next-7e1ba35-20230821

package/core.mjs

@@ -27,21 +27,11 @@ import { hasLanguageDictionary, getValidLanguageCode, getTranslatedPhrase } from
 import { warnUserAboutLanguageRegistration, normalizeLanguageCode } from "./i18n/utils.mjs";
 import { Selection } from "./selection/index.mjs";
 import { MetaManager, DynamicCellMetaMod, ExtendMetaPropertiesMod, replaceData } from "./dataMap/index.mjs";
-import { installFocusCatcher } from "./core/index.mjs";
 import { createUniqueMap } from "./utils/dataStructures/uniqueMap.mjs";
 import { createShortcutManager } from "./shortcuts/index.mjs";
-import { registerAllShortcutContexts } from "./shortcutContexts/index.mjs";
+const SHORTCUTS_GROUP = 'gridDefault';
 let activeGuid = null;
 
-/**
- * Keeps the collection of the all Handsontable instances created on the same page. The
- * list is then used to trigger the "afterUnlisten" hook when the "listen()" method was
- * called on another instance.
- *
- * @type {Map<string, Core>}
- */
-const foreignHotInstances = new Map();
-
 /**
  * A set of deprecated feature names.
  *
@@ -101,8 +91,7 @@ const deprecationWarns = new Set();
  * @param {boolean} [rootInstanceSymbol=false] Indicates if the instance is root of all later instances created.
  */
 export default function Core(rootElement, userSettings) {
-  var _userSettings$layoutD,
-    _this = this;
+  var _userSettings$layoutD;
   let rootInstanceSymbol = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
   let preventScrollingToCell = false;
   let instance = this;
@@ -219,8 +208,6 @@ export default function Core(rootElement, userSettings) {
   }
   this.guid = `ht_${randomString()}`; // this is the namespace for global events
 
-  foreignHotInstances.set(this.guid, this);
-
   /**
    * Instance of index mapper which is responsible for managing the column indexes.
    *
@@ -269,16 +256,14 @@ export default function Core(rootElement, userSettings) {
   };
 
   let selection = new Selection(tableMeta, {
-    rowIndexMapper: instance.rowIndexMapper,
-    columnIndexMapper: instance.columnIndexMapper,
+    rowIndexMapper: () => instance.rowIndexMapper,
+    columnIndexMapper: () => instance.columnIndexMapper,
     countCols: () => instance.countCols(),
     countRows: () => instance.countRows(),
     propToCol: prop => datamap.propToCol(prop),
     isEditorOpened: () => instance.getActiveEditor() ? instance.getActiveEditor().isOpened() : false,
-    countRenderableColumns: () => this.view.countRenderableColumns(),
-    countRenderableRows: () => this.view.countRenderableRows(),
-    countRowHeaders: () => this.countRowHeaders(),
-    countColHeaders: () => this.countColHeaders(),
+    countColsTranslated: () => this.view.countRenderableColumns(),
+    countRowsTranslated: () => this.view.countRenderableRows(),
     getShortcutManager: () => instance.getShortcutManager(),
     createCellCoords: (row, column) => instance._createCellCoords(row, column),
     createCellRange: (highlight, from, to) => instance._createCellRange(highlight, from, to),
@@ -305,6 +290,12 @@ export default function Core(rootElement, userSettings) {
   });
   this.selection.addLocalHook('beforeSetRangeEnd', 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', cellCoords => {
     const preventScrolling = createObjectPropListener(false);
@@ -331,14 +322,7 @@ export default function Core(rootElement, userSettings) {
     if (scrollToCell !== false) {
       if (!isSelectedByAnyHeader) {
         if (currentSelectedRange && !this.selection.isMultiple()) {
-          const 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);
-          }
+          this.view.scrollViewport(visualToRenderableCoords(currentSelectedRange.from));
         } else {
           this.view.scrollViewport(visualToRenderableCoords(cellCoords));
         }
@@ -380,30 +364,6 @@ 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('beforeSelectColumns', ...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('afterSelectColumns', ...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('beforeSelectRows', ...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('afterSelectRows', ...args);
-  });
   this.selection.addLocalHook('beforeModifyTransformStart', cellCoordsDelta => {
     this.runHooks('modifyTransformStart', cellCoordsDelta);
   });
@@ -1053,9 +1013,6 @@ export default function Core(rootElement, userSettings) {
     this.updateSettings(tableMeta, true);
     this.view = new TableView(this);
     editorManager = EditorManager.getInstance(instance, tableMeta, selection);
-    if (isRootInstance(this)) {
-      installFocusCatcher(instance);
-    }
     instance.runHooks('init');
     this.forceFullRender = true; // used when data was changed
     this.view.render();
@@ -1469,11 +1426,6 @@ export default function Core(rootElement, userSettings) {
    */
   this.listen = function () {
     if (instance && !instance.isListening()) {
-      foreignHotInstances.forEach(foreignHot => {
-        if (instance !== foreignHot) {
-          foreignHot.unlisten();
-        }
-      });
       activeGuid = instance.guid;
       instance.runHooks('afterListen');
     }
@@ -1558,8 +1510,8 @@ export default function Core(rootElement, userSettings) {
    * @returns {Array} Returns removed portion of columns.
    */
   this.spliceCol = function (column, index, amount) {
-    for (var _len5 = arguments.length, elements = new Array(_len5 > 3 ? _len5 - 3 : 0), _key5 = 3; _key5 < _len5; _key5++) {
-      elements[_key5 - 3] = arguments[_key5];
+    for (var _len = arguments.length, elements = new Array(_len > 3 ? _len - 3 : 0), _key = 3; _key < _len; _key++) {
+      elements[_key - 3] = arguments[_key];
     }
     return datamap.spliceCol(column, index, amount, ...elements);
   };
@@ -1576,8 +1528,8 @@ export default function Core(rootElement, userSettings) {
    * @returns {Array} Returns removed portion of rows.
    */
   this.spliceRow = function (row, index, amount) {
-    for (var _len6 = arguments.length, elements = new Array(_len6 > 3 ? _len6 - 3 : 0), _key6 = 3; _key6 < _len6; _key6++) {
-      elements[_key6 - 3] = arguments[_key6];
+    for (var _len2 = arguments.length, elements = new Array(_len2 > 3 ? _len2 - 3 : 0), _key2 = 3; _key2 < _len2; _key2++) {
+      elements[_key2 - 3] = arguments[_key2];
     }
     return datamap.spliceRow(row, index, amount, ...elements);
   };
@@ -1674,9 +1626,6 @@ export default function Core(rootElement, userSettings) {
     }
     const changes = [];
     arrayEach(selection.getSelectedRange(), cellRange => {
-      if (cellRange.isSingleHeader()) {
-        return;
-      }
       const topStart = cellRange.getTopStartCorner();
       const bottomEnd = cellRange.getBottomEndCorner();
       rangeEach(topStart.row, bottomEnd.row, row => {
@@ -2974,8 +2923,8 @@ export default function Core(rootElement, userSettings) {
    */
   this.spliceCellsMeta = function (visualIndex) {
     let deleteAmount = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-    for (var _len7 = arguments.length, cellMetaRows = new Array(_len7 > 2 ? _len7 - 2 : 0), _key7 = 2; _key7 < _len7; _key7++) {
-      cellMetaRows[_key7 - 2] = arguments[_key7];
+    for (var _len3 = arguments.length, cellMetaRows = new Array(_len3 > 2 ? _len3 - 2 : 0), _key3 = 2; _key3 < _len3; _key3++) {
+      cellMetaRows[_key3 - 2] = arguments[_key3];
     }
     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.');
@@ -3666,30 +3615,6 @@ export default function Core(rootElement, userSettings) {
     return instance.view._wt.drawn ? instance.view._wt.wtTable.getVisibleColumnsCount() : -1;
   };
 
-  /**
-   * Returns the number of rendered row headers.
-   *
-   * @since 14.0.0
-   * @memberof Core#
-   * @function countRowHeaders
-   * @returns {number} Number of row headers.
-   */
-  this.countRowHeaders = function () {
-    return this.view.getRowHeadersCount();
-  };
-
-  /**
-   * Returns the number of rendered column headers.
-   *
-   * @since 14.0.0
-   * @memberof Core#
-   * @function countColHeaders
-   * @returns {number} Number of column headers.
-   */
-  this.countColHeaders = function () {
-    return this.view.getColumnHeadersCount();
-  };
-
   /**
    * Returns the number of empty rows. If the optional ending parameter is `true`, returns the
    * number of empty rows at the bottom of the table.
@@ -3894,10 +3819,6 @@ 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');
    * ```
@@ -3908,15 +3829,11 @@ 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) {
     let endColumn = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : startColumn;
-    let focusPosition = arguments.length > 2 ? arguments[2] : undefined;
-    return selection.selectColumns(startColumn, endColumn, focusPosition);
+    return selection.selectColumns(startColumn, endColumn);
   };
 
   /**
@@ -3926,12 +3843,8 @@ export default function Core(rootElement, userSettings) {
    * ```js
    * // Select row using visual index.
    * hot.selectRows(1);
-   * // select a range of rows, using visual indexes.
+   * // Select 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#
@@ -3940,15 +3853,11 @@ 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) {
     let endRow = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : startRow;
-    let focusPosition = arguments.length > 2 ? arguments[2] : undefined;
-    return selection.selectRows(startRow, endRow, focusPosition);
+    return selection.selectRows(startRow, endRow);
   };
 
   /**
@@ -3967,16 +3876,9 @@ export default function Core(rootElement, userSettings) {
    * The previous selection is overwritten.
    *
    * ```js
-   * // select all cells in the table, including all headers and the corner cell
+   * // select all cells in the table, including all headers
    * 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);
    * ```
@@ -3984,20 +3886,15 @@ export default function Core(rootElement, userSettings) {
    * @since 0.38.2
    * @memberof Core#
    * @function selectAll
-   * @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.
+   * @param {boolean} [includeHeaders=true] `true`: include all row, column and corner headers.
+   * `false`: don't include any headers.
    */
   this.selectAll = function () {
-    let includeRowHeaders = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
-    let includeColumnHeaders = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : includeRowHeaders;
-    let focusPosition = arguments.length > 2 ? arguments[2] : undefined;
+    let includeHeaders = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+    const includeRowHeaders = includeHeaders && this.hasRowHeaders();
+    const includeColumnHeaders = includeHeaders && this.hasColHeaders();
     preventScrollingToCell = true;
-    selection.selectAll(includeRowHeaders, includeColumnHeaders, focusPosition);
+    selection.selectAll(includeRowHeaders, includeColumnHeaders);
     preventScrollingToCell = false;
   };
   const getIndexToScroll = (indexMapper, visualIndex) => {
@@ -4055,34 +3952,6 @@ 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 () {
-    let callback = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : () => {};
-    if (!this.selection.isSelected()) {
-      return;
-    }
-    this.addHookOnce('afterScroll', callback);
-    const {
-      highlight
-    } = this.getSelectedRangeLast();
-    const renderableRowIndex = this.rowIndexMapper.getRenderableFromVisualIndex(highlight.row);
-    const renderableColumnIndex = this.columnIndexMapper.getRenderableFromVisualIndex(highlight.col);
-    const isScrolled = this.view.scrollViewport(this._createCellCoords(renderableRowIndex, renderableColumnIndex));
-    if (isScrolled) {
-      this.view.render();
-    } else {
-      this.removeHook('afterScroll', callback);
-      this._registerImmediate(() => callback());
-    }
-  };
-
   /**
    * Removes the table from the DOM and destroys the instance of the Handsontable.
    *
@@ -4103,7 +3972,6 @@ export default function Core(rootElement, userSettings) {
     dataSource = null;
     this.getShortcutManager().destroy();
     metaManager.clearCache();
-    foreignHotInstances.delete(this.guid);
     if (isRootInstance(instance)) {
       const licenseInfo = this.rootDocument.querySelector('.hot-display-license-info');
       if (licenseInfo) {
@@ -4427,16 +4295,6 @@ 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.
    *
@@ -4509,11 +4367,270 @@ export default function Core(rootElement, userSettings) {
   this.getShortcutManager = function () {
     return shortcutManager;
   };
+  const gridContext = shortcutManager.addContext('grid');
+  const gridConfig = {
+    runOnlyIf: () => {
+      return isDefined(instance.getSelected()) && instance.countRenderedRows() > 0 && instance.countRenderedCols() > 0;
+    },
+    group: SHORTCUTS_GROUP
+  };
+  shortcutManager.setActiveContextName('grid');
+  gridContext.addShortcuts([{
+    keys: [['Control/Meta', 'A']],
+    callback: () => {
+      instance.selectAll();
+    }
+  }, {
+    keys: [['Control/Meta', 'Enter']],
+    callback: () => {
+      const selectedRange = instance.getSelectedRange();
+      const {
+        row: highlightRow,
+        col: highlightColumn
+      } = selectedRange[selectedRange.length - 1].highlight;
+      const valueToPopulate = instance.getDataAtCell(highlightRow, highlightColumn);
+      const cellValues = new Map();
+      for (let i = 0; i < selectedRange.length; i++) {
+        selectedRange[i].forAll((row, column) => {
+          if (row >= 0 && column >= 0 && (row !== highlightRow || column !== highlightColumn)) {
+            const {
+              readOnly
+            } = instance.getCellMeta(row, column);
+            if (!readOnly) {
+              cellValues.set(`${row}x${column}`, [row, column, valueToPopulate]);
+            }
+          }
+        });
+      }
+      instance.setDataAtCell(Array.from(cellValues.values()));
+    },
+    runOnlyIf: () => instance.getSelectedRangeLast().getCellsCount() > 1
+  }, {
+    keys: [['ArrowUp']],
+    callback: () => {
+      selection.transformStart(-1, 0);
+    }
+  }, {
+    keys: [['ArrowUp', 'Control/Meta']],
+    captureCtrl: true,
+    callback: () => {
+      selection.setRangeStart(instance._createCellCoords(instance.rowIndexMapper.getNearestNotHiddenIndex(0, 1), instance.getSelectedRangeLast().highlight.col));
+    }
+  }, {
+    keys: [['ArrowUp', 'Shift']],
+    callback: () => {
+      selection.transformEnd(-1, 0);
+    }
+  }, {
+    keys: [['ArrowUp', 'Shift', 'Control/Meta']],
+    captureCtrl: true,
+    callback: () => {
+      const {
+        from,
+        to
+      } = instance.getSelectedRangeLast();
+      const row = instance.rowIndexMapper.getNearestNotHiddenIndex(0, 1);
+      selection.setRangeStart(from.clone());
+      selection.setRangeEnd(instance._createCellCoords(row, to.col));
+    },
+    runOnlyIf: () => !(instance.selection.isSelectedByCorner() || instance.selection.isSelectedByColumnHeader())
+  }, {
+    keys: [['ArrowDown']],
+    callback: () => {
+      selection.transformStart(1, 0);
+    }
+  }, {
+    keys: [['ArrowDown', 'Control/Meta']],
+    captureCtrl: true,
+    callback: () => {
+      selection.setRangeStart(instance._createCellCoords(instance.rowIndexMapper.getNearestNotHiddenIndex(instance.countRows() - 1, -1), instance.getSelectedRangeLast().highlight.col));
+    }
+  }, {
+    keys: [['ArrowDown', 'Shift']],
+    callback: () => {
+      selection.transformEnd(1, 0);
+    }
+  }, {
+    keys: [['ArrowDown', 'Shift', 'Control/Meta']],
+    captureCtrl: true,
+    callback: () => {
+      const {
+        from,
+        to
+      } = instance.getSelectedRangeLast();
+      const row = instance.rowIndexMapper.getNearestNotHiddenIndex(instance.countRows() - 1, -1);
+      selection.setRangeStart(from.clone());
+      selection.setRangeEnd(instance._createCellCoords(row, to.col));
+    },
+    runOnlyIf: () => !(instance.selection.isSelectedByCorner() || instance.selection.isSelectedByColumnHeader())
+  }, {
+    keys: [['ArrowLeft']],
+    callback: () => {
+      selection.transformStart(0, -1 * instance.getDirectionFactor());
+    }
+  }, {
+    keys: [['ArrowLeft', 'Control/Meta']],
+    captureCtrl: true,
+    callback: () => {
+      const row = instance.getSelectedRangeLast().highlight.row;
+      const column = instance.columnIndexMapper.getNearestNotHiddenIndex(...(instance.isRtl() ? [instance.countCols() - 1, -1] : [0, 1]));
+      selection.setRangeStart(instance._createCellCoords(row, column));
+    }
+  }, {
+    keys: [['ArrowLeft', 'Shift']],
+    callback: () => {
+      selection.transformEnd(0, -1 * instance.getDirectionFactor());
+    }
+  }, {
+    keys: [['ArrowLeft', 'Shift', 'Control/Meta']],
+    captureCtrl: true,
+    callback: () => {
+      const {
+        from,
+        to
+      } = instance.getSelectedRangeLast();
+      const column = instance.columnIndexMapper.getNearestNotHiddenIndex(...(instance.isRtl() ? [instance.countCols() - 1, -1] : [0, 1]));
+      selection.setRangeStart(from.clone());
+      selection.setRangeEnd(instance._createCellCoords(to.row, column));
+    },
+    runOnlyIf: () => !(instance.selection.isSelectedByCorner() || instance.selection.isSelectedByRowHeader())
+  }, {
+    keys: [['ArrowRight']],
+    callback: () => {
+      selection.transformStart(0, instance.getDirectionFactor());
+    }
+  }, {
+    keys: [['ArrowRight', 'Control/Meta']],
+    captureCtrl: true,
+    callback: () => {
+      const row = instance.getSelectedRangeLast().highlight.row;
+      const column = instance.columnIndexMapper.getNearestNotHiddenIndex(...(instance.isRtl() ? [0, 1] : [instance.countCols() - 1, -1]));
+      selection.setRangeStart(instance._createCellCoords(row, column));
+    }
+  }, {
+    keys: [['ArrowRight', 'Shift']],
+    callback: () => {
+      selection.transformEnd(0, instance.getDirectionFactor());
+    }
+  }, {
+    keys: [['ArrowRight', 'Shift', 'Control/Meta']],
+    captureCtrl: true,
+    callback: () => {
+      const {
+        from,
+        to
+      } = instance.getSelectedRangeLast();
+      const column = instance.columnIndexMapper.getNearestNotHiddenIndex(...(instance.isRtl() ? [0, 1] : [instance.countCols() - 1, -1]));
+      selection.setRangeStart(from.clone());
+      selection.setRangeEnd(instance._createCellCoords(to.row, column));
+    },
+    runOnlyIf: () => !(instance.selection.isSelectedByCorner() || instance.selection.isSelectedByRowHeader())
+  }, {
+    keys: [['Home']],
+    captureCtrl: true,
+    callback: () => {
+      const fixedColumns = parseInt(instance.getSettings().fixedColumnsStart, 10);
+      const row = instance.getSelectedRangeLast().highlight.row;
+      const column = instance.columnIndexMapper.getNearestNotHiddenIndex(fixedColumns, 1);
+      selection.setRangeStart(instance._createCellCoords(row, column));
+    },
+    runOnlyIf: () => instance.view.isMainTableNotFullyCoveredByOverlays()
+  }, {
+    keys: [['Home', 'Shift']],
+    callback: () => {
+      selection.setRangeEnd(instance._createCellCoords(selection.selectedRange.current().from.row, instance.columnIndexMapper.getNearestNotHiddenIndex(0, 1)));
+    }
+  }, {
+    keys: [['Home', 'Control/Meta']],
+    captureCtrl: true,
+    callback: () => {
+      const fixedRows = parseInt(instance.getSettings().fixedRowsTop, 10);
+      const fixedColumns = parseInt(instance.getSettings().fixedColumnsStart, 10);
+      const row = instance.rowIndexMapper.getNearestNotHiddenIndex(fixedRows, 1);
+      const column = instance.columnIndexMapper.getNearestNotHiddenIndex(fixedColumns, 1);
+      selection.setRangeStart(instance._createCellCoords(row, column));
+    },
+    runOnlyIf: () => instance.view.isMainTableNotFullyCoveredByOverlays()
+  }, {
+    keys: [['End']],
+    captureCtrl: true,
+    callback: () => {
+      selection.setRangeStart(instance._createCellCoords(instance.getSelectedRangeLast().highlight.row, instance.columnIndexMapper.getNearestNotHiddenIndex(instance.countCols() - 1, -1)));
+    },
+    runOnlyIf: () => instance.view.isMainTableNotFullyCoveredByOverlays()
+  }, {
+    keys: [['End', 'Shift']],
+    callback: () => {
+      selection.setRangeEnd(instance._createCellCoords(selection.selectedRange.current().from.row, instance.columnIndexMapper.getNearestNotHiddenIndex(instance.countCols() - 1, -1)));
+    }
+  }, {
+    keys: [['End', 'Control/Meta']],
+    captureCtrl: true,
+    callback: () => {
+      const fixedRows = parseInt(instance.getSettings().fixedRowsBottom, 10);
+      const row = instance.rowIndexMapper.getNearestNotHiddenIndex(instance.countRows() - fixedRows - 1, -1);
+      const column = instance.columnIndexMapper.getNearestNotHiddenIndex(instance.countCols() - 1, -1);
+      selection.setRangeStart(instance._createCellCoords(row, column));
+    },
+    runOnlyIf: () => instance.view.isMainTableNotFullyCoveredByOverlays()
+  }, {
+    keys: [['PageUp']],
+    callback: () => {
+      selection.transformStart(-instance.countVisibleRows(), 0);
+    }
+  }, {
+    keys: [['PageUp', 'Shift']],
+    callback: () => {
+      const {
+        to
+      } = instance.getSelectedRangeLast();
+      const nextRowIndexToSelect = Math.max(to.row - instance.countVisibleRows(), 0);
+      const row = instance.rowIndexMapper.getNearestNotHiddenIndex(nextRowIndexToSelect, 1);
+      if (row !== null) {
+        const coords = instance._createCellCoords(row, to.col);
+        const scrollPadding = to.row - instance.view.getFirstFullyVisibleRow();
+        const nextVerticalScroll = Math.max(coords.row - scrollPadding, 0);
+        selection.setRangeEnd(coords);
+        instance.scrollViewportTo(nextVerticalScroll);
+      }
+    }
+  }, {
+    keys: [['PageDown']],
+    callback: () => {
+      selection.transformStart(instance.countVisibleRows(), 0);
+    }
+  }, {
+    keys: [['PageDown', 'Shift']],
+    callback: () => {
+      const {
+        to
+      } = instance.getSelectedRangeLast();
+      const nextRowIndexToSelect = Math.min(to.row + instance.countVisibleRows(), instance.countRows() - 1);
+      const row = instance.rowIndexMapper.getNearestNotHiddenIndex(nextRowIndexToSelect, -1);
+      if (row !== null) {
+        const coords = instance._createCellCoords(row, to.col);
+        const scrollPadding = to.row - instance.view.getFirstFullyVisibleRow();
+        const nextVerticalScroll = Math.min(coords.row - scrollPadding, instance.countRows() - 1);
+        selection.setRangeEnd(coords);
+        instance.scrollViewportTo(nextVerticalScroll);
+      }
+    }
+  }, {
+    keys: [['Tab']],
+    callback: event => {
+      const tabMoves = typeof tableMeta.tabMoves === 'function' ? tableMeta.tabMoves(event) : tableMeta.tabMoves;
+      selection.transformStart(tabMoves.row, tabMoves.col, true);
+    }
+  }, {
+    keys: [['Shift', 'Tab']],
+    callback: event => {
+      const tabMoves = typeof tableMeta.tabMoves === 'function' ? tableMeta.tabMoves(event) : tableMeta.tabMoves;
+      selection.transformStart(-tabMoves.row, -tabMoves.col);
+    }
+  }], gridConfig);
   getPluginsNames().forEach(pluginName => {
     const PluginClass = getPlugin(pluginName);
     pluginsRegistry.addItem(pluginName, new PluginClass(this));
   });
-  registerAllShortcutContexts(instance);
-  shortcutManager.setActiveContextName('grid');
   Hooks.getSingleton().run(instance, 'construct');
 }