handsontable 11.0.0 → 12.0.0

package/editors/autocompleteEditor/autocompleteEditor.mjs

@@ -1,16 +1,16 @@
-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); }
 
 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
 function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
 
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
 
-function _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get(target, property, receiver || target); }
+function _get() { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(arguments.length < 3 ? target : receiver); } return desc.value; }; } return _get.apply(this, arguments); }
 
 function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
 
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
 
 function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
 
@@ -226,6 +226,9 @@ export 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 ? [outerWidth(this.TEXTAREA) - 2] : void 0,
         width: trimDropdown ? outerWidth(this.TEXTAREA) + scrollbarWidth : void 0,
@@ -387,9 +390,9 @@ export var AutocompleteEditor = /*#__PURE__*/function (_HandsontableEditor) {
       var textareaOffset = offset(this.TEXTAREA);
       var textareaHeight = outerHeight(this.TEXTAREA);
       var dropdownHeight = this.getDropdownHeight();
-      var trimmingContainer = getTrimmingContainer(this.hot.view.wt.wtTable.TABLE);
+      var trimmingContainer = getTrimmingContainer(this.hot.view._wt.wtTable.TABLE);
       var trimmingContainerScrollTop = trimmingContainer.scrollTop;
-      var headersHeight = outerHeight(this.hot.view.wt.wtTable.THEAD);
+      var headersHeight = outerHeight(this.hot.view._wt.wtTable.THEAD);
       var containerOffset = {
         row: 0,
         col: 0
@@ -430,7 +433,7 @@ export 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);
@@ -469,12 +472,8 @@ export 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;
     }
     /**
@@ -492,7 +491,8 @@ export 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.
@@ -614,7 +614,11 @@ export var AutocompleteEditor = /*#__PURE__*/function (_HandsontableEditor) {
       priv.skipOne = false;
 
       if (isPrintableChar(event.keyCode) || event.keyCode === KEY_CODES.BACKSPACE || event.keyCode === KEY_CODES.DELETE || event.keyCode === 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 === KEY_CODES.C && (event.ctrlKey || event.metaKey)) {
           return;
@@ -632,8 +636,6 @@ export var AutocompleteEditor = /*#__PURE__*/function (_HandsontableEditor) {
           }, timeOffset);
         }
       }
-
-      _get(_getPrototypeOf(AutocompleteEditor.prototype), "onBeforeKeyDown", this).call(this, event);
     }
     /**
      * Filters and sorts by relevance.

package/editors/baseEditor/baseEditor.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");
 
@@ -24,27 +24,31 @@ require("core-js/modules/web.dom-collections.iterator.js");
 
 require("core-js/modules/es.array.slice.js");
 
-require("core-js/modules/es.function.name.js");
-
 require("core-js/modules/es.array.from.js");
 
 require("core-js/modules/es.regexp.exec.js");
 
 exports.__esModule = true;
-exports.EDITOR_TYPE = exports.EDITOR_STATE = exports.BaseEditor = void 0;
+exports.SHORTCUTS_GROUP_EDITOR = exports.EDITOR_TYPE = exports.EDITOR_STATE = exports.BaseEditor = void 0;
 
 require("core-js/modules/es.object.freeze.js");
 
 require("core-js/modules/es.string.trim.js");
 
-var _src = require("../../3rdparty/walkontable/src");
+require("core-js/modules/es.function.name.js");
+
+require("core-js/modules/es.array.includes.js");
 
 var _mixed = require("../../helpers/mixed");
 
 var _object = require("../../helpers/object");
 
+var _editorManager = require("../../editorManager");
+
 var _hooksRefRegisterer = _interopRequireDefault(require("../../mixins/hooksRefRegisterer"));
 
+var _element = require("../../helpers/dom/element");
+
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
@@ -59,7 +63,7 @@ function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Sy
 
 function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
 
-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); }
 
@@ -77,7 +81,7 @@ 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; }
 
 var EDITOR_TYPE = 'base';
 exports.EDITOR_TYPE = EDITOR_TYPE;
@@ -89,11 +93,13 @@ var EDITOR_STATE = Object.freeze({
   // waiting for async validation
   FINISHED: 'STATE_FINISHED'
 });
+exports.EDITOR_STATE = EDITOR_STATE;
+var SHORTCUTS_GROUP_EDITOR = 'baseEditor';
 /**
  * @class BaseEditor
  */
 
