handsontable 0.0.0-next-d82e84a-20240117 → 0.0.0-next-40cdda4-20240118

package/3rdparty/walkontable/src/core/_base.js

@@ -318,12 +318,18 @@ class CoreAbstract {
       get startColumnVisible() {
         return wot.wtViewport.columnsVisibleCalculator.startColumn;
       },
+      get startColumnPartiallyVisible() {
+        return wot.wtViewport.columnsPartiallyVisibleCalculator.startColumn;
+      },
       get endColumnRendered() {
         return wot.wtViewport.columnsRenderCalculator.endColumn;
       },
       get endColumnVisible() {
         return wot.wtViewport.columnsVisibleCalculator.endColumn;
       },
+      get endColumnPartiallyVisible() {
+        return wot.wtViewport.columnsPartiallyVisibleCalculator.endColumn;
+      },
       get countColumnsRendered() {
         return wot.wtViewport.columnsRenderCalculator.count;
       },
@@ -336,12 +342,18 @@ class CoreAbstract {
       get startRowVisible() {
         return wot.wtViewport.rowsVisibleCalculator.startRow;
       },
+      get startRowPartiallyVisible() {
+        return wot.wtViewport.rowsPartiallyVisibleCalculator.startRow;
+      },
       get endRowRendered() {
         return wot.wtViewport.rowsRenderCalculator.endRow;
       },
       get endRowVisible() {
         return wot.wtViewport.rowsVisibleCalculator.endRow;
       },
+      get endRowPartiallyVisible() {
+        return wot.wtViewport.rowsPartiallyVisibleCalculator.endRow;
+      },
       get countRowsRendered() {
         return wot.wtViewport.rowsRenderCalculator.count;
       },

package/3rdparty/walkontable/src/core/_base.mjs

@@ -314,12 +314,18 @@ export default class CoreAbstract {
       get startColumnVisible() {
         return wot.wtViewport.columnsVisibleCalculator.startColumn;
       },
+      get startColumnPartiallyVisible() {
+        return wot.wtViewport.columnsPartiallyVisibleCalculator.startColumn;
+      },
       get endColumnRendered() {
         return wot.wtViewport.columnsRenderCalculator.endColumn;
       },
       get endColumnVisible() {
         return wot.wtViewport.columnsVisibleCalculator.endColumn;
       },
+      get endColumnPartiallyVisible() {
+        return wot.wtViewport.columnsPartiallyVisibleCalculator.endColumn;
+      },
       get countColumnsRendered() {
         return wot.wtViewport.columnsRenderCalculator.count;
       },
@@ -332,12 +338,18 @@ export default class CoreAbstract {
       get startRowVisible() {
         return wot.wtViewport.rowsVisibleCalculator.startRow;
       },
+      get startRowPartiallyVisible() {
+        return wot.wtViewport.rowsPartiallyVisibleCalculator.startRow;
+      },
       get endRowRendered() {
         return wot.wtViewport.rowsRenderCalculator.endRow;
       },
       get endRowVisible() {
         return wot.wtViewport.rowsVisibleCalculator.endRow;
       },
+      get endRowPartiallyVisible() {
+        return wot.wtViewport.rowsPartiallyVisibleCalculator.endRow;
+      },
       get countRowsRendered() {
         return wot.wtViewport.rowsRenderCalculator.count;
       },

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

@@ -3,40 +3,43 @@
 exports.__esModule = true;
 require("core-js/modules/es.error.cause.js");
 var _element = require("../../../helpers/dom/element");
+function _classPrivateMethodInitSpec(obj, privateSet) { _checkPrivateRedeclaration(obj, privateSet); privateSet.add(obj); }
+function _checkPrivateRedeclaration(obj, privateCollection) { if (privateCollection.has(obj)) { throw new TypeError("Cannot initialize the same private elements twice on an object"); } }
 function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : String(i); }
 function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _classPrivateMethodGet(receiver, privateSet, fn) { if (!privateSet.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return fn; }
 /**
  * @class Scroll
  */
+var _getLastColumnIndex = /*#__PURE__*/new WeakSet();
+var _getLastRowIndex = /*#__PURE__*/new WeakSet();
 class Scroll {
   /**
    * @param {ScrollDao} dataAccessObject Tha data access object.
    */
   constructor(dataAccessObject) {
     /**
-     * The data access object.
+     * Get last visible row based on virtual dom and how table is visible in browser window viewport.
      *
-     * @protected
-     * @type {ScrollDao}
+     * @param {number} lastRowIndex The last visible row index.
+     * @returns {number}
      */
-    _defineProperty(this, "dataAccessObject", void 0);
+    _classPrivateMethodInitSpec(this, _getLastRowIndex);
     /**
-     * Holds the last column reached by the scroll, which determines the scroll snapping direction
-     * (left or right) for a next horizontal scroll.
+     * Get last visible column based on virtual dom and how table is visible in browser window viewport.
      *
-     * @protected
-     * @type {number}
+     * @param {number} lastColumnIndex The last visible column index.
+     * @returns {number}
      */
-    _defineProperty(this, "lastScrolledColumnPos", -1);
+    _classPrivateMethodInitSpec(this, _getLastColumnIndex);
     /**
-     * Holds the last row reached by the scroll, which determines the scroll snapping direction
-     * (top or bottom) for a next vertical scroll.
+     * The data access object.
      *
      * @protected
-     * @type {number}
+     * @type {ScrollDao}
      */
-    _defineProperty(this, "lastScrolledRowPos", -1);
+    _defineProperty(this, "dataAccessObject", void 0);
     this.dataAccessObject = dataAccessObject;
   }
 
@@ -74,8 +77,6 @@ class Scroll {
     if (!drawn || !Number.isInteger(column) || column < 0 || column > totalColumns) {
       return false;
     }
-    const firstVisibleColumn = this.getFirstVisibleColumn();
-    const lastVisibleColumn = this.getLastVisibleColumn();
     const autoSnapping = snapToRight === undefined && snapToLeft === undefined;
     const {
       fixedColumnsStart,
@@ -87,20 +88,14 @@ class Scroll {
     if (autoSnapping && column < fixedColumnsStart) {
       return false;
     }
-    let result = false;
     column = this.dataAccessObject.wtSettings.getSetting('onBeforeViewportScrollHorizontally', column);
-
-    // 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) {
+    const firstColumn = this.getFirstVisibleColumn();
+    const lastColumn = this.getLastVisibleColumn();
+    let result = false;
+    if (autoSnapping && (column < firstColumn || column > lastColumn) || !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;
+      result = inlineStartOverlay.scrollTo(column, autoSnapping ? column >= this.getLastPartiallyVisibleColumn() : snapToRight);
     }
     return result;
   }
@@ -123,8 +118,6 @@ class Scroll {
     if (!drawn || !Number.isInteger(row) || row < 0 || row > totalRows) {
       return false;
     }
-    const firstVisibleRow = this.getFirstVisibleRow();
-    const lastVisibleRow = this.getLastVisibleRow();
     const autoSnapping = snapToTop === undefined && snapToBottom === undefined;
     const {
       fixedRowsBottom,
@@ -137,20 +130,14 @@ class Scroll {
     if (autoSnapping && (row < fixedRowsTop || row > totalRows - fixedRowsBottom - 1)) {
       return false;
     }
-    let result = false;
     row = this.dataAccessObject.wtSettings.getSetting('onBeforeViewportScrollVertically', row);
-
-    // 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) {
+    const firstRow = this.getFirstVisibleRow();
+    const lastRow = this.getLastVisibleRow();
+    let result = false;
+    if (autoSnapping && (row < firstRow || row > lastRow) || !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;
+      result = topOverlay.scrollTo(row, autoSnapping ? row >= this.getLastPartiallyVisibleRow() : snapToBottom);
     }
     return result;
   }
@@ -170,33 +157,25 @@ class Scroll {
    * @returns {number}
    */
   getLastVisibleRow() {
-    const {
-      topOverlay,
-      wtTable,
-      wtViewport,
-      totalRows,
-      rootWindow
-    } = this.dataAccessObject;
-    let lastVisibleRow = wtTable.getLastVisibleRow();
-    if (topOverlay.mainTableScrollableElement === rootWindow) {
-      const rootElementOffset = (0, _element.offset)(wtTable.wtRootElement);
-      const windowScrollTop = (0, _element.getScrollTop)(rootWindow, rootWindow);
+    return _classPrivateMethodGet(this, _getLastRowIndex, _getLastRowIndex2).call(this, this.dataAccessObject.wtTable.getLastVisibleRow());
+  }
 
-      // Only calculate lastVisibleRow when table didn't filled (from bottom) whole viewport space
-      if (rootElementOffset.top > windowScrollTop) {
-        const windowHeight = (0, _element.innerHeight)(rootWindow);
-        let rowsHeight = wtViewport.getColumnHeaderHeight();
-        for (let 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 partially visible row based on virtual dom and how table is visible in browser window viewport.
+   *
+   * @returns {number}
+   */
+  getFirstPartiallyVisibleRow() {
+    return this.dataAccessObject.wtTable.getFirstPartiallyVisibleRow();
+  }
+
+  /**
+   * Get last visible row based on virtual dom and how table is visible in browser window viewport.
+   *
+   * @returns {number}
+   */
+  getLastPartiallyVisibleRow() {
+    return _classPrivateMethodGet(this, _getLastRowIndex, _getLastRowIndex2).call(this, this.dataAccessObject.wtTable.getLastPartiallyVisibleRow());
   }
 
   /**
@@ -214,44 +193,92 @@ class Scroll {
    * @returns {number}
    */
   getLastVisibleColumn() {
-    const {
-      wtSettings,
-      inlineStartOverlay,
-      wtTable,
-      wtViewport,
-      totalColumns,
-      rootWindow
-    } = this.dataAccessObject;
-    let lastVisibleColumn = wtTable.getLastVisibleColumn();
-    if (inlineStartOverlay.mainTableScrollableElement === rootWindow) {
-      const isRtl = wtSettings.getSetting('rtlMode');
-      let inlineStartRootElementOffset = null;
-      if (isRtl) {
-        const tableRect = wtTable.TABLE.getBoundingClientRect();
-        const rootDocument = this.dataAccessObject.rootWindow.document;
-        const docOffsetWidth = rootDocument.documentElement.offsetWidth;
-        inlineStartRootElementOffset = Math.abs(tableRect.right - docOffsetWidth);
-      } else {
-        const rootElementOffset = (0, _element.offset)(wtTable.wtRootElement);
-        inlineStartRootElementOffset = rootElementOffset.left;
+    return _classPrivateMethodGet(this, _getLastColumnIndex, _getLastColumnIndex2).call(this, this.dataAccessObject.wtTable.getLastVisibleColumn());
+  }
+
+  /**
+   * Get first partially visible column based on virtual dom and how table is visible in browser window viewport.
+   *
+   * @returns {number}
+   */
+  getFirstPartiallyVisibleColumn() {
+    return this.dataAccessObject.wtTable.getFirstPartiallyVisibleColumn();
+  }
+
+  /**
+   * Get last partially visible column based on virtual dom and how table is visible in browser window viewport.
+   *
+   * @returns {number}
+   */
+  getLastPartiallyVisibleColumn() {
+    return _classPrivateMethodGet(this, _getLastColumnIndex, _getLastColumnIndex2).call(this, this.dataAccessObject.wtTable.getLastPartiallyVisibleColumn());
+  }
+}
+function _getLastColumnIndex2(lastColumnIndex) {
+  const {
+    wtSettings,
+    inlineStartOverlay,
+    wtTable,
+    wtViewport,
+    totalColumns,
+    rootWindow
+  } = this.dataAccessObject;
+  if (inlineStartOverlay.mainTableScrollableElement === rootWindow) {
+    const isRtl = wtSettings.getSetting('rtlMode');
+    let inlineStartRootElementOffset = null;
+    if (isRtl) {
+      const tableRect = wtTable.TABLE.getBoundingClientRect();
+      const rootDocument = this.dataAccessObject.rootWindow.document;
+      const docOffsetWidth = rootDocument.documentElement.offsetWidth;
+      inlineStartRootElementOffset = Math.abs(tableRect.right - docOffsetWidth);
+    } else {
+      const rootElementOffset = (0, _element.offset)(wtTable.wtRootElement);
+      inlineStartRootElementOffset = rootElementOffset.left;
+    }
+    const windowScrollLeft = Math.abs((0, _element.getScrollLeft)(rootWindow, rootWindow));
+
+    // Only calculate lastColumnIndex when table didn't filled (from right) whole viewport space
+    if (inlineStartRootElementOffset > windowScrollLeft) {
+      const windowWidth = (0, _element.innerWidth)(rootWindow);
+      let columnsWidth = wtViewport.getRowHeaderWidth();
+      for (let column = 1; column <= totalColumns; column++) {
+        columnsWidth += inlineStartOverlay.sumCellSizes(column - 1, column);
+        if (inlineStartRootElementOffset + columnsWidth - windowScrollLeft >= windowWidth) {
+          // Return physical column - 1 (-2 because rangeEach gives column index + 1 - sumCellSizes requirements)
+          lastColumnIndex = column - 2;
+          break;
+        }
       }
-      const windowScrollLeft = Math.abs((0, _element.getScrollLeft)(rootWindow, rootWindow));
+    }
+  }
+  return lastColumnIndex;
+}
+function _getLastRowIndex2(lastRowIndex) {
+  const {
+    topOverlay,
+    wtTable,
+    wtViewport,
+    totalRows,
+    rootWindow
+  } = this.dataAccessObject;
+  if (topOverlay.mainTableScrollableElement === rootWindow) {
+    const rootElementOffset = (0, _element.offset)(wtTable.wtRootElement);
+    const windowScrollTop = (0, _element.getScrollTop)(rootWindow, rootWindow);
 
-      // Only calculate lastVisibleColumn when table didn't filled (from right) whole viewport space
-      if (inlineStartRootElementOffset > windowScrollLeft) {
-        const windowWidth = (0, _element.innerWidth)(rootWindow);
-        let columnsWidth = wtViewport.getRowHeaderWidth();
-        for (let column = 1; column <= totalColumns; column++) {
-          columnsWidth += inlineStartOverlay.sumCellSizes(column - 1, column);
-          if (inlineStartRootElementOffset + columnsWidth - windowScrollLeft >= windowWidth) {
-            // Return physical column - 1 (-2 because rangeEach gives column index + 1 - sumCellSizes requirements)
-            lastVisibleColumn = column - 2;
-            break;
-          }
+    // Only calculate lastRowIndex when table didn't filled (from bottom) whole viewport space
+    if (rootElementOffset.top > windowScrollTop) {
+      const windowHeight = (0, _element.innerHeight)(rootWindow);
+      let rowsHeight = wtViewport.getColumnHeaderHeight();
+      for (let 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)
+          lastRowIndex = row - 2;
+          break;
         }
       }
     }
-    return lastVisibleColumn;
   }
+  return lastRowIndex;
 }
 var _default = exports.default = Scroll;