handsontable 11.0.0 → 12.0.0

package/editorManager.mjs

@@ -1,3 +1,17 @@
+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; }
+
+import "core-js/modules/es.array.includes.js";
+import "core-js/modules/es.string.includes.js";
 import "core-js/modules/es.array.iterator.js";
 import "core-js/modules/es.object.to-string.js";
 import "core-js/modules/es.string.iterator.js";
@@ -11,31 +25,19 @@ 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"); } }
 
 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; }
 
-import { CellCoords } from "./3rdparty/walkontable/src/index.mjs";
-import { KEY_CODES, isFunctionKey, isCtrlMetaKey } from "./helpers/unicode.mjs";
-import { stopImmediatePropagation, isImmediatePropagationStopped } from "./helpers/dom/event.mjs";
+import { isFunctionKey, isCtrlMetaKey } from "./helpers/unicode.mjs";
+import { stopImmediatePropagation } from "./helpers/dom/event.mjs";
 import { getEditorInstance } from "./editors/registry.mjs";
 import EventManager from "./eventManager.mjs";
-import { EDITOR_STATE } from "./editors/baseEditor/index.mjs";
-import { getParentWindow } from "./helpers/dom/element.mjs";
+import { isDefined } from "./helpers/mixed.mjs";
+export var SHORTCUTS_GROUP_NAVIGATION = 'editorManager.navigation';
+export var SHORTCUTS_GROUP_EDITOR = 'editorManager.handlingEditor';
 
 var EditorManager = /*#__PURE__*/function () {
   /**
@@ -110,44 +112,97 @@ var EditorManager = /*#__PURE__*/function () {
      */
 
     this.cellProperties = void 0;
-    /**
-     * Keeps last keyCode pressed from the keydown event.
-     *
-     * @type {number}
-     */
-
-    this.lastKeyCode = void 0;
+    var shortcutManager = this.instance.getShortcutManager();
+    shortcutManager.addContext('editor');
+    this.registerShortcuts();
     this.instance.addHook('afterDocumentKeyDown', function (event) {
       return _this.onAfterDocumentKeyDown(event);
-    });
-    var frame = this.instance.rootWindow;
-
-    while (frame) {
-      this.eventManager.addEventListener(frame.document.documentElement, 'keydown', function (event) {
-        if (!_this.destroyed) {
-          _this.instance.runHooks('afterDocumentKeyDown', event);
-        }
-      });
-      frame = getParentWindow(frame);
-    } // Open editor when text composition is started (IME editor)
-
+    }); // Open editor when text composition is started (IME editor)
 
     this.eventManager.addEventListener(this.instance.rootDocument.documentElement, 'compositionstart', function (event) {
       if (!_this.destroyed && _this.activeEditor && !_this.activeEditor.isOpened() && _this.instance.isListening()) {
         _this.openEditor('', event);
       }
     });
