@svgrid/grid 3.0.4 → 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,9 @@ 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;
     let cachedPipeline = options._rowModels;
@@ -967,29 +1273,63 @@ export function createSvGridCore(options) {
         },
         getRowModel() {
             const columns = grid.getAllColumns();
-            if (cachedBaseRowsInput !== options.data || cachedBaseRowsColumns !== columns) {
-                cachedBaseRowsInput = options.data;
+            // 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
+                // array of 60k entries per block where 100 changed; building 60k
+                // fresh row objects each time was most of the cost of a block
+                // landing. The reused row drops its memoised values and cells, since
+                // 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;
+                // 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)).
-                const columnIndexById = new Map();
-                for (let i = 0; i < columns.length; i++)
-                    columnIndexById.set(columns[i].id, i);
-                const columnCount = columns.length;
-                // One shared context for every row in this table, so a row carries a
-                // pointer rather than a closure scope. See BASE_ROW_METHODS.
-                const rowCtx = {
-                    grid: grid,
-                    store,
-                    columns,
-                    columnCount,
-                    columnIndexById,
-                };
-                cachedBaseRows = new Array(options.data.length);
+                let rowCtx;
+                if (previous && cachedRowCtx) {
+                    rowCtx = cachedRowCtx;
+                }
+                else {
+                    const columnIndexById = new Map();
+                    for (let i = 0; i < columns.length; i++)
+                        columnIndexById.set(columns[i].id, i);
+                    // One shared context for every row in this table, so a row carries a
+                    // pointer rather than a closure scope. See BASE_ROW_METHODS.
+                    rowCtx = {
+                        grid: grid,
+                        store,
+                        columns,
+                        columnCount: columns.length,
+                        columnIndexById,
+                    };
+                    cachedRowCtx = rowCtx;
+                }
+                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;
+                        kept[ROW_CELLS] = null;
+                        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.
@@ -1001,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,
@@ -1010,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.
             //
@@ -1052,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

@@ -28,6 +28,16 @@ export function createEditing(ctx) {
         const editable = column.columnDef.editable;
         if (editable === false)
             return false;
+        if (row) {
+            // A server-side group row is a key with aggregates under the leaf
+            // columns, and a placeholder row has no data yet: neither takes an
+            // edit, whatever the column says.
+            const serverGroup = ctx.props.serverGroup;
+            if (serverGroup && row.original !== undefined && serverGroup.isGroup(row.original))
+                return false;
+            if (ctx.placeholderStateOf?.(row))
+                return false;
+        }
         if (typeof editable !== "function")
             return true;
         if (!row)
@@ -123,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;
@@ -155,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);
@@ -754,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/gantt-view.svelte.d.ts

@@ -0,0 +1,24 @@
+/**
+ * gantt-view registry - the injection seam for the *Gantt view of the grid*.
+ * Setting the `gantt` prop on `<SvGrid>` switches the table for a task table
+ * beside a time chart (bars by start / end, a work-breakdown tree, dependency
+ * arrows), but the renderer itself ships in `@svgrid/enterprise` (a paid
+ * feature). This tiny reactive holder lets enterprise register that renderer at
+ * import time; the grid looks it up and mounts it, or shows an upsell
+ * placeholder when it is absent. Mirrors the `scheduler-view` / `board-view`
+ * pattern.
+ *
+ * ```ts
+ * // in @svgrid/enterprise, at module load:
+ * import { registerGanttView } from '@svgrid/grid'
+ * import SvGridGantt from './gantt/SvGridGantt.svelte'
+ * registerGanttView(SvGridGantt)
+ * ```
+ */
+import type { Component } from 'svelte';
+/** Register the component that renders `gantt` mode. Enterprise calls this. */
+export declare function registerGanttView(component: Component<any>): void;
+/** The registered Gantt renderer, or null when enterprise is not installed. */
+export declare function getGanttView(): Component<any> | null;
+/** Whether a Gantt renderer has been registered. */
+export declare function hasGanttView(): boolean;

package/dist/gantt-view.svelte.js

@@ -0,0 +1,13 @@
+let renderer = $state(null);
+/** Register the component that renders `gantt` mode. Enterprise calls this. */
+export function registerGanttView(component) {
+    renderer = component;
+}
+/** The registered Gantt renderer, or null when enterprise is not installed. */
+export function getGanttView() {
+    return renderer;
+}
+/** Whether a Gantt renderer has been registered. */
+export function hasGanttView() {
+    return renderer != null;
+}