handsontable 18.0.0 → 18.1.0-rc7

package/3rdparty/walkontable/src/viewport/boxLayout/gatherLayoutInput.js

@@ -0,0 +1,139 @@
+/**
+ * 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.
+ */ "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 createLayoutDeps () {
+        return createLayoutDeps;
+    },
+    get gatherLayoutInput () {
+        return gatherLayoutInput;
+    }
+});
+const _workspaceSize = require("../workspaceSize");
+function createLayoutDeps(ctx) {
+    return {
+        geometryReader: ctx.geometryReader,
+        wtSettings: ctx.wtSettings,
+        rootDocument: ctx.rootDocument,
+        rootWindow: ctx.rootWindow,
+        getWtTable: ctx.getWtTable,
+        getWtViewport: ctx.getWtViewport,
+        getTopOverlay: ctx.getTopOverlay,
+        getInlineStartOverlay: ctx.getInlineStartOverlay
+    };
+}
+/**
+ * Maps a raw CSS `overflow` string to the narrowed `OverflowMode`. Anything that is not `scroll` or
+ * `hidden` (including `visible`, `auto`, and unset) resolves to `'auto'` — "scrollbar only on
+ * overflow" — which is the engine's default behavior.
+ *
+ * @param {string | undefined} value The raw computed `overflow-x`/`overflow-y` value.
+ * @returns {OverflowMode}
+ */ function toOverflowMode(value) {
+    if (value === 'scroll') {
+        return 'scroll';
+    }
+    if (value === 'hidden') {
+        return 'hidden';
+    }
+    return 'auto';
+}
+function gatherLayoutInput(deps) {
+    const { geometryReader, wtSettings, rootDocument, rootWindow } = deps;
+    const viewport = deps.getWtViewport();
+    const wtTable = deps.getWtTable();
+    const trimmingContainer = deps.getTopOverlay().trimmingContainer;
+    const isWindow = trimmingContainer === rootWindow;
+    const isRtl = wtSettings.getSetting('rtlMode');
+    const scrollbarSize = geometryReader.getScrollbarWidth(rootDocument);
+    // The prefix-sum caches are the source of the content totals below. Build them here so a lazy
+    // `getLayout()` after a cache invalidation (which also drops the snapshot, see
+    // `Viewport#invalidateRowHeightCache`) recomputes correct totals instead of reading
+    // `getTotalSize()` as 0. `ensureBuilt()` is a no-op when already built, so the in-draw resolve
+    // (where the draw has already built the caches) is unaffected.
+    viewport.rowHeightCache.ensureBuilt();
+    viewport.columnWidthCache.ensureBuilt();
+    const rowHeaderWidth = viewport.getRowHeaderWidth();
+    const columnHeaderHeight = viewport.getColumnHeaderHeight();
+    // Match the hider extent the engine actually renders into: the internal row-height calculator
+    // carries a known 1px miscalculation that `Overlays#adjustElementsSize` compensates for by adding
+    // 1px to the hider height (and does not when AutoRowSize supplies exact heights — the
+    // `externalRowCalculator` case). Fold the same compensation into the total so the predicted
+    // vertical-scroll boundary matches today's post-render measurement exactly.
+    const hiderHeightCompensation = wtSettings.getSetting('externalRowCalculator') ? 0 : 1;
+    const totalContentWidth = rowHeaderWidth + viewport.columnWidthCache.getTotalSize();
+    const totalContentHeight = columnHeaderHeight + viewport.rowHeightCache.getTotalSize() + hiderHeightCompensation;
+    // The element whose overflow decides the scrollbars is the one that actually scrolls: the document
+    // in window mode, the table `holder` in element mode. This is NOT the trimming container — a
+    // trimming container with `overflow: hidden` still clips to its box while the inner holder shows
+    // the scrollbar, which is why the engine's `hasVerticalScroll()` is content-vs-workspace and
+    // overflow-agnostic on the container. Reading the holder keeps the prediction aligned with it.
+    const overflowElement = isWindow ? rootDocument.documentElement : wtTable.holder;
+    const overflowX = toOverflowMode(geometryReader.getStyle(overflowElement, 'overflow-x'));
+    const overflowY = toOverflowMode(geometryReader.getStyle(overflowElement, 'overflow-y'));
+    if (isWindow) {
+        const documentElement = rootDocument.documentElement;
+        // Read each layout-forcing dimension once — the live reader is uncached, so the workspace box
+        // and the window-context client size would otherwise force two reflows each per call.
+        const documentClientWidth = geometryReader.clientWidth(documentElement);
+        const documentClientHeight = geometryReader.clientHeight(documentElement);
+        return {
+            scrollMode: 'window',
+            workspaceWidth: documentClientWidth,
+            workspaceHeight: documentClientHeight,
+            totalContentWidth,
+            totalContentHeight,
+            scrollbarSize,
+            overflowX,
+            overflowY,
+            rowHeaderWidth,
+            columnHeaderHeight,
+            isRtl,
+            windowContext: {
+                documentScrollWidth: geometryReader.scrollWidth(documentElement),
+                documentScrollHeight: geometryReader.scrollHeight(documentElement),
+                documentClientWidth,
+                documentClientHeight,
+                currentHiderWidth: geometryReader.offsetWidth(wtTable.hider),
+                currentHiderHeight: geometryReader.offsetHeight(wtTable.hider)
+            }
+        };
+    }
+    return {
+        scrollMode: 'element',
+        // Source the workspace box from the RAW measure functions (not the public
+        // `getWorkspaceWidth`/`getWorkspaceHeight`, which on the single-pass path return this very
+        // snapshot — calling them here would recurse). The raw measures carry the exact legacy semantics,
+        // notably the `#3119` zero-height→window fallback, so the snapshot stays behavior-identical.
+        workspaceWidth: (0, _workspaceSize.measureWorkspaceWidth)(viewport),
+        workspaceHeight: (0, _workspaceSize.measureWorkspaceHeight)(viewport),
+        totalContentWidth,
+        totalContentHeight,
+        scrollbarSize,
+        overflowX,
+        overflowY,
+        rowHeaderWidth,
+        columnHeaderHeight,
+        isRtl
+    };
+}