-    this.instance.view.wt.update('onCellDblClick', function (event, coords, elem) {
+
+    this.instance.view._wt.update('onCellDblClick', function (event, coords, elem) {
       return _this.onCellDblClick(event, coords, elem);
     });
   }
   /**
-   * Lock the editor from being prepared and closed. Locking the editor prevents its closing and
-   * reinitialized after selecting the new cell. This feature is necessary for a mobile editor.
+   * Register shortcuts responsible for handling some actions related to an editor.
+   *
+   * @private
    */
 
 
   _createClass(EditorManager, [{
+    key: "registerShortcuts",
+    value: function registerShortcuts() {
+      var _this2 = this;
+
+      var shortcutManager = this.instance.getShortcutManager();
+      var gridContext = shortcutManager.getContext('grid');
+      var editorContext = shortcutManager.getContext('editor');
+      var config = {
+        group: SHORTCUTS_GROUP_EDITOR
+      };
+      editorContext.addShortcuts([{
+        keys: [['Enter'], ['Enter', 'Shift'], ['Enter', 'Control/Meta'], ['Enter', 'Control/Meta', 'Shift']],
+        callback: function callback(event, keys) {
+          _this2.closeEditorAndSaveChanges(shortcutManager.isCtrlPressed());
+
+          _this2.moveSelectionAfterEnter(keys.includes('shift'));
+        }
+      }, {
+        keys: [['Escape'], ['Escape', 'Control/Meta']],
+        callback: function callback() {
+          _this2.closeEditorAndRestoreOriginalValue(shortcutManager.isCtrlPressed());
+
+          _this2.activeEditor.focus();
+        }
+      }], config);
+      gridContext.addShortcuts([{
+        keys: [['F2']],
+        callback: function callback(event) {
+          if (_this2.activeEditor) {
+            _this2.activeEditor.enableFullEditMode();
+          }
+
+          _this2.openEditor(null, event);
+        }
+      }, {
+        keys: [['Backspace'], ['Delete']],
+        callback: function callback() {
+          _this2.instance.emptySelectedCells();
+
+          _this2.prepareEditor();
+        }
+      }, {
+        keys: [['Enter'], ['Enter', 'Shift']],
+        callback: function callback(event, keys) {
+          if (_this2.instance.getSettings().enterBeginsEditing) {
+            if (_this2.cellProperties.readOnly) {
+              _this2.moveSelectionAfterEnter();
+            } else if (_this2.activeEditor) {
+              _this2.activeEditor.enableFullEditMode();
+
+              _this2.openEditor(null, event);
+            }
+          } else {
+            _this2.moveSelectionAfterEnter(keys.includes('shift'));
+          }
+
+          stopImmediatePropagation(event); // required by HandsontableEditor
+        }
+      }], config);
+    }
+    /**
+     * Lock the editor from being prepared and closed. Locking the editor prevents its closing and
+     * reinitialized after selecting the new cell. This feature is necessary for a mobile editor.
+     */
+
+  }, {
     key: "lockEditor",
     value: function lockEditor() {
       this.lock = true;
@@ -194,7 +249,7 @@ var EditorManager = /*#__PURE__*/function () {
   }, {
     key: "prepareEditor",
     value: function prepareEditor() {
-      var _this2 = this;
+      var _this3 = this;
 
       if (this.lock) {
         return;
@@ -203,7 +258,7 @@ var EditorManager = /*#__PURE__*/function () {
       if (this.activeEditor && this.activeEditor.isWaiting()) {
         this.closeEditor(false, false, function (dataSaved) {
           if (dataSaved) {
-            _this2.prepareEditor();
+            _this3.prepareEditor();
           }
         });
         return;
@@ -351,71 +406,6 @@ var EditorManager = /*#__PURE__*/function () {
         this.selection.transformStart(enterMoves.row, enterMoves.col, true);
       }
     }
-    /**
-     * Controls selection behaviour after clicking `arrow up`.
-     *
-     * @private
-     * @param {boolean} isShiftPressed If `true`, then the selection will expand up.
-     */
-
-  }, {
-    key: "moveSelectionUp",
-    value: function moveSelectionUp(isShiftPressed) {
-      if (isShiftPressed) {
-        this.selection.transformEnd(-1, 0);
-      } else {
-        this.selection.transformStart(-1, 0);
-      }
-    }
-    /**
-     * Controls selection's behaviour after clicking `arrow down`.
-     *
-     * @private
-     * @param {boolean} isShiftPressed If `true`, then the selection will expand down.
-     */
-
-  }, {
-    key: "moveSelectionDown",
-    value: function moveSelectionDown(isShiftPressed) {
-      if (isShiftPressed) {
-        // expanding selection down with shift
-        this.selection.transformEnd(1, 0);
-      } else {
-        this.selection.transformStart(1, 0);
-      }
-    }
-    /**
-     * Controls selection's behaviour after clicking `arrow right`.
-     *
-     * @private
-     * @param {boolean} isShiftPressed If `true`, then the selection will expand right.
-     */
-
-  }, {
-    key: "moveSelectionRight",
-    value: function moveSelectionRight(isShiftPressed) {
-      if (isShiftPressed) {
-        this.selection.transformEnd(0, this.instance.getDirectionFactor());
-      } else {
-        this.selection.transformStart(0, this.instance.getDirectionFactor());
-      }
-    }
-    /**
-     * Controls selection's behaviour after clicking `arrow left`.
-     *
-     * @private
-     * @param {boolean} isShiftPressed If `true`, then the selection will expand left.
-     */
-
-  }, {
-    key: "moveSelectionLeft",
-    value: function moveSelectionLeft(isShiftPressed) {
-      if (isShiftPressed) {
-        this.selection.transformEnd(0, -1 * this.instance.getDirectionFactor());
-      } else {
-        this.selection.transformStart(0, -1 * this.instance.getDirectionFactor());
-      }
-    }
     /**
      * OnAfterDocumentKeyDown callback.
      *
@@ -426,24 +416,19 @@ var EditorManager = /*#__PURE__*/function () {
   }, {
     key: "onAfterDocumentKeyDown",
     value: function onAfterDocumentKeyDown(event) {
+      var _this4 = this;
+
       if (!this.instance.isListening()) {
         return;
       }
 
-      this.instance.runHooks('beforeKeyDown', event);
       var keyCode = event.keyCode; // keyCode 229 aka 'uninitialized' doesn't take into account with editors. This key code is produced when unfinished
       // character is entering (using IME editor). It is fired mainly on linux (ubuntu) with installed ibus-pinyin package.
 
-      if (this.destroyed || keyCode === 229) {
-        return;
-      }
-
-      if (isImmediatePropagationStopped(event)) {
+      if (keyCode === 229) {
         return;
       }
 
-      this.lastKeyCode = keyCode;
-
       if (!this.selection.isSelected()) {
         return;
       } // catch CTRL but not right ALT (which in some systems triggers ALT+CTRL)
@@ -453,172 +438,37 @@ var EditorManager = /*#__PURE__*/function () {
 
       if (this.activeEditor && !this.activeEditor.isWaiting()) {
         if (!isFunctionKey(keyCode) && !isCtrlMetaKey(keyCode) && !isCtrlPressed && !this.isEditorOpened()) {
-          this.openEditor('', event);
-          return;
-        }
-      }
-
-      var isShiftPressed = event.shiftKey;
-      var rangeModifier = isShiftPressed ? this.selection.setRangeEnd : this.selection.setRangeStart;
-      var tabMoves;
-
-      switch (keyCode) {
-        case KEY_CODES.A:
-          if (!this.isEditorOpened() && isCtrlPressed) {
-            this.instance.selectAll();
-            event.preventDefault();
-            event.stopPropagation();
-          }
-
-          break;
-
-        case KEY_CODES.ARROW_UP:
-          if (this.isEditorOpened() && !this.activeEditor.isWaiting()) {
-            this.closeEditorAndSaveChanges(isCtrlPressed);
-          }
-
-          this.moveSelectionUp(isShiftPressed);
-          event.preventDefault();
-          event.stopPropagation();
-          break;
-
-        case KEY_CODES.ARROW_DOWN:
-          if (this.isEditorOpened() && !this.activeEditor.isWaiting()) {
-            this.closeEditorAndSaveChanges(isCtrlPressed);
-          }
-
-          this.moveSelectionDown(isShiftPressed);
-          event.preventDefault();
-          event.stopPropagation();
-          break;
-
-        case KEY_CODES.ARROW_RIGHT:
-          if (this.isEditorOpened() && !this.activeEditor.isWaiting()) {
-            this.closeEditorAndSaveChanges(isCtrlPressed);
-          }
-
-          this.moveSelectionRight(isShiftPressed);
-          event.preventDefault();
-          event.stopPropagation();
-          break;
-
-        case KEY_CODES.ARROW_LEFT:
-          if (this.isEditorOpened() && !this.activeEditor.isWaiting()) {
-            this.closeEditorAndSaveChanges(isCtrlPressed);
-          }
-
-          this.moveSelectionLeft(isShiftPressed);
-          event.preventDefault();
-          event.stopPropagation();
-          break;
-
-        case KEY_CODES.TAB:
-          tabMoves = typeof this.tableMeta.tabMoves === 'function' ? this.tableMeta.tabMoves(event) : this.tableMeta.tabMoves;
-
-          if (isShiftPressed) {
-            // move selection left
-            this.selection.transformStart(-tabMoves.row, -tabMoves.col);
-          } else {
-            // move selection right (add a new column if needed)
-            this.selection.transformStart(tabMoves.row, tabMoves.col, true);
-          }
-
-          event.preventDefault();
-          event.stopPropagation();
-          break;
-
-        case KEY_CODES.BACKSPACE:
-        case KEY_CODES.DELETE:
-          this.instance.emptySelectedCells();
-          this.prepareEditor();
-          event.preventDefault();
-          break;
-
-        case KEY_CODES.F2:
-          /* F2 */
-          if (this.activeEditor) {
-            this.activeEditor.enableFullEditMode();
-          }
-
-          this.openEditor(null, event);
-          event.preventDefault(); // prevent Opera from opening 'Go to Page dialog'
-
-          break;
-
-        case KEY_CODES.ENTER:
-          /* return/enter */
-          if (this.isEditorOpened()) {
-            if (this.activeEditor && this.activeEditor.state !== EDITOR_STATE.WAITING) {
-              this.closeEditorAndSaveChanges(isCtrlPressed);
+          var shortcutManager = this.instance.getShortcutManager();
+          var editorContext = shortcutManager.getContext('editor');
+          var runOnlySelectedConfig = {
+            runOnlyIf: function runOnlyIf() {
+              return isDefined(_this4.instance.getSelected());
+            },
+            group: SHORTCUTS_GROUP_NAVIGATION
+          };
+          editorContext.addShortcuts([{
+            keys: [['ArrowUp']],
+            callback: function callback() {
+              _this4.instance.selection.transformStart(-1, 0);
             }
-
-            this.moveSelectionAfterEnter(isShiftPressed);
-          } else if (this.instance.getSettings().enterBeginsEditing) {
-            if (this.cellProperties.readOnly) {
-              this.moveSelectionAfterEnter();
-            } else if (this.activeEditor) {
-              this.activeEditor.enableFullEditMode();
-              this.openEditor(null, event);
+          }, {
+            keys: [['ArrowDown']],
+            callback: function callback() {
+              _this4.instance.selection.transformStart(1, 0);
             }
-          } else {
-            this.moveSelectionAfterEnter(isShiftPressed);
-          }
-
-          event.preventDefault(); // don't add newline to field
-
-          stopImmediatePropagation(event); // required by HandsontableEditor
-
-          break;
-
-        case KEY_CODES.ESCAPE:
-          if (this.isEditorOpened()) {
-            this.closeEditorAndRestoreOriginalValue(isCtrlPressed);
-            this.activeEditor.focus();
-          }
-
-          event.preventDefault();
-          break;
-
-        case KEY_CODES.HOME:
-          if (event.ctrlKey || event.metaKey) {
-            rangeModifier.call(this.selection, new CellCoords(this.instance.rowIndexMapper.getFirstNotHiddenIndex(0, 1), this.selection.selectedRange.current().from.col));
-          } else {
-            rangeModifier.call(this.selection, new CellCoords(this.selection.selectedRange.current().from.row, this.instance.columnIndexMapper.getFirstNotHiddenIndex(0, 1)));
-          }
-
-          event.preventDefault(); // don't scroll the window
-
-          event.stopPropagation();
-          break;
-
-        case KEY_CODES.END:
-          if (event.ctrlKey || event.metaKey) {
-            rangeModifier.call(this.selection, new CellCoords(this.instance.rowIndexMapper.getFirstNotHiddenIndex(this.instance.countRows() - 1, -1), this.selection.selectedRange.current().from.col));
-          } else {
-            rangeModifier.call(this.selection, new CellCoords(this.selection.selectedRange.current().from.row, this.instance.columnIndexMapper.getFirstNotHiddenIndex(this.instance.countCols() - 1, -1)));
-          }
-
-          event.preventDefault(); // don't scroll the window
-
-          event.stopPropagation();
-          break;
-
-        case KEY_CODES.PAGE_UP:
-          this.selection.transformStart(-this.instance.countVisibleRows(), 0);
-          event.preventDefault(); // don't page up the window
-
-          event.stopPropagation();
-          break;
-
-        case KEY_CODES.PAGE_DOWN:
-          this.selection.transformStart(this.instance.countVisibleRows(), 0);
-          event.preventDefault(); // don't page down the window
-
-          event.stopPropagation();
-          break;
-
-        default:
-          break;
+          }, {
+            keys: [['ArrowLeft']],
+            callback: function callback() {
+              _this4.instance.selection.transformStart(0, -1 * _this4.instance.getDirectionFactor());
+            }
+          }, {
+            keys: [['ArrowRight']],
+            callback: function callback() {
+              _this4.instance.selection.transformStart(0, _this4.instance.getDirectionFactor());
+            }
+          }], runOnlySelectedConfig);
+          this.openEditor('', event);
+        }
       }
     }
     /**

package/editors/autocompleteEditor/autocompleteEditor.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.set-prototype-of.js");
 
@@ -61,13 +61,13 @@ function _classCallCheck(instance, Constructor) { if (!(instance instanceof Cons
 
 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); }
 
@@ -259,6 +259,9 @@ var AutocompleteEditor = /*#__PURE__*/function (_HandsontableEditor) {
         scrollbarWidth += 15; // default scroll bar width if scroll bars are visible only when scrolling
       }
 
+      this.addHook('beforeKeyDown', function (event) {
+        return _this3.onBeforeKeyDown(event);
+      });
       choicesListHot.updateSettings({
         colWidths: trimDropdown ? [(0, _element.outerWidth)(this.TEXTAREA) - 2] : void 0,
         width: trimDropdown ? (0, _element.outerWidth)(this.TEXTAREA) + scrollbarWidth : void 0,
@@ -420,9 +423,9 @@ var AutocompleteEditor = /*#__PURE__*/function (_HandsontableEditor) {
       var textareaOffset = (0, _element.offset)(this.TEXTAREA);
       var textareaHeight = (0, _element.outerHeight)(this.TEXTAREA);
       var dropdownHeight = this.getDropdownHeight();
-      var trimmingContainer = (0, _element.getTrimmingContainer)(this.hot.view.wt.wtTable.TABLE);
+      var trimmingContainer = (0, _element.getTrimmingContainer)(this.hot.view._wt.wtTable.TABLE);
       var trimmingContainerScrollTop = trimmingContainer.scrollTop;
-      var headersHeight = (0, _element.outerHeight)(this.hot.view.wt.wtTable.THEAD);
+      var headersHeight = (0, _element.outerHeight)(this.hot.view._wt.wtTable.THEAD);
       var containerOffset = {
         row: 0,
         col: 0
@@ -463,7 +466,7 @@ var AutocompleteEditor = /*#__PURE__*/function (_HandsontableEditor) {
         var height = null;
 
         do {
-          lastRowHeight = this.htEditor.getRowHeight(i) || this.htEditor.view.wt.wtSettings.settings.defaultRowHeight;
+          lastRowHeight = this.htEditor.getRowHeight(i) || this.htEditor.view._wt.getSetting('defaultRowHeight');
           tempHeight += lastRowHeight;
           i += 1;
         } while (tempHeight < spaceAvailable);
@@ -502,12 +505,8 @@ var AutocompleteEditor = /*#__PURE__*/function (_HandsontableEditor) {
     key: "unflipDropdown",
     value: function unflipDropdown() {
       var dropdownStyle = this.htEditor.rootElement.style;
-
-      if (dropdownStyle.position === 'absolute') {
-        dropdownStyle.position = '';
-        dropdownStyle.top = '';
-      }
-
+      dropdownStyle.position = 'absolute';
+      dropdownStyle.top = '';
       this.htEditor.flipped = void 0;
     }
     /**
@@ -525,7 +524,8 @@ var AutocompleteEditor = /*#__PURE__*/function (_HandsontableEditor) {
         height: this.getDropdownHeight(),
         width: trimDropdown ? void 0 : currentDropdownWidth
       });
-      this.htEditor.view.wt.wtTable.alignOverlaysWithTrimmingContainer();
+
+      this.htEditor.view._wt.wtTable.alignOverlaysWithTrimmingContainer();
     }
     /**
      * Sets new height of the internal Handsontable's instance.
@@ -647,7 +647,11 @@ var AutocompleteEditor = /*#__PURE__*/function (_HandsontableEditor) {
       priv.skipOne = false;
 
       if ((0, _unicode.isPrintableChar)(event.keyCode) || event.keyCode === _unicode.KEY_CODES.BACKSPACE || event.keyCode === _unicode.KEY_CODES.DELETE || event.keyCode === _unicode.KEY_CODES.INSERT) {
-        var timeOffset = 0; // on ctl+c / cmd+c don't update suggestion list
+        // for Windows 10 + FF86 there is need to add delay to make sure that the value taken from
+        // the textarea is the freshest value. Otherwise the list of choices does not update correctly (see #7570).
+        // On the more modern version of the FF (~ >=91) it seems that the issue is not present or it is
+        // more difficult to induce.
+        var timeOffset = 10; // on ctl+c / cmd+c don't update suggestion list
 
         if (event.keyCode === _unicode.KEY_CODES.C && (event.ctrlKey || event.metaKey)) {
           return;
@@ -665,8 +669,6 @@ var AutocompleteEditor = /*#__PURE__*/function (_HandsontableEditor) {
           }, timeOffset);
         }
       }
-
-      _get(_getPrototypeOf(AutocompleteEditor.prototype), "onBeforeKeyDown", this).call(this, event);
     }
     /**
      * Filters and sorts by relevance.