handsontable 18.0.0 → 18.1.0-rc7

package/3rdparty/walkontable/src/overlay/{bottom.mjs → regions/bottomOverlay.mjs}

@@ -1,8 +1,31 @@
-import { addClass, getScrollbarWidth, getScrollTop, hasClass, outerHeight, removeClass } from '../../../../helpers/dom/element.mjs';
-import BottomOverlayTable from './../table/bottom.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 } from '../../../../../helpers/dom/element.mjs';
+import BottomOverlayTable from '../../table/regions/bottomTable.mjs';
 import { Overlay } from './_base.mjs';
-import { CLONE_BOTTOM } from './constants.mjs';
-import { throwWithCause } from '../../../../helpers/errors.mjs';
+import { CLONE_BOTTOM } from '../constants.mjs';
+import { throwWithCause } from '../../../../../helpers/errors.mjs';
+var /**
+   * Computes the bottom 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 `innerBorderBottom` toggle before rendering, instead of after.
+   *
+   * @param {number} position Header Y position if trimming container is window or scroll top if not.
+   * @returns {{ innerBorderBottom: string, positionChanged: boolean }}
+   */ _computeHeaderBordersState = /*#__PURE__*/ new WeakSet();
 /**
  * @class BottomOverlay
  */ export class BottomOverlay extends Overlay {
@@ -12,8 +35,8 @@ import { throwWithCause } from '../../../../helpers/errors.mjs';
    * @see Table#constructor
    * @param {...*} args Parameters that will be forwarded to the `Table` constructor.
    * @returns {BottomOverlayTable}
-   */ createTable(...args) {
-        return new BottomOverlayTable(...args);
+   */ createTable(deps) {
+        return new BottomOverlayTable(deps);
     }
     /**
    * Checks if overlay should be fully rendered.
@@ -27,11 +50,11 @@ 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 { rootWindow } = this.domBindings;
+        const { rootWindow } = this.deps;
         const overlayRoot = this.clone.wtTable.holder.parentNode;
         overlayRoot.style.top = '';
         let overlayPosition = 0;
@@ -43,8 +66,9 @@ import { throwWithCause } from '../../../../helpers/errors.mjs';
             // fractional CSS pixel past the holder's integer CSS height. Subtract this overflow
             // so the overlay sits flush against the actual table content instead of the
             // CSS-integer hider boundary.
-            const masterTableRect = this.wot.wtTable.TABLE.getBoundingClientRect();
-            const masterHolderRect = this.wot.wtTable.holder.getBoundingClientRect();
+            const { geometryReader } = this.deps;
+            const masterTableRect = geometryReader.getBoundingClientRect(this.deps.getWtTable().TABLE);
+            const masterHolderRect = geometryReader.getBoundingClientRect(this.deps.getWtTable().holder);
             const masterTableOverflow = Math.max(0, masterTableRect.bottom - masterHolderRect.bottom);
             overlayRoot.style.bottom = `${overlayPosition - masterTableOverflow}px`;
         } else {
@@ -61,15 +85,16 @@ import { throwWithCause } from '../../../../helpers/errors.mjs';
         if (!this.clone) {
             return;
         }
-        const { wtTable, wtViewport } = this.wot;
-        const { rootDocument } = this.domBindings;
+        const wtTable = this.deps.getWtTable();
+        const wtViewport = this.deps.getWtViewport();
+        const { rootDocument } = this.deps;
         const cloneRoot = this.clone.wtTable.holder.parentNode;
         let bottomOffset = 0;
         if (!wtViewport.hasVerticalScroll()) {
             bottomOffset += wtViewport.getWorkspaceHeight() - wtTable.getTotalHeight();
         }
         if (wtViewport.hasVerticalScroll() && wtViewport.hasHorizontalScroll()) {
-            bottomOffset += getScrollbarWidth(rootDocument);
+            bottomOffset += this.deps.geometryReader.getScrollbarWidth(rootDocument);
         }
         cloneRoot.style.bottom = `${bottomOffset}px`;
     }
@@ -79,7 +104,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 = ()=>{
@@ -106,22 +131,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 { wtTable, wtSettings } = this.wot;
-        const defaultRowHeight = wtSettings.getSetting('stylesHandler').getDefaultRowHeight();
-        let row = from;
-        let sum = 0;
-        while(row < to){
-            const height = 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).
@@ -138,23 +157,24 @@ 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;
         }
@@ -176,10 +196,12 @@ import { throwWithCause } from '../../../../helpers/errors.mjs';
    * Adjust the overlay dimensions and position.
    */ applyToDOM() {
         const total = this.wtSettings.getSetting('totalRows');
-        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');
@@ -197,8 +219,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] = '';
         }
@@ -210,15 +233,16 @@ import { throwWithCause } from '../../../../helpers/errors.mjs';
    * @param {boolean} [bottomEdge=false] If `true`, scrolls according to the bottom edge (top edge is by default).
    */ scrollTo(sourceRow, bottomEdge) {
         let newY = this.getTableParentOffset();
+        const { geometryReader } = this.deps;
         const sourceInstance = this.wot.cloneSource ? this.wot.cloneSource : this.wot;
         const mainHolder = sourceInstance.wtTable.holder;
         let scrollbarCompensation = 0;
-        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) {
             newY += this.sumCellSizes(0, sourceRow + 1);
-            newY -= this.wot.wtViewport.getViewportHeight();
+            newY -= this.deps.getWtViewport().getViewportHeight();
             // Fix 1 pixel offset when cell is selected
             newY += 1;
         } else {
@@ -232,8 +256,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;
     }
@@ -242,21 +266,21 @@ 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') && this.clone) {
-            const rootHeight = this.wot.wtTable.getTotalHeight();
+            const rootHeight = this.deps.getWtTable().getTotalHeight();
             const overlayRootHeight = this.clone.wtTable.getTotalHeight();
             const maxOffset = rootHeight - overlayRootHeight;
-            const docClientHeight = this.domBindings.rootDocument.documentElement.clientHeight;
+            const docClientHeight = this.deps.geometryReader.clientHeight(this.deps.rootDocument.documentElement);
             overlayOffset = Math.max(this.getTableParentOffset() - this.getScrollPosition() - docClientHeight + rootHeight, 0);
             if (overlayOffset > maxOffset) {
                 overlayOffset = 0;
@@ -265,36 +289,36 @@ import { throwWithCause } from '../../../../helpers/errors.mjs';
         return overlayOffset;
     }
     /**
+   * Pre-applies the header-border class before the cell render (single-pass gated path), so the
+   * post-render `resetFixedPosition` toggle is a no-op and the nested re-draw is skipped. Element mode
+   * only — see `TopOverlay#prepareHeaderBorders`.
+   */ 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.
    * @returns {boolean}
    */ adjustHeaderBordersPosition(position) {
-        const fixedRowsBottom = this.wtSettings.getSetting('fixedRowsBottom');
-        const areFixedRowsBottomChanged = this.cachedFixedRowsBottom !== fixedRowsBottom;
-        const columnHeaders = this.wtSettings.getSetting('columnHeaders');
-        let positionChanged = false;
-        if ((areFixedRowsBottomChanged || fixedRowsBottom === 0) && columnHeaders.length > 0) {
-            const masterParent = this.wot.wtTable.holder.parentNode;
-            const previousState = hasClass(masterParent, 'innerBorderBottom');
+        const masterParent = this.deps.getWtTable().holder.parentNode;
+        const state = _class_private_method_get(this, _computeHeaderBordersState, computeHeaderBordersState).call(this, position);
+        if (state.innerBorderBottom === 'add') {
+            addClass(masterParent, 'innerBorderBottom');
+        } else if (state.innerBorderBottom === 'remove') {
+            removeClass(masterParent, 'innerBorderBottom');
+        }
+        if (state.innerBorderBottom !== 'keep') {
             this.cachedFixedRowsBottom = this.wtSettings.getSetting('fixedRowsBottom');
-            if (position || this.wtSettings.getSetting('totalRows') === 0) {
-                addClass(masterParent, 'innerBorderBottom');
-                positionChanged = !previousState;
-            } else {
-                removeClass(masterParent, 'innerBorderBottom');
-                positionChanged = previousState;
-            }
         }
-        return positionChanged;
+        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_BOTTOM, wtSettings, domBindings), /**
+   */ constructor(deps){
+        super(deps, CLONE_BOTTOM), _class_private_method_init(this, _computeHeaderBordersState), /**
    * Cached value which holds the previous value of the `fixedRowsBottom` option.
    * It is used as a comparison value that can be used to detect changes in that value.
    *
@@ -303,3 +327,26 @@ import { throwWithCause } from '../../../../helpers/errors.mjs';
         this.cachedFixedRowsBottom = this.wtSettings.getSetting('fixedRowsBottom');
     }
 }
+function computeHeaderBordersState(position) {
+    const { wtSettings } = this;
+    const masterParent = this.deps.getWtTable().holder.parentNode;
+    const fixedRowsBottom = wtSettings.getSetting('fixedRowsBottom');
+    const areFixedRowsBottomChanged = this.cachedFixedRowsBottom !== fixedRowsBottom;
+    const columnHeaders = wtSettings.getSetting('columnHeaders');
+    let innerBorderBottom = 'keep';
+    let positionChanged = false;
+    if ((areFixedRowsBottomChanged || fixedRowsBottom === 0) && columnHeaders.length > 0) {
+        const previousState = hasClass(masterParent, 'innerBorderBottom');
+        if (position || wtSettings.getSetting('totalRows') === 0) {
+            innerBorderBottom = 'add';
+            positionChanged = !previousState;
+        } else {
+            innerBorderBottom = 'remove';
+            positionChanged = previousState;
+        }
+    }
+    return {
+        innerBorderBottom,
+        positionChanged
+    };
+}

package/3rdparty/walkontable/src/overlay/regions/inlineStartOverlay.d.mts

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

package/3rdparty/walkontable/src/overlay/{inlineStart.d.ts → regions/inlineStartOverlay.d.ts}

@@ -1,18 +1,14 @@
-import type { DataAccessObject, DomBindings, WalkontableInstance } from '../types';
-import type Settings from '../settings';
-import InlineStartOverlayTable from '../table/inlineStart';
-import { Overlay } from './_base';
+import type { TableDeps } from '../../table/baseTable';
+import InlineStartOverlayTable from '../../table/regions/inlineStartTable';
+import { Overlay, type OverlayDeps } from './_base';
 /**
  * @class InlineStartOverlay
  */
 export declare class InlineStartOverlay extends Overlay {
+    #private;
     /**
-     * @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: WalkontableInstance, facadeGetter: Function, wtSettings: Settings, domBindings: DomBindings);
+    constructor(deps: OverlayDeps);
     /**
      * Factory method to create a subclass of `Table` that is relevant to this overlay.
      *
@@ -20,7 +16,7 @@ export declare class InlineStartOverlay extends Overlay {
      * @param {...*} args Parameters that will be forwarded to the `Table` constructor.
      * @returns {InlineStartOverlayTable}
      */
-    createTable(...args: [DataAccessObject, Function, DomBindings, Settings]): InlineStartOverlayTable;
+    createTable(deps: TableDeps): InlineStartOverlayTable;
     /**
      * Checks if overlay should be fully rendered.
      *
@@ -45,7 +41,11 @@ export declare class InlineStartOverlay extends Overlay {
      */
     onScroll(): void;
     /**
-     * Calculates total sum cells width.
+     * Calculates total sum cells width. Walks the columns live instead of reading the column-width
+     * prefix-sum cache: stretched widths (`stretchH`) are derived from the workspace width, which in
+     * turn depends on this sum — the live read resolves that cycle fresh on every call, while a
+     * cached read would freeze pre-stretch widths (nothing invalidates the cache when stretching
+     * recomputes). Column counts stay far below row counts, so this walk is not a scroll hotspot.
      *
      * @param {number} from Column index which calculates started from.
      * @param {number} to Column index where calculation is finished.
@@ -99,6 +99,12 @@ export declare class InlineStartOverlay extends Overlay {
      * @returns {number} Main table's horizontal overlay offset.
      */
     getOverlayOffset(): number;
+    /**
+     * Pre-applies the `innerBorderInlineStart` class before the cell render (single-pass gated
+     * path), so the post-render `resetFixedPosition` toggle is a no-op and the nested re-draw is
+     * skipped. Element mode only — see `TopOverlay#prepareHeaderBorders`.
+     */
+    prepareHeaderBorders(): void;
     /**
      * Adds css classes to hide the header border's header (cell-selection border hiding issue).
      *