handsontable 18.0.0 → 18.1.0-rc1

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

@@ -1,9 +1,30 @@
-import { addClass, getScrollbarWidth, getScrollLeft, getMaximumScrollLeft, hasClass, outerWidth, removeClass, setOverlayPosition, resetCssTransform } from '../../../../helpers/dom/element.mjs';
-import InlineStartOverlayTable from '../table/inlineStart.mjs';
+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_private_method_get(receiver, privateSet, fn) {
+    if (!privateSet.has(receiver)) throw new TypeError("attempted to get private field on non-instance");
+    return fn;
+}
+function _class_private_method_init(obj, privateSet) {
+    _check_private_redeclaration(obj, privateSet);
+    privateSet.add(obj);
+}
+import { addClass, getScrollLeft, hasClass, removeClass, setOverlayPosition, resetCssTransform } from '../../../../../helpers/dom/element.mjs';
+import InlineStartOverlayTable from '../../table/regions/inlineStartTable.mjs';
 import { Overlay } from './_base.mjs';
-import { getCornerStyle } from '../selection/index.mjs';
-import { CLONE_INLINE_START } from './constants.mjs';
-import { throwWithCause } from '../../../../helpers/errors.mjs';
+import { getCornerStyle } from '../../selection/index.mjs';
+import { CLONE_INLINE_START } from '../constants.mjs';
+import { throwWithCause } from '../../../../../helpers/errors.mjs';
+var /**
+   * Computes the inline-start overlay's header-border state without mutating the DOM. Pure: reads
+   * settings and the current class state only. Splitting the decision from the write lets the
+   * single-pass draw resolve the `innerBorderInlineStart` toggle before rendering, instead of after.
+   *
+   * @param {number} position The overlay offset that decides whether the inline-start border is shown.
+   * @returns {{ hasEmptyRows: boolean, innerBorder: string, positionChanged: boolean }}
+   */ _computeHeaderBordersState = /*#__PURE__*/ new WeakSet();
 /**
  * @class InlineStartOverlay
  */ export class InlineStartOverlay extends Overlay {
@@ -13,8 +34,8 @@ import { throwWithCause } from '../../../../helpers/errors.mjs';
    * @see Table#constructor
    * @param {...*} args Parameters that will be forwarded to the `Table` constructor.
    * @returns {InlineStartOverlayTable}
-   */ createTable(...args) {
-        return new InlineStartOverlayTable(...args);
+   */ createTable(deps) {
+        return new InlineStartOverlayTable(deps);
     }
     /**
    * Checks if overlay should be fully rendered.
@@ -28,7 +49,7 @@ import { throwWithCause } from '../../../../helpers/errors.mjs';
    *
    * @returns {boolean}
    */ resetFixedPosition() {
-        const { wtTable } = this.wot;
+        const wtTable = this.deps.getWtTable();
         if (!this.needFullRender || !this.shouldBeRendered() || !wtTable.holder.parentNode) {
             // removed from DOM
             return false;
@@ -36,7 +57,7 @@ import { throwWithCause } from '../../../../helpers/errors.mjs';
         if (!this.clone) {
             return false;
         }
-        const { rootWindow } = this.domBindings;
+        const { rootWindow } = this.deps;
         const overlayRoot = this.clone.wtTable.holder.parentNode;
         const preventOverflow = this.wtSettings.getSetting('preventOverflow');
         let overlayPosition = 0;
@@ -57,7 +78,7 @@ import { throwWithCause } from '../../../../helpers/errors.mjs';
    * @param {number} pos The scroll position.
    * @returns {boolean}
    */ setScrollPosition(pos) {
-        const { rootWindow } = this.domBindings;
+        const { rootWindow } = this.deps;
         const scrollableElement = this.mainTableScrollableElement;
         const scrollEl = scrollableElement;
         const getScrollPosition = ()=>{
@@ -87,7 +108,11 @@ import { throwWithCause } from '../../../../helpers/errors.mjs';
         this.wtSettings.getSetting('onScrollVertically');
     }
     /**
-   * Calculates total sum cells width.
+   * Calculates total sum cells width. Walks the columns live instead of reading the column-width
+   * prefix-sum cache: stretched widths (`stretchH`) are derived from the workspace width, which in
+   * turn depends on this sum — the live read resolves that cycle fresh on every call, while a
+   * cached read would freeze pre-stretch widths (nothing invalidates the cache when stretching
+   * recomputes). Column counts stay far below row counts, so this walk is not a scroll hotspot.
    *
    * @param {number} from Column index which calculates started from.
    * @param {number} to Column index where calculation is finished.
@@ -97,7 +122,7 @@ import { throwWithCause } from '../../../../helpers/errors.mjs';
         let column = from;
         let sum = 0;
         while(column < to){
-            sum += this.wot.wtTable.getColumnWidth(column) || defaultColumnWidth;
+            sum += this.deps.getWtTable().getColumnWidth(column) || defaultColumnWidth;
             column += 1;
         }
         return sum;
@@ -117,8 +142,9 @@ import { throwWithCause } from '../../../../helpers/errors.mjs';
         if (!this.clone) {
             return;
         }
-        const { wtTable, wtViewport } = this.wot;
-        const { rootDocument, rootWindow } = this.domBindings;
+        const wtTable = this.deps.getWtTable();
+        const wtViewport = this.deps.getWtViewport();
+        const { rootDocument, rootWindow } = this.deps;
         const overlayRoot = this.clone.wtTable.holder.parentNode;
         const overlayRootStyle = overlayRoot.style;
         const preventOverflow = this.wtSettings.getSetting('preventOverflow');
@@ -131,16 +157,16 @@ import { throwWithCause } from '../../../../helpers/errors.mjs';
                 // from the real scrollbar size, giving the frozen overlay a different vertical scroll range
                 // than the master. That mismatch clamps the overlay's scrollTop ~1px short at the bottom and
                 // shifts the frozen rows out of alignment (#12632).
-                const masterClientHeight = wtTable.holder.clientHeight;
-                height = masterClientHeight > 0 ? masterClientHeight : height - getScrollbarWidth(rootDocument);
+                const masterClientHeight = this.deps.geometryReader.clientHeight(wtTable.holder);
+                height = masterClientHeight > 0 ? masterClientHeight : height - this.deps.geometryReader.getScrollbarWidth(rootDocument);
             }
-            height = Math.min(height, wtTable.wtRootElement.scrollHeight);
+            height = Math.min(height, this.deps.geometryReader.scrollHeight(wtTable.wtRootElement));
             overlayRootStyle.height = `${height}px`;
         } else {
             overlayRootStyle.height = '';
         }
         this.clone.wtTable.holder.style.height = overlayRootStyle.height;
-        const tableWidth = outerWidth(this.clone.wtTable.TABLE);
+        const tableWidth = this.deps.geometryReader.outerWidth(this.clone.wtTable.TABLE);
         overlayRootStyle.width = `${tableWidth}px`;
     }
     /**
@@ -151,7 +177,7 @@ import { throwWithCause } from '../../../../helpers/errors.mjs';
         }
         const { holder } = this.clone.wtTable;
         const cornerStyle = getCornerStyle(this.wot);
-        const selectionCornerOffset = this.wot.selectionManager.getFocusSelection() ? parseInt(cornerStyle.width, 10) / 2 : 0;
+        const selectionCornerOffset = this.deps.getSelectionManager().getFocusSelection() ? parseInt(cornerStyle.width, 10) / 2 : 0;
         this.clone.wtTable.hider.style.height = this.hider.style.height;
         const holderParent = holder.parentNode;
         holder.style.height = holderParent.style.height;
@@ -164,9 +190,12 @@ import { throwWithCause } from '../../../../helpers/errors.mjs';
    */ applyToDOM() {
         const total = this.wtSettings.getSetting('totalColumns');
         const styleProperty = this.isRtl() ? 'right' : 'left';
-        if (typeof this.wot.wtViewport.columnsRenderCalculator?.startPosition === 'number') {
-            this.spreader.style[styleProperty] = `${this.wot.wtViewport.columnsRenderCalculator.startPosition}px`;
-        } else if (total === 0) {
+        const columnsRenderCalculator = this.deps.getWtViewport().columnsRenderCalculator;
+        if (typeof columnsRenderCalculator?.startPosition === 'number') {
+            this.spreader.style[styleProperty] = `${columnsRenderCalculator.startPosition}px`;
+        } else if (total === 0 || columnsRenderCalculator === null) {
+            // 0 columns, or nothing rendered yet — a `null` calculator is the drawn-but-never-rendered state
+            // a skipped first draw leaves behind (see `restoreRenderedStateIfSafe` in `table/drawCycle.ts`).
             this.spreader.style[styleProperty] = '0';
         } else {
             throwWithCause('Incorrect value of the columnsRenderCalculator');
@@ -186,8 +215,9 @@ import { throwWithCause } from '../../../../helpers/errors.mjs';
         if (!this.clone) {
             return;
         }
-        if (typeof this.wot.wtViewport.rowsRenderCalculator?.startPosition === 'number') {
-            this.clone.wtTable.spreader.style.top = `${this.wot.wtViewport.rowsRenderCalculator.startPosition}px`;
+        const rowsRenderCalculator = this.deps.getWtViewport().rowsRenderCalculator;
+        if (typeof rowsRenderCalculator?.startPosition === 'number') {
+            this.clone.wtTable.spreader.style.top = `${rowsRenderCalculator.startPosition}px`;
         } else {
             this.clone.wtTable.spreader.style.top = '';
         }
@@ -201,6 +231,7 @@ import { throwWithCause } from '../../../../helpers/errors.mjs';
    * @returns {boolean}
    */ scrollTo(sourceCol, beyondRendered) {
         const { wtSettings } = this;
+        const { geometryReader } = this.deps;
         const rowHeaders = wtSettings.getSetting('rowHeaders');
         const fixedColumnsStart = wtSettings.getSetting('fixedColumnsStart');
         const sourceInstance = this.wot.cloneSource ? this.wot.cloneSource : this.wot;
@@ -209,18 +240,18 @@ import { throwWithCause } from '../../../../helpers/errors.mjs';
         let newX = this.getTableParentOffset();
         let scrollbarCompensation = 0;
         if (beyondRendered) {
-            const columnWidth = this.wot.wtTable.getColumnWidth(sourceCol);
-            const viewportWidth = this.wot.wtViewport.getViewportWidth();
+            const columnWidth = this.deps.getWtTable().getColumnWidth(sourceCol);
+            const viewportWidth = this.deps.getWtViewport().getViewportWidth();
             if (columnWidth > viewportWidth) {
                 beyondRendered = false;
             }
         }
-        if (beyondRendered && mainHolder.offsetWidth !== mainHolder.clientWidth) {
-            scrollbarCompensation = getScrollbarWidth(this.domBindings.rootDocument);
+        if (beyondRendered && geometryReader.offsetWidth(mainHolder) !== geometryReader.clientWidth(mainHolder)) {
+            scrollbarCompensation = geometryReader.getScrollbarWidth(this.deps.rootDocument);
         }
         if (beyondRendered) {
             newX += this.sumCellSizes(0, sourceCol + 1);
-            newX -= this.wot.wtViewport.getViewportWidth();
+            newX -= this.deps.getWtViewport().getViewportWidth();
             // Compensate for the right header border if scrolled from the absolute left.
             newX += rowHeaderBorderCompensation;
         } else {
@@ -229,8 +260,8 @@ import { throwWithCause } from '../../../../helpers/errors.mjs';
         newX += scrollbarCompensation;
         // If the table is scrolled all the way left when starting the scroll and going to be scrolled to the far right,
         // we need to compensate for the potential header border width.
-        if (getMaximumScrollLeft(this.mainTableScrollableElement) === newX - rowHeaderBorderCompensation && rowHeaderBorderCompensation > 0) {
-            this.wot.wtOverlays.expandHiderHorizontallyBy(rowHeaderBorderCompensation);
+        if (geometryReader.getMaximumScrollLeft(this.mainTableScrollableElement) === newX - rowHeaderBorderCompensation && rowHeaderBorderCompensation > 0) {
+            this.deps.getWtOverlays().expandHiderHorizontallyBy(rowHeaderBorderCompensation);
         }
         return this.setScrollPosition(newX);
     }
@@ -241,8 +272,8 @@ import { throwWithCause } from '../../../../helpers/errors.mjs';
    */ getTableParentOffset() {
         const preventOverflow = this.wtSettings.getSetting('preventOverflow');
         let offset = 0;
-        if (!preventOverflow && this.trimmingContainer === this.domBindings.rootWindow) {
-            offset = this.wot.wtTable.holderOffset.left;
+        if (!preventOverflow && this.trimmingContainer === this.deps.rootWindow) {
+            offset = this.deps.getWtTable().holderOffset.left;
         }
         return offset;
     }
@@ -251,14 +282,14 @@ import { throwWithCause } from '../../../../helpers/errors.mjs';
    *
    * @returns {number} Main table's horizontal scroll position.
    */ getScrollPosition() {
-        return Math.abs(getScrollLeft(this.mainTableScrollableElement, this.domBindings.rootWindow));
+        return Math.abs(getScrollLeft(this.mainTableScrollableElement, this.deps.rootWindow));
     }
     /**
    * Gets the main overlay's horizontal overlay offset.
    *
    * @returns {number} Main table's horizontal overlay offset.
    */ getOverlayOffset() {
-        const { rootWindow } = this.domBindings;
+        const { rootWindow } = this.deps;
         const preventOverflow = this.wtSettings.getSetting('preventOverflow');
         let overlayOffset = 0;
         if (this.trimmingContainer === rootWindow && (!preventOverflow || preventOverflow !== 'horizontal')) {
@@ -267,7 +298,7 @@ import { throwWithCause } from '../../../../helpers/errors.mjs';
             } else {
                 overlayOffset = Math.max(this.getScrollPosition() - this.getTableParentOffset(), 0);
             }
-            const rootWidth = this.wot.wtTable.getTotalWidth();
+            const rootWidth = this.deps.getWtTable().getTotalWidth();
             const overlayRootWidth = this.clone ? this.clone.wtTable.getTotalWidth() : 0;
             const maxOffset = rootWidth - overlayRootWidth;
             if (overlayOffset > maxOffset) {
@@ -277,46 +308,68 @@ import { throwWithCause } from '../../../../helpers/errors.mjs';
         return overlayOffset;
     }
     /**
+   * Pre-applies the `innerBorderInlineStart` class before the cell render (single-pass gated
+   * path), so the post-render `resetFixedPosition` toggle is a no-op and the nested re-draw is
+   * skipped. Element mode only — see `TopOverlay#prepareHeaderBorders`.
+   */ prepareHeaderBorders() {
+        if (!this.needFullRender || !this.shouldBeRendered() || !this.deps.getWtTable().holder.parentNode || !this.clone || this.trimmingContainer === this.deps.rootWindow) {
+            return;
+        }
+        this.adjustHeaderBordersPosition(this.getScrollPosition());
+    }
+    /**
    * Adds css classes to hide the header border's header (cell-selection border hiding issue).
    *
    * @param {number} position Header X position if trimming container is window or scroll top if not.
    * @returns {boolean}
    */ adjustHeaderBordersPosition(position) {
-        const { wtSettings } = this;
-        const masterParent = this.wot.wtTable.holder.parentNode;
-        const rowHeaders = wtSettings.getSetting('rowHeaders');
-        const fixedColumnsStart = wtSettings.getSetting('fixedColumnsStart');
-        const totalRows = wtSettings.getSetting('totalRows');
-        const preventVerticalOverflow = wtSettings.getSetting('preventOverflow') === 'vertical';
-        if (totalRows) {
-            removeClass(masterParent, 'emptyRows');
-        } else {
+        const masterParent = this.deps.getWtTable().holder.parentNode;
+        const state = _class_private_method_get(this, _computeHeaderBordersState, computeHeaderBordersState).call(this, position);
+        if (state.hasEmptyRows) {
             addClass(masterParent, 'emptyRows');
+        } else {
+            removeClass(masterParent, 'emptyRows');
         }
-        let positionChanged = false;
-        if (!preventVerticalOverflow) {
-            if (fixedColumnsStart && !rowHeaders.length) {
-                // "innerBorderLeft" is for backward compatibility
-                addClass(masterParent, 'innerBorderLeft innerBorderInlineStart');
-            } else if (!fixedColumnsStart && rowHeaders.length) {
-                const previousState = hasClass(masterParent, 'innerBorderInlineStart');
-                if (position) {
-                    addClass(masterParent, 'innerBorderLeft innerBorderInlineStart');
-                    positionChanged = !previousState;
-                } else {
-                    removeClass(masterParent, 'innerBorderLeft innerBorderInlineStart');
-                    positionChanged = previousState;
-                }
-            }
+        // "innerBorderLeft" is for backward compatibility.
+        if (state.innerBorder === 'add') {
+            addClass(masterParent, 'innerBorderLeft innerBorderInlineStart');
+        } else if (state.innerBorder === 'remove') {
+            removeClass(masterParent, 'innerBorderLeft innerBorderInlineStart');
         }
-        return positionChanged;
+        return state.positionChanged;
     }
     /**
-   * @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.
-   */ constructor(wotInstance, facadeGetter, wtSettings, domBindings){
-        super(wotInstance, facadeGetter, CLONE_INLINE_START, wtSettings, domBindings);
+   */ constructor(deps){
+        super(deps, CLONE_INLINE_START), _class_private_method_init(this, _computeHeaderBordersState);
+    }
+}
+function computeHeaderBordersState(position) {
+    const { wtSettings } = this;
+    const masterParent = this.deps.getWtTable().holder.parentNode;
+    const rowHeaders = wtSettings.getSetting('rowHeaders');
+    const fixedColumnsStart = wtSettings.getSetting('fixedColumnsStart');
+    const totalRows = wtSettings.getSetting('totalRows');
+    const preventVerticalOverflow = wtSettings.getSetting('preventOverflow') === 'vertical';
+    const hasEmptyRows = !totalRows;
+    let innerBorder = 'keep';
+    let positionChanged = false;
+    if (!preventVerticalOverflow) {
+        if (fixedColumnsStart && !rowHeaders.length) {
+            innerBorder = 'add';
+        } else if (!fixedColumnsStart && rowHeaders.length) {
+            const previousState = hasClass(masterParent, 'innerBorderInlineStart');
+            if (position) {
+                innerBorder = 'add';
+                positionChanged = !previousState;
+            } else {
+                innerBorder = 'remove';
+                positionChanged = previousState;
+            }
+        }
     }
+    return {
+        hasEmptyRows,
+        innerBorder,
+        positionChanged
+    };
 }

package/3rdparty/walkontable/src/overlay/regions/topInlineStartCornerOverlay.d.mts

@@ -0,0 +1 @@
+export * from './topInlineStartCornerOverlay.js';

package/3rdparty/walkontable/src/overlay/{topInlineStartCorner.d.ts → regions/topInlineStartCornerOverlay.d.ts}

@@ -1,7 +1,6 @@
-import type { DataAccessObject, DomBindings, WalkontableInstance } from '../types';
-import type Settings from '../settings';
-import TopInlineStartCornerOverlayTable from '../table/topInlineStartCorner';
-import { Overlay } from './_base';
+import type { TableDeps } from '../../table/baseTable';
+import TopInlineStartCornerOverlayTable from '../../table/regions/topInlineStartCornerTable';
+import { Overlay, type OverlayDeps } from './_base';
 /**
  * @class TopInlineStartCornerOverlay
  */
@@ -19,14 +18,10 @@ export declare class TopInlineStartCornerOverlay extends Overlay {
      */
     inlineStartOverlay: Overlay;
     /**
-     * @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.
      * @param {TopOverlay} topOverlay The instance of the Top overlay.
      * @param {InlineStartOverlay} inlineStartOverlay The instance of the InlineStart overlay.
      */
-    constructor(wotInstance: WalkontableInstance, facadeGetter: Function, wtSettings: Settings, domBindings: DomBindings, topOverlay: Overlay, inlineStartOverlay: Overlay);
+    constructor(deps: OverlayDeps, topOverlay: Overlay, inlineStartOverlay: Overlay);
     /**
      * Factory method to create a subclass of `Table` that is relevant to this overlay.
      *
@@ -34,7 +29,7 @@ export declare class TopInlineStartCornerOverlay extends Overlay {
      * @param {...*} args Parameters that will be forwarded to the `Table` constructor.
      * @returns {TopInlineStartCornerOverlayTable}
      */
-    createTable(...args: [DataAccessObject, Function, DomBindings, Settings]): TopInlineStartCornerOverlayTable;
+    createTable(deps: TableDeps): TopInlineStartCornerOverlayTable;
     /**
      * Checks if overlay should be fully rendered.
      *

package/3rdparty/walkontable/src/overlay/{topInlineStartCorner.js → regions/topInlineStartCornerOverlay.js}

@@ -8,10 +8,10 @@ Object.defineProperty(exports, "TopInlineStartCornerOverlay", {
         return TopInlineStartCornerOverlay;
     }
 });
-const _element = require("../../../../helpers/dom/element");
-const _topInlineStartCorner = /*#__PURE__*/ _interop_require_default(require("../table/topInlineStartCorner"));
+const _element = require("../../../../../helpers/dom/element");
+const _topInlineStartCornerTable = /*#__PURE__*/ _interop_require_default(require("../../table/regions/topInlineStartCornerTable"));
 const _base = require("./_base");
-const _constants = require("./constants");
+const _constants = require("../constants");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -24,8 +24,8 @@ class TopInlineStartCornerOverlay extends _base.Overlay {
    * @see Table#constructor
    * @param {...*} args Parameters that will be forwarded to the `Table` constructor.
    * @returns {TopInlineStartCornerOverlayTable}
-   */ createTable(...args) {
-        return new _topInlineStartCorner.default(...args);
+   */ createTable(deps) {
+        return new _topInlineStartCornerTable.default(deps);
     }
     /**
    * Checks if overlay should be fully rendered.
@@ -90,21 +90,22 @@ class TopInlineStartCornerOverlay extends _base.Overlay {
    * @returns {boolean}
    */ resetFixedPosition() {
         this.updateTrimmingContainer();
-        if (!this.wot.wtTable.holder.parentNode || !this.clone) {
+        if (!this.deps.getWtTable().holder.parentNode || !this.clone) {
             // removed from DOM
             return false;
         }
         const overlayRoot = this.clone.wtTable.holder.parentNode;
-        if (this.trimmingContainer === this.domBindings.rootWindow) {
+        if (this.trimmingContainer === this.deps.rootWindow) {
             const left = this.inlineStartOverlay.getOverlayOffset() * (this.isRtl() ? -1 : 1);
             const top = this.topOverlay.getOverlayOffset();
             (0, _element.setOverlayPosition)(overlayRoot, `${left}px`, `${top}px`);
         } else {
             (0, _element.resetCssTransform)(overlayRoot);
         }
-        let tableHeight = (0, _element.outerHeight)(this.clone.wtTable.TABLE);
-        const tableWidth = (0, _element.outerWidth)(this.clone.wtTable.TABLE);
-        if (!this.wot.wtTable.hasDefinedSize()) {
+        const { geometryReader } = this.deps;
+        let tableHeight = geometryReader.outerHeight(this.clone.wtTable.TABLE);
+        const tableWidth = geometryReader.outerWidth(this.clone.wtTable.TABLE);
+        if (!this.deps.getWtTable().hasDefinedSize()) {
             tableHeight = 0;
         }
         overlayRoot.style.height = `${tableHeight}px`;
@@ -112,14 +113,10 @@ class TopInlineStartCornerOverlay extends _base.Overlay {
         return true;
     }
     /**
-   * @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.
    * @param {TopOverlay} topOverlay The instance of the Top overlay.
    * @param {InlineStartOverlay} inlineStartOverlay The instance of the InlineStart overlay.
-   */ constructor(wotInstance, facadeGetter, wtSettings, domBindings, topOverlay, inlineStartOverlay){
-        super(wotInstance, facadeGetter, _constants.CLONE_TOP_INLINE_START_CORNER, wtSettings, domBindings);
+   */ constructor(deps, topOverlay, inlineStartOverlay){
+        super(deps, _constants.CLONE_TOP_INLINE_START_CORNER);
         this.topOverlay = topOverlay;
         this.inlineStartOverlay = inlineStartOverlay;
     }

package/3rdparty/walkontable/src/overlay/{topInlineStartCorner.mjs → regions/topInlineStartCornerOverlay.mjs}

@@ -1,7 +1,7 @@
-import { outerHeight, outerWidth, setOverlayPosition, resetCssTransform } from '../../../../helpers/dom/element.mjs';
-import TopInlineStartCornerOverlayTable from '../table/topInlineStartCorner.mjs';
+import { setOverlayPosition, resetCssTransform } from '../../../../../helpers/dom/element.mjs';
+import TopInlineStartCornerOverlayTable from '../../table/regions/topInlineStartCornerTable.mjs';
 import { Overlay } from './_base.mjs';
-import { CLONE_TOP_INLINE_START_CORNER } from './constants.mjs';
+import { CLONE_TOP_INLINE_START_CORNER } from '../constants.mjs';
 /**
  * @class TopInlineStartCornerOverlay
  */ export class TopInlineStartCornerOverlay extends Overlay {
@@ -11,8 +11,8 @@ import { CLONE_TOP_INLINE_START_CORNER } from './constants.mjs';
    * @see Table#constructor
    * @param {...*} args Parameters that will be forwarded to the `Table` constructor.
    * @returns {TopInlineStartCornerOverlayTable}
-   */ createTable(...args) {
-        return new TopInlineStartCornerOverlayTable(...args);
+   */ createTable(deps) {
+        return new TopInlineStartCornerOverlayTable(deps);
     }
     /**
    * Checks if overlay should be fully rendered.
@@ -77,21 +77,22 @@ import { CLONE_TOP_INLINE_START_CORNER } from './constants.mjs';
    * @returns {boolean}
    */ resetFixedPosition() {
         this.updateTrimmingContainer();
-        if (!this.wot.wtTable.holder.parentNode || !this.clone) {
+        if (!this.deps.getWtTable().holder.parentNode || !this.clone) {
             // removed from DOM
             return false;
         }
         const overlayRoot = this.clone.wtTable.holder.parentNode;
-        if (this.trimmingContainer === this.domBindings.rootWindow) {
+        if (this.trimmingContainer === this.deps.rootWindow) {
             const left = this.inlineStartOverlay.getOverlayOffset() * (this.isRtl() ? -1 : 1);
             const top = this.topOverlay.getOverlayOffset();
             setOverlayPosition(overlayRoot, `${left}px`, `${top}px`);
         } else {
             resetCssTransform(overlayRoot);
         }
-        let tableHeight = outerHeight(this.clone.wtTable.TABLE);
-        const tableWidth = outerWidth(this.clone.wtTable.TABLE);
-        if (!this.wot.wtTable.hasDefinedSize()) {
+        const { geometryReader } = this.deps;
+        let tableHeight = geometryReader.outerHeight(this.clone.wtTable.TABLE);
+        const tableWidth = geometryReader.outerWidth(this.clone.wtTable.TABLE);
+        if (!this.deps.getWtTable().hasDefinedSize()) {
             tableHeight = 0;
         }
         overlayRoot.style.height = `${tableHeight}px`;
@@ -99,14 +100,10 @@ import { CLONE_TOP_INLINE_START_CORNER } from './constants.mjs';
         return true;
     }
     /**
-   * @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.
    * @param {TopOverlay} topOverlay The instance of the Top overlay.
    * @param {InlineStartOverlay} inlineStartOverlay The instance of the InlineStart overlay.
-   */ constructor(wotInstance, facadeGetter, wtSettings, domBindings, topOverlay, inlineStartOverlay){
-        super(wotInstance, facadeGetter, CLONE_TOP_INLINE_START_CORNER, wtSettings, domBindings);
+   */ constructor(deps, topOverlay, inlineStartOverlay){
+        super(deps, CLONE_TOP_INLINE_START_CORNER);
         this.topOverlay = topOverlay;
         this.inlineStartOverlay = inlineStartOverlay;
     }

package/3rdparty/walkontable/src/overlay/regions/topOverlay.d.mts

@@ -0,0 +1 @@
+export * from './topOverlay.js';

package/3rdparty/walkontable/src/overlay/{top.d.ts → regions/topOverlay.d.ts}

@@ -1,11 +1,12 @@
-import type { DataAccessObject, DomBindings, WalkontableInstance } from '../types';
-import type Settings from '../settings';
-import TopOverlayTable from './../table/top';
-import { Overlay } from './_base';
+import type { TableDeps } from '../../table/baseTable';
+import TopOverlayTable from '../../table/regions/topTable';
+import { Overlay, type OverlayDeps } from './_base';
+import type { Selection } from '../../selection';
 /**
  * @class TopOverlay
  */
 export declare class TopOverlay extends Overlay {
+    #private;
     /**
      * Cached value which holds the previous value of the `fixedRowsTop` option.
      * It is used as a comparison value that can be used to detect changes in this value.
@@ -14,12 +15,8 @@ export declare class TopOverlay extends Overlay {
      */
     cachedFixedRowsTop: number;
     /**
-     * @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.
      */
-    constructor(wotInstance: WalkontableInstance, facadeGetter: Function, wtSettings: Settings, domBindings: DomBindings);
+    constructor(deps: OverlayDeps);
     /**
      * Factory method to create a subclass of `Table` that is relevant to this overlay.
      *
@@ -27,7 +24,7 @@ export declare class TopOverlay extends Overlay {
      * @param {...*} args Parameters that will be forwarded to the `Table` constructor.
      * @returns {TopOverlayTable}
      */
-    createTable(...args: [DataAccessObject, Function, DomBindings, Settings]): TopOverlayTable;
+    createTable(deps: TableDeps): TopOverlayTable;
     /**
      * Checks if overlay should be fully rendered.
      *
@@ -52,7 +49,10 @@ export declare class TopOverlay extends Overlay {
      */
     onScroll(): void;
     /**
-     * Calculates total sum cells height.
+     * Calculates total sum cells height. Delegates to the viewport's row-height prefix-sum cache
+     * (`Viewport#sumRowHeights`), so a call costs O(1) instead of walking every row in the
+     * `[from, to)` range — `scrollTo` passes ranges that start at row 0, which made keyboard
+     * navigation near the bottom of a large grid re-sum the whole dataset on every keypress.
      *
      * @param {number} from Row index which calculates started from.
      * @param {number} to Row index where calculation is finished.
@@ -67,6 +67,18 @@ export declare class TopOverlay extends Overlay {
      * Adjust overlay root element size (width and height).
      */
     adjustRootElementSize(): void;
+    /**
+     * Tells whether the holder must reserve the selection corner's protruding half-height (#6937),
+     * needed only when the selection's bottom-end corner falls within the frozen top rows this overlay
+     * renders — otherwise the reserved strip leaves a leftover top border at the seam. On mobile the
+     * handles always protrude so the range check suffices; on desktop the fill handle must also be
+     * enabled (`cornerVisible` truthy), mirroring `Border#appear`.
+     *
+     * @private
+     * @param {Selection|null} focusSelection The focus Selection instance (or `null` when none).
+     * @returns {boolean}
+     */
+    shouldReserveSelectionCornerOffset(focusSelection: Selection | null): boolean;
     /**
      * Adjust overlay root childs size.
      */
@@ -105,6 +117,15 @@ export declare class TopOverlay extends Overlay {
      * @returns {number} Main table's vertical overlay offset.
      */
     getOverlayOffset(): number;
+    /**
+     * Pre-applies the `innerBorderTop` class before the cell render, from the pre-render scroll
+     * position and settings. On the single-pass gated path the border is then already in its final
+     * state when cells render, so the post-render `resetFixedPosition` toggle becomes a no-op
+     * (`positionChanged` stays `false`) and the nested `wot.draw(true)` re-render is never triggered.
+     * Element mode only — the window path resolves the border from post-render geometry
+     * (`getOverlayOffset` + the #7256 guard) and is excluded by the single-pass gate.
+     */
+    prepareHeaderBorders(): void;
     /**
      * Adds css classes to hide the header border's header (cell-selection border hiding issue).
      *