handsontable 13.1.0 → 14.0.0-next-d97b156-20231027

package/editors/selectEditor/selectEditor.js

@@ -6,13 +6,12 @@ var _element = require("../../helpers/dom/element");
 var _object = require("../../helpers/object");
 const EDITOR_VISIBLE_CLASS_NAME = 'ht_editor_visible';
 const SHORTCUTS_GROUP = 'selectEditor';
-const EDITOR_TYPE = 'select';
+const EDITOR_TYPE = exports.EDITOR_TYPE = 'select';
 
 /**
  * @private
  * @class SelectEditor
  */
-exports.EDITOR_TYPE = EDITOR_TYPE;
 class SelectEditor extends _baseEditor.BaseEditor {
   static get EDITOR_TYPE() {
     return EDITOR_TYPE;

package/editors/textEditor/textEditor.js

@@ -12,17 +12,17 @@ var _mixed = require("../../helpers/mixed");
 var _editorManager = require("../../editorManager");
 var _baseEditor2 = require("../baseEditor/baseEditor");
 var _caretPositioner = require("./caretPositioner");
+var _a11y = require("../../helpers/a11y");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 const EDITOR_VISIBLE_CLASS_NAME = 'ht_editor_visible';
 const EDITOR_HIDDEN_CLASS_NAME = 'ht_editor_hidden';
 const SHORTCUTS_GROUP = 'textEditor';
-const EDITOR_TYPE = 'text';
+const EDITOR_TYPE = exports.EDITOR_TYPE = 'text';
 
 /**
  * @private
  * @class TextEditor
  */
-exports.EDITOR_TYPE = EDITOR_TYPE;
 class TextEditor extends _baseEditor.BaseEditor {
   static get EDITOR_TYPE() {
     return EDITOR_TYPE;
@@ -122,7 +122,7 @@ class TextEditor extends _baseEditor.BaseEditor {
    */
   close() {
     this.autoResize.unObserve();
-    if (this.hot.rootDocument.activeElement === this.TEXTAREA) {
+    if ((0, _element.isThisHotChild)(this.hot.rootDocument.activeElement, this.hot.rootElement)) {
       this.hot.listen(); // don't refocus the table if user focused some cell outside of HT on purpose
     }
 
@@ -147,8 +147,7 @@ class TextEditor extends _baseEditor.BaseEditor {
     if (!cellProperties.readOnly) {
       this.refreshDimensions(true);
       const {
-        allowInvalid,
-        fragmentSelection
+        allowInvalid
       } = cellProperties;
       if (allowInvalid) {
         // Remove an empty space from textarea (added by copyPaste plugin to make copy/paste
@@ -158,13 +157,6 @@ class TextEditor extends _baseEditor.BaseEditor {
       if (previousState !== _baseEditor.EDITOR_STATE.FINISHED) {
         this.hideEditableElement();
       }
-
-      // @TODO: The fragmentSelection functionality is conflicted with IME. For this feature
-      // refocus has to be disabled (to make IME working).
-      const restoreFocus = !fragmentSelection;
-      if (restoreFocus && !(0, _browser.isMobileBrowser)()) {
-        this.focus();
-      }
     }
   }
 
@@ -201,8 +193,13 @@ class TextEditor extends _baseEditor.BaseEditor {
       rootDocument
     } = this.hot;
     this.TEXTAREA = rootDocument.createElement('TEXTAREA');
-    this.TEXTAREA.setAttribute('data-hot-input', ''); // Makes the element recognizable by Hot as its own component's element.
-    this.TEXTAREA.tabIndex = -1;
+
+    // Makes the element recognizable by Hot as its own
+    // component's element.
+    (0, _element.setAttribute)(this.TEXTAREA, [['data-hot-input', ''], (0, _a11y.A11Y_TABINDEX)(-1)]);
+    if (this.hot.getSettings().ariaTags) {
+      (0, _element.setAttribute)(this.TEXTAREA, [(0, _a11y.A11Y_HIDDEN)()]);
+    }
     (0, _element.addClass)(this.TEXTAREA, 'handsontableInput');
     this.textareaStyle = this.TEXTAREA.style;
     this.textareaStyle.width = 0;
@@ -340,8 +337,6 @@ class TextEditor extends _baseEditor.BaseEditor {
    * @private
    */
   bindEvents() {
-    this.eventManager.addEventListener(this.TEXTAREA, 'cut', event => event.stopPropagation());
-    this.eventManager.addEventListener(this.TEXTAREA, 'paste', event => event.stopPropagation());
     if ((0, _browser.isIOS)()) {
       // on iOS after click "Done" the edit isn't hidden by default, so we need to handle it manually.
       this.eventManager.addEventListener(this.TEXTAREA, 'focusout', () => this.finishEditing(false));
@@ -350,11 +345,15 @@ class TextEditor extends _baseEditor.BaseEditor {
     this.addHook('afterScrollVertically', () => this.refreshDimensions());
     this.addHook('afterColumnResize', () => {
       this.refreshDimensions();
-      this.focus();
+      if (this.state === _baseEditor.EDITOR_STATE.EDITING) {
+        this.focus();
+      }
     });
     this.addHook('afterRowResize', () => {
       this.refreshDimensions();
-      this.focus();
+      if (this.state === _baseEditor.EDITOR_STATE.EDITING) {
+        this.focus();
+      }
     });
   }
 
@@ -416,9 +415,7 @@ class TextEditor extends _baseEditor.BaseEditor {
       runOnlyIf: event => !this.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'
+      !event.altKey
     }, {
       keys: [['Meta', 'Enter']],
       callback: () => {
@@ -426,19 +423,13 @@ class TextEditor extends _baseEditor.BaseEditor {
         return false; // Will block closing editor.
       },
 
-      runOnlyIf: () => !this.hot.selection.isMultiple(),
-      // We trigger a data population for multiple selection.
-      relativeToGroup: _editorManager.SHORTCUTS_GROUP_EDITOR,
-      position: 'before'
+      runOnlyIf: () => !this.hot.selection.isMultiple() // We trigger a data population for multiple selection.
     }, {
       keys: [['Alt', 'Enter']],
       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']],

package/editors/textEditor/textEditor.mjs

@@ -1,14 +1,15 @@
 import { BaseEditor, EDITOR_STATE } from "../baseEditor/index.mjs";
 import EventManager from "../../eventManager.mjs";
-import { isMobileBrowser, isEdge, isIOS } from "../../helpers/browser.mjs";
-import { addClass, getComputedStyle, setCaretPosition, hasClass, removeClass } from "../../helpers/dom/element.mjs";
+import { isEdge, isIOS } from "../../helpers/browser.mjs";
+import { addClass, getComputedStyle, isThisHotChild, setCaretPosition, hasClass, removeClass, setAttribute } 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_NAVIGATION } from "../../editorManager.mjs";
 import { SHORTCUTS_GROUP_EDITOR } from "../baseEditor/baseEditor.mjs";
 import { updateCaretPosition } from "./caretPositioner.mjs";
+import { A11Y_HIDDEN, A11Y_TABINDEX } from "../../helpers/a11y.mjs";
 const EDITOR_VISIBLE_CLASS_NAME = 'ht_editor_visible';
 const EDITOR_HIDDEN_CLASS_NAME = 'ht_editor_hidden';
 const SHORTCUTS_GROUP = 'textEditor';
@@ -117,7 +118,7 @@ export class TextEditor extends BaseEditor {
    */
   close() {
     this.autoResize.unObserve();
-    if (this.hot.rootDocument.activeElement === this.TEXTAREA) {
+    if (isThisHotChild(this.hot.rootDocument.activeElement, this.hot.rootElement)) {
       this.hot.listen(); // don't refocus the table if user focused some cell outside of HT on purpose
     }
 
@@ -142,8 +143,7 @@ export class TextEditor extends BaseEditor {
     if (!cellProperties.readOnly) {
       this.refreshDimensions(true);
       const {
-        allowInvalid,
-        fragmentSelection
+        allowInvalid
       } = cellProperties;
       if (allowInvalid) {
         // Remove an empty space from textarea (added by copyPaste plugin to make copy/paste
@@ -153,13 +153,6 @@ export class TextEditor extends BaseEditor {
       if (previousState !== EDITOR_STATE.FINISHED) {
         this.hideEditableElement();
       }
-
-      // @TODO: The fragmentSelection functionality is conflicted with IME. For this feature
-      // refocus has to be disabled (to make IME working).
-      const restoreFocus = !fragmentSelection;
-      if (restoreFocus && !isMobileBrowser()) {
-        this.focus();
-      }
     }
   }
 
@@ -196,8 +189,13 @@ export class TextEditor extends BaseEditor {
       rootDocument
     } = this.hot;
     this.TEXTAREA = rootDocument.createElement('TEXTAREA');
-    this.TEXTAREA.setAttribute('data-hot-input', ''); // Makes the element recognizable by Hot as its own component's element.
-    this.TEXTAREA.tabIndex = -1;
+
+    // Makes the element recognizable by Hot as its own
+    // component's element.
+    setAttribute(this.TEXTAREA, [['data-hot-input', ''], A11Y_TABINDEX(-1)]);
+    if (this.hot.getSettings().ariaTags) {
+      setAttribute(this.TEXTAREA, [A11Y_HIDDEN()]);
+    }
     addClass(this.TEXTAREA, 'handsontableInput');
     this.textareaStyle = this.TEXTAREA.style;
     this.textareaStyle.width = 0;
@@ -335,8 +333,6 @@ export class TextEditor extends BaseEditor {
    * @private
    */
   bindEvents() {
-    this.eventManager.addEventListener(this.TEXTAREA, 'cut', event => event.stopPropagation());
-    this.eventManager.addEventListener(this.TEXTAREA, 'paste', event => event.stopPropagation());
     if (isIOS()) {
       // on iOS after click "Done" the edit isn't hidden by default, so we need to handle it manually.
       this.eventManager.addEventListener(this.TEXTAREA, 'focusout', () => this.finishEditing(false));
@@ -345,11 +341,15 @@ export class TextEditor extends BaseEditor {
     this.addHook('afterScrollVertically', () => this.refreshDimensions());
     this.addHook('afterColumnResize', () => {
       this.refreshDimensions();
-      this.focus();
+      if (this.state === EDITOR_STATE.EDITING) {
+        this.focus();
+      }
     });
     this.addHook('afterRowResize', () => {
       this.refreshDimensions();
-      this.focus();
+      if (this.state === EDITOR_STATE.EDITING) {
+        this.focus();
+      }
     });
   }
 
@@ -411,9 +411,7 @@ export class TextEditor extends BaseEditor {
       runOnlyIf: event => !this.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'
+      !event.altKey
     }, {
       keys: [['Meta', 'Enter']],
       callback: () => {
@@ -421,19 +419,13 @@ export class TextEditor extends BaseEditor {
         return false; // Will block closing editor.
       },
 
-      runOnlyIf: () => !this.hot.selection.isMultiple(),
-      // We trigger a data population for multiple selection.
-      relativeToGroup: EDITOR_MANAGER_GROUP,
-      position: 'before'
+      runOnlyIf: () => !this.hot.selection.isMultiple() // We trigger a data population for multiple selection.
     }, {
       keys: [['Alt', 'Enter']],
       callback: () => {
         insertNewLine();
         return false; // Will block closing editor.
-      },
-
-      relativeToGroup: EDITOR_MANAGER_GROUP,
-      position: 'before'
+      }
     }, {
       // TODO: Duplicated part of code (callback to shortcut)
       keys: [['PageUp']],

package/editors/timeEditor/timeEditor.js

@@ -2,13 +2,12 @@
 
 exports.__esModule = true;
 var _textEditor = require("../textEditor");
-const EDITOR_TYPE = 'time';
+const EDITOR_TYPE = exports.EDITOR_TYPE = 'time';
 
 /**
  * @private
  * @class TimeEditor
  */
-exports.EDITOR_TYPE = EDITOR_TYPE;
 class TimeEditor extends _textEditor.TextEditor {
   static get EDITOR_TYPE() {
     return EDITOR_TYPE;

package/eventManager.js

@@ -201,11 +201,10 @@ function extendEvent(event) {
   };
   return event;
 }
-var _default = EventManager;
+var _default = exports.default = EventManager;
 /**
  * @returns {number}
  */
-exports.default = _default;
 function getListenersCounter() {
   return listenersCounter;
 }

package/focusManager.d.ts

@@ -0,0 +1,12 @@
+type FocusMode = 'cell' | 'mixed';
+
+export interface FocusManager {
+  getFocusMode(): FocusMode;
+  setFocusMode(focusMode: FocusMode): void;
+  getRefocusDelay(): number;
+  setRefocusDelay(delay: number): void;
+  setRefocusElementGetter(getterFn: () => HTMLElement): void;
+  getRefocusElement(): HTMLElement | void;
+  focusOnHighlightedCell(): void;
+  refocusToEditorTextarea(delay: number): void;
+}

package/focusManager.js

@@ -0,0 +1,265 @@
+"use strict";
+
+exports.__esModule = true;
+require("core-js/modules/es.error.cause.js");
+var _console = require("./helpers/console");
+var _element = require("./helpers/dom/element");
+function _classPrivateMethodInitSpec(obj, privateSet) { _checkPrivateRedeclaration(obj, privateSet); privateSet.add(obj); }
+function _classPrivateFieldInitSpec(obj, privateMap, value) { _checkPrivateRedeclaration(obj, privateMap); privateMap.set(obj, value); }
+function _checkPrivateRedeclaration(obj, privateCollection) { if (privateCollection.has(obj)) { throw new TypeError("Cannot initialize the same private elements twice on an object"); } }
+function _classPrivateMethodGet(receiver, privateSet, fn) { if (!privateSet.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return fn; }
+function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); }
+function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; }
+function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set"); _classApplyDescriptorSet(receiver, descriptor, value); return value; }
+function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); }
+function _classApplyDescriptorSet(receiver, descriptor, value) { if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } }
+/**
+ * Possible focus modes.
+ * - CELL - The browser's focus stays on the lastly selected cell element.
+ * - MIXED - The browser's focus switches from the lastly selected cell element to the currently active editor's
+ * `TEXTAREA` element after a delay defined in the manager.
+ *
+ * @type {{CELL: string, MIXED: string}}
+ */
+const FOCUS_MODES = Object.freeze({
+  CELL: 'cell',
+  MIXED: 'mixed'
+});
+
+/**
+ * Manages the browser's focus in the table.
+ */
+var _hot = /*#__PURE__*/new WeakMap();
+var _focusMode = /*#__PURE__*/new WeakMap();
+var _refocusDelay = /*#__PURE__*/new WeakMap();
+var _refocusElementGetter = /*#__PURE__*/new WeakMap();
+var _getCurrentHighlightCoords = /*#__PURE__*/new WeakSet();
+var _getSelectedCell = /*#__PURE__*/new WeakSet();
+var _manageFocus = /*#__PURE__*/new WeakSet();
+var _onUpdateSettings = /*#__PURE__*/new WeakSet();
+class FocusManager {
+  constructor(hotInstance) {
+    var _this = this;
+    /**
+     * Update the manager configuration after calling `updateSettings`.
+     *
+     * @private
+     * @param {object} newSettings The new settings passed to the `updateSettings` method.
+     */
+    _classPrivateMethodInitSpec(this, _onUpdateSettings);
+    /**
+     * Manage the browser's focus after cell selection.
+     *
+     * @private
+     */
+    _classPrivateMethodInitSpec(this, _manageFocus);
+    /**
+     * Get and return the currently selected and highlighted cell/header element.
+     *
+     * @private
+     * @returns {HTMLTableCellElement}
+     */
+    _classPrivateMethodInitSpec(this, _getSelectedCell);
+    /**
+     * Get the coordinates of the highlight of the currently selected cell/header.
+     *
+     * @returns {CellCoords}
+     */
+    _classPrivateMethodInitSpec(this, _getCurrentHighlightCoords);
+    /**
+     * The Handsontable instance.
+     */
+    _classPrivateFieldInitSpec(this, _hot, {
+      writable: true,
+      value: void 0
+    });
+    /**
+     * The currently enabled focus mode.
+     * Can be either:
+     *
+     * - 'cell' - The browser's focus stays on the lastly selected cell element.
+     * - 'mixed' - The browser's focus switches from the lastly selected cell element to the currently active editor's
+     * `TEXTAREA` element after a delay defined in the manager.
+     *
+     * @type {string}
+     */
+    _classPrivateFieldInitSpec(this, _focusMode, {
+      writable: true,
+      value: void 0
+    });
+    /**
+     * The delay after which the focus switches from the lastly selected cell to the active editor's `TEXTAREA`
+     * element if the focus mode is set to 'mixed'.
+     *
+     * @type {number}
+     */
+    _classPrivateFieldInitSpec(this, _refocusDelay, {
+      writable: true,
+      value: 50
+    });
+    /**
+     * Getter function for the element to be used when refocusing the browser after a delay. If `null`, the active
+     * editor's `TEXTAREA` element will be used.
+     *
+     * @type {null|Function}
+     */
+    _classPrivateFieldInitSpec(this, _refocusElementGetter, {
+      writable: true,
+      value: null
+    });
+    const hotSettings = hotInstance.getSettings();
+    _classPrivateFieldSet(this, _hot, hotInstance);
+    _classPrivateFieldSet(this, _focusMode, hotSettings.imeFastEdit ? FOCUS_MODES.MIXED : FOCUS_MODES.CELL);
+    _classPrivateFieldGet(this, _hot).addHook('afterUpdateSettings', function () {
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      return _classPrivateMethodGet(_this, _onUpdateSettings, _onUpdateSettings2).call(_this, ...args);
+    });
+    _classPrivateFieldGet(this, _hot).addHook('afterSelection', function () {
+      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+        args[_key2] = arguments[_key2];
+      }
+      return _classPrivateMethodGet(_this, _manageFocus, _manageFocus2).call(_this, ...args);
+    });
+  }
+
+  /**
+   * Get the current focus mode.
+   *
+   * @returns {'cell' | 'mixed'}
+   */
+  getFocusMode() {
+    return _classPrivateFieldGet(this, _focusMode);
+  }
+
+  /**
+   * Set the focus mode.
+   *
+   * @param {'cell' | 'mixed'} focusMode The new focus mode.
+   */
+  setFocusMode(focusMode) {
+    if (Object.values(FOCUS_MODES).includes(focusMode)) {
+      _classPrivateFieldSet(this, _focusMode, focusMode);
+    } else {
+      (0, _console.warn)(`"${focusMode}" is not a valid focus mode.`);
+    }
+  }
+
+  /**
+   * Get the delay after which the focus will change from the cell elements to the active editor's `TEXTAREA`
+   * element if the focus mode is set to 'mixed'.
+   *
+   * @returns {number} Delay in milliseconds.
+   */
+  getRefocusDelay() {
+    return _classPrivateFieldGet(this, _refocusDelay);
+  }
+
+  /**
+   * Set the delay after which the focus will change from the cell elements to the active editor's `TEXTAREA`
+   * element if the focus mode is set to 'mixed'.
+   *
+   * @param {number} delay Delay in milliseconds.
+   */
+  setRefocusDelay(delay) {
+    _classPrivateFieldSet(this, _refocusDelay, delay);
+  }
+
+  /**
+   * Set the function to be used as the "refocus element" getter. It should return a focusable HTML element.
+   *
+   * @param {Function} getRefocusElementFunction The refocus element getter.
+   */
+  setRefocusElementGetter(getRefocusElementFunction) {
+    _classPrivateFieldSet(this, _refocusElementGetter, getRefocusElementFunction);
+  }
+
+  /**
+   * Get the element to be used when refocusing the browser after a delay in case of the focus mode being 'mixed'.
+   *
+   * @returns {HTMLTextAreaElement|HTMLElement|undefined}
+   */
+  getRefocusElement() {
+    if (typeof _classPrivateFieldGet(this, _refocusElementGetter) === 'function') {
+      return _classPrivateFieldGet(this, _refocusElementGetter).call(this);
+    } else {
+      var _classPrivateFieldGet2;
+      return (_classPrivateFieldGet2 = _classPrivateFieldGet(this, _hot).getActiveEditor()) === null || _classPrivateFieldGet2 === void 0 ? void 0 : _classPrivateFieldGet2.TEXTAREA;
+    }
+  }
+
+  /**
+   * Set the browser's focus to the highlighted cell of the last selection.
+   *
+   * @param {HTMLTableCellElement} [selectedCell] The highlighted cell/header element.
+   */
+  focusOnHighlightedCell(selectedCell) {
+    var _classPrivateFieldGet3;
+    const currentHighlightCoords = _classPrivateMethodGet(this, _getCurrentHighlightCoords, _getCurrentHighlightCoords2).call(this);
+    const currentlySelectedHighlight = selectedCell || _classPrivateMethodGet(this, _getSelectedCell, _getSelectedCell2).call(this);
+    let elementToBeFocused = _classPrivateFieldGet(this, _hot).runHooks('modifyFocusedElement', currentHighlightCoords.row, currentHighlightCoords.col, currentlySelectedHighlight);
+    if (!(elementToBeFocused instanceof HTMLElement)) {
+      elementToBeFocused = currentlySelectedHighlight;
+    }
+    if (elementToBeFocused && !((_classPrivateFieldGet3 = _classPrivateFieldGet(this, _hot).getActiveEditor()) !== null && _classPrivateFieldGet3 !== void 0 && _classPrivateFieldGet3.isOpened())) {
+      elementToBeFocused.focus({
+        preventScroll: true
+      });
+    }
+  }
+
+  /**
+   * Set the focus to the active editor's `TEXTAREA` element after the provided delay. If no delay is provided, it
+   * will be taken from the manager's configuration.
+   *
+   * @param {number} delay Delay in milliseconds.
+   */
+  refocusToEditorTextarea() {
+    let delay = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _classPrivateFieldGet(this, _refocusDelay);
+    const refocusElement = this.getRefocusElement();
+
+    // Re-focus on the editor's `TEXTAREA` element (or a predefined element) if the `imeFastEdit` option is enabled.
+    if (_classPrivateFieldGet(this, _hot).getSettings().imeFastEdit && !!refocusElement) {
+      _classPrivateFieldGet(this, _hot)._registerTimeout(() => {
+        refocusElement.select();
+      }, delay);
+    }
+  }
+}
+exports.FocusManager = FocusManager;
+function _getCurrentHighlightCoords2() {
+  const lastSelectedRange = _classPrivateFieldGet(this, _hot).getSelectedRangeLast();
+  return lastSelectedRange.highlight;
+}
+function _getSelectedCell2() {
+  const selectedCellCoords = _classPrivateMethodGet(this, _getCurrentHighlightCoords, _getCurrentHighlightCoords2).call(this);
+  return _classPrivateFieldGet(this, _hot).getCell(selectedCellCoords.row, selectedCellCoords.col, true);
+}
+function _manageFocus2() {
+  const selectedCell = _classPrivateMethodGet(this, _getSelectedCell, _getSelectedCell2).call(this);
+  const {
+    activeElement
+  } = _classPrivateFieldGet(this, _hot).rootDocument;
+
+  // Blurring the `activeElement` removes the unwanted border around the focusable element (#6877)
+  // and resets the `document.activeElement` property. The blurring should happen only when the
+  // previously selected input element has not belonged to the Handsontable editor. If blurring is
+  // triggered for all elements, there is a problem with the disappearing IME editor (#9672).
+  if (activeElement && (0, _element.isOutsideInput)(activeElement)) {
+    activeElement.blur();
+  }
+  this.focusOnHighlightedCell(selectedCell);
+  if (this.getFocusMode() === FOCUS_MODES.MIXED && selectedCell.nodeName === 'TD') {
+    _classPrivateFieldGet(this, _hot).addHookOnce('afterSelectionEnd', () => {
+      this.refocusToEditorTextarea();
+    });
+  }
+}
+function _onUpdateSettings2(newSettings) {
+  if (newSettings.imeFastEdit && this.getFocusMode() !== FOCUS_MODES.MIXED) {
+    this.setFocusMode(FOCUS_MODES.MIXED);
+  } else if (!newSettings.imeFastEdit && this.getFocusMode() !== FOCUS_MODES.CELL) {
+    this.setFocusMode(FOCUS_MODES.CELL);
+  }
+}