handsontable 18.0.0 → 18.1.0-rc7

package/3rdparty/walkontable/src/axisSizing/rowUtils.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return RowUtils;
+    }
+});
+function _check_private_redeclaration(obj, privateCollection) {
+    if (privateCollection.has(obj)) {
+        throw new TypeError("Cannot initialize the same private elements twice on an object");
+    }
+}
+function _class_apply_descriptor_get(receiver, descriptor) {
+    if (descriptor.get) {
+        return descriptor.get.call(receiver);
+    }
+    return descriptor.value;
+}
+function _class_apply_descriptor_set(receiver, descriptor, value) {
+    if (descriptor.set) {
+        descriptor.set.call(receiver, value);
+    } else {
+        if (!descriptor.writable) {
+            throw new TypeError("attempted to set read only private field");
+        }
+        descriptor.value = value;
+    }
+}
+function _class_extract_field_descriptor(receiver, privateMap, action) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to " + action + " private field on non-instance");
+    }
+    return privateMap.get(receiver);
+}
+function _class_private_field_get(receiver, privateMap) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "get");
+    return _class_apply_descriptor_get(receiver, descriptor);
+}
+function _class_private_field_init(obj, privateMap, value) {
+    _check_private_redeclaration(obj, privateMap);
+    privateMap.set(obj, value);
+}
+function _class_private_field_set(receiver, privateMap, value) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "set");
+    _class_apply_descriptor_set(receiver, descriptor, value);
+    return value;
+}
+var /**
+   * The table module dependencies.
+   *
+   * @type {TableDeps}
+   */ _deps = /*#__PURE__*/ new WeakMap(), /**
+   * The row-height source — supplies the provided (non-oversized) height half.
+   *
+   * @type {RowSizeSource}
+   */ _rowSizeSource = /*#__PURE__*/ new WeakMap();
+class RowUtils {
+    /**
+   * Read-only access to the dependencies, for the renderer, which reads `rowUtils.deps` externally
+   * and so cannot reach the private `#deps`.
+   *
+   * @returns {TableDeps}
+   */ get deps() {
+        return _class_private_field_get(this, _deps);
+    }
+    /**
+   * Returns row height based on passed source index.
+   *
+   * @param {number} sourceIndex Row source index.
+   * @returns {number}
+   */ getHeight(sourceIndex) {
+        let height = _class_private_field_get(this, _rowSizeSource).getSize(sourceIndex);
+        const oversizedHeight = _class_private_field_get(this, _deps).getWtViewport().oversizedRows[sourceIndex];
+        if (oversizedHeight !== undefined) {
+            height = height === undefined ? oversizedHeight : Math.max(height, oversizedHeight);
+        }
+        return height;
+    }
+    /**
+   * Returns row height based on passed source index for the specified overlay type.
+   *
+   * @param {number} sourceIndex Row source index.
+   * @param {'inline_start'|'top'|'top_inline_start_corner'|'bottom'|'bottom_inline_start_corner'|'master'} overlayName The overlay name.
+   * @returns {number}
+   */ getHeightByOverlayName(sourceIndex, overlayName) {
+        let height = _class_private_field_get(this, _rowSizeSource).getSizeForOverlay(sourceIndex, overlayName);
+        const oversizedHeight = _class_private_field_get(this, _deps).getWtViewport().oversizedRows[sourceIndex];
+        if (oversizedHeight !== undefined) {
+            height = height === undefined ? oversizedHeight : Math.max(height, oversizedHeight);
+        }
+        return height;
+    }
+    /**
+   * @param {TableDeps} deps The table module dependencies.
+   */ constructor(deps){
+        _class_private_field_init(this, _deps, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _rowSizeSource, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_set(this, _deps, deps);
+        _class_private_field_set(this, _rowSizeSource, deps.rowSizeSource);
+        this.wtSettings = deps.wtSettings;
+    }
+}

package/3rdparty/walkontable/src/axisSizing/rowUtils.mjs

@@ -0,0 +1,106 @@
+function _check_private_redeclaration(obj, privateCollection) {
+    if (privateCollection.has(obj)) {
+        throw new TypeError("Cannot initialize the same private elements twice on an object");
+    }
+}
+function _class_apply_descriptor_get(receiver, descriptor) {
+    if (descriptor.get) {
+        return descriptor.get.call(receiver);
+    }
+    return descriptor.value;
+}
+function _class_apply_descriptor_set(receiver, descriptor, value) {
+    if (descriptor.set) {
+        descriptor.set.call(receiver, value);
+    } else {
+        if (!descriptor.writable) {
+            throw new TypeError("attempted to set read only private field");
+        }
+        descriptor.value = value;
+    }
+}
+function _class_extract_field_descriptor(receiver, privateMap, action) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to " + action + " private field on non-instance");
+    }
+    return privateMap.get(receiver);
+}
+function _class_private_field_get(receiver, privateMap) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "get");
+    return _class_apply_descriptor_get(receiver, descriptor);
+}
+function _class_private_field_init(obj, privateMap, value) {
+    _check_private_redeclaration(obj, privateMap);
+    privateMap.set(obj, value);
+}
+function _class_private_field_set(receiver, privateMap, value) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "set");
+    _class_apply_descriptor_set(receiver, descriptor, value);
+    return value;
+}
+var /**
+   * The table module dependencies.
+   *
+   * @type {TableDeps}
+   */ _deps = /*#__PURE__*/ new WeakMap(), /**
+   * The row-height source — supplies the provided (non-oversized) height half.
+   *
+   * @type {RowSizeSource}
+   */ _rowSizeSource = /*#__PURE__*/ new WeakMap();
+class RowUtils {
+    /**
+   * Read-only access to the dependencies, for the renderer, which reads `rowUtils.deps` externally
+   * and so cannot reach the private `#deps`.
+   *
+   * @returns {TableDeps}
+   */ get deps() {
+        return _class_private_field_get(this, _deps);
+    }
+    /**
+   * Returns row height based on passed source index.
+   *
+   * @param {number} sourceIndex Row source index.
+   * @returns {number}
+   */ getHeight(sourceIndex) {
+        let height = _class_private_field_get(this, _rowSizeSource).getSize(sourceIndex);
+        const oversizedHeight = _class_private_field_get(this, _deps).getWtViewport().oversizedRows[sourceIndex];
+        if (oversizedHeight !== undefined) {
+            height = height === undefined ? oversizedHeight : Math.max(height, oversizedHeight);
+        }
+        return height;
+    }
+    /**
+   * Returns row height based on passed source index for the specified overlay type.
+   *
+   * @param {number} sourceIndex Row source index.
+   * @param {'inline_start'|'top'|'top_inline_start_corner'|'bottom'|'bottom_inline_start_corner'|'master'} overlayName The overlay name.
+   * @returns {number}
+   */ getHeightByOverlayName(sourceIndex, overlayName) {
+        let height = _class_private_field_get(this, _rowSizeSource).getSizeForOverlay(sourceIndex, overlayName);
+        const oversizedHeight = _class_private_field_get(this, _deps).getWtViewport().oversizedRows[sourceIndex];
+        if (oversizedHeight !== undefined) {
+            height = height === undefined ? oversizedHeight : Math.max(height, oversizedHeight);
+        }
+        return height;
+    }
+    /**
+   * @param {TableDeps} deps The table module dependencies.
+   */ constructor(deps){
+        _class_private_field_init(this, _deps, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _rowSizeSource, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_set(this, _deps, deps);
+        _class_private_field_set(this, _rowSizeSource, deps.rowSizeSource);
+        this.wtSettings = deps.wtSettings;
+    }
+}
+/**
+ * Row utils class contains all necessary information about sizes of the rows.
+ *
+ * @class {RowUtils}
+ */ export { RowUtils as default };

package/3rdparty/walkontable/src/axisSizing/sizeGetters.d.mts

@@ -0,0 +1,2 @@
+export * from './sizeGetters.js';
+export { default } from './sizeGetters.js';

package/3rdparty/walkontable/src/axisSizing/sizeGetters.d.ts

@@ -0,0 +1,84 @@
+import type { default as Table } from '../table/baseTable';
+/**
+ * Size getters, mixed into every `Table` type.
+ */
+export interface SizeGetters {
+    getRowHeight(sourceRow: number): number;
+    getColumnHeaderHeight(level: number): number;
+    getColumnWidth(sourceColumn: number): number;
+    hasDefinedSize(): boolean;
+    getWidth(): number;
+    getHeight(): number;
+    getTotalWidth(): number;
+    getTotalHeight(): number;
+    isVisible(): boolean;
+}
+declare const sizeGetters: {
+    /**
+     * @param {number} sourceRow The physical row index.
+     * @returns {number}
+     * @this Table
+     */
+    getRowHeight(this: Table, sourceRow: number): number | undefined;
+    /**
+     * @param {number} level The column level.
+     * @returns {number}
+     * @this Table
+     */
+    getColumnHeaderHeight(this: Table, level: number): number;
+    /**
+     * @param {number} sourceColumn The physical column index.
+     * @returns {number}
+     * @this Table
+     */
+    getColumnWidth(this: Table, sourceColumn: number): number;
+    /**
+     * Checks if the table has defined size. It returns `true` when the table has width and height
+     * set bigger than `0px`.
+     *
+     * @returns {boolean}
+     * @this Table
+     */
+    hasDefinedSize(this: Table): boolean;
+    /**
+     * Gets table's width. The returned width is the width of the rendered cells that fit in the
+     * current viewport. The value may change depends on the viewport position (scroll position).
+     *
+     * @returns {number}
+     * @this Table
+     */
+    getWidth(this: Table): number;
+    /**
+     * Gets table's height. The returned height is the height of the rendered cells that fit in the
+     * current viewport. The value may change depends on the viewport position (scroll position).
+     *
+     * @returns {number}
+     * @this Table
+     */
+    getHeight(this: Table): number;
+    /**
+     * Gets table's total width. The returned width is the width of all rendered cells (including headers)
+     * that can be displayed in the table.
+     *
+     * @returns {number}
+     * @this Table
+     */
+    getTotalWidth(this: Table): number;
+    /**
+     * Gets table's total height. The returned height is the height of all rendered cells (including headers)
+     * that can be displayed in the table.
+     *
+     * @returns {number}
+     * @this Table
+     */
+    getTotalHeight(this: Table): number;
+    /**
+     * Checks if the table is visible. It returns `true` when the holder element (or its parents)
+     * has CSS 'display' property different than 'none'.
+     *
+     * @returns {boolean}
+     * @this Table
+     */
+    isVisible(this: Table): boolean;
+};
+export default sizeGetters;

package/3rdparty/walkontable/src/axisSizing/sizeGetters.js

@@ -0,0 +1,102 @@
+/**
+ * Size getters for `Table` and every subclass.
+ *
+ * These read the per-row / per-column sizes (through `RowUtils` / `ColumnUtils`) and the rendered
+ * table box (through the `GeometryReader`). They are universal — every table type (master and each
+ * overlay clone) needs them — so the mixin is applied once to the base `Table` (`mixin(Table,
+ * sizeGetters)` in `baseTable.ts`) and inherited by all subclasses. The methods run on the `Table`
+ * instance (`this`), reading its public fields (`rowUtils`/`columnUtils`/`TABLE`/`hider`/
+ * `hasTableWidth`/`hasTableHeight`) and the geometry-read port via the `deps` getter.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _element = require("../../../../helpers/dom/element");
+const sizeGetters = {
+    /**
+   * @param {number} sourceRow The physical row index.
+   * @returns {number}
+   * @this Table
+   */ getRowHeight (sourceRow) {
+        return this.rowUtils.getHeight(sourceRow);
+    },
+    /**
+   * @param {number} level The column level.
+   * @returns {number}
+   * @this Table
+   */ getColumnHeaderHeight (level) {
+        return this.columnUtils.getHeaderHeight(level);
+    },
+    /**
+   * @param {number} sourceColumn The physical column index.
+   * @returns {number}
+   * @this Table
+   */ getColumnWidth (sourceColumn) {
+        return this.columnUtils.getWidth(sourceColumn);
+    },
+    /**
+   * Checks if the table has defined size. It returns `true` when the table has width and height
+   * set bigger than `0px`.
+   *
+   * @returns {boolean}
+   * @this Table
+   */ hasDefinedSize () {
+        return this.hasTableHeight && this.hasTableWidth;
+    },
+    /**
+   * Gets table's width. The returned width is the width of the rendered cells that fit in the
+   * current viewport. The value may change depends on the viewport position (scroll position).
+   *
+   * @returns {number}
+   * @this Table
+   */ getWidth () {
+        return this.deps.geometryReader.outerWidth(this.TABLE);
+    },
+    /**
+   * Gets table's height. The returned height is the height of the rendered cells that fit in the
+   * current viewport. The value may change depends on the viewport position (scroll position).
+   *
+   * @returns {number}
+   * @this Table
+   */ getHeight () {
+        return this.deps.geometryReader.outerHeight(this.TABLE);
+    },
+    /**
+   * Gets table's total width. The returned width is the width of all rendered cells (including headers)
+   * that can be displayed in the table.
+   *
+   * @returns {number}
+   * @this Table
+   */ getTotalWidth () {
+        const width = this.deps.geometryReader.outerWidth(this.hider);
+        // when the overlay's table does not have any cells the hider returns 0, get then width from the table element
+        return width !== 0 ? width : this.getWidth();
+    },
+    /**
+   * Gets table's total height. The returned height is the height of all rendered cells (including headers)
+   * that can be displayed in the table.
+   *
+   * @returns {number}
+   * @this Table
+   */ getTotalHeight () {
+        const height = this.deps.geometryReader.outerHeight(this.hider);
+        // when the overlay's table does not have any cells the hider returns 0, get then height from the table element
+        return height !== 0 ? height : this.getHeight();
+    },
+    /**
+   * Checks if the table is visible. It returns `true` when the holder element (or its parents)
+   * has CSS 'display' property different than 'none'.
+   *
+   * @returns {boolean}
+   * @this Table
+   */ isVisible () {
+        return (0, _element.isVisible)(this.TABLE);
+    }
+};
+const _default = sizeGetters;

