handsontable 18.0.0 → 18.1.0-rc7

package/3rdparty/walkontable/src/types.d.ts

@@ -5,19 +5,21 @@
 import type CellCoords from './cell/coords';
 import type CellRange from './cell/range';
 import type { default as WalkontableSettings } from './settings';
-import type { default as WalkontableTable } from './table';
-import type { default as WalkontableViewport } from './viewport';
-import type { default as WalkontableScroll } from './scroll';
-import type { default as WalkontableOverlays } from './overlays';
+import type { default as WalkontableTable } from './table/baseTable';
+import type { default as WalkontableViewport } from './viewport/viewport';
+import type { default as WalkontableScroll } from './scroll/scroll';
+import type { default as WalkontableOverlays } from './overlay/overlays';
 import type { SelectionManager as WalkontableSelectionManager } from './selection/manager';
-import type { Overlay as WalkontableOverlay } from './overlay/_base';
+import type { Overlay as WalkontableOverlay } from './overlay/regions/_base';
 import type EventManager from '../../../eventManager';
 import type WalkontableEvent from './event';
+import type { GeometryReader } from './domMeasure/geometryReader';
 export interface DomBindings {
     rootDocument: Document;
     rootWindow: Window;
     rootElement: HTMLElement;
     rootTable: HTMLTableElement;
+    geometryReader: GeometryReader;
     [key: string]: unknown;
 }
 export interface WalkontableInstance {
@@ -71,67 +73,3 @@ export interface StylesHandler {
     areCellsBorderBox(): boolean;
     [key: string]: unknown;
 }
-/**
- * Data access object passed to Walkontable table/viewport/scroll subsystems.
- */
-export interface DataAccessObject {
-    wot: WalkontableInstance;
-    wtTable: WalkontableTable;
-    wtViewport: WalkontableViewport;
-    wtOverlays: WalkontableOverlays;
-    domBindings: DomBindings;
-    cloneSource: WalkontableInstance;
-    selectionManager: WalkontableSelectionManager;
-    drawn: boolean;
-    parentTableOffset: {
-        top: number;
-        left: number;
-    } | number;
-    topOverlayTrimmingContainer: HTMLElement | Window;
-    inlineStartOverlayTrimmingContainer: HTMLElement | Window;
-    topScrollPosition: number;
-    topParentOffset: number;
-    inlineStartScrollPosition: number;
-    inlineStartParentOffset: number;
-    topOverlay: WalkontableOverlay;
-    bottomOverlay: WalkontableOverlay;
-    inlineStartOverlay: WalkontableOverlay;
-    workspaceWidth: number;
-    startColumnRendered: number | null;
-    startColumnVisible: number | null;
-    startColumnPartiallyVisible: number | null;
-    endColumnRendered: number | null;
-    endColumnVisible: number | null;
-    endColumnPartiallyVisible: number | null;
-    countColumnsRendered: number;
-    countColumnsVisible: number;
-    startRowRendered: number | null;
-    startRowVisible: number | null;
-    startRowPartiallyVisible: number | null;
-    endRowRendered: number | null;
-    endRowVisible: number | null;
-    endRowPartiallyVisible: number | null;
-    countRowsRendered: number;
-    countRowsVisible: number;
-    columnHeaders: Function[];
-    rowHeaders: Function[];
-    [key: string]: unknown;
-}
-/**
- * Scroll data access object passed to the Walkontable scroll module.
- */
-export interface ScrollDao {
-    drawn: boolean;
-    topOverlay: WalkontableOverlay;
-    inlineStartOverlay: WalkontableOverlay;
-    wtTable: WalkontableTable;
-    wtViewport: WalkontableViewport;
-    wtSettings: WalkontableSettings;
-    rootWindow: Window;
-    totalRows: number;
-    totalColumns: number;
-    fixedRowsTop: number;
-    fixedRowsBottom: number;
-    fixedColumnsStart: number;
-    [key: string]: unknown;
-}

package/3rdparty/walkontable/src/types.mjs

@@ -2,5 +2,6 @@
  * Internal type definitions for the Walkontable rendering engine.
  * These are NOT part of the public Handsontable API.
  */ /**
- * Scroll data access object passed to the Walkontable scroll module.
+ * Minimal interface for the StylesHandler used inside Walkontable.
+ * The full class lives in src/utils/stylesHandler.ts.
  */ export { };

package/3rdparty/walkontable/src/utils/pointerToCoords.d.mts

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

package/3rdparty/walkontable/src/utils/{cellCoords.d.ts → pointerToCoords.d.ts}

@@ -1,4 +1,14 @@
 import type { WalkontableInstance } from '../types';
+import type { default as Settings } from '../settings';
+import type { GeometryReader } from '../domMeasure/geometryReader';
+import type { default as Table } from '../table/baseTable';
+interface MousePositionDeps {
+    wtSettings: Settings;
+    geometryReader: GeometryReader;
+    wtTable: Table;
+    rootWindow: Window;
+    facadeGetter: Function;
+}
 /**
  * Finds which column the mouse is over within a given column range.
  *
@@ -21,3 +31,17 @@ export declare function findColumnAtX(wotInstance: WalkontableInstance, row: num
  * @returns {number | null} Row index, or null if the mouse is outside the range.
  */
 export declare function findRowAtY(wotInstance: WalkontableInstance, column: number, startRow: number, endRow: number, relativeY: number): number | null;
+/**
+ * Returns the cell coordinates for the given mouse position and whether the mouse is
+ * outside the visible viewport. When the mouse is outside, the nearest edge cell is returned.
+ *
+ * @param {MousePositionDeps} deps The layout/settings/geometry dependencies (satisfied by `Event`'s deps).
+ * @param {number} mouseX Client X coordinate of the mouse.
+ * @param {number} mouseY Client Y coordinate of the mouse.
+ * @returns {{ coords: CellCoords, isOutside: boolean }}
+ */
+export declare function getCellCoordsFromMousePosition(deps: MousePositionDeps, mouseX: number, mouseY: number): {
+    coords: any;
+    isOutside: boolean;
+};
+export {};

package/3rdparty/walkontable/src/utils/pointerToCoords.js

@@ -0,0 +1,181 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get findColumnAtX () {
+        return findColumnAtX;
+    },
+    get findRowAtY () {
+        return findRowAtY;
+    },
+    get getCellCoordsFromMousePosition () {
+        return getCellCoordsFromMousePosition;
+    }
+});
+const _number = require("../../../../helpers/number");
+const _element = require("../../../../helpers/dom/element");
+function findColumnAtX(wotInstance, row, startColumn, endColumn, relativeX) {
+    let accumulatedX = 0;
+    for(let column = startColumn; column <= endColumn; column++){
+        const cellElement = wotInstance.getCell({
+            row,
+            col: column
+        }, true);
+        if (!(0, _element.isHTMLElement)(cellElement)) {
+            continue;
+        }
+        const width = wotInstance.domBindings.geometryReader.offsetWidth(cellElement);
+        if (relativeX < accumulatedX + width) {
+            return column;
+        }
+        accumulatedX += width;
+    }
+    return null;
+}
+function findRowAtY(wotInstance, column, startRow, endRow, relativeY) {
+    let accumulatedY = 0;
+    for(let row = startRow; row <= endRow; row++){
+        const cellElement = wotInstance.getCell({
+            row,
+            col: column
+        }, true);
+        if (!(0, _element.isHTMLElement)(cellElement)) {
+            continue;
+        }
+        const height = wotInstance.domBindings.geometryReader.offsetHeight(cellElement);
+        if (relativeY < accumulatedY + height) {
+            return row;
+        }
+        accumulatedY += height;
+    }
+    return null;
+}
+function getCellCoordsFromMousePosition(deps, mouseX, mouseY) {
+    const isRtl = deps.wtSettings.getSetting('rtlMode');
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const wot = deps.facadeGetter();
+    const numberOfFixedColumnsStart = deps.wtSettings.getSetting('fixedColumnsStart');
+    const numberOfFixedRowsTop = deps.wtSettings.getSetting('fixedRowsTop');
+    const numberOfFixedRowsBottom = deps.wtSettings.getSetting('fixedRowsBottom');
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const firstPartiallyVisibleRow = wot.wtScroll.getFirstPartiallyVisibleRow();
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const lastPartiallyVisibleRow = wot.wtScroll.getLastPartiallyVisibleRow();
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const firstPartiallyVisibleColumn = wot.wtScroll.getFirstPartiallyVisibleColumn();
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const lastPartiallyVisibleColumn = wot.wtScroll.getLastPartiallyVisibleColumn();
+    const tableOffset = deps.geometryReader.getBoundingClientRect(deps.wtTable.wtRootElement);
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const columnHeaderHeight = deps.wtSettings.getSetting('columnHeaders').length > 0 ? wot.wtViewport.getColumnHeaderHeight() : 0;
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const rowHeaderWidth = deps.wtSettings.getSetting('rowHeaders').length > 0 ? wot.wtViewport.getRowHeaderWidth() : 0;
+    const rootWindow = deps.rootWindow;
+    // When the window is the scroll container and tableOffset.left/top > 0 (e.g. RTL
+    // at max-left scroll where tableOffset.left can exceed innerWidth), using it as the
+    // clamp minimum causes clamp(min > max) to always return min, mapping every mouse
+    // position to the wrong edge column. Math.min(0, tableOffset) corrects this while
+    // preserving the original boundary when the table is partially off-screen to the
+    // left/top (tableOffset < 0), which is the normal scrolled-past-origin case.
+    const tableViewportLeft = wot.wtViewport.isHorizontallyScrollableByWindow() ? Math.min(0, tableOffset.left) : tableOffset.left;
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const tableViewportTop = wot.wtViewport.isVerticallyScrollableByWindow() ? Math.min(0, tableOffset.top) : tableOffset.top;
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const tableViewportRight = wot.wtViewport.isHorizontallyScrollableByWindow() ? rootWindow.innerWidth : tableOffset.left + wot.wtViewport.getViewportWidth() + rowHeaderWidth;
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const tableViewportBottom = wot.wtViewport.isVerticallyScrollableByWindow() ? rootWindow.innerHeight : tableOffset.top + wot.wtViewport.getViewportHeight() + columnHeaderHeight;
+    const clampedX = (0, _number.clamp)(mouseX, tableViewportLeft, tableViewportRight);
+    const clampedY = (0, _number.clamp)(mouseY, tableViewportTop, tableViewportBottom);
+    let foundColumn = null;
+    if (numberOfFixedColumnsStart > 0) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        const fixedCell = wot.getCell({
+            row: firstPartiallyVisibleRow,
+            col: 0
+        }, true);
+        if ((0, _element.isHTMLElement)(fixedCell)) {
+            const fixedCellRect = deps.geometryReader.getBoundingClientRect(fixedCell);
+            const fixedRelativeX = isRtl ? fixedCellRect.right - clampedX : clampedX - fixedCellRect.left;
+            foundColumn = findColumnAtX(wot, firstPartiallyVisibleRow, 0, numberOfFixedColumnsStart - 1, fixedRelativeX);
+        }
+    }
+    if (foundColumn === null) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        const scrollCell = wot.getCell({
+            row: firstPartiallyVisibleRow,
+            col: firstPartiallyVisibleColumn
+        }, true);
+        if ((0, _element.isHTMLElement)(scrollCell)) {
+            const scrollCellRect = deps.geometryReader.getBoundingClientRect(scrollCell);
+            const scrollRelativeX = isRtl ? scrollCellRect.right - clampedX : clampedX - scrollCellRect.left;
+            foundColumn = findColumnAtX(wot, firstPartiallyVisibleRow, firstPartiallyVisibleColumn, lastPartiallyVisibleColumn, scrollRelativeX);
+            if (foundColumn === null) {
+                foundColumn = scrollRelativeX < 0 ? firstPartiallyVisibleColumn : lastPartiallyVisibleColumn;
+            }
+        } else {
+            foundColumn = firstPartiallyVisibleColumn;
+        }
+    }
+    let foundRow = null;
+    if (numberOfFixedRowsTop > 0) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        const fixedCell = wot.getCell({
+            row: 0,
+            col: firstPartiallyVisibleColumn
+        }, true);
+        if ((0, _element.isHTMLElement)(fixedCell)) {
+            const fixedCellRect = deps.geometryReader.getBoundingClientRect(fixedCell);
+            const fixedRelativeY = clampedY - fixedCellRect.top;
+            foundRow = findRowAtY(wot, firstPartiallyVisibleColumn, 0, numberOfFixedRowsTop - 1, fixedRelativeY);
+        }
+    }
+    if (foundRow === null && numberOfFixedRowsBottom > 0) {
+        const totalRows = deps.wtSettings.getSetting('totalRows');
+        const bottomStartRow = totalRows - numberOfFixedRowsBottom;
+        const bottomEndRow = totalRows - 1;
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        const fixedBottomCell = wot.getCell({
+            row: bottomStartRow,
+            col: firstPartiallyVisibleColumn
+        }, true);
+        if ((0, _element.isHTMLElement)(fixedBottomCell)) {
+            const fixedBottomCellRect = deps.geometryReader.getBoundingClientRect(fixedBottomCell);
+            const fixedBottomRelativeY = clampedY - fixedBottomCellRect.top;
+            if (fixedBottomRelativeY >= 0) {
+                foundRow = findRowAtY(wot, firstPartiallyVisibleColumn, bottomStartRow, bottomEndRow, fixedBottomRelativeY);
+                if (foundRow === null) {
+                    foundRow = bottomEndRow;
+                }
+            }
+        }
+    }
+    if (foundRow === null) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        const scrollCell = wot.getCell({
+            row: firstPartiallyVisibleRow,
+            col: firstPartiallyVisibleColumn
+        }, true);
+        if ((0, _element.isHTMLElement)(scrollCell)) {
+            const scrollCellRect = deps.geometryReader.getBoundingClientRect(scrollCell);
+            const scrollRelativeY = clampedY - scrollCellRect.top;
+            foundRow = findRowAtY(wot, firstPartiallyVisibleColumn, firstPartiallyVisibleRow, lastPartiallyVisibleRow, scrollRelativeY);
+            if (foundRow === null) {
+                foundRow = lastPartiallyVisibleRow;
+            }
+        } else {
+            foundRow = firstPartiallyVisibleRow;
+        }
+    }
+    return {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        coords: wot.createCellCoords(foundRow, foundColumn),
+        isOutside: mouseX < tableViewportLeft || mouseX > tableViewportRight || mouseY < tableViewportTop || mouseY > tableViewportBottom
+    };
+}

