handsontable 17.1.0 → 18.0.0-rc2

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

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

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

@@ -0,0 +1,10 @@
+/**
+ * @typedef {'top'|'bottom'|'inline_start'|'top_inline_start_corner'|'bottom_inline_start_corner'} CLONE_TYPES_ENUM
+ */
+export declare const CLONE_TOP = "top";
+export declare const CLONE_BOTTOM = "bottom";
+export declare const CLONE_INLINE_START = "inline_start";
+export declare const CLONE_TOP_INLINE_START_CORNER = "top_inline_start_corner";
+export declare const CLONE_BOTTOM_INLINE_START_CORNER = "bottom_inline_start_corner";
+export declare const CLONE_TYPES: string[];
+export declare const CLONE_CLASS_NAMES: Map<string, string>;

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

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

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

@@ -0,0 +1,7 @@
+export { BottomInlineStartCornerOverlay } from './bottomInlineStartCorner';
+export { BottomOverlay } from './bottom';
+export { InlineStartOverlay } from './inlineStart';
+export { Overlay } from './_base';
+export { TopInlineStartCornerOverlay } from './topInlineStartCorner';
+export { TopOverlay } from './top';
+export * from './constants';

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

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

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

@@ -0,0 +1,109 @@
+import type { DataAccessObject, DomBindings, WalkontableInstance } from '../types';
+import type Settings from '../settings';
+import InlineStartOverlayTable from '../table/inlineStart';
+import { Overlay } from './_base';
+/**
+ * @class InlineStartOverlay
+ */
+export declare class InlineStartOverlay extends Overlay {
+    /**
+     * @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);
+    /**
+     * Factory method to create a subclass of `Table` that is relevant to this overlay.
+     *
+     * @see Table#constructor
+     * @param {...*} args Parameters that will be forwarded to the `Table` constructor.
+     * @returns {InlineStartOverlayTable}
+     */
+    createTable(...args: [DataAccessObject, Function, DomBindings, Settings]): InlineStartOverlayTable;
+    /**
+     * Checks if overlay should be fully rendered.
+     *
+     * @returns {boolean}
+     */
+    shouldBeRendered(): boolean;
+    /**
+     * Updates the left overlay position.
+     *
+     * @returns {boolean}
+     */
+    resetFixedPosition(): boolean;
+    /**
+     * Sets the main overlay's horizontal scroll position.
+     *
+     * @param {number} pos The scroll position.
+     * @returns {boolean}
+     */
+    setScrollPosition(pos: number): boolean;
+    /**
+     * Triggers onScroll hook callback.
+     */
+    onScroll(): void;
+    /**
+     * Calculates total sum cells width.
+     *
+     * @param {number} from Column index which calculates started from.
+     * @param {number} to Column index where calculation is finished.
+     * @returns {number} Width sum.
+     */
+    sumCellSizes(from: number, to: number): number;
+    /**
+     * Adjust overlay root element, children and master table element sizes (width, height).
+     */
+    adjustElementsSize(): void;
+    /**
+     * Adjust overlay root element size (width and height).
+     */
+    adjustRootElementSize(): void;
+    /**
+     * Adjust overlay root childs size.
+     */
+    adjustRootChildrenSize(): void;
+    /**
+     * Adjust the overlay dimensions and position.
+     */
+    applyToDOM(): void;
+    /**
+     * Synchronize calculated top position to an element.
+     */
+    syncOverlayOffset(): void;
+    /**
+     * Scrolls horizontally to a column at the left edge of the viewport.
+     *
+     * @param {number} sourceCol  Column index which you want to scroll to.
+     * @param {boolean} [beyondRendered]  If `true`, scrolls according to the right
+     *                                    edge (left edge is by default).
+     * @returns {boolean}
+     */
+    scrollTo(sourceCol: number, beyondRendered: boolean): boolean;
+    /**
+     * Gets table parent left position.
+     *
+     * @returns {number}
+     */
+    getTableParentOffset(): number;
+    /**
+     * Gets the main overlay's horizontal scroll position.
+     *
+     * @returns {number} Main table's horizontal scroll position.
+     */
+    getScrollPosition(): number;
+    /**
+     * Gets the main overlay's horizontal overlay offset.
+     *
+     * @returns {number} Main table's horizontal overlay offset.
+     */
+    getOverlayOffset(): number;
+    /**
+     * 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: number): boolean;
+}

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

@@ -46,6 +46,9 @@ class InlineStartOverlay extends _base.Overlay {
             // removed from DOM
             return false;
         }
+        if (!this.clone) {
+            return false;
+        }
         const { rootWindow } = this.domBindings;
         const overlayRoot = this.clone.wtTable.holder.parentNode;
         const preventOverflow = this.wtSettings.getSetting('preventOverflow');
@@ -68,19 +71,26 @@ class InlineStartOverlay extends _base.Overlay {
    * @returns {boolean}
    */ setScrollPosition(pos) {
         const { rootWindow } = this.domBindings;
-        let result = false;
+        const scrollableElement = this.mainTableScrollableElement;
+        const scrollEl = scrollableElement;
+        const getScrollPosition = ()=>{
+            return scrollableElement === rootWindow ? rootWindow.scrollX : scrollEl.scrollLeft;
+        };
+        const setScrollPosition = (newPosition)=>{
+            if (scrollableElement === rootWindow) {
+                rootWindow.scrollTo(newPosition, rootWindow.scrollY);
+            } else {
+                scrollEl.scrollLeft = newPosition;
+            }
+        };
         if (this.isRtl()) {
             pos = -pos;
         }
-        const scrollableElement = this.mainTableScrollableElement;
-        if (scrollableElement === rootWindow && pos !== rootWindow.scrollX) {
-            const oldScrollX = rootWindow.scrollX;
-            rootWindow.scrollTo(pos, (0, _element.getWindowScrollTop)(rootWindow));
-            result = oldScrollX !== rootWindow.scrollX;
-        } else if (pos !== scrollableElement.scrollLeft) {
-            const oldScrollLeft = scrollableElement.scrollLeft;
-            scrollableElement.scrollLeft = pos;
-            result = oldScrollLeft !== scrollableElement.scrollLeft;
+        const oldScrollPosition = getScrollPosition();
+        let result = false;
+        if (pos !== oldScrollPosition) {
+            setScrollPosition(pos);
+            result = oldScrollPosition !== getScrollPosition();
         }
         return result;
     }
@@ -117,6 +127,9 @@ class InlineStartOverlay extends _base.Overlay {
     /**
    * Adjust overlay root element size (width and height).
    */ adjustRootElementSize() {
+        if (!this.clone) {
+            return;
+        }
         const { wtTable, wtViewport } = this.wot;
         const { rootDocument, rootWindow } = this.domBindings;
         const overlayRoot = this.clone.wtTable.holder.parentNode;
@@ -125,7 +138,14 @@ class InlineStartOverlay extends _base.Overlay {
         if (this.trimmingContainer !== rootWindow || preventOverflow === 'vertical') {
             let height = wtViewport.getWorkspaceHeight();
             if (wtViewport.hasHorizontalScroll()) {
-                height -= (0, _element.getScrollbarWidth)(rootDocument);
+                // Match the master holder's actual inner height instead of subtracting a rounded scrollbar
+                // width. `clientHeight` natively accounts for the horizontal scrollbar at the browser's
+                // sub-pixel accuracy; under fractional browser zoom a rounded `getScrollbarWidth()` diverges
+                // 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);
             }
             height = Math.min(height, wtTable.wtRootElement.scrollHeight);
             overlayRootStyle.height = `${height}px`;
@@ -139,21 +159,25 @@ class InlineStartOverlay extends _base.Overlay {
     /**
    * Adjust overlay root childs size.
    */ adjustRootChildrenSize() {
+        if (!this.clone) {
+            return;
+        }
         const { holder } = this.clone.wtTable;
         const cornerStyle = (0, _selection.getCornerStyle)(this.wot);
         const selectionCornerOffset = this.wot.selectionManager.getFocusSelection() ? parseInt(cornerStyle.width, 10) / 2 : 0;
         this.clone.wtTable.hider.style.height = this.hider.style.height;
-        holder.style.height = holder.parentNode.style.height;
+        const holderParent = holder.parentNode;
+        holder.style.height = holderParent.style.height;
         // Add selection corner protruding part to the holder total width to make sure that
         // borders' corner won't be cut after horizontal scroll (#6937).
-        holder.style.width = `${parseInt(holder.parentNode.style.width, 10) + selectionCornerOffset}px`;
+        holder.style.width = `${parseInt(holderParent.style.width, 10) + selectionCornerOffset}px`;
     }
     /**
    * Adjust the overlay dimensions and position.
    */ applyToDOM() {
         const total = this.wtSettings.getSetting('totalColumns');
         const styleProperty = this.isRtl() ? 'right' : 'left';
-        if (typeof this.wot.wtViewport.columnsRenderCalculator.startPosition === 'number') {
+        if (typeof this.wot.wtViewport.columnsRenderCalculator?.startPosition === 'number') {
             this.spreader.style[styleProperty] = `${this.wot.wtViewport.columnsRenderCalculator.startPosition}px`;
         } else if (total === 0) {
             this.spreader.style[styleProperty] = '0';
@@ -172,7 +196,10 @@ class InlineStartOverlay extends _base.Overlay {
     /**
    * Synchronize calculated top position to an element.
    */ syncOverlayOffset() {
-        if (typeof this.wot.wtViewport.rowsRenderCalculator.startPosition === 'number') {
+        if (!this.clone) {
+            return;
+        }
+        if (typeof this.wot.wtViewport.rowsRenderCalculator?.startPosition === 'number') {
             this.clone.wtTable.spreader.style.top = `${this.wot.wtViewport.rowsRenderCalculator.startPosition}px`;
         } else {
             this.clone.wtTable.spreader.style.top = '';
@@ -254,7 +281,7 @@ class InlineStartOverlay extends _base.Overlay {
                 overlayOffset = Math.max(this.getScrollPosition() - this.getTableParentOffset(), 0);
             }
             const rootWidth = this.wot.wtTable.getTotalWidth();
-            const overlayRootWidth = this.clone.wtTable.getTotalWidth();
+            const overlayRootWidth = this.clone ? this.clone.wtTable.getTotalWidth() : 0;
             const maxOffset = rootWidth - overlayRootWidth;
             if (overlayOffset > maxOffset) {
                 overlayOffset = 0;

package/3rdparty/walkontable/src/overlay/inlineStart.mjs

@@ -1,4 +1,4 @@
-import { addClass, getScrollbarWidth, getScrollLeft, getMaximumScrollLeft, getWindowScrollTop, hasClass, outerWidth, removeClass, setOverlayPosition, resetCssTransform } from '../../../../helpers/dom/element.mjs';
+import { addClass, getScrollbarWidth, getScrollLeft, getMaximumScrollLeft, hasClass, outerWidth, removeClass, setOverlayPosition, resetCssTransform } from '../../../../helpers/dom/element.mjs';
 import InlineStartOverlayTable from '../table/inlineStart.mjs';
 import { Overlay } from './_base.mjs';
 import { getCornerStyle } from '../selection/index.mjs';
@@ -33,6 +33,9 @@ import { throwWithCause } from '../../../../helpers/errors.mjs';
             // removed from DOM
             return false;
         }
+        if (!this.clone) {
+            return false;
+        }
         const { rootWindow } = this.domBindings;
         const overlayRoot = this.clone.wtTable.holder.parentNode;
         const preventOverflow = this.wtSettings.getSetting('preventOverflow');
@@ -55,19 +58,26 @@ import { throwWithCause } from '../../../../helpers/errors.mjs';
    * @returns {boolean}
    */ setScrollPosition(pos) {
         const { rootWindow } = this.domBindings;
-        let result = false;
+        const scrollableElement = this.mainTableScrollableElement;
+        const scrollEl = scrollableElement;
+        const getScrollPosition = ()=>{
+            return scrollableElement === rootWindow ? rootWindow.scrollX : scrollEl.scrollLeft;
+        };
+        const setScrollPosition = (newPosition)=>{
+            if (scrollableElement === rootWindow) {
+                rootWindow.scrollTo(newPosition, rootWindow.scrollY);
+            } else {
+                scrollEl.scrollLeft = newPosition;
+            }
+        };
         if (this.isRtl()) {
             pos = -pos;
         }
-        const scrollableElement = this.mainTableScrollableElement;
-        if (scrollableElement === rootWindow && pos !== rootWindow.scrollX) {
-            const oldScrollX = rootWindow.scrollX;
-            rootWindow.scrollTo(pos, getWindowScrollTop(rootWindow));
-            result = oldScrollX !== rootWindow.scrollX;
-        } else if (pos !== scrollableElement.scrollLeft) {
-            const oldScrollLeft = scrollableElement.scrollLeft;
-            scrollableElement.scrollLeft = pos;
-            result = oldScrollLeft !== scrollableElement.scrollLeft;
+        const oldScrollPosition = getScrollPosition();
+        let result = false;
+        if (pos !== oldScrollPosition) {
+            setScrollPosition(pos);
+            result = oldScrollPosition !== getScrollPosition();
         }
         return result;
     }
@@ -104,6 +114,9 @@ import { throwWithCause } from '../../../../helpers/errors.mjs';
     /**
    * Adjust overlay root element size (width and height).
    */ adjustRootElementSize() {
+        if (!this.clone) {
+            return;
+        }
         const { wtTable, wtViewport } = this.wot;
         const { rootDocument, rootWindow } = this.domBindings;
         const overlayRoot = this.clone.wtTable.holder.parentNode;
@@ -112,7 +125,14 @@ import { throwWithCause } from '../../../../helpers/errors.mjs';
         if (this.trimmingContainer !== rootWindow || preventOverflow === 'vertical') {
             let height = wtViewport.getWorkspaceHeight();
             if (wtViewport.hasHorizontalScroll()) {
-                height -= getScrollbarWidth(rootDocument);
+                // Match the master holder's actual inner height instead of subtracting a rounded scrollbar
+                // width. `clientHeight` natively accounts for the horizontal scrollbar at the browser's
+                // sub-pixel accuracy; under fractional browser zoom a rounded `getScrollbarWidth()` diverges
+                // 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 - getScrollbarWidth(rootDocument);
             }
             height = Math.min(height, wtTable.wtRootElement.scrollHeight);
             overlayRootStyle.height = `${height}px`;
@@ -126,21 +146,25 @@ import { throwWithCause } from '../../../../helpers/errors.mjs';
     /**
    * Adjust overlay root childs size.
    */ adjustRootChildrenSize() {
+        if (!this.clone) {
+            return;
+        }
         const { holder } = this.clone.wtTable;
         const cornerStyle = getCornerStyle(this.wot);
         const selectionCornerOffset = this.wot.selectionManager.getFocusSelection() ? parseInt(cornerStyle.width, 10) / 2 : 0;
         this.clone.wtTable.hider.style.height = this.hider.style.height;
-        holder.style.height = holder.parentNode.style.height;
+        const holderParent = holder.parentNode;
+        holder.style.height = holderParent.style.height;
         // Add selection corner protruding part to the holder total width to make sure that
         // borders' corner won't be cut after horizontal scroll (#6937).
-        holder.style.width = `${parseInt(holder.parentNode.style.width, 10) + selectionCornerOffset}px`;
+        holder.style.width = `${parseInt(holderParent.style.width, 10) + selectionCornerOffset}px`;
     }
     /**
    * Adjust the overlay dimensions and position.
    */ applyToDOM() {
         const total = this.wtSettings.getSetting('totalColumns');
         const styleProperty = this.isRtl() ? 'right' : 'left';
-        if (typeof this.wot.wtViewport.columnsRenderCalculator.startPosition === 'number') {
+        if (typeof this.wot.wtViewport.columnsRenderCalculator?.startPosition === 'number') {
             this.spreader.style[styleProperty] = `${this.wot.wtViewport.columnsRenderCalculator.startPosition}px`;
         } else if (total === 0) {
             this.spreader.style[styleProperty] = '0';
@@ -159,7 +183,10 @@ import { throwWithCause } from '../../../../helpers/errors.mjs';
     /**
    * Synchronize calculated top position to an element.
    */ syncOverlayOffset() {
-        if (typeof this.wot.wtViewport.rowsRenderCalculator.startPosition === 'number') {
+        if (!this.clone) {
+            return;
+        }
+        if (typeof this.wot.wtViewport.rowsRenderCalculator?.startPosition === 'number') {
             this.clone.wtTable.spreader.style.top = `${this.wot.wtViewport.rowsRenderCalculator.startPosition}px`;
         } else {
             this.clone.wtTable.spreader.style.top = '';
@@ -241,7 +268,7 @@ import { throwWithCause } from '../../../../helpers/errors.mjs';
                 overlayOffset = Math.max(this.getScrollPosition() - this.getTableParentOffset(), 0);
             }
             const rootWidth = this.wot.wtTable.getTotalWidth();
-            const overlayRootWidth = this.clone.wtTable.getTotalWidth();
+            const overlayRootWidth = this.clone ? this.clone.wtTable.getTotalWidth() : 0;
             const maxOffset = rootWidth - overlayRootWidth;
             if (overlayOffset > maxOffset) {
                 overlayOffset = 0;

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

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

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

@@ -0,0 +1,116 @@
+import type { DataAccessObject, DomBindings, WalkontableInstance } from '../types';
+import type Settings from '../settings';
+import TopOverlayTable from './../table/top';
+import { Overlay } from './_base';
+/**
+ * @class TopOverlay
+ */
+export declare class TopOverlay extends Overlay {
+    /**
+     * 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.
+     *
+     * @type {number}
+     */
+    cachedFixedRowsTop: number;
+    /**
+     * @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);
+    /**
+     * Factory method to create a subclass of `Table` that is relevant to this overlay.
+     *
+     * @see Table#constructor
+     * @param {...*} args Parameters that will be forwarded to the `Table` constructor.
+     * @returns {TopOverlayTable}
+     */
+    createTable(...args: [DataAccessObject, Function, DomBindings, Settings]): TopOverlayTable;
+    /**
+     * Checks if overlay should be fully rendered.
+     *
+     * @returns {boolean}
+     */
+    shouldBeRendered(): boolean;
+    /**
+     * Updates the top overlay position.
+     *
+     * @returns {boolean}
+     */
+    resetFixedPosition(): boolean;
+    /**
+     * Sets the main overlay's vertical scroll position.
+     *
+     * @param {number} pos The scroll position.
+     * @returns {boolean}
+     */
+    setScrollPosition(pos: number): boolean;
+    /**
+     * Triggers onScroll hook callback.
+     */
+    onScroll(): void;
+    /**
+     * Calculates total sum cells height.
+     *
+     * @param {number} from Row index which calculates started from.
+     * @param {number} to Row index where calculation is finished.
+     * @returns {number} Height sum.
+     */
+    sumCellSizes(from: number, to: number): number;
+    /**
+     * Adjust overlay root element, children and master table element sizes (width, height).
+     */
+    adjustElementsSize(): void;
+    /**
+     * Adjust overlay root element size (width and height).
+     */
+    adjustRootElementSize(): void;
+    /**
+     * Adjust overlay root childs size.
+     */
+    adjustRootChildrenSize(): void;
+    /**
+     * Adjust the overlay dimensions and position.
+     */
+    applyToDOM(): void;
+    /**
+     * Synchronize calculated left position to an element.
+     */
+    syncOverlayOffset(): void;
+    /**
+     * Scrolls vertically to a row.
+     *
+     * @param {number} sourceRow Row index which you want to scroll to.
+     * @param {boolean} [bottomEdge] If `true`, scrolls according to the bottom edge (top edge is by default).
+     * @returns {boolean}
+     */
+    scrollTo(sourceRow: number, bottomEdge: boolean): boolean;
+    /**
+     * Gets table parent top position.
+     *
+     * @returns {number}
+     */
+    getTableParentOffset(): number;
+    /**
+     * Gets the main overlay's vertical scroll position.
+     *
+     * @returns {number} Main table's vertical scroll position.
+     */
+    getScrollPosition(): number;
+    /**
+     * Gets the main overlay's vertical overlay offset.
+     *
+     * @returns {number} Main table's vertical overlay offset.
+     */
+    getOverlayOffset(): number;
+    /**
+     * 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: number, skipInnerBorderAdjusting?: boolean): boolean;
+}

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

@@ -41,7 +41,7 @@ class TopOverlay extends _base.Overlay {
    *
    * @returns {boolean}
    */ resetFixedPosition() {
-        if (!this.needFullRender || !this.shouldBeRendered() || !this.wot.wtTable.holder.parentNode) {
+        if (!this.needFullRender || !this.shouldBeRendered() || !this.wot.wtTable.holder.parentNode || !this.clone) {
             // removed from DOM
             return false;
         }
@@ -85,15 +85,22 @@ class TopOverlay extends _base.Overlay {
    */ setScrollPosition(pos) {
         const { rootWindow } = this.domBindings;
         const scrollableElement = this.mainTableScrollableElement;
+        const scrollEl = scrollableElement;
+        const getScrollPosition = ()=>{
+            return scrollableElement === rootWindow ? rootWindow.scrollY : scrollEl.scrollTop;
+        };
+        const setScrollPosition = (newPosition)=>{
+            if (scrollableElement === rootWindow) {
+                rootWindow.scrollTo(rootWindow.scrollX, newPosition);
+            } else {
+                scrollEl.scrollTop = newPosition;
+            }
+        };
+        const oldScrollPosition = getScrollPosition();
         let result = false;
-        if (scrollableElement === rootWindow && pos !== rootWindow.scrollY) {
-            const oldScrollX = rootWindow.scrollY;
-            rootWindow.scrollTo((0, _element.getWindowScrollLeft)(rootWindow), pos);
-            result = oldScrollX !== rootWindow.scrollY;
-        } else if (pos !== scrollableElement.scrollTop) {
-            const oldScrollLeft = scrollableElement.scrollTop;
-            scrollableElement.scrollTop = pos;
-            result = oldScrollLeft !== scrollableElement.scrollTop;
+        if (pos !== oldScrollPosition) {
+            setScrollPosition(pos);
+            result = oldScrollPosition !== getScrollPosition();
         }
         return result;
     }
@@ -109,7 +116,8 @@ class TopOverlay extends _base.Overlay {
    * @param {number} to Row index where calculation is finished.
    * @returns {number} Height sum.
    */ sumCellSizes(from, to) {
-        const defaultRowHeight = this.wtSettings.getSetting('stylesHandler').getDefaultRowHeight();
+        const stylesHandler = this.wtSettings.getSetting('stylesHandler');
+        const defaultRowHeight = stylesHandler.getDefaultRowHeight();
         let row = from;
         let sum = 0;
         while(row < to){
@@ -131,6 +139,9 @@ class TopOverlay extends _base.Overlay {
     /**
    * Adjust overlay root element size (width and height).
    */ adjustRootElementSize() {
+        if (!this.clone) {
+            return;
+        }
         const { wtTable, wtViewport } = this.wot;
         const { rootDocument, rootWindow } = this.domBindings;
         const overlayRoot = this.clone.wtTable.holder.parentNode;
@@ -156,20 +167,24 @@ class TopOverlay extends _base.Overlay {
     /**
    * Adjust overlay root childs size.
    */ adjustRootChildrenSize() {
+        if (!this.clone) {
+            return;
+        }
         const { holder } = this.clone.wtTable;
         const cornerStyle = (0, _selection.getCornerStyle)(this.wot);
         const selectionCornerOffset = this.wot.selectionManager.getFocusSelection() ? parseInt(cornerStyle.height, 10) / 2 : 0;
         this.clone.wtTable.hider.style.width = this.hider.style.width;
-        holder.style.width = holder.parentNode.style.width;
+        const holderParent = holder.parentNode;
+        holder.style.width = holderParent.style.width;
         // Add selection corner protruding part to the holder total height to make sure that
         // borders' corner won't be cut after vertical scroll (#6937).
-        holder.style.height = `${parseInt(holder.parentNode.style.height, 10) + selectionCornerOffset}px`;
+        holder.style.height = `${parseInt(holderParent.style.height, 10) + selectionCornerOffset}px`;
     }
     /**
    * Adjust the overlay dimensions and position.
    */ applyToDOM() {
-        const total = this.wtSettings.getSetting('totalRows');
-        if (typeof this.wot.wtViewport.rowsRenderCalculator.startPosition === 'number') {
+        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
@@ -185,9 +200,12 @@ class TopOverlay extends _base.Overlay {
     /**
    * Synchronize calculated left position to an element.
    */ syncOverlayOffset() {
+        if (!this.clone) {
+            return;
+        }
         const styleProperty = this.isRtl() ? 'right' : 'left';
         const { spreader } = this.clone.wtTable;
-        if (typeof this.wot.wtViewport.columnsRenderCalculator.startPosition === 'number') {
+        if (typeof this.wot.wtViewport.columnsRenderCalculator?.startPosition === 'number') {
             spreader.style[styleProperty] = `${this.wot.wtViewport.columnsRenderCalculator.startPosition}px`;
         } else {
             spreader.style[styleProperty] = '';
@@ -209,7 +227,7 @@ class TopOverlay extends _base.Overlay {
         let newY = this.getTableParentOffset();
         let scrollbarCompensation = 0;
         if (bottomEdge) {
-            const rowHeight = this.wot.wtTable.getRowHeight(sourceRow);
+            const rowHeight = this.wot.wtTable.getRowHeight(sourceRow) ?? 0;
             const viewportHeight = this.wot.wtViewport.getViewportHeight();
             if (rowHeight > viewportHeight) {
                 bottomEdge = false;
@@ -265,7 +283,7 @@ class TopOverlay extends _base.Overlay {
         let overlayOffset = 0;
         if (this.trimmingContainer === rootWindow && (!preventOverflow || preventOverflow !== 'vertical')) {
             const rootHeight = this.wot.wtTable.getTotalHeight();
-            const overlayRootHeight = this.clone.wtTable.getTotalHeight();
+            const overlayRootHeight = this.clone ? this.clone.wtTable.getTotalHeight() : 0;
             const maxOffset = rootHeight - overlayRootHeight;
             overlayOffset = Math.max(this.getScrollPosition() - this.getTableParentOffset(), 0);
             if (overlayOffset > maxOffset) {
@@ -283,7 +301,7 @@ class TopOverlay extends _base.Overlay {
    */ adjustHeaderBordersPosition(position, skipInnerBorderAdjusting = false) {
         const { wtSettings } = this;
         const masterParent = this.wot.wtTable.holder.parentNode;
-        const totalColumns = wtSettings.getSetting('totalColumns');
+        const totalColumns = wtSettings.getSetting('totalColumns') ?? 0;
         const preventHorizontalOverflow = wtSettings.getSetting('preventOverflow') === 'horizontal';
         if (totalColumns) {
             (0, _element.removeClass)(masterParent, 'emptyColumns');