handsontable 18.0.0 → 18.1.0-rc7

package/3rdparty/walkontable/src/overlay/{top.mjs → regions/topOverlay.mjs}

@@ -1,9 +1,34 @@
-import { addClass, getMaximumScrollTop, getScrollbarWidth, getScrollTop, hasClass, outerHeight, removeClass, setOverlayPosition, resetCssTransform } from '../../../../helpers/dom/element.mjs';
-import TopOverlayTable from './../table/top.mjs';
+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_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 { addClass, getScrollTop, hasClass, removeClass, setOverlayPosition, resetCssTransform } from '../../../../../helpers/dom/element.mjs';
+import { isMobileBrowser } from '../../../../../helpers/browser.mjs';
+import TopOverlayTable from '../../table/regions/topTable.mjs';
 import { Overlay } from './_base.mjs';
-import { getCornerStyle } from '../selection/index.mjs';
-import { CLONE_TOP } from './constants.mjs';
-import { throwWithCause } from '../../../../helpers/errors.mjs';
+import { getCornerStyle } from '../../selection/index.mjs';
+import { CLONE_TOP } from '../constants.mjs';
+import { throwWithCause } from '../../../../../helpers/errors.mjs';
+var /**
+   * Computes the top overlay's header-border state without mutating the DOM. Pure: reads settings and
+   * the current class state only. Splitting the decision from the write lets the single-pass draw
+   * resolve the `innerBorderTop` toggle before rendering, instead of after (which forces a re-draw).
+   *
+   * @param {number} position The overlay offset that decides whether the top border is shown.
+   * @param {boolean} skipInnerBorderAdjusting The #7256 guard that suppresses the toggle.
+   * @returns {{ hasEmptyColumns: boolean, innerBorderTop: string, positionChanged: boolean }}
+   */ _computeHeaderBordersState = /*#__PURE__*/ new WeakSet();
 /**
  * @class TopOverlay
  */ export class TopOverlay extends Overlay {
@@ -13,8 +38,8 @@ import { throwWithCause } from '../../../../helpers/errors.mjs';
    * @see Table#constructor
    * @param {...*} args Parameters that will be forwarded to the `Table` constructor.
    * @returns {TopOverlayTable}
-   */ createTable(...args) {
-        return new TopOverlayTable(...args);
+   */ createTable(deps) {
+        return new TopOverlayTable(deps);
     }
     /**
    * Checks if overlay should be fully rendered.
@@ -28,20 +53,21 @@ import { throwWithCause } from '../../../../helpers/errors.mjs';
    *
    * @returns {boolean}
    */ resetFixedPosition() {
-        if (!this.needFullRender || !this.shouldBeRendered() || !this.wot.wtTable.holder.parentNode || !this.clone) {
+        if (!this.needFullRender || !this.shouldBeRendered() || !this.deps.getWtTable().holder.parentNode || !this.clone) {
             // removed from DOM
             return false;
         }
         const overlayRoot = this.clone.wtTable.holder.parentNode;
-        const { rootWindow } = this.domBindings;
+        const { rootWindow } = this.deps;
         const preventOverflow = this.wtSettings.getSetting('preventOverflow');
         let overlayPosition = 0;
         let skipInnerBorderAdjusting = false;
         if (this.trimmingContainer === rootWindow && (!preventOverflow || preventOverflow !== 'vertical')) {
-            const { wtTable } = this.wot;
-            const hiderRect = wtTable.hider.getBoundingClientRect();
+            const wtTable = this.deps.getWtTable();
+            const { geometryReader } = this.deps;
+            const hiderRect = geometryReader.getBoundingClientRect(wtTable.hider);
             const bottom = Math.ceil(hiderRect.bottom);
-            const rootHeight = overlayRoot.offsetHeight;
+            const rootHeight = geometryReader.offsetHeight(overlayRoot);
             // This checks if the overlay is going to an infinite loop caused by added (or removed)
             // `innerBorderTop` class name. Toggling the class name shifts the viewport by 1px and
             // triggers the `scroll` event. It causes the table to render. The new render cycle takes into,
@@ -70,7 +96,7 @@ import { throwWithCause } from '../../../../helpers/errors.mjs';
    * @param {number} pos The scroll position.
    * @returns {boolean}
    */ setScrollPosition(pos) {
-        const { rootWindow } = this.domBindings;
+        const { rootWindow } = this.deps;
         const scrollableElement = this.mainTableScrollableElement;
         const scrollEl = scrollableElement;
         const getScrollPosition = ()=>{
@@ -97,22 +123,16 @@ import { throwWithCause } from '../../../../helpers/errors.mjs';
         this.wtSettings.getSetting('onScrollHorizontally');
     }
     /**
-   * Calculates total sum cells height.
+   * Calculates total sum cells height. Delegates to the viewport's row-height prefix-sum cache
+   * (`Viewport#sumRowHeights`), so a call costs O(1) instead of walking every row in the
+   * `[from, to)` range — `scrollTo` passes ranges that start at row 0, which made keyboard
+   * navigation near the bottom of a large grid re-sum the whole dataset on every keypress.
    *
    * @param {number} from Row index which calculates started from.
    * @param {number} to Row index where calculation is finished.
    * @returns {number} Height sum.
    */ sumCellSizes(from, to) {
-        const stylesHandler = this.wtSettings.getSetting('stylesHandler');
-        const defaultRowHeight = stylesHandler.getDefaultRowHeight();
-        let row = from;
-        let sum = 0;
-        while(row < to){
-            const height = this.wot.wtTable.getRowHeight(row);
-            sum += height === undefined ? defaultRowHeight : height;
-            row += 1;
-        }
-        return sum;
+        return this.deps.getWtViewport().sumRowHeights(from, to);
     }
     /**
    * Adjust overlay root element, children and master table element sizes (width, height).
@@ -129,29 +149,61 @@ import { throwWithCause } from '../../../../helpers/errors.mjs';
         if (!this.clone) {
             return;
         }
-        const { wtTable, wtViewport } = this.wot;
-        const { rootDocument, rootWindow } = this.domBindings;
+        const wtTable = this.deps.getWtTable();
+        const wtViewport = this.deps.getWtViewport();
+        const { rootDocument, rootWindow } = this.deps;
         const overlayRoot = this.clone.wtTable.holder.parentNode;
         const overlayRootStyle = overlayRoot.style;
         const preventOverflow = this.wtSettings.getSetting('preventOverflow');
         if (this.trimmingContainer !== rootWindow || preventOverflow === 'horizontal') {
             let width = wtViewport.getWorkspaceWidth();
             if (wtViewport.hasVerticalScroll()) {
-                width -= getScrollbarWidth(rootDocument);
+                width -= this.deps.geometryReader.getScrollbarWidth(rootDocument);
             }
-            width = Math.min(width, wtTable.wtRootElement.scrollWidth);
+            width = Math.min(width, this.deps.geometryReader.scrollWidth(wtTable.wtRootElement));
             overlayRootStyle.width = `${width}px`;
         } else {
             overlayRootStyle.width = '';
         }
         this.clone.wtTable.holder.style.width = overlayRootStyle.width;
-        let tableHeight = outerHeight(this.clone.wtTable.TABLE);
+        let tableHeight = this.deps.geometryReader.outerHeight(this.clone.wtTable.TABLE);
         if (!wtTable.hasDefinedSize()) {
             tableHeight = 0;
         }
         overlayRootStyle.height = `${tableHeight}px`;
     }
     /**
+   * Tells whether the holder must reserve the selection corner's protruding half-height (#6937),
+   * needed only when the selection's bottom-end corner falls within the frozen top rows this overlay
+   * renders — otherwise the reserved strip leaves a leftover top border at the seam. On mobile the
+   * handles always protrude so the range check suffices; on desktop the fill handle must also be
+   * enabled (`cornerVisible` truthy), mirroring `Border#appear`.
+   *
+   * @private
+   * @param {Selection|null} focusSelection The focus Selection instance (or `null` when none).
+   * @returns {boolean}
+   */ shouldReserveSelectionCornerOffset(focusSelection) {
+        if (!focusSelection || !focusSelection.cellRange) {
+            return false;
+        }
+        const fixedRowsTop = this.wtSettings.getSetting('fixedRowsTop');
+        const bottomEndRow = focusSelection.cellRange.getBottomEndCorner().row;
+        // The corner is at the selection's bottom-end; reserve only when it lands inside the frozen rows
+        // this overlay renders.
+        if (bottomEndRow === null || bottomEndRow >= fixedRowsTop) {
+            return false;
+        }
+        if (isMobileBrowser()) {
+            return true;
+        }
+        const border = focusSelection.settings.border;
+        const cornerVisible = border?.cornerVisible;
+        if (typeof cornerVisible === 'function') {
+            return !!cornerVisible(focusSelection.settings.layerLevel);
+        }
+        return !!cornerVisible;
+    }
+    /**
    * Adjust overlay root childs size.
    */ adjustRootChildrenSize() {
         if (!this.clone) {
@@ -159,7 +211,10 @@ import { throwWithCause } from '../../../../helpers/errors.mjs';
         }
         const { holder } = this.clone.wtTable;
         const cornerStyle = getCornerStyle(this.wot);
-        const selectionCornerOffset = this.wot.selectionManager.getFocusSelection() ? parseInt(cornerStyle.height, 10) / 2 : 0;
+        const focusSelection = this.deps.getSelectionManager().getFocusSelection();
+        // Reserve the corner's protruding half-height only when it lands in this overlay's frozen rows;
+        // otherwise the holder grows taller than its table and leaves a leftover top border at the seam.
+        const selectionCornerOffset = this.shouldReserveSelectionCornerOffset(focusSelection) ? parseInt(cornerStyle.height, 10) / 2 : 0;
         this.clone.wtTable.hider.style.width = this.hider.style.width;
         const holderParent = holder.parentNode;
         holder.style.width = holderParent.style.width;
@@ -171,10 +226,12 @@ import { throwWithCause } from '../../../../helpers/errors.mjs';
    * Adjust the overlay dimensions and position.
    */ applyToDOM() {
         const total = this.wtSettings.getSetting('totalRows') ?? 0;
-        if (typeof this.wot.wtViewport.rowsRenderCalculator?.startPosition === 'number') {
-            this.spreader.style.top = `${this.wot.wtViewport.rowsRenderCalculator.startPosition}px`;
-        } else if (total === 0) {
-            // can happen if there are 0 rows
+        const rowsRenderCalculator = this.deps.getWtViewport().rowsRenderCalculator;
+        if (typeof rowsRenderCalculator?.startPosition === 'number') {
+            this.spreader.style.top = `${rowsRenderCalculator.startPosition}px`;
+        } else if (total === 0 || rowsRenderCalculator === null) {
+            // 0 rows, or nothing rendered yet — a `null` calculator is the drawn-but-never-rendered state
+            // a skipped first draw leaves behind (see `restoreRenderedStateIfSafe` in `table/drawCycle.ts`).
             this.spreader.style.top = '0';
         } else {
             throwWithCause('Incorrect value of the rowsRenderCalculator');
@@ -192,8 +249,9 @@ import { throwWithCause } from '../../../../helpers/errors.mjs';
         }
         const styleProperty = this.isRtl() ? 'right' : 'left';
         const { spreader } = this.clone.wtTable;
-        if (typeof this.wot.wtViewport.columnsRenderCalculator?.startPosition === 'number') {
-            spreader.style[styleProperty] = `${this.wot.wtViewport.columnsRenderCalculator.startPosition}px`;
+        const columnsRenderCalculator = this.deps.getWtViewport().columnsRenderCalculator;
+        if (typeof columnsRenderCalculator?.startPosition === 'number') {
+            spreader.style[styleProperty] = `${columnsRenderCalculator.startPosition}px`;
         } else {
             spreader.style[styleProperty] = '';
         }
@@ -206,6 +264,7 @@ import { throwWithCause } from '../../../../helpers/errors.mjs';
    * @returns {boolean}
    */ scrollTo(sourceRow, bottomEdge) {
         const { wot, wtSettings } = this;
+        const { geometryReader } = this.deps;
         const sourceInstance = wot.cloneSource ? wot.cloneSource : wot;
         const mainHolder = sourceInstance.wtTable.holder;
         const columnHeaders = wtSettings.getSetting('columnHeaders');
@@ -214,14 +273,14 @@ import { throwWithCause } from '../../../../helpers/errors.mjs';
         let newY = this.getTableParentOffset();
         let scrollbarCompensation = 0;
         if (bottomEdge) {
-            const rowHeight = this.wot.wtTable.getRowHeight(sourceRow) ?? 0;
-            const viewportHeight = this.wot.wtViewport.getViewportHeight();
+            const rowHeight = this.deps.getWtTable().getRowHeight(sourceRow) ?? 0;
+            const viewportHeight = this.deps.getWtViewport().getViewportHeight();
             if (rowHeight > viewportHeight) {
                 bottomEdge = false;
             }
         }
-        if (bottomEdge && mainHolder.offsetHeight !== mainHolder.clientHeight) {
-            scrollbarCompensation = getScrollbarWidth(this.domBindings.rootDocument);
+        if (bottomEdge && geometryReader.offsetHeight(mainHolder) !== geometryReader.clientHeight(mainHolder)) {
+            scrollbarCompensation = geometryReader.getScrollbarWidth(this.deps.rootDocument);
         }
         if (bottomEdge) {
             const fixedRowsBottom = wtSettings.getSetting('fixedRowsBottom');
@@ -238,8 +297,8 @@ import { throwWithCause } from '../../../../helpers/errors.mjs';
         newY += scrollbarCompensation;
         // If the table is scrolled all the way up when starting the scroll and going to be scrolled to the bottom,
         // we need to compensate for the potential header bottom border height.
-        if (getMaximumScrollTop(this.mainTableScrollableElement) === newY - columnHeaderBorderCompensation && columnHeaderBorderCompensation > 0) {
-            this.wot.wtOverlays.expandHiderVerticallyBy(columnHeaderBorderCompensation);
+        if (geometryReader.getMaximumScrollTop(this.mainTableScrollableElement) === newY - columnHeaderBorderCompensation && columnHeaderBorderCompensation > 0) {
+            this.deps.getWtOverlays().expandHiderVerticallyBy(columnHeaderBorderCompensation);
         }
         return this.setScrollPosition(newY);
     }
@@ -248,8 +307,8 @@ import { throwWithCause } from '../../../../helpers/errors.mjs';
    *
    * @returns {number}
    */ getTableParentOffset() {
-        if (this.mainTableScrollableElement === this.domBindings.rootWindow) {
-            return this.wot.wtTable.holderOffset.top;
+        if (this.mainTableScrollableElement === this.deps.rootWindow) {
+            return this.deps.getWtTable().holderOffset.top;
         }
         return 0;
     }
@@ -258,18 +317,18 @@ import { throwWithCause } from '../../../../helpers/errors.mjs';
    *
    * @returns {number} Main table's vertical scroll position.
    */ getScrollPosition() {
-        return getScrollTop(this.mainTableScrollableElement, this.domBindings.rootWindow);
+        return getScrollTop(this.mainTableScrollableElement, this.deps.rootWindow);
     }
     /**
    * Gets the main overlay's vertical overlay offset.
    *
    * @returns {number} Main table's vertical overlay offset.
    */ getOverlayOffset() {
-        const { rootWindow } = this.domBindings;
+        const { rootWindow } = this.deps;
         const preventOverflow = this.wtSettings.getSetting('preventOverflow');
         let overlayOffset = 0;
         if (this.trimmingContainer === rootWindow && (!preventOverflow || preventOverflow !== 'vertical')) {
-            const rootHeight = this.wot.wtTable.getTotalHeight();
+            const rootHeight = this.deps.getWtTable().getTotalHeight();
             const overlayRootHeight = this.clone ? this.clone.wtTable.getTotalHeight() : 0;
             const maxOffset = rootHeight - overlayRootHeight;
             overlayOffset = Math.max(this.getScrollPosition() - this.getTableParentOffset(), 0);
@@ -280,47 +339,45 @@ import { throwWithCause } from '../../../../helpers/errors.mjs';
         return overlayOffset;
     }
     /**
+   * Pre-applies the `innerBorderTop` class before the cell render, from the pre-render scroll
+   * position and settings. On the single-pass gated path the border is then already in its final
+   * state when cells render, so the post-render `resetFixedPosition` toggle becomes a no-op
+   * (`positionChanged` stays `false`) and the nested `wot.draw(true)` re-render is never triggered.
+   * Element mode only — the window path resolves the border from post-render geometry
+   * (`getOverlayOffset` + the #7256 guard) and is excluded by the single-pass gate.
+   */ prepareHeaderBorders() {
+        if (!this.needFullRender || !this.shouldBeRendered() || !this.deps.getWtTable().holder.parentNode || !this.clone || this.trimmingContainer === this.deps.rootWindow) {
+            return;
+        }
+        this.adjustHeaderBordersPosition(this.getScrollPosition());
+    }
+    /**
    * Adds css classes to hide the header border's header (cell-selection border hiding issue).
    *
    * @param {number} position Header Y position if trimming container is window or scroll top if not.
    * @param {boolean} [skipInnerBorderAdjusting=false] If `true` the inner border adjusting will be skipped.
    * @returns {boolean}
    */ adjustHeaderBordersPosition(position, skipInnerBorderAdjusting = false) {
-        const { wtSettings } = this;
-        const masterParent = this.wot.wtTable.holder.parentNode;
-        const totalColumns = wtSettings.getSetting('totalColumns') ?? 0;
-        const preventHorizontalOverflow = wtSettings.getSetting('preventOverflow') === 'horizontal';
-        if (totalColumns) {
-            removeClass(masterParent, 'emptyColumns');
-        } else {
+        const masterParent = this.deps.getWtTable().holder.parentNode;
+        const state = _class_private_method_get(this, _computeHeaderBordersState, computeHeaderBordersState).call(this, position, skipInnerBorderAdjusting);
+        if (state.hasEmptyColumns) {
             addClass(masterParent, 'emptyColumns');
+        } else {
+            removeClass(masterParent, 'emptyColumns');
         }
-        let positionChanged = false;
-        if (!skipInnerBorderAdjusting && !preventHorizontalOverflow) {
-            const fixedRowsTop = wtSettings.getSetting('fixedRowsTop');
-            const areFixedRowsTopChanged = this.cachedFixedRowsTop !== fixedRowsTop;
-            const columnHeaders = wtSettings.getSetting('columnHeaders');
-            if ((areFixedRowsTopChanged || fixedRowsTop === 0) && columnHeaders.length > 0) {
-                const previousState = hasClass(masterParent, 'innerBorderTop');
-                this.cachedFixedRowsTop = wtSettings.getSetting('fixedRowsTop');
-                if (position || wtSettings.getSetting('totalRows') === 0) {
-                    addClass(masterParent, 'innerBorderTop');
-                    positionChanged = !previousState;
-                } else {
-                    removeClass(masterParent, 'innerBorderTop');
-                    positionChanged = previousState;
-                }
-            }
+        if (state.innerBorderTop === 'add') {
+            addClass(masterParent, 'innerBorderTop');
+        } else if (state.innerBorderTop === 'remove') {
+            removeClass(masterParent, 'innerBorderTop');
         }
-        return positionChanged;
+        if (state.innerBorderTop !== 'keep') {
+            this.cachedFixedRowsTop = this.wtSettings.getSetting('fixedRowsTop');
+        }
+        return state.positionChanged;
     }
     /**
-   * @param {Walkontable} wotInstance The Walkontable instance. @TODO refactoring: check if can be deleted.
-   * @param {FacadeGetter} facadeGetter Function which return proper facade.
-   * @param {Settings} wtSettings The Walkontable settings.
-   * @param {DomBindings} domBindings Dom elements bound to the current instance.
-   */ constructor(wotInstance, facadeGetter, wtSettings, domBindings){
-        super(wotInstance, facadeGetter, CLONE_TOP, wtSettings, domBindings), /**
+   */ constructor(deps){
+        super(deps, CLONE_TOP), _class_private_method_init(this, _computeHeaderBordersState), /**
    * Cached value which holds the previous value of the `fixedRowsTop` option.
    * It is used as a comparison value that can be used to detect changes in this value.
    *
@@ -329,3 +386,32 @@ import { throwWithCause } from '../../../../helpers/errors.mjs';
         this.cachedFixedRowsTop = this.wtSettings.getSetting('fixedRowsTop');
     }
 }
+function computeHeaderBordersState(position, skipInnerBorderAdjusting) {
+    const { wtSettings } = this;
+    const masterParent = this.deps.getWtTable().holder.parentNode;
+    const totalColumns = wtSettings.getSetting('totalColumns') ?? 0;
+    const preventHorizontalOverflow = wtSettings.getSetting('preventOverflow') === 'horizontal';
+    const hasEmptyColumns = !totalColumns;
+    let innerBorderTop = 'keep';
+    let positionChanged = false;
+    if (!skipInnerBorderAdjusting && !preventHorizontalOverflow) {
+        const fixedRowsTop = wtSettings.getSetting('fixedRowsTop');
+        const areFixedRowsTopChanged = this.cachedFixedRowsTop !== fixedRowsTop;
+        const columnHeaders = wtSettings.getSetting('columnHeaders');
+        if ((areFixedRowsTopChanged || fixedRowsTop === 0) && columnHeaders.length > 0) {
+            const previousState = hasClass(masterParent, 'innerBorderTop');
+            if (position || wtSettings.getSetting('totalRows') === 0) {
+                innerBorderTop = 'add';
+                positionChanged = !previousState;
+            } else {
+                innerBorderTop = 'remove';
+                positionChanged = previousState;
+            }
+        }
+    }
+    return {
+        hasEmptyColumns,
+        innerBorderTop,
+        positionChanged
+    };
+}

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

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

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

@@ -0,0 +1,49 @@
+import type { EngineContext } from '../wire';
+/**
+ * Assembles the ResizeMonitor's dependencies from the engine composition context. It needs only the
+ * settings accessor (to fire the `onContainerElementResize` setting) and the master table (for the
+ * wrapper element it observes) — no callback back into the owning Overlays coordinator.
+ *
+ * @param {EngineContext} ctx The engine composition context.
+ * @returns {object} The ResizeMonitor dependency set.
+ */
+export declare function createResizeMonitorDeps(ctx: EngineContext): {
+    wtSettings: import("../settings").default;
+    wtTable: import("../table/baseTable").default;
+};
+/**
+ * The ResizeMonitor dependencies, inferred from `createResizeMonitorDeps`.
+ */
+export type ResizeMonitorDeps = ReturnType<typeof createResizeMonitorDeps>;
+/**
+ * Watches the Walkontable wrapper's parent element for size changes and fires the
+ * `onContainerElementResize` setting when one is detected.
+ *
+ * The class owns the `ResizeObserver` plus the endless-loop guard: a dynamic parent size (for example
+ * `dvh` units) can make the observer callback re-trigger itself indefinitely, so a rolling count with
+ * a short reset window disconnects the observer once the callback fires too many times in direct
+ * succession. Extracted from the Overlays coordinator so the loop-guard lifecycle stays self-contained.
+ *
+ * @class ResizeMonitor
+ */
+export declare class ResizeMonitor {
+    #private;
+    /**
+     * @param {ResizeMonitorDeps} deps The ResizeMonitor dependencies.
+     */
+    constructor(deps: ResizeMonitorDeps);
+    /**
+     * Starts observing the Walkontable wrapper's parent element for size changes. No-op when the
+     * wrapper has no parent element.
+     */
+    observe(): void;
+    /**
+     * Resets the direct-succession resize counter. Called when a window resize accounts for the size
+     * change, so it is excluded from the endless-loop-blocking logic.
+     */
+    resetResizeCount(): void;
+    /**
+     * Cleans up on destroy: clears the pending reset timeout and disconnects the observer.
+     */
+    destroy(): void;
+}

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

@@ -0,0 +1,154 @@
+"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 ResizeMonitor () {
+        return ResizeMonitor;
+    },
+    get createResizeMonitorDeps () {
+        return createResizeMonitorDeps;
+    }
+});
+const _feature = require("../../../../helpers/feature");
+const _console = require("../../../../helpers/console");
+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 createResizeMonitorDeps(ctx) {
+    return {
+        wtSettings: ctx.wtSettings,
+        wtTable: ctx.getWtTable()
+    };
+}
+var _deps = /*#__PURE__*/ new WeakMap(), /**
+   * The amount of times the ResizeObserver callback was fired in direct succession.
+   *
+   * @type {number}
+   */ _containerDomResizeCount = /*#__PURE__*/ new WeakMap(), /**
+   * The timeout ID for the ResizeObserver endless-loop-blocking logic.
+   *
+   * @type {number}
+   */ _containerDomResizeCountTimeout = /*#__PURE__*/ new WeakMap(), /**
+   * The instance of the ResizeObserver that observes the size of the Walkontable wrapper element.
+   * In case of the size change detection the `onContainerElementResize` is fired.
+   *
+   * @type {ResizeObserver}
+   */ _resizeObserver = /*#__PURE__*/ new WeakMap();
+class ResizeMonitor {
+    /**
+   * Starts observing the Walkontable wrapper's parent element for size changes. No-op when the
+   * wrapper has no parent element.
+   */ observe() {
+        const parentElement = _class_private_field_get(this, _deps).wtTable.wtRootElement.parentElement;
+        if (parentElement) {
+            _class_private_field_get(this, _resizeObserver).observe(parentElement);
+        }
+    }
+    /**
+   * Resets the direct-succession resize counter. Called when a window resize accounts for the size
+   * change, so it is excluded from the endless-loop-blocking logic.
+   */ resetResizeCount() {
+        _class_private_field_set(this, _containerDomResizeCount, 0);
+    }
+    /**
+   * Cleans up on destroy: clears the pending reset timeout and disconnects the observer.
+   */ destroy() {
+        if (_class_private_field_get(this, _containerDomResizeCountTimeout) !== null) {
+            clearTimeout(_class_private_field_get(this, _containerDomResizeCountTimeout));
+            _class_private_field_set(this, _containerDomResizeCountTimeout, null);
+        }
+        _class_private_field_get(this, _resizeObserver).disconnect();
+    }
+    /**
+   * @param {ResizeMonitorDeps} deps The ResizeMonitor dependencies.
+   */ constructor(deps){
+        /**
+   * The ResizeMonitor dependencies.
+   *
+   * @type {ResizeMonitorDeps}
+   */ _class_private_field_init(this, _deps, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _containerDomResizeCount, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _containerDomResizeCountTimeout, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _resizeObserver, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_set(this, _containerDomResizeCount, 0);
+        _class_private_field_set(this, _containerDomResizeCountTimeout, null);
+        _class_private_field_set(this, _resizeObserver, new ResizeObserver((entries)=>{
+            (0, _feature.requestAnimationFrame)(()=>{
+                if (!Array.isArray(entries) || !entries.length) {
+                    return;
+                }
+                _class_private_field_set(this, _containerDomResizeCount, _class_private_field_get(this, _containerDomResizeCount) + 1);
+                if (_class_private_field_get(this, _containerDomResizeCount) === 300) {
+                    (0, _console.warn)('The ResizeObserver callback was fired too many times in direct succession.' + '\nThis may be due to an infinite loop caused by setting a dynamic height/width (for example, ' + 'with the `dvh` units) to a Handsontable container\'s parent. ' + '\nThe observer will be disconnected.');
+                    _class_private_field_get(this, _resizeObserver).disconnect();
+                }
+                // This logic is required to prevent an endless loop of the ResizeObserver callback.
+                // https://github.com/handsontable/dev-handsontable/issues/1898#issuecomment-2154794817
+                if (_class_private_field_get(this, _containerDomResizeCountTimeout) !== null) {
+                    clearTimeout(_class_private_field_get(this, _containerDomResizeCountTimeout));
+                }
+                _class_private_field_set(this, _containerDomResizeCountTimeout, setTimeout(()=>{
+                    _class_private_field_set(this, _containerDomResizeCount, 0);
+                }, 100));
+                _class_private_field_get(this, _deps).wtSettings.getSetting('onContainerElementResize');
+            });
+        }));
+        _class_private_field_set(this, _deps, deps);
+    }
+}