handsontable 18.0.0 → 18.1.0-rc1

package/3rdparty/walkontable/src/axisSizing/sizeGetters.js

@@ -0,0 +1,102 @@
+/**
+ * Size getters for `Table` and every subclass.
+ *
+ * These read the per-row / per-column sizes (through `RowUtils` / `ColumnUtils`) and the rendered
+ * table box (through the `GeometryReader`). They are universal — every table type (master and each
+ * overlay clone) needs them — so the mixin is applied once to the base `Table` (`mixin(Table,
+ * sizeGetters)` in `baseTable.ts`) and inherited by all subclasses. The methods run on the `Table`
+ * instance (`this`), reading its public fields (`rowUtils`/`columnUtils`/`TABLE`/`hider`/
+ * `hasTableWidth`/`hasTableHeight`) and the geometry-read port via the `deps` getter.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _element = require("../../../../helpers/dom/element");
+const sizeGetters = {
+    /**
+   * @param {number} sourceRow The physical row index.
+   * @returns {number}
+   * @this Table
+   */ getRowHeight (sourceRow) {
+        return this.rowUtils.getHeight(sourceRow);
+    },
+    /**
+   * @param {number} level The column level.
+   * @returns {number}
+   * @this Table
+   */ getColumnHeaderHeight (level) {
+        return this.columnUtils.getHeaderHeight(level);
+    },
+    /**
+   * @param {number} sourceColumn The physical column index.
+   * @returns {number}
+   * @this Table
+   */ getColumnWidth (sourceColumn) {
+        return this.columnUtils.getWidth(sourceColumn);
+    },
+    /**
+   * Checks if the table has defined size. It returns `true` when the table has width and height
+   * set bigger than `0px`.
+   *
+   * @returns {boolean}
+   * @this Table
+   */ hasDefinedSize () {
+        return this.hasTableHeight && this.hasTableWidth;
+    },
+    /**
+   * Gets table's width. The returned width is the width of the rendered cells that fit in the
+   * current viewport. The value may change depends on the viewport position (scroll position).
+   *
+   * @returns {number}
+   * @this Table
+   */ getWidth () {
+        return this.deps.geometryReader.outerWidth(this.TABLE);
+    },
+    /**
+   * Gets table's height. The returned height is the height of the rendered cells that fit in the
+   * current viewport. The value may change depends on the viewport position (scroll position).
+   *
+   * @returns {number}
+   * @this Table
+   */ getHeight () {
+        return this.deps.geometryReader.outerHeight(this.TABLE);
+    },
+    /**
+   * Gets table's total width. The returned width is the width of all rendered cells (including headers)
+   * that can be displayed in the table.
+   *
+   * @returns {number}
+   * @this Table
+   */ getTotalWidth () {
+        const width = this.deps.geometryReader.outerWidth(this.hider);
+        // when the overlay's table does not have any cells the hider returns 0, get then width from the table element
+        return width !== 0 ? width : this.getWidth();
+    },
+    /**
+   * Gets table's total height. The returned height is the height of all rendered cells (including headers)
+   * that can be displayed in the table.
+   *
+   * @returns {number}
+   * @this Table
+   */ getTotalHeight () {
+        const height = this.deps.geometryReader.outerHeight(this.hider);
+        // when the overlay's table does not have any cells the hider returns 0, get then height from the table element
+        return height !== 0 ? height : this.getHeight();
+    },
+    /**
+   * Checks if the table is visible. It returns `true` when the holder element (or its parents)
+   * has CSS 'display' property different than 'none'.
+   *
+   * @returns {boolean}
+   * @this Table
+   */ isVisible () {
+        return (0, _element.isVisible)(this.TABLE);
+    }
+};
+const _default = sizeGetters;

package/3rdparty/walkontable/src/axisSizing/sizeGetters.mjs