package/3rdparty/walkontable/src/viewport/boxLayout/gatherLayoutInput.mjs

@@ -0,0 +1,131 @@
+/**
+ * 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 { measureWorkspaceWidth, measureWorkspaceHeight } from '../workspaceSize.mjs';
+/**
+ * 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 function createLayoutDeps(ctx) {
+    return {
+        geometryReader: ctx.geometryReader,
+        wtSettings: ctx.wtSettings,
+        rootDocument: ctx.rootDocument,
+        rootWindow: ctx.rootWindow,
+        getWtTable: ctx.getWtTable,
+        getWtViewport: ctx.getWtViewport,
+        getTopOverlay: ctx.getTopOverlay,
+        getInlineStartOverlay: ctx.getInlineStartOverlay
+    };
+}
+/**
+ * Maps a raw CSS `overflow` string to the narrowed `OverflowMode`. Anything that is not `scroll` or
+ * `hidden` (including `visible`, `auto`, and unset) resolves to `'auto'` — "scrollbar only on
+ * overflow" — which is the engine's default behavior.
+ *
+ * @param {string | undefined} value The raw computed `overflow-x`/`overflow-y` value.
+ * @returns {OverflowMode}
+ */ function toOverflowMode(value) {
+    if (value === 'scroll') {
+        return 'scroll';
+    }
+    if (value === 'hidden') {
+        return 'hidden';
+    }
+    return 'auto';
+}
+/**
+ * Reads the current geometry and settings into a pure `LayoutInput`.
+ *
+ * @param {LayoutDeps} deps The layout dependency set.
+ * @returns {LayoutInput}
+ */ export function gatherLayoutInput(deps) {
+    const { geometryReader, wtSettings, rootDocument, rootWindow } = deps;
+    const viewport = deps.getWtViewport();
+    const wtTable = deps.getWtTable();
+    const trimmingContainer = deps.getTopOverlay().trimmingContainer;
+    const isWindow = trimmingContainer === rootWindow;
+    const isRtl = wtSettings.getSetting('rtlMode');
+    const scrollbarSize = geometryReader.getScrollbarWidth(rootDocument);
+    // The prefix-sum caches are the source of the content totals below. Build them here so a lazy
+    // `getLayout()` after a cache invalidation (which also drops the snapshot, see
+    // `Viewport#invalidateRowHeightCache`) recomputes correct totals instead of reading
+    // `getTotalSize()` as 0. `ensureBuilt()` is a no-op when already built, so the in-draw resolve
+    // (where the draw has already built the caches) is unaffected.
+    viewport.rowHeightCache.ensureBuilt();
+    viewport.columnWidthCache.ensureBuilt();
+    const rowHeaderWidth = viewport.getRowHeaderWidth();
+    const columnHeaderHeight = viewport.getColumnHeaderHeight();
+    // Match the hider extent the engine actually renders into: the internal row-height calculator
+    // carries a known 1px miscalculation that `Overlays#adjustElementsSize` compensates for by adding
+    // 1px to the hider height (and does not when AutoRowSize supplies exact heights — the
+    // `externalRowCalculator` case). Fold the same compensation into the total so the predicted
+    // vertical-scroll boundary matches today's post-render measurement exactly.
+    const hiderHeightCompensation = wtSettings.getSetting('externalRowCalculator') ? 0 : 1;
+    const totalContentWidth = rowHeaderWidth + viewport.columnWidthCache.getTotalSize();
+    const totalContentHeight = columnHeaderHeight + viewport.rowHeightCache.getTotalSize() + hiderHeightCompensation;
+    // The element whose overflow decides the scrollbars is the one that actually scrolls: the document
+    // in window mode, the table `holder` in element mode. This is NOT the trimming container — a
+    // trimming container with `overflow: hidden` still clips to its box while the inner holder shows
+    // the scrollbar, which is why the engine's `hasVerticalScroll()` is content-vs-workspace and
+    // overflow-agnostic on the container. Reading the holder keeps the prediction aligned with it.
+    const overflowElement = isWindow ? rootDocument.documentElement : wtTable.holder;
+    const overflowX = toOverflowMode(geometryReader.getStyle(overflowElement, 'overflow-x'));
+    const overflowY = toOverflowMode(geometryReader.getStyle(overflowElement, 'overflow-y'));
+    if (isWindow) {
+        const documentElement = rootDocument.documentElement;
+        // Read each layout-forcing dimension once — the live reader is uncached, so the workspace box
+        // and the window-context client size would otherwise force two reflows each per call.
+        const documentClientWidth = geometryReader.clientWidth(documentElement);
+        const documentClientHeight = geometryReader.clientHeight(documentElement);
+        return {
+            scrollMode: 'window',
+            workspaceWidth: documentClientWidth,
+            workspaceHeight: documentClientHeight,
+            totalContentWidth,
+            totalContentHeight,
+            scrollbarSize,
+            overflowX,
+            overflowY,
+            rowHeaderWidth,
+            columnHeaderHeight,
+            isRtl,
+            windowContext: {
+                documentScrollWidth: geometryReader.scrollWidth(documentElement),
+                documentScrollHeight: geometryReader.scrollHeight(documentElement),
+                documentClientWidth,
+                documentClientHeight,
+                currentHiderWidth: geometryReader.offsetWidth(wtTable.hider),
+                currentHiderHeight: geometryReader.offsetHeight(wtTable.hider)
+            }
+        };
+    }
+    return {
+        scrollMode: 'element',
+        // Source the workspace box from the RAW measure functions (not the public
+        // `getWorkspaceWidth`/`getWorkspaceHeight`, which on the single-pass path return this very
+        // snapshot — calling them here would recurse). The raw measures carry the exact legacy semantics,
+        // notably the `#3119` zero-height→window fallback, so the snapshot stays behavior-identical.
+        workspaceWidth: measureWorkspaceWidth(viewport),
+        workspaceHeight: measureWorkspaceHeight(viewport),
+        totalContentWidth,
+        totalContentHeight,
+        scrollbarSize,
+        overflowX,
+        overflowY,
+        rowHeaderWidth,
+        columnHeaderHeight,
+        isRtl
+    };
+}

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

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

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

