handsontable 11.0.0 → 12.0.0

package/editors/textEditor/caretPositioner.mjs

@@ -0,0 +1,42 @@
+import "core-js/modules/es.regexp.exec.js";
+import "core-js/modules/es.string.split.js";
+import { getCaretPosition, setCaretPosition } from "../../helpers/dom/element.mjs";
+/**
+ * Updates the textarea caret position depends on the action executed on that element.
+ *
+ * The following actions are supported:
+ *  - 'home': Move the caret to the beginning of the current line;
+ *  - 'end': Move the caret to the end of the current line.
+ *
+ * @param {'home'|'end'} actionName The action to perform that modifies the caret behavior.
+ * @param {HTMLTextAreaElement} textareaElement The textarea element where the action is supposed to happen.
+ */
+
+export function updateCaretPosition(actionName, textareaElement) {
+  var caretPosition = getCaretPosition(textareaElement);
+  var textLines = textareaElement.value.split('\n');
+  var newCaretPosition = caretPosition;
+  var lineStartIndex = 0;
+
+  for (var i = 0; i < textLines.length; i++) {
+    var textLine = textLines[i];
+
+    if (i !== 0) {
+      lineStartIndex += textLines[i - 1].length + 1;
+    }
+
+    var lineEndIndex = lineStartIndex + textLine.length;
+
+    if (actionName === 'home') {
+      newCaretPosition = lineStartIndex;
+    } else if (actionName === 'end') {
+      newCaretPosition = lineEndIndex;
+    }
+
+    if (caretPosition <= lineEndIndex) {
+      break;
+    }
+  }
+
+  setCaretPosition(textareaElement, newCaretPosition);
+}

package/editors/textEditor/textEditor.js

@@ -1,6 +1,6 @@
 "use strict";
 
-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); }
 
 require("core-js/modules/es.object.to-string.js");
 
@@ -22,14 +22,16 @@ require("core-js/modules/es.string.iterator.js");
 
 require("core-js/modules/web.dom-collections.iterator.js");
 
-exports.__esModule = true;
-exports.TextEditor = exports.EDITOR_TYPE = void 0;
+require("core-js/modules/es.array.slice.js");
 
-require("core-js/modules/es.array.includes.js");
+require("core-js/modules/es.function.name.js");
 
-require("core-js/modules/es.array.concat.js");
+require("core-js/modules/es.array.from.js");
 
-require("core-js/modules/es.array.slice.js");
+require("core-js/modules/es.regexp.exec.js");
+
+exports.__esModule = true;
+exports.TextEditor = exports.EDITOR_TYPE = void 0;
 
 require("core-js/modules/es.array.index-of.js");
 
@@ -45,27 +47,45 @@ var _browser = require("../../helpers/browser");
 
 var _element = require("../../helpers/dom/element");
 
-var _event = require("../../helpers/dom/event");
-
 var _number = require("../../helpers/number");
 
 var _unicode = require("../../helpers/unicode");
 
 var _autoResize = require("../../3rdparty/autoResize");
 
+var _mixed = require("../../helpers/mixed");
+
+var _editorManager = require("../../editorManager");
+
+var _baseEditor2 = require("../baseEditor/baseEditor");
+
+var _caretPositioner = require("./caretPositioner");
+
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
+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 _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+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; }
+
+function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
 function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
 
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
 
-function _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get(target, property, receiver || target); }
+function _get() { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(arguments.length < 3 ? target : receiver); } return desc.value; }; } return _get.apply(this, arguments); }
 
 function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
 
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
 
 function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
 
@@ -81,6 +101,7 @@ function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.g
 
 var EDITOR_VISIBLE_CLASS_NAME = 'ht_editor_visible';
 var EDITOR_HIDDEN_CLASS_NAME = 'ht_editor_hidden';