@@ -0,0 +1,92 @@
+/**
+ * Size getters for `Table` and every subclass.
+ *
+ * These read the per-row / per-column sizes (through `RowUtils` / `ColumnUtils`) and the rendered
+ * table box (through the `GeometryReader`). They are universal — every table type (master and each
+ * overlay clone) needs them — so the mixin is applied once to the base `Table` (`mixin(Table,
+ * sizeGetters)` in `baseTable.ts`) and inherited by all subclasses. The methods run on the `Table`
+ * instance (`this`), reading its public fields (`rowUtils`/`columnUtils`/`TABLE`/`hider`/
+ * `hasTableWidth`/`hasTableHeight`) and the geometry-read port via the `deps` getter.
+ */ import { isVisible } from '../../../../helpers/dom/element.mjs';
+const sizeGetters = {
+    /**
+   * @param {number} sourceRow The physical row index.
+   * @returns {number}
+   * @this Table
+   */ getRowHeight (sourceRow) {
+        return this.rowUtils.getHeight(sourceRow);
+    },
+    /**
+   * @param {number} level The column level.
+   * @returns {number}
+   * @this Table
+   */ getColumnHeaderHeight (level) {
+        return this.columnUtils.getHeaderHeight(level);
+    },
+    /**
+   * @param {number} sourceColumn The physical column index.
+   * @returns {number}
+   * @this Table
+   */ getColumnWidth (sourceColumn) {
+        return this.columnUtils.getWidth(sourceColumn);
+    },
+    /**
+   * Checks if the table has defined size. It returns `true` when the table has width and height
+   * set bigger than `0px`.
+   *
+   * @returns {boolean}
+   * @this Table
+   */ hasDefinedSize () {
+        return this.hasTableHeight && this.hasTableWidth;
+    },
+    /**
+   * Gets table's width. The returned width is the width of the rendered cells that fit in the
+   * current viewport. The value may change depends on the viewport position (scroll position).
+   *
+   * @returns {number}
+   * @this Table
+   */ getWidth () {
+        return this.deps.geometryReader.outerWidth(this.TABLE);
+    },
+    /**
+   * Gets table's height. The returned height is the height of the rendered cells that fit in the
+   * current viewport. The value may change depends on the viewport position (scroll position).
+   *
+   * @returns {number}
+   * @this Table
+   */ getHeight () {
+        return this.deps.geometryReader.outerHeight(this.TABLE);
+    },
+    /**
+   * Gets table's total width. The returned width is the width of all rendered cells (including headers)
+   * that can be displayed in the table.
+   *
+   * @returns {number}
+   * @this Table
+   */ getTotalWidth () {
+        const width = this.deps.geometryReader.outerWidth(this.hider);
+        // when the overlay's table does not have any cells the hider returns 0, get then width from the table element
+        return width !== 0 ? width : this.getWidth();
+    },
+    /**
+   * Gets table's total height. The returned height is the height of all rendered cells (including headers)
+   * that can be displayed in the table.
+   *
+   * @returns {number}
+   * @this Table
+   */ getTotalHeight () {
+        const height = this.deps.geometryReader.outerHeight(this.hider);
+        // when the overlay's table does not have any cells the hider returns 0, get then height from the table element
+        return height !== 0 ? height : this.getHeight();
+    },
+    /**
+   * Checks if the table is visible. It returns `true` when the holder element (or its parents)
+   * has CSS 'display' property different than 'none'.
+   *
+   * @returns {boolean}
+   * @this Table
+   */ isVisible () {
+        return isVisible(this.TABLE);
+    }
+};
+export default sizeGetters;

package/3rdparty/walkontable/src/calculator/axisCalculation.d.ts

