handsontable 11.1.0 → 12.1.0

package/3rdparty/walkontable/src/overlay/{left.mjs → inlineStart.mjs}

@@ -11,7 +11,7 @@ import "core-js/modules/es.array.iterator.js";
 import "core-js/modules/es.string.iterator.js";
 import "core-js/modules/web.dom-collections.iterator.js";
 
-function _construct(Parent, args, Class) { if (_isNativeReflectConstruct()) { _construct = Reflect.construct; } 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 _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 _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
@@ -21,7 +21,7 @@ function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _d
 
 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); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
 
 function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
 
@@ -31,50 +31,49 @@ function _assertThisInitialized(self) { if (self === void 0) { throw new Referen
 
 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 _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
 
-import { addClass, getScrollbarWidth, getScrollLeft, getWindowScrollTop, hasClass, outerWidth, removeClass, setOverlayPosition, resetCssTransform } from "./../../../../helpers/dom/element.mjs";
-import LeftOverlayTable from "./../table/left.mjs";
+import { addClass, getScrollbarWidth, getScrollLeft, getWindowScrollTop, hasClass, outerWidth, removeClass, setOverlayPosition, resetCssTransform } from "../../../../helpers/dom/element.mjs";
+import InlineStartOverlayTable from "../table/inlineStart.mjs";
 import { Overlay } from "./_base.mjs";
-import { CLONE_LEFT } from "./constants.mjs";
+import { CLONE_INLINE_START } from "./constants.mjs";
 /**
- * @class LeftOverlay
+ * @class InlineStartOverlay
  */
 
-export var LeftOverlay = /*#__PURE__*/function (_Overlay) {
-  _inherits(LeftOverlay, _Overlay);
+export var InlineStartOverlay = /*#__PURE__*/function (_Overlay) {
+  _inherits(InlineStartOverlay, _Overlay);
 
-  var _super = _createSuper(LeftOverlay);
+  var _super = _createSuper(InlineStartOverlay);
 
   /**
-   * @param {Walkontable} wotInstance The Walkontable instance.
+   * @param {Walkontable} wotInstance The Walkontable instance. @TODO refactoring: check if can be deleted.
+   * @param {FacadeGetter} facadeGetter Function which return proper facade.
+   * @param {Settings} wtSettings The Walkontable settings.
+   * @param {DomBindings} domBindings Dom elements bound to the current instance.
    */
-  function LeftOverlay(wotInstance) {
-    var _this;
+  function InlineStartOverlay(wotInstance, facadeGetter, wtSettings, domBindings) {
+    _classCallCheck(this, InlineStartOverlay);
 
-    _classCallCheck(this, LeftOverlay);
-
-    _this = _super.call(this, wotInstance);
-    _this.clone = _this.makeClone(CLONE_LEFT);
-    return _this;
+    return _super.call(this, wotInstance, facadeGetter, CLONE_INLINE_START, wtSettings, domBindings);
   }
   /**
    * Factory method to create a subclass of `Table` that is relevant to this overlay.
    *
    * @see Table#constructor
    * @param {...*} args Parameters that will be forwarded to the `Table` constructor.
-   * @returns {Table}
+   * @returns {InlineStartOverlayTable}
    */
 
 
-  _createClass(LeftOverlay, [{
+  _createClass(InlineStartOverlay, [{
     key: "createTable",
     value: function createTable() {
       for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
         args[_key] = arguments[_key];
       }
 
-      return _construct(LeftOverlayTable, args);
+      return _construct(InlineStartOverlayTable, args);
     }
     /**
      * Checks if overlay should be fully rendered.
@@ -85,7 +84,7 @@ export var LeftOverlay = /*#__PURE__*/function (_Overlay) {
   }, {
     key: "shouldBeRendered",
     value: function shouldBeRendered() {
-      return this.wot.getSetting('shouldRenderLeftOverlay');
+      return this.wtSettings.getSetting('shouldRenderInlineStartOverlay');
     }
     /**
      * Updates the left overlay position.
@@ -100,37 +99,23 @@ export var LeftOverlay = /*#__PURE__*/function (_Overlay) {
 
       if (!this.needFullRender || !wtTable.holder.parentNode) {
         // removed from DOM
-        return;
+        return false;
       }
 
+      var rootWindow = this.domBindings.rootWindow;
       var overlayRoot = this.clone.wtTable.holder.parentNode;
-      var headerPosition = 0;
-      var preventOverflow = this.wot.getSetting('preventOverflow');
-
-      if (this.trimmingContainer === this.wot.rootWindow && (!preventOverflow || preventOverflow !== 'horizontal')) {
-        var hiderRect = wtTable.hider.getBoundingClientRect();
-        var left = Math.ceil(hiderRect.left);
-        var right = Math.ceil(hiderRect.right);
-        var finalLeft;
-        var finalTop;
-        finalTop = wtTable.hider.style.top;
-        finalTop = finalTop === '' ? 0 : finalTop;
-
-        if (left < 0 && right - overlayRoot.offsetWidth > 0) {
-          finalLeft = -left;
-        } else {
-          finalLeft = 0;
-        }
+      var preventOverflow = this.wtSettings.getSetting('preventOverflow');
+      var overlayPosition = 0;
 
-        headerPosition = finalLeft;
-        finalLeft += 'px';
-        setOverlayPosition(overlayRoot, finalLeft, finalTop);
+      if (this.trimmingContainer === rootWindow && (!preventOverflow || preventOverflow !== 'horizontal')) {
+        overlayPosition = this.getOverlayOffset() * (this.isRtl() ? -1 : 1);
+        setOverlayPosition(overlayRoot, "".concat(overlayPosition, "px"), '0px');
       } else {
-        headerPosition = this.getScrollPosition();
+        overlayPosition = this.getScrollPosition();
         resetCssTransform(overlayRoot);
       }
 
-      var positionChanged = this.adjustHeaderBordersPosition(headerPosition);
+      var positionChanged = this.adjustHeaderBordersPosition(overlayPosition);
       this.adjustElementsSize();
       return positionChanged;
     }
@@ -144,9 +129,13 @@ export var LeftOverlay = /*#__PURE__*/function (_Overlay) {
   }, {
     key: "setScrollPosition",
     value: function setScrollPosition(pos) {
-      var rootWindow = this.wot.rootWindow;
+      var rootWindow = this.domBindings.rootWindow;
       var result = false;
 
+      if (this.isRtl()) {
+        pos = -pos;
+      }
+
       if (this.mainTableScrollableElement === rootWindow && rootWindow.scrollX !== pos) {
         rootWindow.scrollTo(pos, getWindowScrollTop(rootWindow));
         result = true;
@@ -164,7 +153,7 @@ export var LeftOverlay = /*#__PURE__*/function (_Overlay) {
   }, {
     key: "onScroll",
     value: function onScroll() {
-      this.wot.getSetting('onScrollVertically');
+      this.wtSettings.getSetting('onScrollVertically');
     }
     /**
      * Calculates total sum cells width.
@@ -177,7 +166,7 @@ export var LeftOverlay = /*#__PURE__*/function (_Overlay) {
   }, {
     key: "sumCellSizes",
     value: function sumCellSizes(from, to) {
-      var defaultColumnWidth = this.wot.wtSettings.defaultColumnWidth;
+      var defaultColumnWidth = this.wtSettings.getSetting('defaultColumnWidth');
       var column = from;
       var sum = 0;
 
@@ -212,14 +201,14 @@ export var LeftOverlay = /*#__PURE__*/function (_Overlay) {
   }, {
     key: "adjustRootElementSize",
     value: function adjustRootElementSize() {
-      var _this$wot = this.wot,
-          wtTable = _this$wot.wtTable,
-          rootDocument = _this$wot.rootDocument,
-          rootWindow = _this$wot.rootWindow;
+      var wtTable = this.wot.wtTable;
+      var _this$domBindings = this.domBindings,
+          rootDocument = _this$domBindings.rootDocument,
+          rootWindow = _this$domBindings.rootWindow;
       var scrollbarHeight = getScrollbarWidth(rootDocument);
       var overlayRoot = this.clone.wtTable.holder.parentNode;
       var overlayRootStyle = overlayRoot.style;
-      var preventOverflow = this.wot.getSetting('preventOverflow');
+      var preventOverflow = this.wtSettings.getSetting('preventOverflow');
 
       if (this.trimmingContainer !== rootWindow || preventOverflow === 'vertical') {
         var height = this.wot.wtViewport.getWorkspaceHeight();
@@ -249,7 +238,8 @@ export var LeftOverlay = /*#__PURE__*/function (_Overlay) {
 
       var holder = this.clone.wtTable.holder;
       var selections = this.wot.selections;
-      var selectionCornerOffset = Math.abs((_selections$getCell$g = selections === null || selections === void 0 ? void 0 : selections.getCell().getBorder(this.wot).cornerCenterPointOffset) !== null && _selections$getCell$g !== void 0 ? _selections$getCell$g : 0);
+      var facade = this.facadeGetter();
+      var selectionCornerOffset = Math.abs((_selections$getCell$g = selections === null || selections === void 0 ? void 0 : selections.getCell().getBorder(facade).cornerCenterPointOffset) !== null && _selections$getCell$g !== void 0 ? _selections$getCell$g : 0);
       this.clone.wtTable.hider.style.height = this.hider.style.height;
       holder.style.height = holder.parentNode.style.height; // Add selection corner protruding part to the holder total width to make sure that
       // borders' corner won't be cut after horizontal scroll (#6937).
@@ -263,17 +253,22 @@ export var LeftOverlay = /*#__PURE__*/function (_Overlay) {
   }, {
     key: "applyToDOM",
     value: function applyToDOM() {
-      var total = this.wot.getSetting('totalColumns');
+      var total = this.wtSettings.getSetting('totalColumns');
+      var styleProperty = this.isRtl() ? 'right' : 'left';
 
       if (typeof this.wot.wtViewport.columnsRenderCalculator.startPosition === 'number') {
-        this.spreader.style.left = "".concat(this.wot.wtViewport.columnsRenderCalculator.startPosition, "px");
+        this.spreader.style[styleProperty] = "".concat(this.wot.wtViewport.columnsRenderCalculator.startPosition, "px");
       } else if (total === 0) {
-        this.spreader.style.left = '0';
+        this.spreader.style[styleProperty] = '0';
       } else {
         throw new Error('Incorrect value of the columnsRenderCalculator');
       }
 
-      this.spreader.style.right = '';
+      if (this.isRtl()) {
+        this.spreader.style.left = '';
+      } else {
+        this.spreader.style.right = '';
+      }
 
       if (this.needFullRender) {
         this.syncOverlayOffset();
@@ -296,8 +291,8 @@ export var LeftOverlay = /*#__PURE__*/function (_Overlay) {
      * Scrolls horizontally to a column at the left edge of the viewport.
      *
      * @param {number} sourceCol  Column index which you want to scroll to.
-     * @param {boolean} [beyondRendered]  If `true`, scrolls according to the bottom
-     *                                    edge (top edge is by default).
+     * @param {boolean} [beyondRendered]  If `true`, scrolls according to the right
+     *                                    edge (left edge is by default).
      * @returns {boolean}
      */
 
@@ -309,15 +304,24 @@ export var LeftOverlay = /*#__PURE__*/function (_Overlay) {
       var mainHolder = sourceInstance.wtTable.holder;
       var scrollbarCompensation = 0;
 
+      if (beyondRendered) {
+        var columnWidth = this.wot.wtTable.getColumnWidth(sourceCol);
+        var viewportWidth = this.wot.wtViewport.getViewportWidth();
+
+        if (columnWidth > viewportWidth) {
+          beyondRendered = false;
+        }
+      }
+
       if (beyondRendered && mainHolder.offsetWidth !== mainHolder.clientWidth) {
-        scrollbarCompensation = getScrollbarWidth(this.wot.rootDocument);
+        scrollbarCompensation = getScrollbarWidth(this.domBindings.rootDocument);
       }
 
       if (beyondRendered) {
         newX += this.sumCellSizes(0, sourceCol + 1);
         newX -= this.wot.wtViewport.getViewportWidth();
       } else {
-        newX += this.sumCellSizes(this.wot.getSetting('fixedColumnsLeft'), sourceCol);
+        newX += this.sumCellSizes(this.wtSettings.getSetting('fixedColumnsStart'), sourceCol);
       }
 
       newX += scrollbarCompensation;
@@ -332,10 +336,10 @@ export var LeftOverlay = /*#__PURE__*/function (_Overlay) {
   }, {
     key: "getTableParentOffset",
     value: function getTableParentOffset() {
-      var preventOverflow = this.wot.getSetting('preventOverflow');
+      var preventOverflow = this.wtSettings.getSetting('preventOverflow');
       var offset = 0;
 
-      if (!preventOverflow && this.trimmingContainer === this.wot.rootWindow) {
+      if (!preventOverflow && this.trimmingContainer === this.domBindings.rootWindow) {
         offset = this.wot.wtTable.holderOffset.left;
       }
 
@@ -344,13 +348,44 @@ export var LeftOverlay = /*#__PURE__*/function (_Overlay) {
     /**
      * Gets the main overlay's horizontal scroll position.
      *
-     * @returns {number} Main table's vertical scroll position.
+     * @returns {number} Main table's horizontal scroll position.
      */
 
   }, {
     key: "getScrollPosition",
     value: function getScrollPosition() {
-      return getScrollLeft(this.mainTableScrollableElement, this.wot.rootWindow);
+      return Math.abs(getScrollLeft(this.mainTableScrollableElement, this.domBindings.rootWindow));
+    }
+    /**
+     * Gets the main overlay's horizontal overlay offset.
+     *
+     * @returns {number} Main table's horizontal overlay offset.
+     */
+
+  }, {
+    key: "getOverlayOffset",
+    value: function getOverlayOffset() {
+      var rootWindow = this.domBindings.rootWindow;
+      var preventOverflow = this.wtSettings.getSetting('preventOverflow');
+      var overlayOffset = 0;
+
+      if (this.trimmingContainer === rootWindow && (!preventOverflow || preventOverflow !== 'horizontal')) {
+        if (this.isRtl()) {
+          overlayOffset = Math.abs(Math.min(this.getTableParentOffset() - this.getScrollPosition(), 0));
+        } else {
+          overlayOffset = Math.max(this.getScrollPosition() - this.getTableParentOffset(), 0);
+        }
+
+        var rootWidth = this.wot.wtTable.getTotalWidth();
+        var overlayRootWidth = this.clone.wtTable.getTotalWidth();
+        var maxOffset = rootWidth - overlayRootWidth;
+
+        if (overlayOffset > maxOffset) {
+          overlayOffset = 0;
+        }
+      }
+
+      return overlayOffset;
     }
     /**
      * Adds css classes to hide the header border's header (cell-selection border hiding issue).
@@ -363,9 +398,9 @@ export var LeftOverlay = /*#__PURE__*/function (_Overlay) {
     key: "adjustHeaderBordersPosition",
     value: function adjustHeaderBordersPosition(position) {
       var masterParent = this.wot.wtTable.holder.parentNode;
-      var rowHeaders = this.wot.getSetting('rowHeaders');
-      var fixedColumnsLeft = this.wot.getSetting('fixedColumnsLeft');
-      var totalRows = this.wot.getSetting('totalRows');
+      var rowHeaders = this.wtSettings.getSetting('rowHeaders');
+      var fixedColumnsStart = this.wtSettings.getSetting('fixedColumnsStart');
+      var totalRows = this.wtSettings.getSetting('totalRows');
 
       if (totalRows) {
         removeClass(masterParent, 'emptyRows');
@@ -375,28 +410,24 @@ export var LeftOverlay = /*#__PURE__*/function (_Overlay) {
 
       var positionChanged = false;
 
-      if (fixedColumnsLeft && !rowHeaders.length) {
-        addClass(masterParent, 'innerBorderLeft');
-      } else if (!fixedColumnsLeft && rowHeaders.length) {
-        var previousState = hasClass(masterParent, 'innerBorderLeft');
+      if (fixedColumnsStart && !rowHeaders.length) {
+        // "innerBorderLeft" is for backward compatibility
+        addClass(masterParent, 'innerBorderLeft innerBorderInlineStart');
+      } else if (!fixedColumnsStart && rowHeaders.length) {
+        var previousState = hasClass(masterParent, 'innerBorderInlineStart');
 
         if (position) {
-          addClass(masterParent, 'innerBorderLeft');
+          addClass(masterParent, 'innerBorderLeft innerBorderInlineStart');
           positionChanged = !previousState;
         } else {
-          removeClass(masterParent, 'innerBorderLeft');
+          removeClass(masterParent, 'innerBorderLeft innerBorderInlineStart');
           positionChanged = previousState;
         }
       }
 
       return positionChanged;
     }
-  }], [{
-    key: "OVERLAY_NAME",
-    get: function get() {
-      return CLONE_LEFT;
-    }
   }]);
 
-  return LeftOverlay;
+  return InlineStartOverlay;
 }(Overlay);