handsontable 18.0.0 → 18.1.0-rc7

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

@@ -0,0 +1,360 @@
+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;
+}
+import { mixin, objectEach } from '../../../../helpers/object.mjs';
+import { FullyVisibleColumnsCalculationType, FullyVisibleRowsCalculationType, PartiallyVisibleColumnsCalculationType, PartiallyVisibleRowsCalculationType, RenderedAllColumnsCalculationType, RenderedAllRowsCalculationType, RenderedColumnsCalculationType, RenderedRowsCalculationType } from '../calculator/index.mjs';
+import { PositionCache } from '../axisSizing/positionCache/index.mjs';
+import { workspaceSize } from './workspaceSize.mjs';
+import { calculatorFactory } from './calculatorFactory.mjs';
+import { createLayoutDeps, gatherLayoutInput } from './boxLayout/gatherLayoutInput.mjs';
+import { resolveLayout } from './boxLayout/resolveLayout.mjs';
+/**
+ * Assembles the Viewport module's dependencies from the engine composition context.
+ *
+ * Everything the Viewport once received as separate constructor arguments (DOM bindings, settings,
+ * event manager, table) now flows through this one object. The `EventManager` is created once here
+ * (matching the previous per-module `this.eventManager`), and the table is resolved concretely
+ * because the Viewport is constructed after the master table exists.
+ *
+ * @param {EngineContext} ctx The engine composition context.
+ * @returns {object} The Viewport dependency set.
+ */ export function createViewportDeps(ctx) {
+    return {
+        wot: ctx.wot,
+        rootDocument: ctx.rootDocument,
+        rootWindow: ctx.rootWindow,
+        geometryReader: ctx.geometryReader,
+        rowSizeSource: ctx.rowSizeSource,
+        columnSizeSource: ctx.columnSizeSource,
+        layoutDeps: createLayoutDeps(ctx),
+        wtSettings: ctx.wtSettings,
+        eventManager: ctx.makeEventManager(),
+        wtTable: ctx.getWtTable(),
+        getTopOverlay: ctx.getTopOverlay,
+        getInlineStartOverlay: ctx.getInlineStartOverlay,
+        getBottomOverlay: ctx.getBottomOverlay
+    };
+}
+var /**
+   * The Viewport module dependencies.
+   *
+   * @type {ViewportDeps}
+   */ _deps = /*#__PURE__*/ new WeakMap(), /**
+   * The layout slice's dependency set — the input-gathering seam for the single-pass snapshot.
+   *
+   * @type {LayoutDeps}
+   */ _layoutDeps = /*#__PURE__*/ new WeakMap(), /**
+   * The layout snapshot resolved at the top of the current draw, or `null` between draws / after an
+   * invalidation. Computed by `beginDrawLayout()`; read through `getLayout()`.
+   *
+   * @type {LayoutSnapshot | null}
+   */ _layout = /*#__PURE__*/ new WeakMap(), /**
+   * The row that was the first rendered row when `rowHeightCache` was last built, or `-1` when
+   * nothing was rendered at that moment. The first rendered visible row carries a 1px border-top
+   * compensation in its reported height (see `StylesHandler#getDefaultRowHeight`), so the cache
+   * holds a value for this row that stops being correct once the viewport scrolls.
+   * {@link Viewport#sumRowHeights} re-reads it (and the current first rendered row) live.
+   *
+   * @type {number}
+   */ _rowFirstRenderedAtBuild = /*#__PURE__*/ new WeakMap();
+/**
+ * The Viewport owns the per-draw calculator objects and the size prefix-sum caches. Its
+ * workspace-size / scroll-detection queries and its calculator-creation logic are supplied by two
+ * mixins (`workspaceSize`, `calculatorFactory`); the method bodies live in their own files so the
+ * single-pass refactor can rework the workspace-size group in isolation. The mixin methods reach the
+ * private dependency set through the public `deps` getter.
+ *
+ * @class Viewport
+ */ class Viewport {
+    /**
+   * Read-only access to the dependencies, for the `workspaceSize` / `calculatorFactory` mixins, which
+   * are defined outside this class and so cannot reach the private `#deps`.
+   *
+   * @returns {ViewportDeps}
+   */ get deps() {
+        return _class_private_field_get(this, _deps);
+    }
+    /**
+   * Resolves the layout snapshot for the draw that is starting, stores it, and returns it. Called
+   * once per master draw, after the size caches are built and before the calculators run, so the
+   * snapshot reflects the geometry the draw will render into.
+   *
+   * On the single-pass gated path (element mode, uniform sizes) the calculators and the
+   * scroll-detection queries read this snapshot, so the scrollbars are predicted from content totals
+   * and the draw renders in one pass. Off that path (merged cells, window scroll, non-uniform sizes)
+   * the engine keeps measuring the rendered DOM; the snapshot is still resolved and its prediction
+   * stays in agreement with the live measurement (asserted in `viewport.spec.js`).
+   *
+   * @returns {LayoutSnapshot}
+   */ beginDrawLayout() {
+        _class_private_field_set(this, _layout, resolveLayout(gatherLayoutInput(_class_private_field_get(this, _layoutDeps))));
+        return _class_private_field_get(this, _layout);
+    }
+    /**
+   * Returns the current layout snapshot. Recomputes lazily when there is none (between draws, or after
+   * an invalidation) so API callers outside the draw get a fresh answer.
+   *
+   * @returns {LayoutSnapshot}
+   */ getLayout() {
+        if (_class_private_field_get(this, _layout) === null) {
+            _class_private_field_set(this, _layout, resolveLayout(gatherLayoutInput(_class_private_field_get(this, _layoutDeps))));
+        }
+        return _class_private_field_get(this, _layout);
+    }
+    /**
+   * Drops the cached layout snapshot so the next `getLayout()` recomputes it. Called whenever the
+   * geometry that feeds the snapshot may have changed (a resize or a size-cache invalidation).
+   */ invalidateLayout() {
+        _class_private_field_set(this, _layout, null);
+    }
+    /**
+   * Sums the heights of the `[from, to)` row range in O(1) using the row-height prefix-sum cache,
+   * with the exact semantics of a live per-row walk. Row heights are position-independent except
+   * for one row: the first rendered visible row reports a 1px border-top compensation
+   * (`StylesHandler#getDefaultRowHeight`, AutoRowSize). The cache holds the heights read at build
+   * time, so the row that carried the compensation then, and the row that carries it now, are
+   * re-read live and the cached values are replaced by the live ones.
+   *
+   * @param {number} from Start row index (inclusive).
+   * @param {number} to End row index (exclusive).
+   * @returns {number} The height sum in pixels.
+   */ sumRowHeights(from, to) {
+        const cache = this.rowHeightCache;
+        cache.ensureBuilt();
+        let sum = cache.getOffset(to) - cache.getOffset(from);
+        const compensationRows = new Set([
+            _class_private_field_get(this, _rowFirstRenderedAtBuild),
+            this.wtTable.getFirstRenderedRow()
+        ]);
+        compensationRows.forEach((row)=>{
+            if (row >= 0 && row >= from && row < to && row < cache.totalItems) {
+                const liveHeight = this.wtTable.getRowHeight(row);
+                const resolvedLiveHeight = liveHeight === undefined ? _class_private_field_get(this, _deps).rowSizeSource.getDefaultSize() : liveHeight;
+                sum += resolvedLiveHeight - cache.getSizeAt(row);
+            }
+        });
+        return sum;
+    }
+    /**
+   * Marks the row height position cache as stale. The cache will be rebuilt
+   * on the next viewport calculation.
+   */ invalidateRowHeightCache() {
+        this.rowHeightCache.invalidate();
+        this.invalidateLayout();
+    }
+    /**
+   * Drops every oversized-row record, not just the rendered band's, and marks the row-height cache
+   * stale so the next draw measures the rows again.
+   *
+   * `resetOversizedRows` deliberately wipes only the rendered band, because a record outside it is
+   * still the best height known for that row. That assumption breaks when the records were taken
+   * against a table with no layout: `getComputedStyle` returned nothing, so the default row height
+   * was unknown and every row was recorded oversized at a height it never had. Then the whole map
+   * has to go at once, or the rows outside the band keep inflating the scroll range for good.
+   */ resetAllOversizedRows() {
+        this.oversizedRows = {};
+        this.frozenOversizedRows.clear();
+        this.invalidateRowHeightCache();
+    }
+    /**
+   * Hands the frozen-derived row records back to the ordinary oversized-row machinery, keeping their
+   * heights but dropping their exemption from `resetOversizedRows`.
+   *
+   * Called on any draw that does NOT run the frozen-column row sync — the master's rendered band
+   * starts at column 0, so it renders every frozen column and can measure those rows itself. Without
+   * this the records would keep their exemption while nothing re-measured them, so they could only
+   * ever grow.
+   */ releaseFrozenOversizedRows() {
+        this.frozenOversizedRows.clear();
+    }
+    /**
+   * Marks the column width position cache as stale. The cache will be rebuilt
+   * on the next viewport calculation.
+   */ invalidateColumnWidthCache() {
+        this.columnWidthCache.invalidate();
+        this.invalidateLayout();
+    }
+    /**
+   * Marks both the row height and column width position caches as stale.
+   */ invalidateAllCaches() {
+        this.rowHeightCache.invalidate();
+        this.columnWidthCache.invalidate();
+        this.invalidateLayout();
+    }
+    /**
+   * Resets values in keys of the hasOversizedColumnHeadersMarked object after updateSettings.
+   */ resetHasOversizedColumnHeadersMarked() {
+        objectEach(this.hasOversizedColumnHeadersMarked, (value, key, object)=>{
+            object[key] = undefined;
+        });
+    }
+    /**
+   * @param {ViewportDeps} deps The Viewport module dependencies.
+   */ constructor(deps){
+        _class_private_field_init(this, _deps, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _layoutDeps, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _layout, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _rowFirstRenderedAtBuild, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_set(this, _layout, null);
+        /**
+   * Monotonic counter of cell-band renders, bumped by every `renderCellBand` call (see
+   * `table/drawCycle.ts`). Overlay clones share the master's Viewport instance, so a render by ANY
+   * table of this Walkontable — the master or any clone, nested inside a hook or not — advances it.
+   * The master's `skipRender` rollback compares it against the value read right before the
+   * `beforeDraw` hook fired to answer "did the hook render a DOM cell band?" — see
+   * `restoreRenderedStateIfSafe`.
+   *
+   * @type {number}
+   */ this.renderCycleSeq = 0;
+        _class_private_field_set(this, _rowFirstRenderedAtBuild, -1);
+        const { wtSettings, wtTable, rowSizeSource, columnSizeSource } = deps;
+        _class_private_field_set(this, _deps, deps);
+        _class_private_field_set(this, _layoutDeps, deps.layoutDeps);
+        // legacy support
+        this.wot = deps.wot;
+        this.wtSettings = wtSettings;
+        this.wtTable = wtTable;
+        this.oversizedRows = {};
+        this.frozenOversizedRows = new Set();
+        this.frozenClearRowCacheBuildSeq = 0;
+        this.hasOversizedColumnHeadersMarked = {};
+        this.clientHeight = 0;
+        this.rowHeaderWidth = NaN;
+        this.rowsVisibleCalculator = null;
+        this.columnsVisibleCalculator = null;
+        // Before the first render these must be `null` (the declared type), not `undefined` — the
+        // `skipRender` rollback captures/restores them and the overlays' `applyToDOM` null-checks them.
+        this.rowsRenderCalculator = null;
+        this.columnsRenderCalculator = null;
+        this.rowsCalculatorTypes = new Map([
+            [
+                'rendered',
+                ()=>this.wtSettings.getSetting('renderAllRows') ? new RenderedAllRowsCalculationType() : new RenderedRowsCalculationType()
+            ],
+            [
+                'fullyVisible',
+                ()=>new FullyVisibleRowsCalculationType()
+            ],
+            [
+                'partiallyVisible',
+                ()=>new PartiallyVisibleRowsCalculationType()
+            ]
+        ]);
+        this.columnsCalculatorTypes = new Map([
+            [
+                'rendered',
+                ()=>this.wtSettings.getSetting('renderAllColumns') ? new RenderedAllColumnsCalculationType() : new RenderedColumnsCalculationType()
+            ],
+            [
+                'fullyVisible',
+                ()=>new FullyVisibleColumnsCalculationType()
+            ],
+            [
+                'partiallyVisible',
+                ()=>new PartiallyVisibleColumnsCalculationType()
+            ]
+        ]);
+        /**
+     * Cumulative row height prefix sum cache. Enables O(log n) scroll-to-row lookups
+     * when custom row heights are configured.
+     *
+     * @type {PositionCache}
+     */ this.rowHeightCache = new PositionCache({
+            totalItemsFn: ()=>wtSettings.getSetting('totalRows'),
+            // The size must stay the MERGED value (`Math.max(provided, oversized)`), so it reads
+            // `wtTable.getRowHeight` — not `rowSizeSource.getSize`, which supplies only the provided half.
+            // This is the LOGICAL row height; the constant relating it to the pixel height the renderer
+            // writes lives in `getBoxAdjustedRowHeight` (axisSizing/boxModel.ts). Do not box-adjust it here —
+            // the calculators and `sumCellSizes` sum this value and expect the logical height.
+            sizeFn: (sourceRow)=>wtTable.getRowHeight(sourceRow) ?? NaN,
+            defaultSizeFn: ()=>rowSizeSource.getDefaultSize(),
+            // Uniform fast path: every row is the default height only when the source reports it (no per-row
+            // `rowHeights`/`minRowHeights`, no `modifyRowHeight` hook) AND walkontable has measured no
+            // oversized rows. Any of these invalidates the cache, so the next build re-evaluates this.
+            isUniformFn: ()=>rowSizeSource.isUniform() && Object.keys(this.oversizedRows).length === 0,
+            // Sparse fast path: when the provided heights are uniform but walkontable HAS measured
+            // oversized rows, those records are the only deviations from the default height — the cache
+            // stores just them and rebuilds in O(oversized rows) instead of walking all `totalRows`
+            // (a scroll into unmeasured territory rebuilds on every band change). With per-row heights
+            // or a `modifyRowHeight` hook this returns `null` and the full prefix-sum walk runs.
+            sparseExceptionsFn: ()=>rowSizeSource.isUniform() ? this.oversizedRows : null,
+            onBuildFn: ()=>{
+                _class_private_field_set(this, _rowFirstRenderedAtBuild, wtTable.getFirstRenderedRow());
+            }
+        });
+        /**
+     * Cumulative column width prefix sum cache. Enables O(log n) scroll-to-column lookups
+     * when custom column widths are configured.
+     *
+     * @type {PositionCache}
+     */ this.columnWidthCache = new PositionCache({
+            totalItemsFn: ()=>wtSettings.getSetting('totalColumns'),
+            sizeFn: (sourceCol)=>wtTable.getColumnWidth(sourceCol),
+            // Read the default through the size source (the `defaultColumnWidth` setting) — the same
+            // fallback the overlays' `sumCellSizes` used before they delegated to this cache — so a
+            // consumer-overridden default keeps scroll offsets and calculators in agreement.
+            defaultSizeFn: ()=>columnSizeSource.getDefaultSize(),
+            // Uniform fast path: every column is the default width only when the source reports it (no
+            // per-column `colWidths`, no `modifyColWidth` hook — note `autoColumnSize` is on by default and
+            // registers that hook, so this is true only when `colWidths` is set).
+            isUniformFn: ()=>columnSizeSource.isUniform()
+        });
+        this.eventManager = deps.eventManager;
+        this.eventManager.addEventListener(_class_private_field_get(this, _deps).rootWindow, 'resize', ()=>{
+            this.clientHeight = this.getWorkspaceHeight();
+            this.invalidateLayout();
+        });
+    }
+}
+mixin(Viewport, workspaceSize);
+mixin(Viewport, calculatorFactory);
+export default Viewport;

package/3rdparty/walkontable/src/viewport/workspaceSize.d.mts

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

package/3rdparty/walkontable/src/viewport/workspaceSize.d.ts

@@ -0,0 +1,59 @@
+/**
+ * The workspace-size and scroll-detection queries for `Viewport`, plus the mixin object that
+ * implements them.
+ *
+ * These methods answer "how big is the drawable area and will scrollbars appear" — the workspace and
+ * viewport dimensions, the row-header width / column-header height (with their lazy caches), the
+ * scrollbar-presence checks, and the window-scrollability checks. They are applied to `Viewport` with
+ * the same `mixin()` helper the range-query and sticky mixins use and reach the injected deps through
+ * the public `this.deps` getter (a mixin cannot see the class's `#deps` private field).
+ *
+ * On the single-pass gated path these read the per-draw `LayoutSnapshot` instead of forcing DOM
+ * layout; off that path they measure the DOM directly.
+ */
+import type { default as Viewport } from './viewport';
+/**
+ * Measures the workspace height off the live DOM (the trimming container, with the `#3119`
+ * zero-height→window fallback). Kept as a free function so the public `getWorkspaceHeight` can return
+ * the layout snapshot on the single-pass path while `gatherLayoutInput` (which BUILDS the snapshot)
+ * and the legacy measure path route here directly, avoiding recursion through `getLayout()`.
+ *
+ * @param {Viewport} viewport The viewport instance.
+ * @returns {number}
+ */
+export declare function measureWorkspaceHeight(viewport: Viewport): number;
+/**
+ * Measures the workspace width off the live DOM. Free-function twin of `measureWorkspaceHeight` (see
+ * its note on why the raw measure is split out from the public `getWorkspaceWidth`).
+ *
+ * @param {Viewport} viewport The viewport instance.
+ * @returns {number}
+ */
+export declare function measureWorkspaceWidth(viewport: Viewport): number;
+/**
+ * Workspace-size and scroll-detection queries, mixed into `Viewport`.
+ */
+export interface WorkspaceSize {
+    getWorkspaceHeight(): number;
+    getViewportHeight(): number;
+    getWorkspaceWidth(): number;
+    getViewportWidth(): number;
+    hasVerticalScroll(): boolean;
+    hasHorizontalScroll(): boolean;
+    isVerticallyScrollableByWindow(): boolean;
+    isHorizontallyScrollableByWindow(): boolean;
+    sumColumnWidths(from: number, length: number): number;
+    getWorkspaceOffset(): {
+        left: number;
+        top: number;
+    };
+    getColumnHeaderHeight(): number;
+    getRowHeaderWidth(): number;
+}
+/**
+ * The workspace-size mixin. Implements `WorkspaceSize` by measuring the trimming container and the
+ * rendered table through the geometry reader.
+ *
+ * @type {WorkspaceSize}
+ */
+export declare const workspaceSize: WorkspaceSize;