handsontable 18.0.0 → 18.1.0-rc7

package/3rdparty/walkontable/src/overlay/spreaderSize.js

@@ -0,0 +1,178 @@
+"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 SpreaderSize () {
+        return SpreaderSize;
+    },
+    get createSpreaderSizeDeps () {
+        return createSpreaderSizeDeps;
+    }
+});
+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 createSpreaderSizeDeps(ctx, overlays) {
+    return {
+        wtSettings: ctx.wtSettings,
+        rootWindow: ctx.rootWindow,
+        geometryReader: ctx.geometryReader,
+        wtTable: ctx.getWtTable(),
+        getWtViewport: ctx.getWtViewport,
+        getTopOverlay: ctx.getTopOverlay,
+        getInlineStartOverlay: ctx.getInlineStartOverlay,
+        getBottomOverlay: ctx.getBottomOverlay,
+        getScrollableElement: ()=>overlays.scrollableElement
+    };
+}
+var _deps = /*#__PURE__*/ new WeakMap(), /**
+   * The last cached spreader size, used to detect whether a resize is needed.
+   *
+   * @type {{ width: number | null, height: number | null }}
+   */ _lastSize = /*#__PURE__*/ new WeakMap();
+class SpreaderSize {
+    /**
+   * Update the last cached spreader size with the current size.
+   *
+   * @returns {boolean} `true` if the lastSize cache was updated, `false` otherwise.
+   */ updateLastSpreaderSize() {
+        const spreader = _class_private_field_get(this, _deps).wtTable.spreader;
+        const { geometryReader } = _class_private_field_get(this, _deps);
+        const width = geometryReader.clientWidth(spreader);
+        const height = geometryReader.clientHeight(spreader);
+        const needsUpdating = width !== _class_private_field_get(this, _lastSize).width || height !== _class_private_field_get(this, _lastSize).height;
+        if (needsUpdating) {
+            _class_private_field_get(this, _lastSize).width = width;
+            _class_private_field_get(this, _lastSize).height = height;
+        }
+        return needsUpdating;
+    }
+    /**
+   * Adjust overlays elements size and master table size.
+   */ adjustElementsSize() {
+        const { wtSettings, rootWindow, geometryReader } = _class_private_field_get(this, _deps);
+        const wtViewport = _class_private_field_get(this, _deps).getWtViewport();
+        const { wtTable } = _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 bottomOverlay = _class_private_field_get(this, _deps).getBottomOverlay();
+        const scrollableElement = _class_private_field_get(this, _deps).getScrollableElement();
+        const isWindowScrolled = scrollableElement === rootWindow;
+        const totalColumns = wtSettings.getSetting('totalColumns');
+        const totalRows = wtSettings.getSetting('totalRows');
+        const headerRowSize = wtViewport.getRowHeaderWidth();
+        const headerColumnSize = wtViewport.getColumnHeaderHeight();
+        // The internal row height calculator contains a known issue that results in a 1px miscalculation.
+        // Ideally, this should be addressed at the core level. However, resolving it is non-trivial,
+        // as the flaw is embedded across multiple core modules and corresponding test cases.
+        // This limitation does not affect when the external calculator is used (AutoRowSize), which
+        // computes heights accurately, so no adjustment is required when using it.
+        const hiderHeightComp = wtSettings.getSetting('externalRowCalculator') ? 0 : 1;
+        const proposedHiderHeight = headerColumnSize + topOverlay.sumCellSizes(0, totalRows) + hiderHeightComp;
+        const proposedHiderWidth = headerRowSize + inlineStartOverlay.sumCellSizes(0, totalColumns);
+        const hiderElement = wtTable.hider;
+        const hiderStyle = hiderElement.style;
+        const isScrolledBeyondHiderHeight = ()=>{
+            if (isWindowScrolled || !(scrollableElement instanceof HTMLElement)) {
+                return false;
+            }
+            return scrollableElement.scrollTop > Math.max(0, proposedHiderHeight - geometryReader.clientHeight(wtTable.holder));
+        };
+        const isScrolledBeyondHiderWidth = ()=>{
+            if (isWindowScrolled || !(scrollableElement instanceof HTMLElement)) {
+                return false;
+            }
+            return scrollableElement.scrollLeft > Math.max(0, proposedHiderWidth - geometryReader.clientWidth(wtTable.holder));
+        };
+        const columnHeaderBorderCompensation = isScrolledBeyondHiderHeight() ? 1 : 0;
+        const rowHeaderBorderCompensation = isScrolledBeyondHiderWidth() ? 1 : 0;
+        // If the elements are being adjusted after scrolling the table from the very beginning to the very end,
+        // we need to adjust the hider dimensions by the header border size. (https://github.com/handsontable/dev-handsontable/issues/1772)
+        hiderStyle.width = `${proposedHiderWidth + rowHeaderBorderCompensation}px`;
+        hiderStyle.height = `${proposedHiderHeight + columnHeaderBorderCompensation}px`;
+        topOverlay.adjustElementsSize();
+        inlineStartOverlay.adjustElementsSize();
+        bottomOverlay.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) {
+        const { hider } = _class_private_field_get(this, _deps).wtTable;
+        hider.style.height = `${parseInt(hider.style.height, 10) + heightDelta}px`;
+    }
+    /**
+   * Expand the hider horizontally element by the provided delta value.
+   *
+   * @param {number} widthDelta The delta value to expand the hider element by.
+   */ expandHiderHorizontallyBy(widthDelta) {
+        const { hider } = _class_private_field_get(this, _deps).wtTable;
+        hider.style.width = `${parseInt(hider.style.width, 10) + widthDelta}px`;
+    }
+    /**
+   * @param {SpreaderSizeDeps} deps The SpreaderSize dependencies.
+   */ constructor(deps){
+        /**
+   * The SpreaderSize dependencies.
+   *
+   * @type {SpreaderSizeDeps}
+   */ _class_private_field_init(this, _deps, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _lastSize, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_set(this, _lastSize, {
+            width: null,
+            height: null
+        });
+        _class_private_field_set(this, _deps, deps);
+    }
+}

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

@@ -0,0 +1,179 @@
+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;
+}
+/**
+ * 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 function createSpreaderSizeDeps(ctx, overlays) {
+    return {
+        wtSettings: ctx.wtSettings,
+        rootWindow: ctx.rootWindow,
+        geometryReader: ctx.geometryReader,
+        wtTable: ctx.getWtTable(),
+        getWtViewport: ctx.getWtViewport,
+        getTopOverlay: ctx.getTopOverlay,
+        getInlineStartOverlay: ctx.getInlineStartOverlay,
+        getBottomOverlay: ctx.getBottomOverlay,
+        getScrollableElement: ()=>overlays.scrollableElement
+    };
+}
+var _deps = /*#__PURE__*/ new WeakMap(), /**
+   * The last cached spreader size, used to detect whether a resize is needed.
+   *
+   * @type {{ width: number | null, height: number | null }}
+   */ _lastSize = /*#__PURE__*/ new WeakMap();
+/**
+ * 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 class SpreaderSize {
+    /**
+   * Update the last cached spreader size with the current size.
+   *
+   * @returns {boolean} `true` if the lastSize cache was updated, `false` otherwise.
+   */ updateLastSpreaderSize() {
+        const spreader = _class_private_field_get(this, _deps).wtTable.spreader;
+        const { geometryReader } = _class_private_field_get(this, _deps);
+        const width = geometryReader.clientWidth(spreader);
+        const height = geometryReader.clientHeight(spreader);
+        const needsUpdating = width !== _class_private_field_get(this, _lastSize).width || height !== _class_private_field_get(this, _lastSize).height;
+        if (needsUpdating) {
+            _class_private_field_get(this, _lastSize).width = width;
+            _class_private_field_get(this, _lastSize).height = height;
+        }
+        return needsUpdating;
+    }
+    /**
+   * Adjust overlays elements size and master table size.
+   */ adjustElementsSize() {
+        const { wtSettings, rootWindow, geometryReader } = _class_private_field_get(this, _deps);
+        const wtViewport = _class_private_field_get(this, _deps).getWtViewport();
+        const { wtTable } = _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 bottomOverlay = _class_private_field_get(this, _deps).getBottomOverlay();
+        const scrollableElement = _class_private_field_get(this, _deps).getScrollableElement();
+        const isWindowScrolled = scrollableElement === rootWindow;
+        const totalColumns = wtSettings.getSetting('totalColumns');
+        const totalRows = wtSettings.getSetting('totalRows');
+        const headerRowSize = wtViewport.getRowHeaderWidth();
+        const headerColumnSize = wtViewport.getColumnHeaderHeight();
+        // The internal row height calculator contains a known issue that results in a 1px miscalculation.
+        // Ideally, this should be addressed at the core level. However, resolving it is non-trivial,
+        // as the flaw is embedded across multiple core modules and corresponding test cases.
+        // This limitation does not affect when the external calculator is used (AutoRowSize), which
+        // computes heights accurately, so no adjustment is required when using it.
+        const hiderHeightComp = wtSettings.getSetting('externalRowCalculator') ? 0 : 1;
+        const proposedHiderHeight = headerColumnSize + topOverlay.sumCellSizes(0, totalRows) + hiderHeightComp;
+        const proposedHiderWidth = headerRowSize + inlineStartOverlay.sumCellSizes(0, totalColumns);
+        const hiderElement = wtTable.hider;
+        const hiderStyle = hiderElement.style;
+        const isScrolledBeyondHiderHeight = ()=>{
+            if (isWindowScrolled || !(scrollableElement instanceof HTMLElement)) {
+                return false;
+            }
+            return scrollableElement.scrollTop > Math.max(0, proposedHiderHeight - geometryReader.clientHeight(wtTable.holder));
+        };
+        const isScrolledBeyondHiderWidth = ()=>{
+            if (isWindowScrolled || !(scrollableElement instanceof HTMLElement)) {
+                return false;
+            }
+            return scrollableElement.scrollLeft > Math.max(0, proposedHiderWidth - geometryReader.clientWidth(wtTable.holder));
+        };
+        const columnHeaderBorderCompensation = isScrolledBeyondHiderHeight() ? 1 : 0;
+        const rowHeaderBorderCompensation = isScrolledBeyondHiderWidth() ? 1 : 0;
+        // If the elements are being adjusted after scrolling the table from the very beginning to the very end,
+        // we need to adjust the hider dimensions by the header border size. (https://github.com/handsontable/dev-handsontable/issues/1772)
+        hiderStyle.width = `${proposedHiderWidth + rowHeaderBorderCompensation}px`;
+        hiderStyle.height = `${proposedHiderHeight + columnHeaderBorderCompensation}px`;
+        topOverlay.adjustElementsSize();
+        inlineStartOverlay.adjustElementsSize();
+        bottomOverlay.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) {
+        const { hider } = _class_private_field_get(this, _deps).wtTable;
+        hider.style.height = `${parseInt(hider.style.height, 10) + heightDelta}px`;
+    }
+    /**
+   * Expand the hider horizontally element by the provided delta value.
+   *
+   * @param {number} widthDelta The delta value to expand the hider element by.
+   */ expandHiderHorizontallyBy(widthDelta) {
+        const { hider } = _class_private_field_get(this, _deps).wtTable;
+        hider.style.width = `${parseInt(hider.style.width, 10) + widthDelta}px`;
+    }
+    /**
+   * @param {SpreaderSizeDeps} deps The SpreaderSize dependencies.
+   */ constructor(deps){
+        /**
+   * The SpreaderSize dependencies.
+   *
+   * @type {SpreaderSizeDeps}
+   */ _class_private_field_init(this, _deps, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _lastSize, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_set(this, _lastSize, {
+            width: null,
+            height: null
+        });
+        _class_private_field_set(this, _deps, deps);
+    }
+}

