handsontable 18.0.0 → 18.1.0-rc7

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

@@ -0,0 +1,267 @@
+import type { WalkontableInstance } from '../types';
+import type { EngineContext } from '../wire';
+import type Settings from '../settings';
+import type Table from '../table/baseTable';
+import type EventManager from '../../../../eventManager';
+import type { CalculationTypeLike, ColumnsCalculationType, RowsCalculationType } from '../calculator/viewportBase';
+import { PositionCache } from '../axisSizing/positionCache';
+import { type WorkspaceSize } from './workspaceSize';
+import { type CalculatorFactory } from './calculatorFactory';
+import type { LayoutSnapshot } from './boxLayout/layoutSnapshot';
+/**
+ * Assembles the Viewport module's dependencies from the engine composition context.
+ *
+ * Everything the Viewport once received as separate constructor arguments (DOM bindings, settings,
+ * event manager, table) now flows through this one object. The `EventManager` is created once here
+ * (matching the previous per-module `this.eventManager`), and the table is resolved concretely
+ * because the Viewport is constructed after the master table exists.
+ *
+ * @param {EngineContext} ctx The engine composition context.
+ * @returns {object} The Viewport dependency set.
+ */
+export declare function createViewportDeps(ctx: EngineContext): {
+    wot: WalkontableInstance;
+    rootDocument: Document;
+    rootWindow: Window;
+    geometryReader: import("../domMeasure/geometryReader").GeometryReader;
+    rowSizeSource: import("../axisSizing/axisSizeSource").RowSizeSource;
+    columnSizeSource: import("../axisSizing/axisSizeSource").AxisSizeSource;
+    layoutDeps: {
+        geometryReader: import("../domMeasure/geometryReader").GeometryReader;
+        wtSettings: Settings;
+        rootDocument: Document;
+        rootWindow: Window;
+        getWtTable: () => Table;
+        getWtViewport: () => Viewport;
+        getTopOverlay: () => import("../overlay").Overlay;
+        getInlineStartOverlay: () => import("../overlay").Overlay;
+    };
+    wtSettings: Settings;
+    eventManager: EventManager;
+    wtTable: Table;
+    getTopOverlay: () => import("../overlay").Overlay;
+    getInlineStartOverlay: () => import("../overlay").Overlay;
+    getBottomOverlay: () => import("../overlay").Overlay;
+};
+/**
+ * The Viewport module dependencies, inferred from `createViewportDeps`.
+ */
+export type ViewportDeps = ReturnType<typeof createViewportDeps>;
+/**
+ * The Viewport owns the per-draw calculator objects and the size prefix-sum caches. Its
+ * workspace-size / scroll-detection queries and its calculator-creation logic are supplied by two
+ * mixins (`workspaceSize`, `calculatorFactory`); the method bodies live in their own files so the
+ * single-pass refactor can rework the workspace-size group in isolation. The mixin methods reach the
+ * private dependency set through the public `deps` getter.
+ *
+ * @class Viewport
+ */
+declare class Viewport {
+    #private;
+    /**
+     * @type {WalkontableInstance}
+     */
+    wot: WalkontableInstance;
+    /**
+     * @type {Settings}
+     */
+    wtSettings: Settings;
+    /**
+     * @type {Table}
+     */
+    wtTable: Table;
+    /**
+     * @type {Record<number, number | undefined>}
+     */
+    oversizedRows: Record<number, number | undefined>;
+    /**
+     * The `oversizedRows` keys whose height was discovered in a FROZEN column — content the master
+     * table does not render, so `markOversizedRows` on the master can never re-detect it.
+     *
+     * `resetOversizedRows` skips these keys: wiping them would drop the record before the row-height
+     * cache and the viewport calculators are built, and the master could not put it back. They are
+     * cleared instead by `resetFrozenOversizedRows`, in the seam between the master's render and the
+     * frozen overlays' — late enough that the master rendered at the right height, early enough that
+     * the frozen clone renders at its natural height and stays re-measurable.
+     *
+     * @type {Set<number>}
+     */
+    frozenOversizedRows: Set<number>;
+    /**
+     * The row-height cache's `buildSeq` as it stood when this draw cleared the frozen-derived
+     * records.
+     *
+     * Between that clear and the frozen sync putting the records back, `oversizedRows` is missing
+     * every frozen-derived height — so a cache built in that window is short by all of them. It is
+     * not self-correcting: the records come back unchanged, so nothing invalidates, and the hider
+     * keeps a scrollbar that cannot reach the end of the grid while every rendered row still looks
+     * right. The bottom clone reaches exactly this window, since it renders (and measures) inside
+     * `wtOverlays.refresh()`. Comparing the counter afterwards is how the sync notices.
+     *
+     * @type {number}
+     */
+    frozenClearRowCacheBuildSeq: number;
+    /**
+     * @type {Record<string, unknown>}
+     */
+    hasOversizedColumnHeadersMarked: Record<string, unknown>;
+    /**
+     * @type {number}
+     */
+    clientHeight: number;
+    /**
+     * @type {number}
+     */
+    columnHeaderHeight: number;
+    /**
+     * @type {number}
+     */
+    rowHeaderWidth: number;
+    /**
+     * @type {RowsCalculationType | null}
+     */
+    rowsVisibleCalculator: RowsCalculationType | null;
+    /**
+     * @type {ColumnsCalculationType | null}
+     */
+    columnsVisibleCalculator: ColumnsCalculationType | null;
+    /**
+     * @type {Map<string, () => CalculationTypeLike>}
+     */
+    rowsCalculatorTypes: Map<string, () => CalculationTypeLike>;
+    /**
+     * @type {Map<string, () => CalculationTypeLike>}
+     */
+    columnsCalculatorTypes: Map<string, () => CalculationTypeLike>;
+    /**
+     * @type {EventManager}
+     */
+    eventManager: EventManager;
+    /**
+     * @type {RowsCalculationType | null}
+     */
+    rowsRenderCalculator: RowsCalculationType | null;
+    /**
+     * @type {ColumnsCalculationType | null}
+     */
+    columnsRenderCalculator: ColumnsCalculationType | null;
+    /**
+     * Monotonic counter of cell-band renders, bumped by every `renderCellBand` call (see
+     * `table/drawCycle.ts`). Overlay clones share the master's Viewport instance, so a render by ANY
+     * table of this Walkontable — the master or any clone, nested inside a hook or not — advances it.
+     * The master's `skipRender` rollback compares it against the value read right before the
+     * `beforeDraw` hook fired to answer "did the hook render a DOM cell band?" — see
+     * `restoreRenderedStateIfSafe`.
+     *
+     * @type {number}
+     */
+    renderCycleSeq: number;
+    /**
+     * @type {RowsCalculationType | null}
+     */
+    rowsPartiallyVisibleCalculator: RowsCalculationType | null;
+    /**
+     * @type {ColumnsCalculationType | null}
+     */
+    columnsPartiallyVisibleCalculator: ColumnsCalculationType | null;
+    /**
+     * @type {PositionCache}
+     */
+    rowHeightCache: PositionCache;
+    /**
+     * @type {PositionCache}
+     */
+    columnWidthCache: PositionCache;
+    /**
+     * Read-only access to the dependencies, for the `workspaceSize` / `calculatorFactory` mixins, which
+     * are defined outside this class and so cannot reach the private `#deps`.
+     *
+     * @returns {ViewportDeps}
+     */
+    get deps(): ViewportDeps;
+    /**
+     * @param {ViewportDeps} deps The Viewport module dependencies.
+     */
+    constructor(deps: ViewportDeps);
+    /**
+     * Resolves the layout snapshot for the draw that is starting, stores it, and returns it. Called
+     * once per master draw, after the size caches are built and before the calculators run, so the
+     * snapshot reflects the geometry the draw will render into.
+     *
+     * On the single-pass gated path (element mode, uniform sizes) the calculators and the
+     * scroll-detection queries read this snapshot, so the scrollbars are predicted from content totals
+     * and the draw renders in one pass. Off that path (merged cells, window scroll, non-uniform sizes)
+     * the engine keeps measuring the rendered DOM; the snapshot is still resolved and its prediction
+     * stays in agreement with the live measurement (asserted in `viewport.spec.js`).
+     *
+     * @returns {LayoutSnapshot}
+     */
+    beginDrawLayout(): LayoutSnapshot;
+    /**
+     * Returns the current layout snapshot. Recomputes lazily when there is none (between draws, or after
+     * an invalidation) so API callers outside the draw get a fresh answer.
+     *
+     * @returns {LayoutSnapshot}
+     */
+    getLayout(): LayoutSnapshot;
+    /**
+     * Drops the cached layout snapshot so the next `getLayout()` recomputes it. Called whenever the
+     * geometry that feeds the snapshot may have changed (a resize or a size-cache invalidation).
+     */
+    invalidateLayout(): void;
+    /**
+     * Sums the heights of the `[from, to)` row range in O(1) using the row-height prefix-sum cache,
+     * with the exact semantics of a live per-row walk. Row heights are position-independent except
+     * for one row: the first rendered visible row reports a 1px border-top compensation
+     * (`StylesHandler#getDefaultRowHeight`, AutoRowSize). The cache holds the heights read at build
+     * time, so the row that carried the compensation then, and the row that carries it now, are
+     * re-read live and the cached values are replaced by the live ones.
+     *
+     * @param {number} from Start row index (inclusive).
+     * @param {number} to End row index (exclusive).
+     * @returns {number} The height sum in pixels.
+     */
+    sumRowHeights(from: number, to: number): number;
+    /**
+     * Marks the row height position cache as stale. The cache will be rebuilt
+     * on the next viewport calculation.
+     */
+    invalidateRowHeightCache(): void;
+    /**
+     * Drops every oversized-row record, not just the rendered band's, and marks the row-height cache
+     * stale so the next draw measures the rows again.
+     *
+     * `resetOversizedRows` deliberately wipes only the rendered band, because a record outside it is
+     * still the best height known for that row. That assumption breaks when the records were taken
+     * against a table with no layout: `getComputedStyle` returned nothing, so the default row height
+     * was unknown and every row was recorded oversized at a height it never had. Then the whole map
+     * has to go at once, or the rows outside the band keep inflating the scroll range for good.
+     */
+    resetAllOversizedRows(): void;
+    /**
+     * Hands the frozen-derived row records back to the ordinary oversized-row machinery, keeping their
+     * heights but dropping their exemption from `resetOversizedRows`.
+     *
+     * Called on any draw that does NOT run the frozen-column row sync — the master's rendered band
+     * starts at column 0, so it renders every frozen column and can measure those rows itself. Without
+     * this the records would keep their exemption while nothing re-measured them, so they could only
+     * ever grow.
+     */
+    releaseFrozenOversizedRows(): void;
+    /**
+     * Marks the column width position cache as stale. The cache will be rebuilt
+     * on the next viewport calculation.
+     */
+    invalidateColumnWidthCache(): void;
+    /**
+     * Marks both the row height and column width position caches as stale.
+     */
+    invalidateAllCaches(): void;
+    /**
+     * Resets values in keys of the hasOversizedColumnHeadersMarked object after updateSettings.
+     */
+    resetHasOversizedColumnHeadersMarked(): void;
+}
+interface Viewport extends WorkspaceSize, CalculatorFactory {
+}
+export default Viewport;

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

