handsontable 0.0.0-next-9ec04ce-20221121

package/3rdparty/walkontable/src/renderer/table.mjs

@@ -0,0 +1,313 @@
+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); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+/**
+ * TableRenderer class collects all renderers and properties necessary for table creation. It's
+ * responsible for adjusting and rendering each renderer.
+ *
+ * Below is a diagram of the renderers together with an indication of what they are responisble for.
+ *   <table>
+ *     <colgroup>  \ (root node)
+ *       <col>      \
+ *       <col>       \___ ColGroupRenderer
+ *       <col>       /
+ *       <col>      /
+ *     </colgroup> /
+ *     <thead>     \ (root node)
+ *       <tr>       \
+ *         <th>      \
+ *         <th>       \____ ColumnHeadersRenderer
+ *         <th>       /
+ *         <th>      /
+ *       </tr>      /
+ *     </thead>    /
+ *     <tbody>   ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯\ (root node)
+ *       <tr>   (root node)          \
+ *         <th>  --- RowHeadersRenderer
+ *         <td>  \                     \
+ *         <td>   -- CellsRenderer      \
+ *         <td>  /                       \
+ *       </tr>                            \
+ *       <tr>   (root node)                \
+ *         <th>  --- RowHeadersRenderer     \
+ *         <td>  \                           \___ RowsRenderer
+ *         <td>   -- CellsRenderer           /
+ *         <td>  /                          /
+ *       </tr>                             /
+ *       <tr>   (root node)               /
+ *         <th>  --- RowHeadersRenderer  /
+ *         <td>  \                      /
+ *         <td>   -- CellsRenderer     /
+ *         <td>  /                    /
+ *       </tr>                       /
+ *     </tbody>  ___________________/
+ *   </table>.
+ *
+ * @class {RowsRenderer}
+ */
+var TableRenderer = /*#__PURE__*/function () {
+  function TableRenderer(rootNode) {
+    var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+      cellRenderer = _ref.cellRenderer;
+    _classCallCheck(this, TableRenderer);
+    /**
+     * Table element which will be used to render the children element.
+     *
+     * @type {HTMLTableElement}
+     */
+    this.rootNode = rootNode;
+    /**
+     * Document owner of the root node.
+     *
+     * @type {HTMLDocument}
+     */
+    this.rootDocument = this.rootNode.ownerDocument;
+    /**
+     * Renderer class responsible for rendering row headers.
+     *
+     * @type {RowsRenderer}
+     */
+    this.rowHeaders = null;
+    /**
+     * Renderer class responsible for rendering column headers.
+     *
+     * @type {ColumnHeadersRenderer}
+     */
+    this.columnHeaders = null;
+    /**
+     * Renderer class responsible for rendering col in colgroup.
+     *
+     * @type {ColGroupRenderer}
+     */
+    this.colGroup = null;
+    /**
+     * Renderer class responsible for rendering rows in tbody.
+     *
+     * @type {RowsRenderer}
+     */
+    this.rows = null;
+    /**
+     * Renderer class responsible for rendering cells.
+     *
+     * @type {CellsRenderer}
+     */
+    this.cells = null;
+    /**
+     * Row filter which contains all necessary information about row index transformation.
+     *
+     * @type {RowFilter}
+     */
+    this.rowFilter = null;
+    /**
+     * Column filter which contains all necessary information about column index transformation.
+     *
+     * @type {ColumnFilter}
+     */
+    this.columnFilter = null;
+    /**
+     * Row utils class which contains all necessary information about sizes of the rows.
+     *
+     * @type {RowUtils}
+     */
+    this.rowUtils = null;
+    /**
+     * Column utils class which contains all necessary information about sizes of the columns.
+     *
+     * @type {ColumnUtils}
+     */
+    this.columnUtils = null;
+    /**
+     * Indicates how much rows should be rendered to fill whole table viewport.
+     *
+     * @type {number}
+     */
+    this.rowsToRender = 0;
+    /**
+     * Indicates how much columns should be rendered to fill whole table viewport.
+     *
+     * @type {number}
+     */
+    this.columnsToRender = 0;
+    /**
+     * An array of functions to be used as a content factory to row headers.
+     *
+     * @type {Function[]}
+     */
+    this.rowHeaderFunctions = [];
+    /**
+     * Count of the function used to render row headers.
+     *
+     * @type {number}
+     */
+    this.rowHeadersCount = 0;
+    /**
+     * An array of functions to be used as a content factory to column headers.
+     *
+     * @type {Function[]}
+     */
+    this.columnHeaderFunctions = [];
+    /**
+     * Count of the function used to render column headers.
+     *
+     * @type {number}
+     */
+    this.columnHeadersCount = 0;
+    /**
+     * Cell renderer used to render cells content.
+     *
+     * @type {Function}
+     */
+    this.cellRenderer = cellRenderer;
+  }
+
+  /**
+   * Set row and column util classes.
+   *
+   * @param {RowUtils} rowUtils RowUtils instance which provides useful methods related to row sizes.
+   * @param {ColumnUtils} columnUtils ColumnUtils instance which provides useful methods related to row sizes.
+   */
+  _createClass(TableRenderer, [{
+    key: "setAxisUtils",
+    value: function setAxisUtils(rowUtils, columnUtils) {
+      this.rowUtils = rowUtils;
+      this.columnUtils = columnUtils;
+    }
+
+    /**
+     * Sets viewport size of the table.
+     *
+     * @param {number} rowsCount An amount of rows to render.
+     * @param {number} columnsCount An amount of columns to render.
+     */
+  }, {
+    key: "setViewportSize",
+    value: function setViewportSize(rowsCount, columnsCount) {
+      this.rowsToRender = rowsCount;
+      this.columnsToRender = columnsCount;
+    }
+
+    /**
+     * Sets row and column filter instances.
+     *
+     * @param {RowFilter} rowFilter Row filter instance which contains all necessary information about row index transformation.
+     * @param {ColumnFilter} columnFilter Column filter instance which contains all necessary information about row
+     * index transformation.
+     */
+  }, {
+    key: "setFilters",
+    value: function setFilters(rowFilter, columnFilter) {
+      this.rowFilter = rowFilter;
+      this.columnFilter = columnFilter;
+    }
+
+    /**
+     * Sets row and column header functions.
+     *
+     * @param {Function[]} rowHeaders Row header functions. Factories for creating content for row headers.
+     * @param {Function[]} columnHeaders Column header functions. Factories for creating content for column headers.
+     */
+  }, {
+    key: "setHeaderContentRenderers",
+    value: function setHeaderContentRenderers(rowHeaders, columnHeaders) {
+      this.rowHeaderFunctions = rowHeaders;
+      this.rowHeadersCount = rowHeaders.length;
+      this.columnHeaderFunctions = columnHeaders;
+      this.columnHeadersCount = columnHeaders.length;
+    }
+
+    /**
+     * Sets table renderers.
+     *
+     * @param {renderers} renderers The renderer units.
+     * @param {RowHeadersRenderer} renderers.rowHeaders Row headers renderer.
+     * @param {ColumnHeadersRenderer} renderers.columnHeaders Column headers renderer.
+     * @param {ColGroupRenderer} renderers.colGroup Col group renderer.
+     * @param {RowsRenderer} renderers.rows Rows renderer.
+     * @param {CellsRenderer} renderers.cells Cells renderer.
+     */
+  }, {
+    key: "setRenderers",
+    value: function setRenderers() {
+      var _ref2 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+        rowHeaders = _ref2.rowHeaders,
+        columnHeaders = _ref2.columnHeaders,
+        colGroup = _ref2.colGroup,
+        rows = _ref2.rows,
+        cells = _ref2.cells;
+      rowHeaders.setTable(this);
+      columnHeaders.setTable(this);
+      colGroup.setTable(this);
+      rows.setTable(this);
+      cells.setTable(this);
+      this.rowHeaders = rowHeaders;
+      this.columnHeaders = columnHeaders;
+      this.colGroup = colGroup;
+      this.rows = rows;
+      this.cells = cells;
+    }
+
+    /**
+     * Transforms visual/rendered row index to source index.
+     *
+     * @param {number} rowIndex Rendered index.
+     * @returns {number}
+     */
+  }, {
+    key: "renderedRowToSource",
+    value: function renderedRowToSource(rowIndex) {
+      return this.rowFilter.renderedToSource(rowIndex);
+    }
+
+    /**
+     * Transforms visual/rendered column index to source index.
+     *
+     * @param {number} columnIndex Rendered index.
+     * @returns {number}
+     */
+  }, {
+    key: "renderedColumnToSource",
+    value: function renderedColumnToSource(columnIndex) {
+      return this.columnFilter.renderedToSource(columnIndex);
+    }
+
+    /**
+     * Renders the table.
+     */
+  }, {
+    key: "render",
+    value: function render() {
+      this.colGroup.adjust();
+      this.columnHeaders.adjust();
+      this.rows.adjust();
+      this.rowHeaders.adjust();
+      this.columnHeaders.render();
+      this.rows.render();
+      this.rowHeaders.render();
+      this.cells.render();
+
+      // After the cells are rendered calculate columns width (or columns stretch width) to prepare proper values
+      // for colGroup renderer (which renders COL elements).
+      this.columnUtils.calculateWidths();
+      this.colGroup.render();
+      var rowsToRender = this.rowsToRender,
+        rows = this.rows;
+
+      // Fix for multi-line content and for supporting `rowHeights` option.
+      for (var visibleRowIndex = 0; visibleRowIndex < rowsToRender; visibleRowIndex++) {
+        var TR = rows.getRenderedNode(visibleRowIndex);
+        if (TR.firstChild) {
+          var sourceRowIndex = this.renderedRowToSource(visibleRowIndex);
+          var rowHeight = this.rowUtils.getHeight(sourceRowIndex);
+          if (rowHeight) {
+            // Decrease height. 1 pixel will be "replaced" by 1px border top
+            TR.firstChild.style.height = "".concat(rowHeight - 1, "px");
+          } else {
+            TR.firstChild.style.height = '';
+          }
+        }
+      }
+    }
+  }]);
+  return TableRenderer;
+}();
+export { TableRenderer as default };

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

