handsontable 18.0.0 → 18.1.0-rc7

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

@@ -0,0 +1,99 @@
+/**
+ * The pure layout solver.
+ *
+ * `resolveLayout` turns a `LayoutInput` (plain numbers) into a frozen `LayoutSnapshot`. Its only real
+ * work is the two-variable scrollbar fix-point: a vertical scrollbar consumes width, which can make a
+ * horizontal one necessary, which consumes height, which can make the vertical one necessary. The
+ * solve is monotone — a scrollbar only ever shrinks the box, never grows it — so a single corrective
+ * pass after the first guess always converges. There is no loop and no DOM.
+ */ /**
+ * Decides the two scrollbars for a table that scrolls inside its own element.
+ *
+ * @param {LayoutInput} input The layout input.
+ * @returns {{ hasVerticalScroll: boolean, hasHorizontalScroll: boolean }}
+ */ function solveElementScrollbars(input) {
+    const { totalContentWidth: contentWidth, totalContentHeight: contentHeight, workspaceWidth, workspaceHeight, scrollbarSize } = input;
+    const forcedVertical = input.overflowY === 'scroll';
+    const forcedHorizontal = input.overflowX === 'scroll';
+    const suppressVertical = input.overflowY === 'hidden';
+    const suppressHorizontal = input.overflowX === 'hidden';
+    // First guess: does the content overflow the raw box on each axis?
+    let hasVerticalScroll = forcedVertical || !suppressVertical && contentHeight > workspaceHeight;
+    const hasHorizontalScroll = forcedHorizontal || !suppressHorizontal && contentWidth > workspaceWidth - (hasVerticalScroll ? scrollbarSize : 0);
+    // Corrective pass: a horizontal scrollbar we just decided on consumes height, which may now push
+    // the content past the vertical box. This can only turn the vertical scrollbar on, never off (the
+    // box only shrinks), so one pass is enough.
+    if (hasHorizontalScroll && !hasVerticalScroll && !suppressVertical) {
+        hasVerticalScroll = contentHeight > workspaceHeight - scrollbarSize;
+    }
+    return {
+        hasVerticalScroll,
+        hasHorizontalScroll
+    };
+}
+/**
+ * Decides the two scrollbars for a table that scrolls with the window. The scrollbars belong to the
+ * document, so the solver predicts the document's post-render scroll size by swapping the table's
+ * current hider extent for the extent it is about to take.
+ *
+ * @param {LayoutInput} input The layout input (must carry `windowContext`).
+ * @returns {{ hasVerticalScroll: boolean, hasHorizontalScroll: boolean }}
+ */ function solveWindowScrollbars(input) {
+    const context = input.windowContext;
+    if (!context) {
+        // No window metrics supplied — treat as no document scroll. This keeps the solver total; callers
+        // in window mode always supply the context.
+        return {
+            hasVerticalScroll: false,
+            hasHorizontalScroll: false
+        };
+    }
+    const predictedScrollHeight = context.documentScrollHeight - context.currentHiderHeight + input.totalContentHeight;
+    const predictedScrollWidth = context.documentScrollWidth - context.currentHiderWidth + input.totalContentWidth;
+    const hasVerticalScroll = input.overflowY === 'scroll' || input.overflowY !== 'hidden' && predictedScrollHeight > context.documentClientHeight;
+    const hasHorizontalScroll = input.overflowX === 'scroll' || input.overflowX !== 'hidden' && predictedScrollWidth > context.documentClientWidth;
+    return {
+        hasVerticalScroll,
+        hasHorizontalScroll
+    };
+}
+/**
+ * Resolves a layout input into an immutable snapshot. Pure: same input, same output, no side effects.
+ *
+ * @param {LayoutInput} input The layout input.
+ * @returns {LayoutSnapshot}
+ */ export function resolveLayout(input) {
+    const { hasVerticalScroll, hasHorizontalScroll } = input.scrollMode === 'window' ? solveWindowScrollbars(input) : solveElementScrollbars(input);
+    const { workspaceWidth, workspaceHeight, scrollbarSize } = input;
+    const innerWidth = workspaceWidth - (hasVerticalScroll ? scrollbarSize : 0);
+    const innerHeight = workspaceHeight - (hasHorizontalScroll ? scrollbarSize : 0);
+    // Render band = scrollbar-unaware (workspace − header, no scrollbar); visible band = scrollbar-aware
+    // (inner − header). The two differ by exactly one scrollbar on the axis the opposite scrollbar eats.
+    const renderViewportWidth = workspaceWidth - input.rowHeaderWidth;
+    const renderViewportHeight = workspaceHeight - input.columnHeaderHeight;
+    const visibleViewportWidth = innerWidth - input.rowHeaderWidth;
+    const visibleViewportHeight = innerHeight - input.columnHeaderHeight;
+    return Object.freeze({
+        scrollMode: input.scrollMode,
+        hasVerticalScroll,
+        hasHorizontalScroll,
+        workspaceWidth,
+        workspaceHeight,
+        innerWidth,
+        innerHeight,
+        viewportWidth: visibleViewportWidth,
+        viewportHeight: visibleViewportHeight,
+        renderViewportWidth,
+        renderViewportHeight,
+        visibleViewportWidth,
+        visibleViewportHeight,
+        rowHeaderWidth: input.rowHeaderWidth,
+        columnHeaderHeight: input.columnHeaderHeight,
+        totalContentWidth: input.totalContentWidth,
+        totalContentHeight: input.totalContentHeight,
+        hiderWidth: input.totalContentWidth,
+        hiderHeight: input.totalContentHeight,
+        scrollbarSize,
+        isRtl: input.isRtl
+    });
+}

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

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

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