@@ -0,0 +1,133 @@
+/**
+ * Value objects for the single-pass layout resolution.
+ *
+ * `LayoutInput` is everything the layout math needs, expressed as plain numbers and enums — no DOM
+ * nodes, no live reads. `LayoutSnapshot` is the immutable answer: whether each scrollbar will be
+ * present after the draw, and the boxes that follow from that. Both are pure data so the solver
+ * (`resolveLayout`) can be unit-tested without a browser.
+ *
+ * This module is intentionally free of any DOM or engine imports. Gathering the input from the live
+ * DOM is the job of `createLayoutDeps`; consuming the snapshot is the job of the viewport (wired in a
+ * later stage). Keeping the three concerns apart is what lets a caching or predictive adapter replace
+ * the input-gathering step without touching the math.
+ */
+/**
+ * How the table scrolls: inside its own element, or by scrolling the whole window/document.
+ */
+export type ScrollMode = 'window' | 'element';
+/**
+ * The CSS `overflow` behavior for one axis, narrowed to the three values that change the scrollbar
+ * decision. `'auto'` means "a scrollbar appears only when the content overflows"; `'scroll'` forces
+ * one; `'hidden'` forbids one.
+ */
+export type OverflowMode = 'auto' | 'scroll' | 'hidden';
+/**
+ * Window-mode metrics. In window mode the scrollbars belong to the document, and other page content
+ * contributes to the document's scroll size, so the solver predicts the post-render document scroll
+ * size by delta: `documentScrollHeight - currentHiderHeight + newHiderHeight`. These are only read in
+ * window mode; in element mode the field is absent.
+ */
+export interface WindowLayoutContext {
+    documentScrollWidth: number;
+    documentScrollHeight: number;
+    documentClientWidth: number;
+    documentClientHeight: number;
+    currentHiderWidth: number;
+    currentHiderHeight: number;
+}
+/**
+ * Everything the layout math needs, as pure data.
+ */
+export interface LayoutInput {
+    scrollMode: ScrollMode;
+    /**
+     * The outer box the content plus our own scrollbars must fit into, in pixels. Stable and
+     * scrollbar-independent by construction (it is the container box, not a post-render measurement).
+     */
+    workspaceWidth: number;
+    workspaceHeight: number;
+    /**
+     * Total size of everything the table will render along each axis, from the prefix-sum caches plus
+     * the header extents. `totalContentWidth` includes the row-header width; `totalContentHeight`
+     * includes the column-header height.
+     */
+    totalContentWidth: number;
+    totalContentHeight: number;
+    /**
+     * Thickness of one scrollbar, in pixels. `0` on overlay scrollbars (e.g. macOS trackpad mode).
+     */
+    scrollbarSize: number;
+    overflowX: OverflowMode;
+    overflowY: OverflowMode;
+    /**
+     * Width taken by the row headers, subtracted from the inner width to get the column viewport.
+     */
+    rowHeaderWidth: number;
+    /**
+     * Height taken by all column-header levels, subtracted from the inner height to get the row
+     * viewport.
+     */
+    columnHeaderHeight: number;
+    /**
+     * Right-to-left layout. Carried through to the snapshot for downstream overlay placement; it does
+     * not change whether scrollbars appear.
+     */
+    isRtl: boolean;
+    /**
+     * Present only in window mode (see `WindowLayoutContext`).
+     */
+    windowContext?: WindowLayoutContext;
+}
+/**
+ * The immutable result of resolving a `LayoutInput`. Every field is a number or boolean known before
+ * a single cell is written to the DOM, so the draw can render once in final geometry.
+ */
+export interface LayoutSnapshot {
+    readonly scrollMode: ScrollMode;
+    readonly hasVerticalScroll: boolean;
+    readonly hasHorizontalScroll: boolean;
+    /**
+     * The stable outer box (equal to the input workspace box — scrollbar-independent).
+     */
+    readonly workspaceWidth: number;
+    readonly workspaceHeight: number;
+    /**
+     * The outer box minus the scrollbar that the opposite axis consumes.
+     */
+    readonly innerWidth: number;
+    readonly innerHeight: number;
+    /**
+     * The inner box minus the header extent — the area available for cells along each axis.
+     */
+    readonly viewportWidth: number;
+    readonly viewportHeight: number;
+    /**
+     * The viewport as the RENDER band sees it: the workspace box minus the header extent, WITHOUT
+     * subtracting either scrollbar. The rendered band is kept scrollbar-unaware on purpose so it always
+     * covers the strip a scrollbar will later sit over — that keeps `getCell` on the row/column under the
+     * scrollbar returning a real TD, so native `scrollIntoView` still works. Wider/taller than the
+     * scrollbar-aware `visibleViewport*` by exactly one scrollbar when the opposite axis scrolls.
+     */
+    readonly renderViewportWidth: number;
+    readonly renderViewportHeight: number;
+    /**
+     * The viewport as the VISIBLE band sees it: the workspace box minus the header extent AND the
+     * opposite-axis scrollbar when present. This scrollbar-aware area drives the fully/partially-visible
+     * row and column counts and the scroll-to-cell decisions. Always equal to `viewportWidth` /
+     * `viewportHeight` — the explicit name exists so consumers reading it beside `renderViewport*` state
+     * intent; keep both.
+     */
+    readonly visibleViewportWidth: number;
+    readonly visibleViewportHeight: number;
+    readonly rowHeaderWidth: number;
+    readonly columnHeaderHeight: number;
+    readonly totalContentWidth: number;
+    readonly totalContentHeight: number;
+    /**
+     * The size the hider element must take so its scrollable content matches the total content.
+     */
+    readonly hiderWidth: number;
+    readonly hiderHeight: number;
+    readonly scrollbarSize: number;
+    readonly isRtl: boolean;
+}