@@ -1,4 +1,4 @@
-import type { PositionCache } from '../utils/positionCache';
+import type { PositionCache } from '../axisSizing/positionCache';
 import type { ViewportBaseCalculator } from './viewportBase';
 export interface AxisCalculatorContext extends ViewportBaseCalculator {
     needReverse: boolean;

package/3rdparty/walkontable/src/calculator/calculationType/renderedColumns.d.ts

@@ -16,6 +16,16 @@ export declare class RenderedColumnsCalculationType extends PartiallyVisibleColu
      * @type {number}
      */
     columnEndOffset: number;
+    /**
+     * The horizontal scroll offset (zero-based, in px) the band was computed at. Read on the next
+     * scroll-driven draw by `applyRenderedColumnsBandOverscan` (`viewport/calculatorFactory.ts`): the
+     * sign of the offset delta between two consecutive full draws picks the band side that receives
+     * the directional overscan. The value is clamped to zero and derived from an absolute scroll
+     * position, so the comparison works the same in LTR and RTL.
+     *
+     * @type {number}
+     */
+    scrollOffset: number;
     /**
      * Finalizes the calculation.
      *

package/3rdparty/walkontable/src/calculator/calculationType/renderedColumns.js

@@ -17,6 +17,7 @@ class RenderedColumnsCalculationType extends _partiallyVisibleColumns.PartiallyV
    */ finalize(viewportCalculator) {
         super.finalize(viewportCalculator);
         const { overrideFn, totalColumns, positionCache } = viewportCalculator;
+        this.scrollOffset = viewportCalculator.zeroBasedScrollOffset;
         if (this.startColumn !== null && typeof overrideFn === 'function') {
             const startColumn = this.startColumn;
             const endColumn = this.endColumn;
@@ -44,6 +45,14 @@ class RenderedColumnsCalculationType extends _partiallyVisibleColumns.PartiallyV
    * The property holds the offset applied in the `overrideFn` function to the `endColumn` value.
    *
    * @type {number}
-   */ this.columnEndOffset = 0;
+   */ this.columnEndOffset = 0, /**
+   * The horizontal scroll offset (zero-based, in px) the band was computed at. Read on the next
+   * scroll-driven draw by `applyRenderedColumnsBandOverscan` (`viewport/calculatorFactory.ts`): the
+   * sign of the offset delta between two consecutive full draws picks the band side that receives
+   * the directional overscan. The value is clamped to zero and derived from an absolute scroll
+   * position, so the comparison works the same in LTR and RTL.
+   *
+   * @type {number}
+   */ this.scrollOffset = 0;
     }
 }

package/3rdparty/walkontable/src/calculator/calculationType/renderedColumns.mjs

@@ -9,6 +9,7 @@ import { PartiallyVisibleColumnsCalculationType } from './partiallyVisibleColumn
    */ finalize(viewportCalculator) {
         super.finalize(viewportCalculator);
         const { overrideFn, totalColumns, positionCache } = viewportCalculator;
+        this.scrollOffset = viewportCalculator.zeroBasedScrollOffset;
         if (this.startColumn !== null && typeof overrideFn === 'function') {
             const startColumn = this.startColumn;
             const endColumn = this.endColumn;
@@ -36,6 +37,14 @@ import { PartiallyVisibleColumnsCalculationType } from './partiallyVisibleColumn
    * The property holds the offset applied in the `overrideFn` function to the `endColumn` value.
    *
    * @type {number}
-   */ this.columnEndOffset = 0;
+   */ this.columnEndOffset = 0, /**
+   * The horizontal scroll offset (zero-based, in px) the band was computed at. Read on the next
+   * scroll-driven draw by `applyRenderedColumnsBandOverscan` (`viewport/calculatorFactory.ts`): the
+   * sign of the offset delta between two consecutive full draws picks the band side that receives
+   * the directional overscan. The value is clamped to zero and derived from an absolute scroll
+   * position, so the comparison works the same in LTR and RTL.
+   *
+   * @type {number}
+   */ this.scrollOffset = 0;
     }
 }

package/3rdparty/walkontable/src/calculator/calculationType/renderedRows.d.ts

@@ -16,6 +16,15 @@ export declare class RenderedRowsCalculationType extends PartiallyVisibleRowsCal
      * @type {number}
      */
     rowEndOffset: number;
+    /**
+     * The vertical scroll offset (zero-based, in px) the band was computed at. Read on the next
+     * scroll-driven draw by `applyRenderedRowsBandOverscan` (`viewport/calculatorFactory.ts`): the sign
+     * of the offset delta between two consecutive full draws picks the band side that receives the
+     * directional overscan.
+     *
+     * @type {number}
+     */
+    scrollOffset: number;
     /**
      * Finalizes the calculation.
      *

package/3rdparty/walkontable/src/calculator/calculationType/renderedRows.js

@@ -17,6 +17,7 @@ class RenderedRowsCalculationType extends _partiallyVisibleRows.PartiallyVisible
    */ finalize(viewportCalculator) {
         super.finalize(viewportCalculator);
         const { overrideFn, totalRows, positionCache } = viewportCalculator;
+        this.scrollOffset = viewportCalculator.zeroBasedScrollOffset;
         if (this.startRow !== null && typeof overrideFn === 'function') {
             const startRow = this.startRow;
             const endRow = this.endRow;
@@ -44,6 +45,13 @@ class RenderedRowsCalculationType extends _partiallyVisibleRows.PartiallyVisible
    * The property holds the offset applied in the `overrideFn` function to the `endColumn` value.
    *
    * @type {number}
-   */ this.rowEndOffset = 0;
+   */ this.rowEndOffset = 0, /**
+   * The vertical scroll offset (zero-based, in px) the band was computed at. Read on the next
+   * scroll-driven draw by `applyRenderedRowsBandOverscan` (`viewport/calculatorFactory.ts`): the sign
+   * of the offset delta between two consecutive full draws picks the band side that receives the
+   * directional overscan.
+   *
+   * @type {number}
+   */ this.scrollOffset = 0;
     }
 }

package/3rdparty/walkontable/src/calculator/calculationType/renderedRows.mjs

@@ -9,6 +9,7 @@ import { PartiallyVisibleRowsCalculationType } from './partiallyVisibleRows.mjs'
    */ finalize(viewportCalculator) {
         super.finalize(viewportCalculator);
         const { overrideFn, totalRows, positionCache } = viewportCalculator;
+        this.scrollOffset = viewportCalculator.zeroBasedScrollOffset;
         if (this.startRow !== null && typeof overrideFn === 'function') {
             const startRow = this.startRow;
             const endRow = this.endRow;
@@ -36,6 +37,13 @@ import { PartiallyVisibleRowsCalculationType } from './partiallyVisibleRows.mjs'
    * The property holds the offset applied in the `overrideFn` function to the `endColumn` value.
    *
    * @type {number}
-   */ this.rowEndOffset = 0;
+   */ this.rowEndOffset = 0, /**
+   * The vertical scroll offset (zero-based, in px) the band was computed at. Read on the next
+   * scroll-driven draw by `applyRenderedRowsBandOverscan` (`viewport/calculatorFactory.ts`): the sign
+   * of the offset delta between two consecutive full draws picks the band side that receives the
+   * directional overscan.
+   *
+   * @type {number}
+   */ this.scrollOffset = 0;
     }
 }

package/3rdparty/walkontable/src/calculator/viewportColumns.d.ts

@@ -1,4 +1,4 @@
-import type { PositionCache } from '../utils/positionCache';
+import type { PositionCache } from '../axisSizing/positionCache';
 import type { CalculationTypeLike, ColumnsCalculationType } from './viewportBase';
 import { ViewportBaseCalculator } from './viewportBase';
 /**

package/3rdparty/walkontable/src/calculator/viewportRows.d.ts

@@ -1,4 +1,4 @@
-import type { PositionCache } from '../utils/positionCache';
+import type { PositionCache } from '../axisSizing/positionCache';
 import type { CalculationTypeLike, RowsCalculationType } from './viewportBase';
 import { ViewportBaseCalculator } from './viewportBase';
 /**

package/3rdparty/walkontable/src/cell/coords.js

@@ -14,15 +14,12 @@ function _check_private_redeclaration(obj, privateCollection) {
     }
 }
 function _class_apply_descriptor_get(receiver, descriptor) {
-    if (descriptor.get) {
-        return descriptor.get.call(receiver);
-    }
+    if (descriptor.get) return descriptor.get.call(receiver);
     return descriptor.value;
 }
 function _class_apply_descriptor_set(receiver, descriptor, value) {
-    if (descriptor.set) {
-        descriptor.set.call(receiver, value);
-    } else {
+    if (descriptor.set) descriptor.set.call(receiver, value);
+    else {
         if (!descriptor.writable) {
             throw new TypeError("attempted to set read only private field");
         }
@@ -30,9 +27,7 @@ function _class_apply_descriptor_set(receiver, descriptor, value) {
     }
 }
 function _class_extract_field_descriptor(receiver, privateMap, action) {
-    if (!privateMap.has(receiver)) {
-        throw new TypeError("attempted to " + action + " private field on non-instance");
-    }
+    if (!privateMap.has(receiver)) throw new TypeError("attempted to " + action + " private field on non-instance");
     return privateMap.get(receiver);
 }
 function _class_private_field_get(receiver, privateMap) {

package/3rdparty/walkontable/src/cell/coords.mjs

@@ -4,15 +4,12 @@ function _check_private_redeclaration(obj, privateCollection) {
     }
 }
 function _class_apply_descriptor_get(receiver, descriptor) {
-    if (descriptor.get) {
-        return descriptor.get.call(receiver);
-    }
+    if (descriptor.get) return descriptor.get.call(receiver);
     return descriptor.value;
 }
 function _class_apply_descriptor_set(receiver, descriptor, value) {
-    if (descriptor.set) {
-        descriptor.set.call(receiver, value);
-    } else {
+    if (descriptor.set) descriptor.set.call(receiver, value);
+    else {
         if (!descriptor.writable) {
             throw new TypeError("attempted to set read only private field");
         }
@@ -20,9 +17,7 @@ function _class_apply_descriptor_set(receiver, descriptor, value) {
     }
 }
 function _class_extract_field_descriptor(receiver, privateMap, action) {
-    if (!privateMap.has(receiver)) {
-        throw new TypeError("attempted to " + action + " private field on non-instance");
-    }
+    if (!privateMap.has(receiver)) throw new TypeError("attempted to " + action + " private field on non-instance");
     return privateMap.get(receiver);
 }
 function _class_private_field_get(receiver, privateMap) {

package/3rdparty/walkontable/src/cell/range.d.ts

@@ -522,4 +522,14 @@ declare class CellRange {
      */
     _createCellCoords(row: number | null, column: number | null): CellCoords;
 }