@@ -0,0 +1,84 @@
+/**
+ * The viewport calculator-creation queries for `Viewport`, plus the mixin object that implements them.
+ *
+ * These methods build the row/column render, fully-visible, and partially-visible calculators and
+ * decide (on a fast draw) whether the proposed visible range is already inside the rendered band.
+ * They were extracted verbatim from `Viewport` and applied with the same `mixin()` helper the
+ * range-query and sticky mixins use, so the public surface and behavior are unchanged; only the
+ * private `#deps` access became the public `this.deps` getter.
+ *
+ * The calculator RESULT fields (`rowsRenderCalculator`, `rowsVisibleCalculator`, …) stay owned by
+ * `Viewport`; `createCalculators` / `createVisibleCalculators` assign them through `this`.
+ */
+import type { ColumnsCalculationType, RowsCalculationType } from '../calculator/viewportBase';
+import { ViewportColumnsCalculator, ViewportRowsCalculator } from '../calculator';
+/**
+ * Which viewport box a calculator reads from the layout snapshot. `'render'` is scrollbar-unaware
+ * (covers the strip a scrollbar sits over, so `getCell` on that row/column returns a real TD);
+ * `'visible'` is scrollbar-aware (drives the fully/partially-visible counts and scroll-to-cell).
+ */
+export type ViewportBand = 'render' | 'visible';
+/**
+ * Calculator-creation queries, mixed into `Viewport`.
+ */
+export interface CalculatorFactory {
+    createRowsCalculator(calculatorTypes?: string[], band?: ViewportBand): ViewportRowsCalculator;
+    createColumnsCalculator(calculatorTypes?: string[], band?: ViewportBand): ViewportColumnsCalculator;
+    createCalculators(fastDraw?: boolean, options?: {
+        stationaryBands?: boolean;
+    }): boolean;
+    createVisibleCalculators(): void;
+    usesLayoutSnapshotForCalculators(): boolean;
+    allowsStationaryBands(): boolean;
+    applyRenderedColumnsBandOverscan(renderedColumns: ColumnsCalculationType | null): void;
+    applyRenderedRowsBandOverscan(renderedRows: RowsCalculationType | null): void;
+    stabilizeRenderedRowsBand(renderedRows: RowsCalculationType | null): void;
+    stabilizeRenderedColumnsBand(renderedColumns: ColumnsCalculationType | null): void;
+    areAllProposedVisibleRowsAlreadyRendered(proposedFullyVisibleRowsCalculator: RowsCalculationType | undefined, proposedPartiallyVisibleRowsCalculator: RowsCalculationType | undefined): boolean;
+    areAllProposedVisibleColumnsAlreadyRendered(proposedFullyVisibleColumnsCalculator: ColumnsCalculationType | undefined, proposedPartiallyVisibleColumnsCalculator: ColumnsCalculationType | undefined): boolean;
+}
+/**
+ * Decides the directional overscan for a freshly computed render band: which side of the band to
+ * extend (toward the scroll direction) and by how many tracks. Shared by the row and column overscan
+ * appliers — the axis methods map their field names onto this axis-agnostic arithmetic, so the
+ * direction rules stay single-sourced.
+ *
+ * Direction: the sign of the scroll-offset delta between this draw and the previous full draw.
+ * A zero delta means the OTHER axis scrolled; an existing overscan side is then preserved (so the
+ * band comes out identical), where "existing" is proven by a recorded side offset greater than 1 —
+ * the 'auto' offset override adds at most 1 per side, and clamps to 0 at the dataset edges, so
+ * offset inequality alone cannot be the test. A band that was never overscanned gets none.
+ *
+ * Exported for direct unit coverage; the production callers are the two band-overscan appliers
+ * in this module.
+ *
+ * @param {number} scrollOffsetDelta The current band's scroll offset minus the previous band's.
+ * @param {object} previous The previous band's recorded side offsets.
+ * @param {number} previous.startOffset The previous band's start-side offset.
+ * @param {number} previous.endOffset The previous band's end-side offset.
+ * @param {object} fresh The freshly computed band's geometry.
+ * @param {number} fresh.start The band's first track index.
+ * @param {number} fresh.end The band's last track index.
+ * @param {number} fresh.count The band's track count.
+ * @param {number} total The axis total track count.
+ * @param {number} max The axis overscan cap.
+ * @returns {{ side: -1 | 1, extension: number } | null} The side to extend (`-1` = start, `1` =
+ * end) and the clamped track count, or `null` when no overscan applies.
+ */
+export declare function directionalBandOverscan(scrollOffsetDelta: number, previous: {
+    startOffset: number;
+    endOffset: number;
+}, fresh: {
+    start: number;
+    end: number;
+    count: number;
+}, total: number, max: number): {
+    side: -1 | 1;
+    extension: number;
+} | null;
+/**
+ * The calculator-factory mixin. Implements `CalculatorFactory`.
+ *
+ * @type {CalculatorFactory}
+ */
+export declare const calculatorFactory: CalculatorFactory;