package/3rdparty/walkontable/src/axisSizing/sizeGetters.mjs

@@ -0,0 +1,92 @@
+/**
+ * Size getters for `Table` and every subclass.
+ *
+ * These read the per-row / per-column sizes (through `RowUtils` / `ColumnUtils`) and the rendered
+ * table box (through the `GeometryReader`). They are universal — every table type (master and each
+ * overlay clone) needs them — so the mixin is applied once to the base `Table` (`mixin(Table,
+ * sizeGetters)` in `baseTable.ts`) and inherited by all subclasses. The methods run on the `Table`
+ * instance (`this`), reading its public fields (`rowUtils`/`columnUtils`/`TABLE`/`hider`/
+ * `hasTableWidth`/`hasTableHeight`) and the geometry-read port via the `deps` getter.
+ */ import { isVisible } from '../../../../helpers/dom/element.mjs';
+const sizeGetters = {
+    /**
+   * @param {number} sourceRow The physical row index.
+   * @returns {number}
+   * @this Table
+   */ getRowHeight (sourceRow) {
+        return this.rowUtils.getHeight(sourceRow);
+    },
+    /**
+   * @param {number} level The column level.
+   * @returns {number}
+   * @this Table
+   */ getColumnHeaderHeight (level) {
+        return this.columnUtils.getHeaderHeight(level);
+    },
+    /**
+   * @param {number} sourceColumn The physical column index.
+   * @returns {number}
+   * @this Table
+   */ getColumnWidth (sourceColumn) {
+        return this.columnUtils.getWidth(sourceColumn);
+    },
+    /**
+   * Checks if the table has defined size. It returns `true` when the table has width and height
+   * set bigger than `0px`.
+   *
+   * @returns {boolean}
+   * @this Table
+   */ hasDefinedSize () {
+        return this.hasTableHeight && this.hasTableWidth;
+    },
+    /**
+   * Gets table's width. The returned width is the width of the rendered cells that fit in the
+   * current viewport. The value may change depends on the viewport position (scroll position).
+   *
+   * @returns {number}
+   * @this Table
+   */ getWidth () {
+        return this.deps.geometryReader.outerWidth(this.TABLE);
+    },
+    /**
+   * Gets table's height. The returned height is the height of the rendered cells that fit in the
+   * current viewport. The value may change depends on the viewport position (scroll position).
+   *
+   * @returns {number}
+   * @this Table
+   */ getHeight () {
+        return this.deps.geometryReader.outerHeight(this.TABLE);
+    },
+    /**
+   * Gets table's total width. The returned width is the width of all rendered cells (including headers)
+   * that can be displayed in the table.
+   *
+   * @returns {number}
+   * @this Table
+   */ getTotalWidth () {
+        const width = this.deps.geometryReader.outerWidth(this.hider);
+        // when the overlay's table does not have any cells the hider returns 0, get then width from the table element
+        return width !== 0 ? width : this.getWidth();
+    },
+    /**
+   * Gets table's total height. The returned height is the height of all rendered cells (including headers)
+   * that can be displayed in the table.
+   *
+   * @returns {number}
+   * @this Table
+   */ getTotalHeight () {
+        const height = this.deps.geometryReader.outerHeight(this.hider);
+        // when the overlay's table does not have any cells the hider returns 0, get then height from the table element
+        return height !== 0 ? height : this.getHeight();
+    },
+    /**
+   * Checks if the table is visible. It returns `true` when the holder element (or its parents)
+   * has CSS 'display' property different than 'none'.
+   *
+   * @returns {boolean}
+   * @this Table
+   */ isVisible () {
+        return isVisible(this.TABLE);
+    }
+};
+export default sizeGetters;