+var SHORTCUTS_GROUP = 'textEditor';
 var EDITOR_TYPE = 'text';
 /**
  * @private
@@ -205,9 +226,12 @@ var TextEditor = /*#__PURE__*/function (_BaseEditor) {
       this.refreshDimensions(); // need it instantly, to prevent https://github.com/handsontable/handsontable/issues/348
 
       this.showEditableElement();
-      this.addHook('beforeKeyDown', function (event) {
-        return _this2.onBeforeKeyDown(event);
+      var shortcutManager = this.hot.getShortcutManager();
+      shortcutManager.setActiveContextName('editor');
+      this.addHook('afterDocumentKeyDown', function (event) {
+        return _this2.onAfterDocumentKeyDown(event);
       });
+      this.registerShortcuts();
     }
     /**
      * Closes the editor.
@@ -223,7 +247,8 @@ var TextEditor = /*#__PURE__*/function (_BaseEditor) {
       }
 
       this.hideEditableElement();
-      this.removeHooksByKey('beforeKeyDown');
+      this.unregisterShortcuts();
+      this.removeHooksByKey('afterDocumentKeyDown');
     }
     /**
      * Prepares editor's meta data.
@@ -249,7 +274,7 @@ var TextEditor = /*#__PURE__*/function (_BaseEditor) {
             fragmentSelection = cellProperties.fragmentSelection;
 
         if (allowInvalid) {
-          // Remove an empty space from texarea (added by copyPaste plugin to make copy/paste
+          // Remove an empty space from textarea (added by copyPaste plugin to make copy/paste
           // functionality work with IME)
           this.TEXTAREA.value = '';
         }
@@ -281,7 +306,7 @@ var TextEditor = /*#__PURE__*/function (_BaseEditor) {
         return;
       }
 
-      this.TEXTAREA.value = ''; // Remove an empty space from texarea (added by copyPaste plugin to make copy/paste functionality work with IME).
+      this.TEXTAREA.value = ''; // Remove an empty space from textarea (added by copyPaste plugin to make copy/paste functionality work with IME).
 
       _get(_getPrototypeOf(TextEditor.prototype), "beginEditing", this).call(this, newInitialValue, event);
     }
@@ -294,7 +319,7 @@ var TextEditor = /*#__PURE__*/function (_BaseEditor) {
     value: function focus() {
       // For IME editor textarea element must be focused using ".select" method.
       // Using ".focus" browser automatically scroll into the focused element which
-      // is undesire effect.
+      // is undesired effect.
       this.TEXTAREA.select();
       (0, _element.setCaretPosition)(this.TEXTAREA, this.TEXTAREA.value.length);
     }
@@ -343,11 +368,7 @@ var TextEditor = /*#__PURE__*/function (_BaseEditor) {
       this.textareaStyle.overflowY = 'visible';
       this.textareaParentStyle.opacity = '0';
       this.textareaParentStyle.height = '1px';
-
-      if ((0, _element.hasClass)(this.TEXTAREA_PARENT, this.layerClass)) {
-        (0, _element.removeClass)(this.TEXTAREA_PARENT, this.layerClass);
-      }
-
+      (0, _element.removeClass)(this.TEXTAREA_PARENT, this.layerClass);
       (0, _element.addClass)(this.TEXTAREA_PARENT, EDITOR_HIDDEN_CLASS_NAME);
     }
     /**
@@ -362,7 +383,7 @@ var TextEditor = /*#__PURE__*/function (_BaseEditor) {
       this.textareaParentStyle.height = '';
       this.textareaParentStyle.overflow = '';
       this.textareaParentStyle.position = '';
-      this.textareaParentStyle.right = 'auto';
+      this.textareaParentStyle[this.hot.isRtl() ? 'left' : 'right'] = 'auto';
       this.textareaParentStyle.opacity = '1';
       this.textareaStyle.textIndent = '';
       this.textareaStyle.overflowY = 'hidden';
@@ -430,98 +451,34 @@ var TextEditor = /*#__PURE__*/function (_BaseEditor) {
         return;
       }
 
-      var _this$hot$view$wt = this.hot.view.wt,
-          wtOverlays = _this$hot$view$wt.wtOverlays,
-          wtViewport = _this$hot$view$wt.wtViewport;
-      var currentOffset = (0, _element.offset)(this.TD);
-      var containerOffset = (0, _element.offset)(this.hot.rootElement);
-      var scrollableContainerTop = wtOverlays.topOverlay.holder;
-      var scrollableContainerLeft = wtOverlays.leftOverlay.holder;
-      var containerScrollTop = scrollableContainerTop !== this.hot.rootWindow ? scrollableContainerTop.scrollTop : 0;
-      var containerScrollLeft = scrollableContainerLeft !== this.hot.rootWindow ? scrollableContainerLeft.scrollLeft : 0;
-      var editorSection = this.checkEditorSection();
-      var scrollTop = ['', 'left'].includes(editorSection) ? containerScrollTop : 0;
-      var scrollLeft = ['', 'top', 'bottom'].includes(editorSection) ? containerScrollLeft : 0; // If colHeaders is disabled, cells in the first row have border-top
-
-      var editTopModifier = currentOffset.top === containerOffset.top ? 0 : 1;
-      var backgroundColor = this.TD.style.backgroundColor;
-      var editTop = currentOffset.top - containerOffset.top - editTopModifier - scrollTop;
-      var editLeft = currentOffset.left - containerOffset.left - 1 - scrollLeft;
-      var cssTransformOffset; // TODO: Refactor this to the new instance.getCell method (from #ply-59), after 0.12.1 is released
-
-      switch (editorSection) {
-        case 'top':
-          cssTransformOffset = (0, _element.getCssTransform)(wtOverlays.topOverlay.clone.wtTable.holder.parentNode);
-          break;
-
-        case 'left':
-          cssTransformOffset = (0, _element.getCssTransform)(wtOverlays.leftOverlay.clone.wtTable.holder.parentNode);
-          break;
-
-        case 'top-left-corner':
-          cssTransformOffset = (0, _element.getCssTransform)(wtOverlays.topLeftCornerOverlay.clone.wtTable.holder.parentNode);
-          break;
-
-        case 'bottom-left-corner':
-          cssTransformOffset = (0, _element.getCssTransform)(wtOverlays.bottomLeftCornerOverlay.clone.wtTable.holder.parentNode);
-          break;
-
-        case 'bottom':
-          cssTransformOffset = (0, _element.getCssTransform)(wtOverlays.bottomOverlay.clone.wtTable.holder.parentNode);
-          break;
-
-        default:
-          break;
-      }
-
-      var hasColumnHeaders = this.hot.hasColHeaders();
-      var renderableRow = this.hot.rowIndexMapper.getRenderableFromVisualIndex(this.row);
-      var renderableColumn = this.hot.columnIndexMapper.getRenderableFromVisualIndex(this.col);
-      var nrOfRenderableRowIndexes = this.hot.rowIndexMapper.getRenderableIndexesLength();
-      var firstRowIndexOfTheBottomOverlay = nrOfRenderableRowIndexes - this.hot.view.wt.getSetting('fixedRowsBottom');
-
-      if (hasColumnHeaders && renderableRow <= 0 || renderableRow === firstRowIndexOfTheBottomOverlay) {
-        editTop += 1;
-      }
-
-      if (renderableColumn <= 0) {
-        editLeft += 1;
-      }
-
-      if (cssTransformOffset && cssTransformOffset !== -1) {
-        this.textareaParentStyle[cssTransformOffset[0]] = cssTransformOffset[1];
-      } else {
-        (0, _element.resetCssTransform)(this.TEXTAREA_PARENT);
-      }
+      var _this$getEditedCellRe = this.getEditedCellRect(),
+          top = _this$getEditedCellRe.top,
+          start = _this$getEditedCellRe.start,
+          width = _this$getEditedCellRe.width,
+          maxWidth = _this$getEditedCellRe.maxWidth,
+          height = _this$getEditedCellRe.height,
+          maxHeight = _this$getEditedCellRe.maxHeight;
 
-      this.textareaParentStyle.top = "".concat(editTop, "px");
-      this.textareaParentStyle.left = "".concat(editLeft, "px");
+      this.textareaParentStyle.top = "".concat(top, "px");
+      this.textareaParentStyle[this.hot.isRtl() ? 'right' : 'left'] = "".concat(start, "px");
       this.showEditableElement();
-      var firstRowOffset = wtViewport.rowsRenderCalculator.startPosition;
-      var firstColumnOffset = wtViewport.columnsRenderCalculator.startPosition;
-      var horizontalScrollPosition = wtOverlays.leftOverlay.getScrollPosition();
-      var verticalScrollPosition = wtOverlays.topOverlay.getScrollPosition();
-      var scrollbarWidth = (0, _element.getScrollbarWidth)(this.hot.rootDocument);
-      var cellTopOffset = this.TD.offsetTop + firstRowOffset - verticalScrollPosition;
-      var cellLeftOffset = this.TD.offsetLeft + firstColumnOffset - horizontalScrollPosition;
-      var width = (0, _element.innerWidth)(this.TD) - 8;
-      var actualVerticalScrollbarWidth = (0, _element.hasVerticalScrollbar)(scrollableContainerTop) ? scrollbarWidth : 0;
-      var actualHorizontalScrollbarWidth = (0, _element.hasHorizontalScrollbar)(scrollableContainerLeft) ? scrollbarWidth : 0;
-      var maxWidth = this.hot.view.maximumVisibleElementWidth(cellLeftOffset) - 9 - actualVerticalScrollbarWidth;
-      var height = this.TD.scrollHeight + 1;
-      var maxHeight = Math.max(this.hot.view.maximumVisibleElementHeight(cellTopOffset) - actualHorizontalScrollbarWidth, 23); // eslint-disable-line max-len
-
       var cellComputedStyle = (0, _element.getComputedStyle)(this.TD, this.hot.rootWindow);
       this.TEXTAREA.style.fontSize = cellComputedStyle.fontSize;
       this.TEXTAREA.style.fontFamily = cellComputedStyle.fontFamily;
-      this.TEXTAREA.style.backgroundColor = backgroundColor;
+      this.TEXTAREA.style.backgroundColor = this.TD.style.backgroundColor;
+      var textareaComputedStyle = (0, _element.getComputedStyle)(this.TEXTAREA);
+      var horizontalPadding = parseInt(textareaComputedStyle.paddingLeft, 10) + parseInt(textareaComputedStyle.paddingRight, 10);
+      var verticalPadding = parseInt(textareaComputedStyle.paddingTop, 10) + parseInt(textareaComputedStyle.paddingBottom, 10);
+      var finalWidth = width - horizontalPadding;
+      var finalHeight = height - verticalPadding;
+      var finalMaxWidth = maxWidth - horizontalPadding;
+      var finalMaxHeight = maxHeight - verticalPadding;
       this.autoResize.init(this.TEXTAREA, {
-        minHeight: Math.min(height, maxHeight),
-        maxHeight: maxHeight,
-        // TEXTAREA should never be higher than visible part of the viewport (should not cover the scrollbar)
-        minWidth: Math.min(width, maxWidth),
-        maxWidth: maxWidth // TEXTAREA should never be wider than visible part of the viewport (should not cover the scrollbar)
-
+        minWidth: Math.min(finalWidth, finalMaxWidth),
+        minHeight: Math.min(finalHeight, finalMaxHeight),
+        // TEXTAREA should never be wider than visible part of the viewport (should not cover the scrollbar)
+        maxWidth: finalMaxWidth,
+        maxHeight: finalMaxHeight
       }, true);
     }
     /**
@@ -588,86 +545,153 @@ var TextEditor = /*#__PURE__*/function (_BaseEditor) {
       this.clearHooks();
     }
     /**
-     * OnBeforeKeyDown callback.
+     * Register shortcuts responsible for handling editor.
      *
-     * @param {Event} event The keyboard event object.
+     * @private
      */
 
   }, {
-    key: "onBeforeKeyDown",
-    value: function onBeforeKeyDown(event) {
-      // catch CTRL but not right ALT (which in some systems triggers ALT+CTRL)
-      var ctrlDown = (event.ctrlKey || event.metaKey) && !event.altKey; // Process only events that have been fired in the editor
+    key: "registerShortcuts",
+    value: function registerShortcuts() {
+      var _this4 = this;
+
+      var shortcutManager = this.hot.getShortcutManager();
+      var editorContext = shortcutManager.getContext('editor');
+      var contextConfig = {
+        runOnlyIf: function runOnlyIf() {
+          return (0, _mixed.isDefined)(_this4.hot.getSelected());
+        },
+        group: SHORTCUTS_GROUP
+      };
+
+      var insertNewLine = function insertNewLine() {
+        _this4.hot.rootDocument.execCommand('insertText', false, '\n');
+      };
+
+      editorContext.addShortcuts([{
+        keys: [['Tab']],
+        // TODO: Duplicated part of code (callback to shortcut).
+        callback: function callback(event) {
+          var tableMeta = _this4.hot.getSettings();
+
+          var tabMoves = typeof tableMeta.tabMoves === 'function' ? tableMeta.tabMoves(event) : tableMeta.tabMoves;
+
+          _this4.hot.selection.transformStart(tabMoves.row, tabMoves.col, true);
+        }
+      }, {
+        keys: [['Shift', 'Tab']],
+        // TODO: Duplicated part of code (callback to shortcut).
+        callback: function callback(event) {
+          var tableMeta = _this4.hot.getSettings();
 
-      if (event.target !== this.TEXTAREA || (0, _event.isImmediatePropagationStopped)(event)) {
-        return;
-      }
+          var tabMoves = typeof tableMeta.tabMoves === 'function' ? tableMeta.tabMoves(event) : tableMeta.tabMoves;
 
-      switch (event.keyCode) {
-        case _unicode.KEY_CODES.ARROW_RIGHT:
-          if (this.isInFullEditMode()) {
-            if (!this.isWaiting() && !this.allowKeyEventPropagation(event.keyCode)) {
-              (0, _event.stopImmediatePropagation)(event);
-            }
-          }
-
-          break;
-
-        case _unicode.KEY_CODES.ARROW_LEFT:
-          if (this.isInFullEditMode()) {
-            if (!this.isWaiting() && !this.allowKeyEventPropagation(event.keyCode)) {
-              (0, _event.stopImmediatePropagation)(event);
-            }
-          }
-
-          break;
-
-        case _unicode.KEY_CODES.ARROW_UP:
-        case _unicode.KEY_CODES.ARROW_DOWN:
-          if (this.isInFullEditMode()) {
-            if (!this.isWaiting() && !this.allowKeyEventPropagation(event.keyCode)) {
-              (0, _event.stopImmediatePropagation)(event);
-            }
-          }
-
-          break;
-
-        case _unicode.KEY_CODES.ENTER:
-          {
-            var isMultipleSelection = this.hot.selection.isMultiple();
-
-            if (ctrlDown && !isMultipleSelection || event.altKey) {
-              // if ctrl+enter or alt+enter, add new line
-              if (this.isOpened()) {
-                var caretPosition = (0, _element.getCaretPosition)(this.TEXTAREA);
-                var value = this.getValue();
-                var newValue = "".concat(value.slice(0, caretPosition), "\n").concat(value.slice(caretPosition));
-                this.setValue(newValue);
-                (0, _element.setCaretPosition)(this.TEXTAREA, caretPosition + 1);
-              } else {
-                this.beginEditing("".concat(this.originalValue, "\n"));
-              }
-
-              (0, _event.stopImmediatePropagation)(event);
-            }
-
-            event.preventDefault(); // don't add newline to field
-
-            break;
-          }
-
-        case _unicode.KEY_CODES.BACKSPACE:
-        case _unicode.KEY_CODES.DELETE:
-        case _unicode.KEY_CODES.HOME:
-        case _unicode.KEY_CODES.END:
-          (0, _event.stopImmediatePropagation)(event); // backspace, delete, home, end should only work locally when cell is edited (not in table context)
-
-          break;
-
-        default:
-          break;
-      }
+          _this4.hot.selection.transformStart(-tabMoves.row, -tabMoves.col);
+        }
+      }, {
+        keys: [['Control', 'Enter']],
+        callback: function callback() {
+          insertNewLine();
+          return false; // Will block closing editor.
+        },
+        runOnlyIf: function runOnlyIf(event) {
+          return !_this4.hot.selection.isMultiple() && // We trigger a data population for multiple selection.
+          // catch CTRL but not right ALT (which in some systems triggers ALT+CTRL)
+          !event.altKey;
+        },
+        relativeToGroup: _editorManager.SHORTCUTS_GROUP_EDITOR,
+        position: 'before'
+      }, {
+        keys: [['Meta', 'Enter']],
+        callback: function callback() {
+          insertNewLine();
+          return false; // Will block closing editor.
+        },
+        runOnlyIf: function runOnlyIf() {
+          return !_this4.hot.selection.isMultiple();
+        },
+        // We trigger a data population for multiple selection.
+        relativeToGroup: _editorManager.SHORTCUTS_GROUP_EDITOR,
+        position: 'before'
+      }, {
+        keys: [['Alt', 'Enter']],
+        callback: function callback() {
+          insertNewLine();
+          return false; // Will block closing editor.
+        },
+        relativeToGroup: _editorManager.SHORTCUTS_GROUP_EDITOR,
+        position: 'before'
+      }, {
+        // TODO: Duplicated part of code (callback to shortcut)
+        keys: [['PageUp']],
+        callback: function callback() {
+          _this4.hot.selection.transformStart(-_this4.hot.countVisibleRows(), 0);
+        }
+      }, {
+        // TODO: Duplicated part of code (callback to shortcut)
+        keys: [['PageDown']],
+        callback: function callback() {
+          _this4.hot.selection.transformStart(_this4.hot.countVisibleRows(), 0);
+        }
+      }, {
+        keys: [['Home']],
+        callback: function callback(event, _ref) {
+          var _ref2 = _slicedToArray(_ref, 1),
+              keyName = _ref2[0];
 
+          (0, _caretPositioner.updateCaretPosition)(keyName, _this4.TEXTAREA);
+        }
+      }, {
+        keys: [['End']],
+        callback: function callback(event, _ref3) {
+          var _ref4 = _slicedToArray(_ref3, 1),
+              keyName = _ref4[0];
+
+          (0, _caretPositioner.updateCaretPosition)(keyName, _this4.TEXTAREA);
+        }
+      }, {
+        keys: [['Control/Meta', 'Z']],
+        preventDefault: false,
+        callback: function callback() {
+          _this4.hot._registerTimeout(function () {
+            _this4.autoResize.resize();
+          }, 10);
+        }
+      }, {
+        keys: [['Control/Meta', 'Shift', 'Z']],
+        preventDefault: false,
+        callback: function callback() {
+          _this4.hot._registerTimeout(function () {
+            _this4.autoResize.resize();
+          }, 10);
+        }
+      }], contextConfig);
+    }
+    /**
+     * Unregister shortcuts responsible for handling editor.
+     *
+     * @private
+     */
+
+  }, {
+    key: "unregisterShortcuts",
+    value: function unregisterShortcuts() {
+      var shortcutManager = this.hot.getShortcutManager();
+      var editorContext = shortcutManager.getContext('editor');
+      editorContext.removeShortcutsByGroup(_editorManager.SHORTCUTS_GROUP_NAVIGATION);
+      editorContext.removeShortcutsByGroup(SHORTCUTS_GROUP);
+      editorContext.removeShortcutsByGroup(_baseEditor2.SHORTCUTS_GROUP_EDITOR);
+    }
+    /**
+     * OnAfterDocumentKeyDown callback.
+     *
+     * @private
+     * @param {KeyboardEvent} event The keyboard event object.
+     */
+
+  }, {
+    key: "onAfterDocumentKeyDown",
+    value: function onAfterDocumentKeyDown(event) {
       var arrowKeyCodes = [_unicode.KEY_CODES.ARROW_UP, _unicode.KEY_CODES.ARROW_RIGHT, _unicode.KEY_CODES.ARROW_DOWN, _unicode.KEY_CODES.ARROW_LEFT];
 
       if (arrowKeyCodes.indexOf(event.keyCode) === -1) {