+/**
+ * Checks whether a value has the shape of a `CellRange`. Duck-typed rather than `instanceof` so it
+ * stays correct across realm boundaries (a range created in an iframe's realm), and usable as a
+ * defense for hook arguments: `Hooks.run` threads any non-`undefined` listener return value into
+ * the next listener's first argument, so an internal listener cannot trust the argument's type.
+ *
+ * @param {*} value The value to check.
+ * @returns {boolean}
+ */
+export declare function isCellRangeLike(value: unknown): value is CellRange;
 export default CellRange;

package/3rdparty/walkontable/src/cell/range.js

@@ -2,10 +2,18 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-Object.defineProperty(exports, "default", {
-    enumerable: true,
-    get: function() {
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get default () {
         return _default;
+    },
+    get isCellRangeLike () {
+        return isCellRangeLike;
     }
 });
 const _coords = /*#__PURE__*/ _interop_require_default(require("./../cell/coords"));
@@ -15,15 +23,12 @@ function _check_private_redeclaration(obj, privateCollection) {
     }
 }
 function _class_apply_descriptor_get(receiver, descriptor) {
-    if (descriptor.get) {
-        return descriptor.get.call(receiver);
-    }
+    if (descriptor.get) return descriptor.get.call(receiver);
     return descriptor.value;
 }
 function _class_apply_descriptor_set(receiver, descriptor, value) {
-    if (descriptor.set) {
-        descriptor.set.call(receiver, value);
-    } else {
+    if (descriptor.set) descriptor.set.call(receiver, value);
+    else {
         if (!descriptor.writable) {
             throw new TypeError("attempted to set read only private field");
         }
@@ -31,9 +36,7 @@ function _class_apply_descriptor_set(receiver, descriptor, value) {
     }
 }
 function _class_extract_field_descriptor(receiver, privateMap, action) {
-    if (!privateMap.has(receiver)) {
-        throw new TypeError("attempted to " + action + " private field on non-instance");
-    }
+    if (!privateMap.has(receiver)) throw new TypeError("attempted to " + action + " private field on non-instance");
     return privateMap.get(receiver);
 }
 function _class_private_field_get(receiver, privateMap) {
@@ -50,9 +53,7 @@ function _class_private_field_set(receiver, privateMap, value) {
     return value;
 }
 function _class_private_method_get(receiver, privateSet, fn) {
-    if (!privateSet.has(receiver)) {
-        throw new TypeError("attempted to get private field on non-instance");
-    }
+    if (!privateSet.has(receiver)) throw new TypeError("attempted to get private field on non-instance");
     return fn;
 }
 function _class_private_method_init(obj, privateSet) {
@@ -887,4 +888,7 @@ var /**
 function n(v) {
     return v ?? 0;
 }
+function isCellRangeLike(value) {
+    return typeof value?.getTopStartCorner === 'function';
+}
 const _default = CellRange;

package/3rdparty/walkontable/src/cell/range.mjs

@@ -4,15 +4,12 @@ function _check_private_redeclaration(obj, privateCollection) {
     }
 }
 function _class_apply_descriptor_get(receiver, descriptor) {
-    if (descriptor.get) {
-        return descriptor.get.call(receiver);
-    }
+    if (descriptor.get) return descriptor.get.call(receiver);
     return descriptor.value;
 }
 function _class_apply_descriptor_set(receiver, descriptor, value) {
-    if (descriptor.set) {
-        descriptor.set.call(receiver, value);
-    } else {
+    if (descriptor.set) descriptor.set.call(receiver, value);
+    else {
         if (!descriptor.writable) {
             throw new TypeError("attempted to set read only private field");
         }
@@ -20,9 +17,7 @@ function _class_apply_descriptor_set(receiver, descriptor, value) {
     }
 }
 function _class_extract_field_descriptor(receiver, privateMap, action) {
-    if (!privateMap.has(receiver)) {
-        throw new TypeError("attempted to " + action + " private field on non-instance");
-    }
+    if (!privateMap.has(receiver)) throw new TypeError("attempted to " + action + " private field on non-instance");
     return privateMap.get(receiver);
 }
 function _class_private_field_get(receiver, privateMap) {
@@ -39,9 +34,7 @@ function _class_private_field_set(receiver, privateMap, value) {
     return value;
 }
 function _class_private_method_get(receiver, privateSet, fn) {
-    if (!privateSet.has(receiver)) {
-        throw new TypeError("attempted to get private field on non-instance");
-    }
+    if (!privateSet.has(receiver)) throw new TypeError("attempted to get private field on non-instance");
     return fn;
 }
 function _class_private_method_init(obj, privateSet) {
@@ -872,4 +865,15 @@ var /**
 function n(v) {
     return v ?? 0;
 }
+/**
+ * Checks whether a value has the shape of a `CellRange`. Duck-typed rather than `instanceof` so it
+ * stays correct across realm boundaries (a range created in an iframe's realm), and usable as a
+ * defense for hook arguments: `Hooks.run` threads any non-`undefined` listener return value into
+ * the next listener's first argument, so an internal listener cannot trust the argument's type.
+ *
+ * @param {*} value The value to check.
+ * @returns {boolean}
+ */ export function isCellRangeLike(value) {
+    return typeof value?.getTopStartCorner === 'function';
+}
 export default CellRange;

package/3rdparty/walkontable/src/core/_base.d.ts

@@ -1,14 +1,16 @@
-import type { ScrollDao, DomBindings, WalkontableInstance } from '../types';
+import type { DomBindings, WalkontableInstance } from '../types';
 import type Settings from '../settings';
-import type Table from '../table';
-import type Viewport from '../viewport';
-import type Overlays from '../overlays';
+import type Table from '../table/baseTable';
+import type Viewport from '../viewport/viewport';
+import type Overlays from '../overlay/overlays';
 import type { SelectionManager } from '../selection/manager';
 import type Event from '../event';
 import EventManager from '../../../../eventManager';
-import Scroll from '../scroll';
+import Scroll from '../scroll/scroll';
 import CellCoords from '../cell/coords';
 import CellRange from '../cell/range';
+import type { GeometryReader } from '../domMeasure/geometryReader';
+import { type EngineContext } from '../wire';
 /**
  * @abstract
  * @class Walkontable
@@ -100,6 +102,14 @@ export default class CoreAbstract {
      * @type {Settings}
      */
     wtSettings: Settings;
+    /**
+     * The engine composition context — stable references plus the late-bound dependency thunks,
+     * defined once and shared by every module's dependency object.
+     *
+     * @public
+     * @type {EngineContext}
+     */
+    engineContext: EngineContext;
     /**
      * Gets or creates the event manager instance.
      *
@@ -136,8 +146,12 @@ export default class CoreAbstract {
     /**
      * @param {HTMLTableElement} table Main table.
      * @param {Settings} settings The Walkontable settings.
+     * @param {GeometryReader} [geometryReader] The shared geometry reader. The master creates one live
+     *   reader and passes it to every clone (see `Clone`), so a single reader serves the master and all
+     *   overlay clones — the one place a `CachingGeometryReader` gets swapped in later. When omitted (the
+     *   master), a `LiveGeometryReader` is created.
      */
-    constructor(table: HTMLTableElement, settings: Settings);
+    constructor(table: HTMLTableElement, settings: Settings, geometryReader?: GeometryReader);
     /**
      * Finds and stores original table headers, setting up column header rendering callbacks if not already configured.
      */
@@ -181,7 +195,7 @@ export default class CoreAbstract {
     getCell(coords: {
         row: number | null;
         col: number | null;
-    }, topmost?: boolean): -1 | HTMLElement | -5 | -2 | -3 | -4 | undefined;
+    }, topmost?: boolean): number | HTMLElement | undefined;
     /**
      * Scrolls the viewport to a cell (rerenders if needed).
      *
@@ -238,18 +252,4 @@ export default class CoreAbstract {
      * Destroy instance.
      */
     destroy(): void;
-    /**
-     * Create data access object for scroll.
-     *
-     * @protected
-     * @returns {ScrollDao}
-     */
-    createScrollDao(): ScrollDao;
-    /**
-     * Create data access object for wtTable.
-     *
-     * @protected
-     * @returns {Record<string, unknown>}
-     */
-    getTableDao(): Record<string, unknown>;
 }