handsontable 11.1.0 → 12.1.0

package/editors/textEditor/textEditor.mjs

@@ -1,8 +1,5 @@
 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); }
 
-import "core-js/modules/es.array.includes.js";
-import "core-js/modules/es.array.concat.js";
-import "core-js/modules/es.array.slice.js";
 import "core-js/modules/es.array.index-of.js";
 import "core-js/modules/es.object.set-prototype-of.js";
 import "core-js/modules/es.object.get-prototype-of.js";
@@ -16,6 +13,22 @@ import "core-js/modules/es.symbol.iterator.js";
 import "core-js/modules/es.array.iterator.js";
 import "core-js/modules/es.string.iterator.js";
 import "core-js/modules/web.dom-collections.iterator.js";
+import "core-js/modules/es.array.slice.js";
+import "core-js/modules/es.function.name.js";
+import "core-js/modules/es.array.from.js";
+import "core-js/modules/es.regexp.exec.js";
+
+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"); } }
 
@@ -23,13 +36,13 @@ function _defineProperties(target, props) { for (var i = 0; i < props.length; i+
 
 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() { 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 _get() { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get.bind(); } 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 } }); 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); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
 
 function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
 
@@ -39,18 +52,22 @@ function _assertThisInitialized(self) { if (self === void 0) { throw new Referen
 
 function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
 
-function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
 
 import { BaseEditor, EDITOR_STATE } from "../baseEditor/index.mjs";
 import EventManager from "../../eventManager.mjs";
 import { isMobileBrowser, isIE, isEdge, isIOS } from "../../helpers/browser.mjs";
-import { addClass, getCaretPosition, getComputedStyle, getCssTransform, getScrollbarWidth, innerWidth, offset, resetCssTransform, setCaretPosition, hasVerticalScrollbar, hasHorizontalScrollbar, hasClass, removeClass } from "../../helpers/dom/element.mjs";
-import { stopImmediatePropagation, isImmediatePropagationStopped } from "../../helpers/dom/event.mjs";
+import { addClass, getComputedStyle, setCaretPosition, hasClass, removeClass } from "../../helpers/dom/element.mjs";
 import { rangeEach } from "../../helpers/number.mjs";
 import { KEY_CODES } from "../../helpers/unicode.mjs";
 import { autoResize } from "../../3rdparty/autoResize/index.mjs";
+import { isDefined } from "../../helpers/mixed.mjs";
+import { SHORTCUTS_GROUP_NAVIGATION, SHORTCUTS_GROUP_EDITOR as EDITOR_MANAGER_GROUP } from "../../editorManager.mjs";
+import { SHORTCUTS_GROUP_EDITOR } from "../baseEditor/baseEditor.mjs";
+import { updateCaretPosition } from "./caretPositioner.mjs";
 var EDITOR_VISIBLE_CLASS_NAME = 'ht_editor_visible';
 var EDITOR_HIDDEN_CLASS_NAME = 'ht_editor_hidden';
+var SHORTCUTS_GROUP = 'textEditor';
 export var EDITOR_TYPE = 'text';
 /**
  * @private
@@ -173,9 +190,12 @@ export 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.
@@ -191,7 +211,8 @@ export var TextEditor = /*#__PURE__*/function (_BaseEditor) {
       }
 
       this.hideEditableElement();
-      this.removeHooksByKey('beforeKeyDown');
+      this.unregisterShortcuts();
+      this.removeHooksByKey('afterDocumentKeyDown');
     }
     /**
      * Prepares editor's meta data.
@@ -217,7 +238,7 @@ export 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 = '';
         }
@@ -249,7 +270,7 @@ export 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);
     }
@@ -262,7 +283,7 @@ export 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();
       setCaretPosition(this.TEXTAREA, this.TEXTAREA.value.length);
     }
@@ -311,11 +332,7 @@ export var TextEditor = /*#__PURE__*/function (_BaseEditor) {
       this.textareaStyle.overflowY = 'visible';
       this.textareaParentStyle.opacity = '0';
       this.textareaParentStyle.height = '1px';
-
-      if (hasClass(this.TEXTAREA_PARENT, this.layerClass)) {
-        removeClass(this.TEXTAREA_PARENT, this.layerClass);
-      }
-
+      removeClass(this.TEXTAREA_PARENT, this.layerClass);
       addClass(this.TEXTAREA_PARENT, EDITOR_HIDDEN_CLASS_NAME);
     }
     /**
@@ -330,7 +347,7 @@ export 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';
@@ -398,98 +415,34 @@ export 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 = offset(this.TD);
-      var containerOffset = 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 = getCssTransform(wtOverlays.topOverlay.clone.wtTable.holder.parentNode);
-          break;
-
-        case 'left':
-          cssTransformOffset = getCssTransform(wtOverlays.leftOverlay.clone.wtTable.holder.parentNode);
-          break;
-
-        case 'top-left-corner':
-          cssTransformOffset = getCssTransform(wtOverlays.topLeftCornerOverlay.clone.wtTable.holder.parentNode);
-          break;
-
-        case 'bottom-left-corner':
-          cssTransformOffset = getCssTransform(wtOverlays.bottomLeftCornerOverlay.clone.wtTable.holder.parentNode);
-          break;
-
-        case 'bottom':
-          cssTransformOffset = 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;
-      }
+      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;
 
-      if (renderableColumn <= 0) {
-        editLeft += 1;
-      }
-
-      if (cssTransformOffset && cssTransformOffset !== -1) {
-        this.textareaParentStyle[cssTransformOffset[0]] = cssTransformOffset[1];
-      } else {
-        resetCssTransform(this.TEXTAREA_PARENT);
-      }
-
-      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 = getScrollbarWidth(this.hot.rootDocument);
-      var cellTopOffset = this.TD.offsetTop + firstRowOffset - verticalScrollPosition;
-      var cellLeftOffset = this.TD.offsetLeft + firstColumnOffset - horizontalScrollPosition;
-      var width = innerWidth(this.TD) - 8;
-      var actualVerticalScrollbarWidth = hasVerticalScrollbar(scrollableContainerTop) ? scrollbarWidth : 0;
-      var actualHorizontalScrollbarWidth = 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 = 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 = 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);
     }
     /**
@@ -556,86 +509,153 @@ export 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 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 || isImmediatePropagationStopped(event)) {
-        return;
-      }
+          var tabMoves = typeof tableMeta.tabMoves === 'function' ? tableMeta.tabMoves(event) : tableMeta.tabMoves;
 
-      switch (event.keyCode) {
-        case KEY_CODES.ARROW_RIGHT:
-          if (this.isInFullEditMode()) {
-            if (!this.isWaiting() && !this.allowKeyEventPropagation(event.keyCode)) {
-              stopImmediatePropagation(event);
-            }
-          }
-
-          break;
-
-        case KEY_CODES.ARROW_LEFT:
-          if (this.isInFullEditMode()) {
-            if (!this.isWaiting() && !this.allowKeyEventPropagation(event.keyCode)) {
-              stopImmediatePropagation(event);
-            }
-          }
-
-          break;
-
-        case KEY_CODES.ARROW_UP:
-        case KEY_CODES.ARROW_DOWN:
-          if (this.isInFullEditMode()) {
-            if (!this.isWaiting() && !this.allowKeyEventPropagation(event.keyCode)) {
-              stopImmediatePropagation(event);
-            }
-          }
-
-          break;
-
-        case 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 = getCaretPosition(this.TEXTAREA);
-                var value = this.getValue();
-                var newValue = "".concat(value.slice(0, caretPosition), "\n").concat(value.slice(caretPosition));
-                this.setValue(newValue);
-                setCaretPosition(this.TEXTAREA, caretPosition + 1);
-              } else {
-                this.beginEditing("".concat(this.originalValue, "\n"));
-              }
-
-              stopImmediatePropagation(event);
-            }
-
-            event.preventDefault(); // don't add newline to field
-
-            break;
-          }
-
-        case KEY_CODES.BACKSPACE:
-        case KEY_CODES.DELETE:
-        case KEY_CODES.HOME:
-        case KEY_CODES.END:
-          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: EDITOR_MANAGER_GROUP,
+        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: EDITOR_MANAGER_GROUP,
+        position: 'before'
+      }, {
+        keys: [['Alt', 'Enter']],
+        callback: function callback() {
+          insertNewLine();
+          return false; // Will block closing editor.
+        },
+        relativeToGroup: EDITOR_MANAGER_GROUP,
+        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];
+
+          updateCaretPosition(keyName, _this4.TEXTAREA);
+        }
+      }, {
+        keys: [['End']],
+        callback: function callback(event, _ref3) {
+          var _ref4 = _slicedToArray(_ref3, 1),
+              keyName = _ref4[0];
+
+          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(SHORTCUTS_GROUP_NAVIGATION);
+      editorContext.removeShortcutsByGroup(SHORTCUTS_GROUP);
+      editorContext.removeShortcutsByGroup(SHORTCUTS_GROUP_EDITOR);
+    }
+    /**
+     * OnAfterDocumentKeyDown callback.
+     *
+     * @private
+     * @param {KeyboardEvent} event The keyboard event object.
+     */
+
+  }, {
+    key: "onAfterDocumentKeyDown",
+    value: function onAfterDocumentKeyDown(event) {
       var arrowKeyCodes = [KEY_CODES.ARROW_UP, KEY_CODES.ARROW_RIGHT, KEY_CODES.ARROW_DOWN, KEY_CODES.ARROW_LEFT];
 
       if (arrowKeyCodes.indexOf(event.keyCode) === -1) {

package/editors/timeEditor/index.d.ts

@@ -0,0 +1 @@
+export { EDITOR_TYPE, TimeEditor } from './timeEditor';

package/editors/timeEditor/index.js

@@ -0,0 +1,9 @@
+"use strict";
+
+exports.__esModule = true;
+exports.TimeEditor = exports.EDITOR_TYPE = void 0;
+
+var _timeEditor = require("./timeEditor");
+
+exports.EDITOR_TYPE = _timeEditor.EDITOR_TYPE;
+exports.TimeEditor = _timeEditor.TimeEditor;

package/editors/timeEditor/index.mjs

@@ -0,0 +1 @@
+export { EDITOR_TYPE, TimeEditor } from "./timeEditor.mjs";

package/editors/timeEditor/timeEditor.d.ts

@@ -0,0 +1,7 @@
+import Core from '../../core';
+import { TextEditor } from '../textEditor';
+
+export const EDITOR_TYPE: 'time';
+export class TimeEditor extends TextEditor {
+  constructor(instance: Core);
+}

package/editors/timeEditor/timeEditor.js

@@ -0,0 +1,105 @@
+"use strict";
+
+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");
+
+require("core-js/modules/es.reflect.construct.js");
+
+require("core-js/modules/es.reflect.get.js");
+
+require("core-js/modules/es.object.get-own-property-descriptor.js");
+
+require("core-js/modules/es.symbol.js");
+
+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/es.string.iterator.js");
+
+require("core-js/modules/web.dom-collections.iterator.js");
+
+exports.__esModule = true;
+exports.TimeEditor = exports.EDITOR_TYPE = void 0;
+
+require("core-js/modules/es.object.set-prototype-of.js");
+
+require("core-js/modules/es.object.get-prototype-of.js");
+
+var _textEditor = require("../textEditor");
+
+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); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
+function _get() { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get.bind(); } 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 } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+var EDITOR_TYPE = 'time';
+/**
+ * @private
+ * @class TimeEditor
+ */
+
+exports.EDITOR_TYPE = EDITOR_TYPE;
+
+var TimeEditor = /*#__PURE__*/function (_TextEditor) {
+  _inherits(TimeEditor, _TextEditor);
+
+  var _super = _createSuper(TimeEditor);
+
+  function TimeEditor() {
+    _classCallCheck(this, TimeEditor);
+
+    return _super.apply(this, arguments);
+  }
+
+  _createClass(TimeEditor, [{
+    key: "prepare",
+    value:
+    /**
+     * Prepares editor's meta data.
+     *
+     * @param {number} row The visual row index.
+     * @param {number} col The visual column index.
+     * @param {number|string} prop The column property (passed when datasource is an array of objects).
+     * @param {HTMLTableCellElement} td The rendered cell element.
+     * @param {*} value The rendered value.
+     * @param {object} cellProperties The cell meta object ({@see Core#getCellMeta}).
+     */
+    function prepare(row, col, prop, td, value, cellProperties) {
+      _get(_getPrototypeOf(TimeEditor.prototype), "prepare", this).call(this, row, col, prop, td, value, cellProperties);
+
+      this.TEXTAREA.dir = 'ltr';
+    }
+  }], [{
+    key: "EDITOR_TYPE",
+    get: function get() {
+      return EDITOR_TYPE;
+    }
+  }]);
+
+  return TimeEditor;
+}(_textEditor.TextEditor);
+
+exports.TimeEditor = TimeEditor;