handsontable 18.0.0 → 18.1.0-rc7

package/3rdparty/walkontable/src/overlay/scroll/scrollSync.mjs

@@ -0,0 +1,557 @@
+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 _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 { getScrollableElement, isHTMLElement } from '../../../../../helpers/dom/element.mjs';
+/**
+ * Assembles the ScrollSync's dependencies. Most come from the engine composition context; the ones
+ * that drive the owning Overlays coordinator (`refreshAll`/`registerListeners`/`eventManager`/the
+ * `destroyed` flag) and the sticky-scroll strategy (`tryActivate`/`syncOffsets`) come from the
+ * Overlays instance and its already-built `StickyScrollStrategy` — passed as callbacks so ScrollSync
+ * never imports either at runtime (only as a type), keeping the scroll slice free of an overlay cycle.
+ *
+ * @param {EngineContext} ctx The engine composition context.
+ * @param {Overlays} overlays The owning Overlays coordinator.
+ * @param {StickyScrollStrategy} stickyScroll The overlays' sticky-scroll strategy.
+ * @returns {object} The ScrollSync dependency set.
+ */ export function createScrollSyncDeps(ctx, overlays, stickyScroll) {
+    return {
+        wtSettings: ctx.wtSettings,
+        rootWindow: ctx.rootWindow,
+        geometryReader: ctx.geometryReader,
+        wtTable: ctx.getWtTable(),
+        getWtViewport: ctx.getWtViewport,
+        // Resolve the overlays off the owning coordinator (its own fields set by `initOverlays`), not via
+        // `ctx.getTopOverlay` (which reads `wot.wtOverlays`): `cacheScrollCallbackPositions` runs inside
+        // the Overlays constructor, before `wot.wtOverlays` is assigned. Matches the original direct
+        // `this.topOverlay` access.
+        getTopOverlay: ()=>overlays.topOverlay,
+        getInlineStartOverlay: ()=>overlays.inlineStartOverlay,
+        getBottomOverlay: ()=>overlays.bottomOverlay,
+        eventManager: overlays.eventManager,
+        getDestroyed: ()=>overlays.destroyed,
+        refreshAll: ()=>overlays.refreshAll(),
+        registerListeners: ()=>overlays.registerListeners(),
+        tryActivateStickyScroll: (verticalScrolling, horizontalScrolling)=>stickyScroll.tryActivate(verticalScrolling, horizontalScrolling),
+        syncStickyScrollOffsets: ()=>stickyScroll.syncOffsets()
+    };
+}
+var _deps = /*#__PURE__*/ new WeakMap(), /**
+   * The element that scrolls the table (the trimming container or the window).
+   *
+   * @type {HTMLElement | Window}
+   */ _scrollableElement = /*#__PURE__*/ new WeakMap(), /**
+   * Whether `#scrollableElement` was resolved while the table generated no boxes, which makes it an
+   * answer taken against nothing.
+   *
+   * Cleared by the first resolution pass that settles it, and also by a pass that gives up because the
+   * answer stopped changing – the two helpers behind it can disagree permanently. Covers the scrolling
+   * element only; the sizes measured in that state are tracked separately, by
+   * `#sizesMeasuredBeforeLayoutSettled`.
+   *
+   * @type {boolean}
+   */ _isScrollableElementProvisional = /*#__PURE__*/ new WeakMap(), /**
+   * The scrolling element the last non-settling resolution pass computed, so a pass that computes the
+   * same answer again can stop retrying.
+   *
+   * @type {HTMLElement | Window | null}
+   */ _lastProvisionalScrollableElement = /*#__PURE__*/ new WeakMap(), /**
+   * Whether the sizes measured before the layout settled still have to be dropped, which the next
+   * draw does on its way in. Stays set until a draw has rendered the cell band and re-measured them
+   * (`confirmSizesRemeasured`), so a draw whose `skipRender` hook cancels the render cannot spend it.
+   *
+   * @type {boolean}
+   */ _sizesMeasuredBeforeLayoutSettled = /*#__PURE__*/ new WeakMap(), /**
+   * Whether a drop has run and is still waiting for a draw to re-measure what it invalidated. The
+   * mark above is spent only while this is set, so a draw that renders the cells without having
+   * dropped anything cannot spend it – which is what an entry-fast draw that `createCalculators`
+   * escalates to a full render does: it passed the reset gate as a scroll draw and the render gate
+   * as a full one.
+   *
+   * @type {boolean}
+   */ _sizesAwaitingRemeasure = /*#__PURE__*/ new WeakMap(), /**
+   * Whether a vertical scroll happened in the current frame.
+   *
+   * @type {boolean}
+   */ _verticalScrolling = /*#__PURE__*/ new WeakMap(), /**
+   * Whether a horizontal scroll happened in the current frame.
+   *
+   * @type {boolean}
+   */ _horizontalScrolling = /*#__PURE__*/ new WeakMap(), /**
+   * The last synchronized horizontal scroll offset.
+   *
+   * @type {number}
+   */ _lastScrollX = /*#__PURE__*/ new WeakMap(), /**
+   * The last synchronized vertical scroll offset.
+   *
+   * @type {number}
+   */ _lastScrollY = /*#__PURE__*/ new WeakMap(), /**
+   * Whether any overlay's rendering state changed in the current draw (drives `syncScrollWithMaster`).
+   *
+   * @type {boolean}
+   */ _hasRenderingStateChanged = /*#__PURE__*/ new WeakMap(), /**
+   * Cached vertical scroll position used to deduplicate `onScrollVertically` callbacks.
+   *
+   * @type {number | null}
+   */ _lastVerticalScrollPositionForCallback = /*#__PURE__*/ new WeakMap(), /**
+   * Cached horizontal scroll position used to deduplicate `onScrollHorizontally` callbacks.
+   *
+   * @type {number | null}
+   */ _lastHorizontalScrollPositionForCallback = /*#__PURE__*/ new WeakMap(), /**
+   * Checks whether the vertical scroll position has changed since the last `onScrollVertically`
+   * callback and updates the cache. Returns `true` when the callback should fire.
+   *
+   * @returns {boolean}
+   */ _didVerticalScrollPositionChange = /*#__PURE__*/ new WeakSet(), /**
+   * Checks whether the horizontal scroll position has changed since the last `onScrollHorizontally`
+   * callback and updates the cache. Returns `true` when the callback should fire.
+   *
+   * @returns {boolean}
+   */ _didHorizontalScrollPositionChange = /*#__PURE__*/ new WeakSet(), /**
+   * Resolves the scrolling element and records whether the answer is provisional.
+   *
+   * A table outside the layout resolves every ancestor style to an empty declaration, which reads as
+   * "no ancestor clips or scrolls" and hands the whole grid to the window. A provisional answer is
+   * retaken on the next draw that finds the table rendered (see `Overlays#afterDraw`).
+   *
+   * Re-arming the flag starts a fresh series of retries, so the answer an earlier series gave up on
+   * is forgotten with it: `updateMainScrollableElements()` is public and `updateSettings` calls it
+   * whenever `height` moves to or from `''`, so a grid that already gave up while it was outside the
+   * layout would otherwise match its own stale answer on the first retry and give up again at once.
+   *
+   * @returns {HTMLElement | Window}
+   */ _takeScrollableElement = /*#__PURE__*/ new WeakSet(), /**
+   * Computes the element that scrolls the table: the master holder when the trimming container clips
+   * overflow, otherwise the nearest scrollable ancestor of the master TABLE.
+   *
+   * Answers the question and nothing else. Whether the answer is provisional is recorded by the
+   * callers, which is also where a provisional answer is acted on.
+   *
+   * @returns {HTMLElement | Window}
+   */ _computeScrollableElement = /*#__PURE__*/ new WeakSet();
+/**
+ * Owns the scroll state shared across the overlays and the master<->clone scroll synchronization:
+ * which element scrolls the table (`scrollableElement`), the per-frame scroll-direction flags, the
+ * last scroll offsets, and the callback-position cache that deduplicates the `onScroll*` hooks.
+ *
+ * It reacts to a scroll event by mirroring the master scroll position onto the overlay clone holders
+ * (`syncScrollPositions`), pushes the master scroll position onto the clones after a rendering-state
+ * change (`syncScrollWithMaster`), and recomputes the scrollable element + re-binds listeners when
+ * the trimming container changes (`updateMainScrollableElements`).
+ *
+ * Extracted from the Overlays coordinator so the scroll-position lifecycle is self-contained; the
+ * coordinator keeps thin public delegates and get/set accessors for the state that its own draw
+ * participation and the whitebox tests rely on.
+ *
+ * @class ScrollSync
+ */ export class ScrollSync {
+    /**
+   * The element that scrolls the table.
+   *
+   * @returns {HTMLElement | Window}
+   */ get scrollableElement() {
+        return _class_private_field_get(this, _scrollableElement);
+    }
+    /**
+   * Whether the scrollable element was resolved against a table that had no layout at that moment,
+   * so the answer is provisional and has to be retaken once the table is rendered.
+   *
+   * @returns {boolean}
+   */ get isScrollableElementProvisional() {
+        return _class_private_field_get(this, _isScrollableElementProvisional);
+    }
+    /**
+   * Whether a vertical scroll happened in the current frame.
+   *
+   * @returns {boolean}
+   */ get verticalScrolling() {
+        return _class_private_field_get(this, _verticalScrolling);
+    }
+    /**
+   * @param {boolean} value Whether a vertical scroll happened in the current frame.
+   */ set verticalScrolling(value) {
+        _class_private_field_set(this, _verticalScrolling, value);
+    }
+    /**
+   * Whether a horizontal scroll happened in the current frame.
+   *
+   * @returns {boolean}
+   */ get horizontalScrolling() {
+        return _class_private_field_get(this, _horizontalScrolling);
+    }
+    /**
+   * @param {boolean} value Whether a horizontal scroll happened in the current frame.
+   */ set horizontalScrolling(value) {
+        _class_private_field_set(this, _horizontalScrolling, value);
+    }
+    /**
+   * Records whether any overlay's rendering state changed in the current draw. Set from the
+   * coordinator's `beforeDraw`; consumed by `syncScrollWithMaster`.
+   *
+   * @param {boolean} value Whether any overlay's rendering state changed.
+   */ setRenderingStateChanged(value) {
+        _class_private_field_set(this, _hasRenderingStateChanged, value);
+    }
+    /**
+   * Caches the initial vertical and horizontal scroll positions for callback deduplication.
+   */ cacheScrollCallbackPositions() {
+        _class_private_field_set(this, _lastVerticalScrollPositionForCallback, _class_private_field_get(this, _deps).getTopOverlay().getScrollPosition());
+        _class_private_field_set(this, _lastHorizontalScrollPositionForCallback, _class_private_field_get(this, _deps).getInlineStartOverlay().getScrollPosition());
+    }
+    /**
+   * Synchronize scroll position between master table and overlay table.
+   */ syncScrollPositions() {
+        if (_class_private_field_get(this, _deps).getDestroyed()) {
+            return;
+        }
+        const topOverlay = _class_private_field_get(this, _deps).getTopOverlay();
+        const inlineStartOverlay = _class_private_field_get(this, _deps).getInlineStartOverlay();
+        const bottomOverlay = _class_private_field_get(this, _deps).getBottomOverlay();
+        const wtViewport = _class_private_field_get(this, _deps).getWtViewport();
+        const { wtSettings } = _class_private_field_get(this, _deps);
+        const scrollableElement = _class_private_field_get(this, _scrollableElement);
+        const topHolder = topOverlay.clone?.wtTable.holder; // todo rethink
+        const leftHolder = inlineStartOverlay.clone?.wtTable.holder; // todo rethink
+        const preventOverflow = wtSettings.getSetting('preventOverflow');
+        let scrollX = scrollableElement instanceof HTMLElement ? scrollableElement.scrollLeft : 0;
+        let scrollY = scrollableElement instanceof HTMLElement ? scrollableElement.scrollTop : 0;
+        if (wtViewport.isHorizontallyScrollableByWindow() && (typeof preventOverflow === 'boolean' && preventOverflow || preventOverflow !== 'horizontal') && scrollableElement instanceof Window) {
+            scrollX = scrollableElement.scrollX;
+        }
+        if (wtViewport.isVerticallyScrollableByWindow() && (typeof preventOverflow === 'boolean' && preventOverflow || preventOverflow !== 'vertical') && scrollableElement instanceof Window) {
+            scrollY = scrollableElement.scrollY;
+        }
+        _class_private_field_set(this, _horizontalScrolling, _class_private_field_get(this, _lastScrollX) !== scrollX);
+        _class_private_field_set(this, _verticalScrolling, _class_private_field_get(this, _lastScrollY) !== scrollY);
+        _class_private_field_set(this, _lastScrollX, scrollX);
+        _class_private_field_set(this, _lastScrollY, scrollY);
+        _class_private_field_get(this, _deps).tryActivateStickyScroll(_class_private_field_get(this, _verticalScrolling), _class_private_field_get(this, _horizontalScrolling));
+        if (_class_private_field_get(this, _horizontalScrolling)) {
+            if (isHTMLElement(topHolder)) {
+                topHolder.scrollLeft = scrollX;
+            }
+            const bottomHolder = bottomOverlay.needFullRender ? bottomOverlay.clone?.wtTable.holder : null; // todo rethink
+            if (bottomHolder) {
+                bottomHolder.scrollLeft = scrollX;
+            }
+        }
+        if (_class_private_field_get(this, _verticalScrolling)) {
+            // In window-scroll mode the left overlay's row positions are driven by
+            // spreader.style.top; the holder must not accumulate scroll offset.
+            // Setting scrollTop to window.scrollY would be capped to the tiny
+            // hider/holder size difference caused by fractional zoom rounding,
+            // shifting the visible rows and misaligning them with the master table.
+            if (isHTMLElement(leftHolder)) {
+                if (wtViewport.isVerticallyScrollableByWindow()) {
+                    leftHolder.scrollTop = 0;
+                } else {
+                    leftHolder.scrollTop = scrollY;
+                }
+            }
+        }
+        _class_private_field_get(this, _deps).refreshAll();
+        _class_private_field_get(this, _deps).syncStickyScrollOffsets();
+    }
+    /**
+   * Fires the `onScroll*` overlay hooks when the scroll position changed since they last fired, then
+   * resets the per-frame scroll-direction flags. Called by the coordinator from `refreshAll`.
+   */ fireScrollCallbacksAndReset() {
+        if (_class_private_field_get(this, _verticalScrolling) && _class_private_method_get(this, _didVerticalScrollPositionChange, didVerticalScrollPositionChange).call(this)) {
+            _class_private_field_get(this, _deps).getInlineStartOverlay().onScroll(); // todo the inlineStartOverlay.onScroll() fires hook. Why is it needed there, not in any another place?
+        }
+        if (_class_private_field_get(this, _horizontalScrolling) && _class_private_method_get(this, _didHorizontalScrollPositionChange, didHorizontalScrollPositionChange).call(this)) {
+            _class_private_field_get(this, _deps).getTopOverlay().onScroll();
+        }
+        _class_private_field_set(this, _verticalScrolling, false);
+        _class_private_field_set(this, _horizontalScrolling, false);
+    }
+    /**
+   * Synchronize overlay scrollbars with the master scrollbar.
+   */ syncScrollWithMaster() {
+        if (!_class_private_field_get(this, _hasRenderingStateChanged)) {
+            return;
+        }
+        const topOverlay = _class_private_field_get(this, _deps).getTopOverlay();
+        const bottomOverlay = _class_private_field_get(this, _deps).getBottomOverlay();
+        const inlineStartOverlay = _class_private_field_get(this, _deps).getInlineStartOverlay();
+        const masterScrollable = topOverlay.mainTableScrollableElement;
+        if (!(masterScrollable instanceof HTMLElement)) {
+            return;
+        }
+        const { scrollLeft, scrollTop } = masterScrollable;
+        if (topOverlay.needFullRender && topOverlay.clone) {
+            topOverlay.clone.wtTable.holder.scrollLeft = scrollLeft; // todo rethink, *overlay.setScroll*()
+        }
+        if (bottomOverlay.needFullRender && bottomOverlay.clone) {
+            bottomOverlay.clone.wtTable.holder.scrollLeft = scrollLeft; // todo rethink, *overlay.setScroll*()
+        }
+        if (inlineStartOverlay.needFullRender && inlineStartOverlay.clone) {
+            inlineStartOverlay.clone.wtTable.holder.scrollTop = scrollTop; // todo rethink, *overlay.setScroll*()
+        }
+        _class_private_field_set(this, _hasRenderingStateChanged, false);
+    }
+    /**
+   * Drops the sizes measured before the layout settled, if `resolveProvisionalLayout()` found any.
+   *
+   * Called from `Overlays#beforeDraw`, so the draw that follows re-measures the row heights it just
+   * invalidated and resizes the elements from the results. Doing it the other way round – dropping
+   * the sizes and then asking for a redraw – leaves the row heights dropped for good whenever that
+   * redraw renders no cells.
+   *
+   * "Sizes" is the engine's own record of them: the oversized-row heights and the column-width
+   * prefix sum. A rebuilt width cache re-asks `wtTable.getColumnWidth`, so it re-enters
+   * `modifyColWidth` and `AutoColumnSize` answers from its own map – a width that plugin measured
+   * while the table had no layout is not dropped by this and outlives the settle. That gap is the
+   * narrow-container `AutoColumnSize` follow-up, filed separately.
+   *
+   * The mark is not spent here, because a draw that got this far can still render nothing: a
+   * `beforeDraw` hook that sets `skipRender` (NestedRows does this, and so can any user hook) cancels
+   * the cell render, and then `markOversizedRows` never runs to take the heights again. It is spent
+   * by `confirmSizesRemeasured()`, from the `afterDraw` of a draw that did render the band. The drop
+   * is idempotent, so repeating it on the next draw costs one invalidation.
+   */ resetSizesMeasuredBeforeLayoutSettled() {
+        if (!_class_private_field_get(this, _sizesMeasuredBeforeLayoutSettled)) {
+            return;
+        }
+        _class_private_field_set(this, _sizesAwaitingRemeasure, true);
+        const wtViewport = _class_private_field_get(this, _deps).getWtViewport();
+        wtViewport.resetAllOversizedRows();
+        wtViewport.invalidateColumnWidthCache();
+    }
+    /**
+   * Spends the mark left by `resolveProvisionalLayout()`, once a draw has rendered the cell band and
+   * therefore re-measured the sizes that `resetSizesMeasuredBeforeLayoutSettled()` dropped on its way
+   * in. Called from `Overlays#afterDraw`.
+   *
+   * A draw that rendered the cells without having dropped anything spends nothing: the two gates read
+   * different values of the same fast/full question (the reset gate reads it at draw entry, the render
+   * gate after `createCalculators` could downgrade it), so an escalated scroll draw satisfies the
+   * second without ever passing the first.
+   */ confirmSizesRemeasured() {
+        if (!_class_private_field_get(this, _sizesAwaitingRemeasure)) {
+            return;
+        }
+        _class_private_field_set(this, _sizesAwaitingRemeasure, false);
+        _class_private_field_set(this, _sizesMeasuredBeforeLayoutSettled, false);
+    }
+    /**
+   * Settles the layout decisions and measurements of a table that was constructed while it had no
+   * layout – most often a light-DOM child of a shadow host whose `<slot>` renders later, or a subtree
+   * assembled before it was appended to the document. Such a table reads every ancestor style as an
+   * empty declaration and measures every size against nothing, so two things are wrong at once:
+   * the scrollable element resolves to the window, and the row heights and column widths describe a
+   * layout the table never had.
+   *
+   * Runs from the `afterDraw` of a full draw, so the overlays have already refreshed their trimming
+   * containers and the holder has its final overflow; in `beforeDraw`, and on a fast draw that never
+   * aligned the overlays at all, both are still stale and the scrollable element would settle on the
+   * window again. While the answer is still the window even though an element
+   * trims the table, the layout has not settled yet and the pass is retried on the next draw – but
+   * only while the answer keeps changing. `getTrimmingContainer` counts `overflow: hidden` and
+   * `getScrollableElement` does not, so the two can disagree permanently, and a table in an iframe
+   * driven from the parent realm does exactly that: `MasterTable#alignOverlaysWithTrimmingContainer`
+   * misses it with a realm-bound `instanceof` and leaves the holder `overflow: visible`. Retrying
+   * such a table forever would rebind every listener on every draw.
+   *
+   * Once it does settle, the sizes measured before it are marked for dropping, which the next draw
+   * does on its way in (`resetSizesMeasuredBeforeLayoutSettled`). Left in place they survive until
+   * something else redraws the grid, which is what made it fill short of its container and look like
+   * it needed a click to finish loading (DEV-2515).
+   */ resolveProvisionalLayout() {
+        if (!_class_private_field_get(this, _isScrollableElementProvisional) || !_class_private_field_get(this, _deps).geometryReader.isRendered(_class_private_field_get(this, _deps).wtTable.wtRootElement)) {
+            return;
+        }
+        const { rootWindow } = _class_private_field_get(this, _deps);
+        const scrollableElement = _class_private_method_get(this, _computeScrollableElement, computeScrollableElement).call(this);
+        const settles = scrollableElement !== rootWindow || _class_private_field_get(this, _deps).getTopOverlay().trimmingContainer === rootWindow;
+        if (!settles) {
+            // The answer is checked before anything is rebound, so a pass that cannot settle costs one
+            // style read. Retry only while the answer keeps changing: a repeated answer is what a
+            // permanent disagreement between the two helpers looks like, and rebinding the listeners on
+            // every draw would drop every in-flight scroll event for the instance's life.
+            _class_private_field_set(this, _isScrollableElementProvisional, scrollableElement !== _class_private_field_get(this, _lastProvisionalScrollableElement));
+            _class_private_field_set(this, _lastProvisionalScrollableElement, scrollableElement);
+            return;
+        }
+        this.updateMainScrollableElements();
+        // The sizes are not dropped here. Dropping them after a draw leaves them dropped: the follow-up
+        // is a redraw request, and a draw that re-renders nothing never re-runs `markOversizedRows`, so
+        // the row heights this pass invalidated would never be taken again. The next draw drops them on
+        // its way in instead, so reset, re-measure and resize run in the order the draw cycle documents.
+        _class_private_field_set(this, _sizesMeasuredBeforeLayoutSettled, true);
+    // No redraw is requested from here. The flag stays set until a draw consumes it, and settling
+    // means the root element went from no layout to a layout, which is a size change the grid already
+    // observes and redraws for. Forcing a draw from this frame instead measures a DOM whose column
+    // widths have not settled: it records row heights for rows that leave the band on the next draw,
+    // and those records survive – measured as 6 rendered rows and 56px of dead space where 9 rows
+    // belong.
+    }
+    /**
+   * Update the main scrollable elements for all the overlays.
+   */ updateMainScrollableElements() {
+        _class_private_field_get(this, _deps).eventManager.clearEvents(true);
+        _class_private_field_get(this, _deps).getInlineStartOverlay().updateMainScrollableElement();
+        _class_private_field_get(this, _deps).getTopOverlay().updateMainScrollableElement();
+        if (_class_private_field_get(this, _deps).getBottomOverlay().needFullRender) {
+            _class_private_field_get(this, _deps).getBottomOverlay().updateMainScrollableElement();
+        }
+        _class_private_field_set(this, _scrollableElement, _class_private_method_get(this, _takeScrollableElement, takeScrollableElement).call(this));
+        _class_private_field_get(this, _deps).registerListeners();
+    }
+    /**
+   * @param {ScrollSyncDeps} deps The ScrollSync dependencies.
+   */ constructor(deps){
+        _class_private_method_init(this, _didVerticalScrollPositionChange);
+        _class_private_method_init(this, _didHorizontalScrollPositionChange);
+        _class_private_method_init(this, _takeScrollableElement);
+        _class_private_method_init(this, _computeScrollableElement);
+        /**
+   * The ScrollSync dependencies.
+   *
+   * @type {ScrollSyncDeps}
+   */ _class_private_field_init(this, _deps, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _scrollableElement, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _isScrollableElementProvisional, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _lastProvisionalScrollableElement, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _sizesMeasuredBeforeLayoutSettled, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _sizesAwaitingRemeasure, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _verticalScrolling, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _horizontalScrolling, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _lastScrollX, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _lastScrollY, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _hasRenderingStateChanged, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _lastVerticalScrollPositionForCallback, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _lastHorizontalScrollPositionForCallback, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_set(this, _isScrollableElementProvisional, false);
+        _class_private_field_set(this, _lastProvisionalScrollableElement, null);
+        _class_private_field_set(this, _sizesMeasuredBeforeLayoutSettled, false);
+        _class_private_field_set(this, _sizesAwaitingRemeasure, false);
+        _class_private_field_set(this, _verticalScrolling, false);
+        _class_private_field_set(this, _horizontalScrolling, false);
+        _class_private_field_set(this, _hasRenderingStateChanged, false);
+        _class_private_field_set(this, _lastVerticalScrollPositionForCallback, null);
+        _class_private_field_set(this, _lastHorizontalScrollPositionForCallback, null);
+        _class_private_field_set(this, _deps, deps);
+        _class_private_field_set(this, _scrollableElement, _class_private_method_get(this, _takeScrollableElement, takeScrollableElement).call(this));
+        _class_private_field_set(this, _lastScrollX, _class_private_field_get(this, _deps).rootWindow.scrollX);
+        _class_private_field_set(this, _lastScrollY, _class_private_field_get(this, _deps).rootWindow.scrollY);
+    }
+}
+function didVerticalScrollPositionChange() {
+    const current = _class_private_field_get(this, _deps).getTopOverlay().getScrollPosition();
+    if (_class_private_field_get(this, _lastVerticalScrollPositionForCallback) === current) {
+        return false;
+    }
+    _class_private_field_set(this, _lastVerticalScrollPositionForCallback, current);
+    return true;
+}
+function didHorizontalScrollPositionChange() {
+    const current = _class_private_field_get(this, _deps).getInlineStartOverlay().getScrollPosition();
+    if (_class_private_field_get(this, _lastHorizontalScrollPositionForCallback) === current) {
+        return false;
+    }
+    _class_private_field_set(this, _lastHorizontalScrollPositionForCallback, current);
+    return true;
+}
+function takeScrollableElement() {
+    const { wtTable, geometryReader } = _class_private_field_get(this, _deps);
+    _class_private_field_set(this, _isScrollableElementProvisional, !geometryReader.isRendered(wtTable.wtRootElement));
+    _class_private_field_set(this, _lastProvisionalScrollableElement, null);
+    return _class_private_method_get(this, _computeScrollableElement, computeScrollableElement).call(this);
+}
+function computeScrollableElement() {
+    const { wtTable, geometryReader } = _class_private_field_get(this, _deps);
+    const tableParentNode = wtTable.wtRootElement.parentNode;
+    // Use nodeType === 1 instead of instanceof Element so the check works across realms (iframes).
+    // Falls back to getScrollableElement when there is no element parent (null or detached).
+    const isOverflowClip = tableParentNode !== null && tableParentNode.nodeType === 1 && (()=>{
+        const overflow = geometryReader.getComputedStyle(tableParentNode).getPropertyValue('overflow');
+        return overflow === 'hidden' || overflow === 'clip';
+    })();
+    return isOverflowClip ? wtTable.holder : getScrollableElement(wtTable.TABLE);
+}

package/3rdparty/walkontable/src/overlay/spreaderSize.d.mts

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

package/3rdparty/walkontable/src/overlay/spreaderSize.d.ts

@@ -0,0 +1,67 @@
+import type { EngineContext } from '../wire';
+import type { default as Overlays } from './overlays';
+/**
+ * Assembles the SpreaderSize's dependencies. Most come from the engine composition context; the
+ * scrollable element is resolved through the owning Overlays instance (it is computed there and can
+ * change on `updateSettings`), so it is read via a thunk rather than captured.
+ *
+ * @param {EngineContext} ctx The engine composition context.
+ * @param {Overlays} overlays The owning Overlays coordinator.
+ * @returns {object} The SpreaderSize dependency set.
+ */
+export declare function createSpreaderSizeDeps(ctx: EngineContext, overlays: Overlays): {
+    wtSettings: import("../settings").default;
+    rootWindow: Window;
+    geometryReader: import("../domMeasure/geometryReader").GeometryReader;
+    wtTable: import("../table/baseTable").default;
+    getWtViewport: () => import("../viewport/viewport").default;
+    getTopOverlay: () => import(".").Overlay;
+    getInlineStartOverlay: () => import(".").Overlay;
+    getBottomOverlay: () => import(".").Overlay;
+    getScrollableElement: () => HTMLElement | Window;
+};
+/**
+ * The SpreaderSize dependencies, inferred from `createSpreaderSizeDeps`.
+ */
+export type SpreaderSizeDeps = ReturnType<typeof createSpreaderSizeDeps>;
+/**
+ * Owns the master hider/spreader sizing math: it computes the hider's width/height from the summed
+ * cell sizes (plus the header sizes and the border compensations), writes them to the DOM, and then
+ * delegates to the top/inline-start/bottom overlays to size their own elements. It also caches the
+ * last measured spreader size so the coordinator can skip a redundant resize when nothing changed.
+ *
+ * Extracted from the Overlays coordinator so the sizing lifecycle is self-contained; the coordinator
+ * keeps thin public `adjustElementsSize`/`updateLastSpreaderSize`/`expandHider*` delegates because
+ * those are part of the public overlay API.
+ *
+ * @class SpreaderSize
+ */
+export declare class SpreaderSize {
+    #private;
+    /**
+     * @param {SpreaderSizeDeps} deps The SpreaderSize dependencies.
+     */
+    constructor(deps: SpreaderSizeDeps);
+    /**
+     * Update the last cached spreader size with the current size.
+     *
+     * @returns {boolean} `true` if the lastSize cache was updated, `false` otherwise.
+     */
+    updateLastSpreaderSize(): boolean;
+    /**
+     * Adjust overlays elements size and master table size.
+     */
+    adjustElementsSize(): void;
+    /**
+     * Expand the hider vertically element by the provided delta value.
+     *
+     * @param {number} heightDelta The delta value to expand the hider element by.
+     */
+    expandHiderVerticallyBy(heightDelta: number): void;
+    /**
+     * Expand the hider horizontally element by the provided delta value.
+     *
+     * @param {number} widthDelta The delta value to expand the hider element by.
+     */
+    expandHiderHorizontallyBy(widthDelta: number): void;
+}