handsontable 18.0.0 → 18.1.0-rc7

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

@@ -0,0 +1,295 @@
+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 { isKey } from '../../../../../helpers/unicode.mjs';
+import { eventTargetEl } from '../../../../../helpers/dom/element.mjs';
+import { requestAnimationFrame } from '../../../../../helpers/feature.mjs';
+/**
+ * Type predicate that checks whether a WheelEvent carries the legacy
+ * non-standard `wheelDeltaX`/`wheelDeltaY` properties emitted by older browsers.
+ *
+ * @param {WheelEvent} event The wheel event to test.
+ * @returns {boolean}
+ */ function isWheelEventWithLegacyDelta(event) {
+    return 'wheelDeltaY' in event || 'wheelDeltaX' in event;
+}
+/**
+ * Assembles the NativeScrollInput's dependencies. The overlays are resolved off the owning
+ * coordinator (its own fields set by `initOverlays`), and the sticky-scroll strategy + resize monitor
+ * are passed as the already-built instances so their listener hooks can be re-registered from here.
+ * ScrollSync's `syncScrollPositions` and the coordinator's scrollable element are reached via
+ * callbacks, so this module type-imports Overlays/StickyScrollStrategy/ResizeMonitor only.
+ *
+ * @param {EngineContext} ctx The engine composition context.
+ * @param {Overlays} overlays The owning Overlays coordinator.
+ * @param {StickyScrollStrategy} stickyScroll The overlays' sticky-scroll strategy.
+ * @param {ResizeMonitor} resizeMonitor The overlays' container-resize monitor.
+ * @returns {object} The NativeScrollInput dependency set.
+ */ export function createNativeScrollInputDeps(ctx, overlays, stickyScroll, resizeMonitor) {
+    return {
+        wtSettings: ctx.wtSettings,
+        rootDocument: ctx.rootDocument,
+        rootWindow: ctx.rootWindow,
+        geometryReader: ctx.geometryReader,
+        wtTable: ctx.getWtTable(),
+        eventManager: overlays.eventManager,
+        getTopOverlay: ()=>overlays.topOverlay,
+        getInlineStartOverlay: ()=>overlays.inlineStartOverlay,
+        getCloneableOverlays: ()=>[
+                overlays.topOverlay,
+                overlays.bottomOverlay,
+                overlays.inlineStartOverlay,
+                overlays.topInlineStartCornerOverlay,
+                overlays.bottomInlineStartCornerOverlay
+            ],
+        getScrollableElement: ()=>overlays.scrollableElement,
+        syncScrollPositions: ()=>overlays.syncScrollPositions(),
+        scrollVertically: (delta)=>overlays.scrollVertically(delta),
+        scrollHorizontally: (delta)=>overlays.scrollHorizontally(delta),
+        registerStickyScrollListeners: ()=>stickyScroll.registerListeners(),
+        resetResizeCount: ()=>resizeMonitor.resetResizeCount(),
+        observeResize: ()=>resizeMonitor.observe()
+    };
+}
+var _deps = /*#__PURE__*/ new WeakMap(), /**
+   * Whether an arrow key is currently pressed.
+   *
+   * @type {boolean}
+   */ _keyPressed = /*#__PURE__*/ new WeakMap(), /**
+   * The browser's line height, used to convert line-based wheel deltas into pixels.
+   *
+   * @type {number}
+   */ _browserLineHeight = /*#__PURE__*/ new WeakMap(), /**
+   * Scroll listener.
+   *
+   * @param {Event} event The mouse event object.
+   */ _onTableScroll = /*#__PURE__*/ new WeakSet(), /**
+   * Wheel listener for cloned overlays.
+   *
+   * @param {Event} event The mouse event object.
+   * @param {boolean} preventDefault If `true`, the `preventDefault` will be called on event object.
+   */ _onCloneWheel = /*#__PURE__*/ new WeakSet(), /**
+   * Key down listener.
+   *
+   * @param {KeyboardEvent} event The keyboard event object.
+   */ _onKeyDown = /*#__PURE__*/ new WeakSet(), /**
+   * Key up listener.
+   */ _onKeyUp = /*#__PURE__*/ new WeakSet(), /**
+   * Translate wheel event into scroll event and sync scroll overlays position.
+   *
+   * @param {WheelEvent} event The mouse event object.
+   * @returns {boolean}
+   */ _translateMouseWheelToScroll = /*#__PURE__*/ new WeakSet(), /**
+   * Retrieve the browser line height, used to convert line-based wheel deltas into pixels.
+   *
+   * @returns {number}
+   */ _computeBrowserLineHeight = /*#__PURE__*/ new WeakSet();
+/**
+ * Binds the native DOM input listeners (scroll, wheel, keydown/keyup, window resize) and translates
+ * them into the engine's scroll actions: a scroll event syncs the master/clone positions, a wheel
+ * event over a clone is turned into a scroll of the master scrollable element, and arrow-key presses
+ * flip a flag so a keyboard-driven render only syncs master -> overlay.
+ *
+ * Extracted from the Overlays coordinator so the native-input lifecycle is self-contained; the
+ * coordinator keeps a thin public `registerListeners` delegate because ScrollSync re-registers the
+ * listeners when the scrollable element changes.
+ *
+ * @class NativeScrollInput
+ */ export class NativeScrollInput {
+    /**
+   * Register all necessary event listeners.
+   */ registerListeners() {
+        const { rootDocument, rootWindow, wtTable, wtSettings, eventManager } = _class_private_field_get(this, _deps);
+        const topOverlay = _class_private_field_get(this, _deps).getTopOverlay();
+        const inlineStartOverlay = _class_private_field_get(this, _deps).getInlineStartOverlay();
+        const { mainTableScrollableElement: topOverlayScrollableElement } = topOverlay;
+        const { mainTableScrollableElement: inlineStartOverlayScrollableElement } = inlineStartOverlay;
+        eventManager.addEventListener(rootDocument.documentElement, 'keydown', (event)=>_class_private_method_get(this, _onKeyDown, onKeyDown).call(this, event));
+        eventManager.addEventListener(rootDocument.documentElement, 'keyup', ()=>_class_private_method_get(this, _onKeyUp, onKeyUp).call(this));
+        eventManager.addEventListener(rootDocument, 'visibilitychange', ()=>_class_private_method_get(this, _onKeyUp, onKeyUp).call(this));
+        _class_private_field_get(this, _deps).registerStickyScrollListeners();
+        eventManager.addEventListener(topOverlayScrollableElement, 'scroll', (event)=>_class_private_method_get(this, _onTableScroll, onTableScroll).call(this, event), {
+            passive: true
+        });
+        if (topOverlayScrollableElement !== inlineStartOverlayScrollableElement) {
+            eventManager.addEventListener(inlineStartOverlayScrollableElement, 'scroll', (event)=>_class_private_method_get(this, _onTableScroll, onTableScroll).call(this, event), {
+                passive: true
+            });
+        }
+        const isScrollOnWindow = _class_private_field_get(this, _deps).getScrollableElement() === rootWindow;
+        const preventWheel = wtSettings.getSetting('preventWheel');
+        const wheelEventOptions = {
+            passive: isScrollOnWindow
+        };
+        eventManager.addEventListener(wtTable.wtRootElement, 'wheel', (event)=>_class_private_method_get(this, _onCloneWheel, onCloneWheel).call(this, event, preventWheel), wheelEventOptions);
+        _class_private_field_get(this, _deps).getCloneableOverlays().forEach((overlay)=>{
+            if (!overlay.clone) {
+                return;
+            }
+            eventManager.addEventListener(overlay.clone.wtTable.holder, 'wheel', (event)=>_class_private_method_get(this, _onCloneWheel, onCloneWheel).call(this, event, preventWheel), wheelEventOptions);
+        });
+        let resizeTimeout;
+        eventManager.addEventListener(rootWindow, 'resize', ()=>{
+            requestAnimationFrame(()=>{
+                clearTimeout(resizeTimeout);
+                wtSettings.getSetting('onWindowResize');
+                resizeTimeout = setTimeout(()=>{
+                    // Remove resizing the window from the ResizeObserver's endless-loop-blocking logic.
+                    _class_private_field_get(this, _deps).resetResizeCount();
+                }, 200);
+            });
+        });
+        if (!isScrollOnWindow) {
+            _class_private_field_get(this, _deps).observeResize();
+        }
+    }
+    /**
+   * @param {NativeScrollInputDeps} deps The NativeScrollInput dependencies.
+   */ constructor(deps){
+        _class_private_method_init(this, _onTableScroll);
+        _class_private_method_init(this, _onCloneWheel);
+        _class_private_method_init(this, _onKeyDown);
+        _class_private_method_init(this, _onKeyUp);
+        _class_private_method_init(this, _translateMouseWheelToScroll);
+        _class_private_method_init(this, _computeBrowserLineHeight);
+        /**
+   * The NativeScrollInput dependencies.
+   *
+   * @type {NativeScrollInputDeps}
+   */ _class_private_field_init(this, _deps, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _keyPressed, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _browserLineHeight, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_set(this, _keyPressed, false);
+        _class_private_field_set(this, _deps, deps);
+        _class_private_field_set(this, _browserLineHeight, _class_private_method_get(this, _computeBrowserLineHeight, computeBrowserLineHeight).call(this));
+    }
+}
+function onTableScroll(event) {
+    // There was if statement which controlled flow of this function. It avoided the execution of the next lines
+    // on mobile devices. It was changed. Broader description of this case is included within issue #4856.
+    const { rootWindow } = _class_private_field_get(this, _deps);
+    const masterHorizontal = _class_private_field_get(this, _deps).getInlineStartOverlay().mainTableScrollableElement;
+    const masterVertical = _class_private_field_get(this, _deps).getTopOverlay().mainTableScrollableElement;
+    const target = event.target;
+    // For key press, sync only master -> overlay position because while pressing Walkontable.render is triggered
+    // by hot.refreshBorder
+    if (_class_private_field_get(this, _keyPressed)) {
+        if (masterVertical !== rootWindow && target !== rootWindow && !(masterVertical instanceof HTMLElement && eventTargetEl(event).contains(masterVertical)) || masterHorizontal !== rootWindow && target !== rootWindow && !(masterHorizontal instanceof HTMLElement && eventTargetEl(event).contains(masterHorizontal))) {
+            return;
+        }
+    }
+    _class_private_field_get(this, _deps).syncScrollPositions();
+}
+function onCloneWheel(event, preventDefault) {
+    // Fix for Windows OS, where the ctrl key is used to zoom the page (issue #dev-2405).
+    if (event.ctrlKey) {
+        return;
+    }
+    const { rootWindow } = _class_private_field_get(this, _deps);
+    // There was if statement which controlled flow of this function. It avoided the execution of the next lines
+    // on mobile devices. It was changed. Broader description of this case is included within issue #4856.
+    const masterHorizontal = _class_private_field_get(this, _deps).getInlineStartOverlay().mainTableScrollableElement;
+    const masterVertical = _class_private_field_get(this, _deps).getTopOverlay().mainTableScrollableElement;
+    const target = event.target;
+    // For key press, sync only master -> overlay position because while pressing Walkontable.render is triggered
+    // by hot.refreshBorder
+    const shouldNotWheelVertically = masterVertical !== rootWindow && target !== rootWindow && !(target instanceof Node && masterVertical instanceof HTMLElement && target.contains(masterVertical));
+    const shouldNotWheelHorizontally = masterHorizontal !== rootWindow && target !== rootWindow && !(target instanceof Node && masterHorizontal instanceof HTMLElement && target.contains(masterHorizontal));
+    if (_class_private_field_get(this, _keyPressed) && (shouldNotWheelVertically || shouldNotWheelHorizontally) || _class_private_field_get(this, _deps).getScrollableElement() === rootWindow) {
+        return;
+    }
+    const isScrollPossible = _class_private_method_get(this, _translateMouseWheelToScroll, translateMouseWheelToScroll).call(this, event);
+    if (preventDefault || _class_private_field_get(this, _deps).getScrollableElement() !== rootWindow && isScrollPossible) {
+        event.preventDefault();
+    }
+}
+function onKeyDown(event) {
+    _class_private_field_set(this, _keyPressed, isKey(event.keyCode, 'ARROW_UP|ARROW_RIGHT|ARROW_DOWN|ARROW_LEFT'));
+}
+function onKeyUp() {
+    _class_private_field_set(this, _keyPressed, false);
+}
+function translateMouseWheelToScroll(event) {
+    let deltaY;
+    let deltaX;
+    if (isWheelEventWithLegacyDelta(event)) {
+        deltaY = isNaN(event.deltaY) ? -1 * (event.wheelDeltaY ?? 0) : event.deltaY;
+        deltaX = isNaN(event.deltaX) ? -1 * (event.wheelDeltaX ?? 0) : event.deltaX;
+    } else {
+        deltaY = event.deltaY;
+        deltaX = event.deltaX;
+    }
+    if (event.deltaMode === 1) {
+        deltaX += deltaX * _class_private_field_get(this, _browserLineHeight);
+        deltaY += deltaY * _class_private_field_get(this, _browserLineHeight);
+    }
+    const isScrollVerticallyPossible = _class_private_field_get(this, _deps).scrollVertically(deltaY);
+    const isScrollHorizontallyPossible = _class_private_field_get(this, _deps).scrollHorizontally(deltaX);
+    return isScrollVerticallyPossible || isScrollHorizontallyPossible;
+}
+function computeBrowserLineHeight() {
+    const { rootDocument, geometryReader } = _class_private_field_get(this, _deps);
+    const computedStyle = geometryReader.getComputedStyle(rootDocument.body);
+    /**
+     * Sometimes `line-height` might be set to 'normal'. In that case, a default `font-size` should be multiplied by roughly 1.2.
+     * Https://developer.mozilla.org/pl/docs/Web/CSS/line-height#Values.
+     */ const lineHeight = parseInt(computedStyle.lineHeight, 10);
+    const lineHeightFalback = parseInt(computedStyle.fontSize, 10) * 1.2;
+    return lineHeight || lineHeightFalback;
+}

package/3rdparty/walkontable/src/overlay/scroll/scrollSync.d.mts

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

package/3rdparty/walkontable/src/overlay/scroll/scrollSync.d.ts

@@ -0,0 +1,176 @@
+import type { EngineContext } from '../../wire';
+import type { default as Overlays } from '../overlays';
+import type { StickyScrollStrategy } from '../strategies/stickyScrollStrategy';
+/**
+ * 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 declare function createScrollSyncDeps(ctx: EngineContext, overlays: Overlays, stickyScroll: StickyScrollStrategy): {
+    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;
+    eventManager: import("../../../../../eventManager").default;
+    getDestroyed: () => boolean;
+    refreshAll: () => void;
+    registerListeners: () => void;
+    tryActivateStickyScroll: (verticalScrolling: boolean, horizontalScrolling: boolean) => void;
+    syncStickyScrollOffsets: () => void;
+};
+/**
+ * The ScrollSync dependencies, inferred from `createScrollSyncDeps`.
+ */
+export type ScrollSyncDeps = ReturnType<typeof createScrollSyncDeps>;
+/**
+ * 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 declare class ScrollSync {
+    #private;
+    /**
+     * @param {ScrollSyncDeps} deps The ScrollSync dependencies.
+     */
+    constructor(deps: ScrollSyncDeps);
+    /**
+     * The element that scrolls the table.
+     *
+     * @returns {HTMLElement | Window}
+     */
+    get scrollableElement(): HTMLElement | Window;
+    /**
+     * 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(): boolean;
+    /**
+     * Whether a vertical scroll happened in the current frame.
+     *
+     * @returns {boolean}
+     */
+    get verticalScrolling(): boolean;
+    /**
+     * @param {boolean} value Whether a vertical scroll happened in the current frame.
+     */
+    set verticalScrolling(value: boolean);
+    /**
+     * Whether a horizontal scroll happened in the current frame.
+     *
+     * @returns {boolean}
+     */
+    get horizontalScrolling(): boolean;
+    /**
+     * @param {boolean} value Whether a horizontal scroll happened in the current frame.
+     */
+    set horizontalScrolling(value: boolean);
+    /**
+     * 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: boolean): void;
+    /**
+     * Caches the initial vertical and horizontal scroll positions for callback deduplication.
+     */
+    cacheScrollCallbackPositions(): void;
+    /**
+     * Synchronize scroll position between master table and overlay table.
+     */
+    syncScrollPositions(): void;
+    /**
+     * 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(): void;
+    /**
+     * Synchronize overlay scrollbars with the master scrollbar.
+     */
+    syncScrollWithMaster(): void;
+    /**
+     * 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(): void;
+    /**
+     * 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(): void;
+    /**
+     * 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(): void;
+    /**
+     * Update the main scrollable elements for all the overlays.
+     */
+    updateMainScrollableElements(): void;
+}