@svgrid/enterprise 3.1.3 → 3.1.5

package/dist/pivot-enable.js

@@ -17,7 +17,7 @@
  * ```
  */
 import { registerPivotEngine } from '@svgrid/grid';
-import { isLicenseKeySet } from './license.js';
+import { hasValidLicense } from './license.js';
 import { emitUnlicensedNudge } from './watermark.js';
 import { createPivotModel } from './pivot.js';
 let enabled = false;
@@ -34,6 +34,6 @@ export function enablePivot() {
         return;
     enabled = true;
     registerPivotEngine(pivotEngine);
-    if (!isLicenseKeySet())
+    if (!hasValidLicense())
         emitUnlicensedNudge();
 }

package/dist/scheduler.js

@@ -16,7 +16,7 @@
  * ```
  */
 import { registerSchedulerView } from '@svgrid/grid';
-import { isLicenseKeySet } from './license.js';
+import { hasValidLicense } from './license.js';
 import { emitUnlicensedNudge } from './watermark.js';
 import SvGridScheduler from './SvGridScheduler.svelte';
 let enabled = false;
@@ -30,7 +30,7 @@ export function enableSchedulerView() {
         return;
     enabled = true;
     registerSchedulerView(SvGridScheduler);
-    if (!isLicenseKeySet())
+    if (!hasValidLicense())
         emitUnlicensedNudge();
 }
 export { default as SvGridScheduler } from './SvGridScheduler.svelte';

package/dist/selection-bar.js

@@ -22,7 +22,7 @@
  * ```
  */
 import { registerSelectionBarView } from '@svgrid/grid';
-import { isLicenseKeySet } from './license.js';
+import { hasValidLicense } from './license.js';
 import { emitUnlicensedNudge } from './watermark.js';
 import SvGridSelectionBar from './SvGridSelectionBar.svelte';
 let enabled = false;
@@ -36,7 +36,7 @@ export function enableSelectionBar() {
         return;
     enabled = true;
     registerSelectionBarView(SvGridSelectionBar);
-    if (!isLicenseKeySet())
+    if (!hasValidLicense())
         emitUnlicensedNudge();
 }
 export { default as SvGridSelectionBar } from './SvGridSelectionBar.svelte';

package/dist/server/enable.js

@@ -19,7 +19,7 @@
  * const ctl = createServerRowModel(source, { groupBy: ['region'], onChange })
  * ```
  */
-import { isLicenseKeySet } from '../license.js';
+import { hasValidLicense } from '../license.js';
 import { emitUnlicensedNudge } from '../watermark.js';
 let enabled = false;
 /**
@@ -34,7 +34,7 @@ export function enableServerRowModel() {
     if (enabled)
         return;
     enabled = true;
-    if (!isLicenseKeySet())
+    if (!hasValidLicense())
         emitUnlicensedNudge();
 }
 /**

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) {

package/dist/sha256.d.ts

@@ -0,0 +1 @@
+export declare function sha256Hex(input: string): string;

package/dist/sha256.js

@@ -0,0 +1,69 @@
+// Synchronous SHA-256 for the license check. WebCrypto's digest() is async,
+// and setLicenseKey / checkLicenseKey are synchronous on purpose (they run at
+// module start-up and in the Node / MCP generator), so the key is hashed here.
+// FIPS 180-4, over the UTF-8 bytes of the input; returns lowercase hex.
+const K = new Uint32Array([
+    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+]);
+const rotr = (x, n) => (x >>> n) | (x << (32 - n));
+export function sha256Hex(input) {
+    const data = new TextEncoder().encode(input);
+    const bitLen = data.length * 8;
+    // Message + 0x80 + zero padding + 64-bit length, to a multiple of 64 bytes.
+    const total = Math.ceil((data.length + 9) / 64) * 64;
+    const buf = new Uint8Array(total);
+    buf.set(data);
+    buf[data.length] = 0x80;
+    const view = new DataView(buf.buffer);
+    view.setUint32(total - 8, Math.floor(bitLen / 0x100000000));
+    view.setUint32(total - 4, bitLen >>> 0);
+    const h = new Uint32Array([
+        0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,
+    ]);
+    const w = new Uint32Array(64);
+    for (let off = 0; off < total; off += 64) {
+        for (let i = 0; i < 16; i++)
+            w[i] = view.getUint32(off + i * 4);
+        for (let i = 16; i < 64; i++) {
+            const s0 = rotr(w[i - 15], 7) ^ rotr(w[i - 15], 18) ^ (w[i - 15] >>> 3);
+            const s1 = rotr(w[i - 2], 17) ^ rotr(w[i - 2], 19) ^ (w[i - 2] >>> 10);
+            w[i] = (w[i - 16] + s0 + w[i - 7] + s1) >>> 0;
+        }
+        let a = h[0], b = h[1], c = h[2], d = h[3], e = h[4], f = h[5], g = h[6], hh = h[7];
+        for (let i = 0; i < 64; i++) {
+            const S1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
+            const ch = (e & f) ^ (~e & g);
+            const t1 = (hh + S1 + ch + K[i] + w[i]) >>> 0;
+            const S0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22);
+            const maj = (a & b) ^ (a & c) ^ (b & c);
+            const t2 = (S0 + maj) >>> 0;
+            hh = g;
+            g = f;
+            f = e;
+            e = (d + t1) >>> 0;
+            d = c;
+            c = b;
+            b = a;
+            a = (t1 + t2) >>> 0;
+        }
+        h[0] = (h[0] + a) >>> 0;
+        h[1] = (h[1] + b) >>> 0;
+        h[2] = (h[2] + c) >>> 0;
+        h[3] = (h[3] + d) >>> 0;
+        h[4] = (h[4] + e) >>> 0;
+        h[5] = (h[5] + f) >>> 0;
+        h[6] = (h[6] + g) >>> 0;
+        h[7] = (h[7] + hh) >>> 0;
+    }
+    let out = '';
+    for (const word of h)
+        out += word.toString(16).padStart(8, '0');
+    return out;
+}