@svgrid/enterprise 3.1.4 → 3.1.6

package/dist/server/server-row-model.js

@@ -21,7 +21,7 @@
  * `createServerGroupModel` (the previous model, block-append with a "Load N
  * more" button) is still exported for anyone on it; this one supersedes it.
  */
-import { createBlockCache, createRowPlaceholder, rowPlaceholderState, toServerFilterColumns,
+import { createBlockCache, createRowPlaceholder, createWindowedData, isWindowedData, rowPlaceholderState, toServerFilterColumns,
 // The subpath, not the root: the root re-exports SvGrid.svelte, which
 // would land in every bundle and test that touches this model.
  } from '@svgrid/grid/server';
@@ -412,17 +412,80 @@ export function createServerRowModel(source, options) {
         leafRuns.set(store, run);
         return run;
     }
+    /**
+     * A level made only of data rows maps one to one: its i-th display row is
+     * its i-th child. Such a level is not walked or copied - the flatten records
+     * it as one lazy piece and `lazyLeafAt` builds a row when the grid reads it,
+     * so a 100M-row level costs the rows on screen, not 100M. Groups, tree
+     * data, pivot, load-more, detail rows and child-row paging still walk.
+     */
+    function isLazyLeafLevel(store) {
+        return (!treeData &&
+            !pivotMode &&
+            store.level >= groupBy.length &&
+            !store.loadMore &&
+            openDetails.size === 0 &&
+            !paging?.paginateChildRows);
+    }
+    // Replaced when a write settles (see `saving`): the grid writes a cell edit
+    // into the row object it was handed, so a row the server refused would keep
+    // showing the refused value while its child, which nothing changed, still
+    // matched the memo.
+    let lazyMemo = new WeakMap();
+    const LAZY_MEMO_CAP = 20000;
+    /** Row `index` of a lazy leaf level, built once per child object it holds. */
+    function lazyLeafAt(store, index) {
+        const child = store.cache.getRow(index);
+        const ph = rowPlaceholderState(child);
+        if (ph) {
+            const d = ph === 'failed' ? FAILED_ROW : LOADING_ROW;
+            return { child, d, g: toGridRow(d) };
+        }
+        let memo = lazyMemo.get(store);
+        if (!memo) {
+            memo = new Map();
+            lazyMemo.set(store, memo);
+        }
+        const hit = memo.get(index);
+        if (hit && hit.child === child)
+            return hit;
+        const leaf = child;
+        const d = { kind: 'leaf', id: leaf.id, level: store.level, route: store.route, data: leaf.data };
+        const entry = { child, d, g: toGridRow(d, leaf.data) };
+        memo.set(index, entry);
+        if (memo.size > LAZY_MEMO_CAP) {
+            let drop = LAZY_MEMO_CAP / 4;
+            for (const key of memo.keys()) {
+                if (drop-- <= 0)
+                    break;
+                memo.delete(key);
+            }
+        }
+        return entry;
+    }
     function flatten() {
-        let display = [];
-        let grid = [];
+        const pieces = [];
+        let total = 0;
+        let open = null;
         segments = [];
         const pushRow = (d, data) => {
-            display.push(d);
-            grid.push(toGridRow(d, data));
+            if (!open) {
+                open = { start: total, length: 0, display: [], grid: [] };
+                pieces.push(open);
+            }
+            open.display.push(d);
+            open.grid.push(toGridRow(d, data));
+            open.length += 1;
+            total += 1;
+        };
+        const pushPiece = (piece) => {
+            open = null;
+            pieces.push(piece);
+            total += piece.length;
         };
         if (grandTotalRow === 'top' && grandTotal)
             pushRow(grandTotalDisplay(grandTotal), grandTotal);
-        const bodyStart = display.length;
+        const bodyStart = total;
         /**
          * A `loadMore` level shows its loaded prefix and a "more" row; rows
          * past the first placeholder are not the grid's to scroll into.
@@ -434,32 +497,34 @@ export function createServerRowModel(source, options) {
             return n;
         };
         const walk = (store, from = 0, to = Number.POSITIVE_INFINITY) => {
+            if (isLazyLeafLevel(store)) {
+                // A pure leaf level: one lazy piece, nothing copied.
+                const end = Math.min(store.cache.windowedRows().length, to);
+                if (end > from) {
+                    segments.push({ store, displayStart: total, storeStart: from, length: end - from });
+                    pushPiece({ start: total, length: end - from, store, from });
+                }
+                return;
+            }
             const rows = store.cache.rows();
             const run = store.loadMore ? null : leafRun(store, rows);
             if (run) {
                 // A level of leaves maps one to one: copy the range out of the run.
                 const end = Math.min(rows.length, to);
                 if (end > from) {
-                    segments.push({ store, displayStart: display.length, storeStart: from, length: end - from });
-                    const { display: d, grid: g } = run;
-                    if (display.length === 0) {
-                        // The common flat case: the whole list is this run. A slice is a
-                        // block copy; a push per row was the rest of the flatten's cost.
-                        display = d.slice(from, end);
-                        grid = g.slice(from, end);
-                    }
-                    else {
-                        for (let i = from; i < end; i += 1) {
-                            display.push(d[i]);
-                            grid.push(g[i]);
-                        }
-                    }
+                    segments.push({ store, displayStart: total, storeStart: from, length: end - from });
+                    pushPiece({
+                        start: total,
+                        length: end - from,
+                        display: run.display.slice(from, end),
+                        grid: run.grid.slice(from, end),
+                    });
                 }
                 return;
             }
             const end = Math.min(rows.length, to, store.loadMore ? loadedPrefix(rows) : Number.POSITIVE_INFINITY);
             let segStart = from;
-            let dispStart = display.length;
+            let dispStart = total;
             const flushSegment = (upTo) => {
                 if (upTo > segStart) {
                     segments.push({ store, displayStart: dispStart, storeStart: segStart, length: upTo - segStart });
@@ -523,7 +588,7 @@ export function createServerRowModel(source, options) {
                         }, child.data);
                     }
                     segStart = i + 1;
-                    dispStart = display.length;
+                    dispStart = total;
                 }
             }
             flushSegment(end);
@@ -548,7 +613,7 @@ export function createServerRowModel(source, options) {
                 // A page of top-level rows. The root rows array is already sized to
                 // the count (placeholders for what has not loaded), so the page
                 // exists before its block does.
-                const count = root.cache.rowCount() ?? root.cache.rows().length;
+                const count = root.cache.rowCount() ?? root.cache.windowedRows().length;
                 pagerRowCount = count;
                 const start = Math.min(pageIndex * pageSize, Math.max(0, count - 1));
                 walk(root, start, start + pageSize);
@@ -557,7 +622,32 @@ export function createServerRowModel(source, options) {
                 walk(root);
             }
         }
+        /** Every piece as plain arrays. Lazy pieces read through `lazyLeafAt`. */
+        const materialize = () => {
+            if (pieces.length === 1 && pieces[0].display)
+                return { display: pieces[0].display, grid: pieces[0].grid };
+            const display = [];
+            const grid = [];
+            for (const p of pieces) {
+                if (p.display) {
+                    for (let i = 0; i < p.length; i += 1) {
+                        display.push(p.display[i]);
+                        grid.push(p.grid[i]);
+                    }
+                    continue;
+                }
+                for (let i = 0; i < p.length; i += 1) {
+                    const e = lazyLeafAt(p.store, p.from + i);
+                    display.push(e.d);
+                    grid.push(e.g);
+                }
+            }
+            return { display, grid };
+        };
         if (paging?.paginateChildRows) {
+            // Child-row paging cuts the flattened body, so it works on plain
+            // arrays; no level is lazy in this mode (see isLazyLeafLevel).
+            const { display, grid } = materialize();
             // A page of the flattened tree. Cut the body and re-base the segments
             // that cross into the page; the grand total stays on every page.
             const bodyLength = display.length - bodyStart;
@@ -582,10 +672,47 @@ export function createServerRowModel(source, options) {
                 });
             }
             segments = cut;
+            if (grandTotalRow === 'bottom' && grandTotal) {
+                const d = grandTotalDisplay(grandTotal);
+                display.push(d);
+                grid.push(toGridRow(d, grandTotal));
+            }
+            return { display, grid };
         }
         if (grandTotalRow === 'bottom' && grandTotal)
             pushRow(grandTotalDisplay(grandTotal), grandTotal);
-        return { display, grid };
+        if (!pieces.some((p) => p.store))
+            return materialize();
+        // At least one lazy piece: hand out windowed arrays that find the piece
+        // holding an index by binary search on the piece starts.
+        const pieceAt = (index) => {
+            let lo = 0;
+            let hi = pieces.length - 1;
+            while (lo <= hi) {
+                const mid = (lo + hi) >> 1;
+                const p = pieces[mid];
+                if (index < p.start)
+                    hi = mid - 1;
+                else if (index >= p.start + p.length)
+                    lo = mid + 1;
+                else
+                    return p;
+            }
+            return undefined;
+        };
+        const entryAt = (index) => {
+            const p = pieceAt(index);
+            if (!p)
+                return undefined;
+            const offset = index - p.start;
+            if (p.display)
+                return { d: p.display[offset], g: p.grid[offset] };
+            return lazyLeafAt(p.store, p.from + offset);
+        };
+        return {
+            display: createWindowedData(total, (i) => entryAt(i)?.d),
+            grid: createWindowedData(total, (i) => entryAt(i)?.g),
+        };
     }
     function pagination() {
         if (!paging)
@@ -679,8 +806,38 @@ export function createServerRowModel(source, options) {
     let held = false;
     function holdRows() {
         const ms = options.keepRowsWhileLoading ?? 0;
-        if (ms > 0 && current.displayRows.length > 0)
+        if (ms > 0 && current.displayRows.length > 0) {
             holdUntil = Date.now() + ms;
+            freezeCurrent();
+        }
+    }
+    /**
+     * Held rows must not change under the user, but a lazy list reads the live
+     * caches, which the sort or filter that started the hold is about to purge.
+     * Copy the rows around the last viewport into a snapshot and serve the held
+     * lists from it. Only the grid's subscription is told (so it re-reads);
+     * `onChange` still fires once, when the hold ends.
+     */
+    function freezeCurrent() {
+        if (!isWindowedData(current.gridRows))
+            return; // plain arrays are a snapshot already
+        const n = current.gridRows.length;
+        const MARGIN = 200;
+        const from = Math.max(0, lastViewport[0] - MARGIN);
+        const to = Math.min(n - 1, lastViewport[1] + MARGIN);
+        const display = new Map();
+        const grid = new Map();
+        for (let i = from; i <= to; i += 1) {
+            display.set(i, current.displayRows[i]);
+            grid.set(i, current.gridRows[i]);
+        }
+        current = {
+            ...current,
+            displayRows: createWindowedData(n, (i) => display.get(i) ?? LOADING_ROW),
+            gridRows: createWindowedData(n, (i) => grid.get(i) ?? toGridRow(LOADING_ROW)),
+        };
+        for (const notify of subscribers)
+            notify();
     }
     /** Whether the rows on screen should stay a little longer. */
     function holding() {
@@ -1012,7 +1169,7 @@ export function createServerRowModel(source, options) {
         }
         if (tx.add && tx.add.length) {
             const total = store.cache.rowCount();
-            const at = tx.addIndex ?? (total ?? store.cache.rows().length);
+            const at = tx.addIndex ?? (total ?? store.cache.windowedRows().length);
             const children = toChildren(route, at, tx.add);
             const placed = store.cache.insert(at, children);
             if (placed)
@@ -1090,6 +1247,9 @@ export function createServerRowModel(source, options) {
         }
         finally {
             writesInFlight -= 1;
+            // Rows are rebuilt from the cache on the next read, so an edit the
+            // server refused (and the model never applied) is gone from the grid.
+            lazyMemo = new WeakMap();
             scheduleEmit();
         }
     }
@@ -1358,6 +1518,10 @@ export function createServerRowModel(source, options) {
         expandAll(opts) {
             autoExpand = !!opts?.includeUnloaded;
             for (const store of [...stores.values()]) {
+                // A pure leaf level holds no groups to open; reading it would walk
+                // every row it has.
+                if (isLazyLeafLevel(store))
+                    continue;
                 for (const child of store.cache.rows()) {
                     if (rowPlaceholderState(child) || child.kind !== 'group')
                         continue;
@@ -1478,6 +1642,15 @@ export function createServerRowModel(source, options) {
         },
         setViewport(startIndex, endIndex) {
             lastViewport = [Math.max(0, startIndex), Math.max(startIndex, endIndex)];
+            // The first viewport starts the model. Its first load used to come from
+            // the grid reporting its starting sort on mount (setSort -> rebuild);
+            // the grid no longer reports a mount as a sort change, and a model that
+            // nothing else touched (no sort, no filter, a layout equal to the one
+            // it was built with) then never asked for a single block.
+            if (!disposed && !stores.has(routeKey([]))) {
+                rebuild();
+                return;
+            }
             applyViewport();
         },
         setPage(next) {