handsontable 18.0.0 → 18.1.0-rc7

package/3rdparty/walkontable/src/overlay/overlays.mjs

@@ -0,0 +1,601 @@
+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 { debounce } from '../../../../helpers/function.mjs';
+import { arrayEach } from '../../../../helpers/array.mjs';
+import { InlineStartOverlay, TopOverlay, TopInlineStartCornerOverlay, BottomOverlay, BottomInlineStartCornerOverlay } from './index.mjs';
+import { createOverlayDeps } from './regions/_base.mjs';
+import { StickyScrollStrategy, createStickyScrollStrategyDeps } from './strategies/stickyScrollStrategy.mjs';
+import { ResizeMonitor, createResizeMonitorDeps } from './resizeMonitor.mjs';
+import { SpreaderSize, createSpreaderSizeDeps } from './spreaderSize.mjs';
+import { ScrollSync, createScrollSyncDeps } from './scroll/scrollSync.mjs';
+import { NativeScrollInput, createNativeScrollInputDeps } from './scroll/nativeScrollInput.mjs';
+import { adjustColumnHeaderHeights, syncOversizedColumnHeadersWithFrozenOverlays } from '../axisSizing/oversizedRows.mjs';
+/**
+ * Assembles the Overlays module's dependencies from the engine composition context. Overlays is the
+ * sub-composition point for the individual overlays, so it carries `makeOverlayDeps` — a factory that
+ * mints a fresh overlay dependency set (via `createOverlayDeps`) for each overlay it builds.
+ *
+ * @param {EngineContext} ctx The engine composition context.
+ * @returns {object} The Overlays dependency set.
+ */ export function createOverlaysDeps(ctx) {
+    return {
+        wot: ctx.wot,
+        wtSettings: ctx.wtSettings,
+        rootDocument: ctx.rootDocument,
+        rootWindow: ctx.rootWindow,
+        geometryReader: ctx.geometryReader,
+        eventManager: ctx.makeEventManager(),
+        wtTable: ctx.getWtTable(),
+        makeOverlayDeps: ()=>createOverlayDeps(ctx),
+        // Sub-composition for the sticky-scroll strategy: mirrors `makeOverlayDeps`, but also needs the
+        // owning Overlays instance (for `refreshAll`/`applyToDOM`/`scrollableElement`/`eventManager`).
+        makeStickyScrollDeps: (overlays)=>createStickyScrollStrategyDeps(ctx, overlays),
+        makeResizeMonitorDeps: ()=>createResizeMonitorDeps(ctx),
+        makeSpreaderSizeDeps: (overlays)=>createSpreaderSizeDeps(ctx, overlays),
+        makeScrollSyncDeps: (overlays, stickyScroll)=>createScrollSyncDeps(ctx, overlays, stickyScroll),
+        makeNativeScrollInputDeps: (overlays, stickyScroll, resizeMonitor)=>createNativeScrollInputDeps(ctx, overlays, stickyScroll, resizeMonitor)
+    };
+}
+var /**
+   * The Overlays module dependencies (holds the DOM roots and the overlay-deps factory).
+   *
+   * @type {OverlaysDeps}
+   */ _deps = /*#__PURE__*/ new WeakMap(), /**
+   * Binds the native DOM input listeners (scroll, wheel, key, resize) and translates them into the
+   * engine's scroll actions. Extracted as a separate class to isolate the native-input lifecycle
+   * from the overlay coordinator; the coordinator keeps a thin public `registerListeners` delegate.
+   *
+   * @type {NativeScrollInput}
+   */ _nativeScrollInput = /*#__PURE__*/ new WeakMap(), /**
+   * Owns the master hider/spreader sizing math. Extracted as a separate class to isolate the sizing
+   * lifecycle from the overlay coordinator; the coordinator keeps thin public delegates.
+   *
+   * @type {SpreaderSize}
+   */ _spreaderSize = /*#__PURE__*/ new WeakMap(), /**
+   * Owns the shared scroll state and the master<->clone scroll synchronization. Extracted as a
+   * separate class to isolate the scroll-position lifecycle from the overlay coordinator; the
+   * coordinator keeps thin public delegates and get/set accessors for the state it and the tests use.
+   *
+   * @type {ScrollSync}
+   */ _scrollSync = /*#__PURE__*/ new WeakMap(), /**
+   * An array of the all overlays.
+   *
+   * @type {Overlay[]}
+   */ _overlays = /*#__PURE__*/ new WeakMap(), /**
+   * Debounced `updateLastSpreaderSize` / `adjustElementsSize` used during scroll so rapid
+   * `refresh` calls do not repeat layout work every frame.
+   *
+   * @type {Function}
+   */ _postponedAdjustElementsSize = /*#__PURE__*/ new WeakMap(), /**
+   * Strategy that manages the sticky-scroll optimization during native
+   * scrollbar drag. Extracted as a separate class to isolate the sticky
+   * positioning lifecycle from the overlay coordinator.
+   *
+   * @type {StickyScrollStrategy}
+   */ _stickyScroll = /*#__PURE__*/ new WeakMap(), /**
+   * Watches the Walkontable wrapper's parent element for size changes (with an endless-loop guard)
+   * and fires the `onContainerElementResize` setting. Extracted as a separate class to isolate the
+   * ResizeObserver lifecycle from the overlay coordinator.
+   *
+   * @type {ResizeMonitor}
+   */ _resizeMonitor = /*#__PURE__*/ new WeakMap(), /**
+   * Adjust the elements size if needed.
+   */ _adjustElementsSizeIfNeeded = /*#__PURE__*/ new WeakSet();
+/**
+ * @class Overlays
+ */ class Overlays {
+    /**
+   * Flag indicating whether the table is being scrolled vertically.
+   *
+   * @returns {boolean}
+   */ get verticalScrolling() {
+        return _class_private_field_get(this, _scrollSync).verticalScrolling;
+    }
+    /**
+   * @param {boolean} value Whether the table is being scrolled vertically.
+   */ set verticalScrolling(value) {
+        _class_private_field_get(this, _scrollSync).verticalScrolling = value;
+    }
+    /**
+   * Flag indicating whether the table is being scrolled horizontally.
+   *
+   * @returns {boolean}
+   */ get horizontalScrolling() {
+        return _class_private_field_get(this, _scrollSync).horizontalScrolling;
+    }
+    /**
+   * @param {boolean} value Whether the table is being scrolled horizontally.
+   */ set horizontalScrolling(value) {
+        _class_private_field_get(this, _scrollSync).horizontalScrolling = value;
+    }
+    /**
+   * The element that scrolls the table (the trimming container or the window).
+   *
+   * @returns {HTMLElement | Window}
+   */ get scrollableElement() {
+        return _class_private_field_get(this, _scrollSync).scrollableElement;
+    }
+    /**
+   * Whether the scrolling element was resolved while the table generated no boxes, so the answer was
+   * taken against nothing and a later draw still has to settle it.
+   *
+   * Covers that answer only, not the sizes measured in the same state. Goes false once a pass settles
+   * it, or once a pass gives up because the answer stopped changing.
+   *
+   * @returns {boolean}
+   */ get isScrollableElementProvisional() {
+        return _class_private_field_get(this, _scrollSync).isScrollableElementProvisional;
+    }
+    /**
+   * Get the list of references to all overlays.
+   *
+   * @param {boolean} [includeMaster = false] If set to `true`, the list will contain the master table as the last
+   * element.
+   * @returns {(TopOverlay|TopInlineStartCornerOverlay|InlineStartOverlay|BottomOverlay|BottomInlineStartCornerOverlay)[]}
+   */ getOverlays(includeMaster = false) {
+        const overlays = [
+            ..._class_private_field_get(this, _overlays)
+        ];
+        if (includeMaster) {
+            overlays.push(this.wtTable);
+        }
+        return overlays;
+    }
+    /**
+   * Prepare overlays based on user settings.
+   *
+   * @private
+   */ initOverlays() {
+        // Each overlay gets a fresh dependency set from the shared factory (all fields are stable refs,
+        // so the objects are independent but equivalent).
+        const makeDeps = _class_private_field_get(this, _deps).makeOverlayDeps;
+        // TODO refactoring, conceive about using generic collection of overlays.
+        this.topOverlay = new TopOverlay(makeDeps());
+        this.bottomOverlay = new BottomOverlay(makeDeps());
+        this.inlineStartOverlay = new InlineStartOverlay(makeDeps());
+        // TODO discuss, the controversial here would be removing the lazy creation mechanism for corners.
+        // TODO cond. Has no any visual impact. They're initially hidden in same way like left, top, and bottom overlays.
+        this.topInlineStartCornerOverlay = new TopInlineStartCornerOverlay(makeDeps(), this.topOverlay, this.inlineStartOverlay);
+        this.bottomInlineStartCornerOverlay = new BottomInlineStartCornerOverlay(makeDeps(), this.bottomOverlay, this.inlineStartOverlay);
+        _class_private_field_set(this, _overlays, [
+            this.topOverlay,
+            this.bottomOverlay,
+            this.inlineStartOverlay,
+            this.topInlineStartCornerOverlay,
+            this.bottomInlineStartCornerOverlay
+        ]);
+    }
+    /**
+   * Pre-applies the header-border classes (`innerBorderTop` / `innerBorderInlineStart`) before
+   * the cell render, so the post-render `resetFixedPosition` toggle is a no-op and the nested
+   * `wot.draw(true)` re-render is skipped. Called from the master draw on the single-pass gated path,
+   * before `beginDrawLayout`. Mirrors the overlay set used by the post-render position pass.
+   */ prepareHeaderBorders() {
+        this.topOverlay.prepareHeaderBorders();
+        if (this.bottomOverlay.clone) {
+            this.bottomOverlay.prepareHeaderBorders();
+        }
+        this.inlineStartOverlay.prepareHeaderBorders();
+    }
+    /**
+   * Runs logic for the overlays before the table is drawn.
+   */ beforeDraw() {
+        // Before anything measures: drops the sizes a previous draw took while the table had no settled
+        // layout, so this draw re-measures them and resizes from the results. Not on a fast draw – it
+        // re-renders nothing, so it cannot re-measure the row heights this drops, and taking the reset
+        // there would leave them dropped. The mark stays pending until `afterDraw` sees a draw that
+        // actually rendered the band (a `skipRender` hook cancels one that got this far), so the drop is
+        // simply retaken on the next draw that can re-measure.
+        if (!this.isScrollDrivenDraw) {
+            _class_private_field_get(this, _scrollSync).resetSizesMeasuredBeforeLayoutSettled();
+        }
+        _class_private_field_get(this, _scrollSync).setRenderingStateChanged(_class_private_field_get(this, _overlays).reduce((acc, overlay)=>{
+            return overlay.hasRenderingStateChanged() || acc;
+        }, false));
+        _class_private_field_get(this, _overlays).forEach((overlay)=>overlay.updateStateOfRendering('before'));
+    }
+    /**
+   * Runs logic for the overlays after the table is drawn.
+   *
+   * A fast draw never runs `alignOverlaysWithTrimmingContainer`, so the holder still carries the
+   * `overflow: visible` it was born with and the trimming container is whatever the last full draw
+   * left – a layout resolution taken from it would read a table that nothing has aligned yet. No such
+   * draw can currently precede the first full one (`refreshAll()` returns while `drawn` is false, and
+   * a table built outside the layout stays undrawn until it joins it), so the gate protects the
+   * settle test in `ScrollSync#resolveProvisionalLayout` from a state it never has to judge.
+   *
+   * @param {boolean} cellsRendered Whether this draw rendered the cell band. `false` for a fast
+   *                                (scroll) draw and for a draw whose `beforeDraw` hook set
+   *                                `skipRender`. Only a draw that rendered the band re-measured the
+   *                                sizes the reset on the way in dropped, so only it may spend the
+   *                                mark – otherwise the drop is retaken on the next draw.
+   */ afterDraw(cellsRendered) {
+        this.syncScrollWithMaster();
+        _class_private_field_get(this, _overlays).forEach((overlay)=>{
+            const hasRenderingStateChanged = overlay.hasRenderingStateChanged();
+            overlay.updateStateOfRendering('after');
+            if (hasRenderingStateChanged && !overlay.needFullRender) {
+                overlay.reset();
+            }
+        });
+        if (cellsRendered) {
+            _class_private_field_get(this, _scrollSync).confirmSizesRemeasured();
+        }
+        // Runs after the overlays refreshed their trimming containers and the holder got its final
+        // overflow, so a table born outside the layout can settle on the scrollable element and the sizes
+        // it would have had if it had been rendered from the start. It cannot run in `beforeDraw`: both
+        // are still stale there, so the scrollable element would settle on the window again. A fast draw
+        // is stale in the same way – it never aligns the overlays – so it must not resolve anything
+        // either; the flag survives to the next full draw.
+        if (!this.isScrollDrivenDraw) {
+            _class_private_field_get(this, _scrollSync).resolveProvisionalLayout();
+        }
+    }
+    /**
+   * Refresh and redraw table.
+   */ refreshAll() {
+        if (!this.wot.drawn) {
+            return;
+        }
+        if (!this.wtTable.holder.parentNode) {
+            // Walkontable was detached from DOM, but this handler was not removed
+            this.destroy();
+            return;
+        }
+        this.wot.draw(true);
+        _class_private_field_get(this, _scrollSync).fireScrollCallbacksAndReset();
+    }
+    /**
+   * Register all necessary event listeners.
+   */ registerListeners() {
+        _class_private_field_get(this, _nativeScrollInput).registerListeners();
+    }
+    /**
+   * Scrolls main scrollable element vertically.
+   *
+   * @param {number} delta Relative value to scroll.
+   * @returns {boolean}
+   */ scrollVertically(delta) {
+        if (!(this.scrollableElement instanceof HTMLElement)) {
+            return false;
+        }
+        const el = this.scrollableElement;
+        const previousScroll = el.scrollTop;
+        el.scrollTop += delta;
+        return previousScroll !== el.scrollTop;
+    }
+    /**
+   * Scrolls main scrollable element horizontally.
+   *
+   * @param {number} delta Relative value to scroll.
+   * @returns {boolean}
+   */ scrollHorizontally(delta) {
+        if (!(this.scrollableElement instanceof HTMLElement)) {
+            return false;
+        }
+        const el = this.scrollableElement;
+        const previousScroll = el.scrollLeft;
+        el.scrollLeft += delta;
+        return previousScroll !== el.scrollLeft;
+    }
+    /**
+   * Synchronize scroll position between master table and overlay table.
+   *
+   * @private
+   */ syncScrollPositions() {
+        _class_private_field_get(this, _scrollSync).syncScrollPositions();
+    }
+    /**
+   * Synchronize overlay scrollbars with the master scrollbar.
+   */ syncScrollWithMaster() {
+        _class_private_field_get(this, _scrollSync).syncScrollWithMaster();
+    }
+    /**
+   * Update the main scrollable elements for all the overlays.
+   */ updateMainScrollableElements() {
+        _class_private_field_get(this, _scrollSync).updateMainScrollableElements();
+    }
+    /**
+   *
+   */ destroy() {
+        _class_private_field_get(this, _postponedAdjustElementsSize).cancel();
+        _class_private_field_get(this, _resizeMonitor).destroy();
+        _class_private_field_get(this, _stickyScroll).destroy();
+        this.eventManager.destroy();
+        // todo, probably all below `destroy` calls has no sense. To analyze
+        this.topOverlay.destroy();
+        if (this.bottomOverlay.clone) {
+            this.bottomOverlay.destroy();
+        }
+        this.inlineStartOverlay.destroy();
+        if (this.topInlineStartCornerOverlay) {
+            this.topInlineStartCornerOverlay.destroy();
+        }
+        if (this.bottomInlineStartCornerOverlay && this.bottomInlineStartCornerOverlay.clone) {
+            this.bottomInlineStartCornerOverlay.destroy();
+        }
+        this.destroyed = true;
+    }
+    /**
+   * @param {boolean} [fastDraw=false] When `true`, try to refresh only the positions of borders without rerendering
+   *                                   the data. It will only work if Table.draw() does not force
+   *                                   rendering anyway.
+   */ refresh(fastDraw = false) {
+        // `isScrollDrivenDraw` guards both decisions below: the scroll-direction flags can still be set
+        // during a `forceFullRender` (an `afterScroll` hook may trigger `hot.render()` before the flags are
+        // reset), and a full render enters as `draw(false)` (so `isScrollDrivenDraw` is `false`), which must
+        // fully re-render and size the overlays rather than treat this as a scroll.
+        const isScrollTriggered = this.isScrollDrivenDraw && (this.verticalScrolling || this.horizontalScrolling);
+        // On a pure vertical scroll the bottom overlay (and its inline-start corner) render the same fixed
+        // rows over the same visible columns, so their DOM is unchanged - a full re-render is wasted work and
+        // forces an expensive style/layout/paint of the clone subtree on every scroll frame. Reposition them
+        // (fast draw) instead. Any horizontal scroll changes the visible columns, and a non-scroll redraw
+        // (data, settings, resize) is not scroll-driven, so those paths still trigger a full re-render.
+        const bottomFastDraw = fastDraw || this.isScrollDrivenDraw && this.verticalScrolling && !this.horizontalScrolling;
+        if (isScrollTriggered) {
+            _class_private_field_get(this, _postponedAdjustElementsSize).call(this);
+        } else {
+            _class_private_method_get(this, _adjustElementsSizeIfNeeded, adjustElementsSizeIfNeeded).call(this);
+        }
+        if (this.bottomOverlay.clone) {
+            this.bottomOverlay.refresh(bottomFastDraw);
+        }
+        this.inlineStartOverlay.refresh(fastDraw);
+        this.topOverlay.refresh(fastDraw);
+        if (this.topInlineStartCornerOverlay) {
+            this.topInlineStartCornerOverlay.refresh(fastDraw);
+        }
+        if (this.bottomInlineStartCornerOverlay && this.bottomInlineStartCornerOverlay.clone) {
+            this.bottomInlineStartCornerOverlay.refresh(bottomFastDraw);
+        }
+    }
+    /**
+   * Update the last cached spreader size with the current size.
+   *
+   * @returns {boolean} `true` if the lastSpreaderSize cache was updated, `false` otherwise.
+   */ updateLastSpreaderSize() {
+        return _class_private_field_get(this, _spreaderSize).updateLastSpreaderSize();
+    }
+    /**
+   * Re-applies the column-header heights to the master and every header-bearing overlay after the
+   * Handsontable-side render-size probe has measured content-driven header heights. The probe runs
+   * after the draw completes (once the DOM is final), so the overlays first render at the provided
+   * height and are corrected here to match the master - a synchronous, hook-free reconcile that
+   * replaces the old mid-draw `markOversizedColumnHeaders` measurement. The frozen-overlay sync runs
+   * last so a wrapped header inside the frozen region still wins, and the sizes are flushed to the DOM.
+   */ refreshColumnHeaderHeights() {
+        const headerBearingTables = [
+            this.wot.wtTable,
+            this.topOverlay.clone?.wtTable,
+            this.inlineStartOverlay.clone?.wtTable,
+            this.topInlineStartCornerOverlay?.clone?.wtTable
+        ];
+        headerBearingTables.forEach((table)=>{
+            if (table) {
+                adjustColumnHeaderHeights(table);
+            }
+        });
+        syncOversizedColumnHeadersWithFrozenOverlays(this.wot.wtTable);
+        this.adjustElementsSize();
+    }
+    /**
+   * Adjust overlays elements size and master table size.
+   */ adjustElementsSize() {
+        _class_private_field_get(this, _spreaderSize).adjustElementsSize();
+    }
+    /**
+   * Expand the hider vertically element by the provided delta value.
+   *
+   * @param {number} heightDelta The delta value to expand the hider element by.
+   */ expandHiderVerticallyBy(heightDelta) {
+        _class_private_field_get(this, _spreaderSize).expandHiderVerticallyBy(heightDelta);
+    }
+    /**
+   * Expand the hider horizontally element by the provided delta value.
+   *
+   * @param {number} widthDelta The delta value to expand the hider element by.
+   */ expandHiderHorizontallyBy(widthDelta) {
+        _class_private_field_get(this, _spreaderSize).expandHiderHorizontallyBy(widthDelta);
+    }
+    /**
+   *
+   */ applyToDOM() {
+        if (!this.wtTable.isVisible()) {
+            return;
+        }
+        this.topOverlay.applyToDOM();
+        if (this.bottomOverlay.clone) {
+            this.bottomOverlay.applyToDOM();
+        }
+        this.inlineStartOverlay.applyToDOM();
+        _class_private_field_get(this, _stickyScroll).syncOffsets();
+    }
+    /**
+   * Get the parent overlay of the provided element.
+   *
+   * @param {HTMLElement} element An element to process.
+   * @returns {WalkontableInstance|null}
+   */ getParentOverlay(element) {
+        if (!element) {
+            return null;
+        }
+        const overlays = [
+            this.topOverlay,
+            this.inlineStartOverlay,
+            this.bottomOverlay,
+            this.topInlineStartCornerOverlay,
+            this.bottomInlineStartCornerOverlay
+        ];
+        let result = null;
+        arrayEach(overlays, (overlay)=>{
+            if (!overlay) {
+                return;
+            }
+            if (overlay.clone && overlay.clone.wtTable.TABLE.contains(element)) {
+                result = overlay.clone;
+            }
+        });
+        return result;
+    }
+    /**
+   * Synchronize the class names between the main overlay table and the tables on the other overlays.
+   *
+   */ syncOverlayTableClassNames() {
+        const masterTable = this.wtTable.TABLE;
+        const overlays = [
+            this.topOverlay,
+            this.inlineStartOverlay,
+            this.bottomOverlay,
+            this.topInlineStartCornerOverlay,
+            this.bottomInlineStartCornerOverlay
+        ];
+        arrayEach(overlays, (elem)=>{
+            if (!elem) {
+                return;
+            }
+            if (elem.clone) {
+                elem.clone.wtTable.TABLE.className = masterTable.className; // todo demeter
+            }
+        });
+    }
+    /**
+   * @param {OverlaysDeps} deps The Overlays module dependencies.
+   */ constructor(deps){
+        _class_private_method_init(this, _adjustElementsSizeIfNeeded);
+        _class_private_field_init(this, _deps, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _nativeScrollInput, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _spreaderSize, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _scrollSync, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _overlays, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _postponedAdjustElementsSize, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _stickyScroll, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _resizeMonitor, {
+            writable: true,
+            value: void 0
+        });
+        /**
+   * The width of the scrollbar.
+   *
+   * @protected
+   * @type {number}
+   */ this.scrollbarSize = 0;
+        /**
+   * Flag indicating whether the overlay has been destroyed.
+   *
+   * @protected
+   * @type {boolean}
+   */ this.destroyed = false;
+        /**
+   * `true` while the in-progress master draw was entered as a fast/scroll draw (`draw(true)`), and
+   * `false` for a full render (`draw(false)`, e.g. a `forceFullRender` from `hot.render()`). Set once
+   * per master draw before the cells are rendered, and read by the draw cycle (master and its clones,
+   * which reach it through the clone source) to gate the column-header render skip. It exists because
+   * the `verticalScrolling`/`horizontalScrolling` flags can still be set when an `afterScroll` hook
+   * synchronously triggers a `forceFullRender`, and a full render must always rebuild the headers.
+   *
+   * @type {boolean}
+   */ this.isScrollDrivenDraw = false;
+        _class_private_field_set(this, _overlays, []);
+        _class_private_field_set(this, _postponedAdjustElementsSize, debounce(_class_private_method_get(this, _adjustElementsSizeIfNeeded, adjustElementsSizeIfNeeded).bind(this), 200));
+        _class_private_field_set(this, _deps, deps);
+        this.wot = deps.wot;
+        this.wtSettings = deps.wtSettings;
+        this.wtTable = deps.wtTable;
+        const { rootDocument } = deps;
+        // legacy support
+        this.eventManager = deps.eventManager;
+        // TODO refactoring: probably invalid place to this logic
+        this.scrollbarSize = _class_private_field_get(this, _deps).geometryReader.getScrollbarWidth(rootDocument);
+        // Built here (not as field initializers) so `eventManager` is set and each collaborator can be
+        // wired via the composition context. ScrollSync is built after the sticky strategy because it
+        // drives sticky activation on scroll; it owns the scrollable element and the scroll state.
+        _class_private_field_set(this, _stickyScroll, new StickyScrollStrategy(_class_private_field_get(this, _deps).makeStickyScrollDeps(this)));
+        _class_private_field_set(this, _resizeMonitor, new ResizeMonitor(_class_private_field_get(this, _deps).makeResizeMonitorDeps()));
+        _class_private_field_set(this, _spreaderSize, new SpreaderSize(_class_private_field_get(this, _deps).makeSpreaderSizeDeps(this)));
+        _class_private_field_set(this, _scrollSync, new ScrollSync(_class_private_field_get(this, _deps).makeScrollSyncDeps(this, _class_private_field_get(this, _stickyScroll))));
+        _class_private_field_set(this, _nativeScrollInput, new NativeScrollInput(_class_private_field_get(this, _deps).makeNativeScrollInputDeps(this, _class_private_field_get(this, _stickyScroll), _class_private_field_get(this, _resizeMonitor))));
+        this.initOverlays();
+        _class_private_field_get(this, _scrollSync).cacheScrollCallbackPositions();
+        this.destroyed = false;
+        this.registerListeners();
+    }
+}
+function adjustElementsSizeIfNeeded() {
+    if (this.destroyed) {
+        return;
+    }
+    const wasSpreaderSizeUpdated = this.updateLastSpreaderSize();
+    if (wasSpreaderSizeUpdated) {
+        this.adjustElementsSize();
+    }
+}
+export default Overlays;