package/3rdparty/walkontable/src/{stickyScrollStrategy.d.ts → overlay/strategies/stickyScrollStrategy.d.ts}

@@ -1,21 +1,34 @@
-import type { WalkontableInstance, DomBindings } from './types';
-import type Settings from './settings';
-import type Table from './table';
-import type { Overlay } from './overlay/_base';
-import type EventManager from '../../../eventManager';
-interface OverlaysLike {
-    wot: WalkontableInstance;
-    wtTable: Table;
-    wtSettings: Settings;
-    domBindings: DomBindings;
-    eventManager: EventManager;
-    scrollableElement: HTMLElement | Window;
-    topOverlay: Overlay;
-    bottomOverlay: Overlay;
-    inlineStartOverlay: Overlay;
-    refreshAll(): void;
-    applyToDOM(): void;
-}
+import type { EngineContext } from '../../wire';
+import type { default as Overlays } from '../overlays';
+import type { Overlay } from '../regions/_base';
+/**
+ * Assembles the StickyScrollStrategy's dependencies. Most come from the engine composition context;
+ * the three that drive the Overlays coordinator itself (`refreshAll`/`applyToDOM`/`scrollableElement`)
+ * and the shared `eventManager` come from the owning Overlays instance — so its scrollbar listeners
+ * are tracked on (and torn down with) the same event manager as the rest of the overlays.
+ *
+ * @param {EngineContext} ctx The engine composition context.
+ * @param {Overlays} overlays The owning Overlays coordinator.
+ * @returns {object} The StickyScrollStrategy dependency set.
+ */
+export declare function createStickyScrollStrategyDeps(ctx: EngineContext, overlays: Overlays): {
+    wtSettings: import("../../settings").default;
+    rootDocument: Document;
+    rootWindow: Window;
+    eventManager: import("../../../../../eventManager").default;
+    wtTable: import("../../table/baseTable").default;
+    getWtViewport: () => import("../../viewport/viewport").default;
+    getTopOverlay: () => Overlay;
+    getBottomOverlay: () => Overlay;
+    getInlineStartOverlay: () => Overlay;
+    getScrollableElement: () => HTMLElement | Window;
+    refreshAll: () => void;
+    applyToDOM: () => void;
+};
+/**
+ * The StickyScrollStrategy dependencies, inferred from `createStickyScrollStrategyDeps`.
+ */
+export type StickyScrollStrategyDeps = ReturnType<typeof createStickyScrollStrategyDeps>;
 /**
  * Manages the sticky-scroll optimization during native scrollbar drag.
  *
@@ -34,9 +47,9 @@ interface OverlaysLike {
 export declare class StickyScrollStrategy {
     #private;
     /**
-     * @param {Overlays} overlays The parent Overlays instance.
+     * @param {StickyScrollStrategyDeps} deps The StickyScrollStrategy dependencies.
      */