@@ -0,0 +1,368 @@
+"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 createViewportDeps () {
+        return createViewportDeps;
+    },
+    get default () {
+        return _default;
+    }
+});
+const _object = require("../../../../helpers/object");
+const _calculator = require("../calculator");
+const _positionCache = require("../axisSizing/positionCache");
+const _workspaceSize = require("./workspaceSize");
+const _calculatorFactory = require("./calculatorFactory");
+const _gatherLayoutInput = require("./boxLayout/gatherLayoutInput");
+const _resolveLayout = require("./boxLayout/resolveLayout");
+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;
+}
+function createViewportDeps(ctx) {
+    return {
+        wot: ctx.wot,
+        rootDocument: ctx.rootDocument,
+        rootWindow: ctx.rootWindow,
+        geometryReader: ctx.geometryReader,
+        rowSizeSource: ctx.rowSizeSource,
+        columnSizeSource: ctx.columnSizeSource,
+        layoutDeps: (0, _gatherLayoutInput.createLayoutDeps)(ctx),
+        wtSettings: ctx.wtSettings,
+        eventManager: ctx.makeEventManager(),
+        wtTable: ctx.getWtTable(),
+        getTopOverlay: ctx.getTopOverlay,
+        getInlineStartOverlay: ctx.getInlineStartOverlay,
+        getBottomOverlay: ctx.getBottomOverlay
+    };
+}
+var /**
+   * The Viewport module dependencies.
+   *
+   * @type {ViewportDeps}
+   */ _deps = /*#__PURE__*/ new WeakMap(), /**
+   * The layout slice's dependency set — the input-gathering seam for the single-pass snapshot.
+   *
+   * @type {LayoutDeps}
+   */ _layoutDeps = /*#__PURE__*/ new WeakMap(), /**
+   * The layout snapshot resolved at the top of the current draw, or `null` between draws / after an
+   * invalidation. Computed by `beginDrawLayout()`; read through `getLayout()`.
+   *
+   * @type {LayoutSnapshot | null}
+   */ _layout = /*#__PURE__*/ new WeakMap(), /**
+   * The row that was the first rendered row when `rowHeightCache` was last built, or `-1` when
+   * nothing was rendered at that moment. The first rendered visible row carries a 1px border-top
+   * compensation in its reported height (see `StylesHandler#getDefaultRowHeight`), so the cache
+   * holds a value for this row that stops being correct once the viewport scrolls.
+   * {@link Viewport#sumRowHeights} re-reads it (and the current first rendered row) live.
+   *
+   * @type {number}
+   */ _rowFirstRenderedAtBuild = /*#__PURE__*/ new WeakMap();
+/**
+ * The Viewport owns the per-draw calculator objects and the size prefix-sum caches. Its
+ * workspace-size / scroll-detection queries and its calculator-creation logic are supplied by two
+ * mixins (`workspaceSize`, `calculatorFactory`); the method bodies live in their own files so the
+ * single-pass refactor can rework the workspace-size group in isolation. The mixin methods reach the
+ * private dependency set through the public `deps` getter.
+ *
+ * @class Viewport
+ */ class Viewport {
+    /**
+   * Read-only access to the dependencies, for the `workspaceSize` / `calculatorFactory` mixins, which
+   * are defined outside this class and so cannot reach the private `#deps`.
+   *
+   * @returns {ViewportDeps}
+   */ get deps() {
+        return _class_private_field_get(this, _deps);
+    }
+    /**
+   * Resolves the layout snapshot for the draw that is starting, stores it, and returns it. Called
+   * once per master draw, after the size caches are built and before the calculators run, so the
+   * snapshot reflects the geometry the draw will render into.
+   *
+   * On the single-pass gated path (element mode, uniform sizes) the calculators and the
+   * scroll-detection queries read this snapshot, so the scrollbars are predicted from content totals
+   * and the draw renders in one pass. Off that path (merged cells, window scroll, non-uniform sizes)
+   * the engine keeps measuring the rendered DOM; the snapshot is still resolved and its prediction
+   * stays in agreement with the live measurement (asserted in `viewport.spec.js`).
+   *
+   * @returns {LayoutSnapshot}
+   */ beginDrawLayout() {
+        _class_private_field_set(this, _layout, (0, _resolveLayout.resolveLayout)((0, _gatherLayoutInput.gatherLayoutInput)(_class_private_field_get(this, _layoutDeps))));
+        return _class_private_field_get(this, _layout);
+    }
+    /**
+   * Returns the current layout snapshot. Recomputes lazily when there is none (between draws, or after
+   * an invalidation) so API callers outside the draw get a fresh answer.
+   *
+   * @returns {LayoutSnapshot}
+   */ getLayout() {
+        if (_class_private_field_get(this, _layout) === null) {
+            _class_private_field_set(this, _layout, (0, _resolveLayout.resolveLayout)((0, _gatherLayoutInput.gatherLayoutInput)(_class_private_field_get(this, _layoutDeps))));
+        }
+        return _class_private_field_get(this, _layout);
+    }
+    /**
+   * Drops the cached layout snapshot so the next `getLayout()` recomputes it. Called whenever the
+   * geometry that feeds the snapshot may have changed (a resize or a size-cache invalidation).
+   */ invalidateLayout() {
+        _class_private_field_set(this, _layout, null);
+    }
+    /**
+   * Sums the heights of the `[from, to)` row range in O(1) using the row-height prefix-sum cache,
+   * with the exact semantics of a live per-row walk. Row heights are position-independent except
+   * for one row: the first rendered visible row reports a 1px border-top compensation
+   * (`StylesHandler#getDefaultRowHeight`, AutoRowSize). The cache holds the heights read at build
+   * time, so the row that carried the compensation then, and the row that carries it now, are
+   * re-read live and the cached values are replaced by the live ones.
+   *
+   * @param {number} from Start row index (inclusive).
+   * @param {number} to End row index (exclusive).
+   * @returns {number} The height sum in pixels.
+   */ sumRowHeights(from, to) {
+        const cache = this.rowHeightCache;
+        cache.ensureBuilt();
+        let sum = cache.getOffset(to) - cache.getOffset(from);
+        const compensationRows = new Set([
+            _class_private_field_get(this, _rowFirstRenderedAtBuild),
+            this.wtTable.getFirstRenderedRow()
+        ]);
+        compensationRows.forEach((row)=>{
+            if (row >= 0 && row >= from && row < to && row < cache.totalItems) {
+                const liveHeight = this.wtTable.getRowHeight(row);
+                const resolvedLiveHeight = liveHeight === undefined ? _class_private_field_get(this, _deps).rowSizeSource.getDefaultSize() : liveHeight;
+                sum += resolvedLiveHeight - cache.getSizeAt(row);
+            }
+        });
+        return sum;
+    }
+    /**
+   * Marks the row height position cache as stale. The cache will be rebuilt
+   * on the next viewport calculation.
+   */ invalidateRowHeightCache() {
+        this.rowHeightCache.invalidate();
+        this.invalidateLayout();
+    }
+    /**
+   * Drops every oversized-row record, not just the rendered band's, and marks the row-height cache
+   * stale so the next draw measures the rows again.
+   *
+   * `resetOversizedRows` deliberately wipes only the rendered band, because a record outside it is
+   * still the best height known for that row. That assumption breaks when the records were taken
+   * against a table with no layout: `getComputedStyle` returned nothing, so the default row height
+   * was unknown and every row was recorded oversized at a height it never had. Then the whole map
+   * has to go at once, or the rows outside the band keep inflating the scroll range for good.
+   */ resetAllOversizedRows() {
+        this.oversizedRows = {};
+        this.frozenOversizedRows.clear();
+        this.invalidateRowHeightCache();
+    }
+    /**
+   * Hands the frozen-derived row records back to the ordinary oversized-row machinery, keeping their
+   * heights but dropping their exemption from `resetOversizedRows`.
+   *
+   * Called on any draw that does NOT run the frozen-column row sync — the master's rendered band
+   * starts at column 0, so it renders every frozen column and can measure those rows itself. Without
+   * this the records would keep their exemption while nothing re-measured them, so they could only
+   * ever grow.
+   */ releaseFrozenOversizedRows() {
+        this.frozenOversizedRows.clear();
+    }
+    /**
+   * Marks the column width position cache as stale. The cache will be rebuilt
+   * on the next viewport calculation.
+   */ invalidateColumnWidthCache() {
+        this.columnWidthCache.invalidate();
+        this.invalidateLayout();
+    }
+    /**
+   * Marks both the row height and column width position caches as stale.
+   */ invalidateAllCaches() {
+        this.rowHeightCache.invalidate();
+        this.columnWidthCache.invalidate();
+        this.invalidateLayout();
+    }
+    /**
+   * Resets values in keys of the hasOversizedColumnHeadersMarked object after updateSettings.
+   */ resetHasOversizedColumnHeadersMarked() {
+        (0, _object.objectEach)(this.hasOversizedColumnHeadersMarked, (value, key, object)=>{
+            object[key] = undefined;
+        });
+    }
+    /**
+   * @param {ViewportDeps} deps The Viewport module dependencies.
+   */ constructor(deps){
+        _class_private_field_init(this, _deps, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _layoutDeps, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _layout, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _rowFirstRenderedAtBuild, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_set(this, _layout, null);
+        /**
+   * Monotonic counter of cell-band renders, bumped by every `renderCellBand` call (see
+   * `table/drawCycle.ts`). Overlay clones share the master's Viewport instance, so a render by ANY
+   * table of this Walkontable — the master or any clone, nested inside a hook or not — advances it.
+   * The master's `skipRender` rollback compares it against the value read right before the
+   * `beforeDraw` hook fired to answer "did the hook render a DOM cell band?" — see
+   * `restoreRenderedStateIfSafe`.
+   *
+   * @type {number}
+   */ this.renderCycleSeq = 0;
+        _class_private_field_set(this, _rowFirstRenderedAtBuild, -1);
+        const { wtSettings, wtTable, rowSizeSource, columnSizeSource } = deps;
+        _class_private_field_set(this, _deps, deps);
+        _class_private_field_set(this, _layoutDeps, deps.layoutDeps);
+        // legacy support
+        this.wot = deps.wot;
+        this.wtSettings = wtSettings;
+        this.wtTable = wtTable;
+        this.oversizedRows = {};
+        this.frozenOversizedRows = new Set();
+        this.frozenClearRowCacheBuildSeq = 0;
+        this.hasOversizedColumnHeadersMarked = {};
+        this.clientHeight = 0;
+        this.rowHeaderWidth = NaN;
+        this.rowsVisibleCalculator = null;
+        this.columnsVisibleCalculator = null;
+        // Before the first render these must be `null` (the declared type), not `undefined` — the
+        // `skipRender` rollback captures/restores them and the overlays' `applyToDOM` null-checks them.
+        this.rowsRenderCalculator = null;
+        this.columnsRenderCalculator = null;
+        this.rowsCalculatorTypes = new Map([
+            [
+                'rendered',
+                ()=>this.wtSettings.getSetting('renderAllRows') ? new _calculator.RenderedAllRowsCalculationType() : new _calculator.RenderedRowsCalculationType()
+            ],
+            [
+                'fullyVisible',
+                ()=>new _calculator.FullyVisibleRowsCalculationType()
+            ],
+            [
+                'partiallyVisible',
+                ()=>new _calculator.PartiallyVisibleRowsCalculationType()
+            ]
+        ]);
+        this.columnsCalculatorTypes = new Map([
+            [
+                'rendered',
+                ()=>this.wtSettings.getSetting('renderAllColumns') ? new _calculator.RenderedAllColumnsCalculationType() : new _calculator.RenderedColumnsCalculationType()
+            ],
+            [
+                'fullyVisible',
+                ()=>new _calculator.FullyVisibleColumnsCalculationType()
+            ],
+            [
+                'partiallyVisible',
+                ()=>new _calculator.PartiallyVisibleColumnsCalculationType()
+            ]
+        ]);
+        /**
+     * Cumulative row height prefix sum cache. Enables O(log n) scroll-to-row lookups
+     * when custom row heights are configured.
+     *
+     * @type {PositionCache}
+     */ this.rowHeightCache = new _positionCache.PositionCache({
+            totalItemsFn: ()=>wtSettings.getSetting('totalRows'),
+            // The size must stay the MERGED value (`Math.max(provided, oversized)`), so it reads
+            // `wtTable.getRowHeight` — not `rowSizeSource.getSize`, which supplies only the provided half.
+            // This is the LOGICAL row height; the constant relating it to the pixel height the renderer
+            // writes lives in `getBoxAdjustedRowHeight` (axisSizing/boxModel.ts). Do not box-adjust it here —
+            // the calculators and `sumCellSizes` sum this value and expect the logical height.
+            sizeFn: (sourceRow)=>wtTable.getRowHeight(sourceRow) ?? NaN,
+            defaultSizeFn: ()=>rowSizeSource.getDefaultSize(),
+            // Uniform fast path: every row is the default height only when the source reports it (no per-row
+            // `rowHeights`/`minRowHeights`, no `modifyRowHeight` hook) AND walkontable has measured no
+            // oversized rows. Any of these invalidates the cache, so the next build re-evaluates this.
+            isUniformFn: ()=>rowSizeSource.isUniform() && Object.keys(this.oversizedRows).length === 0,
+            // Sparse fast path: when the provided heights are uniform but walkontable HAS measured
+            // oversized rows, those records are the only deviations from the default height — the cache
+            // stores just them and rebuilds in O(oversized rows) instead of walking all `totalRows`
+            // (a scroll into unmeasured territory rebuilds on every band change). With per-row heights
+            // or a `modifyRowHeight` hook this returns `null` and the full prefix-sum walk runs.
+            sparseExceptionsFn: ()=>rowSizeSource.isUniform() ? this.oversizedRows : null,
+            onBuildFn: ()=>{
+                _class_private_field_set(this, _rowFirstRenderedAtBuild, wtTable.getFirstRenderedRow());
+            }
+        });
+        /**
+     * Cumulative column width prefix sum cache. Enables O(log n) scroll-to-column lookups
+     * when custom column widths are configured.
+     *
+     * @type {PositionCache}
+     */ this.columnWidthCache = new _positionCache.PositionCache({
+            totalItemsFn: ()=>wtSettings.getSetting('totalColumns'),
+            sizeFn: (sourceCol)=>wtTable.getColumnWidth(sourceCol),
+            // Read the default through the size source (the `defaultColumnWidth` setting) — the same
+            // fallback the overlays' `sumCellSizes` used before they delegated to this cache — so a
+            // consumer-overridden default keeps scroll offsets and calculators in agreement.
+            defaultSizeFn: ()=>columnSizeSource.getDefaultSize(),
+            // Uniform fast path: every column is the default width only when the source reports it (no
+            // per-column `colWidths`, no `modifyColWidth` hook — note `autoColumnSize` is on by default and
+            // registers that hook, so this is true only when `colWidths` is set).
+            isUniformFn: ()=>columnSizeSource.isUniform()
+        });
+        this.eventManager = deps.eventManager;
+        this.eventManager.addEventListener(_class_private_field_get(this, _deps).rootWindow, 'resize', ()=>{
+            this.clientHeight = this.getWorkspaceHeight();
+            this.invalidateLayout();
+        });
+    }
+}
+(0, _object.mixin)(Viewport, _workspaceSize.workspaceSize);
+(0, _object.mixin)(Viewport, _calculatorFactory.calculatorFactory);
+const _default = Viewport;