handsontable 18.0.0 → 18.1.0-rc1

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

@@ -8,17 +8,38 @@ Object.defineProperty(exports, "InlineStartOverlay", {
         return InlineStartOverlay;
     }
 });
-const _element = require("../../../../helpers/dom/element");
-const _inlineStart = /*#__PURE__*/ _interop_require_default(require("../table/inlineStart"));
+const _element = require("../../../../../helpers/dom/element");
+const _inlineStartTable = /*#__PURE__*/ _interop_require_default(require("../../table/regions/inlineStartTable"));
 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 inline-start 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 `innerBorderInlineStart` toggle before rendering, instead of after.
+   *
+   * @param {number} position The overlay offset that decides whether the inline-start border is shown.
+   * @returns {{ hasEmptyRows: boolean, innerBorder: string, positionChanged: boolean }}
+   */ _computeHeaderBordersState = /*#__PURE__*/ new WeakSet();
 class InlineStartOverlay extends _base.Overlay {
     /**
    * Factory method to create a subclass of `Table` that is relevant to this overlay.
@@ -26,8 +47,8 @@ class InlineStartOverlay extends _base.Overlay {
    * @see Table#constructor
    * @param {...*} args Parameters that will be forwarded to the `Table` constructor.
    * @returns {InlineStartOverlayTable}
-   */ createTable(...args) {
-        return new _inlineStart.default(...args);
+   */ createTable(deps) {
+        return new _inlineStartTable.default(deps);
     }
     /**
    * Checks if overlay should be fully rendered.
@@ -41,7 +62,7 @@ class InlineStartOverlay extends _base.Overlay {
    *
    * @returns {boolean}
    */ resetFixedPosition() {
-        const { wtTable } = this.wot;
+        const wtTable = this.deps.getWtTable();
         if (!this.needFullRender || !this.shouldBeRendered() || !wtTable.holder.parentNode) {
             // removed from DOM
             return false;
@@ -49,7 +70,7 @@ class InlineStartOverlay extends _base.Overlay {
         if (!this.clone) {
             return false;
         }
-        const { rootWindow } = this.domBindings;
+        const { rootWindow } = this.deps;
         const overlayRoot = this.clone.wtTable.holder.parentNode;
         const preventOverflow = this.wtSettings.getSetting('preventOverflow');
         let overlayPosition = 0;
@@ -70,7 +91,7 @@ class InlineStartOverlay 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 = ()=>{
@@ -100,7 +121,11 @@ class InlineStartOverlay extends _base.Overlay {
         this.wtSettings.getSetting('onScrollVertically');
     }
     /**
-   * 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.
@@ -110,7 +135,7 @@ class InlineStartOverlay extends _base.Overlay {
         let column = from;
         let sum = 0;
         while(column < to){
-            sum += this.wot.wtTable.getColumnWidth(column) || defaultColumnWidth;
+            sum += this.deps.getWtTable().getColumnWidth(column) || defaultColumnWidth;
             column += 1;
         }
         return sum;
@@ -130,8 +155,9 @@ class InlineStartOverlay 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');
@@ -144,16 +170,16 @@ class InlineStartOverlay extends _base.Overlay {
                 // from the real scrollbar size, giving the frozen overlay a different vertical scroll range
                 // than the master. That mismatch clamps the overlay's scrollTop ~1px short at the bottom and
                 // shifts the frozen rows out of alignment (#12632).
-                const masterClientHeight = wtTable.holder.clientHeight;
-                height = masterClientHeight > 0 ? masterClientHeight : height - (0, _element.getScrollbarWidth)(rootDocument);
+                const masterClientHeight = this.deps.geometryReader.clientHeight(wtTable.holder);
+                height = masterClientHeight > 0 ? masterClientHeight : height - this.deps.geometryReader.getScrollbarWidth(rootDocument);
             }
-            height = Math.min(height, wtTable.wtRootElement.scrollHeight);
+            height = Math.min(height, this.deps.geometryReader.scrollHeight(wtTable.wtRootElement));
             overlayRootStyle.height = `${height}px`;
         } else {
             overlayRootStyle.height = '';
         }
         this.clone.wtTable.holder.style.height = overlayRootStyle.height;
-        const tableWidth = (0, _element.outerWidth)(this.clone.wtTable.TABLE);
+        const tableWidth = this.deps.geometryReader.outerWidth(this.clone.wtTable.TABLE);
         overlayRootStyle.width = `${tableWidth}px`;
     }
     /**
@@ -164,7 +190,7 @@ class InlineStartOverlay extends _base.Overlay {
         }
         const { holder } = this.clone.wtTable;
         const cornerStyle = (0, _selection.getCornerStyle)(this.wot);
-        const selectionCornerOffset = this.wot.selectionManager.getFocusSelection() ? parseInt(cornerStyle.width, 10) / 2 : 0;
+        const selectionCornerOffset = this.deps.getSelectionManager().getFocusSelection() ? parseInt(cornerStyle.width, 10) / 2 : 0;
         this.clone.wtTable.hider.style.height = this.hider.style.height;
         const holderParent = holder.parentNode;
         holder.style.height = holderParent.style.height;
@@ -177,9 +203,12 @@ class InlineStartOverlay extends _base.Overlay {
    */ applyToDOM() {
         const total = this.wtSettings.getSetting('totalColumns');
         const styleProperty = this.isRtl() ? 'right' : 'left';
-        if (typeof this.wot.wtViewport.columnsRenderCalculator?.startPosition === 'number') {
-            this.spreader.style[styleProperty] = `${this.wot.wtViewport.columnsRenderCalculator.startPosition}px`;
-        } else if (total === 0) {
+        const columnsRenderCalculator = this.deps.getWtViewport().columnsRenderCalculator;
+        if (typeof columnsRenderCalculator?.startPosition === 'number') {
+            this.spreader.style[styleProperty] = `${columnsRenderCalculator.startPosition}px`;
+        } else if (total === 0 || columnsRenderCalculator === null) {
+            // 0 columns, 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[styleProperty] = '0';
         } else {
             (0, _errors.throwWithCause)('Incorrect value of the columnsRenderCalculator');
@@ -199,8 +228,9 @@ class InlineStartOverlay extends _base.Overlay {
         if (!this.clone) {
             return;
         }
-        if (typeof this.wot.wtViewport.rowsRenderCalculator?.startPosition === 'number') {
-            this.clone.wtTable.spreader.style.top = `${this.wot.wtViewport.rowsRenderCalculator.startPosition}px`;
+        const rowsRenderCalculator = this.deps.getWtViewport().rowsRenderCalculator;
+        if (typeof rowsRenderCalculator?.startPosition === 'number') {
+            this.clone.wtTable.spreader.style.top = `${rowsRenderCalculator.startPosition}px`;
         } else {
             this.clone.wtTable.spreader.style.top = '';
         }
@@ -214,6 +244,7 @@ class InlineStartOverlay extends _base.Overlay {
    * @returns {boolean}
    */ scrollTo(sourceCol, beyondRendered) {
         const { wtSettings } = this;
+        const { geometryReader } = this.deps;
         const rowHeaders = wtSettings.getSetting('rowHeaders');
         const fixedColumnsStart = wtSettings.getSetting('fixedColumnsStart');
         const sourceInstance = this.wot.cloneSource ? this.wot.cloneSource : this.wot;
@@ -222,18 +253,18 @@ class InlineStartOverlay extends _base.Overlay {
         let newX = this.getTableParentOffset();
         let scrollbarCompensation = 0;
         if (beyondRendered) {
-            const columnWidth = this.wot.wtTable.getColumnWidth(sourceCol);
-            const viewportWidth = this.wot.wtViewport.getViewportWidth();
+            const columnWidth = this.deps.getWtTable().getColumnWidth(sourceCol);
+            const viewportWidth = this.deps.getWtViewport().getViewportWidth();
             if (columnWidth > viewportWidth) {
                 beyondRendered = false;
             }
         }
-        if (beyondRendered && mainHolder.offsetWidth !== mainHolder.clientWidth) {
-            scrollbarCompensation = (0, _element.getScrollbarWidth)(this.domBindings.rootDocument);
+        if (beyondRendered && geometryReader.offsetWidth(mainHolder) !== geometryReader.clientWidth(mainHolder)) {
+            scrollbarCompensation = geometryReader.getScrollbarWidth(this.deps.rootDocument);
         }
         if (beyondRendered) {
             newX += this.sumCellSizes(0, sourceCol + 1);
-            newX -= this.wot.wtViewport.getViewportWidth();
+            newX -= this.deps.getWtViewport().getViewportWidth();
             // Compensate for the right header border if scrolled from the absolute left.
             newX += rowHeaderBorderCompensation;
         } else {
@@ -242,8 +273,8 @@ class InlineStartOverlay extends _base.Overlay {
         newX += scrollbarCompensation;
         // If the table is scrolled all the way left when starting the scroll and going to be scrolled to the far right,
         // we need to compensate for the potential header border width.
-        if ((0, _element.getMaximumScrollLeft)(this.mainTableScrollableElement) === newX - rowHeaderBorderCompensation && rowHeaderBorderCompensation > 0) {
-            this.wot.wtOverlays.expandHiderHorizontallyBy(rowHeaderBorderCompensation);
+        if (geometryReader.getMaximumScrollLeft(this.mainTableScrollableElement) === newX - rowHeaderBorderCompensation && rowHeaderBorderCompensation > 0) {
+            this.deps.getWtOverlays().expandHiderHorizontallyBy(rowHeaderBorderCompensation);
         }
         return this.setScrollPosition(newX);
     }
@@ -254,8 +285,8 @@ class InlineStartOverlay extends _base.Overlay {
    */ getTableParentOffset() {
         const preventOverflow = this.wtSettings.getSetting('preventOverflow');
         let offset = 0;
-        if (!preventOverflow && this.trimmingContainer === this.domBindings.rootWindow) {
-            offset = this.wot.wtTable.holderOffset.left;
+        if (!preventOverflow && this.trimmingContainer === this.deps.rootWindow) {
+            offset = this.deps.getWtTable().holderOffset.left;
         }
         return offset;
     }
@@ -264,14 +295,14 @@ class InlineStartOverlay extends _base.Overlay {
    *
    * @returns {number} Main table's horizontal scroll position.
    */ getScrollPosition() {
-        return Math.abs((0, _element.getScrollLeft)(this.mainTableScrollableElement, this.domBindings.rootWindow));
+        return Math.abs((0, _element.getScrollLeft)(this.mainTableScrollableElement, this.deps.rootWindow));
     }
     /**
    * Gets the main overlay's horizontal overlay offset.
    *
    * @returns {number} Main table's horizontal 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 !== 'horizontal')) {
@@ -280,7 +311,7 @@ class InlineStartOverlay extends _base.Overlay {
             } else {
                 overlayOffset = Math.max(this.getScrollPosition() - this.getTableParentOffset(), 0);
             }
-            const rootWidth = this.wot.wtTable.getTotalWidth();
+            const rootWidth = this.deps.getWtTable().getTotalWidth();
             const overlayRootWidth = this.clone ? this.clone.wtTable.getTotalWidth() : 0;
             const maxOffset = rootWidth - overlayRootWidth;
             if (overlayOffset > maxOffset) {
@@ -290,46 +321,68 @@ class InlineStartOverlay extends _base.Overlay {
         return overlayOffset;
     }
     /**
+   * 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() {
+        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 X position if trimming container is window or scroll top if not.
    * @returns {boolean}
    */ adjustHeaderBordersPosition(position) {
-        const { wtSettings } = this;
-        const masterParent = this.wot.wtTable.holder.parentNode;
-        const rowHeaders = wtSettings.getSetting('rowHeaders');
-        const fixedColumnsStart = wtSettings.getSetting('fixedColumnsStart');
-        const totalRows = wtSettings.getSetting('totalRows');
-        const preventVerticalOverflow = wtSettings.getSetting('preventOverflow') === 'vertical';
-        if (totalRows) {
-            (0, _element.removeClass)(masterParent, 'emptyRows');
-        } else {
+        const masterParent = this.deps.getWtTable().holder.parentNode;
+        const state = _class_private_method_get(this, _computeHeaderBordersState, computeHeaderBordersState).call(this, position);
+        if (state.hasEmptyRows) {
             (0, _element.addClass)(masterParent, 'emptyRows');
+        } else {
+            (0, _element.removeClass)(masterParent, 'emptyRows');
         }
-        let positionChanged = false;
-        if (!preventVerticalOverflow) {
-            if (fixedColumnsStart && !rowHeaders.length) {
-                // "innerBorderLeft" is for backward compatibility
-                (0, _element.addClass)(masterParent, 'innerBorderLeft innerBorderInlineStart');
-            } else if (!fixedColumnsStart && rowHeaders.length) {
-                const previousState = (0, _element.hasClass)(masterParent, 'innerBorderInlineStart');
-                if (position) {
-                    (0, _element.addClass)(masterParent, 'innerBorderLeft innerBorderInlineStart');
-                    positionChanged = !previousState;
-                } else {
-                    (0, _element.removeClass)(masterParent, 'innerBorderLeft innerBorderInlineStart');
-                    positionChanged = previousState;
-                }
-            }
+        // "innerBorderLeft" is for backward compatibility.
+        if (state.innerBorder === 'add') {
+            (0, _element.addClass)(masterParent, 'innerBorderLeft innerBorderInlineStart');
+        } else if (state.innerBorder === 'remove') {
+            (0, _element.removeClass)(masterParent, 'innerBorderLeft innerBorderInlineStart');
         }
-        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, _constants.CLONE_INLINE_START, wtSettings, domBindings);
+   */ constructor(deps){
+        super(deps, _constants.CLONE_INLINE_START), _class_private_method_init(this, _computeHeaderBordersState);
     }
 }
+function computeHeaderBordersState(position) {
+    const { wtSettings } = this;
+    const masterParent = this.deps.getWtTable().holder.parentNode;
+    const rowHeaders = wtSettings.getSetting('rowHeaders');
+    const fixedColumnsStart = wtSettings.getSetting('fixedColumnsStart');
+    const totalRows = wtSettings.getSetting('totalRows');
+    const preventVerticalOverflow = wtSettings.getSetting('preventOverflow') === 'vertical';
+    const hasEmptyRows = !totalRows;
+    let innerBorder = 'keep';
+    let positionChanged = false;
+    if (!preventVerticalOverflow) {
+        if (fixedColumnsStart && !rowHeaders.length) {
+            innerBorder = 'add';
+        } else if (!fixedColumnsStart && rowHeaders.length) {
+            const previousState = (0, _element.hasClass)(masterParent, 'innerBorderInlineStart');
+            if (position) {
+                innerBorder = 'add';
+                positionChanged = !previousState;
+            } else {
+                innerBorder = 'remove';
+                positionChanged = previousState;
+            }
+        }
+    }
+    return {
+        hasEmptyRows,
+        innerBorder,
+        positionChanged
+    };
+}