package/3rdparty/walkontable/src/utils/pointerToCoords.mjs

@@ -0,0 +1,186 @@
+import { clamp } from '../../../../helpers/number.mjs';
+import { isHTMLElement } from '../../../../helpers/dom/element.mjs';
+/**
+ * Finds which column the mouse is over within a given column range.
+ *
+ * @param {Walkontable} wotInstance The Walkontable instance.
+ * @param {number} row Row to use for measuring cell widths.
+ * @param {number} startColumn First column in the range.
+ * @param {number} endColumn Last column in the range (inclusive).
+ * @param {number} relativeX Mouse X position relative to the first cell's left edge (or right edge in RTL).
+ * @returns {number | null} Column index, or null if the mouse is outside the range.
+ */ export function findColumnAtX(wotInstance, row, startColumn, endColumn, relativeX) {
+    let accumulatedX = 0;
+    for(let column = startColumn; column <= endColumn; column++){
+        const cellElement = wotInstance.getCell({
+            row,
+            col: column
+        }, true);
+        if (!isHTMLElement(cellElement)) {
+            continue;
+        }
+        const width = wotInstance.domBindings.geometryReader.offsetWidth(cellElement);
+        if (relativeX < accumulatedX + width) {
+            return column;
+        }
+        accumulatedX += width;
+    }
+    return null;
+}
+/**
+ * Finds which row the mouse is over within a given row range.
+ *
+ * @param {Walkontable} wotInstance The Walkontable instance.
+ * @param {number} column Column to use for measuring cell heights.
+ * @param {number} startRow First row in the range.
+ * @param {number} endRow Last row in the range (inclusive).
+ * @param {number} relativeY Mouse Y position relative to the first cell's top edge.
+ * @returns {number | null} Row index, or null if the mouse is outside the range.
+ */ export function findRowAtY(wotInstance, column, startRow, endRow, relativeY) {
+    let accumulatedY = 0;
+    for(let row = startRow; row <= endRow; row++){
+        const cellElement = wotInstance.getCell({
+            row,
+            col: column
+        }, true);
+        if (!isHTMLElement(cellElement)) {
+            continue;
+        }
+        const height = wotInstance.domBindings.geometryReader.offsetHeight(cellElement);
+        if (relativeY < accumulatedY + height) {
+            return row;
+        }
+        accumulatedY += height;
+    }
+    return null;
+}
+/**
+ * Returns the cell coordinates for the given mouse position and whether the mouse is
+ * outside the visible viewport. When the mouse is outside, the nearest edge cell is returned.
+ *
+ * @param {MousePositionDeps} deps The layout/settings/geometry dependencies (satisfied by `Event`'s deps).
+ * @param {number} mouseX Client X coordinate of the mouse.
+ * @param {number} mouseY Client Y coordinate of the mouse.
+ * @returns {{ coords: CellCoords, isOutside: boolean }}
+ */ export function getCellCoordsFromMousePosition(deps, mouseX, mouseY) {
+    const isRtl = deps.wtSettings.getSetting('rtlMode');
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const wot = deps.facadeGetter();
+    const numberOfFixedColumnsStart = deps.wtSettings.getSetting('fixedColumnsStart');
+    const numberOfFixedRowsTop = deps.wtSettings.getSetting('fixedRowsTop');
+    const numberOfFixedRowsBottom = deps.wtSettings.getSetting('fixedRowsBottom');
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const firstPartiallyVisibleRow = wot.wtScroll.getFirstPartiallyVisibleRow();
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const lastPartiallyVisibleRow = wot.wtScroll.getLastPartiallyVisibleRow();
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const firstPartiallyVisibleColumn = wot.wtScroll.getFirstPartiallyVisibleColumn();
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const lastPartiallyVisibleColumn = wot.wtScroll.getLastPartiallyVisibleColumn();
+    const tableOffset = deps.geometryReader.getBoundingClientRect(deps.wtTable.wtRootElement);
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const columnHeaderHeight = deps.wtSettings.getSetting('columnHeaders').length > 0 ? wot.wtViewport.getColumnHeaderHeight() : 0;
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const rowHeaderWidth = deps.wtSettings.getSetting('rowHeaders').length > 0 ? wot.wtViewport.getRowHeaderWidth() : 0;
+    const rootWindow = deps.rootWindow;
+    // When the window is the scroll container and tableOffset.left/top > 0 (e.g. RTL
+    // at max-left scroll where tableOffset.left can exceed innerWidth), using it as the
+    // clamp minimum causes clamp(min > max) to always return min, mapping every mouse
+    // position to the wrong edge column. Math.min(0, tableOffset) corrects this while
+    // preserving the original boundary when the table is partially off-screen to the
+    // left/top (tableOffset < 0), which is the normal scrolled-past-origin case.
+    const tableViewportLeft = wot.wtViewport.isHorizontallyScrollableByWindow() ? Math.min(0, tableOffset.left) : tableOffset.left;
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const tableViewportTop = wot.wtViewport.isVerticallyScrollableByWindow() ? Math.min(0, tableOffset.top) : tableOffset.top;
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const tableViewportRight = wot.wtViewport.isHorizontallyScrollableByWindow() ? rootWindow.innerWidth : tableOffset.left + wot.wtViewport.getViewportWidth() + rowHeaderWidth;
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const tableViewportBottom = wot.wtViewport.isVerticallyScrollableByWindow() ? rootWindow.innerHeight : tableOffset.top + wot.wtViewport.getViewportHeight() + columnHeaderHeight;
+    const clampedX = clamp(mouseX, tableViewportLeft, tableViewportRight);
+    const clampedY = clamp(mouseY, tableViewportTop, tableViewportBottom);
+    let foundColumn = null;
+    if (numberOfFixedColumnsStart > 0) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        const fixedCell = wot.getCell({
+            row: firstPartiallyVisibleRow,
+            col: 0
+        }, true);
+        if (isHTMLElement(fixedCell)) {
+            const fixedCellRect = deps.geometryReader.getBoundingClientRect(fixedCell);
+            const fixedRelativeX = isRtl ? fixedCellRect.right - clampedX : clampedX - fixedCellRect.left;
+            foundColumn = findColumnAtX(wot, firstPartiallyVisibleRow, 0, numberOfFixedColumnsStart - 1, fixedRelativeX);
+        }
+    }
+    if (foundColumn === null) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        const scrollCell = wot.getCell({
+            row: firstPartiallyVisibleRow,
+            col: firstPartiallyVisibleColumn
+        }, true);
+        if (isHTMLElement(scrollCell)) {
+            const scrollCellRect = deps.geometryReader.getBoundingClientRect(scrollCell);
+            const scrollRelativeX = isRtl ? scrollCellRect.right - clampedX : clampedX - scrollCellRect.left;
+            foundColumn = findColumnAtX(wot, firstPartiallyVisibleRow, firstPartiallyVisibleColumn, lastPartiallyVisibleColumn, scrollRelativeX);
+            if (foundColumn === null) {
+                foundColumn = scrollRelativeX < 0 ? firstPartiallyVisibleColumn : lastPartiallyVisibleColumn;
+            }
+        } else {
+            foundColumn = firstPartiallyVisibleColumn;
+        }
+    }
+    let foundRow = null;
+    if (numberOfFixedRowsTop > 0) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        const fixedCell = wot.getCell({
+            row: 0,
+            col: firstPartiallyVisibleColumn
+        }, true);
+        if (isHTMLElement(fixedCell)) {
+            const fixedCellRect = deps.geometryReader.getBoundingClientRect(fixedCell);
+            const fixedRelativeY = clampedY - fixedCellRect.top;
+            foundRow = findRowAtY(wot, firstPartiallyVisibleColumn, 0, numberOfFixedRowsTop - 1, fixedRelativeY);
+        }
+    }
+    if (foundRow === null && numberOfFixedRowsBottom > 0) {
+        const totalRows = deps.wtSettings.getSetting('totalRows');
+        const bottomStartRow = totalRows - numberOfFixedRowsBottom;
+        const bottomEndRow = totalRows - 1;
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        const fixedBottomCell = wot.getCell({
+            row: bottomStartRow,
+            col: firstPartiallyVisibleColumn
+        }, true);
+        if (isHTMLElement(fixedBottomCell)) {
+            const fixedBottomCellRect = deps.geometryReader.getBoundingClientRect(fixedBottomCell);
+            const fixedBottomRelativeY = clampedY - fixedBottomCellRect.top;
+            if (fixedBottomRelativeY >= 0) {
+                foundRow = findRowAtY(wot, firstPartiallyVisibleColumn, bottomStartRow, bottomEndRow, fixedBottomRelativeY);
+                if (foundRow === null) {
+                    foundRow = bottomEndRow;
+                }
+            }
+        }
+    }
+    if (foundRow === null) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        const scrollCell = wot.getCell({
+            row: firstPartiallyVisibleRow,
+            col: firstPartiallyVisibleColumn
+        }, true);
+        if (isHTMLElement(scrollCell)) {
+            const scrollCellRect = deps.geometryReader.getBoundingClientRect(scrollCell);
+            const scrollRelativeY = clampedY - scrollCellRect.top;
+            foundRow = findRowAtY(wot, firstPartiallyVisibleColumn, firstPartiallyVisibleRow, lastPartiallyVisibleRow, scrollRelativeY);
+            if (foundRow === null) {
+                foundRow = lastPartiallyVisibleRow;
+            }
+        } else {
+            foundRow = firstPartiallyVisibleRow;
+        }
+    }
+    return {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        coords: wot.createCellCoords(foundRow, foundColumn),
+        isOutside: mouseX < tableViewportLeft || mouseX > tableViewportRight || mouseY < tableViewportTop || mouseY > tableViewportBottom
+    };
+}