package/3rdparty/walkontable/src/viewport/boxLayout/layoutSnapshot.js

@@ -0,0 +1,18 @@
+/**
+ * Value objects for the single-pass layout resolution.
+ *
+ * `LayoutInput` is everything the layout math needs, expressed as plain numbers and enums — no DOM
+ * nodes, no live reads. `LayoutSnapshot` is the immutable answer: whether each scrollbar will be
+ * present after the draw, and the boxes that follow from that. Both are pure data so the solver
+ * (`resolveLayout`) can be unit-tested without a browser.
+ *
+ * This module is intentionally free of any DOM or engine imports. Gathering the input from the live
+ * DOM is the job of `createLayoutDeps`; consuming the snapshot is the job of the viewport (wired in a
+ * later stage). Keeping the three concerns apart is what lets a caching or predictive adapter replace
+ * the input-gathering step without touching the math.
+ */ /**
+ * How the table scrolls: inside its own element, or by scrolling the whole window/document.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});

package/3rdparty/walkontable/src/viewport/boxLayout/layoutSnapshot.mjs

@@ -0,0 +1,18 @@
+/**
+ * Value objects for the single-pass layout resolution.
+ *
+ * `LayoutInput` is everything the layout math needs, expressed as plain numbers and enums — no DOM
+ * nodes, no live reads. `LayoutSnapshot` is the immutable answer: whether each scrollbar will be
+ * present after the draw, and the boxes that follow from that. Both are pure data so the solver
+ * (`resolveLayout`) can be unit-tested without a browser.
+ *
+ * This module is intentionally free of any DOM or engine imports. Gathering the input from the live
+ * DOM is the job of `createLayoutDeps`; consuming the snapshot is the job of the viewport (wired in a
+ * later stage). Keeping the three concerns apart is what lets a caching or predictive adapter replace
+ * the input-gathering step without touching the math.
+ */ /**
+ * How the table scrolls: inside its own element, or by scrolling the whole window/document.
+ */ /**
+ * The immutable result of resolving a `LayoutInput`. Every field is a number or boolean known before
+ * a single cell is written to the DOM, so the draw can render once in final geometry.
+ */ export { };

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

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

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

