handsontable 18.0.0 → 18.1.0-rc7

package/3rdparty/walkontable/src/render/tableRenderer.js

@@ -0,0 +1,382 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "TableRenderer", {
+    enumerable: true,
+    get: function() {
+        return TableRenderer;
+    }
+});
+const _boxModel = require("../axisSizing/boxModel");
+function _check_private_redeclaration(obj, privateCollection) {
+    if (privateCollection.has(obj)) {
+        throw new TypeError("Cannot initialize the same private elements twice on an object");
+    }
+}
+function _class_apply_descriptor_get(receiver, descriptor) {
+    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.writable) {
+            throw new TypeError("attempted to set read only private field");
+        }
+        descriptor.value = value;
+    }
+}
+function _class_extract_field_descriptor(receiver, privateMap, action) {
+    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) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "get");
+    return _class_apply_descriptor_get(receiver, descriptor);
+}
+function _class_private_field_init(obj, privateMap, value) {
+    _check_private_redeclaration(obj, privateMap);
+    privateMap.set(obj, value);
+}
+function _class_private_field_set(receiver, privateMap, value) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "set");
+    _class_apply_descriptor_set(receiver, descriptor, 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");
+    }
+    return fn;
+}
+function _class_private_method_init(obj, privateSet) {
+    _check_private_redeclaration(obj, privateSet);
+    privateSet.add(obj);
+}
+var /**
+   * When `true`, the column-header pass (THEAD) may be skipped for this draw if the column render
+   * window is unchanged. Set once per draw by the draw cycle; only a pure vertical scroll (no data,
+   * settings, selection, or column-window change) enables it. Defaults to `false` so every non-scroll
+   * draw renders the headers.
+   *
+   * @type {boolean}
+   */ _columnHeadersRenderSkippable = /*#__PURE__*/ new WeakMap(), /**
+   * `true` once the column-header pass has rendered at least once and stored its render window.
+   *
+   * @type {boolean}
+   */ _hasStoredColumnHeaderWindow = /*#__PURE__*/ new WeakMap(), /**
+   * The first rendered column (column filter offset) captured on the last column-header render.
+   *
+   * @type {number}
+   */ _prevColumnHeaderOffset = /*#__PURE__*/ new WeakMap(), /**
+   * The number of rendered columns captured on the last column-header render.
+   *
+   * @type {number}
+   */ _prevColumnsToRender = /*#__PURE__*/ new WeakMap(), /**
+   * The column headers count captured on the last column-header render.
+   *
+   * @type {number}
+   */ _prevColumnHeadersCount = /*#__PURE__*/ new WeakMap(), /**
+   * The row headers count captured on the last column-header render.
+   *
+   * @type {number}
+   */ _prevRowHeadersCount = /*#__PURE__*/ new WeakMap(), /**
+   * Returns `true` when the column-header (THEAD) pass can be skipped for this draw because it is a
+   * pure vertical scroll and the exact same column render window (offset + counts) was rendered on
+   * the previous header render. The THEAD content is then identical to what is already in the DOM.
+   *
+   * @returns {boolean}
+   */ _canSkipColumnHeadersRender = /*#__PURE__*/ new WeakSet(), /**
+   * Stores the current column render window so the next draw can detect whether it is unchanged.
+   */ _storeColumnHeaderRenderWindow = /*#__PURE__*/ new WeakSet();
+class TableRenderer {
+    /**
+   * Sets the overlay that is currently rendered. If `null` is provided, the master overlay is set.
+   *
+   * @param {'inline_start'|'top'|'top_inline_start_corner'|'bottom'|'bottom_inline_start_corner'|'master'} overlayName The overlay name.
+   */ setActiveOverlayName(overlayName) {
+        this.activeOverlayName = overlayName;
+    }
+    /**
+   * Set row and column util classes.
+   *
+   * @param {RowUtils} rowUtils RowUtils instance which provides useful methods related to row sizes.
+   * @param {ColumnUtils} columnUtils ColumnUtils instance which provides useful methods related to row sizes.
+   */ setAxisUtils(rowUtils, columnUtils) {
+        this.rowUtils = rowUtils;
+        this.columnUtils = columnUtils;
+    }
+    /**
+   * Sets viewport size of the table.
+   *
+   * @param {number} rowsCount An amount of rows to render.
+   * @param {number} columnsCount An amount of columns to render.
+   */ setViewportSize(rowsCount, columnsCount) {
+        this.rowsToRender = rowsCount;
+        this.columnsToRender = columnsCount;
+    }
+    /**
+   * Marks this draw as one where the column-header (THEAD) pass may be skipped, provided the column
+   * render window is unchanged since the last header render. The draw cycle sets this to `true` only
+   * for a pure vertical scroll (nothing but the vertical scroll position changed), and to `false`
+   * otherwise, so any data, settings, selection, or column-window change re-renders the headers.
+   *
+   * @param {boolean} skippable Whether the column-header pass may be skipped for this draw.
+   */ setColumnHeadersRenderSkippable(skippable) {
+        _class_private_field_set(this, _columnHeadersRenderSkippable, skippable);
+    }
+    /**
+   * Sets row and column filter instances.
+   *
+   * @param {RowFilter} rowFilter Row filter instance which contains all necessary information about row index transformation.
+   * @param {ColumnFilter} columnFilter Column filter instance which contains all necessary information about row
+   * index transformation.
+   */ setFilters(rowFilter, columnFilter) {
+        this.rowFilter = rowFilter;
+        this.columnFilter = columnFilter;
+    }
+    /**
+   * Sets row and column header functions.
+   *
+   * @param {Function[]} rowHeaders Row header functions. Factories for creating content for row headers.
+   * @param {Function[]} columnHeaders Column header functions. Factories for creating content for column headers.
+   */ setHeaderContentRenderers(rowHeaders, columnHeaders) {
+        this.rowHeaderFunctions = rowHeaders;
+        this.rowHeadersCount = rowHeaders.length;
+        this.columnHeaderFunctions = columnHeaders;
+        this.columnHeadersCount = columnHeaders.length;
+    }
+    /**
+   * Sets table renderers.
+   *
+   * @param {renderers} renderers The renderer units.
+   * @param {RowHeadersRenderer} renderers.rowHeaders Row headers renderer.
+   * @param {ColumnHeaderRowsRenderer} renderers.columnHeaderRows Column header rows renderer.
+   * @param {ColumnHeadersRenderer} renderers.columnHeaders Column headers renderer.
+   * @param {ColGroupRenderer} renderers.colGroup Col group renderer.
+   * @param {RowsRenderer} renderers.rows Rows renderer.
+   * @param {CellsRenderer} renderers.cells Cells renderer.
+   */ setRenderers({ rowHeaders, columnHeaderRows, columnHeaders, colGroup, rows, cells }) {
+        rowHeaders.setTable(this);
+        columnHeaderRows.setTable(this);
+        columnHeaders.setTable(this);
+        colGroup.setTable(this);
+        rows.setTable(this);
+        cells.setTable(this);
+        this.rowHeaders = rowHeaders;
+        this.columnHeaderRows = columnHeaderRows;
+        this.columnHeaders = columnHeaders;
+        this.colGroup = colGroup;
+        this.rows = rows;
+        this.cells = cells;
+    }
+    /**
+   * Transforms visual/rendered row index to source index.
+   *
+   * @param {number} rowIndex Rendered index.
+   * @returns {number}
+   */ renderedRowToSource(rowIndex) {
+        return this.rowFilter.renderedToSource(rowIndex);
+    }
+    /**
+   * Transforms visual/rendered column index to source index.
+   *
+   * @param {number} columnIndex Rendered index.
+   * @returns {number}
+   */ renderedColumnToSource(columnIndex) {
+        return this.columnFilter.renderedToSource(columnIndex);
+    }
+    /**
+   * Returns `true` if the accessibility-related ARIA tags should be added to the table, `false` otherwise.
+   *
+   * @returns {boolean}
+   */ isAriaEnabled() {
+        return this.rowUtils.wtSettings.getSetting('ariaTags');
+    }
+    /**
+   * Renders the table.
+   */ render() {
+        // On a pure vertical scroll the THEAD (column header rows + cells) is identical draw-to-draw, so
+        // skip re-rendering it. The selection highlight classes on headers are (re)applied by the
+        // separate selection pass, and are unchanged while only the vertical scroll position moves.
+        if (!_class_private_method_get(this, _canSkipColumnHeadersRender, canSkipColumnHeadersRender).call(this)) {
+            this.columnHeaderRows.render();
+            this.columnHeaders.render();
+            _class_private_method_get(this, _storeColumnHeaderRenderWindow, storeColumnHeaderRenderWindow).call(this);
+        }
+        // Stationary bands: the TR/TD/TH nodes keep their DOM positions on every draw — the
+        // `OrderView`s reuse the children in place and the renderers below overwrite their content.
+        // Rows and cells are deliberately NEVER moved, inserted, or removed while a band merely shifts
+        // (the draw cycle keeps both band sizes stable on scroll-driven draws — see
+        // `stabilizeRenderedRowsBand`/`stabilizeRenderedColumnsBand`). Structural DOM mutations here
+        // would trigger the host page's `:has()` style invalidation on every scroll, at a cost that
+        // scales with the host document.
+        this.rows.render();
+        this.rowHeaders.render();
+        this.cells.render();
+        // After the cells are rendered calculate columns width to prepare proper values
+        // for colGroup renderer (which renders COL elements).
+        this.columnUtils.calculateWidths();
+        this.colGroup.render();
+        const { rowsToRender, rows } = this;
+        // Fix for multi-line content and for supporting `rowHeights` option.
+        for(let visibleRowIndex = 0; visibleRowIndex < rowsToRender; visibleRowIndex++){
+            const TR = rows.getRenderedNode(visibleRowIndex);
+            const rowUtils = this.rowUtils;
+            if (TR && TR.firstChild) {
+                const sourceRowIndex = this.renderedRowToSource(visibleRowIndex);
+                const rowHeight = rowUtils.getHeightByOverlayName(sourceRowIndex, this.activeOverlayName);
+                if (rowHeight) {
+                    // Convert the logical row height to the pixel height written to the DOM. In content-box mode
+                    // 1px is "replaced" by the row's 1px top border; the shared helper keeps that constant in one
+                    // place (see axisSizing/boxModel.ts).
+                    const pixelHeight = (0, _boxModel.getBoxAdjustedRowHeight)(rowHeight, this.stylesHandler.areCellsBorderBox());
+                    TR.firstChild.style.height = `${pixelHeight}px`;
+                } else {
+                    TR.firstChild.style.height = '';
+                }
+            }
+        }
+    }
+    /**
+   * Creates a new TableRenderer instance.
+   *
+   * @param {HTMLTableElement} rootNode The HTML table element to use as the root node for rendering.
+   * @param {object} options The configuration options.
+   * @param {Function} [options.cellRenderer] The cell renderer function.
+   * @param {StylesHandler} [options.stylesHandler] The styles handler instance.
+   */ constructor(rootNode, { cellRenderer, stylesHandler } = {}){
+        _class_private_method_init(this, _canSkipColumnHeadersRender);
+        _class_private_method_init(this, _storeColumnHeaderRenderWindow);
+        _class_private_field_init(this, _columnHeadersRenderSkippable, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _hasStoredColumnHeaderWindow, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _prevColumnHeaderOffset, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _prevColumnsToRender, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _prevColumnHeadersCount, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _prevRowHeadersCount, {
+            writable: true,
+            value: void 0
+        });
+        /**
+   * Renderer class responsible for rendering row headers.
+   *
+   * @type {RowHeadersRenderer}
+   */ this.rowHeaders = null;
+        /**
+   * Renderer class responsible for rendering column header rows (TR elements in THEAD).
+   *
+   * @type {ColumnHeaderRowsRenderer}
+   */ this.columnHeaderRows = null;
+        /**
+   * Renderer class responsible for rendering column headers (TH elements in TR).
+   *
+   * @type {ColumnHeadersRenderer}
+   */ this.columnHeaders = null;
+        /**
+   * Renderer class responsible for rendering col in colgroup.
+   *
+   * @type {ColGroupRenderer}
+   */ this.colGroup = null;
+        /**
+   * Renderer class responsible for rendering rows in tbody.
+   *
+   * @type {RowsRenderer}
+   */ this.rows = null;
+        /**
+   * Renderer class responsible for rendering cells.
+   *
+   * @type {CellsRenderer}
+   */ this.cells = null;
+        /**
+   * Row filter which contains all necessary information about row index transformation.
+   *
+   * @type {RowFilter}
+   */ this.rowFilter = null;
+        /**
+   * Column filter which contains all necessary information about column index transformation.
+   *
+   * @type {ColumnFilter}
+   */ this.columnFilter = null;
+        /**
+   * Row utils class which contains all necessary information about sizes of the rows.
+   *
+   * @type {RowUtils}
+   */ this.rowUtils = null;
+        /**
+   * Column utils class which contains all necessary information about sizes of the columns.
+   *
+   * @type {ColumnUtils}
+   */ this.columnUtils = null;
+        /**
+   * Indicates how much rows should be rendered to fill whole table viewport.
+   *
+   * @type {number}
+   */ this.rowsToRender = 0;
+        /**
+   * Indicates how much columns should be rendered to fill whole table viewport.
+   *
+   * @type {number}
+   */ this.columnsToRender = 0;
+        /**
+   * An array of functions to be used as a content factory to row headers.
+   *
+   * @type {Function[]}
+   */ this.rowHeaderFunctions = [];
+        /**
+   * Count of the function used to render row headers.
+   *
+   * @type {number}
+   */ this.rowHeadersCount = 0;
+        /**
+   * An array of functions to be used as a content factory to column headers.
+   *
+   * @type {Function[]}
+   */ this.columnHeaderFunctions = [];
+        /**
+   * Count of the function used to render column headers.
+   *
+   * @type {number}
+   */ this.columnHeadersCount = 0;
+        _class_private_field_set(this, _columnHeadersRenderSkippable, false);
+        _class_private_field_set(this, _hasStoredColumnHeaderWindow, false);
+        _class_private_field_set(this, _prevColumnHeaderOffset, -1);
+        _class_private_field_set(this, _prevColumnsToRender, -1);
+        _class_private_field_set(this, _prevColumnHeadersCount, -1);
+        _class_private_field_set(this, _prevRowHeadersCount, -1);
+        this.rootNode = rootNode;
+        this.rootDocument = this.rootNode.ownerDocument;
+        this.cellRenderer = cellRenderer;
+        this.stylesHandler = stylesHandler;
+    }
+}
+function canSkipColumnHeadersRender() {
+    return _class_private_field_get(this, _columnHeadersRenderSkippable) && _class_private_field_get(this, _hasStoredColumnHeaderWindow) && _class_private_field_get(this, _prevColumnHeaderOffset) === (this.columnFilter ? this.columnFilter.offset : 0) && _class_private_field_get(this, _prevColumnsToRender) === this.columnsToRender && _class_private_field_get(this, _prevColumnHeadersCount) === this.columnHeadersCount && _class_private_field_get(this, _prevRowHeadersCount) === this.rowHeadersCount;
+}
+function storeColumnHeaderRenderWindow() {
+    _class_private_field_set(this, _hasStoredColumnHeaderWindow, true);
+    _class_private_field_set(this, _prevColumnHeaderOffset, this.columnFilter ? this.columnFilter.offset : 0);
+    _class_private_field_set(this, _prevColumnsToRender, this.columnsToRender);
+    _class_private_field_set(this, _prevColumnHeadersCount, this.columnHeadersCount);
+    _class_private_field_set(this, _prevRowHeadersCount, this.rowHeadersCount);
+}