package/3rdparty/walkontable/src/viewport/boxLayout/gatherLayoutInput.d.mts

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

package/3rdparty/walkontable/src/viewport/boxLayout/gatherLayoutInput.d.ts

@@ -0,0 +1,40 @@
+/**
+ * The input-gathering seam for layout resolution — the ONLY file in the layout slice that touches the
+ * live DOM (through the geometry-read port) and the settings. It reads the current geometry into a
+ * plain `LayoutInput`; the pure solver in `resolveLayout` takes it from there.
+ *
+ * Following the composition-root convention, `createLayoutDeps(ctx)` picks the narrow set of
+ * dependencies this slice needs out of the `EngineContext`; its inferred `ReturnType` is the deps
+ * type. `gatherLayoutInput(deps)` is the read step.
+ *
+ * NOTE: this module is not wired into the draw yet. It exists so the pure solver has a real,
+ * reviewable source of inputs. The exact derivation of the workspace box (client box vs offset box
+ * minus borders) is refined when the snapshot is wired into the viewport in a later stage; the
+ * scrollbar math it feeds is already final and unit-tested.
+ */
+import type { EngineContext } from '../../wire';
+import type { LayoutInput } from './layoutSnapshot';
+/**
+ * Narrows the engine context to the dependencies the layout slice reads.
+ *
+ * @param {EngineContext} ctx The engine composition context.
+ * @returns {object} The layout dependency set.
+ */
+export declare function createLayoutDeps(ctx: EngineContext): {
+    geometryReader: import("../../domMeasure/geometryReader").GeometryReader;
+    wtSettings: import("../../settings").default;
+    rootDocument: Document;
+    rootWindow: Window;
+    getWtTable: () => import("../../table/baseTable").default;
+    getWtViewport: () => import("../viewport").default;
+    getTopOverlay: () => import("../../overlay").Overlay;
+    getInlineStartOverlay: () => import("../../overlay").Overlay;
+};
+export type LayoutDeps = ReturnType<typeof createLayoutDeps>;
+/**
+ * Reads the current geometry and settings into a pure `LayoutInput`.
+ *
+ * @param {LayoutDeps} deps The layout dependency set.
+ * @returns {LayoutInput}
+ */
+export declare function gatherLayoutInput(deps: LayoutDeps): LayoutInput;