handsontable 18.0.0 → 18.1.0-rc7

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"));
@@ -887,4 +895,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

@@ -872,4 +872,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>;
 }

package/3rdparty/walkontable/src/core/_base.js

@@ -11,14 +11,57 @@ Object.defineProperty(exports, "default", {
 const _element = require("../../../../helpers/dom/element");
 const _string = require("../../../../helpers/string");
 const _eventManager = /*#__PURE__*/ _interop_require_default(require("../../../../eventManager"));
-const _scroll = /*#__PURE__*/ _interop_require_default(require("../scroll"));
+const _scroll = /*#__PURE__*/ _interop_require_wildcard(require("../scroll/scroll"));
 const _coords = /*#__PURE__*/ _interop_require_default(require("../cell/coords"));
 const _range = /*#__PURE__*/ _interop_require_default(require("../cell/range"));
+const _liveGeometryReader = require("../domMeasure/liveGeometryReader");
+const _wire = require("../wire");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
 }
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
 class CoreAbstract {
     /**
    * Gets or creates the event manager instance.
@@ -216,152 +259,13 @@ class CoreAbstract {
         this.wtEvent.destroy();
     }
     /**
-   * Create data access object for scroll.
-   *
-   * @protected
-   * @returns {ScrollDao}
-   */ createScrollDao() {
-        const wot = this;
-        return {
-            get drawn () {
-                return wot.drawn; // TODO refactoring: consider about injecting `isDrawn` function : ()=>return wot.drawn. (it'll enables remove dao layer)
-            },
-            get topOverlay () {
-                return wot.wtOverlays.topOverlay; // TODO refactoring: move outside dao, use IOC
-            },
-            get inlineStartOverlay () {
-                return wot.wtOverlays.inlineStartOverlay; // TODO refactoring: move outside dao, use IOC
-            },
-            get wtTable () {
-                return wot.wtTable; // TODO refactoring: move outside dao, use IOC
-            },
-            get wtViewport () {
-                return wot.wtViewport; // TODO refactoring: move outside dao, use IOC
-            },
-            get wtSettings () {
-                return wot.wtSettings;
-            },
-            get rootWindow () {
-                return wot.domBindings.rootWindow; // TODO refactoring: move outside dao
-            },
-            // TODO refactoring, consider about using injecting wtSettings into scroll (it'll enables remove dao layer)
-            get totalRows () {
-                return wot.wtSettings.getSetting('totalRows');
-            },
-            get totalColumns () {
-                return wot.wtSettings.getSetting('totalColumns');
-            },
-            get fixedRowsTop () {
-                return wot.wtSettings.getSetting('fixedRowsTop');
-            },
-            get fixedRowsBottom () {
-                return wot.wtSettings.getSetting('fixedRowsBottom');
-            },
-            get fixedColumnsStart () {
-                return wot.wtSettings.getSetting('fixedColumnsStart');
-            }
-        };
-    }
-    // TODO refactoring: it will be much better to not use DAO objects. They are needed for now to provide
-    // dynamically access to related objects
-    /**
-   * Create data access object for wtTable.
-   *
-   * @protected
-   * @returns {Record<string, unknown>}
-   */ getTableDao() {
-        const wot = this;
-        return {
-            get wot () {
-                return wot;
-            },
-            get parentTableOffset () {
-                return wot.cloneSource.wtTable.tableOffset; // TODO rethink: cloneSource exists only in Clone type.
-            },
-            get cloneSource () {
-                return wot.cloneSource; // TODO rethink: cloneSource exists only in Clone type.
-            },
-            get workspaceWidth () {
-                return wot.wtViewport.getWorkspaceWidth();
-            },
-            get wtViewport () {
-                return wot.wtViewport; // TODO refactoring: move outside dao, use IOC
-            },
-            get wtOverlays () {
-                return wot.wtOverlays; // TODO refactoring: move outside dao, use IOC
-            },
-            get selectionManager () {
-                return wot.selectionManager; // TODO refactoring: move outside dao, use IOC
-            },
-            get drawn () {
-                return wot.drawn;
-            },
-            set drawn (v){
-                wot.drawn = v;
-            },
-            get wtTable () {
-                return wot.wtTable; // TODO refactoring: it provides itself
-            },
-            get startColumnRendered () {
-                return wot.wtViewport.columnsRenderCalculator?.startColumn ?? null;
-            },
-            get startColumnVisible () {
-                return wot.wtViewport.columnsVisibleCalculator?.startColumn ?? null;
-            },
-            get startColumnPartiallyVisible () {
-                return wot.wtViewport.columnsPartiallyVisibleCalculator?.startColumn ?? null;
-            },
-            get endColumnRendered () {
-                return wot.wtViewport.columnsRenderCalculator?.endColumn ?? null;
-            },
-            get endColumnVisible () {
-                return wot.wtViewport.columnsVisibleCalculator?.endColumn ?? null;
-            },
-            get endColumnPartiallyVisible () {
-                return wot.wtViewport.columnsPartiallyVisibleCalculator?.endColumn ?? null;
-            },
-            get countColumnsRendered () {
-                return wot.wtViewport.columnsRenderCalculator?.count ?? 0;
-            },
-            get countColumnsVisible () {
-                return wot.wtViewport.columnsVisibleCalculator?.count ?? 0;
-            },
-            get startRowRendered () {
-                return wot.wtViewport.rowsRenderCalculator?.startRow ?? null;
-            },
-            get startRowVisible () {
-                return wot.wtViewport.rowsVisibleCalculator?.startRow ?? null;
-            },
-            get startRowPartiallyVisible () {
-                return wot.wtViewport.rowsPartiallyVisibleCalculator?.startRow ?? null;
-            },
-            get endRowRendered () {
-                return wot.wtViewport.rowsRenderCalculator?.endRow ?? null;
-            },
-            get endRowVisible () {
-                return wot.wtViewport.rowsVisibleCalculator?.endRow ?? null;
-            },
-            get endRowPartiallyVisible () {
-                return wot.wtViewport.rowsPartiallyVisibleCalculator?.endRow ?? null;
-            },
-            get countRowsRendered () {
-                return wot.wtViewport.rowsRenderCalculator?.count ?? 0;
-            },
-            get countRowsVisible () {
-                return wot.wtViewport.rowsVisibleCalculator?.count ?? 0;
-            },
-            get columnHeaders () {
-                return wot.wtSettings.getSetting('columnHeaders');
-            },
-            get rowHeaders () {
-                return wot.wtSettings.getSetting('rowHeaders');
-            }
-        };
-    }
-    /**
    * @param {HTMLTableElement} table Main table.
    * @param {Settings} settings The Walkontable settings.
-   */ constructor(table, 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, settings, geometryReader){
         /**
    * The walkontable instance id.
    *
@@ -387,9 +291,16 @@ class CoreAbstract {
         this.domBindings = {
             rootTable: table,
             rootDocument: table.ownerDocument,
-            rootWindow: table.ownerDocument.defaultView
+            rootWindow: table.ownerDocument.defaultView,
+            geometryReader: geometryReader ?? new _liveGeometryReader.LiveGeometryReader(table.ownerDocument.defaultView)
         };
         this.wtSettings = settings;
-        this.wtScroll = new _scroll.default(this.createScrollDao());
+        // The engine context is the single composition surface: it holds the stable references and
+        // defines every late-bound/cyclic thunk ONCE. Built here because settings and DOM bindings now
+        // exist; the thunks resolve the table/viewport/overlays lazily, at call time, exactly as before.
+        this.engineContext = (0, _wire.buildContext)(this);
+        // `Scroll` is created before the table/viewport/overlays exist, so its dependency set is assembled
+        // from the context (the late-bound engine objects come through as thunks resolved at call time).
+        this.wtScroll = new _scroll.default((0, _scroll.createScrollDeps)(this.engineContext));
     }
 }

package/3rdparty/walkontable/src/core/_base.mjs

@@ -1,9 +1,11 @@
 import { fastInnerText, hasZeroHeight } from '../../../../helpers/dom/element.mjs';
 import { randomString } from '../../../../helpers/string.mjs';
 import EventManager from '../../../../eventManager.mjs';
-import Scroll from '../scroll.mjs';
+import Scroll, { createScrollDeps } from '../scroll/scroll.mjs';
 import CellCoords from '../cell/coords.mjs';
 import CellRange from '../cell/range.mjs';
+import { LiveGeometryReader } from '../domMeasure/liveGeometryReader.mjs';
+import { buildContext } from '../wire.mjs';
 class CoreAbstract {
     /**
    * Gets or creates the event manager instance.
@@ -201,152 +203,13 @@ class CoreAbstract {
         this.wtEvent.destroy();
     }
     /**
-   * Create data access object for scroll.
-   *
-   * @protected
-   * @returns {ScrollDao}
-   */ createScrollDao() {
-        const wot = this;
-        return {
-            get drawn () {
-                return wot.drawn; // TODO refactoring: consider about injecting `isDrawn` function : ()=>return wot.drawn. (it'll enables remove dao layer)
-            },
-            get topOverlay () {
-                return wot.wtOverlays.topOverlay; // TODO refactoring: move outside dao, use IOC
-            },
-            get inlineStartOverlay () {
-                return wot.wtOverlays.inlineStartOverlay; // TODO refactoring: move outside dao, use IOC
-            },
-            get wtTable () {
-                return wot.wtTable; // TODO refactoring: move outside dao, use IOC
-            },
-            get wtViewport () {
-                return wot.wtViewport; // TODO refactoring: move outside dao, use IOC
-            },
-            get wtSettings () {
-                return wot.wtSettings;
-            },
-            get rootWindow () {
-                return wot.domBindings.rootWindow; // TODO refactoring: move outside dao
-            },
-            // TODO refactoring, consider about using injecting wtSettings into scroll (it'll enables remove dao layer)
-            get totalRows () {
-                return wot.wtSettings.getSetting('totalRows');
-            },
-            get totalColumns () {
-                return wot.wtSettings.getSetting('totalColumns');
-            },
-            get fixedRowsTop () {
-                return wot.wtSettings.getSetting('fixedRowsTop');
-            },
-            get fixedRowsBottom () {
-                return wot.wtSettings.getSetting('fixedRowsBottom');
-            },
-            get fixedColumnsStart () {
-                return wot.wtSettings.getSetting('fixedColumnsStart');
-            }
-        };
-    }
-    // TODO refactoring: it will be much better to not use DAO objects. They are needed for now to provide
-    // dynamically access to related objects
-    /**
-   * Create data access object for wtTable.
-   *
-   * @protected
-   * @returns {Record<string, unknown>}
-   */ getTableDao() {
-        const wot = this;
-        return {
-            get wot () {
-                return wot;
-            },
-            get parentTableOffset () {
-                return wot.cloneSource.wtTable.tableOffset; // TODO rethink: cloneSource exists only in Clone type.
-            },
-            get cloneSource () {
-                return wot.cloneSource; // TODO rethink: cloneSource exists only in Clone type.
-            },
-            get workspaceWidth () {
-                return wot.wtViewport.getWorkspaceWidth();
-            },
-            get wtViewport () {
-                return wot.wtViewport; // TODO refactoring: move outside dao, use IOC
-            },
-            get wtOverlays () {
-                return wot.wtOverlays; // TODO refactoring: move outside dao, use IOC
-            },
-            get selectionManager () {
-                return wot.selectionManager; // TODO refactoring: move outside dao, use IOC
-            },
-            get drawn () {
-                return wot.drawn;
-            },
-            set drawn (v){
-                wot.drawn = v;
-            },
-            get wtTable () {
-                return wot.wtTable; // TODO refactoring: it provides itself
-            },
-            get startColumnRendered () {
-                return wot.wtViewport.columnsRenderCalculator?.startColumn ?? null;
-            },
-            get startColumnVisible () {
-                return wot.wtViewport.columnsVisibleCalculator?.startColumn ?? null;
-            },
-            get startColumnPartiallyVisible () {
-                return wot.wtViewport.columnsPartiallyVisibleCalculator?.startColumn ?? null;
-            },
-            get endColumnRendered () {
-                return wot.wtViewport.columnsRenderCalculator?.endColumn ?? null;
-            },
-            get endColumnVisible () {
-                return wot.wtViewport.columnsVisibleCalculator?.endColumn ?? null;
-            },
-            get endColumnPartiallyVisible () {
-                return wot.wtViewport.columnsPartiallyVisibleCalculator?.endColumn ?? null;
-            },
-            get countColumnsRendered () {
-                return wot.wtViewport.columnsRenderCalculator?.count ?? 0;
-            },
-            get countColumnsVisible () {
-                return wot.wtViewport.columnsVisibleCalculator?.count ?? 0;
-            },
-            get startRowRendered () {
-                return wot.wtViewport.rowsRenderCalculator?.startRow ?? null;
-            },
-            get startRowVisible () {
-                return wot.wtViewport.rowsVisibleCalculator?.startRow ?? null;
-            },
-            get startRowPartiallyVisible () {
-                return wot.wtViewport.rowsPartiallyVisibleCalculator?.startRow ?? null;
-            },
-            get endRowRendered () {
-                return wot.wtViewport.rowsRenderCalculator?.endRow ?? null;
-            },
-            get endRowVisible () {
-                return wot.wtViewport.rowsVisibleCalculator?.endRow ?? null;
-            },
-            get endRowPartiallyVisible () {
-                return wot.wtViewport.rowsPartiallyVisibleCalculator?.endRow ?? null;
-            },
-            get countRowsRendered () {
-                return wot.wtViewport.rowsRenderCalculator?.count ?? 0;
-            },
-            get countRowsVisible () {
-                return wot.wtViewport.rowsVisibleCalculator?.count ?? 0;
-            },
-            get columnHeaders () {
-                return wot.wtSettings.getSetting('columnHeaders');
-            },
-            get rowHeaders () {
-                return wot.wtSettings.getSetting('rowHeaders');
-            }
-        };
-    }
-    /**
    * @param {HTMLTableElement} table Main table.
    * @param {Settings} settings The Walkontable settings.
-   */ constructor(table, 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, settings, geometryReader){
         /**
    * The walkontable instance id.
    *
@@ -372,10 +235,17 @@ class CoreAbstract {
         this.domBindings = {
             rootTable: table,
             rootDocument: table.ownerDocument,
-            rootWindow: table.ownerDocument.defaultView
+            rootWindow: table.ownerDocument.defaultView,
+            geometryReader: geometryReader ?? new LiveGeometryReader(table.ownerDocument.defaultView)
         };
         this.wtSettings = settings;
-        this.wtScroll = new Scroll(this.createScrollDao());
+        // The engine context is the single composition surface: it holds the stable references and
+        // defines every late-bound/cyclic thunk ONCE. Built here because settings and DOM bindings now
+        // exist; the thunks resolve the table/viewport/overlays lazily, at call time, exactly as before.
+        this.engineContext = buildContext(this);
+        // `Scroll` is created before the table/viewport/overlays exist, so its dependency set is assembled
+        // from the context (the late-bound engine objects come through as thunks resolved at call time).
+        this.wtScroll = new Scroll(createScrollDeps(this.engineContext));
     }
 }
 /**

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

@@ -1,10 +1,6 @@
-import Event from '../event';
 import CoreAbstract from './_base';
 import type Settings from '../settings';
-import type Viewport from '../viewport';
-import type { SelectionManager } from '../selection/manager';
-import type { Overlay } from '../overlay/_base';
-import type { WalkontableInstance } from '../types';
+import type { CloneDeps } from '../overlay/regions/_base';
 /**
  * @class Walkontable
  */
@@ -12,21 +8,15 @@ export default class Clone extends CoreAbstract {
     /**
      * @type {Walkontable}
      */
-    cloneSource: WalkontableInstance;
+    cloneSource: import("../types").WalkontableInstance;
     /**
      * @type {Overlay}
      */
-    cloneOverlay: Overlay;
+    cloneOverlay: import("../overlay").Overlay;
     /**
      * @param {HTMLTableElement} table Main table.
      * @param {SettingsPure|Settings} settings The Walkontable settings.
      * @param {WalkontableCloneOptions} clone Clone data.
      */
-    constructor(table: HTMLTableElement, settings: Settings, clone: {
-        source: WalkontableInstance;
-        overlay: Overlay;
-        viewport: Viewport;
-        event: Event | Record<string, unknown> | null;
-        selectionManager: SelectionManager;
-    });
+    constructor(table: HTMLTableElement, settings: Settings, clone: CloneDeps);
 }

package/3rdparty/walkontable/src/core/clone.js

@@ -8,27 +8,73 @@ Object.defineProperty(exports, "default", {
         return Clone;
     }
 });
-const _event = /*#__PURE__*/ _interop_require_default(require("../event"));
+const _event = /*#__PURE__*/ _interop_require_wildcard(require("../event"));
+const _baseTable = require("../table/baseTable");
 const _base = /*#__PURE__*/ _interop_require_default(require("./_base"));
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
 }
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
 class Clone extends _base.default {
     /**
    * @param {HTMLTableElement} table Main table.
    * @param {SettingsPure|Settings} settings The Walkontable settings.
    * @param {WalkontableCloneOptions} clone Clone data.
    */ constructor(table, settings, clone){
-        super(table, settings);
-        const facadeGetter = this.wtSettings.getSetting('facade', this);
+        // Share the master's geometry reader instead of creating a new one, so a single reader serves
+        // the master and all overlay clones.
+        super(table, settings, clone.geometryReader);
         this.cloneSource = clone.source;
         this.cloneOverlay = clone.overlay;
-        this.wtTable = this.cloneOverlay.createTable(this.getTableDao(), facadeGetter, this.domBindings, this.wtSettings);
+        this.wtTable = this.cloneOverlay.createTable((0, _baseTable.createTableDeps)(this.engineContext));
         this.wtViewport = clone.viewport;
         this.selectionManager = clone.selectionManager;
-        this.wtEvent = new _event.default(facadeGetter, this.domBindings, this.wtSettings, this.eventManager, this.wtTable, this.selectionManager, clone.event);
+        // Event deps resolve `getWtTable()`/`getSelectionManager()` off this clone's context, so they
+        // read the clone's own table and selection manager (set just above). The parent Event is the
+        // per-instance link back to the master, kept as a separate argument.
+        this.wtEvent = new _event.default((0, _event.createEventDeps)(this.engineContext), clone.event);
         this.findOriginalHeaders();
     }
 }