handsontable 17.1.0 → 18.0.0-rc2

package/3rdparty/walkontable/src/table.js

@@ -9,7 +9,6 @@ Object.defineProperty(exports, "default", {
     }
 });
 const _element = require("../../../helpers/dom/element");
-const _function = require("../../../helpers/function");
 const _column = /*#__PURE__*/ _interop_require_default(require("./filter/column"));
 const _row = /*#__PURE__*/ _interop_require_default(require("./filter/row"));
 const _renderer = require("./renderer");
@@ -34,6 +33,17 @@ function _interop_require_default(obj) {
  * @mixes calculatedColumns
  * @abstract
  */ class Table {
+    // Methods defined in subclass MasterTable but called from Table via `this.isMaster` guards.
+    /**
+   * Aligns overlays with the trimming container.
+   *
+   * @returns {void}
+   */ alignOverlaysWithTrimmingContainer() {}
+    /**
+   * Marks oversized column headers.
+   *
+   * @returns {void}
+   */ markOversizedColumnHeaders() {}
     /**
    * Returns a boolean that is true if this Table represents a specific overlay, identified by the overlay name.
    * For MasterTable, it returns false.
@@ -69,20 +79,22 @@ function _interop_require_default(obj) {
    */ createSpreader(table) {
         const parent = table.parentNode;
         let spreader;
-        if (!parent || parent.nodeType !== Node.ELEMENT_NODE || !(0, _element.hasClass)(parent, 'wtHolder')) {
+        if (!parent || parent.nodeType !== Node.ELEMENT_NODE || !(0, _element.isHTMLElement)(parent) || !(0, _element.hasClass)(parent, 'wtHolder')) {
             spreader = this.domBindings.rootDocument.createElement('div');
             spreader.className = 'wtSpreader';
             if (parent) {
                 // if TABLE is detached (e.g. in Jasmine test), it has no parentNode so we cannot attach holder to it
-                parent.insertBefore(spreader, table);
+                table.before(spreader);
             }
             spreader.appendChild(table);
         }
-        spreader.style.position = 'relative';
-        if (this.wtSettings.getSetting('ariaTags')) {
-            (0, _element.setAttribute)(spreader, [
-                (0, _a11y.A11Y_PRESENTATION)()
-            ]);
+        if (spreader) {
+            spreader.style.position = 'relative';
+            if (this.wtSettings.getSetting('ariaTags')) {
+                (0, _element.setAttribute)(spreader, [
+                    (0, _a11y.A11Y_PRESENTATION)()
+                ]);
+            }
         }
         return spreader;
     }
@@ -92,16 +104,16 @@ function _interop_require_default(obj) {
    */ createHider(spreader) {
         const parent = spreader.parentNode;
         let hider;
-        if (!parent || parent.nodeType !== Node.ELEMENT_NODE || !(0, _element.hasClass)(parent, 'wtHolder')) {
+        if (!parent || parent.nodeType !== Node.ELEMENT_NODE || !(0, _element.isHTMLElement)(parent) || !(0, _element.hasClass)(parent, 'wtHolder')) {
             hider = this.domBindings.rootDocument.createElement('div');
             hider.className = 'wtHider';
             if (parent) {
                 // if TABLE is detached (e.g. in Jasmine test), it has no parentNode so we cannot attach holder to it
-                parent.insertBefore(hider, spreader);
+                spreader.before(hider);
             }
             hider.appendChild(spreader);
         }
-        if (this.wtSettings.getSetting('ariaTags')) {
+        if (hider && this.wtSettings.getSetting('ariaTags')) {
             (0, _element.setAttribute)(hider, [
                 (0, _a11y.A11Y_PRESENTATION)()
             ]);
@@ -115,7 +127,7 @@ function _interop_require_default(obj) {
    */ createHolder(hider) {
         const parent = hider.parentNode;
         let holder;
-        if (!parent || parent.nodeType !== Node.ELEMENT_NODE || !(0, _element.hasClass)(parent, 'wtHolder')) {
+        if (!parent || parent.nodeType !== Node.ELEMENT_NODE || !(0, _element.isHTMLElement)(parent) || !(0, _element.hasClass)(parent, 'wtHolder')) {
             holder = this.domBindings.rootDocument.createElement('div');
             holder.style.position = 'relative';
             holder.className = 'wtHolder';
@@ -126,20 +138,27 @@ function _interop_require_default(obj) {
             }
             if (parent) {
                 // if TABLE is detached (e.g. in Jasmine test), it has no parentNode so we cannot attach holder to it
-                parent.insertBefore(holder, hider);
+                hider.before(holder);
             }
             if (this.isMaster) {
-                holder.parentNode.className += 'ht_master handsontable';
-                holder.parentNode.setAttribute('dir', this.wtSettings.getSettingPure('rtlMode') ? 'rtl' : 'ltr');
-                if (this.wtSettings.getSetting('ariaTags')) {
-                    (0, _element.setAttribute)(holder.parentNode, [
-                        (0, _a11y.A11Y_PRESENTATION)()
-                    ]);
+                const holderParent = holder.parentNode;
+                // holderParent is null when TABLE is detached (e.g. in Jasmine tests); skip class assignment in that case.
+                // isHTMLElement() is used instead of `instanceof HTMLElement` because the latter fails in
+                // cross-frame contexts (e.g. when HoT is mounted inside an <iframe> via React portals):
+                // the iframe's HTMLElement constructor !== the parent frame's HTMLElement.
+                if ((0, _element.isHTMLElement)(holderParent)) {
+                    holderParent.className += 'ht_master handsontable';
+                    holderParent.setAttribute('dir', this.wtSettings.getSettingPure('rtlMode') ? 'rtl' : 'ltr');
+                    if (this.wtSettings.getSetting('ariaTags')) {
+                        (0, _element.setAttribute)(holderParent, [
+                            (0, _a11y.A11Y_PRESENTATION)()
+                        ]);
+                    }
                 }
             }
             holder.appendChild(hider);
         }
-        if (this.wtSettings.getSetting('ariaTags')) {
+        if (holder && this.wtSettings.getSetting('ariaTags')) {
             (0, _element.setAttribute)(holder, [
                 (0, _a11y.A11Y_PRESENTATION)()
             ]);
@@ -180,6 +199,11 @@ function _interop_require_default(obj) {
         if (runFastDraw) {
             if (this.isMaster) {
                 wtOverlays.refresh(true);
+                // Fast (scroll) draws skip the full-render header-height pass below, so the master/top
+                // header heights can drift against the frozen overlays during scrolling (a tall wrapped
+                // frozen header that the master never renders). Re-sync here. The method is a cheap no-op
+                // unless the grid has frozen columns with column headers, so non-frozen grids are unaffected.
+                this.syncOversizedColumnHeadersWithFrozenOverlays();
             }
         } else {
             if (this.isMaster) {
@@ -189,8 +213,8 @@ function _interop_require_default(obj) {
             }
             const startRow = Math.max(this.getFirstRenderedRow(), 0);
             const startColumn = Math.max(this.getFirstRenderedColumn(), 0);
-            this.rowFilter = new _row.default(startRow, totalRows, columnHeadersCount);
-            this.columnFilter = new _column.default(startColumn, totalColumns, rowHeadersCount);
+            this.rowFilter = new _row.default(startRow, wtSettings.getSetting('totalRows'), columnHeadersCount);
+            this.columnFilter = new _column.default(startColumn, wtSettings.getSetting('totalColumns'), rowHeadersCount);
             let performRedraw = true;
             // Only master table rendering can be skipped
             if (this.isMaster) {
@@ -224,6 +248,7 @@ function _interop_require_default(obj) {
                         wtViewport.createVisibleCalculators();
                     }
                     wtOverlays.refresh(false);
+                    this.syncOversizedColumnHeadersWithFrozenOverlays();
                     wtOverlays.applyToDOM();
                     this.wtSettings.getSetting('onDraw', true);
                 } else if (this.is(_overlay.CLONE_BOTTOM)) {
@@ -288,8 +313,10 @@ function _interop_require_default(obj) {
             } else if (!isNaN(columnHeaderHeightSetting)) {
                 this.dataAccessObject.wtViewport.oversizedColumnHeaders[level] = columnHeaderHeightSetting;
             }
-            if (this.dataAccessObject.wtViewport.oversizedColumnHeaders[level] < (columnHeaderHeightSetting[level] || columnHeaderHeightSetting)) {
-                this.dataAccessObject.wtViewport.oversizedColumnHeaders[level] = columnHeaderHeightSetting[level] || columnHeaderHeightSetting; // eslint-disable-line max-len
+            const headerHeightAtLevel = Array.isArray(columnHeaderHeightSetting) // eslint-disable-line max-len
+             ? columnHeaderHeightSetting[level] ?? 0 : columnHeaderHeightSetting;
+            if ((this.dataAccessObject.wtViewport.oversizedColumnHeaders[level] ?? 0) < headerHeightAtLevel) {
+                this.dataAccessObject.wtViewport.oversizedColumnHeaders[level] = headerHeightAtLevel;
             }
         }
     }
@@ -305,7 +332,10 @@ function _interop_require_default(obj) {
                 if (!children[i] || children[i].childNodes.length === 0) {
                     return;
                 }
-                children[i].childNodes[0].style.height = `${oversizedColumnHeaders[i]}px`;
+                const firstChild = children[i].childNodes[0];
+                if ((0, _element.isHTMLElement)(firstChild)) {
+                    firstChild.style.height = `${oversizedColumnHeaders[i]}px`;
+                }
             }
         }
     }
@@ -325,13 +355,74 @@ function _interop_require_default(obj) {
             if (!children[i] || !oversizedColumnHeaders[i]) {
                 continue;
             }
-            const actualRowHeight = (0, _element.innerHeight)(children[i]);
-            if (actualRowHeight > oversizedColumnHeaders[i] + borderCompensation) {
+            const child = children[i];
+            const actualRowHeight = (0, _element.isHTMLElement)(child) ? (0, _element.innerHeight)(child) : 0;
+            if (actualRowHeight > (oversizedColumnHeaders[i] ?? 0) + borderCompensation) {
                 oversizedColumnHeaders[i] = actualRowHeight;
             }
         }
     }
     /**
+   * Frozen column headers (e.g., with `white-space: normal`) are rendered only in the frozen
+   * overlays, never in the master table's THEAD. When such a header is taller than the headers
+   * of the scrollable columns, the master and top overlay THEADs render shorter than the corner
+   * and inline-start overlays, so the frozen overlay body rows sit shifted against the master.
+   * The gap can be sub-pixel: under browser zoom the frozen header content is a fraction of a
+   * pixel taller than the applied height, and that fraction accumulates into a visible 1px shift.
+   *
+   * This method runs after the frozen overlays have rendered. It reads the corner overlay's
+   * content-driven THEAD row heights with sub-pixel precision and forces the matching master and
+   * top overlay header cells to the same height so every overlay THEAD ends up the same height
+   * and the body rows stay pixel-aligned.
+   *
+   * It deliberately does NOT write to `wtViewport.oversizedColumnHeaders`. That cache is applied
+   * back to the corner overlay on the next render; growing it here would inflate the corner cell,
+   * which would then be re-measured taller, ratcheting the height up every render. Reading the
+   * corner's natural (content-driven) height and only adjusting the master/top side keeps the
+   * synchronization stable and lets the header shrink again when the content allows.
+   */ syncOversizedColumnHeadersWithFrozenOverlays() {
+        const { wtOverlays } = this.dataAccessObject;
+        // Cheapest possible bail-out first: with no frozen columns the corner overlay is not cloned,
+        // so the overwhelmingly common (non-frozen) grids pay only a couple of property reads per draw.
+        const cornerClone = wtOverlays.topInlineStartCornerOverlay?.clone;
+        if (!cornerClone?.wtTable?.THEAD) {
+            return;
+        }
+        const columnHeaders = this.wtSettings.getSetting('columnHeaders');
+        if (!columnHeaders.length) {
+            return;
+        }
+        const cornerChildren = cornerClone.wtTable.THEAD.childNodes;
+        const topClone = wtOverlays.topOverlay?.clone;
+        const targetTheads = [
+            this.THEAD,
+            topClone?.wtTable?.THEAD
+        ];
+        // Sub-pixel tolerance to avoid rewriting heights on floating-point jitter while still
+        // catching the fractional gaps (e.g. ~0.33px at 75% zoom) that read as a 1px shift.
+        const epsilon = 0.1;
+        for(let i = 0, len = columnHeaders.length; i < len; i++){
+            const cornerChild = cornerChildren[i];
+            if (!(cornerChild instanceof HTMLElement)) {
+                continue;
+            }
+            const cornerRowHeight = cornerChild.getBoundingClientRect().height;
+            targetTheads.forEach((thead)=>{
+                const targetRow = thead?.childNodes[i];
+                if (!(targetRow instanceof HTMLElement) || targetRow.childNodes.length === 0) {
+                    return;
+                }
+                const firstChild = targetRow.childNodes[0];
+                if (!(firstChild instanceof HTMLElement)) {
+                    return;
+                }
+                if (Math.abs(targetRow.getBoundingClientRect().height - cornerRowHeight) > epsilon) {
+                    firstChild.style.height = `${cornerRowHeight}px`;
+                }
+            });
+        }
+    }
+    /**
    * Resets cache of row heights. The cache should be cached for each render cycle in a case
    * when new cell values have content which increases/decreases cell height.
    */ resetOversizedRows() {
@@ -370,10 +461,15 @@ function _interop_require_default(obj) {
    *  -3 column before viewport
    *  -4 column after viewport.
    */ getCell(coords) {
+        if (coords.row === null || coords.col === null) {
+            return -5;
+        }
         let row = coords.row;
         let column = coords.col;
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
         const hookResult = this.wtSettings.getSetting('onModifyGetCellCoords', row, column, !this.isMaster, 'render');
         if (hookResult && Array.isArray(hookResult)) {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
             [row, column] = hookResult;
         }
         if (this.isRowBeforeRenderedRows(row)) {
@@ -393,10 +489,14 @@ function _interop_require_default(obj) {
         if (!TR && row >= 0) {
             (0, _errors.throwWithCause)('TR was expected to be rendered but is not');
         }
-        const TD = TR.childNodes[this.columnFilter.sourceColumnToVisibleRowHeadedColumn(column)];
+        const trElement = TR !== false ? TR : null;
+        const TD = trElement?.childNodes[this.columnFilter.sourceColumnToVisibleRowHeadedColumn(column)];
         if (!TD && column >= 0) {
             (0, _errors.throwWithCause)('TD or TH was expected to be rendered but is not');
         }
+        // TD is a TD/TH HTMLElement guaranteed by DOM structure. TypeScript cannot narrow ChildNode
+        // to HTMLElement without instanceof, but adding a throw here would change the existing contract
+        // for negative column (header) lookups where TD may be undefined.
         return TD;
     }
     /**
@@ -415,7 +515,7 @@ function _interop_require_default(obj) {
             renderedRowIndex = this.rowFilter?.sourceToRendered(rowIndex);
             parentElement = this.TBODY;
         }
-        if (renderedRowIndex !== undefined && parentElement !== undefined) {
+        if (renderedRowIndex !== undefined && renderedRowIndex !== null && parentElement !== null) {
             if (parentElement.childNodes.length < renderedRowIndex + 1) {
                 return false;
             } else {
@@ -432,7 +532,8 @@ function _interop_require_default(obj) {
    * @returns {object} HTMLElement on success or undefined on error.
    */ getColumnHeader(col, level = 0) {
         const TR = this.THEAD.childNodes[level];
-        return TR?.childNodes[this.columnFilter.sourceColumnToVisibleRowHeadedColumn(col)];
+        const TH = TR?.childNodes[this.columnFilter.sourceColumnToVisibleRowHeadedColumn(col)];
+        return (0, _element.isHTMLElement)(TH) ? TH : undefined;
     }
     /**
    * Gets all columns headers (TH elements) from the table.
@@ -444,7 +545,7 @@ function _interop_require_default(obj) {
         const visibleColumn = this.columnFilter.sourceColumnToVisibleRowHeadedColumn(column);
         this.THEAD.childNodes.forEach((TR)=>{
             const TH = TR.childNodes[visibleColumn];
-            if (TH) {
+            if ((0, _element.isHTMLTableCellElement)(TH)) {
                 THs.push(TH);
             }
         });
@@ -460,13 +561,14 @@ function _interop_require_default(obj) {
    */ getRowHeader(row, level = 0) {
         const rowHeadersCount = this.wtSettings.getSetting('rowHeaders').length;
         if (level >= rowHeadersCount) {
-            return;
+            return undefined;
         }
         const renderedRow = this.rowFilter.sourceToRendered(row);
         const visibleRow = renderedRow < 0 ? this.rowFilter.sourceRowToVisibleColHeadedRow(row) : renderedRow;
         const parentElement = renderedRow < 0 ? this.THEAD : this.TBODY;
-        const TR = parentElement.childNodes[visibleRow];
-        return TR?.childNodes[level];
+        const TR = parentElement?.childNodes[visibleRow];
+        const TH = TR?.childNodes[level];
+        return (0, _element.isHTMLElement)(TH) ? TH : undefined;
     }
     /**
    * Gets all rows headers (TH elements) from the table.
@@ -507,8 +609,11 @@ function _interop_require_default(obj) {
             return null;
         }
         const CONTAINER = TR.parentNode;
-        let row = (0, _element.index)(TR);
-        let col = cellElement.cellIndex;
+        if (!CONTAINER) {
+            return null;
+        }
+        let row = (0, _element.isHTMLElement)(TR) ? (0, _element.index)(TR) : 0;
+        let col = (0, _element.isHTMLTableCellElement)(cellElement) ? cellElement.cellIndex : 0;
         if ((0, _element.overlayContainsElement)(_overlay.CLONE_TOP_INLINE_START_CORNER, cellElement, this.wtRootElement) || (0, _element.overlayContainsElement)(_overlay.CLONE_TOP, cellElement, this.wtRootElement)) {
             if (CONTAINER.nodeName === 'THEAD') {
                 row -= CONTAINER.childNodes.length;
@@ -526,8 +631,10 @@ function _interop_require_default(obj) {
         } else if (this.columnFilter) {
             col = this.columnFilter.visibleRowHeadedColumnToSourceColumn(col);
         }
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
         const hookResult = this.wtSettings.getSetting('onModifyGetCoordsElement', row, col);
         if (hookResult && Array.isArray(hookResult)) {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
             [row, col] = hookResult;
         }
         return this.wot.createCellCoords(row, col);
@@ -563,13 +670,17 @@ function _interop_require_default(obj) {
             previousRowHeight = this.getRowHeight(sourceRowIndex);
             currentTr = this.getTrForRow(sourceRowIndex);
             rowHeader = currentTr.querySelector('th');
-            const topBorderCompensation = sourceRowIndex === 0 ? firstRowBorderCompensation : 0;
+            // Use the rendered row index (rowCount === 0 is always the first <tr> in this tbody),
+            // not the source row index (which would be wrong for clones whose first rendered row
+            // has a different source index). Any tbody's first <tr> gets border-top: 1px from the
+            // tr:first-child CSS rule, so the compensation applies regardless of source identity.
+            const topBorderCompensation = rowCount === 0 ? firstRowBorderCompensation : 0;
             if (rowHeader) {
                 rowCurrentHeight = rowHeightFn(rowHeader);
             } else {
                 rowCurrentHeight = rowHeightFn(currentTr) - borderCompensation;
             }
-            if (!previousRowHeight && stylesHandler.getDefaultRowHeight() < rowCurrentHeight - topBorderCompensation || previousRowHeight < rowCurrentHeight) {
+            if (!previousRowHeight && stylesHandler.getDefaultRowHeight() < rowCurrentHeight - topBorderCompensation || previousRowHeight !== undefined && previousRowHeight < rowCurrentHeight) {
                 if (!borderBoxSizing) {
                     rowCurrentHeight += 1;
                 }
@@ -583,7 +694,7 @@ function _interop_require_default(obj) {
     }
     /**
    * @param {number} row The visual row index.
-   * @returns {HTMLTableElement}
+   * @returns {HTMLTableRowElement}
    */ getTrForRow(row) {
         return this.TBODY.childNodes[this.rowFilter.sourceToRendered(row)];
     }
@@ -613,7 +724,7 @@ function _interop_require_default(obj) {
         const columnHeadersCount = columnHeaders.length;
         return Math.abs(row) <= columnHeadersCount;
     }
-    /* eslint-disable jsdoc/require-description-complete-sentence */ /**
+    /**
    * Check if the given row index is lower than the index of the first row that
    * is currently rendered and return TRUE in that case, or FALSE otherwise.
    *
@@ -640,7 +751,7 @@ function _interop_require_default(obj) {
    * @memberof Table#
    * @function isRowBeforeRenderedRows
    * @returns {boolean}
-   */ /* eslint-enable jsdoc/require-description-complete-sentence */ isRowBeforeRenderedRows(row) {
+   */ isRowBeforeRenderedRows(row) {
         const first = this.getFirstRenderedRow();
         // Check the headers only in case when the first rendered row is -1 or 0.
         // This is an indication that the overlay is placed on the most top position.
@@ -649,7 +760,7 @@ function _interop_require_default(obj) {
         }
         return row < first;
     }
-    /* eslint-disable jsdoc/require-description-complete-sentence */ /**
+    /**
    * Check if the given column index is greater than the index of the last column that
    * is currently rendered and return TRUE in that case, or FALSE otherwise.
    *
@@ -679,10 +790,10 @@ function _interop_require_default(obj) {
    * @memberof Table#
    * @function isRowAfterRenderedRows
    * @returns {boolean}
-   */ /* eslint-enable jsdoc/require-description-complete-sentence */ isRowAfterRenderedRows(row) {
+   */ isRowAfterRenderedRows(row) {
         return row > this.getLastRenderedRow();
     }
-    /* eslint-disable jsdoc/require-description-complete-sentence */ /**
+    /**
    * Check if the given column index is lower than the index of the first column that
    * is currently rendered and return TRUE in that case, or FALSE otherwise.
    *
@@ -708,7 +819,7 @@ function _interop_require_default(obj) {
    * @memberof Table#
    * @function isColumnBeforeRenderedColumns
    * @returns {boolean}
-   */ /* eslint-enable jsdoc/require-description-complete-sentence */ isColumnBeforeRenderedColumns(column) {
+   */ isColumnBeforeRenderedColumns(column) {
         const first = this.getFirstRenderedColumn();
         // Check the headers only in case when the first rendered column is -1 or 0.
         // This is an indication that the overlay is placed on the most left position.
@@ -717,7 +828,7 @@ function _interop_require_default(obj) {
         }
         return column < first;
     }
-    /* eslint-disable jsdoc/require-description-complete-sentence */ /**
+    /**
    * Check if the given column index is greater than the index of the last column that
    * is currently rendered and return TRUE in that case, or FALSE otherwise.
    *
@@ -746,28 +857,59 @@ function _interop_require_default(obj) {
    * @memberof Table#
    * @function isColumnAfterRenderedColumns
    * @returns {boolean}
-   */ /* eslint-enable jsdoc/require-description-complete-sentence */ isColumnAfterRenderedColumns(column) {
+   */ isColumnAfterRenderedColumns(column) {
         return this.columnFilter && column > this.getLastRenderedColumn();
     }
-    isColumnAfterViewport(column) {
+    /**
+   * Checks if the column is after the last visible column.
+   *
+   * @param {number} column The visual column index.
+   * @returns {boolean}
+   */ isColumnAfterViewport(column) {
         return this.columnFilter && column > this.getLastVisibleColumn();
     }
-    isRowAfterViewport(row) {
+    /**
+   * Checks if the row is after the last visible row.
+   *
+   * @param {number} row The visual row index.
+   * @returns {boolean}
+   */ isRowAfterViewport(row) {
         return this.rowFilter && row > this.getLastVisibleRow();
     }
-    isColumnBeforeViewport(column) {
+    /**
+   * Checks if the column is before the first visible column.
+   *
+   * @param {number} column The visual column index.
+   * @returns {boolean}
+   */ isColumnBeforeViewport(column) {
         return this.columnFilter && this.columnFilter.sourceToRendered(column) < 0 && column >= 0;
     }
-    isLastRowFullyVisible() {
+    /**
+   * Checks if the last row is fully visible.
+   *
+   * @returns {boolean}
+   */ isLastRowFullyVisible() {
         return this.getLastVisibleRow() === this.getLastRenderedRow();
     }
-    isLastColumnFullyVisible() {
+    /**
+   * Checks if the last column is fully visible.
+   *
+   * @returns {boolean}
+   */ isLastColumnFullyVisible() {
         return this.getLastVisibleColumn() === this.getLastRenderedColumn();
     }
-    allRowsInViewport() {
+    /**
+   * Checks if all rows fit in the viewport.
+   *
+   * @returns {boolean}
+   */ allRowsInViewport() {
         return this.wtSettings.getSetting('totalRows') === this.getVisibleRowsCount();
     }
-    allColumnsInViewport() {
+    /**
+   * Checks if all columns fit in the viewport.
+   *
+   * @returns {boolean}
+   */ allColumnsInViewport() {
         return this.wtSettings.getSetting('totalColumns') === this.getVisibleColumnsCount();
     }
     /**
@@ -846,10 +988,11 @@ function _interop_require_default(obj) {
    * Modify row header widths provided by user in class contructor.
    *
    * @private
-   * @param {Function} rowHeaderWidthFactory The function which can provide default width values for rows..
+   * @param {Function | number | null} rowHeaderWidthFactory The function which can provide default width values for rows..
    * @returns {number}
    */ _modifyRowHeaderWidth(rowHeaderWidthFactory) {
-        let widths = (0, _function.isFunction)(rowHeaderWidthFactory) ? rowHeaderWidthFactory() : null;
+        const rawWidths = typeof rowHeaderWidthFactory === 'function' ? rowHeaderWidthFactory() : rowHeaderWidthFactory;
+        let widths = rawWidths;
         if (Array.isArray(widths)) {
             widths = [
                 ...widths
@@ -864,19 +1007,21 @@ function _interop_require_default(obj) {
    * Correct row header width if necessary.
    *
    * @private
-   * @param {number} width The width to process.
+   * @param {number | null} width The width to process.
    * @returns {number}
    */ _correctRowHeaderWidth(width) {
-        let rowHeaderWidth = width;
-        if (typeof width !== 'number') {
-            rowHeaderWidth = this.wtSettings.getSetting('defaultColumnWidth');
-        }
+        let rowHeaderWidth = typeof width === 'number' ? width : this.wtSettings.getSetting('defaultColumnWidth');
         if (this.correctHeaderWidth) {
             rowHeaderWidth += 1;
         }
         return rowHeaderWidth;
     }
     /**
+   * Destroys the table instance. Overridden by MasterTable to release DOM resources.
+   */ destroy() {
+    // Intentionally empty
+    }
+    /**
    *
    * @abstract
    * @param {TableDao} dataAccessObject The data access object.
@@ -886,14 +1031,20 @@ function _interop_require_default(obj) {
    * @param {'master'|CLONE_TYPES_ENUM} name Overlay name.
    */ constructor(dataAccessObject, facadeGetter, domBindings, wtSettings, name){
         /**
-   * The walkontable settings.
-   *
-   * @protected
-   * @type {Settings}
-   */ this.wtSettings = null;
-        this.TBODY = null;
-        this.THEAD = null;
-        this.COLGROUP = null;
+   * The table body element (TBODY).
+   *
+   * @type {HTMLTableSectionElement | null}
+   */ this.TBODY = null;
+        /**
+   * The table head element (THEAD).
+   *
+   * @type {HTMLTableSectionElement | null}
+   */ this.THEAD = null;
+        /**
+   * The column group element (COLGROUP).
+   *
+   * @type {HTMLTableColElement | null}
+   */ this.COLGROUP = null;
         /**
    * Indicates if the table has height bigger than 0px.
    *
@@ -910,8 +1061,16 @@ function _interop_require_default(obj) {
    *
    * @type {boolean}
    */ this.isTableVisible = false;
-        this.tableOffset = 0;
-        this.holderOffset = 0;
+        /**
+   * The offset of the table element.
+   *
+   * @type {number | { top: number; left: number }}
+   */ this.tableOffset = 0;
+        /**
+   * The offset of the holder element.
+   *
+   * @type {number | { top: number; left: number }}
+   */ this.holderOffset = 0;
         this.domBindings = domBindings;
         /**
      * Indicates if this instance is of type `MasterTable` (i.e. It is NOT an overlay).
@@ -931,6 +1090,7 @@ function _interop_require_default(obj) {
         this.spreader = this.createSpreader(this.TABLE);
         this.hider = this.createHider(this.spreader);
         this.holder = this.createHolder(this.hider);
+        // parentNode is always an HTMLElement in production; null only when TABLE is detached (e.g. Jasmine tests).
         this.wtRootElement = this.holder.parentNode;
         if (this.isMaster) {
             this.alignOverlaysWithTrimmingContainer(); // todo wow, It calls method from child class (MasterTable).
@@ -939,6 +1099,7 @@ function _interop_require_default(obj) {
         this.rowFilter = null; // TODO refactoring, eliminate all (re)creations of this object, then updates state when needed.
         this.columnFilter = null; // TODO refactoring, eliminate all (re)creations of this object, then updates state when needed.
         this.correctHeaderWidth = false;
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
         const origRowHeaderWidth = this.wtSettings.getSettingPure('rowHeaderWidth');
         // Fix for jumping row headers (https://github.com/handsontable/handsontable/issues/3850)
         this.wtSettings.update('rowHeaderWidth', ()=>this._modifyRowHeaderWidth(origRowHeaderWidth));
@@ -946,9 +1107,9 @@ function _interop_require_default(obj) {
         this.columnUtils = new _column1.default(this.dataAccessObject, this.wtSettings); // TODO refactoring, It can be passed through IOC.
         this.tableRenderer = new _renderer.Renderer({
             TABLE: this.TABLE,
-            THEAD: this.THEAD,
-            COLGROUP: this.COLGROUP,
-            TBODY: this.TBODY,
+            THEAD: this.THEAD ?? undefined,
+            COLGROUP: this.COLGROUP ?? undefined,
+            TBODY: this.TBODY ?? undefined,
             rowUtils: this.rowUtils,
             columnUtils: this.columnUtils,
             cellRenderer: this.wtSettings.getSettingPure('cellRenderer'),