handsontable 11.1.0 → 12.1.0

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

@@ -1,6 +1,15 @@
+import "core-js/modules/es.array.concat.js";
 import "core-js/modules/es.object.to-string.js";
 import "core-js/modules/web.dom-collections.for-each.js";
 import "core-js/modules/web.timers.js";
+import "core-js/modules/es.object.set-prototype-of.js";
+import "core-js/modules/es.reflect.construct.js";
+
+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"); } }
 
@@ -8,60 +17,118 @@ 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; }
 
-import { getScrollableElement, getScrollbarWidth } from "./../../../helpers/dom/element.mjs";
-import { arrayEach } from "./../../../helpers/array.mjs";
-import { isKey } from "./../../../helpers/unicode.mjs";
-import { isChrome } from "./../../../helpers/browser.mjs";
-import EventManager from "./../../../eventManager.mjs";
-import { CLONE_BOTTOM_LEFT_CORNER, CLONE_BOTTOM, CLONE_LEFT, CLONE_TOP_LEFT_CORNER, CLONE_TOP, LeftOverlay, TopOverlay, TopLeftCornerOverlay, BottomOverlay, BottomLeftCornerOverlay, registerOverlayOnce, createOverlay, hasOverlay } from "./overlay/index.mjs";
-registerOverlayOnce(BottomLeftCornerOverlay);
-registerOverlayOnce(BottomOverlay);
-registerOverlayOnce(LeftOverlay);
-registerOverlayOnce(TopLeftCornerOverlay);
-registerOverlayOnce(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; }
+
+import { getScrollableElement, getScrollbarWidth } from "../../../helpers/dom/element.mjs";
+import { arrayEach } from "../../../helpers/array.mjs";
+import { isKey } from "../../../helpers/unicode.mjs";
+import { isChrome } from "../../../helpers/browser.mjs";
+import { InlineStartOverlay, TopOverlay, TopInlineStartCornerOverlay, BottomOverlay, BottomInlineStartCornerOverlay } from "./overlay/index.mjs";
 /**
  * @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}
+   */
+
+  /**
+   * Refer to the InlineStartOverlay or instance.
+   *
+   * @protected
+   * @type {InlineStartOverlay}
+   */
+
+  /**
+   * Refer to the TopInlineStartCornerOverlay instance.
+   *
+   * @protected
+   * @type {TopInlineStartCornerOverlay}
    */
-  function Overlays(wotInstance) {
+
+  /**
+   * 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
+
+    this.instance = this.wot; // todo refactoring: move to facade
 
-    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.eventManager = eventManager; // TODO refactoring: probably invalid place to this logic
 
-    this.instance = this.wot;
-    this.eventManager = new EventManager(this.wot);
     this.scrollbarSize = 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 : 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;
@@ -72,72 +139,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 = createOverlay(CLONE_TOP, this.wot);
-      }
-
-      if (!hasOverlay(CLONE_BOTTOM)) {
-        this.bottomOverlay = {
-          needFullRender: false,
-          updateStateOfRendering: function updateStateOfRendering() {
-            return false;
-          }
-        };
-      }
-
-      if (!hasOverlay(CLONE_BOTTOM_LEFT_CORNER)) {
-        this.bottomLeftCornerOverlay = {
-          needFullRender: false,
-          updateStateOfRendering: function updateStateOfRendering() {
-            return false;
-          }
-        };
-      }
-
-      if (this.bottomOverlay) {
-        syncScroll = this.bottomOverlay.updateStateOfRendering() || syncScroll;
-      } else {
-        this.bottomOverlay = createOverlay(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 = createOverlay(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(TopOverlay, args);
+      this.bottomOverlay = _construct(BottomOverlay, args);
+      this.inlineStartOverlay = _construct(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(TopInlineStartCornerOverlay, args.concat([this.topOverlay, this.inlineStartOverlay]));
+      this.bottomInlineStartCornerOverlay = _construct(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 = createOverlay(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 = createOverlay(CLONE_BOTTOM_LEFT_CORNER, this.wot);
+        if (this.bottomOverlay.needFullRender) {
+          syncScroll = this.bottomInlineStartCornerOverlay.updateStateOfRendering() || syncScroll;
         }
       }
 
@@ -154,7 +224,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;
@@ -163,7 +233,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) {
@@ -182,11 +252,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);
       });
@@ -202,8 +272,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
@@ -212,21 +282,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 || !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);
@@ -237,7 +307,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);
       });
     }
@@ -261,8 +331,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
@@ -285,10 +355,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
@@ -337,13 +407,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);
@@ -391,9 +460,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];
@@ -404,7 +475,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;
@@ -429,15 +500,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*()
       }
     }
     /**
@@ -448,16 +519,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;
@@ -474,21 +544,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;
@@ -503,7 +574,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;
 
@@ -517,15 +588,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);
       }
     }
     /**
@@ -538,18 +609,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;
@@ -567,7 +638,7 @@ var Overlays = /*#__PURE__*/function () {
       }
 
       this.topOverlay.adjustElementsSize(force);
-      this.leftOverlay.adjustElementsSize(force);
+      this.inlineStartOverlay.adjustElementsSize(force);
       this.bottomOverlay.adjustElementsSize(force);
     }
     /**
@@ -577,9 +648,7 @@ var Overlays = /*#__PURE__*/function () {
   }, {
     key: "applyToDOM",
     value: function applyToDOM() {
-      var wtTable = this.wot.wtTable;
-
-      if (!wtTable.isVisible()) {
+      if (!this.wtTable.isVisible()) {
         return;
       }
 
@@ -589,7 +658,7 @@ var Overlays = /*#__PURE__*/function () {
         this.bottomOverlay.applyToDOM();
       }
 
-      this.leftOverlay.applyToDOM();
+      this.inlineStartOverlay.applyToDOM();
     }
     /**
      * Get the parent overlay of the provided element.
@@ -605,15 +674,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;
-      arrayEach(overlays, function (elem) {
-        if (!elem) {
+      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;
@@ -626,14 +696,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];
       arrayEach(overlays, function (elem) {
         if (!elem) {
           return;
         }
 
-        elem.clone.wtTable.TABLE.className = masterTable.className;
+        elem.clone.wtTable.TABLE.className = masterTable.className; // todo demeter
       });
     }
   }]);