@@ -0,0 +1,316 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+require("core-js/modules/es.number.is-integer.js");
+require("core-js/modules/es.number.constructor.js");
+var _element = require("../../../helpers/dom/element");
+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); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+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 Scroll
+ */
+var Scroll = /*#__PURE__*/function () {
+  /**
+   * The data access object.
+   *
+   * @protected
+   * @type {ScrollDao}
+   */
+
+  /**
+   * Holds the last column reached by the scroll, which determines the scroll snapping direction
+   * (left or right) for a next horizontal scroll.
+   *
+   * @protected
+   * @type {number}
+   */
+
+  /**
+   * Holds the last row reached by the scroll, which determines the scroll snapping direction
+   * (top or bottom) for a next vertical scroll.
+   *
+   * @protected
+   * @type {number}
+   */
+
+  /**
+   * @param {ScrollDao} dataAccessObject Tha data access object.
+   */
+  function Scroll(dataAccessObject) {
+    _classCallCheck(this, Scroll);
+    _defineProperty(this, "dataAccessObject", void 0);
+    _defineProperty(this, "lastScrolledColumnPos", -1);
+    _defineProperty(this, "lastScrolledRowPos", -1);
+    this.dataAccessObject = dataAccessObject;
+  }
+
+  /**
+   * Scrolls viewport to a cell.
+   *
+   * @param {CellCoords} coords The cell coordinates.
+   * @param {boolean} [snapToTop] If `true`, viewport is scrolled to show the cell on the top of the table.
+   * @param {boolean} [snapToRight] If `true`, viewport is scrolled to show the cell on the right of the table.
+   * @param {boolean} [snapToBottom] If `true`, viewport is scrolled to show the cell on the bottom of the table.
+   * @param {boolean} [snapToLeft] If `true`, viewport is scrolled to show the cell on the left of the table.
+   * @returns {boolean}
+   */
+  _createClass(Scroll, [{
+    key: "scrollViewport",
+    value: function scrollViewport(coords, snapToTop, snapToRight, snapToBottom, snapToLeft) {
+      var scrolledHorizontally = this.scrollViewportHorizontally(coords.col, snapToRight, snapToLeft);
+      var scrolledVertically = this.scrollViewportVertically(coords.row, snapToTop, snapToBottom);
+      return scrolledHorizontally || scrolledVertically;
+    }
+
+    /**
+     * Scrolls viewport to a column.
+     *
+     * @param {number} column Visual column index.
+     * @param {boolean} [snapToRight] If `true`, viewport is scrolled to show the cell on the right of the table.
+     * @param {boolean} [snapToLeft] If `true`, viewport is scrolled to show the cell on the left of the table.
+     * @returns {boolean}
+     */
+  }, {
+    key: "scrollViewportHorizontally",
+    value: function scrollViewportHorizontally(column, snapToRight, snapToLeft) {
+      var _this$dataAccessObjec = this.dataAccessObject,
+        drawn = _this$dataAccessObjec.drawn,
+        totalColumns = _this$dataAccessObjec.totalColumns;
+
+      // do not scroll the viewport when the column points to a range outside of the dataset
+      if (!drawn || !Number.isInteger(column) || column < 0 || column > totalColumns) {
+        return false;
+      }
+      var firstVisibleColumn = this.getFirstVisibleColumn();
+      var lastVisibleColumn = this.getLastVisibleColumn();
+      var autoSnapping = snapToRight === void 0 && snapToLeft === void 0;
+      var _this$dataAccessObjec2 = this.dataAccessObject,
+        fixedColumnsStart = _this$dataAccessObjec2.fixedColumnsStart,
+        inlineStartOverlay = _this$dataAccessObjec2.inlineStartOverlay;
+
+      // for auto-snapping (both snap* arguments are undefined) do not scroll the viewport
+      // when the columns points to the overlays
+      if (autoSnapping && column < fixedColumnsStart) {
+        return false;
+      }
+      var result = false;
+
+      // if there is no fully visible columns use the supporting variable (lastScrolledColumnPos) to
+      // determine the snapping direction (left or right)
+      if (firstVisibleColumn === -1) {
+        result = inlineStartOverlay.scrollTo(column, autoSnapping ? column > this.lastScrolledColumnPos : snapToRight);
+      } else if (autoSnapping && (column < firstVisibleColumn || column > lastVisibleColumn) || !autoSnapping) {
+        // if there is at least one fully visible column determine the snapping direction based on
+        // that columns or by snapToRight/snapToLeft flags, if provided.
+        result = inlineStartOverlay.scrollTo(column, autoSnapping ? column > lastVisibleColumn : snapToRight);
+      }
+      if (result) {
+        this.lastScrolledColumnPos = column;
+      }
+      return result;
+    }
+
+    /**
+     * Scrolls viewport to a row.
+     *
+     * @param {number} row Visual row index.
+     * @param {boolean} [snapToTop] If `true`, viewport is scrolled to show the cell on the top of the table.
+     * @param {boolean} [snapToBottom] If `true`, viewport is scrolled to show the cell on the bottom of the table.
+     * @returns {boolean}
+     */
+  }, {
+    key: "scrollViewportVertically",
+    value: function scrollViewportVertically(row, snapToTop, snapToBottom) {
+      var _this$dataAccessObjec3 = this.dataAccessObject,
+        drawn = _this$dataAccessObjec3.drawn,
+        totalRows = _this$dataAccessObjec3.totalRows;
+
+      // do not scroll the viewport when the row points to a range outside of the dataset
+      if (!drawn || !Number.isInteger(row) || row < 0 || row > totalRows) {
+        return false;
+      }
+      var firstVisibleRow = this.getFirstVisibleRow();
+      var lastVisibleRow = this.getLastVisibleRow();
+      var autoSnapping = snapToTop === void 0 && snapToBottom === void 0;
+      var _this$dataAccessObjec4 = this.dataAccessObject,
+        fixedRowsBottom = _this$dataAccessObjec4.fixedRowsBottom,
+        fixedRowsTop = _this$dataAccessObjec4.fixedRowsTop,
+        topOverlay = _this$dataAccessObjec4.topOverlay;
+
+      // for auto-snapping (both snap* arguments are undefined) do not scroll the viewport
+      // when the rows points to the overlays
+      if (autoSnapping && (row < fixedRowsTop || row > totalRows - fixedRowsBottom - 1)) {
+        return false;
+      }
+      var result = false;
+
+      // if there is no fully visible rows use the supporting variable (lastScrolledRowPos) to
+      // determine the snapping direction (top or bottom)
+      if (firstVisibleRow === -1) {
+        result = topOverlay.scrollTo(row, autoSnapping ? row > this.lastScrolledRowPos : snapToBottom);
+      } else if (autoSnapping && (row < firstVisibleRow || row > lastVisibleRow) || !autoSnapping) {
+        // if there is at least one fully visible row determine the snapping direction based on
+        // that rows or by snapToTop/snapToBottom flags, if provided.
+        result = topOverlay.scrollTo(row, autoSnapping ? row > lastVisibleRow : snapToBottom);
+      }
+      if (result) {
+        this.lastScrolledRowPos = row;
+      }
+      return result;
+    }
+
+    /**
+     * Get first visible row based on virtual dom and how table is visible in browser window viewport.
+     *
+     * @returns {number}
+     */
+  }, {
+    key: "getFirstVisibleRow",
+    value: function getFirstVisibleRow() {
+      var _this$dataAccessObjec5 = this.dataAccessObject,
+        topOverlay = _this$dataAccessObjec5.topOverlay,
+        wtTable = _this$dataAccessObjec5.wtTable,
+        wtViewport = _this$dataAccessObjec5.wtViewport,
+        totalRows = _this$dataAccessObjec5.totalRows,
+        fixedRowsTop = _this$dataAccessObjec5.fixedRowsTop,
+        rootWindow = _this$dataAccessObjec5.rootWindow;
+      var firstVisibleRow = wtTable.getFirstVisibleRow();
+      if (topOverlay.mainTableScrollableElement === rootWindow) {
+        var rootElementOffset = (0, _element.offset)(wtTable.wtRootElement);
+        var totalTableHeight = (0, _element.innerHeight)(wtTable.hider);
+        var windowHeight = (0, _element.innerHeight)(rootWindow);
+        var windowScrollTop = (0, _element.getScrollTop)(rootWindow, rootWindow);
+
+        // Only calculate firstVisibleRow when table didn't filled (from up) whole viewport space
+        if (rootElementOffset.top + totalTableHeight - windowHeight <= windowScrollTop) {
+          var rowsHeight = wtViewport.getColumnHeaderHeight();
+          rowsHeight += topOverlay.sumCellSizes(0, fixedRowsTop);
+          for (var row = totalRows; row > 0; row--) {
+            rowsHeight += topOverlay.sumCellSizes(row - 1, row);
+            if (rootElementOffset.top + totalTableHeight - rowsHeight <= windowScrollTop) {
+              // Return physical row + 1
+              firstVisibleRow = row;
+              break;
+            }
+          }
+        }
+      }
+      return firstVisibleRow;
+    }
+
+    /**
+     * Get last visible row based on virtual dom and how table is visible in browser window viewport.
+     *
+     * @returns {number}
+     */
+  }, {
+    key: "getLastVisibleRow",
+    value: function getLastVisibleRow() {
+      var _this$dataAccessObjec6 = this.dataAccessObject,
+        topOverlay = _this$dataAccessObjec6.topOverlay,
+        wtTable = _this$dataAccessObjec6.wtTable,
+        wtViewport = _this$dataAccessObjec6.wtViewport,
+        totalRows = _this$dataAccessObjec6.totalRows,
+        rootWindow = _this$dataAccessObjec6.rootWindow;
+      var lastVisibleRow = wtTable.getLastVisibleRow();
+      if (topOverlay.mainTableScrollableElement === rootWindow) {
+        var rootElementOffset = (0, _element.offset)(wtTable.wtRootElement);
+        var windowScrollTop = (0, _element.getScrollTop)(rootWindow, rootWindow);
+
+        // Only calculate lastVisibleRow when table didn't filled (from bottom) whole viewport space
+        if (rootElementOffset.top > windowScrollTop) {
+          var windowHeight = (0, _element.innerHeight)(rootWindow);
+          var rowsHeight = wtViewport.getColumnHeaderHeight();
+          for (var row = 1; row <= totalRows; row++) {
+            rowsHeight += topOverlay.sumCellSizes(row - 1, row);
+            if (rootElementOffset.top + rowsHeight - windowScrollTop >= windowHeight) {
+              // Return physical row - 1 (-2 because rangeEach gives row index + 1 - sumCellSizes requirements)
+              lastVisibleRow = row - 2;
+              break;
+            }
+          }
+        }
+      }
+      return lastVisibleRow;
+    }
+
+    /**
+     * Get first visible column based on virtual dom and how table is visible in browser window viewport.
+     *
+     * @returns {number}
+     */
+  }, {
+    key: "getFirstVisibleColumn",
+    value: function getFirstVisibleColumn() {
+      var _this$dataAccessObjec7 = this.dataAccessObject,
+        inlineStartOverlay = _this$dataAccessObjec7.inlineStartOverlay,
+        wtTable = _this$dataAccessObjec7.wtTable,
+        wtViewport = _this$dataAccessObjec7.wtViewport,
+        totalColumns = _this$dataAccessObjec7.totalColumns,
+        rootWindow = _this$dataAccessObjec7.rootWindow;
+      var firstVisibleColumn = wtTable.getFirstVisibleColumn();
+      if (inlineStartOverlay.mainTableScrollableElement === rootWindow) {
+        var rootElementOffset = (0, _element.offset)(wtTable.wtRootElement);
+        var totalTableWidth = (0, _element.innerWidth)(wtTable.hider);
+        var windowWidth = (0, _element.innerWidth)(rootWindow);
+        var windowScrollLeft = Math.abs((0, _element.getScrollLeft)(rootWindow, rootWindow));
+
+        // Only calculate firstVisibleColumn when table didn't filled (from left) whole viewport space
+        if (rootElementOffset.left + totalTableWidth - windowWidth <= windowScrollLeft) {
+          var columnsWidth = wtViewport.getRowHeaderWidth();
+          for (var column = totalColumns; column > 0; column--) {
+            columnsWidth += inlineStartOverlay.sumCellSizes(column - 1, column);
+            if (rootElementOffset.left + totalTableWidth - columnsWidth <= windowScrollLeft) {
+              // Return physical column + 1
+              firstVisibleColumn = column;
+              break;
+            }
+          }
+        }
+      }
+      return firstVisibleColumn;
+    }
+
+    /**
+     * Get last visible column based on virtual dom and how table is visible in browser window viewport.
+     *
+     * @returns {number}
+     */
+  }, {
+    key: "getLastVisibleColumn",
+    value: function getLastVisibleColumn() {
+      var _this$dataAccessObjec8 = this.dataAccessObject,
+        inlineStartOverlay = _this$dataAccessObjec8.inlineStartOverlay,
+        wtTable = _this$dataAccessObjec8.wtTable,
+        wtViewport = _this$dataAccessObjec8.wtViewport,
+        totalColumns = _this$dataAccessObjec8.totalColumns,
+        rootWindow = _this$dataAccessObjec8.rootWindow;
+      var lastVisibleColumn = wtTable.getLastVisibleColumn();
+      if (inlineStartOverlay.mainTableScrollableElement === rootWindow) {
+        var rootElementOffset = (0, _element.offset)(wtTable.wtRootElement);
+        var windowScrollLeft = Math.abs((0, _element.getScrollLeft)(rootWindow, rootWindow));
+
+        // Only calculate lastVisibleColumn when table didn't filled (from right) whole viewport space
+        if (rootElementOffset.left > windowScrollLeft) {
+          var windowWidth = (0, _element.innerWidth)(rootWindow);
+          var columnsWidth = wtViewport.getRowHeaderWidth();
+          for (var column = 1; column <= totalColumns; column++) {
+            columnsWidth += inlineStartOverlay.sumCellSizes(column - 1, column);
+            if (rootElementOffset.left + columnsWidth - windowScrollLeft >= windowWidth) {
+              // Return physical column - 1 (-2 because rangeEach gives column index + 1 - sumCellSizes requirements)
+              lastVisibleColumn = column - 2;
+              break;
+            }
+          }
+        }
+      }
+      return lastVisibleColumn;
+    }
+  }]);
+  return Scroll;
+}();
+var _default = Scroll;
+exports.default = _default;