@@ -0,0 +1,17 @@
+/**
+ * The pure layout solver.
+ *
+ * `resolveLayout` turns a `LayoutInput` (plain numbers) into a frozen `LayoutSnapshot`. Its only real
+ * work is the two-variable scrollbar fix-point: a vertical scrollbar consumes width, which can make a
+ * horizontal one necessary, which consumes height, which can make the vertical one necessary. The
+ * solve is monotone — a scrollbar only ever shrinks the box, never grows it — so a single corrective
+ * pass after the first guess always converges. There is no loop and no DOM.
+ */
+import type { LayoutInput, LayoutSnapshot } from './layoutSnapshot';
+/**
+ * Resolves a layout input into an immutable snapshot. Pure: same input, same output, no side effects.
+ *
+ * @param {LayoutInput} input The layout input.
+ * @returns {LayoutSnapshot}
+ */
+export declare function resolveLayout(input: LayoutInput): LayoutSnapshot;

package/3rdparty/walkontable/src/viewport/boxLayout/resolveLayout.js

@@ -0,0 +1,104 @@
+/**
+ * The pure layout solver.
+ *
+ * `resolveLayout` turns a `LayoutInput` (plain numbers) into a frozen `LayoutSnapshot`. Its only real
+ * work is the two-variable scrollbar fix-point: a vertical scrollbar consumes width, which can make a
+ * horizontal one necessary, which consumes height, which can make the vertical one necessary. The
+ * solve is monotone — a scrollbar only ever shrinks the box, never grows it — so a single corrective
+ * pass after the first guess always converges. There is no loop and no DOM.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "resolveLayout", {
+    enumerable: true,
+    get: function() {
+        return resolveLayout;
+    }
+});
+/**
+ * Decides the two scrollbars for a table that scrolls inside its own element.
+ *
+ * @param {LayoutInput} input The layout input.
+ * @returns {{ hasVerticalScroll: boolean, hasHorizontalScroll: boolean }}
+ */ function solveElementScrollbars(input) {
+    const { totalContentWidth: contentWidth, totalContentHeight: contentHeight, workspaceWidth, workspaceHeight, scrollbarSize } = input;
+    const forcedVertical = input.overflowY === 'scroll';
+    const forcedHorizontal = input.overflowX === 'scroll';
+    const suppressVertical = input.overflowY === 'hidden';
+    const suppressHorizontal = input.overflowX === 'hidden';
+    // First guess: does the content overflow the raw box on each axis?
+    let hasVerticalScroll = forcedVertical || !suppressVertical && contentHeight > workspaceHeight;
+    const hasHorizontalScroll = forcedHorizontal || !suppressHorizontal && contentWidth > workspaceWidth - (hasVerticalScroll ? scrollbarSize : 0);
+    // Corrective pass: a horizontal scrollbar we just decided on consumes height, which may now push
+    // the content past the vertical box. This can only turn the vertical scrollbar on, never off (the
+    // box only shrinks), so one pass is enough.
+    if (hasHorizontalScroll && !hasVerticalScroll && !suppressVertical) {
+        hasVerticalScroll = contentHeight > workspaceHeight - scrollbarSize;
+    }
+    return {
+        hasVerticalScroll,
+        hasHorizontalScroll
+    };
+}
+/**
+ * Decides the two scrollbars for a table that scrolls with the window. The scrollbars belong to the
+ * document, so the solver predicts the document's post-render scroll size by swapping the table's
+ * current hider extent for the extent it is about to take.
+ *
+ * @param {LayoutInput} input The layout input (must carry `windowContext`).
+ * @returns {{ hasVerticalScroll: boolean, hasHorizontalScroll: boolean }}
+ */ function solveWindowScrollbars(input) {
+    const context = input.windowContext;
+    if (!context) {
+        // No window metrics supplied — treat as no document scroll. This keeps the solver total; callers
+        // in window mode always supply the context.
+        return {
+            hasVerticalScroll: false,
+            hasHorizontalScroll: false
+        };
+    }
+    const predictedScrollHeight = context.documentScrollHeight - context.currentHiderHeight + input.totalContentHeight;
+    const predictedScrollWidth = context.documentScrollWidth - context.currentHiderWidth + input.totalContentWidth;
+    const hasVerticalScroll = input.overflowY === 'scroll' || input.overflowY !== 'hidden' && predictedScrollHeight > context.documentClientHeight;
+    const hasHorizontalScroll = input.overflowX === 'scroll' || input.overflowX !== 'hidden' && predictedScrollWidth > context.documentClientWidth;
+    return {
+        hasVerticalScroll,
+        hasHorizontalScroll
+    };
+}
+function resolveLayout(input) {
+    const { hasVerticalScroll, hasHorizontalScroll } = input.scrollMode === 'window' ? solveWindowScrollbars(input) : solveElementScrollbars(input);
+    const { workspaceWidth, workspaceHeight, scrollbarSize } = input;
+    const innerWidth = workspaceWidth - (hasVerticalScroll ? scrollbarSize : 0);
+    const innerHeight = workspaceHeight - (hasHorizontalScroll ? scrollbarSize : 0);
+    // Render band = scrollbar-unaware (workspace − header, no scrollbar); visible band = scrollbar-aware
+    // (inner − header). The two differ by exactly one scrollbar on the axis the opposite scrollbar eats.
+    const renderViewportWidth = workspaceWidth - input.rowHeaderWidth;
+    const renderViewportHeight = workspaceHeight - input.columnHeaderHeight;
+    const visibleViewportWidth = innerWidth - input.rowHeaderWidth;
+    const visibleViewportHeight = innerHeight - input.columnHeaderHeight;
+    return Object.freeze({
+        scrollMode: input.scrollMode,
+        hasVerticalScroll,
+        hasHorizontalScroll,
+        workspaceWidth,
+        workspaceHeight,
+        innerWidth,
+        innerHeight,
+        viewportWidth: visibleViewportWidth,
+        viewportHeight: visibleViewportHeight,
+        renderViewportWidth,
+        renderViewportHeight,
+        visibleViewportWidth,
+        visibleViewportHeight,
+        rowHeaderWidth: input.rowHeaderWidth,
+        columnHeaderHeight: input.columnHeaderHeight,
+        totalContentWidth: input.totalContentWidth,
+        totalContentHeight: input.totalContentHeight,
+        hiderWidth: input.totalContentWidth,
+        hiderHeight: input.totalContentHeight,
+        scrollbarSize,
+        isRtl: input.isRtl
+    });
+}