handsontable 18.0.0 → 18.1.0-rc7

package/3rdparty/walkontable/src/{stickyScrollStrategy.mjs → overlay/strategies/stickyScrollStrategy.mjs}

@@ -48,8 +48,33 @@ function _class_private_method_init(obj, privateSet) {
     _check_private_redeclaration(obj, privateSet);
     privateSet.add(obj);
 }
-import { isSafari } from '../../../helpers/browser.mjs';
-var _overlays = /*#__PURE__*/ new WeakMap(), /**
+import { isSafari } from '../../../../../helpers/browser.mjs';
+/**
+ * Assembles the StickyScrollStrategy's dependencies. Most come from the engine composition context;
+ * the three that drive the Overlays coordinator itself (`refreshAll`/`applyToDOM`/`scrollableElement`)
+ * and the shared `eventManager` come from the owning Overlays instance — so its scrollbar listeners
+ * are tracked on (and torn down with) the same event manager as the rest of the overlays.
+ *
+ * @param {EngineContext} ctx The engine composition context.
+ * @param {Overlays} overlays The owning Overlays coordinator.
+ * @returns {object} The StickyScrollStrategy dependency set.
+ */ export function createStickyScrollStrategyDeps(ctx, overlays) {
+    return {
+        wtSettings: ctx.wtSettings,
+        rootDocument: ctx.rootDocument,
+        rootWindow: ctx.rootWindow,
+        eventManager: overlays.eventManager,
+        wtTable: ctx.getWtTable(),
+        getWtViewport: ctx.getWtViewport,
+        getTopOverlay: ctx.getTopOverlay,
+        getBottomOverlay: ctx.getBottomOverlay,
+        getInlineStartOverlay: ctx.getInlineStartOverlay,
+        getScrollableElement: ()=>overlays.scrollableElement,
+        refreshAll: ()=>overlays.refreshAll(),
+        applyToDOM: ()=>overlays.applyToDOM()
+    };
+}
+var _deps = /*#__PURE__*/ new WeakMap(), /**
    * Whether sticky-scroll mode is currently active.
    *
    * @type {boolean}
@@ -132,7 +157,7 @@ var _overlays = /*#__PURE__*/ new WeakMap(), /**
    * Registers mousedown/mouseup listeners for scrollbar drag detection.
    * Called from `Overlays.registerListeners()`.
    */ registerListeners() {
-        const { eventManager, domBindings: { rootDocument } } = _class_private_field_get(this, _overlays);
+        const { eventManager, rootDocument } = _class_private_field_get(this, _deps);
         // Scrollable elements may have changed (e.g. updateSettings). Discard any
         // leftover sticky state so a stale deactivate() cannot compute a wrong scroll.
         if (_class_private_field_get(this, _active)) {
@@ -171,8 +196,7 @@ var _overlays = /*#__PURE__*/ new WeakMap(), /**
         if (!_class_private_field_get(this, _active)) {
             return;
         }
-        const overlays = _class_private_field_get(this, _overlays);
-        const { wtViewport } = overlays.wot;
+        const wtViewport = _class_private_field_get(this, _deps).getWtViewport();
         const startTop = wtViewport.rowsRenderCalculator?.startPosition;
         const startLeft = wtViewport.columnsRenderCalculator?.startPosition;
         // startPosition is null when nothing is rendered (empty dataset or trimmed-away rows/columns).
@@ -198,13 +222,12 @@ var _overlays = /*#__PURE__*/ new WeakMap(), /**
    * the scroll position to match, then restores `position: relative` and
    * triggers a final full render.
    */ deactivate() {
-        const overlays = _class_private_field_get(this, _overlays);
-        const spreader = overlays.wtTable.spreader;
-        const { wtViewport } = overlays.wot;
-        const isRtl = overlays.wtSettings.getSetting('rtlMode');
+        const spreader = _class_private_field_get(this, _deps).wtTable.spreader;
+        const wtViewport = _class_private_field_get(this, _deps).getWtViewport();
+        const isRtl = _class_private_field_get(this, _deps).wtSettings.getSetting('rtlMode');
         const leftProp = isRtl ? 'right' : 'left';
         // Render while still active (same code path as during drag).
-        overlays.refreshAll();
+        _class_private_field_get(this, _deps).refreshAll();
         // Capture the sticky offsets and computed start positions.
         const lastStickyTop = Number.parseInt(spreader.style.top, 10) || 0;
         const lastStickyLeft = Number.parseInt(spreader.style[leftProp], 10) || 0;
@@ -218,12 +241,12 @@ var _overlays = /*#__PURE__*/ new WeakMap(), /**
         _class_private_field_set(this, _active, false);
         _class_private_method_get(this, _applySpreaderStyles, applySpreaderStyles).call(this, 'relative', 0, 0);
         // Final render in normal mode at the corrected scroll position.
-        overlays.refreshAll();
-        overlays.applyToDOM();
+        _class_private_field_get(this, _deps).refreshAll();
+        _class_private_field_get(this, _deps).applyToDOM();
     }
     /**
-   * @param {Overlays} overlays The parent Overlays instance.
-   */ constructor(overlays){
+   * @param {StickyScrollStrategyDeps} deps The StickyScrollStrategy dependencies.
+   */ constructor(deps){
         _class_private_method_init(this, _activate);
         _class_private_method_init(this, _getScrollTop);
         _class_private_method_init(this, _getScrollLeft);
@@ -235,10 +258,10 @@ var _overlays = /*#__PURE__*/ new WeakMap(), /**
         _class_private_method_init(this, _isWindowScroll);
         _class_private_method_init(this, _isRtl);
         /**
-   * Reference to the parent Overlays coordinator.
+   * The StickyScrollStrategy dependencies.
    *
-   * @type {OverlaysLike}
-   */ _class_private_field_init(this, _overlays, {
+   * @type {StickyScrollStrategyDeps}
+   */ _class_private_field_init(this, _deps, {
             writable: true,
             value: void 0
         });
@@ -252,13 +275,12 @@ var _overlays = /*#__PURE__*/ new WeakMap(), /**
         });
         _class_private_field_set(this, _active, false);
         _class_private_field_set(this, _mouseDown, false);
-        _class_private_field_set(this, _overlays, overlays);
+        _class_private_field_set(this, _deps, deps);
     }
 }
 function activate() {
-    const overlays = _class_private_field_get(this, _overlays);
-    const spreader = overlays.wtTable.spreader;
-    const isRtl = overlays.wtSettings.getSetting('rtlMode');
+    const spreader = _class_private_field_get(this, _deps).wtTable.spreader;
+    const isRtl = _class_private_field_get(this, _deps).wtSettings.getSetting('rtlMode');
     const leftProp = isRtl ? 'right' : 'left';
     const startTop = Number.parseInt(spreader.style.top, 10) || 0;
     const stickyTop = startTop - _class_private_method_get(this, _getScrollTop, getScrollTop).call(this);
@@ -268,11 +290,11 @@ function activate() {
     _class_private_method_get(this, _applySpreaderStyles, applySpreaderStyles).call(this, 'sticky', stickyTop, stickyLeft);
 }
 function getScrollTop() {
-    const { topOverlay } = _class_private_field_get(this, _overlays);
+    const topOverlay = _class_private_field_get(this, _deps).getTopOverlay();
     return topOverlay.getScrollPosition() - topOverlay.getTableParentOffset();
 }
 function getScrollLeft() {
-    const { inlineStartOverlay } = _class_private_field_get(this, _overlays);
+    const inlineStartOverlay = _class_private_field_get(this, _deps).getInlineStartOverlay();
     // For RTL window scrolling, scrollX increases as the user scrolls left (away from
     // the right-edge origin). getTableParentOffset() returns the left-edge offset which
     // doesn't apply to the RTL coordinate system, so skip it and return scrollX directly.
@@ -282,16 +304,15 @@ function getScrollLeft() {
     return Math.abs(inlineStartOverlay.getScrollPosition()) - inlineStartOverlay.getTableParentOffset();
 }
 function setScrollPosition(top, left) {
-    const overlays = _class_private_field_get(this, _overlays);
     if (_class_private_method_get(this, _isWindowScroll, isWindowScroll).call(this)) {
-        const { rootWindow } = overlays.domBindings;
+        const { rootWindow } = _class_private_field_get(this, _deps);
         // RTL + window-scroll: left is in scrollX coordinates (distance from the right-edge
         // origin), so pass it directly. LTR: add back the table's left page offset.
-        const absoluteLeft = _class_private_method_get(this, _isRtl, isRtl).call(this) ? left : left + overlays.inlineStartOverlay.getTableParentOffset();
-        rootWindow.scrollTo(absoluteLeft, top + overlays.topOverlay.getTableParentOffset());
+        const absoluteLeft = _class_private_method_get(this, _isRtl, isRtl).call(this) ? left : left + _class_private_field_get(this, _deps).getInlineStartOverlay().getTableParentOffset();
+        rootWindow.scrollTo(absoluteLeft, top + _class_private_field_get(this, _deps).getTopOverlay().getTableParentOffset());
     } else {
-        overlays.wtTable.holder.scrollTop = top;
-        overlays.wtTable.holder.scrollLeft = _class_private_method_get(this, _isRtl, isRtl).call(this) ? -left : left;
+        _class_private_field_get(this, _deps).wtTable.holder.scrollTop = top;
+        _class_private_field_get(this, _deps).wtTable.holder.scrollLeft = _class_private_method_get(this, _isRtl, isRtl).call(this) ? -left : left;
     }
 }
 function clearSpreaderInsetStyles(element) {
@@ -301,8 +322,7 @@ function clearSpreaderInsetStyles(element) {
     element.style.right = '';
 }
 function applySpreaderStyles(position, stickyTop, stickyLeft) {
-    const overlays = _class_private_field_get(this, _overlays);
-    const spreader = overlays.wtTable.spreader;
+    const spreader = _class_private_field_get(this, _deps).wtTable.spreader;
     const isRtl1 = _class_private_method_get(this, _isRtl, isRtl).call(this);
     const leftProp = isRtl1 ? 'right' : 'left';
     const isSticky = position === 'sticky';
@@ -322,9 +342,9 @@ function applySpreaderStyles(position, stickyTop, stickyLeft) {
     if (_class_private_method_get(this, _isWindowScroll, isWindowScroll).call(this)) {
         return;
     }
-    _class_private_method_get(this, _applyCloneSpreaderStyles, applyCloneSpreaderStyles).call(this, overlays.inlineStartOverlay, position, isSticky, stickyTop, null, isRtl1);
-    _class_private_method_get(this, _applyCloneSpreaderStyles, applyCloneSpreaderStyles).call(this, overlays.topOverlay, position, isSticky, null, stickyLeft, isRtl1);
-    _class_private_method_get(this, _applyCloneSpreaderStyles, applyCloneSpreaderStyles).call(this, overlays.bottomOverlay, position, isSticky, null, stickyLeft, isRtl1);
+    _class_private_method_get(this, _applyCloneSpreaderStyles, applyCloneSpreaderStyles).call(this, _class_private_field_get(this, _deps).getInlineStartOverlay(), position, isSticky, stickyTop, null, isRtl1);
+    _class_private_method_get(this, _applyCloneSpreaderStyles, applyCloneSpreaderStyles).call(this, _class_private_field_get(this, _deps).getTopOverlay(), position, isSticky, null, stickyLeft, isRtl1);
+    _class_private_method_get(this, _applyCloneSpreaderStyles, applyCloneSpreaderStyles).call(this, _class_private_field_get(this, _deps).getBottomOverlay(), position, isSticky, null, stickyLeft, isRtl1);
 }
 function applyCloneSpreaderStyles(overlay, position, isSticky, stickyTop, stickyLeft, isRtl) {
     if (!overlay.needFullRender || !overlay.clone) {
@@ -347,13 +367,13 @@ function applyCloneSpreaderStyles(overlay, position, isSticky, stickyTop, sticky
 }
 function isScrollbarTarget(event) {
     if (_class_private_method_get(this, _isWindowScroll, isWindowScroll).call(this)) {
-        return event.target === _class_private_field_get(this, _overlays).domBindings.rootDocument.documentElement;
+        return event.target === _class_private_field_get(this, _deps).rootDocument.documentElement;
     }
-    return event.target === _class_private_field_get(this, _overlays).scrollableElement;
+    return event.target === _class_private_field_get(this, _deps).getScrollableElement();
 }
 function isWindowScroll() {
-    return _class_private_field_get(this, _overlays).scrollableElement === _class_private_field_get(this, _overlays).domBindings.rootWindow;
+    return _class_private_field_get(this, _deps).getScrollableElement() === _class_private_field_get(this, _deps).rootWindow;
 }
 function isRtl() {
-    return _class_private_field_get(this, _overlays).wtSettings.getSetting('rtlMode');
+    return _class_private_field_get(this, _deps).wtSettings.getSetting('rtlMode');
 }

package/3rdparty/walkontable/src/ports.d.mts

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

package/3rdparty/walkontable/src/ports.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Outward ports for the Walkontable rendering engine.
+ *
+ * These are thin, type-only interfaces that name the boundaries between the engine and the world
+ * outside it. They add no runtime code and change no call path: each port is a description of a
+ * surface the engine already uses, and the compiler enforces that the existing concrete type still
+ * satisfies it. That enforcement is the whole point — a port that no existing type has to satisfy
+ * would be speculative.
+ *
+ * - `SettingsPort` is enforced by `class Settings implements SettingsPort` (a WoT-owned class).
+ * - `HooksPort` is enforced by a type-level assertion against the shared `EventManager`. `EventManager`
+ *   lives in core and is used far beyond WoT, so it must not depend on a WoT type; the assertion below
+ *   checks conformance without editing it.
+ *
+ * A `CellRendererPort` is intentionally NOT defined here yet. The cell- and header-renderer boundary is
+ * currently a set of plain functions read through settings (`cellRenderer`, `rowHeaders`,
+ * `columnHeaders`) with no cohesive implementing type to attach a port to. Formalizing it would mean
+ * inventing an adapter with no existing implementor, which the ports here deliberately avoid. It is
+ * revisited when the render slice is reshaped.
+ */
+import type { default as EventManager } from '../../../eventManager';
+/**
+ * The settings-read surface the engine consumes. Mirrors the general signatures of `Settings` so the
+ * class satisfies the port; the specific per-key `getSetting` overloads stay on `Settings` itself and
+ * remain available to callers that use the concrete type.
+ */
+export interface SettingsPort {
+    getSetting<T = any>(key: string, param1?: any, param2?: unknown, param3?: unknown, param4?: unknown): T;
+    getSettingPure<T = any>(key: string): T;
+    has(key: string): boolean;
+    update(settings: string | Record<string, unknown>, value?: unknown): void;
+}
+/**
+ * The DOM-event-binding surface the engine uses to attach and tear down the listeners that back its
+ * hooks. Matches the methods the engine actually calls on its `EventManager`.
+ */
+export interface HooksPort {
+    addEventListener<E extends Event = Event>(element: Element | Document | Window, eventName: string, callback: (event: E) => void, options?: boolean | AddEventListenerOptions): () => void;
+    removeEventListener(element: Element | Document | Window, eventName: string, callback: (event: Event) => void, onlyOwnEvents?: boolean): void;
+    clearEvents(onlyOwnEvents?: boolean): void;
+    destroy(): void;
+    destroyWithOwnEventsOnly(): void;
+}
+/**
+ * Forces a compile error when its argument type is not exactly `true`.
+ */
+type Assert<Condition extends true> = Condition;
+/**
+ * Compile-time guarantee that the shared `EventManager` still satisfies `HooksPort`. Emits no
+ * JavaScript. If `EventManager`'s surface drifts away from the port, this alias resolves to
+ * `Assert<false>` and fails to compile.
+ */
+export type EventManagerSatisfiesHooksPort = Assert<EventManager extends HooksPort ? true : false>;
+export {};

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

@@ -0,0 +1,23 @@
+/**
+ * Outward ports for the Walkontable rendering engine.
+ *
+ * These are thin, type-only interfaces that name the boundaries between the engine and the world
+ * outside it. They add no runtime code and change no call path: each port is a description of a
+ * surface the engine already uses, and the compiler enforces that the existing concrete type still
+ * satisfies it. That enforcement is the whole point — a port that no existing type has to satisfy
+ * would be speculative.
+ *
+ * - `SettingsPort` is enforced by `class Settings implements SettingsPort` (a WoT-owned class).
+ * - `HooksPort` is enforced by a type-level assertion against the shared `EventManager`. `EventManager`
+ *   lives in core and is used far beyond WoT, so it must not depend on a WoT type; the assertion below
+ *   checks conformance without editing it.
+ *
+ * A `CellRendererPort` is intentionally NOT defined here yet. The cell- and header-renderer boundary is
+ * currently a set of plain functions read through settings (`cellRenderer`, `rowHeaders`,
+ * `columnHeaders`) with no cohesive implementing type to attach a port to. Formalizing it would mean
+ * inventing an adapter with no existing implementor, which the ports here deliberately avoid. It is
+ * revisited when the render slice is reshaped.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});

package/3rdparty/walkontable/src/ports.mjs

@@ -0,0 +1,24 @@
+/**
+ * Outward ports for the Walkontable rendering engine.
+ *
+ * These are thin, type-only interfaces that name the boundaries between the engine and the world
+ * outside it. They add no runtime code and change no call path: each port is a description of a
+ * surface the engine already uses, and the compiler enforces that the existing concrete type still
+ * satisfies it. That enforcement is the whole point — a port that no existing type has to satisfy
+ * would be speculative.
+ *
+ * - `SettingsPort` is enforced by `class Settings implements SettingsPort` (a WoT-owned class).
+ * - `HooksPort` is enforced by a type-level assertion against the shared `EventManager`. `EventManager`
+ *   lives in core and is used far beyond WoT, so it must not depend on a WoT type; the assertion below
+ *   checks conformance without editing it.
+ *
+ * A `CellRendererPort` is intentionally NOT defined here yet. The cell- and header-renderer boundary is
+ * currently a set of plain functions read through settings (`cellRenderer`, `rowHeaders`,
+ * `columnHeaders`) with no cohesive implementing type to attach a port to. Formalizing it would mean
+ * inventing an adapter with no existing implementor, which the ports here deliberately avoid. It is
+ * revisited when the render slice is reshaped.
+ */ /**
+ * Compile-time guarantee that the shared `EventManager` still satisfies `HooksPort`. Emits no
+ * JavaScript. If `EventManager`'s surface drifts away from the port, this alias resolves to
+ * `Assert<false>` and fails to compile.
+ */ export { };

package/3rdparty/walkontable/src/{renderer → render}/_base.d.ts

@@ -1,5 +1,5 @@
 import { NodesPool } from '../utils/nodesPool';
-import type { TableRenderer } from './table';
+import type { TableRenderer } from './tableRenderer';
 /**
  * Base renderer class, abstract logic for specialized renderers.
  *

package/3rdparty/walkontable/src/{renderer → render}/cells.js

@@ -62,7 +62,7 @@ class CellsRenderer extends _base.BaseRenderer {
                         ],
                         (0, _a11y.A11Y_TABINDEX)(-1),
                         // `aria-colindex` is incremented by both tbody and thead rows.
-                        (0, _a11y.A11Y_COLINDEX)(sourceColumnIndex + (this.table.rowUtils?.dataAccessObject?.rowHeaders?.length ?? 0) + 1)
+                        (0, _a11y.A11Y_COLINDEX)(sourceColumnIndex + (this.table.rowUtils?.deps?.getRowHeaders()?.length ?? 0) + 1)
                     ]);
                 }
             }

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

@@ -64,7 +64,7 @@ import { A11Y_COLINDEX, A11Y_GRIDCELL, A11Y_TABINDEX } from '../../../../helpers
                         ],
                         A11Y_TABINDEX(-1),
                         // `aria-colindex` is incremented by both tbody and thead rows.
-                        A11Y_COLINDEX(sourceColumnIndex + (this.table.rowUtils?.dataAccessObject?.rowHeaders?.length ?? 0) + 1)
+                        A11Y_COLINDEX(sourceColumnIndex + (this.table.rowUtils?.deps?.getRowHeaders()?.length ?? 0) + 1)
                     ]);
                 }
             }

package/3rdparty/walkontable/src/{renderer → render}/columnHeaders.d.ts

@@ -13,6 +13,7 @@ import { OrderView } from '../utils/orderView';
  * @class {ColumnHeadersRenderer}
  */
 export declare class ColumnHeadersRenderer extends BaseRenderer {
+    #private;
     /**
      * Cache for OrderView classes connected to specified node.
      *

package/3rdparty/walkontable/src/{renderer → render}/columnHeaders.js

@@ -12,6 +12,32 @@ const _element = require("../../../../helpers/dom/element");
 const _base = require("./_base");
 const _orderView = require("../utils/orderView");
 const _a11y = require("../../../../helpers/a11y");
+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_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 /**
+   * Stamps the `htLastVisibleHeader` class on the last TH of the header row that does not carry
+   * the `hiddenHeader` class (nested headers hide their colspan-continuation THs with it), and
+   * clears the class from every other TH. The theme CSS rounds the trailing header corner with
+   * this class. It replaces the former `th:not(.hiddenHeader):not(:has(~ th:not(.hiddenHeader)))`
+   * theme selector: any `:has()` rule in a stylesheet makes Chrome re-run host-page-scaled style
+   * invalidation on DOM mutations, so the state is stamped here, after the row's headers (and the
+   * header renderers that toggle `hiddenHeader`) have been rendered.
+   *
+   * @param {HTMLElement} TR The header row (TR element) to process.
+   */ _markLastVisibleHeader = /*#__PURE__*/ new WeakSet();
 class ColumnHeadersRenderer extends _base.BaseRenderer {
     /**
    * Obtains the instance of the OrderView class which is responsible for rendering the nodes to the root node.
@@ -69,15 +95,31 @@ class ColumnHeadersRenderer extends _base.BaseRenderer {
                 columnHeaderFunctions[visibleRowIndex](sourceColumnIndex, TH, visibleRowIndex);
             }
             orderView.end();
+            _class_private_method_get(this, _markLastVisibleHeader, markLastVisibleHeader).call(this, TR);
         }
     }
     /**
    * Creates a new ColumnHeadersRenderer instance.
    */ constructor(){
-        super('TH'), /**
+        super('TH'), _class_private_method_init(this, _markLastVisibleHeader), /**
    * Cache for OrderView classes connected to specified node.
    *
    * @type {WeakMap}
    */ this.orderViews = new WeakMap();
     }
 }
+function markLastVisibleHeader(TR) {
+    const { children } = TR;
+    let lastVisibleTH = null;
+    for(let index = children.length - 1; index >= 0; index--){
+        const TH = children[index];
+        if (lastVisibleTH === null && !(0, _element.hasClass)(TH, 'hiddenHeader')) {
+            lastVisibleTH = TH;
+            if (!(0, _element.hasClass)(TH, 'htLastVisibleHeader')) {
+                (0, _element.addClass)(TH, 'htLastVisibleHeader');
+            }
+        } else if ((0, _element.hasClass)(TH, 'htLastVisibleHeader')) {
+            (0, _element.removeClass)(TH, 'htLastVisibleHeader');
+        }
+    }
+}

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

@@ -1,7 +1,33 @@
-import { setAttribute, removeAttribute } from '../../../../helpers/dom/element.mjs';
+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_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 { addClass, hasClass, removeClass, setAttribute, removeAttribute } from '../../../../helpers/dom/element.mjs';
 import { BaseRenderer } from './_base.mjs';
 import { OrderView } from '../utils/orderView/index.mjs';
 import { A11Y_COLINDEX, A11Y_COLUMNHEADER, A11Y_GRIDCELL_BUTTON, A11Y_LABEL, A11Y_SCOPE_COL, A11Y_TABINDEX } from '../../../../helpers/a11y.mjs';
+var /**
+   * Stamps the `htLastVisibleHeader` class on the last TH of the header row that does not carry
+   * the `hiddenHeader` class (nested headers hide their colspan-continuation THs with it), and
+   * clears the class from every other TH. The theme CSS rounds the trailing header corner with
+   * this class. It replaces the former `th:not(.hiddenHeader):not(:has(~ th:not(.hiddenHeader)))`
+   * theme selector: any `:has()` rule in a stylesheet makes Chrome re-run host-page-scaled style
+   * invalidation on DOM mutations, so the state is stamped here, after the row's headers (and the
+   * header renderers that toggle `hiddenHeader`) have been rendered.
+   *
+   * @param {HTMLElement} TR The header row (TR element) to process.
+   */ _markLastVisibleHeader = /*#__PURE__*/ new WeakSet();
 /**
  * Column headers renderer responsible for managing (inserting, tracking, rendering) TH elements belongs to TR.
  *
@@ -70,15 +96,31 @@ import { A11Y_COLINDEX, A11Y_COLUMNHEADER, A11Y_GRIDCELL_BUTTON, A11Y_LABEL, A11
                 columnHeaderFunctions[visibleRowIndex](sourceColumnIndex, TH, visibleRowIndex);
             }
             orderView.end();
+            _class_private_method_get(this, _markLastVisibleHeader, markLastVisibleHeader).call(this, TR);
         }
     }
     /**
    * Creates a new ColumnHeadersRenderer instance.
    */ constructor(){
-        super('TH'), /**
+        super('TH'), _class_private_method_init(this, _markLastVisibleHeader), /**
    * Cache for OrderView classes connected to specified node.
    *
    * @type {WeakMap}
    */ this.orderViews = new WeakMap();
     }
 }
+function markLastVisibleHeader(TR) {
+    const { children } = TR;
+    let lastVisibleTH = null;
+    for(let index = children.length - 1; index >= 0; index--){
+        const TH = children[index];
+        if (lastVisibleTH === null && !hasClass(TH, 'hiddenHeader')) {
+            lastVisibleTH = TH;
+            if (!hasClass(TH, 'htLastVisibleHeader')) {
+                addClass(TH, 'htLastVisibleHeader');
+            }
+        } else if (hasClass(TH, 'htLastVisibleHeader')) {
+            removeClass(TH, 'htLastVisibleHeader');
+        }
+    }
+}

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

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

package/3rdparty/walkontable/src/{renderer → render}/index.d.ts

@@ -4,11 +4,11 @@ import { ColumnHeadersRenderer } from './columnHeaders';
 import { ColGroupRenderer } from './colGroup';
 import { RowsRenderer } from './rows';
 import { CellsRenderer } from './cells';
-import { TableRenderer } from './table';
+import { TableRenderer } from './tableRenderer';
 import type RowFilter from '../filter/row';
 import type ColumnFilter from '../filter/column';
-import type RowUtils from '../utils/row';
-import type ColumnUtils from '../utils/column';
+import type RowUtils from '../axisSizing/rowUtils';
+import type ColumnUtils from '../axisSizing/columnUtils';
 import type { StylesHandler } from '../types';
 interface RendererOptions {
     TABLE?: HTMLTableElement;
@@ -68,6 +68,14 @@ declare class Renderer {
      * @returns {Renderer}
      */
     setHeaderContentRenderers(rowHeaders: Function[], columnHeaders: Function[]): this;
+    /**
+     * Marks this draw as one where the column-header (THEAD) pass may be skipped when the column render
+     * window is unchanged (a pure vertical scroll).
+     *
+     * @param {boolean} skippable Whether the column-header pass may be skipped for this draw.
+     * @returns {Renderer}
+     */
+    setColumnHeadersRenderSkippable(skippable: boolean): this;
     /**
      * Renders the table.
      */

package/3rdparty/walkontable/src/{renderer → render}/index.js

@@ -31,7 +31,7 @@ _export(exports, {
         return _rows.RowsRenderer;
     },
     get TableRenderer () {
-        return _table.TableRenderer;
+        return _tableRenderer.TableRenderer;
     }
 });
 const _rowHeaders = require("./rowHeaders");
@@ -40,7 +40,7 @@ const _columnHeaders = require("./columnHeaders");
 const _colGroup = require("./colGroup");
 const _rows = require("./rows");
 const _cells = require("./cells");
-const _table = require("./table");
+const _tableRenderer = require("./tableRenderer");
 /**
  * Content renderer.
  *
@@ -87,6 +87,16 @@ const _table = require("./table");
         return this;
     }
     /**
+   * Marks this draw as one where the column-header (THEAD) pass may be skipped when the column render
+   * window is unchanged (a pure vertical scroll).
+   *
+   * @param {boolean} skippable Whether the column-header pass may be skipped for this draw.
+   * @returns {Renderer}
+   */ setColumnHeadersRenderSkippable(skippable) {
+        this.renderer.setColumnHeadersRenderSkippable(skippable);
+        return this;
+    }
+    /**
    * Renders the table.
    */ render() {
         this.renderer.render();
@@ -100,7 +110,7 @@ const _table = require("./table");
      * General renderer class used to render Walkontable content on screen.
      *
      * @type {TableRenderer}
-     */ this.renderer = new _table.TableRenderer(TABLE, {
+     */ this.renderer = new _tableRenderer.TableRenderer(TABLE, {
             cellRenderer,
             stylesHandler
         });

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

@@ -4,7 +4,7 @@ import { ColumnHeadersRenderer } from './columnHeaders.mjs';
 import { ColGroupRenderer } from './colGroup.mjs';
 import { RowsRenderer } from './rows.mjs';
 import { CellsRenderer } from './cells.mjs';
-import { TableRenderer } from './table.mjs';
+import { TableRenderer } from './tableRenderer.mjs';
 /**
  * Content renderer.
  *
@@ -51,6 +51,16 @@ import { TableRenderer } from './table.mjs';
         return this;
     }
     /**
+   * Marks this draw as one where the column-header (THEAD) pass may be skipped when the column render
+   * window is unchanged (a pure vertical scroll).
+   *
+   * @param {boolean} skippable Whether the column-header pass may be skipped for this draw.
+   * @returns {Renderer}
+   */ setColumnHeadersRenderSkippable(skippable) {
+        this.renderer.setColumnHeadersRenderSkippable(skippable);
+        return this;
+    }
+    /**
    * Renders the table.
    */ render() {
         this.renderer.render();

package/3rdparty/walkontable/src/{renderer → render}/rows.js

@@ -55,7 +55,7 @@ class RowsRenderer extends _base.BaseRenderer {
                 (0, _element.setAttribute)(TR, [
                     (0, _a11y.A11Y_ROW)(),
                     // `aria-rowindex` is incremented by both tbody and thead rows.
-                    (0, _a11y.A11Y_ROWINDEX)(sourceRowIndex + (this.table.rowUtils?.dataAccessObject?.columnHeaders?.length ?? 0) + 1)
+                    (0, _a11y.A11Y_ROWINDEX)(sourceRowIndex + (this.table.rowUtils?.deps?.getColumnHeaders()?.length ?? 0) + 1)
                 ]);
             }
             if ((sourceRowIndex + 1) % 2 === 0) {

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

@@ -56,7 +56,7 @@ let performanceWarningAppeared = false;
                 setAttribute(TR, [
                     A11Y_ROW(),
                     // `aria-rowindex` is incremented by both tbody and thead rows.
-                    A11Y_ROWINDEX(sourceRowIndex + (this.table.rowUtils?.dataAccessObject?.columnHeaders?.length ?? 0) + 1)
+                    A11Y_ROWINDEX(sourceRowIndex + (this.table.rowUtils?.deps?.getColumnHeaders()?.length ?? 0) + 1)
                 ]);
             }
             if ((sourceRowIndex + 1) % 2 === 0) {

package/3rdparty/walkontable/src/render/tableRenderer.d.mts

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

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

@@ -6,8 +6,8 @@ import type { RowsRenderer } from './rows';
 import type { CellsRenderer } from './cells';
 import type RowFilter from '../filter/row';
 import type ColumnFilter from '../filter/column';
-import type RowUtils from '../utils/row';
-import type ColumnUtils from '../utils/column';
+import type RowUtils from '../axisSizing/rowUtils';
+import type ColumnUtils from '../axisSizing/columnUtils';
 import type { StylesHandler } from '../types';
 /**
  * TableRenderer class collects all renderers and properties necessary for table creation. It's
@@ -54,6 +54,7 @@ import type { StylesHandler } from '../types';
  * @class {RowsRenderer}
  */
 export declare class TableRenderer {
+    #private;
     /**
      * Table element which will be used to render the children element.
      *
@@ -210,6 +211,15 @@ export declare class TableRenderer {
      * @param {number} columnsCount An amount of columns to render.
      */
     setViewportSize(rowsCount: number, columnsCount: number): void;
+    /**
+     * 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: boolean): void;
     /**
      * Sets row and column filter instances.
      *