handsontable 18.0.0 → 18.1.0-rc7

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

@@ -0,0 +1,424 @@
+/**
+ * Post-render row / column-header measurement for `Table` and every subclass.
+ *
+ * These read the rendered DOM back after a draw to discover content-driven sizes that exceed the
+ * provided ones: `markOversizedRows` records rows taller than their configured height into
+ * `wtViewport.oversizedRows`, `adjustColumnHeaderHeights` applies the provided header heights to the
+ * THEAD rows, and `syncOversizedColumnHeadersWithFrozenOverlays` keeps the frozen-overlay headers
+ * pixel-aligned with the master. They are universal — every table type participates in the draw —
+ * so they are free functions over a `Table` instance (the same pattern as the draw-cycle phase
+ * helpers in `table/drawCycle.ts`), reading the table's public fields (`THEAD`/`TBODY`/`rowFilter`/
+ * `wtSettings`/`isMaster`) and the geometry-read port + the overlays/viewport owners via the `deps`
+ * getter. They belong to the `axisSizing` slice: together with `positionCache/` and
+ * `sizeGetters.ts` they own the "how tall is a row really" answer.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get adjustColumnHeaderHeights () {
+        return adjustColumnHeaderHeights;
+    },
+    get markOversizedRows () {
+        return markOversizedRows;
+    },
+    get resetFrozenOversizedRows () {
+        return resetFrozenOversizedRows;
+    },
+    get resetOversizedRows () {
+        return resetOversizedRows;
+    },
+    get shouldSyncOversizedRowsWithFrozenOverlays () {
+        return shouldSyncOversizedRowsWithFrozenOverlays;
+    },
+    get syncOversizedColumnHeadersWithFrozenOverlays () {
+        return syncOversizedColumnHeadersWithFrozenOverlays;
+    },
+    get syncOversizedRowsWithFrozenOverlays () {
+        return syncOversizedRowsWithFrozenOverlays;
+    }
+});
+const _element = require("../../../../helpers/dom/element");
+const _overlay = require("../overlay");
+const _boxModel = require("./boxModel");
+function adjustColumnHeaderHeights(table) {
+    const { wtSettings } = table;
+    const children = table.THEAD.childNodes;
+    const defaultRowHeight = wtSettings.getSetting('stylesHandler').getDefaultRowHeight();
+    const columnHeaders = wtSettings.getSetting('columnHeaders');
+    for(let i = 0, len = columnHeaders.length; i < len; i++){
+        const headerHeight = table.getColumnHeaderHeight(i);
+        if (headerHeight > defaultRowHeight) {
+            if (!children[i] || children[i].childNodes.length === 0) {
+                return;
+            }
+            const firstChild = children[i].childNodes[0];
+            if ((0, _element.isHTMLElement)(firstChild)) {
+                firstChild.style.height = `${headerHeight}px`;
+            }
+        }
+    }
+}
+function syncOversizedColumnHeadersWithFrozenOverlays(table) {
+    const wtOverlays = table.deps.getWtOverlays();
+    // Cheapest possible bail-out first: with no frozen columns the corner overlay is not cloned,
+    // so the overwhelmingly common (non-frozen) grids pay only a couple of property reads per draw.
+    const cornerClone = wtOverlays.topInlineStartCornerOverlay?.clone;
+    if (!cornerClone?.wtTable?.THEAD) {
+        return;
+    }
+    const columnHeaders = table.wtSettings.getSetting('columnHeaders');
+    if (!columnHeaders.length) {
+        return;
+    }
+    const cornerChildren = cornerClone.wtTable.THEAD.childNodes;
+    const topClone = wtOverlays.topOverlay?.clone;
+    const targetTheads = [
+        table.THEAD,
+        topClone?.wtTable?.THEAD
+    ];
+    // Sub-pixel tolerance to avoid rewriting heights on floating-point jitter while still
+    // catching the fractional gaps (e.g. ~0.33px at 75% zoom) that read as a 1px shift.
+    const epsilon = 0.1;
+    for(let i = 0, len = columnHeaders.length; i < len; i++){
+        const cornerChild = cornerChildren[i];
+        if (!(0, _element.isHTMLElement)(cornerChild)) {
+            continue;
+        }
+        const cornerRowHeight = table.deps.geometryReader.getBoundingClientRect(cornerChild).height;
+        targetTheads.forEach((thead)=>{
+            const targetRow = thead?.childNodes[i];
+            if (!(0, _element.isHTMLElement)(targetRow) || targetRow.childNodes.length === 0) {
+                return;
+            }
+            const firstChild = targetRow.childNodes[0];
+            if (!(0, _element.isHTMLElement)(firstChild)) {
+                return;
+            }
+            const targetRowHeight = table.deps.geometryReader.getBoundingClientRect(targetRow).height;
+            if (Math.abs(targetRowHeight - cornerRowHeight) > epsilon) {
+                firstChild.style.height = `${cornerRowHeight}px`;
+            }
+        });
+    }
+}
+/**
+ * Re-applies the effective row heights to one table's already-rendered rows.
+ *
+ * Mirrors the final pass of `TableRenderer#render` (`render/tableRenderer.ts`), which writes the same
+ * value onto the row's first cell while rendering. This is the out-of-render path, for a height that
+ * became known only after this table had rendered.
+ *
+ * @param {Table} table The table (master or clone) whose rendered rows are re-sized.
+ */ function applyRowHeightsToRenderedRows(table) {
+    const { TBODY, rowFilter } = table;
+    if (!TBODY || !rowFilter) {
+        return;
+    }
+    const borderBoxSizing = table.wtSettings.getSetting('stylesHandler').areCellsBorderBox();
+    const renderedRows = TBODY.childNodes;
+    for(let renderedRowIndex = 0; renderedRowIndex < renderedRows.length; renderedRowIndex++){
+        const firstChild = renderedRows[renderedRowIndex].firstChild;
+        if (!(0, _element.isHTMLElement)(firstChild)) {
+            continue;
+        }
+        const sourceRowIndex = rowFilter.renderedToSource(renderedRowIndex);
+        const rowHeight = table.rowUtils.getHeightByOverlayName(sourceRowIndex, table.name);
+        firstChild.style.height = rowHeight ? `${(0, _boxModel.getBoxAdjustedRowHeight)(rowHeight, borderBoxSizing)}px` : '';
+    }
+}
+function shouldSyncOversizedRowsWithFrozenOverlays(table) {
+    const { wtSettings } = table;
+    return !wtSettings.getSetting('externalRowCalculator') && !!wtSettings.getSetting('fixedColumnsStart') && table.getFirstRenderedColumn() > 0;
+}
+function syncOversizedRowsWithFrozenOverlays(table, wipedFrozenRows) {
+    const wtOverlays = table.deps.getWtOverlays();
+    // Cheapest question first — three settings reads — so a grid with no frozen columns never pays
+    // for the overlay lookups and the list build below.
+    const shouldSync = shouldSyncOversizedRowsWithFrozenOverlays(table);
+    // Only overlays that actually rendered their band in THIS draw may be measured. `Overlay#refresh`
+    // is a no-op when `needFullRender` is false, and a skipped clone still owns the DOM of whatever it
+    // rendered last — measuring that would record a previous draw's heights and mark them
+    // frozen-derived. The master's own pass has this guarantee structurally (`renderCellBand` measures
+    // only the table it just rendered); here it has to be asked for.
+    const frozenTables = shouldSync ? [
+        wtOverlays.inlineStartOverlay,
+        wtOverlays.topInlineStartCornerOverlay,
+        wtOverlays.bottomInlineStartCornerOverlay
+    ].filter((overlay)=>overlay?.needFullRender).map((overlay)=>overlay?.clone?.wtTable).filter((frozenTable)=>!!frozenTable?.TBODY) : [];
+    const settleWipedRows = ()=>{
+        // Rows nothing re-detected shrank back to their provided height.
+        if (wipedFrozenRows !== undefined && wipedFrozenRows.size > 0) {
+            table.deps.getWtViewport().invalidateRowHeightCache();
+            return true;
+        }
+        return false;
+    };
+    // Drops a row-height cache that was built while the frozen-derived records were cleared, i.e.
+    // missing every one of their heights. The bottom clone reaches this: it renders and measures
+    // inside `wtOverlays.refresh()`, so an invalidation of its own lands mid-window and the next
+    // read rebuilds from an `oversizedRows` the frozen rows are not in yet. Nothing else would ever
+    // correct it — the records come back unchanged, so no invalidation follows them — and the result
+    // is a scrollbar too short to reach the end of the grid with every rendered row still correct.
+    //
+    // Must run AFTER the records are back, so whatever rebuilds next sees them.
+    const dropStaleRowCacheBuild = ()=>{
+        const wtViewport = table.deps.getWtViewport();
+        if (wipedFrozenRows === undefined || wtViewport.rowHeightCache.buildSeq === wtViewport.frozenClearRowCacheBuildSeq) {
+            return false;
+        }
+        wtViewport.invalidateRowHeightCache();
+        return true;
+    };
+    if (!shouldSync || frozenTables.length === 0) {
+        // `settleWipedRows` first: it invalidates too, and both must be evaluated.
+        const settled = settleWipedRows();
+        if (dropStaleRowCacheBuild() || settled) {
+            // The heights changed after `wtOverlays.refresh()` sized the elements for this draw.
+            wtOverlays.adjustElementsSize();
+            return true;
+        }
+        return false;
+    }
+    // Exactly the rows these tables measured taller than what was already known — i.e. the heights
+    // that came from a frozen column. A row that is tall for a reason the master renders is NOT in
+    // here, and must not be: the frozen overlays could never re-detect it, so marking it
+    // frozen-derived would make the next draw read it as shrunk and drop it.
+    const recordedRows = new Set();
+    let heightsChanged = false;
+    frozenTables.forEach((frozenTable)=>{
+        // `deferShrinkDetection`: each table sees only its own slice of the band, so a record it cannot
+        // re-detect may simply belong to one of the others. `settleWipedRows` concludes once, below.
+        heightsChanged = markOversizedRows(frozenTable, wipedFrozenRows, {
+            deferShrinkDetection: true,
+            recordedRows
+        }) || heightsChanged;
+    });
+    const { frozenOversizedRows } = table.deps.getWtViewport();
+    recordedRows.forEach((sourceRow)=>frozenOversizedRows.add(sourceRow));
+    heightsChanged = settleWipedRows() || heightsChanged;
+    // The records are back, so a rebuild from here on is complete. Evaluated on its own line rather
+    // than folded into `heightsChanged`: a stale build needs the elements re-sized, but none of the
+    // per-row height re-writes that a genuine height change needs.
+    const hadStaleRowCacheBuild = dropStaleRowCacheBuild();
+    // The top and bottom clones render inside `wtOverlays.refresh()` — AFTER
+    // `resetFrozenOversizedRows` cleared the records — so they need the correction on every draw that
+    // has one. (With no frozen rows configured these clones carry no body rows, so this costs nothing
+    // on an ordinary frozen-columns grid.)
+    //
+    // In steady state the master is deliberately NOT here: it rendered BEFORE the clear, so it already
+    // has the right heights, and re-writing every row each draw would be a per-row DOM write for
+    // nothing.
+    // The frozen tables are here for the same reason: they rendered AFTER the clear, so at their
+    // natural height — which is not the recorded height for a row sitting at the band boundary, where
+    // the first <tr> adds 1px of border on top of its content. The master rendered before the clear,
+    // with the record, so it does not have that pixel; leaving the two as rendered puts them 1px apart
+    // and every row below with them, intermittently, as the boundary moves. Writing to them cannot
+    // ratchet — the next draw clears the records and re-renders them before measuring again.
+    const reapplyTargets = [
+        wtOverlays.topOverlay?.clone?.wtTable,
+        wtOverlays.bottomOverlay?.clone?.wtTable,
+        ...frozenTables
+    ];
+    if (heightsChanged) {
+        // A frozen height appeared or disappeared. Release the master first: one that just went away is
+        // still forced onto its rows. Then re-measure it — the row may STILL be tall for a reason the
+        // master renders, which its own pass earlier in this draw could not see because at that point it
+        // was measuring the frozen height. Without this the row collapses to the frozen overlays' short
+        // natural height while the master keeps its own tall content, i.e. the very misalignment this
+        // whole sync exists to prevent.
+        applyRowHeightsToRenderedRows(table);
+        const masterRecordedRows = new Set();
+        markOversizedRows(table, undefined, {
+            recordedRows: masterRecordedRows
+        });
+        // Whatever the master just recorded, it out-measured the frozen height — its own content is the
+        // taller one, so the record is the master's to own and hand back. Leaving it marked
+        // frozen-derived costs nothing visible and never settles: the next draw's
+        // `resetFrozenOversizedRows` clears a height only the master can recreate, the frozen pass
+        // re-records its own shorter one, the master out-measures it again, and both invalidate the
+        // row-height cache on every draw for as long as both cells stay oversized.
+        masterRecordedRows.forEach((sourceRow)=>frozenOversizedRows.delete(sourceRow));
+        // The master joins the re-apply only if that re-measure actually recorded something; otherwise
+        // the release above already left it at the right height, and a second full pass over its rows
+        // would write every one of them for nothing.
+        if (masterRecordedRows.size > 0) {
+            reapplyTargets.push(table);
+        }
+    }
+    if (recordedRows.size > 0 || heightsChanged) {
+        // The master joins on any draw that has a frozen record, not only a changed one. The record is
+        // whatever the frozen overlay just measured, and at the band boundary that is 1px more than the
+        // master rendered with — a difference the cache-invalidation tolerance deliberately ignores, so
+        // nothing else would bring the two together. Re-applying cannot ratchet: it writes the record,
+        // it does not measure.
+        if (!reapplyTargets.includes(table)) {
+            reapplyTargets.push(table);
+        }
+        reapplyTargets.forEach((target)=>{
+            if (target) {
+                applyRowHeightsToRenderedRows(target);
+            }
+        });
+    }
+    if (heightsChanged || hadStaleRowCacheBuild) {
+        // The summed row heights behind the scrollbar changed after `wtOverlays.refresh()` sized the
+        // elements for this draw, so that sizing is stale. Gated on a real change: `adjustElementsSize`
+        // walks every column (`sumCellSizes` must stay a live walk) and resizes three overlays.
+        wtOverlays.adjustElementsSize();
+        return true;
+    }
+    return false;
+}
+function resetOversizedRows(table) {
+    const { wtSettings } = table;
+    const wtViewport = table.deps.getWtViewport();
+    if (!table.isMaster && !table.is(_overlay.CLONE_BOTTOM)) {
+        return undefined;
+    }
+    if (wtSettings.getSetting('externalRowCalculator')) {
+        return undefined;
+    }
+    const rowsToRender = table.getRenderedRowsCount();
+    const wipedOversizedRows = new Map();
+    // Reset the oversized row cache for rendered rows
+    for(let visibleRowIndex = 0; visibleRowIndex < rowsToRender; visibleRowIndex++){
+        const sourceRow = table.rowFilter.renderedToSource(visibleRowIndex);
+        const previousHeight = wtViewport.oversizedRows?.[sourceRow];
+        // A frozen-derived record is exempt: this table does not render the column the height came from,
+        // so it could not put the record back, and the row-height cache and the viewport calculators are
+        // both built from this map before the frozen overlays have even rendered.
+        // `resetFrozenOversizedRows` clears these later in the draw instead.
+        if (previousHeight && !wtViewport.frozenOversizedRows.has(sourceRow)) {
+            wipedOversizedRows.set(sourceRow, previousHeight);
+            delete wtViewport.oversizedRows[sourceRow];
+        }
+    }
+    return wipedOversizedRows;
+}
+function resetFrozenOversizedRows(table) {
+    const wtViewport = table.deps.getWtViewport();
+    const { frozenOversizedRows } = wtViewport;
+    if (frozenOversizedRows.size === 0) {
+        return undefined;
+    }
+    // The window where `oversizedRows` is short of every frozen-derived height opens here. Anything
+    // that builds the row-height cache before the sync closes it gets a prefix sum missing them all.
+    wtViewport.frozenClearRowCacheBuildSeq = wtViewport.rowHeightCache.buildSeq;
+    const { wtSettings } = table;
+    const wipedRows = new Map();
+    const clear = (sourceRow)=>{
+        if (!frozenOversizedRows.has(sourceRow)) {
+            return;
+        }
+        const previousHeight = wtViewport.oversizedRows[sourceRow];
+        if (previousHeight !== undefined) {
+            wipedRows.set(sourceRow, previousHeight);
+        }
+        delete wtViewport.oversizedRows[sourceRow];
+        frozenOversizedRows.delete(sourceRow);
+    };
+    const rowsToRender = table.getRenderedRowsCount();
+    for(let renderedRowIndex = 0; renderedRowIndex < rowsToRender; renderedRowIndex++){
+        clear(table.rowFilter.renderedToSource(renderedRowIndex));
+    }
+    const totalRows = wtSettings.getSetting('totalRows');
+    const fixedRowsTop = wtSettings.getSetting('fixedRowsTop');
+    const fixedRowsBottom = wtSettings.getSetting('fixedRowsBottom');
+    for(let row = 0; row < fixedRowsTop; row++){
+        clear(row);
+    }
+    for(let row = Math.max(0, totalRows - fixedRowsBottom); row < totalRows; row++){
+        clear(row);
+    }
+    return wipedRows;
+}
+function markOversizedRows(table, wipedOversizedRows, { deferShrinkDetection = false, recordedRows } = {}) {
+    if (table.wtSettings.getSetting('externalRowCalculator')) {
+        return false;
+    }
+    let rowCount = table.TBODY.childNodes.length;
+    const stylesHandler = table.wtSettings.getSetting('stylesHandler');
+    const expectedTableHeight = rowCount * stylesHandler.getDefaultRowHeight();
+    const actualTableHeight = table.deps.geometryReader.innerHeight(table.TBODY) - 1;
+    const borderBoxSizing = stylesHandler.areCellsBorderBox();
+    const rowHeightFn = borderBoxSizing ? (element)=>table.deps.geometryReader.outerHeight(element) : (element)=>table.deps.geometryReader.innerHeight(element);
+    const borderCompensation = borderBoxSizing ? 0 : 1;
+    const firstRowBorderCompensation = borderBoxSizing ? 1 : 0;
+    let previousRowHeight;
+    let rowCurrentHeight;
+    let sourceRowIndex;
+    let currentTr;
+    let rowHeader;
+    if (expectedTableHeight === actualTableHeight && !table.wtSettings.getSetting('fixedRowsBottom')) {
+        // If the actual table height equals rowCount * default single row height, no row is oversized -> no need to iterate over them.
+        // Rows that WERE oversized before this render shrank back to the default height, so their
+        // cached heights are stale and the row-height cache must still be dropped.
+        if (!deferShrinkDetection && wipedOversizedRows !== undefined && wipedOversizedRows.size > 0) {
+            table.deps.getWtViewport().invalidateRowHeightCache();
+            return true;
+        }
+        return false;
+    }
+    const wtViewport = table.deps.getWtViewport();
+    let hasChanges = false;
+    while(rowCount){
+        rowCount -= 1;
+        sourceRowIndex = table.rowFilter.renderedToSource(rowCount);
+        previousRowHeight = table.getRowHeight(sourceRowIndex);
+        currentTr = table.getTrForRow(sourceRowIndex);
+        rowHeader = currentTr.querySelector('th');
+        // Use the rendered row index (rowCount === 0 is always the first <tr> in this tbody),
+        // not the source row index (which would be wrong for clones whose first rendered row
+        // has a different source index). Any tbody's first <tr> gets border-top: 1px from the
+        // tr:first-child CSS rule, so the compensation applies regardless of source identity.
+        const topBorderCompensation = rowCount === 0 ? firstRowBorderCompensation : 0;
+        if (rowHeader) {
+            rowCurrentHeight = rowHeightFn(rowHeader);
+        } else {
+            rowCurrentHeight = rowHeightFn(currentTr) - borderCompensation;
+        }
+        if (!previousRowHeight && stylesHandler.getDefaultRowHeight() < rowCurrentHeight - topBorderCompensation || previousRowHeight !== undefined && previousRowHeight < rowCurrentHeight) {
+            if (!borderBoxSizing) {
+                rowCurrentHeight += 1;
+            }
+            wtViewport.oversizedRows[sourceRowIndex] = rowCurrentHeight;
+            recordedRows?.add(sourceRowIndex);
+            const wipedHeight = wipedOversizedRows?.get(sourceRowIndex);
+            // Re-detecting the height that was already recorded before this render is not a change —
+            // the row-height cache still holds the correct value. A ±1px difference is the
+            // first-rendered-row border compensation flipping as the band boundary moves (the same
+            // row measures 1px taller while it is the band's first <tr>, see the `tr:first-child`
+            // compensation above); `Viewport#sumRowHeights` re-reads the boundary rows live for
+            // exactly this reason, so it is measurement noise, not a content change.
+            //
+            // This tolerance is load-bearing for PERFORMANCE and must not be tightened: at the boundary
+            // the measured value alternates between the two, so counting 1px as a change invalidates the
+            // row-height cache on every single draw for as long as the row sits there. The DOM side of the
+            // flip is handled separately, by re-applying the current record to every table below.
+            if (wipedHeight === undefined || Math.abs(rowCurrentHeight - wipedHeight) > 1) {
+                hasChanges = true;
+            }
+            wipedOversizedRows?.delete(sourceRowIndex);
+        }
+    }
+    // Any wiped record not re-detected above belongs to a row that shrank back to its provided
+    // height — a height change, even though no new record was written. Unless the caller deferred:
+    // then the leftovers may simply be rows this table does not render, and it settles them.
+    if (!deferShrinkDetection && wipedOversizedRows !== undefined && wipedOversizedRows.size > 0) {
+        hasChanges = true;
+    }
+    if (hasChanges) {
+        // Go through the Viewport method (not `rowHeightCache.invalidate()` directly) so the per-draw
+        // layout snapshot is dropped too — otherwise later snapshot readers in the same draw would use
+        // the pre-measurement scrollbar state after the content height changed.
+        wtViewport.invalidateRowHeightCache();
+    }
+    return hasChanges;
+}