@svgrid/grid 3.0.5 → 3.0.6

package/dist/core.js

@@ -165,6 +165,19 @@ export const filterFns = {
 const ROW_CTX = Symbol('svgrid.row.ctx');
 const ROW_VALUES = Symbol('svgrid.row.values');
 const ROW_CELLS = Symbol('svgrid.row.cells');
+// Where the filtered stage last put this row: the generation of that full
+// filter and the row's index in its output. Lets a tick swap a replaced row
+// into place without re-filtering everything (see createFilteredRowModel).
+const ROW_FILTER_GEN = Symbol('svgrid.row.filterGen');
+const ROW_FILTER_POS = Symbol('svgrid.row.filterPos');
+// Stamped on the rows a sort repair drops, so the merge skips them with one
+// property read per row instead of a Set lookup (3 ms per 100k rows).
+const ROW_SORT_DROPPED = Symbol('svgrid.row.sortDropped');
+// The key(s) the last full sort computed for a row: the key itself for a
+// one-clause sort, an array for several. Read by the repair path so a tick
+// never recomputes a kept row's key.
+const ROW_SORT_KEY = Symbol('svgrid.row.sortKey');
+let sortDropGeneration = 0;
 /**
  * The methods every base row carries, defined ONCE and assigned by reference.
  *
@@ -276,17 +289,32 @@ export function createCoreRowModel() {
  * `columnFilteringFeature`; without it there are no filters to apply.
  */
 export function createFilteredRowModel() {
+    /**
+     * The last full filter, so a tick can repair it. When `getRowModel`
+     * reports which rows were replaced (`replacedRowsOf`) and the filter state
+     * and columns are the same objects as last time, each replacement is tested
+     * on its own: a row that stays in keeps its slot, a row that stays out
+     * stays out, and a row whose membership flips sends the whole thing back
+     * through the full pass, because an insertion has to land in data order.
+     * Positions come from stamps on the rows (ROW_FILTER_GEN / ROW_FILTER_POS)
+     * written by the full pass; no map is built.
+     */
+    let cache = null;
+    let generation = 0;
     return ({ table, rows }) => {
         const filters = table.getState().columnFilters ?? [];
-        if (!filters.length)
+        if (!filters.length) {
+            cache = null;
             return rows;
+        }
+        const columns = table.getAllColumns();
         // Resolve each filter's match function once, outside the row loop.
         const compiled = filters.map((filter) => ({
             id: filter.id,
             value: filter.value,
             fn: filter.fn ? filterFns[filter.fn] : filterFns.includesString,
         }));
-        return rows.filter((row) => {
+        const passes = (row) => {
             for (let i = 0; i < compiled.length; i++) {
                 const filter = compiled[i];
                 // `getCellValueByColumnId` rather than `getAllCells().find(...)`.
@@ -299,7 +327,56 @@ export function createFilteredRowModel() {
                     return false;
             }
             return true;
-        });
+        };
+        if (cache && cache.filters === filters && cache.columns === columns) {
+            if (cache.input === rows)
+                return cache.output;
+            const replaced = replacedRowsOf(table);
+            if (replaced && rows.length === cache.input.length) {
+                let out = null;
+                let ok = true;
+                for (let i = 0; i < rows.length && ok; i++) {
+                    const prev = cache.input[i];
+                    const next = rows[i];
+                    if (next === prev)
+                        continue;
+                    if (replaced.get(prev) !== next) {
+                        ok = false;
+                        break;
+                    }
+                    const wasIn = prev[ROW_FILTER_GEN] === cache.gen;
+                    const isIn = passes(next);
+                    if (wasIn !== isIn) {
+                        ok = false;
+                        break;
+                    }
+                    if (!isIn)
+                        continue;
+                    out ?? (out = cache.output.slice());
+                    const pos = prev[ROW_FILTER_POS];
+                    out[pos] = next;
+                    next[ROW_FILTER_GEN] = cache.gen;
+                    next[ROW_FILTER_POS] = pos;
+                }
+                if (ok) {
+                    const output = out ?? cache.output;
+                    cache = { ...cache, input: rows, output };
+                    return output;
+                }
+            }
+        }
+        const gen = ++generation;
+        const output = [];
+        for (let i = 0; i < rows.length; i++) {
+            const row = rows[i];
+            if (!passes(row))
+                continue;
+            row[ROW_FILTER_GEN] = gen;
+            row[ROW_FILTER_POS] = output.length;
+            output.push(row);
+        }
+        cache = { input: rows, output, filters, columns, gen };
+        return output;
     };
 }
 /**
@@ -542,6 +619,19 @@ export function flattenTreeData(data, options) {
 export function createExpandedRowModel() {
     return ({ table, rows }) => {
         const expanded = table.getState().expanded ?? {};
+        // Nothing expanded means every collapsed row hides its children and the
+        // output is the input, element for element. Returning it as is keeps the
+        // array identity the stages downstream and the render window key on, and
+        // skips a 100k-element copy per data change on a flat grid.
+        let anyExpanded = false;
+        for (const id in expanded) {
+            if (expanded[id]) {
+                anyExpanded = true;
+                break;
+            }
+        }
+        if (!anyExpanded)
+            return rows;
         const flattened = [];
         const visit = (row) => {
             flattened.push(row);
@@ -560,11 +650,58 @@ export function createExpandedRowModel() {
  * override the built-in {@link sortFns} - useful for locale-aware or
  * domain-specific ordering.
  */
+/**
+ * Which rows the last `getRowModel` rebuild replaced, old row -> new row, for
+ * the duration of the pipeline run that follows it.
+ *
+ * A live feed replaces a few hundred row objects in a hundred-thousand-row
+ * array and hands the grid the new array. The base rows are rebuilt reusing
+ * every row whose data object is the same (see `getRowModel`), so the rebuild
+ * knows exactly which rows are new. The filtered and sorted stages read that
+ * here and repair their previous output instead of recomputing it, when the
+ * replacements are few and nothing else changed. Cleared after the run; a
+ * stage that reads it outside a run sees null and does the full work.
+ *
+ * Keyed on the grid object in a WeakMap rather than carried on the public
+ * `SvGrid` type, so the stage signature stays `({ table, rows }) => rows`.
+ */
+const replacedRowsByGrid = new WeakMap();
+/** The rows `getRowModel` replaced in the rebuild this pipeline run follows, or null. */
+export function replacedRowsOf(table) {
+    return replacedRowsByGrid.get(table) ?? null;
+}
+/**
+ * The sorting stage of the row pipeline: orders the rows by the grid's
+ * `sorting` state with the built-in comparators (or the `localSortFns` map
+ * handed in), stable, equal keys keeping their data order. A tick that
+ * replaces a few rows out of many is repaired incrementally rather than
+ * re-sorted (see the note inside). Registered by `rowSortingFeature`; an app
+ * only calls this to install its own comparator set.
+ */
 export function createSortedRowModel(localSortFns = sortFns) {
-    return function sortedRowModelStage({ table, rows }) {
-        const sorting = table.getState().sorting ?? [];
-        if (!sorting.length)
-            return rows;
+    /**
+     * What the last full sort produced, kept so a tick can repair it.
+     *
+     * A live feed replaces a few hundred row objects out of a hundred thousand
+     * and hands the grid a new array. Re-sorting all of it costs the same as
+     * the first sort did (115-149 ms in the browser for 100k rows, see
+     * docs/help/benchmarks.md); the order it would produce differs from the
+     * previous one only where the replaced rows land. So the previous output
+     * is kept, with its sort keys aligned to it, and when `getRowModel` says
+     * which rows were replaced (see `replacedRowsOf`) the stage drops those,
+     * sorts the replacements among themselves and merges them back in one
+     * linear pass: O(n + k log k) instead of O(n log n) key builds and
+     * comparisons.
+     *
+     * The repair is only attempted when everything else is the same object as
+     * last time - the sorting state, the columns, and every input row except
+     * the replaced ones - and it produces exactly what the full sort would:
+     * equal keys fall back to the data index, which is the order a stable sort
+     * over data-ordered input keeps.
+     */
+    let cache = null;
+    const MISSING_KEY = Symbol('svgrid.sort.missing-key');
+    function fullSort(rows, sorting, allColumns) {
         // Resolve every clause ONCE, before sorting.
         //
         // This used to live inside the comparator, so `getAllColumns().find(...)`
@@ -572,7 +709,6 @@ export function createSortedRowModel(localSortFns = sortFns) {
         // 1,528,947 array scans, and a three-clause sort made 3,933,751 (measured;
         // `pnpm bench --case=sort-1col`). The comparator is called O(n log n)
         // times, so anything inside it that is not O(1) sets the cost of the sort.
-        const allColumns = table.getAllColumns();
         const clauses = [];
         for (const clause of sorting) {
             const column = allColumns.find((col) => col.id === clause.id);
@@ -599,15 +735,17 @@ export function createSortedRowModel(localSortFns = sortFns) {
             const n = rows.length;
             let keys = new Array(n);
             let compare;
+            let keyOf;
             if (comparator === sortFns.number) {
+                keyOf = (row) => Number(row.getCellValueByColumnId(columnId) ?? 0);
                 for (let i = 0; i < n; i++)
-                    keys[i] = Number(rows[i].getCellValueByColumnId(columnId) ?? 0);
+                    keys[i] = keyOf(rows[i]);
                 compare = compareNumericKeys;
             }
             else if (comparator === sortFns.date) {
-                for (let i = 0; i < n; i++) {
-                    keys[i] = new Date(rows[i].getCellValueByColumnId(columnId)).getTime();
-                }
+                keyOf = (row) => new Date(row.getCellValueByColumnId(columnId)).getTime();
+                for (let i = 0; i < n; i++)
+                    keys[i] = keyOf(rows[i]);
                 compare = compareNumericKeys;
             }
             else if (comparator === sortFns.auto) {
@@ -669,21 +807,26 @@ export function createSortedRowModel(localSortFns = sortFns) {
                     for (let i = 0; i < n; i++)
                         keys[i] = rankOf.get(strings[i]);
                     compare = compareNumericKeys;
+                    // A replacement whose text is not among the ranked values has no
+                    // rank; the repair path treats that as "sort everything again".
+                    keyOf = (row) => rankOf.get(String(row.getCellValueByColumnId(columnId))) ?? MISSING_KEY;
                 }
                 else {
                     keys = strings;
                     compare = compareCollatedKeys;
+                    keyOf = (row) => String(row.getCellValueByColumnId(columnId));
                 }
             }
             else {
+                keyOf = (row) => row.getCellValueByColumnId(columnId);
                 for (let i = 0; i < n; i++)
-                    keys[i] = rows[i].getCellValueByColumnId(columnId);
+                    keys[i] = keyOf(rows[i]);
                 compare = comparator;
             }
-            clauses.push({ keys, desc: clause.desc, compare });
+            clauses.push({ keys, desc: clause.desc, compare, keyOf });
         }
         if (!clauses.length)
-            return rows;
+            return null;
         // Sort an index array, then materialise. `Array.prototype.sort` is stable,
         // so equal keys keep their original relative order exactly as the previous
         // `[...rows].sort(...)` did.
@@ -730,7 +873,167 @@ export function createSortedRowModel(localSortFns = sortFns) {
         const sorted = new Array(rows.length);
         for (let i = 0; i < order.length; i++)
             sorted[i] = rows[order[i]];
-        return sorted;
+        // Each row keeps its key(s), so a later tick can place a replacement
+        // among the kept rows without reading any of them again. One property
+        // write per row; an array per row only when there are several clauses.
+        if (clauses.length === 1) {
+            const keys = clauses[0].keys;
+            for (let i = 0; i < rows.length; i++)
+                rows[i][ROW_SORT_KEY] = keys[i];
+        }
+        else {
+            for (let i = 0; i < rows.length; i++) {
+                const per = new Array(clauses.length);
+                for (let k = 0; k < clauses.length; k++)
+                    per[k] = clauses[k].keys[i];
+                rows[i][ROW_SORT_KEY] = per;
+            }
+        }
+        return { sorted, clauses: clauses.map(({ desc, compare, keyOf }) => ({ desc, compare, keyOf })) };
+    }
+    /**
+     * The previous output with the replaced rows swapped for their
+     * replacements, in sorted position. Null when the input is not the cached
+     * input plus replacements, or a replacement has no incremental key.
+     *
+     * Every row carries the key(s) the last full sort computed for it
+     * (ROW_SORT_KEY: the key itself for one clause, an array for several), so
+     * the merge moves row references and nothing else. At 100k rows the loop
+     * that also copied an aligned key array cost 3.7 ms; this one is the
+     * reference copy alone.
+     */
+    function repair(rows, replaced) {
+        const c = cache;
+        if (rows.length !== c.input.length)
+            return null;
+        // Which rows of THIS stage's input changed. The map may name rows a
+        // stage upstream filtered out; only the ones that reach here matter.
+        const dropGen = ++sortDropGeneration;
+        const added = [];
+        for (let i = 0; i < rows.length; i++) {
+            const prev = c.input[i];
+            const next = rows[i];
+            if (next === prev)
+                continue;
+            if (replaced.get(prev) !== next)
+                return null;
+            prev[ROW_SORT_DROPPED] = dropGen;
+            added.push(next);
+        }
+        if (!added.length)
+            return c.output;
+        const clauses = c.clauses;
+        const single = clauses.length === 1;
+        for (let j = 0; j < added.length; j++) {
+            const row = added[j];
+            if (single) {
+                const key = clauses[0].keyOf(row);
+                if (key === MISSING_KEY)
+                    return null;
+                row[ROW_SORT_KEY] = key;
+            }
+            else {
+                const keys = new Array(clauses.length);
+                for (let k = 0; k < clauses.length; k++) {
+                    const key = clauses[k].keyOf(row);
+                    if (key === MISSING_KEY)
+                        return null;
+                    keys[k] = key;
+                }
+                row[ROW_SORT_KEY] = keys;
+            }
+        }
+        // Keys first, then the data index: the tie-break a stable sort over
+        // data-ordered input applies, so the merge lands where a full sort would.
+        const prevOut = c.output;
+        const compareRows = single
+            ? (() => {
+                const { compare, desc } = clauses[0];
+                return (a, b) => {
+                    const r = compare(a[ROW_SORT_KEY], b[ROW_SORT_KEY]);
+                    if (r !== 0)
+                        return desc ? -r : r;
+                    return a.index - b.index;
+                };
+            })()
+            : (a, b) => {
+                const ka = a[ROW_SORT_KEY];
+                const kb = b[ROW_SORT_KEY];
+                for (let k = 0; k < clauses.length; k++) {
+                    const clause = clauses[k];
+                    const r = clause.compare(ka[k], kb[k]);
+                    if (r !== 0)
+                        return clause.desc ? -r : r;
+                }
+                return a.index - b.index;
+            };
+        // Sort the replacements among themselves (k log k)...
+        added.sort(compareRows);
+        // ...find where each one goes in the previous output by binary search
+        // (k log n comparisons, against the dropped rows too - they are skipped
+        // below, which does not move an insertion point)...
+        const n = prevOut.length;
+        const insertAt = new Array(added.length);
+        let lo = 0;
+        for (let j = 0; j < added.length; j++) {
+            // Monotone: the replacements are sorted, so each search starts where
+            // the previous one landed.
+            const row = added[j];
+            let hi = n;
+            while (lo < hi) {
+                const mid = (lo + hi) >>> 1;
+                if (compareRows(row, prevOut[mid]) < 0)
+                    hi = mid;
+                else
+                    lo = mid + 1;
+            }
+            insertAt[j] = lo;
+        }
+        // ...then one linear pass that only moves references.
+        const out = new Array(rows.length);
+        let w = 0;
+        let j = 0;
+        let nextInsert = insertAt[0] ?? -1;
+        for (let i = 0; i < n; i++) {
+            while (nextInsert === i) {
+                out[w++] = added[j++];
+                nextInsert = j < added.length ? insertAt[j] : -1;
+            }
+            const prev = prevOut[i];
+            if (prev[ROW_SORT_DROPPED] === dropGen)
+                continue;
+            out[w++] = prev;
+        }
+        while (j < added.length)
+            out[w++] = added[j++];
+        return out;
+    }
+    return function sortedRowModelStage({ table, rows }) {
+        const sorting = table.getState().sorting ?? [];
+        if (!sorting.length) {
+            cache = null;
+            return rows;
+        }
+        const columns = table.getAllColumns();
+        if (cache && cache.sorting === sorting && cache.columns === columns) {
+            if (cache.input === rows)
+                return cache.output;
+            const replaced = replacedRowsOf(table);
+            if (replaced) {
+                const repaired = repair(rows, replaced);
+                if (repaired) {
+                    cache = { ...cache, input: rows, output: repaired };
+                    return repaired;
+                }
+            }
+        }
+        const full = fullSort(rows, sorting, columns);
+        if (!full) {
+            cache = null;
+            return rows;
+        }
+        cache = { input: rows, output: full.sorted, sorting, columns, clauses: full.clauses };
+        return full.sorted;
     };
 }
 /**
@@ -788,6 +1091,8 @@ export function createSvGridCore(options) {
     let cachedBaseRowsInput = null;
     let cachedBaseRowsColumns = null;
     let cachedBaseRows = [];
+    /** Old row -> new row for the rebuild the next pipeline run follows; see `replacedRowsOf`. */
+    let replacedRows = null;
     let cachedRowCtx = null;
     let cachedRowModel = null;
     let cachedRowModelBaseRows = null;
@@ -968,7 +1273,11 @@ export function createSvGridCore(options) {
         },
         getRowModel() {
             const columns = grid.getAllColumns();
-            if (cachedBaseRowsInput !== options.data || cachedBaseRowsColumns !== columns) {
+            // Read once. `options.data` is a getter when <SvGrid> drives the engine
+            // (a $state.raw signal), and the rebuild below touched it twice per row:
+            // 200k tracked reads per 100k-row tick, 11 ms of a 65 ms tick.
+            const data = options.data;
+            if (cachedBaseRowsInput !== data || cachedBaseRowsColumns !== columns) {
                 // Same columns as last time: the shared context still describes them,
                 // and a row whose data object sits at the same index can keep its
                 // row object. A row model that streams blocks hands the grid a new
@@ -978,7 +1287,11 @@ export function createSvGridCore(options) {
                 // an app may have changed the object in place before passing a new
                 // array - that is the case the old rebuild covered by accident.
                 const previous = cachedBaseRowsColumns === columns && cachedRowCtx ? cachedBaseRows : null;
-                cachedBaseRowsInput = options.data;
+                // Same length as last time: a replacement, not an add or remove, so
+                // each new row stands in for the old row at its index and the stages
+                // can repair rather than recompute. Anything else is structural.
+                replacedRows = previous && previous.length === data.length ? new Map() : null;
+                cachedBaseRowsInput = data;
                 cachedBaseRowsColumns = columns;
                 // O(1) column-id → index lookup so getCellValueByColumnId doesn't do
                 // a linear `findIndex` on every cell read (was O(rows × cells × cols)).
@@ -1001,11 +1314,11 @@ export function createSvGridCore(options) {
                     };
                     cachedRowCtx = rowCtx;
                 }
-                cachedBaseRows = new Array(options.data.length);
+                cachedBaseRows = new Array(data.length);
                 const getRowId = options.getRowId;
                 const m = BASE_ROW_METHODS;
-                for (let index = 0; index < options.data.length; index++) {
-                    const original = options.data[index];
+                for (let index = 0; index < data.length; index++) {
+                    const original = data[index];
                     const kept = previous?.[index];
                     if (kept && kept.original === original) {
                         kept[ROW_VALUES] = null;
@@ -1013,6 +1326,10 @@ export function createSvGridCore(options) {
                         cachedBaseRows[index] = kept;
                         continue;
                     }
+                    // Past a quarter of the rows the merge stops being cheaper than a
+                    // sort with the ranking pass; let the stages do the full work.
+                    if (replacedRows && replacedRows.size * 4 >= data.length)
+                        replacedRows = null;
                     // `_values` and `_cells` stay null until something reads them - a
                     // 100k-row grid showing twenty rows must not materialise every row's
                     // values or cell objects to paint.
@@ -1024,6 +1341,10 @@ export function createSvGridCore(options) {
                         [ROW_CTX]: rowCtx,
                         [ROW_VALUES]: null,
                         [ROW_CELLS]: null,
+                        [ROW_FILTER_GEN]: 0,
+                        [ROW_FILTER_POS]: -1,
+                        [ROW_SORT_DROPPED]: 0,
+                        [ROW_SORT_KEY]: undefined,
                         getCanExpand: m.getCanExpand,
                         getIsExpanded: m.getIsExpanded,
                         toggleExpanded: m.toggleExpanded,
@@ -1033,7 +1354,17 @@ export function createSvGridCore(options) {
                         getCellValueByColumnId: m.getCellValueByColumnId,
                     };
                     cachedBaseRows[index] = row;
+                    if (replacedRows && kept)
+                        replacedRows.set(kept, row);
                 }
+                // A new array with every object the same is the documented way to
+                // say "I changed rows in place, re-read them" (docs/help/cells/
+                // view-refresh.md). Nothing was replaced, so there is nothing to
+                // repair around: the stages recompute from the current values. A
+                // repair assumes the rows it keeps are unchanged in value as well as
+                // identity, which is the immutable-update contract a tick follows.
+                if (replacedRows && replacedRows.size === 0)
+                    replacedRows = null;
             }
             // Only the slices a pipeline stage actually READS belong in this key.
             //
@@ -1075,10 +1406,19 @@ export function createSvGridCore(options) {
                 pipeline.expandedRowModel,
                 pipeline.paginatedRowModel,
             ];
-            ordered.forEach((fn) => {
-                if (fn)
-                    rows = fn({ table: grid, rows });
-            });
+            // The stages read the replacements through `replacedRowsOf` while the
+            // run lasts; a stage that runs outside one sees null.
+            replacedRowsByGrid.set(grid, replacedRows);
+            try {
+                ordered.forEach((fn) => {
+                    if (fn)
+                        rows = fn({ table: grid, rows });
+                });
+            }
+            finally {
+                replacedRowsByGrid.set(grid, null);
+                replacedRows = null;
+            }
             cachedPipeline = options._rowModels;
             cachedSlices = currentSlices;
             cachedRowModelBaseRows = cachedBaseRows;

package/dist/editing.js

@@ -133,6 +133,22 @@ export function createEditing(ctx) {
         // belongs to the same Ctrl+Z as the value.
         runHistoryGroup(ctx, () => commitEditingCell());
     }
+    /**
+     * True when a column with `rejectInvalid` refuses `value`: its `validate`
+     * hook returns `false` or a message. Without the flag nothing is refused.
+     */
+    function editRejected(column, value, rowData) {
+        const def = column?.columnDef;
+        if (!def?.rejectInvalid || typeof def.validate !== "function")
+            return false;
+        const verdict = def.validate({
+            value,
+            row: rowData,
+            rowIndex: ctx.internalData.indexOf(rowData),
+            column,
+        });
+        return verdict === false || (typeof verdict === "string" && verdict.length > 0);
+    }
     function commitEditingCell() {
         if (!ctx.editingCell)
             return;
@@ -165,6 +181,12 @@ export function createEditing(ctx) {
                     columnId: ctx.editingCell.columnId,
                 });
             }
+            // A refused edit closes the editor and leaves the row, the overlay,
+            // the history and the consumer untouched.
+            if (editRejected(column, finalValue, rowData)) {
+                ctx.editingCell = null;
+                return;
+            }
             rowData[column.columnDef.field] = finalValue;
         }
         const key = getCellKey(ctx.editingCell.rowId, ctx.editingCell.columnId);
@@ -764,6 +786,8 @@ export function createEditing(ctx) {
                     columnId: column.id,
                 })
                 : parsed;
+            if (editRejected(column, finalValue, row.original))
+                continue;
             if (oldValue !== finalValue) {
                 row.original[field] = finalValue;
                 const key = getCellKey(fr.rowId, column.id);

package/dist/grid-messages.d.ts

@@ -76,6 +76,10 @@ export type GridChromeMessages = {
     chartRange: string;
     rowLoadFailed: string;
     rowLoadRetry: string;
+    expandGroup: string;
+    collapseGroup: string;
+    openDetail: string;
+    closeDetail: string;
     pivotUpsellTitle: string;
     pivotUpsellBody: string;
     ganttUpsellTitle: string;

package/dist/grid-messages.js

@@ -86,6 +86,10 @@ export const defaultGridMessages = {
     chartRange: 'Chart selected range',
     rowLoadFailed: 'Could not load these rows.',
     rowLoadRetry: 'Retry',
+    expandGroup: 'Expand group',
+    collapseGroup: 'Collapse group',
+    openDetail: 'Open details',
+    closeDetail: 'Close details',
     pivotUpsellTitle: 'Pivot mode',
     pivotUpsellBody: 'Pivot mode is an Enterprise feature. Install @svgrid/enterprise and call enablePivot() to use it.',
     ganttUpsellTitle: 'Gantt view',

package/dist/headless.d.ts

@@ -27,3 +27,8 @@ export { columnFilteringFeature, columnGroupingFeature, createCoreRowModel, crea
 export { createGrid, createSvGrid, type SvelteGrid } from './createGrid.svelte.js';
 export { createGridState, createSvGridState } from './createGridState.svelte.js';
 export { subscribeGrid, subscribeSvGrid } from './subscribe.js';
+export { createVirtualizer } from './virtualization/virtualizer.js';
+export { createSvelteVirtualizer } from './virtualization/svelte-virtualizer.svelte.js';
+export { createColumnVirtualizer } from './virtualization/column-virtualizer.js';
+export type { VirtualItem, VirtualizerOptions, VirtualizerState } from './virtualization/types.js';
+export { getGridCellDomId, getGridCellA11yProps, getGridHeaderA11yProps, getGridRootA11yProps, getGridRowA11yProps, type GridCellA11yInput, type GridColumnA11yInput, type GridSortDirection, } from './a11y.js';

package/dist/headless.js

@@ -27,3 +27,15 @@ export { columnFilteringFeature, columnGroupingFeature, createCoreRowModel, crea
 export { createGrid, createSvGrid } from './createGrid.svelte.js';
 export { createGridState, createSvGridState } from './createGridState.svelte.js';
 export { subscribeGrid, subscribeSvGrid } from './subscribe.js';
+// The virtualizers are pure window arithmetic (scroll offset in, visible
+// range out) with no DOM of their own, and a custom renderer over 50k rows
+// needs one. They were only on the barrel, so the Headless demos imported
+// the barrel to reach them and paid for the whole thing.
+export { createVirtualizer } from './virtualization/virtualizer.js';
+export { createSvelteVirtualizer } from './virtualization/svelte-virtualizer.svelte.js';
+export { createColumnVirtualizer } from './virtualization/column-virtualizer.js';
+// The WAI-ARIA attribute factories: plain objects to spread onto your own
+// markup (`role`, `aria-sort`, `aria-rowindex`, ...). No DOM is touched here
+// either; a custom renderer that wants keyboard navigation reads
+// `activeCell` from the store and spreads these.
+export { getGridCellDomId, getGridCellA11yProps, getGridHeaderA11yProps, getGridRootA11yProps, getGridRowA11yProps, } from './a11y.js';

package/dist/history.d.ts

@@ -38,6 +38,15 @@ export type HistoryStep = {
         undo: () => void;
         redo: () => void;
     };
+    /**
+     * The consumer's own mark on the step, copied from `api.setHistoryTag` at
+     * the moment it is recorded. The grid never reads it: it is there for a
+     * consumer that shows one of several data sets through the grid and has
+     * to know which one a step belongs to before it lets Ctrl+Z apply it (a
+     * workbook with several sheets, say). Kept as given, so an object tag
+     * compares by identity. Not serialised.
+     */
+    tag?: unknown;
 };
 /** Ctx surface these helpers touch. The controller satisfies it structurally. */
 type HistoryCtx = {
@@ -49,8 +58,20 @@ type HistoryCtx = {
      *  inside it joins that group, so a command does not have to thread a group
      *  id down through the writers it calls. */
     historyGroupId: string | undefined;
+    /** Stamped on every step recorded while it is set; see `HistoryStep.tag`. */
+    historyTag?: unknown;
     applyHistoryStep(step: HistoryStep, direction: 'undo' | 'redo'): void;
 };
+/** What the next undo would apply: the tag of the step Ctrl+Z takes next
+ *  (a group carries one tag, so its last step's is the group's). Null when
+ *  there is nothing to undo. */
+export declare function peekUndoHistory(ctx: HistoryCtx): {
+    tag: unknown;
+} | null;
+/** The redo counterpart of `peekUndoHistory`. */
+export declare function peekRedoHistory(ctx: HistoryCtx): {
+    tag: unknown;
+} | null;
 /** Undo one action. Returns false when there is nothing left to undo. */
 export declare function undoHistory(ctx: HistoryCtx): boolean;
 /** Redo one action. Returns false when there is nothing left to redo. */