-exports.EDITOR_STATE = EDITOR_STATE;
+exports.SHORTCUTS_GROUP_EDITOR = SHORTCUTS_GROUP_EDITOR;
 
 var BaseEditor = /*#__PURE__*/function () {
   /**
@@ -295,7 +301,7 @@ var BaseEditor = /*#__PURE__*/function () {
           return _super.apply(this, arguments);
         }
 
-        return Editor;
+        return _createClass(Editor);
       }(this.constructor);
     }
     /**
@@ -308,6 +314,8 @@ var BaseEditor = /*#__PURE__*/function () {
   }, {
     key: "saveValue",
     value: function saveValue(value, ctrlDown) {
+      var _this = this;
+
       var visualRowFrom;
       var visualColumnFrom;
       var visualRowTo;
@@ -336,6 +344,39 @@ var BaseEditor = /*#__PURE__*/function () {
 
         visualRowFrom = _modifiedCellCoords[0];
         visualColumnFrom = _modifiedCellCoords[1];
+      }
+
+      var shortcutManager = this.hot.getShortcutManager();
+      var editorContext = shortcutManager.getContext('editor');
+      var contextConfig = {
+        runOnlyIf: function runOnlyIf() {
+          return (0, _mixed.isDefined)(_this.hot.getSelected());
+        },
+        group: SHORTCUTS_GROUP_EDITOR
+      };
+
+      if (this.isInFullEditMode()) {
+        editorContext.addShortcuts([{
+          keys: [['ArrowUp']],
+          callback: function callback() {
+            _this.hot.selection.transformStart(-1, 0);
+          }
+        }, {
+          keys: [['ArrowDown']],
+          callback: function callback() {
+            _this.hot.selection.transformStart(1, 0);
+          }
+        }, {
+          keys: [['ArrowLeft']],
+          callback: function callback() {
+            _this.hot.selection.transformStart(0, -1 * _this.hot.getDirectionFactor());
+          }
+        }, {
+          keys: [['ArrowRight']],
+          callback: function callback() {
+            _this.hot.selection.transformStart(0, _this.hot.getDirectionFactor());
+          }
+        }], contextConfig);
       } // Saving values using the modified coordinates.
 
 
@@ -360,7 +401,7 @@ var BaseEditor = /*#__PURE__*/function () {
 
       var renderableRowIndex = hotInstance.rowIndexMapper.getRenderableFromVisualIndex(this.row);
       var renderableColumnIndex = hotInstance.columnIndexMapper.getRenderableFromVisualIndex(this.col);
-      hotInstance.view.scrollViewport(new _src.CellCoords(renderableRowIndex, renderableColumnIndex));
+      hotInstance.view.scrollViewport(hotInstance._createCellCoords(renderableRowIndex, renderableColumnIndex));
       this.state = EDITOR_STATE.EDITING; // Set the editor value only in the full edit mode. In other mode the focusable element has to be empty,
       // otherwise IME (editor for Asia users) doesn't work.
 
@@ -387,7 +428,7 @@ var BaseEditor = /*#__PURE__*/function () {
   }, {
     key: "finishEditing",
     value: function finishEditing(restoreOriginalValue, ctrlDown, callback) {
-      var _this = this;
+      var _this2 = this;
 
       var val;
 
@@ -401,7 +442,7 @@ var BaseEditor = /*#__PURE__*/function () {
 
           callback(result);
 
-          _this.hot.view.render();
+          _this2.hot.view.render();
         };
       }
 
@@ -409,9 +450,14 @@ var BaseEditor = /*#__PURE__*/function () {
         return;
       }
 
+      var shortcutManager = this.hot.getShortcutManager();
+      var editorContext = shortcutManager.getContext('editor');
+      editorContext.removeShortcutsByGroup(SHORTCUTS_GROUP_EDITOR);
+      editorContext.removeShortcutsByGroup(_editorManager.SHORTCUTS_GROUP_NAVIGATION);
+
       if (this.state === EDITOR_STATE.VIRGIN) {
         this.hot._registerTimeout(function () {
-          _this._fireCallbacks(true);
+          _this2._fireCallbacks(true);
         });
 
         return;
@@ -438,9 +484,9 @@ var BaseEditor = /*#__PURE__*/function () {
 
         if (this.hot.getCellValidator(this.cellProperties)) {
           this.hot.addHookOnce('postAfterValidate', function (result) {
-            _this.state = EDITOR_STATE.FINISHED;
+            _this2.state = EDITOR_STATE.FINISHED;
 
-            _this.discardEditor(result);
+            _this2.discardEditor(result);
           });
         } else {
           this.state = EDITOR_STATE.FINISHED;
@@ -486,6 +532,9 @@ var BaseEditor = /*#__PURE__*/function () {
         this.state = EDITOR_STATE.VIRGIN;
 
         this._fireCallbacks(true);
+
+        var shortcutManager = this.hot.getShortcutManager();
+        shortcutManager.setActiveContextName('grid');
       }
     }
     /**
@@ -531,6 +580,137 @@ var BaseEditor = /*#__PURE__*/function () {
     value: function isWaiting() {
       return this.state === EDITOR_STATE.WAITING;
     }
+    /* eslint-disable jsdoc/require-description-complete-sentence */
+
+    /**
+     * Gets the object that provides information about the edited cell size and its position
+     * relative to the table viewport.
+     *
+     * The rectangle has six integer properties:
+     *  - `top` The top position relative to the table viewport
+     *  - `start` The left (or right in RTL) position relative to the table viewport
+     *  - `width` The cell's current width;
+     *  - `maxWidth` The maximum cell's width after which the editor goes out of the table viewport
+     *  - `height` The cell's current height;
+     *  - `maxHeight` The maximum cell's height after which the editor goes out of the table viewport
+     *
+     * @returns {{top: number, start: number, width: number, maxWidth: number, height: number, maxHeight: number} | undefined}
+     */
+
+  }, {
+    key: "getEditedCellRect",
+    value: function getEditedCellRect() {
+      var _wtOverlays$getParent;
+
+      var TD = this.getEditedCell(); // TD is outside of the viewport.
+
+      if (!TD) {
+        return;
+      }
+
+      var _this$hot$view$_wt = this.hot.view._wt,
+          wtOverlays = _this$hot$view$_wt.wtOverlays,
+          wtViewport = _this$hot$view$_wt.wtViewport;
+      var rootWindow = this.hot.rootWindow;
+      var currentOffset = (0, _element.offset)(TD);
+      var cellWidth = (0, _element.outerWidth)(TD);
+      var containerOffset = (0, _element.offset)(this.hot.rootElement);
+      var containerWidth = (0, _element.outerWidth)(this.hot.rootElement);
+      var scrollableContainerTop = wtOverlays.topOverlay.holder;
+      var scrollableContainerLeft = wtOverlays.inlineStartOverlay.holder;
+      var containerScrollTop = scrollableContainerTop !== rootWindow ? scrollableContainerTop.scrollTop : 0;
+      var containerScrollLeft = scrollableContainerLeft !== rootWindow ? scrollableContainerLeft.scrollLeft : 0;
+      var gridMostRightPos = rootWindow.innerWidth - containerOffset.left - containerWidth;
+
+      var _ref2 = (_wtOverlays$getParent = wtOverlays.getParentOverlay(TD)) !== null && _wtOverlays$getParent !== void 0 ? _wtOverlays$getParent : this.hot.view._wt,
+          overlayTable = _ref2.wtTable;
+
+      var overlayName = overlayTable.name;
+      var scrollTop = ['master', 'inline_start'].includes(overlayName) ? containerScrollTop : 0;
+      var scrollLeft = ['master', 'top', 'bottom'].includes(overlayName) ? containerScrollLeft : 0; // If colHeaders is disabled, cells in the first row have border-top
+
+      var editTopModifier = currentOffset.top === containerOffset.top ? 0 : 1;
+      var topPos = currentOffset.top - containerOffset.top - editTopModifier - scrollTop;
+      var inlineStartPos = 0;
+
+      if (this.hot.isRtl()) {
+        inlineStartPos = rootWindow.innerWidth - currentOffset.left - cellWidth - gridMostRightPos - 1 + scrollLeft;
+      } else {
+        inlineStartPos = currentOffset.left - containerOffset.left - 1 - scrollLeft;
+      } // When the scrollable element is Window object then the editor position needs to be compensated
+      // by the overlays' position (position relative to the table viewport). In other cases, the overlay's
+      // position always returns 0.
+
+
+      if (['top', 'top_inline_start_corner'].includes(overlayName)) {
+        topPos += wtOverlays.topOverlay.getOverlayOffset();
+      }
+
+      if (['inline_start', 'top_inline_start_corner'].includes(overlayName)) {
+        inlineStartPos += Math.abs(wtOverlays.inlineStartOverlay.getOverlayOffset());
+      }
+
+      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) {
+        topPos += 1;
+      }
+
+      if (renderableColumn <= 0) {
+        inlineStartPos += 1;
+      }
+
+      var firstRowOffset = wtViewport.rowsRenderCalculator.startPosition;
+      var firstColumnOffset = wtViewport.columnsRenderCalculator.startPosition;
+      var horizontalScrollPosition = Math.abs(wtOverlays.inlineStartOverlay.getScrollPosition());
+      var verticalScrollPosition = wtOverlays.topOverlay.getScrollPosition();
+      var scrollbarWidth = (0, _element.getScrollbarWidth)(this.hot.rootDocument);
+      var cellTopOffset = TD.offsetTop + firstRowOffset - verticalScrollPosition;
+      var cellStartOffset = 0;
+
+      if (this.hot.isRtl()) {
+        var cellOffset = TD.offsetLeft;
+
+        if (cellOffset >= 0) {
+          cellStartOffset = overlayTable.getWidth() - TD.offsetLeft;
+        } else {
+          // The `offsetLeft` returns negative values when the parent offset element has position relative
+          // (it happens when on the cell the selection is applied - the `area` CSS class).
+          // When it happens the `offsetLeft` value is calculated from the right edge of the parent element.
+          cellStartOffset = Math.abs(cellOffset);
+        }
+
+        cellStartOffset += firstColumnOffset - horizontalScrollPosition - cellWidth;
+      } else {
+        cellStartOffset = TD.offsetLeft + firstColumnOffset - horizontalScrollPosition;
+      }
+
+      var cellComputedStyle = (0, _element.getComputedStyle)(this.TD, this.hot.rootWindow);
+      var borderPhysicalWidthProp = this.hot.isRtl() ? 'borderRightWidth' : 'borderLeftWidth';
+      var inlineStartBorderCompensation = parseInt(cellComputedStyle[borderPhysicalWidthProp], 10) > 0 ? 0 : 1;
+      var topBorderCompensation = parseInt(cellComputedStyle.borderTopWidth, 10) > 0 ? 0 : 1;
+      var width = (0, _element.outerWidth)(TD) + inlineStartBorderCompensation;
+      var height = (0, _element.outerHeight)(TD) + topBorderCompensation;
+      var actualVerticalScrollbarWidth = (0, _element.hasVerticalScrollbar)(scrollableContainerTop) ? scrollbarWidth : 0;
+      var actualHorizontalScrollbarWidth = (0, _element.hasHorizontalScrollbar)(scrollableContainerLeft) ? scrollbarWidth : 0;
+      var maxWidth = this.hot.view.maximumVisibleElementWidth(cellStartOffset) - actualVerticalScrollbarWidth + inlineStartBorderCompensation;
+      var maxHeight = Math.max(this.hot.view.maximumVisibleElementHeight(cellTopOffset) - actualHorizontalScrollbarWidth + topBorderCompensation, 23);
+      return {
+        top: topPos,
+        start: inlineStartPos,
+        height: height,
+        maxHeight: maxHeight,
+        width: width,
+        maxWidth: maxWidth
+      };
+    }
+    /* eslint-enable jsdoc/require-description-complete-sentence */
+
     /**
      * Gets className of the edited cell if exist.
      *
@@ -543,29 +723,20 @@ var BaseEditor = /*#__PURE__*/function () {
       var editorSection = this.checkEditorSection();
 
       switch (editorSection) {
-        case 'right':
-          return 'ht_clone_right';
-
-        case 'left':
-          return 'ht_clone_left';
+        case 'inline-start':
+          return 'ht_clone_left ht_clone_inline_start';
 
         case 'bottom':
           return 'ht_clone_bottom';
 
-        case 'bottom-right-corner':
-          return 'ht_clone_bottom_right_corner';
-
-        case 'bottom-left-corner':
-          return 'ht_clone_bottom_left_corner';
+        case 'bottom-inline-start-corner':
+          return 'ht_clone_bottom_left_corner ht_clone_bottom_inline_start_corner';
 
         case 'top':
           return 'ht_clone_top';
 
-        case 'top-right-corner':
-          return 'ht_clone_top_right_corner';
-
-        case 'top-left-corner':
-          return 'ht_clone_top_left_corner';
+        case 'top-inline-start-corner':
+          return 'ht_clone_top_left_corner ht_clone_top_inline_start_corner';
 
         default:
           return 'ht_clone_master';
@@ -596,19 +767,19 @@ var BaseEditor = /*#__PURE__*/function () {
       var section = '';
 
       if (this.row < this.hot.getSettings().fixedRowsTop) {
-        if (this.col < this.hot.getSettings().fixedColumnsLeft) {
-          section = 'top-left-corner';
+        if (this.col < this.hot.getSettings().fixedColumnsStart) {
+          section = 'top-inline-start-corner';
         } else {
           section = 'top';
         }
       } else if (this.hot.getSettings().fixedRowsBottom && this.row >= totalRows - this.hot.getSettings().fixedRowsBottom) {
-        if (this.col < this.hot.getSettings().fixedColumnsLeft) {
-          section = 'bottom-left-corner';
+        if (this.col < this.hot.getSettings().fixedColumnsStart) {
+          section = 'bottom-inline-start-corner';
         } else {
           section = 'bottom';
         }
-      } else if (this.col < this.hot.getSettings().fixedColumnsLeft) {
-        section = 'left';
+      } else if (this.col < this.hot.getSettings().fixedColumnsStart) {
+        section = 'inline-start';
       }
 
       return section;