handsontable 18.0.0 → 18.1.0-rc7

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

@@ -8,17 +8,42 @@ Object.defineProperty(exports, "TopOverlay", {
         return TopOverlay;
     }
 });
-const _element = require("../../../../helpers/dom/element");
-const _top = /*#__PURE__*/ _interop_require_default(require("./../table/top"));
+const _element = require("../../../../../helpers/dom/element");
+const _browser = require("../../../../../helpers/browser");
+const _topTable = /*#__PURE__*/ _interop_require_default(require("../../table/regions/topTable"));
 const _base = require("./_base");
-const _selection = require("../selection");
-const _constants = require("./constants");
-const _errors = require("../../../../helpers/errors");
+const _selection = require("../../selection");
+const _constants = require("../constants");
+const _errors = require("../../../../../helpers/errors");
+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);
+}
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
 }
+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 extends _base.Overlay {
     /**
    * Factory method to create a subclass of `Table` that is relevant to this overlay.
@@ -26,8 +51,8 @@ class TopOverlay extends _base.Overlay {
    * @see Table#constructor
    * @param {...*} args Parameters that will be forwarded to the `Table` constructor.
    * @returns {TopOverlayTable}
-   */ createTable(...args) {
-        return new _top.default(...args);
+   */ createTable(deps) {
+        return new _topTable.default(deps);
     }
     /**
    * Checks if overlay should be fully rendered.
@@ -41,20 +66,21 @@ class TopOverlay extends _base.Overlay {
    *
    * @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,
@@ -83,7 +109,7 @@ class TopOverlay extends _base.Overlay {
    * @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 = ()=>{
@@ -110,22 +136,16 @@ class TopOverlay extends _base.Overlay {
         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).
@@ -142,29 +162,61 @@ class TopOverlay extends _base.Overlay {
         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 -= (0, _element.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 = (0, _element.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 ((0, _browser.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) {
@@ -172,7 +224,10 @@ class TopOverlay extends _base.Overlay {
         }
         const { holder } = this.clone.wtTable;
         const cornerStyle = (0, _selection.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;
@@ -184,10 +239,12 @@ class TopOverlay extends _base.Overlay {
    * 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 {
             (0, _errors.throwWithCause)('Incorrect value of the rowsRenderCalculator');
@@ -205,8 +262,9 @@ class TopOverlay extends _base.Overlay {
         }
         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] = '';
         }
@@ -219,6 +277,7 @@ class TopOverlay extends _base.Overlay {
    * @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');
@@ -227,14 +286,14 @@ class TopOverlay extends _base.Overlay {
         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 = (0, _element.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');
@@ -251,8 +310,8 @@ class TopOverlay extends _base.Overlay {
         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 ((0, _element.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);
     }
@@ -261,8 +320,8 @@ class TopOverlay extends _base.Overlay {
    *
    * @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;
     }
@@ -271,18 +330,18 @@ class TopOverlay extends _base.Overlay {
    *
    * @returns {number} Main table's vertical scroll position.
    */ getScrollPosition() {
-        return (0, _element.getScrollTop)(this.mainTableScrollableElement, this.domBindings.rootWindow);
+        return (0, _element.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);
@@ -293,47 +352,45 @@ class TopOverlay extends _base.Overlay {
         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) {
-            (0, _element.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) {
             (0, _element.addClass)(masterParent, 'emptyColumns');
+        } else {
+            (0, _element.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 = (0, _element.hasClass)(masterParent, 'innerBorderTop');
-                this.cachedFixedRowsTop = wtSettings.getSetting('fixedRowsTop');
-                if (position || wtSettings.getSetting('totalRows') === 0) {
-                    (0, _element.addClass)(masterParent, 'innerBorderTop');
-                    positionChanged = !previousState;
-                } else {
-                    (0, _element.removeClass)(masterParent, 'innerBorderTop');
-                    positionChanged = previousState;
-                }
-            }
+        if (state.innerBorderTop === 'add') {
+            (0, _element.addClass)(masterParent, 'innerBorderTop');
+        } else if (state.innerBorderTop === 'remove') {
+            (0, _element.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, _constants.CLONE_TOP, wtSettings, domBindings), /**
+   */ constructor(deps){
+        super(deps, _constants.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.
    *
@@ -342,3 +399,32 @@ class TopOverlay extends _base.Overlay {
         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 = (0, _element.hasClass)(masterParent, 'innerBorderTop');
+            if (position || wtSettings.getSetting('totalRows') === 0) {
+                innerBorderTop = 'add';
+                positionChanged = !previousState;
+            } else {
+                innerBorderTop = 'remove';
+                positionChanged = previousState;
+            }
+        }
+    }
+    return {
+        hasEmptyColumns,
+        innerBorderTop,
+        positionChanged
+    };
+}