package/3rdparty/walkontable/src/calculator/axisCalculation.d.ts

@@ -1,4 +1,4 @@
-import type { PositionCache } from '../utils/positionCache';
+import type { PositionCache } from '../axisSizing/positionCache';
 import type { ViewportBaseCalculator } from './viewportBase';
 export interface AxisCalculatorContext extends ViewportBaseCalculator {
     needReverse: boolean;

package/3rdparty/walkontable/src/calculator/calculationType/renderedColumns.d.ts

@@ -16,6 +16,16 @@ export declare class RenderedColumnsCalculationType extends PartiallyVisibleColu
      * @type {number}
      */
     columnEndOffset: number;
+    /**
+     * The horizontal scroll offset (zero-based, in px) the band was computed at. Read on the next
+     * scroll-driven draw by `applyRenderedColumnsBandOverscan` (`viewport/calculatorFactory.ts`): the
+     * sign of the offset delta between two consecutive full draws picks the band side that receives
+     * the directional overscan. The value is clamped to zero and derived from an absolute scroll
+     * position, so the comparison works the same in LTR and RTL.
+     *
+     * @type {number}
+     */
+    scrollOffset: number;
     /**
      * Finalizes the calculation.
      *

package/3rdparty/walkontable/src/calculator/calculationType/renderedColumns.js

@@ -17,6 +17,7 @@ class RenderedColumnsCalculationType extends _partiallyVisibleColumns.PartiallyV
    */ finalize(viewportCalculator) {
         super.finalize(viewportCalculator);
         const { overrideFn, totalColumns, positionCache } = viewportCalculator;
+        this.scrollOffset = viewportCalculator.zeroBasedScrollOffset;
         if (this.startColumn !== null && typeof overrideFn === 'function') {
             const startColumn = this.startColumn;
             const endColumn = this.endColumn;
@@ -44,6 +45,14 @@ class RenderedColumnsCalculationType extends _partiallyVisibleColumns.PartiallyV
    * The property holds the offset applied in the `overrideFn` function to the `endColumn` value.
    *
    * @type {number}
-   */ this.columnEndOffset = 0;
+   */ this.columnEndOffset = 0, /**
+   * The horizontal scroll offset (zero-based, in px) the band was computed at. Read on the next
+   * scroll-driven draw by `applyRenderedColumnsBandOverscan` (`viewport/calculatorFactory.ts`): the
+   * sign of the offset delta between two consecutive full draws picks the band side that receives
+   * the directional overscan. The value is clamped to zero and derived from an absolute scroll
+   * position, so the comparison works the same in LTR and RTL.
+   *
+   * @type {number}
+   */ this.scrollOffset = 0;
     }
 }

package/3rdparty/walkontable/src/calculator/calculationType/renderedColumns.mjs

@@ -9,6 +9,7 @@ import { PartiallyVisibleColumnsCalculationType } from './partiallyVisibleColumn
    */ finalize(viewportCalculator) {
         super.finalize(viewportCalculator);
         const { overrideFn, totalColumns, positionCache } = viewportCalculator;
+        this.scrollOffset = viewportCalculator.zeroBasedScrollOffset;
         if (this.startColumn !== null && typeof overrideFn === 'function') {
             const startColumn = this.startColumn;
             const endColumn = this.endColumn;
@@ -36,6 +37,14 @@ import { PartiallyVisibleColumnsCalculationType } from './partiallyVisibleColumn
    * The property holds the offset applied in the `overrideFn` function to the `endColumn` value.
    *
    * @type {number}
-   */ this.columnEndOffset = 0;
+   */ this.columnEndOffset = 0, /**
+   * The horizontal scroll offset (zero-based, in px) the band was computed at. Read on the next
+   * scroll-driven draw by `applyRenderedColumnsBandOverscan` (`viewport/calculatorFactory.ts`): the
+   * sign of the offset delta between two consecutive full draws picks the band side that receives
+   * the directional overscan. The value is clamped to zero and derived from an absolute scroll
+   * position, so the comparison works the same in LTR and RTL.
+   *
+   * @type {number}
+   */ this.scrollOffset = 0;
     }
 }

package/3rdparty/walkontable/src/calculator/calculationType/renderedRows.d.ts

@@ -16,6 +16,15 @@ export declare class RenderedRowsCalculationType extends PartiallyVisibleRowsCal
      * @type {number}
      */
     rowEndOffset: number;
+    /**
+     * The vertical scroll offset (zero-based, in px) the band was computed at. Read on the next
+     * scroll-driven draw by `applyRenderedRowsBandOverscan` (`viewport/calculatorFactory.ts`): the sign
+     * of the offset delta between two consecutive full draws picks the band side that receives the
+     * directional overscan.
+     *
+     * @type {number}
+     */
+    scrollOffset: number;
     /**
      * Finalizes the calculation.
      *

package/3rdparty/walkontable/src/calculator/calculationType/renderedRows.js

@@ -17,6 +17,7 @@ class RenderedRowsCalculationType extends _partiallyVisibleRows.PartiallyVisible
    */ finalize(viewportCalculator) {
         super.finalize(viewportCalculator);
         const { overrideFn, totalRows, positionCache } = viewportCalculator;
+        this.scrollOffset = viewportCalculator.zeroBasedScrollOffset;
         if (this.startRow !== null && typeof overrideFn === 'function') {
             const startRow = this.startRow;
             const endRow = this.endRow;
@@ -44,6 +45,13 @@ class RenderedRowsCalculationType extends _partiallyVisibleRows.PartiallyVisible
    * The property holds the offset applied in the `overrideFn` function to the `endColumn` value.
    *
    * @type {number}
-   */ this.rowEndOffset = 0;
+   */ this.rowEndOffset = 0, /**
+   * The vertical scroll offset (zero-based, in px) the band was computed at. Read on the next
+   * scroll-driven draw by `applyRenderedRowsBandOverscan` (`viewport/calculatorFactory.ts`): the sign
+   * of the offset delta between two consecutive full draws picks the band side that receives the
+   * directional overscan.
+   *
+   * @type {number}
+   */ this.scrollOffset = 0;
     }
 }

package/3rdparty/walkontable/src/calculator/calculationType/renderedRows.mjs

@@ -9,6 +9,7 @@ import { PartiallyVisibleRowsCalculationType } from './partiallyVisibleRows.mjs'
    */ finalize(viewportCalculator) {
         super.finalize(viewportCalculator);
         const { overrideFn, totalRows, positionCache } = viewportCalculator;
+        this.scrollOffset = viewportCalculator.zeroBasedScrollOffset;
         if (this.startRow !== null && typeof overrideFn === 'function') {
             const startRow = this.startRow;
             const endRow = this.endRow;
@@ -36,6 +37,13 @@ import { PartiallyVisibleRowsCalculationType } from './partiallyVisibleRows.mjs'
    * The property holds the offset applied in the `overrideFn` function to the `endColumn` value.
    *
    * @type {number}
-   */ this.rowEndOffset = 0;
+   */ this.rowEndOffset = 0, /**
+   * The vertical scroll offset (zero-based, in px) the band was computed at. Read on the next
+   * scroll-driven draw by `applyRenderedRowsBandOverscan` (`viewport/calculatorFactory.ts`): the sign
+   * of the offset delta between two consecutive full draws picks the band side that receives the
+   * directional overscan.
+   *
+   * @type {number}
+   */ this.scrollOffset = 0;
     }
 }

package/3rdparty/walkontable/src/calculator/viewportColumns.d.ts

@@ -1,4 +1,4 @@
-import type { PositionCache } from '../utils/positionCache';
+import type { PositionCache } from '../axisSizing/positionCache';
 import type { CalculationTypeLike, ColumnsCalculationType } from './viewportBase';
 import { ViewportBaseCalculator } from './viewportBase';
 /**

package/3rdparty/walkontable/src/calculator/viewportRows.d.ts

@@ -1,4 +1,4 @@
-import type { PositionCache } from '../utils/positionCache';
+import type { PositionCache } from '../axisSizing/positionCache';
 import type { CalculationTypeLike, RowsCalculationType } from './viewportBase';
 import { ViewportBaseCalculator } from './viewportBase';
 /**

package/3rdparty/walkontable/src/cell/range.d.ts

@@ -522,4 +522,14 @@ declare class CellRange {
      */
     _createCellCoords(row: number | null, column: number | null): CellCoords;
 }
+/**
+ * Checks whether a value has the shape of a `CellRange`. Duck-typed rather than `instanceof` so it
+ * stays correct across realm boundaries (a range created in an iframe's realm), and usable as a
+ * defense for hook arguments: `Hooks.run` threads any non-`undefined` listener return value into
+ * the next listener's first argument, so an internal listener cannot trust the argument's type.
+ *
+ * @param {*} value The value to check.
+ * @returns {boolean}
+ */
+export declare function isCellRangeLike(value: unknown): value is CellRange;
 export default CellRange;