-    constructor(overlays: OverlaysLike);
+    constructor(deps: StickyScrollStrategyDeps);
     /**
      * Registers mousedown/mouseup listeners for scrollbar drag detection.
      * Called from `Overlays.registerListeners()`.
@@ -67,4 +80,3 @@ export declare class StickyScrollStrategy {
      */
     deactivate(): void;
 }
-export {};

package/3rdparty/walkontable/src/{stickyScrollStrategy.js → overlay/strategies/stickyScrollStrategy.js}

@@ -2,13 +2,21 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-Object.defineProperty(exports, "StickyScrollStrategy", {
-    enumerable: true,
-    get: function() {
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get StickyScrollStrategy () {
         return StickyScrollStrategy;
+    },
+    get createStickyScrollStrategyDeps () {
+        return createStickyScrollStrategyDeps;
     }
 });
-const _browser = require("../../../helpers/browser");
+const _browser = require("../../../../../helpers/browser");
 function _check_private_redeclaration(obj, privateCollection) {
     if (privateCollection.has(obj)) {
         throw new TypeError("Cannot initialize the same private elements twice on an object");
@@ -59,7 +67,23 @@ function _class_private_method_init(obj, privateSet) {
     _check_private_redeclaration(obj, privateSet);
     privateSet.add(obj);
 }
-var _overlays = /*#__PURE__*/ new WeakMap(), /**
+function createStickyScrollStrategyDeps(ctx, overlays) {
+    return {
+        wtSettings: ctx.wtSettings,
+        rootDocument: ctx.rootDocument,
+        rootWindow: ctx.rootWindow,
+        eventManager: overlays.eventManager,
+        wtTable: ctx.getWtTable(),
+        getWtViewport: ctx.getWtViewport,
+        getTopOverlay: ctx.getTopOverlay,
+        getBottomOverlay: ctx.getBottomOverlay,
+        getInlineStartOverlay: ctx.getInlineStartOverlay,
+        getScrollableElement: ()=>overlays.scrollableElement,
+        refreshAll: ()=>overlays.refreshAll(),
+        applyToDOM: ()=>overlays.applyToDOM()
+    };
+}
+var _deps = /*#__PURE__*/ new WeakMap(), /**
    * Whether sticky-scroll mode is currently active.
    *
    * @type {boolean}
@@ -128,7 +152,7 @@ class StickyScrollStrategy {
    * Registers mousedown/mouseup listeners for scrollbar drag detection.
    * Called from `Overlays.registerListeners()`.
    */ registerListeners() {
-        const { eventManager, domBindings: { rootDocument } } = _class_private_field_get(this, _overlays);
+        const { eventManager, rootDocument } = _class_private_field_get(this, _deps);
         // Scrollable elements may have changed (e.g. updateSettings). Discard any
         // leftover sticky state so a stale deactivate() cannot compute a wrong scroll.
         if (_class_private_field_get(this, _active)) {
@@ -167,8 +191,7 @@ class StickyScrollStrategy {
         if (!_class_private_field_get(this, _active)) {
             return;
         }
-        const overlays = _class_private_field_get(this, _overlays);
-        const { wtViewport } = overlays.wot;
+        const wtViewport = _class_private_field_get(this, _deps).getWtViewport();
         const startTop = wtViewport.rowsRenderCalculator?.startPosition;
         const startLeft = wtViewport.columnsRenderCalculator?.startPosition;
         // startPosition is null when nothing is rendered (empty dataset or trimmed-away rows/columns).
@@ -194,13 +217,12 @@ class StickyScrollStrategy {
    * the scroll position to match, then restores `position: relative` and
    * triggers a final full render.
    */ deactivate() {
-        const overlays = _class_private_field_get(this, _overlays);
-        const spreader = overlays.wtTable.spreader;
-        const { wtViewport } = overlays.wot;
-        const isRtl = overlays.wtSettings.getSetting('rtlMode');
+        const spreader = _class_private_field_get(this, _deps).wtTable.spreader;
+        const wtViewport = _class_private_field_get(this, _deps).getWtViewport();
+        const isRtl = _class_private_field_get(this, _deps).wtSettings.getSetting('rtlMode');
         const leftProp = isRtl ? 'right' : 'left';
         // Render while still active (same code path as during drag).
-        overlays.refreshAll();
+        _class_private_field_get(this, _deps).refreshAll();
         // Capture the sticky offsets and computed start positions.
         const lastStickyTop = Number.parseInt(spreader.style.top, 10) || 0;
         const lastStickyLeft = Number.parseInt(spreader.style[leftProp], 10) || 0;
@@ -214,12 +236,12 @@ class StickyScrollStrategy {
         _class_private_field_set(this, _active, false);
         _class_private_method_get(this, _applySpreaderStyles, applySpreaderStyles).call(this, 'relative', 0, 0);
         // Final render in normal mode at the corrected scroll position.
-        overlays.refreshAll();
-        overlays.applyToDOM();
+        _class_private_field_get(this, _deps).refreshAll();
+        _class_private_field_get(this, _deps).applyToDOM();
     }
     /**
-   * @param {Overlays} overlays The parent Overlays instance.
-   */ constructor(overlays){
+   * @param {StickyScrollStrategyDeps} deps The StickyScrollStrategy dependencies.
+   */ constructor(deps){
         _class_private_method_init(this, _activate);
         _class_private_method_init(this, _getScrollTop);
         _class_private_method_init(this, _getScrollLeft);
@@ -231,10 +253,10 @@ class StickyScrollStrategy {
         _class_private_method_init(this, _isWindowScroll);
         _class_private_method_init(this, _isRtl);
         /**
-   * Reference to the parent Overlays coordinator.
+   * The StickyScrollStrategy dependencies.
    *
-   * @type {OverlaysLike}
-   */ _class_private_field_init(this, _overlays, {
+   * @type {StickyScrollStrategyDeps}
+   */ _class_private_field_init(this, _deps, {
             writable: true,
             value: void 0
         });
@@ -248,13 +270,12 @@ class StickyScrollStrategy {
         });
         _class_private_field_set(this, _active, false);
         _class_private_field_set(this, _mouseDown, false);
-        _class_private_field_set(this, _overlays, overlays);
+        _class_private_field_set(this, _deps, deps);
     }
 }
 function activate() {
-    const overlays = _class_private_field_get(this, _overlays);
-    const spreader = overlays.wtTable.spreader;
-    const isRtl = overlays.wtSettings.getSetting('rtlMode');
+    const spreader = _class_private_field_get(this, _deps).wtTable.spreader;
+    const isRtl = _class_private_field_get(this, _deps).wtSettings.getSetting('rtlMode');
     const leftProp = isRtl ? 'right' : 'left';
     const startTop = Number.parseInt(spreader.style.top, 10) || 0;
     const stickyTop = startTop - _class_private_method_get(this, _getScrollTop, getScrollTop).call(this);
@@ -264,11 +285,11 @@ function activate() {
     _class_private_method_get(this, _applySpreaderStyles, applySpreaderStyles).call(this, 'sticky', stickyTop, stickyLeft);
 }
 function getScrollTop() {
-    const { topOverlay } = _class_private_field_get(this, _overlays);
+    const topOverlay = _class_private_field_get(this, _deps).getTopOverlay();
     return topOverlay.getScrollPosition() - topOverlay.getTableParentOffset();
 }
 function getScrollLeft() {
-    const { inlineStartOverlay } = _class_private_field_get(this, _overlays);
+    const inlineStartOverlay = _class_private_field_get(this, _deps).getInlineStartOverlay();
     // For RTL window scrolling, scrollX increases as the user scrolls left (away from
     // the right-edge origin). getTableParentOffset() returns the left-edge offset which
     // doesn't apply to the RTL coordinate system, so skip it and return scrollX directly.
@@ -278,16 +299,15 @@ function getScrollLeft() {
     return Math.abs(inlineStartOverlay.getScrollPosition()) - inlineStartOverlay.getTableParentOffset();
 }
 function setScrollPosition(top, left) {
-    const overlays = _class_private_field_get(this, _overlays);
     if (_class_private_method_get(this, _isWindowScroll, isWindowScroll).call(this)) {
-        const { rootWindow } = overlays.domBindings;
+        const { rootWindow } = _class_private_field_get(this, _deps);
         // RTL + window-scroll: left is in scrollX coordinates (distance from the right-edge
         // origin), so pass it directly. LTR: add back the table's left page offset.
-        const absoluteLeft = _class_private_method_get(this, _isRtl, isRtl).call(this) ? left : left + overlays.inlineStartOverlay.getTableParentOffset();
-        rootWindow.scrollTo(absoluteLeft, top + overlays.topOverlay.getTableParentOffset());
+        const absoluteLeft = _class_private_method_get(this, _isRtl, isRtl).call(this) ? left : left + _class_private_field_get(this, _deps).getInlineStartOverlay().getTableParentOffset();
+        rootWindow.scrollTo(absoluteLeft, top + _class_private_field_get(this, _deps).getTopOverlay().getTableParentOffset());
     } else {
-        overlays.wtTable.holder.scrollTop = top;
-        overlays.wtTable.holder.scrollLeft = _class_private_method_get(this, _isRtl, isRtl).call(this) ? -left : left;
+        _class_private_field_get(this, _deps).wtTable.holder.scrollTop = top;
+        _class_private_field_get(this, _deps).wtTable.holder.scrollLeft = _class_private_method_get(this, _isRtl, isRtl).call(this) ? -left : left;
     }
 }
 function clearSpreaderInsetStyles(element) {
@@ -297,8 +317,7 @@ function clearSpreaderInsetStyles(element) {
     element.style.right = '';
 }
 function applySpreaderStyles(position, stickyTop, stickyLeft) {
-    const overlays = _class_private_field_get(this, _overlays);
-    const spreader = overlays.wtTable.spreader;
+    const spreader = _class_private_field_get(this, _deps).wtTable.spreader;
     const isRtl1 = _class_private_method_get(this, _isRtl, isRtl).call(this);
     const leftProp = isRtl1 ? 'right' : 'left';
     const isSticky = position === 'sticky';
@@ -318,9 +337,9 @@ function applySpreaderStyles(position, stickyTop, stickyLeft) {
     if (_class_private_method_get(this, _isWindowScroll, isWindowScroll).call(this)) {
         return;
     }
-    _class_private_method_get(this, _applyCloneSpreaderStyles, applyCloneSpreaderStyles).call(this, overlays.inlineStartOverlay, position, isSticky, stickyTop, null, isRtl1);
-    _class_private_method_get(this, _applyCloneSpreaderStyles, applyCloneSpreaderStyles).call(this, overlays.topOverlay, position, isSticky, null, stickyLeft, isRtl1);
-    _class_private_method_get(this, _applyCloneSpreaderStyles, applyCloneSpreaderStyles).call(this, overlays.bottomOverlay, position, isSticky, null, stickyLeft, isRtl1);
+    _class_private_method_get(this, _applyCloneSpreaderStyles, applyCloneSpreaderStyles).call(this, _class_private_field_get(this, _deps).getInlineStartOverlay(), position, isSticky, stickyTop, null, isRtl1);
+    _class_private_method_get(this, _applyCloneSpreaderStyles, applyCloneSpreaderStyles).call(this, _class_private_field_get(this, _deps).getTopOverlay(), position, isSticky, null, stickyLeft, isRtl1);
+    _class_private_method_get(this, _applyCloneSpreaderStyles, applyCloneSpreaderStyles).call(this, _class_private_field_get(this, _deps).getBottomOverlay(), position, isSticky, null, stickyLeft, isRtl1);
 }
 function applyCloneSpreaderStyles(overlay, position, isSticky, stickyTop, stickyLeft, isRtl) {
     if (!overlay.needFullRender || !overlay.clone) {
@@ -343,13 +362,13 @@ function applyCloneSpreaderStyles(overlay, position, isSticky, stickyTop, sticky
 }
 function isScrollbarTarget(event) {
     if (_class_private_method_get(this, _isWindowScroll, isWindowScroll).call(this)) {
-        return event.target === _class_private_field_get(this, _overlays).domBindings.rootDocument.documentElement;
+        return event.target === _class_private_field_get(this, _deps).rootDocument.documentElement;
     }
-    return event.target === _class_private_field_get(this, _overlays).scrollableElement;
+    return event.target === _class_private_field_get(this, _deps).getScrollableElement();
 }
 function isWindowScroll() {
-    return _class_private_field_get(this, _overlays).scrollableElement === _class_private_field_get(this, _overlays).domBindings.rootWindow;
+    return _class_private_field_get(this, _deps).getScrollableElement() === _class_private_field_get(this, _deps).rootWindow;
 }
 function isRtl() {
-    return _class_private_field_get(this, _overlays).wtSettings.getSetting('rtlMode');
+    return _class_private_field_get(this, _deps).wtSettings.getSetting('rtlMode');
 }