package/3rdparty/walkontable/src/{renderer/table.mjs → render/tableRenderer.mjs}

@@ -1,3 +1,90 @@
+function _check_private_redeclaration(obj, privateCollection) {
+    if (privateCollection.has(obj)) {
+        throw new TypeError("Cannot initialize the same private elements twice on an object");
+    }
+}
+function _class_apply_descriptor_get(receiver, descriptor) {
+    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.writable) {
+            throw new TypeError("attempted to set read only private field");
+        }
+        descriptor.value = value;
+    }
+}
+function _class_extract_field_descriptor(receiver, privateMap, action) {
+    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) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "get");
+    return _class_apply_descriptor_get(receiver, descriptor);
+}
+function _class_private_field_init(obj, privateMap, value) {
+    _check_private_redeclaration(obj, privateMap);
+    privateMap.set(obj, value);
+}
+function _class_private_field_set(receiver, privateMap, value) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "set");
+    _class_apply_descriptor_set(receiver, descriptor, 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");
+    }
+    return fn;
+}
+function _class_private_method_init(obj, privateSet) {
+    _check_private_redeclaration(obj, privateSet);
+    privateSet.add(obj);
+}
+import { getBoxAdjustedRowHeight } from '../axisSizing/boxModel.mjs';
+var /**
+   * When `true`, the column-header pass (THEAD) may be skipped for this draw if the column render
+   * window is unchanged. Set once per draw by the draw cycle; only a pure vertical scroll (no data,
+   * settings, selection, or column-window change) enables it. Defaults to `false` so every non-scroll
+   * draw renders the headers.
+   *
+   * @type {boolean}
+   */ _columnHeadersRenderSkippable = /*#__PURE__*/ new WeakMap(), /**
+   * `true` once the column-header pass has rendered at least once and stored its render window.
+   *
+   * @type {boolean}
+   */ _hasStoredColumnHeaderWindow = /*#__PURE__*/ new WeakMap(), /**
+   * The first rendered column (column filter offset) captured on the last column-header render.
+   *
+   * @type {number}
+   */ _prevColumnHeaderOffset = /*#__PURE__*/ new WeakMap(), /**
+   * The number of rendered columns captured on the last column-header render.
+   *
+   * @type {number}
+   */ _prevColumnsToRender = /*#__PURE__*/ new WeakMap(), /**
+   * The column headers count captured on the last column-header render.
+   *
+   * @type {number}
+   */ _prevColumnHeadersCount = /*#__PURE__*/ new WeakMap(), /**
+   * The row headers count captured on the last column-header render.
+   *
+   * @type {number}
+   */ _prevRowHeadersCount = /*#__PURE__*/ new WeakMap(), /**
+   * Returns `true` when the column-header (THEAD) pass can be skipped for this draw because it is a
+   * pure vertical scroll and the exact same column render window (offset + counts) was rendered on
+   * the previous header render. The THEAD content is then identical to what is already in the DOM.
+   *
+   * @returns {boolean}
+   */ _canSkipColumnHeadersRender = /*#__PURE__*/ new WeakSet(), /**
+   * Stores the current column render window so the next draw can detect whether it is unchanged.
+   */ _storeColumnHeaderRenderWindow = /*#__PURE__*/ new WeakSet();
 /**
  * TableRenderer class collects all renderers and properties necessary for table creation. It's
  * responsible for adjusting and rendering each renderer.
@@ -68,6 +155,16 @@
         this.columnsToRender = columnsCount;
     }
     /**
+   * Marks this draw as one where the column-header (THEAD) pass may be skipped, provided the column
+   * render window is unchanged since the last header render. The draw cycle sets this to `true` only
+   * for a pure vertical scroll (nothing but the vertical scroll position changed), and to `false`
+   * otherwise, so any data, settings, selection, or column-window change re-renders the headers.
+   *
+   * @param {boolean} skippable Whether the column-header pass may be skipped for this draw.
+   */ setColumnHeadersRenderSkippable(skippable) {
+        _class_private_field_set(this, _columnHeadersRenderSkippable, skippable);
+    }
+    /**
    * Sets row and column filter instances.
    *
    * @param {RowFilter} rowFilter Row filter instance which contains all necessary information about row index transformation.
@@ -138,8 +235,21 @@
     /**
    * Renders the table.
    */ render() {
-        this.columnHeaderRows.render();
-        this.columnHeaders.render();
+        // On a pure vertical scroll the THEAD (column header rows + cells) is identical draw-to-draw, so
+        // skip re-rendering it. The selection highlight classes on headers are (re)applied by the
+        // separate selection pass, and are unchanged while only the vertical scroll position moves.
+        if (!_class_private_method_get(this, _canSkipColumnHeadersRender, canSkipColumnHeadersRender).call(this)) {
+            this.columnHeaderRows.render();
+            this.columnHeaders.render();
+            _class_private_method_get(this, _storeColumnHeaderRenderWindow, storeColumnHeaderRenderWindow).call(this);
+        }
+        // Stationary bands: the TR/TD/TH nodes keep their DOM positions on every draw — the
+        // `OrderView`s reuse the children in place and the renderers below overwrite their content.
+        // Rows and cells are deliberately NEVER moved, inserted, or removed while a band merely shifts
+        // (the draw cycle keeps both band sizes stable on scroll-driven draws — see
+        // `stabilizeRenderedRowsBand`/`stabilizeRenderedColumnsBand`). Structural DOM mutations here
+        // would trigger the host page's `:has()` style invalidation on every scroll, at a cost that
+        // scales with the host document.
         this.rows.render();
         this.rowHeaders.render();
         this.cells.render();
@@ -155,11 +265,12 @@
             if (TR && TR.firstChild) {
                 const sourceRowIndex = this.renderedRowToSource(visibleRowIndex);
                 const rowHeight = rowUtils.getHeightByOverlayName(sourceRowIndex, this.activeOverlayName);
-                const isBorderBoxSizing = this.stylesHandler.areCellsBorderBox();
-                const borderCompensation = isBorderBoxSizing ? 0 : 1;
                 if (rowHeight) {
-                    // Decrease height. 1 pixel will be "replaced" by 1px border top
-                    TR.firstChild.style.height = `${rowHeight - borderCompensation}px`;
+                    // Convert the logical row height to the pixel height written to the DOM. In content-box mode
+                    // 1px is "replaced" by the row's 1px top border; the shared helper keeps that constant in one
+                    // place (see axisSizing/boxModel.ts).
+                    const pixelHeight = getBoxAdjustedRowHeight(rowHeight, this.stylesHandler.areCellsBorderBox());
+                    TR.firstChild.style.height = `${pixelHeight}px`;
                 } else {
                     TR.firstChild.style.height = '';
                 }
@@ -174,6 +285,32 @@
    * @param {Function} [options.cellRenderer] The cell renderer function.
    * @param {StylesHandler} [options.stylesHandler] The styles handler instance.
    */ constructor(rootNode, { cellRenderer, stylesHandler } = {}){
+        _class_private_method_init(this, _canSkipColumnHeadersRender);
+        _class_private_method_init(this, _storeColumnHeaderRenderWindow);
+        _class_private_field_init(this, _columnHeadersRenderSkippable, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _hasStoredColumnHeaderWindow, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _prevColumnHeaderOffset, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _prevColumnsToRender, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _prevColumnHeadersCount, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _prevRowHeadersCount, {
+            writable: true,
+            value: void 0
+        });
         /**
    * Renderer class responsible for rendering row headers.
    *
@@ -254,9 +391,25 @@
    *
    * @type {number}
    */ this.columnHeadersCount = 0;
+        _class_private_field_set(this, _columnHeadersRenderSkippable, false);
+        _class_private_field_set(this, _hasStoredColumnHeaderWindow, false);
+        _class_private_field_set(this, _prevColumnHeaderOffset, -1);
+        _class_private_field_set(this, _prevColumnsToRender, -1);
+        _class_private_field_set(this, _prevColumnHeadersCount, -1);
+        _class_private_field_set(this, _prevRowHeadersCount, -1);
         this.rootNode = rootNode;
         this.rootDocument = this.rootNode.ownerDocument;
         this.cellRenderer = cellRenderer;
         this.stylesHandler = stylesHandler;
     }
 }
+function canSkipColumnHeadersRender() {
+    return _class_private_field_get(this, _columnHeadersRenderSkippable) && _class_private_field_get(this, _hasStoredColumnHeaderWindow) && _class_private_field_get(this, _prevColumnHeaderOffset) === (this.columnFilter ? this.columnFilter.offset : 0) && _class_private_field_get(this, _prevColumnsToRender) === this.columnsToRender && _class_private_field_get(this, _prevColumnHeadersCount) === this.columnHeadersCount && _class_private_field_get(this, _prevRowHeadersCount) === this.rowHeadersCount;
+}
+function storeColumnHeaderRenderWindow() {
+    _class_private_field_set(this, _hasStoredColumnHeaderWindow, true);
+    _class_private_field_set(this, _prevColumnHeaderOffset, this.columnFilter ? this.columnFilter.offset : 0);
+    _class_private_field_set(this, _prevColumnsToRender, this.columnsToRender);
+    _class_private_field_set(this, _prevColumnHeadersCount, this.columnHeadersCount);
+    _class_private_field_set(this, _prevRowHeadersCount, this.rowHeadersCount);
+}

package/3rdparty/walkontable/src/{scroll.d.ts → scroll/scroll.d.ts}

@@ -1,20 +1,37 @@
-import type { ScrollDao } from './types';
+import type { EngineContext } from '../wire';
+/**
+ * Assembles the Scroll module's dependencies from the engine composition context.
+ *
+ * This factory is the single source of truth for what Scroll depends on: adding or removing a
+ * dependency is a one-line edit here, and the `ScrollDeps` type is inferred from the return value,
+ * so there is no separate hand-written interface to keep in sync.
+ *
+ * @param {EngineContext} ctx The engine composition context.
+ * @returns {object} The Scroll dependency set.
+ */
+export declare function createScrollDeps(ctx: EngineContext): {
+    wtSettings: import("../settings").default;
+    rootWindow: Window;
+    geometryReader: import("../domMeasure/geometryReader").GeometryReader;
+    isDrawn: () => boolean;
+    getWtTable: () => import("../table/baseTable").default;
+    getWtViewport: () => import("../viewport/viewport").default;
+    getTopOverlay: () => import("../overlay").Overlay;
+    getInlineStartOverlay: () => import("../overlay").Overlay;
+};
+/**
+ * The Scroll module dependencies, inferred from `createScrollDeps`.
+ */
+export type ScrollDeps = ReturnType<typeof createScrollDeps>;
 /**
  * @class Scroll
  */
 declare class Scroll {
     #private;
     /**
-     * The data access object.
-     *
-     * @protected
-     * @type {ScrollDao}
-     */
-    dataAccessObject: ScrollDao;
-    /**
-     * @param {ScrollDao} dataAccessObject Tha data access object.
+     * @param {ScrollDeps} deps The Scroll module dependencies.
      */
-    constructor(dataAccessObject: ScrollDao);
+    constructor(deps: ScrollDeps);
     /**
      * Scrolls viewport to a cell.
      *