handsontable 0.0.0-next-5e7f0fe-20230504 → 0.0.0-next-48677e7-20230509

package/editors/textEditor/textEditor.mjs

@@ -42,7 +42,7 @@ function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.g
 import { BaseEditor, EDITOR_STATE } from "../baseEditor/index.mjs";
 import EventManager from "../../eventManager.mjs";
 import { isMobileBrowser, isIE, isEdge, isIOS } from "../../helpers/browser.mjs";
-import { addClass, getComputedStyle, setCaretPosition, hasClass, removeClass } from "../../helpers/dom/element.mjs";
+import { addClass, getComputedStyle, isHotChild, 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";
@@ -172,7 +172,7 @@ export var TextEditor = /*#__PURE__*/function (_BaseEditor) {
     key: "close",
     value: function close() {
       this.autoResize.unObserve();
-      if (this.hot.rootDocument.activeElement === this.TEXTAREA) {
+      if (isHotChild(this.hot.rootDocument.activeElement)) {
         this.hot.listen(); // don't refocus the table if user focused some cell outside of HT on purpose
       }
 
@@ -212,7 +212,7 @@ export var TextEditor = /*#__PURE__*/function (_BaseEditor) {
         // @TODO: The fragmentSelection functionality is conflicted with IME. For this feature
         // refocus has to be disabled (to make IME working).
         var restoreFocus = !fragmentSelection;
-        if (restoreFocus && !isMobileBrowser()) {
+        if (this.hot.getSettings().imeFastEdit && restoreFocus && !isMobileBrowser()) {
           this.focus();
         }
       }
@@ -257,6 +257,7 @@ export var TextEditor = /*#__PURE__*/function (_BaseEditor) {
       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;
+      this.TEXTAREA.setAttribute('aria-hidden', 'true');
       addClass(this.TEXTAREA, 'handsontableInput');
       this.textareaStyle = this.TEXTAREA.style;
       this.textareaStyle.width = 0;
@@ -404,12 +405,6 @@ export var TextEditor = /*#__PURE__*/function (_BaseEditor) {
     key: "bindEvents",
     value: function bindEvents() {
       var _this3 = this;
-      this.eventManager.addEventListener(this.TEXTAREA, 'cut', function (event) {
-        return event.stopPropagation();
-      });
-      this.eventManager.addEventListener(this.TEXTAREA, 'paste', function (event) {
-        return 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', function () {
@@ -422,14 +417,6 @@ export var TextEditor = /*#__PURE__*/function (_BaseEditor) {
       this.addHook('afterScrollVertically', function () {
         return _this3.refreshDimensions();
       });
-      this.addHook('afterColumnResize', function () {
-        _this3.refreshDimensions();
-        _this3.focus();
-      });
-      this.addHook('afterRowResize', function () {
-        _this3.refreshDimensions();
-        _this3.focus();
-      });
     }
 
     /**

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,249 @@
+"use strict";
+
+require("core-js/modules/es.symbol.to-primitive.js");
+require("core-js/modules/es.date.to-primitive.js");
+require("core-js/modules/es.symbol.js");
+require("core-js/modules/es.symbol.description.js");
+require("core-js/modules/es.number.constructor.js");
+require("core-js/modules/es.symbol.iterator.js");
+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); }
+exports.__esModule = true;
+exports.default = void 0;
+require("core-js/modules/es.array.concat.js");
+require("core-js/modules/es.array.includes.js");
+require("core-js/modules/es.string.includes.js");
+require("core-js/modules/es.object.values.js");
+require("core-js/modules/es.array.iterator.js");
+require("core-js/modules/es.object.to-string.js");
+require("core-js/modules/es.string.iterator.js");
+require("core-js/modules/es.weak-set.js");
+require("core-js/modules/web.dom-collections.iterator.js");
+var _console = require("./helpers/console");
+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, _toPropertyKey(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 _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function _classPrivateMethodInitSpec(obj, privateSet) { _checkPrivateRedeclaration(obj, privateSet); privateSet.add(obj); }
+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; }
+/**
+ * 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}}
+ */
+var FOCUS_MODES = {
+  CELL: 'cell',
+  MIXED: 'mixed'
+};
+
+/**
+ * Manages the browser's focus in the table.
+ */
+var _manageFocus = /*#__PURE__*/new WeakSet();
+var _onUpdateSettings = /*#__PURE__*/new WeakSet();
+var FocusManager = /*#__PURE__*/function () {
+  function FocusManager(hotInstance) {
+    var _this = this;
+    _classCallCheck(this, FocusManager);
+    /**
+     * 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);
+    var hotSettings = hotInstance.getSettings();
+
+    /**
+     * The Handsontable instance.
+     *
+     * @private
+     */
+    this._hot = hotInstance;
+
+    /**
+     * 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}
+     * @private
+     */
+    this._focusMode = hotSettings.imeFastEdit ? FOCUS_MODES.MIXED : FOCUS_MODES.CELL;
+
+    /**
+     * 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}
+     * @private
+     */
+    this._refocusDelay = 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}
+     * @private
+     */
+    this._refocusElementGetter = null;
+    this._hot.addHook('afterUpdateSettings', function () {
+      var _classPrivateMethodGe;
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      return (_classPrivateMethodGe = _classPrivateMethodGet(_this, _onUpdateSettings, _onUpdateSettings2)).call.apply(_classPrivateMethodGe, [_this].concat(args));
+    });
+    this._hot.addHook('afterSelectionEnd', function () {
+      var _classPrivateMethodGe2;
+      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+        args[_key2] = arguments[_key2];
+      }
+      return (_classPrivateMethodGe2 = _classPrivateMethodGet(_this, _manageFocus, _manageFocus2)).call.apply(_classPrivateMethodGe2, [_this].concat(args));
+    });
+  }
+
+  /**
+   * Get the current focus mode.
+   *
+   * @returns {string}
+   */
+  _createClass(FocusManager, [{
+    key: "getFocusMode",
+    value: function getFocusMode() {
+      return this._focusMode;
+    }
+
+    /**
+     * Set the focus mode.
+     *
+     * @param {string} focusMode The new focus mode.
+     */
+  }, {
+    key: "setFocusMode",
+    value: function setFocusMode(focusMode) {
+      if (Object.values(FOCUS_MODES).includes(focusMode)) {
+        this._focusMode = focusMode;
+      } else {
+        (0, _console.warn)("\"".concat(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.
+     */
+  }, {
+    key: "getRefocusDelay",
+    value: function getRefocusDelay() {
+      return 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.
+     */
+  }, {
+    key: "setRefocusDelay",
+    value: function setRefocusDelay(delay) {
+      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.
+     */
+  }, {
+    key: "setRefocusElementGetter",
+    value: function setRefocusElementGetter(getRefocusElementFunction) {
+      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}
+     */
+  }, {
+    key: "getRefocusElement",
+    value: function getRefocusElement() {
+      if (this._refocusElementGetter !== null) {
+        return this._refocusElementGetter();
+      } else {
+        var _this$_hot$getActiveE;
+        return (_this$_hot$getActiveE = this._hot.getActiveEditor()) === null || _this$_hot$getActiveE === void 0 ? void 0 : _this$_hot$getActiveE.TEXTAREA;
+      }
+    }
+
+    /**
+     * Set the browser's focus to the highlighted cell of the last selection.
+     */
+  }, {
+    key: "focusOnHighlightedCell",
+    value: function focusOnHighlightedCell() {
+      var _this$_hot$getActiveE2;
+      var lastSelectedRange = this._hot.getSelectedRangeLast();
+      var selectedCellCoords = lastSelectedRange.highlight;
+      var selectedCell = this._hot.getCell(selectedCellCoords.row, selectedCellCoords.col);
+      if (selectedCell && !((_this$_hot$getActiveE2 = this._hot.getActiveEditor()) !== null && _this$_hot$getActiveE2 !== void 0 && _this$_hot$getActiveE2.isOpened())) {
+        this._hot.getCell(selectedCellCoords.row, selectedCellCoords.col).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.
+     */
+  }, {
+    key: "refocusToEditorTextarea",
+    value: function refocusToEditorTextarea() {
+      var delay = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this._refocusDelay;
+      var refocusElement = this.getRefocusElement();
+
+      // Re-focus on the editor's `TEXTAREA` element (or a predefined element) if the `imeFastEdit` option is enabled.
+      if (this._hot.getSettings().imeFastEdit && !!refocusElement) {
+        this._hot._registerTimeout(function () {
+          refocusElement.select();
+        }, delay);
+      }
+    }
+  }]);
+  return FocusManager;
+}();
+exports.default = FocusManager;
+function _manageFocus2() {
+  this.focusOnHighlightedCell();
+  if (this.getFocusMode() === FOCUS_MODES.MIXED) {
+    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);
+  }
+}

package/focusManager.mjs

@@ -0,0 +1,245 @@
+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.concat.js";
+import "core-js/modules/es.array.includes.js";
+import "core-js/modules/es.string.includes.js";
+import "core-js/modules/es.object.values.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";
+import "core-js/modules/es.weak-set.js";
+import "core-js/modules/web.dom-collections.iterator.js";
+import "core-js/modules/es.symbol.to-primitive.js";
+import "core-js/modules/es.date.to-primitive.js";
+import "core-js/modules/es.symbol.js";
+import "core-js/modules/es.symbol.description.js";
+import "core-js/modules/es.number.constructor.js";
+import "core-js/modules/es.symbol.iterator.js";
+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, _toPropertyKey(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 _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function _classPrivateMethodInitSpec(obj, privateSet) { _checkPrivateRedeclaration(obj, privateSet); privateSet.add(obj); }
+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; }
+import { warn } from "./helpers/console.mjs";
+/**
+ * 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}}
+ */
+var FOCUS_MODES = {
+  CELL: 'cell',
+  MIXED: 'mixed'
+};
+
+/**
+ * Manages the browser's focus in the table.
+ */
+var _manageFocus = /*#__PURE__*/new WeakSet();
+var _onUpdateSettings = /*#__PURE__*/new WeakSet();
+var FocusManager = /*#__PURE__*/function () {
+  function FocusManager(hotInstance) {
+    var _this = this;
+    _classCallCheck(this, FocusManager);
+    /**
+     * 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);
+    var hotSettings = hotInstance.getSettings();
+
+    /**
+     * The Handsontable instance.
+     *
+     * @private
+     */
+    this._hot = hotInstance;
+
+    /**
+     * 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}
+     * @private
+     */
+    this._focusMode = hotSettings.imeFastEdit ? FOCUS_MODES.MIXED : FOCUS_MODES.CELL;
+
+    /**
+     * 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}
+     * @private
+     */
+    this._refocusDelay = 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}
+     * @private
+     */
+    this._refocusElementGetter = null;
+    this._hot.addHook('afterUpdateSettings', function () {
+      var _classPrivateMethodGe;
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      return (_classPrivateMethodGe = _classPrivateMethodGet(_this, _onUpdateSettings, _onUpdateSettings2)).call.apply(_classPrivateMethodGe, [_this].concat(args));
+    });
+    this._hot.addHook('afterSelectionEnd', function () {
+      var _classPrivateMethodGe2;
+      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+        args[_key2] = arguments[_key2];
+      }
+      return (_classPrivateMethodGe2 = _classPrivateMethodGet(_this, _manageFocus, _manageFocus2)).call.apply(_classPrivateMethodGe2, [_this].concat(args));
+    });
+  }
+
+  /**
+   * Get the current focus mode.
+   *
+   * @returns {string}
+   */
+  _createClass(FocusManager, [{
+    key: "getFocusMode",
+    value: function getFocusMode() {
+      return this._focusMode;
+    }
+
+    /**
+     * Set the focus mode.
+     *
+     * @param {string} focusMode The new focus mode.
+     */
+  }, {
+    key: "setFocusMode",
+    value: function setFocusMode(focusMode) {
+      if (Object.values(FOCUS_MODES).includes(focusMode)) {
+        this._focusMode = focusMode;
+      } else {
+        warn("\"".concat(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.
+     */
+  }, {
+    key: "getRefocusDelay",
+    value: function getRefocusDelay() {
+      return 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.
+     */
+  }, {
+    key: "setRefocusDelay",
+    value: function setRefocusDelay(delay) {
+      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.
+     */
+  }, {
+    key: "setRefocusElementGetter",
+    value: function setRefocusElementGetter(getRefocusElementFunction) {
+      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}
+     */
+  }, {
+    key: "getRefocusElement",
+    value: function getRefocusElement() {
+      if (this._refocusElementGetter !== null) {
+        return this._refocusElementGetter();
+      } else {
+        var _this$_hot$getActiveE;
+        return (_this$_hot$getActiveE = this._hot.getActiveEditor()) === null || _this$_hot$getActiveE === void 0 ? void 0 : _this$_hot$getActiveE.TEXTAREA;
+      }
+    }
+
+    /**
+     * Set the browser's focus to the highlighted cell of the last selection.
+     */
+  }, {
+    key: "focusOnHighlightedCell",
+    value: function focusOnHighlightedCell() {
+      var _this$_hot$getActiveE2;
+      var lastSelectedRange = this._hot.getSelectedRangeLast();
+      var selectedCellCoords = lastSelectedRange.highlight;
+      var selectedCell = this._hot.getCell(selectedCellCoords.row, selectedCellCoords.col);
+      if (selectedCell && !((_this$_hot$getActiveE2 = this._hot.getActiveEditor()) !== null && _this$_hot$getActiveE2 !== void 0 && _this$_hot$getActiveE2.isOpened())) {
+        this._hot.getCell(selectedCellCoords.row, selectedCellCoords.col).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.
+     */
+  }, {
+    key: "refocusToEditorTextarea",
+    value: function refocusToEditorTextarea() {
+      var delay = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this._refocusDelay;
+      var refocusElement = this.getRefocusElement();
+
+      // Re-focus on the editor's `TEXTAREA` element (or a predefined element) if the `imeFastEdit` option is enabled.
+      if (this._hot.getSettings().imeFastEdit && !!refocusElement) {
+        this._hot._registerTimeout(function () {
+          refocusElement.select();
+        }, delay);
+      }
+    }
+  }]);
+  return FocusManager;
+}();
+function _manageFocus2() {
+  this.focusOnHighlightedCell();
+  if (this.getFocusMode() === FOCUS_MODES.MIXED) {
+    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);
+  }
+}
+export { FocusManager as default };

package/helpers/dom/element.js

@@ -43,6 +43,7 @@ exports.innerHeight = innerHeight;
 exports.innerWidth = innerWidth;
 exports.isChildOf = isChildOf;
 exports.isDetached = isDetached;
+exports.isHotChild = isHotChild;
 exports.isInput = isInput;
 exports.isOutsideInput = isOutsideInput;
 exports.isVisible = isVisible;
@@ -110,6 +111,16 @@ function getParent(element) {
   return parent;
 }
 
+/**
+ * Check if the provided element is a child of the Handsontable container.
+ *
+ * @param {HTMLElement} element Element to be analyzed.
+ * @returns {boolean}
+ */
+function isHotChild(element) {
+  return !!element.closest('.handsontable');
+}
+
 /**
  * Gets `frameElement` of the specified frame. Returns null if it is a top frame or if script has no access to read property.
  *

package/helpers/dom/element.mjs

@@ -57,6 +57,16 @@ export function getParent(element) {
   return parent;
 }
 
+/**
+ * Check if the provided element is a child of the Handsontable container.
+ *
+ * @param {HTMLElement} element Element to be analyzed.
+ * @returns {boolean}
+ */
+export function isHotChild(element) {
+  return !!element.closest('.handsontable');
+}
+
 /**
  * Gets `frameElement` of the specified frame. Returns null if it is a top frame or if script has no access to read property.
  *

package/helpers/mixed.js

@@ -152,7 +152,7 @@ var domMessages = {
 function _injectProductInfo(key, element) {
   var hasValidType = !isEmpty(key);
   var isNonCommercial = typeof key === 'string' && key.toLowerCase() === 'non-commercial-and-evaluation';
-  var hotVersion = "0.0.0-next-5e7f0fe-20230504";
+  var hotVersion = "0.0.0-next-48677e7-20230509";
   var keyValidityDate;
   var consoleMessageState = 'invalid';
   var domMessageState = 'invalid';

package/helpers/mixed.mjs

@@ -142,7 +142,7 @@ var domMessages = {
 export function _injectProductInfo(key, element) {
   var hasValidType = !isEmpty(key);
   var isNonCommercial = typeof key === 'string' && key.toLowerCase() === 'non-commercial-and-evaluation';
-  var hotVersion = "0.0.0-next-5e7f0fe-20230504";
+  var hotVersion = "0.0.0-next-48677e7-20230509";
   var keyValidityDate;
   var consoleMessageState = 'invalid';
   var domMessageState = 'invalid';

package/i18n/languages/ar-AR.js

@@ -21,13 +21,7 @@ function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && 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); }
 function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
-function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); } /**
-                                                                                                                                                                                                                                                                                                                                                                                               * @preserve
-                                                                                                                                                                                                                                                                                                                                                                                               * Authors: Handsoncode
-                                                                                                                                                                                                                                                                                                                                                                                               * Last updated: Feb 9, 2022
-                                                                                                                                                                                                                                                                                                                                                                                               *
-                                                                                                                                                                                                                                                                                                                                                                                               * Description: Definition file for Arabic - Without a specific country.
-                                                                                                                                                                                                                                                                                                                                                                                               */
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
 var dictionary = (_dictionary = {
   languageCode: 'ar-AR',
   languageDirection: 'rtl'