handsontable 11.1.0 → 12.1.0

package/3rdparty/walkontable/src/overlays.js

@@ -1,27 +1,35 @@
 "use strict";
 
+require("core-js/modules/es.object.set-prototype-of.js");
+
+require("core-js/modules/es.reflect.construct.js");
+
 exports.__esModule = true;
 exports.default = void 0;
 
+require("core-js/modules/es.array.concat.js");
+
 require("core-js/modules/es.object.to-string.js");
 
 require("core-js/modules/web.dom-collections.for-each.js");
 
 require("core-js/modules/web.timers.js");
 
-var _element = require("./../../../helpers/dom/element");
+var _element = require("../../../helpers/dom/element");
 
-var _array = require("./../../../helpers/array");
+var _array = require("../../../helpers/array");
 
-var _unicode = require("./../../../helpers/unicode");
+var _unicode = require("../../../helpers/unicode");
 
-var _browser = require("./../../../helpers/browser");
-
-var _eventManager = _interopRequireDefault(require("./../../../eventManager"));
+var _browser = require("../../../helpers/browser");
 
 var _overlay = require("./overlay");
 
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _construct(Parent, args, Class) { if (_isNativeReflectConstruct()) { _construct = Reflect.construct.bind(); } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
 
 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
@@ -29,54 +37,112 @@ function _defineProperties(target, props) { for (var i = 0; i < props.length; i+
 
 function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
 
-(0, _overlay.registerOverlayOnce)(_overlay.BottomLeftCornerOverlay);
-(0, _overlay.registerOverlayOnce)(_overlay.BottomOverlay);
-(0, _overlay.registerOverlayOnce)(_overlay.LeftOverlay);
-(0, _overlay.registerOverlayOnce)(_overlay.TopLeftCornerOverlay);
-(0, _overlay.registerOverlayOnce)(_overlay.TopOverlay);
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
 /**
  * @class Overlays
  */
-
 var Overlays = /*#__PURE__*/function () {
   /**
-   * @param {Walkontable} wotInstance The Walkontable instance.
+   * Walkontable instance's reference.
+   *
+   * @protected
+   * @type {Walkontable}
+   */
+
+  /**
+   * Refer to the TopOverlay instance.
+   *
+   * @protected
+   * @type {TopOverlay}
+   */
+
+  /**
+   * Refer to the BottomOverlay instance.
+   *
+   * @protected
+   * @type {BottomOverlay}
    */
-  function Overlays(wotInstance) {
+
+  /**
+   * Refer to the InlineStartOverlay or instance.
+   *
+   * @protected
+   * @type {InlineStartOverlay}
+   */
+
+  /**
+   * Refer to the TopInlineStartCornerOverlay instance.
+   *
+   * @protected
+   * @type {TopInlineStartCornerOverlay}
+   */
+
+  /**
+   * Refer to the BottomInlineStartCornerOverlay instance.
+   *
+   * @protected
+   * @type {BottomInlineStartCornerOverlay}
+   */
+
+  /**
+   * Browser line height for purposes of translating mouse wheel.
+   *
+   * @private
+   * @type {number}
+   */
+
+  /**
+   * The walkontable settings.
+   *
+   * @protected
+   * @type {Settings}
+   */
+
+  /**
+   * @param {Walkontable} wotInstance The Walkontable instance. @todo refactoring remove.
+   * @param {FacadeGetter} facadeGetter Function which return proper facade.
+   * @param {DomBindings} domBindings Bindings into DOM.
+   * @param {Settings} wtSettings The Walkontable settings.
+   * @param {EventManager} eventManager The walkontable event manager.
+   * @param {MasterTable} wtTable The master table.
+   */
+  function Overlays(wotInstance, facadeGetter, domBindings, wtSettings, eventManager, wtTable) {
     _classCallCheck(this, Overlays);
 
-    /**
-     * Walkontable instance's reference.
-     *
-     * @private
-     * @type {Walkontable}
-     */
+    _defineProperty(this, "wot", null);
+
+    _defineProperty(this, "topOverlay", null);
+
+    _defineProperty(this, "bottomOverlay", null);
+
+    _defineProperty(this, "inlineStartOverlay", null);
+
+    _defineProperty(this, "topInlineStartCornerOverlay", null);
+
+    _defineProperty(this, "bottomInlineStartCornerOverlay", null);
+
+    _defineProperty(this, "browserLineHeight", undefined);
+
+    _defineProperty(this, "wtSettings", null);
+
     this.wot = wotInstance;
-    var _this$wot = this.wot,
-        rootDocument = _this$wot.rootDocument,
-        rootWindow = _this$wot.rootWindow,
-        wtTable = _this$wot.wtTable;
-    /**
-     * Sometimes `line-height` might be set to 'normal'. In that case, a default `font-size` should be multiplied by roughly 1.2.
-     * Https://developer.mozilla.org/pl/docs/Web/CSS/line-height#Values.
-     */
+    this.wtSettings = wtSettings;
+    this.domBindings = domBindings;
+    this.facadeGetter = facadeGetter;
+    this.wtTable = wtTable;
+    var _this$domBindings = this.domBindings,
+        rootDocument = _this$domBindings.rootDocument,
+        rootWindow = _this$domBindings.rootWindow; // legacy support
 
-    var BODY_LINE_HEIGHT = parseInt(rootWindow.getComputedStyle(rootDocument.body).lineHeight, 10);
-    var FALLBACK_BODY_LINE_HEIGHT = parseInt(rootWindow.getComputedStyle(rootDocument.body).fontSize, 10) * 1.2; // legacy support
+    this.instance = this.wot; // todo refactoring: move to facade
+
+    this.eventManager = eventManager; // TODO refactoring: probably invalid place to this logic
 
-    this.instance = this.wot;
-    this.eventManager = new _eventManager.default(this.wot);
     this.scrollbarSize = (0, _element.getScrollbarWidth)(rootDocument);
-    this.wot.update('scrollbarWidth', this.scrollbarSize);
-    this.wot.update('scrollbarHeight', this.scrollbarSize);
     var isOverflowHidden = rootWindow.getComputedStyle(wtTable.wtRootElement.parentNode).getPropertyValue('overflow') === 'hidden';
     this.scrollableElement = isOverflowHidden ? wtTable.holder : (0, _element.getScrollableElement)(wtTable.TABLE);
-    this.topOverlay = void 0;
-    this.bottomOverlay = void 0;
-    this.leftOverlay = void 0;
-    this.topLeftCornerOverlay = void 0;
-    this.bottomLeftCornerOverlay = void 0;
-    this.prepareOverlays();
+    this.initOverlays();
     this.hasScrollbarBottom = false;
     this.hasScrollbarRight = false;
     this.destroyed = false;
@@ -87,72 +153,75 @@ var Overlays = /*#__PURE__*/function () {
     };
     this.verticalScrolling = false;
     this.horizontalScrolling = false;
-    this.browserLineHeight = BODY_LINE_HEIGHT || FALLBACK_BODY_LINE_HEIGHT;
+    this.initBrowserLineHeight();
     this.registerListeners();
     this.lastScrollX = rootWindow.scrollX;
     this.lastScrollY = rootWindow.scrollY;
   }
   /**
-   * Prepare overlays based on user settings.
+   * Retrieve browser line height and apply its value to `browserLineHeight`.
    *
-   * @returns {boolean} Returns `true` if changes applied to overlay needs scroll synchronization.
+   * @private
    */
 
 
   _createClass(Overlays, [{
-    key: "prepareOverlays",
-    value: function prepareOverlays() {
-      var syncScroll = false;
-
-      if (this.topOverlay) {
-        syncScroll = this.topOverlay.updateStateOfRendering() || syncScroll;
-      } else {
-        this.topOverlay = (0, _overlay.createOverlay)(_overlay.CLONE_TOP, this.wot);
-      }
-
-      if (!(0, _overlay.hasOverlay)(_overlay.CLONE_BOTTOM)) {
-        this.bottomOverlay = {
-          needFullRender: false,
-          updateStateOfRendering: function updateStateOfRendering() {
-            return false;
-          }
-        };
-      }
-
-      if (!(0, _overlay.hasOverlay)(_overlay.CLONE_BOTTOM_LEFT_CORNER)) {
-        this.bottomLeftCornerOverlay = {
-          needFullRender: false,
-          updateStateOfRendering: function updateStateOfRendering() {
-            return false;
-          }
-        };
-      }
-
-      if (this.bottomOverlay) {
-        syncScroll = this.bottomOverlay.updateStateOfRendering() || syncScroll;
-      } else {
-        this.bottomOverlay = (0, _overlay.createOverlay)(_overlay.CLONE_BOTTOM, this.wot);
-      }
+    key: "initBrowserLineHeight",
+    value: function initBrowserLineHeight() {
+      var _this$domBindings2 = this.domBindings,
+          rootWindow = _this$domBindings2.rootWindow,
+          rootDocument = _this$domBindings2.rootDocument;
+      var computedStyle = rootWindow.getComputedStyle(rootDocument.body);
+      /**
+       * Sometimes `line-height` might be set to 'normal'. In that case, a default `font-size` should be multiplied by roughly 1.2.
+       * Https://developer.mozilla.org/pl/docs/Web/CSS/line-height#Values.
+       */
+
+      var lineHeight = parseInt(computedStyle.lineHeight, 10);
+      var lineHeightFalback = parseInt(computedStyle.fontSize, 10) * 1.2;
+      this.browserLineHeight = lineHeight || lineHeightFalback;
+    }
+    /**
+     * Prepare overlays based on user settings.
+     *
+     * @private
+     */
 
-      if (this.leftOverlay) {
-        syncScroll = this.leftOverlay.updateStateOfRendering() || syncScroll;
-      } else {
-        this.leftOverlay = (0, _overlay.createOverlay)(_overlay.CLONE_LEFT, this.wot);
-      }
+  }, {
+    key: "initOverlays",
+    value: function initOverlays() {
+      var args = [this.wot, this.facadeGetter, this.wtSettings, this.domBindings]; // todo refactoring: IOC, collection or factories.
+      // TODO refactoring, conceive about using generic collection of overlays.
+
+      this.topOverlay = _construct(_overlay.TopOverlay, args);
+      this.bottomOverlay = _construct(_overlay.BottomOverlay, args);
+      this.inlineStartOverlay = _construct(_overlay.InlineStartOverlay, args); // TODO discuss, the controversial here would be removing the lazy creation mechanism for corners.
+      // TODO cond. Has no any visual impact. They're initially hidden in same way like left, top, and bottom overlays.
+
+      this.topInlineStartCornerOverlay = _construct(_overlay.TopInlineStartCornerOverlay, args.concat([this.topOverlay, this.inlineStartOverlay]));
+      this.bottomInlineStartCornerOverlay = _construct(_overlay.BottomInlineStartCornerOverlay, args.concat([this.bottomOverlay, this.inlineStartOverlay]));
+    }
+    /**
+     * Update state of rendering, check if changed.
+     *
+     * @package
+     * @returns {boolean} Returns `true` if changes applied to overlay needs scroll synchronization.
+     */
 
-      if (this.topOverlay.needFullRender && this.leftOverlay.needFullRender) {
-        if (this.topLeftCornerOverlay) {
-          syncScroll = this.topLeftCornerOverlay.updateStateOfRendering() || syncScroll;
-        } else {
-          this.topLeftCornerOverlay = (0, _overlay.createOverlay)(_overlay.CLONE_TOP_LEFT_CORNER, this.wot);
+  }, {
+    key: "updateStateOfRendering",
+    value: function updateStateOfRendering() {
+      var syncScroll = this.topOverlay.updateStateOfRendering();
+      syncScroll = this.bottomOverlay.updateStateOfRendering() || syncScroll;
+      syncScroll = this.inlineStartOverlay.updateStateOfRendering() || syncScroll; // todo refactoring: move conditions into updateStateOfRendering(),
+
+      if (this.inlineStartOverlay.needFullRender) {
+        if (this.topOverlay.needFullRender) {
+          syncScroll = this.topInlineStartCornerOverlay.updateStateOfRendering() || syncScroll;
         }
-      }
 
-      if (this.bottomOverlay.needFullRender && this.leftOverlay.needFullRender) {
-        if (this.bottomLeftCornerOverlay) {
-          syncScroll = this.bottomLeftCornerOverlay.updateStateOfRendering() || syncScroll;
-        } else {
-          this.bottomLeftCornerOverlay = (0, _overlay.createOverlay)(_overlay.CLONE_BOTTOM_LEFT_CORNER, this.wot);
+        if (this.bottomOverlay.needFullRender) {
+          syncScroll = this.bottomInlineStartCornerOverlay.updateStateOfRendering() || syncScroll;
         }
       }
 
@@ -169,7 +238,7 @@ var Overlays = /*#__PURE__*/function () {
         return;
       }
 
-      if (!this.wot.wtTable.holder.parentNode) {
+      if (!this.wtTable.holder.parentNode) {
         // Walkontable was detached from DOM, but this handler was not removed
         this.destroy();
         return;
@@ -178,7 +247,7 @@ var Overlays = /*#__PURE__*/function () {
       this.wot.draw(true);
 
       if (this.verticalScrolling) {
-        this.leftOverlay.onScroll();
+        this.inlineStartOverlay.onScroll(); // todo the inlineStartOverlay.onScroll() fires hook. Why is it needed there, not in any another place?
       }
 
       if (this.horizontalScrolling) {
@@ -197,11 +266,11 @@ var Overlays = /*#__PURE__*/function () {
     value: function registerListeners() {
       var _this = this;
 
-      var _this$wot2 = this.wot,
-          rootDocument = _this$wot2.rootDocument,
-          rootWindow = _this$wot2.rootWindow;
+      var _this$domBindings3 = this.domBindings,
+          rootDocument = _this$domBindings3.rootDocument,
+          rootWindow = _this$domBindings3.rootWindow;
       var topOverlayScrollableElement = this.topOverlay.mainTableScrollableElement;
-      var leftOverlayScrollableElement = this.leftOverlay.mainTableScrollableElement;
+      var inlineStartOverlayScrollableElement = this.inlineStartOverlay.mainTableScrollableElement;
       this.eventManager.addEventListener(rootDocument.documentElement, 'keydown', function (event) {
         return _this.onKeyDown(event);
       });
@@ -217,8 +286,8 @@ var Overlays = /*#__PURE__*/function () {
         passive: true
       });
 
-      if (topOverlayScrollableElement !== leftOverlayScrollableElement) {
-        this.eventManager.addEventListener(leftOverlayScrollableElement, 'scroll', function (event) {
+      if (topOverlayScrollableElement !== inlineStartOverlayScrollableElement) {
+        this.eventManager.addEventListener(inlineStartOverlayScrollableElement, 'scroll', function (event) {
           return _this.onTableScroll(event);
         }, {
           passive: true
@@ -227,21 +296,21 @@ var Overlays = /*#__PURE__*/function () {
 
       var isHighPixelRatio = rootWindow.devicePixelRatio && rootWindow.devicePixelRatio > 1;
       var isScrollOnWindow = this.scrollableElement === rootWindow;
-      var preventWheel = this.wot.wtSettings.getSetting('preventWheel');
+      var preventWheel = this.wtSettings.getSetting('preventWheel');
       var wheelEventOptions = {
         passive: isScrollOnWindow
       };
 
       if (preventWheel || isHighPixelRatio || !(0, _browser.isChrome)()) {
-        this.eventManager.addEventListener(this.wot.wtTable.wtRootElement, 'wheel', function (event) {
+        this.eventManager.addEventListener(this.wtTable.wtRootElement, 'wheel', function (event) {
           return _this.onCloneWheel(event, preventWheel);
         }, wheelEventOptions);
       }
 
-      var overlays = [this.topOverlay, this.bottomOverlay, this.leftOverlay, this.topLeftCornerOverlay, this.bottomLeftCornerOverlay];
+      var overlays = [this.topOverlay, this.bottomOverlay, this.inlineStartOverlay, this.topInlineStartCornerOverlay, this.bottomInlineStartCornerOverlay];
       overlays.forEach(function (overlay) {
         if (overlay && overlay.needFullRender) {
-          var holder = overlay.clone.wtTable.holder;
+          var holder = overlay.clone.wtTable.holder; // todo rethink, maybe: overlay.getHolder()
 
           _this.eventManager.addEventListener(holder, 'wheel', function (event) {
             return _this.onCloneWheel(event, preventWheel);
@@ -252,7 +321,7 @@ var Overlays = /*#__PURE__*/function () {
       this.eventManager.addEventListener(rootWindow, 'resize', function () {
         clearTimeout(resizeTimeout);
         resizeTimeout = setTimeout(function () {
-          _this.wot.getSetting('onWindowResize');
+          _this.wtSettings.getSetting('onWindowResize');
         }, 200);
       });
     }
@@ -276,8 +345,8 @@ var Overlays = /*#__PURE__*/function () {
     value: function onTableScroll(event) {
       // There was if statement which controlled flow of this function. It avoided the execution of the next lines
       // on mobile devices. It was changed. Broader description of this case is included within issue #4856.
-      var rootWindow = this.wot.rootWindow;
-      var masterHorizontal = this.leftOverlay.mainTableScrollableElement;
+      var rootWindow = this.domBindings.rootWindow;
+      var masterHorizontal = this.inlineStartOverlay.mainTableScrollableElement;
       var masterVertical = this.topOverlay.mainTableScrollableElement;
       var target = event.target; // For key press, sync only master -> overlay position because while pressing Walkontable.render is triggered
       // by hot.refreshBorder
@@ -300,10 +369,10 @@ var Overlays = /*#__PURE__*/function () {
   }, {
     key: "onCloneWheel",
     value: function onCloneWheel(event, preventDefault) {
-      var rootWindow = this.wot.rootWindow; // There was if statement which controlled flow of this function. It avoided the execution of the next lines
+      var rootWindow = this.domBindings.rootWindow; // There was if statement which controlled flow of this function. It avoided the execution of the next lines
       // on mobile devices. It was changed. Broader description of this case is included within issue #4856.
 
-      var masterHorizontal = this.leftOverlay.mainTableScrollableElement;
+      var masterHorizontal = this.inlineStartOverlay.mainTableScrollableElement;
       var masterVertical = this.topOverlay.mainTableScrollableElement;
       var target = event.target; // For key press, sync only master -> overlay position because while pressing Walkontable.render is triggered
       // by hot.refreshBorder
@@ -352,13 +421,12 @@ var Overlays = /*#__PURE__*/function () {
   }, {
     key: "translateMouseWheelToScroll",
     value: function translateMouseWheelToScroll(event) {
-      var browserLineHeight = this.browserLineHeight;
       var deltaY = isNaN(event.deltaY) ? -1 * event.wheelDeltaY : event.deltaY;
       var deltaX = isNaN(event.deltaX) ? -1 * event.wheelDeltaX : event.deltaX;
 
       if (event.deltaMode === 1) {
-        deltaX += deltaX * browserLineHeight;
-        deltaY += deltaY * browserLineHeight;
+        deltaX += deltaX * this.browserLineHeight;
+        deltaY += deltaY * this.browserLineHeight;
       }
 
       var isScrollVerticallyPossible = this.scrollVertically(deltaY);
@@ -406,9 +474,11 @@ var Overlays = /*#__PURE__*/function () {
         return;
       }
 
-      var rootWindow = this.wot.rootWindow;
-      var topHolder = this.topOverlay.clone.wtTable.holder;
-      var leftHolder = this.leftOverlay.clone.wtTable.holder;
+      var rootWindow = this.domBindings.rootWindow;
+      var topHolder = this.topOverlay.clone.wtTable.holder; // todo rethink
+
+      var leftHolder = this.inlineStartOverlay.clone.wtTable.holder; // todo rethink
+
       var _ref = [this.scrollableElement.scrollLeft, this.scrollableElement.scrollTop],
           scrollLeft = _ref[0],
           scrollTop = _ref[1];
@@ -419,7 +489,7 @@ var Overlays = /*#__PURE__*/function () {
 
       if (this.horizontalScrolling) {
         topHolder.scrollLeft = scrollLeft;
-        var bottomHolder = this.bottomOverlay.needFullRender ? this.bottomOverlay.clone.wtTable.holder : null;
+        var bottomHolder = this.bottomOverlay.needFullRender ? this.bottomOverlay.clone.wtTable.holder : null; // todo rethink
 
         if (bottomHolder) {
           bottomHolder.scrollLeft = scrollLeft;
@@ -444,15 +514,15 @@ var Overlays = /*#__PURE__*/function () {
           scrollTop = master.scrollTop;
 
       if (this.topOverlay.needFullRender) {
-        this.topOverlay.clone.wtTable.holder.scrollLeft = scrollLeft;
+        this.topOverlay.clone.wtTable.holder.scrollLeft = scrollLeft; // todo rethink, *overlay.setScroll*()
       }
 
       if (this.bottomOverlay.needFullRender) {
-        this.bottomOverlay.clone.wtTable.holder.scrollLeft = scrollLeft;
+        this.bottomOverlay.clone.wtTable.holder.scrollLeft = scrollLeft; // todo rethink, *overlay.setScroll*()
       }
 
-      if (this.leftOverlay.needFullRender) {
-        this.leftOverlay.clone.wtTable.holder.scrollTop = scrollTop;
+      if (this.inlineStartOverlay.needFullRender) {
+        this.inlineStartOverlay.clone.wtTable.holder.scrollTop = scrollTop; // todo rethink, *overlay.setScroll*()
       }
     }
     /**
@@ -463,16 +533,15 @@ var Overlays = /*#__PURE__*/function () {
     key: "updateMainScrollableElements",
     value: function updateMainScrollableElements() {
       this.deregisterListeners();
-      this.leftOverlay.updateMainScrollableElement();
+      this.inlineStartOverlay.updateMainScrollableElement();
       this.topOverlay.updateMainScrollableElement();
 
       if (this.bottomOverlay.needFullRender) {
         this.bottomOverlay.updateMainScrollableElement();
       }
 
-      var _this$wot3 = this.wot,
-          rootWindow = _this$wot3.rootWindow,
-          wtTable = _this$wot3.wtTable;
+      var wtTable = this.wtTable;
+      var rootWindow = this.domBindings.rootWindow;
 
       if (rootWindow.getComputedStyle(wtTable.wtRootElement.parentNode).getPropertyValue('overflow') === 'hidden') {
         this.scrollableElement = wtTable.holder;
@@ -489,21 +558,22 @@ var Overlays = /*#__PURE__*/function () {
   }, {
     key: "destroy",
     value: function destroy() {
-      this.eventManager.destroy();
+      this.eventManager.destroy(); // todo, probably all below `destory` calls has no sense. To analyze
+
       this.topOverlay.destroy();
 
       if (this.bottomOverlay.clone) {
         this.bottomOverlay.destroy();
       }
 
-      this.leftOverlay.destroy();
+      this.inlineStartOverlay.destroy();
 
-      if (this.topLeftCornerOverlay) {
-        this.topLeftCornerOverlay.destroy();
+      if (this.topInlineStartCornerOverlay) {
+        this.topInlineStartCornerOverlay.destroy();
       }
 
-      if (this.bottomLeftCornerOverlay && this.bottomLeftCornerOverlay.clone) {
-        this.bottomLeftCornerOverlay.destroy();
+      if (this.bottomInlineStartCornerOverlay && this.bottomInlineStartCornerOverlay.clone) {
+        this.bottomInlineStartCornerOverlay.destroy();
       }
 
       this.destroyed = true;
@@ -518,7 +588,7 @@ var Overlays = /*#__PURE__*/function () {
     key: "refresh",
     value: function refresh() {
       var fastDraw = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
-      var spreader = this.wot.wtTable.spreader;
+      var spreader = this.wtTable.spreader;
       var width = spreader.clientWidth;
       var height = spreader.clientHeight;
 
@@ -532,15 +602,15 @@ var Overlays = /*#__PURE__*/function () {
         this.bottomOverlay.refresh(fastDraw);
       }
 
-      this.leftOverlay.refresh(fastDraw);
+      this.inlineStartOverlay.refresh(fastDraw);
       this.topOverlay.refresh(fastDraw);
 
-      if (this.topLeftCornerOverlay) {
-        this.topLeftCornerOverlay.refresh(fastDraw);
+      if (this.topInlineStartCornerOverlay) {
+        this.topInlineStartCornerOverlay.refresh(fastDraw);
       }
 
-      if (this.bottomLeftCornerOverlay && this.bottomLeftCornerOverlay.clone) {
-        this.bottomLeftCornerOverlay.refresh(fastDraw);
+      if (this.bottomInlineStartCornerOverlay && this.bottomInlineStartCornerOverlay.clone) {
+        this.bottomInlineStartCornerOverlay.refresh(fastDraw);
       }
     }
     /**
@@ -553,18 +623,18 @@ var Overlays = /*#__PURE__*/function () {
     key: "adjustElementsSize",
     value: function adjustElementsSize() {
       var force = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
-      var _this$wot4 = this.wot,
-          wtViewport = _this$wot4.wtViewport,
-          wtTable = _this$wot4.wtTable;
-      var totalColumns = this.wot.getSetting('totalColumns');
-      var totalRows = this.wot.getSetting('totalRows');
+      var wtViewport = this.wot.wtViewport;
+      var wtTable = this.wtTable;
+      var totalColumns = this.wtSettings.getSetting('totalColumns');
+      var totalRows = this.wtSettings.getSetting('totalRows');
       var headerRowSize = wtViewport.getRowHeaderWidth();
       var headerColumnSize = wtViewport.getColumnHeaderHeight();
       var hiderStyle = wtTable.hider.style;
-      hiderStyle.width = "".concat(headerRowSize + this.leftOverlay.sumCellSizes(0, totalColumns), "px");
+      hiderStyle.width = "".concat(headerRowSize + this.inlineStartOverlay.sumCellSizes(0, totalColumns), "px");
       hiderStyle.height = "".concat(headerColumnSize + this.topOverlay.sumCellSizes(0, totalRows) + 1, "px");
 
       if (this.scrollbarSize > 0) {
+        // todo refactoring, looking as a part of logic which should be moved outside the class
         var _wtTable$wtRootElemen = wtTable.wtRootElement,
             rootElemScrollHeight = _wtTable$wtRootElemen.scrollHeight,
             rootElemScrollWidth = _wtTable$wtRootElemen.scrollWidth;
@@ -582,7 +652,7 @@ var Overlays = /*#__PURE__*/function () {
       }
 
       this.topOverlay.adjustElementsSize(force);
-      this.leftOverlay.adjustElementsSize(force);
+      this.inlineStartOverlay.adjustElementsSize(force);
       this.bottomOverlay.adjustElementsSize(force);
     }
     /**
@@ -592,9 +662,7 @@ var Overlays = /*#__PURE__*/function () {
   }, {
     key: "applyToDOM",
     value: function applyToDOM() {
-      var wtTable = this.wot.wtTable;
-
-      if (!wtTable.isVisible()) {
+      if (!this.wtTable.isVisible()) {
         return;
       }
 
@@ -604,7 +672,7 @@ var Overlays = /*#__PURE__*/function () {
         this.bottomOverlay.applyToDOM();
       }
 
-      this.leftOverlay.applyToDOM();
+      this.inlineStartOverlay.applyToDOM();
     }
     /**
      * Get the parent overlay of the provided element.
@@ -620,15 +688,16 @@ var Overlays = /*#__PURE__*/function () {
         return null;
       }
 
-      var overlays = [this.topOverlay, this.leftOverlay, this.bottomOverlay, this.topLeftCornerOverlay, this.bottomLeftCornerOverlay];
+      var overlays = [this.topOverlay, this.inlineStartOverlay, this.bottomOverlay, this.topInlineStartCornerOverlay, this.bottomInlineStartCornerOverlay];
       var result = null;
-      (0, _array.arrayEach)(overlays, function (elem) {
-        if (!elem) {
+      (0, _array.arrayEach)(overlays, function (overlay) {
+        if (!overlay) {
           return;
         }
 
-        if (elem.clone && elem.clone.wtTable.TABLE.contains(element)) {
-          result = elem.clone;
+        if (overlay.clone && overlay.clone.wtTable.TABLE.contains(element)) {
+          // todo demeter
+          result = overlay.clone;
         }
       });
       return result;
@@ -641,14 +710,14 @@ var Overlays = /*#__PURE__*/function () {
   }, {
     key: "syncOverlayTableClassNames",
     value: function syncOverlayTableClassNames() {
-      var masterTable = this.instance.wtTable.TABLE;
-      var overlays = [this.topOverlay, this.leftOverlay, this.bottomOverlay, this.topLeftCornerOverlay, this.bottomLeftCornerOverlay];
+      var masterTable = this.wtTable.TABLE;
+      var overlays = [this.topOverlay, this.inlineStartOverlay, this.bottomOverlay, this.topInlineStartCornerOverlay, this.bottomInlineStartCornerOverlay];
       (0, _array.arrayEach)(overlays, function (elem) {
         if (!elem) {
           return;
         }
 
-        elem.clone.wtTable.TABLE.className = masterTable.className;
+        elem.clone.wtTable.TABLE.className = masterTable.className; // todo demeter
       });
     }
   }]);