@vueye-table/core 3.0.0-alpha.3 → 3.0.0-alpha.4

package/dist/index.js

@@ -898,6 +898,8 @@ function createRow(original, key, index, columns, canExpand = false) {
 		childCount: 0,
 		childStatus: "loaded",
 		selection: "none",
+		isDirty: false,
+		cellIssues: void 0,
 		getValue,
 		getDisplay(columnId) {
 			const cached = displays.get(columnId);
@@ -966,6 +968,366 @@ function freezeState(state, previous) {
 	});
 }
 
+//#endregion
+//#region src/validation.ts
+function isPromise(value) {
+	return typeof value === "object" && value !== null && "then" in value;
+}
+/** Validators receive values; their messages remain plain text. */
+function runValidation(validate, rowKey, column) {
+	const fail = (message, validationCode) => issue("validation_failed", message, {
+		rowKey,
+		column,
+		validationCode
+	});
+	const read = (result) => {
+		if (result === true) return void 0;
+		if (typeof result === "string") return fail(result);
+		if (result && typeof result.message === "string") return fail(result.message, result.code);
+		return fail("The validator returned an invalid result.");
+	};
+	const thrown = (error) => fail(error instanceof Error ? error.message : String(error));
+	try {
+		const result = validate();
+		return isPromise(result) ? Promise.resolve(result).then(read, thrown) : read(result);
+	} catch (error) {
+		return thrown(error);
+	}
+}
+function editorFailure(spec, value) {
+	if (!spec) return void 0;
+	if (spec.maxLength !== void 0 && (!Number.isSafeInteger(spec.maxLength) || spec.maxLength < 0)) return "Editor maxLength must be a non-negative safe integer.";
+	if (spec.min !== void 0 && !Number.isFinite(spec.min) || spec.max !== void 0 && !Number.isFinite(spec.max) || spec.min !== void 0 && spec.max !== void 0 && spec.min > spec.max) return "Editor bounds must be finite and ordered.";
+	if (spec.options && !spec.options.some((option) => Object.is(option, value))) return "Choose one of the allowed values.";
+	if (spec.maxLength !== void 0 && typeof value === "string" && value.length > spec.maxLength) return `Use at most ${spec.maxLength} characters.`;
+	if (spec.min !== void 0 || spec.max !== void 0) {
+		const number = value instanceof Date ? value.getTime() : value;
+		if (typeof number !== "number" || !Number.isFinite(number)) return "Enter a finite numeric value.";
+		if (spec.min !== void 0 && number < spec.min) return `Use a value of at least ${spec.min}.`;
+		if (spec.max !== void 0 && number > spec.max) return `Use a value of at most ${spec.max}.`;
+	}
+	if (spec.pattern !== void 0) try {
+		if (typeof value !== "string" || !new RegExp(spec.pattern, "u").test(value)) return "The value does not match the required pattern.";
+	} catch {
+		return "The editor pattern is invalid.";
+	}
+}
+
+//#endregion
+//#region src/edit-validation.ts
+function readonlyMap(source) {
+	const copy = new Map(source);
+	const result = {
+		size: copy.size,
+		get: (key) => copy.get(key),
+		has: (key) => copy.has(key),
+		entries: () => copy.entries(),
+		keys: () => copy.keys(),
+		values: () => copy.values(),
+		[Symbol.iterator]: () => copy[Symbol.iterator](),
+		forEach(callback, thisArg) {
+			copy.forEach((value, key) => callback.call(thisArg, value, key, result));
+		}
+	};
+	return Object.freeze(result);
+}
+/** All promises in one edit settle together. Tokens fence every cell against stale results. */
+function createEditValidation(host) {
+	const tokens = /* @__PURE__ */ new Map();
+	const pending = /* @__PURE__ */ new Map();
+	const problems = /* @__PURE__ */ new Map();
+	const current = (candidate) => tokens.get(candidate.edit.rowKey)?.get(candidate.edit.column) === candidate.token;
+	const tokenFor = (rowKey, column) => {
+		const row = tokens.get(rowKey) ?? /* @__PURE__ */ new Map();
+		const token = {};
+		row.set(column, token);
+		tokens.set(rowKey, row);
+		pending.get(rowKey)?.delete(column);
+		problems.get(rowKey)?.delete(column);
+		return token;
+	};
+	const setIssues = (issues) => {
+		for (const problem of issues) {
+			if (problem.rowKey === void 0 || problem.column === void 0) continue;
+			const row = problems.get(problem.rowKey) ?? /* @__PURE__ */ new Map();
+			row.set(problem.column, problem);
+			problems.set(problem.rowKey, row);
+		}
+	};
+	function rowValidation(candidates, failures) {
+		if (!host.validateRow) return [...candidates];
+		const rows = /* @__PURE__ */ new Map();
+		for (const candidate of candidates) {
+			const group = rows.get(candidate.edit.rowKey) ?? [];
+			group.push(candidate);
+			rows.set(candidate.edit.rowKey, group);
+		}
+		const results = [];
+		for (const [key, group] of rows) {
+			const previous = group[0].original;
+			let next = previous;
+			try {
+				for (const candidate of group) next = candidate.column.setValue(next, candidate.edit.value) ?? next;
+			} catch (error) {
+				for (const candidate of group) failures.push(issue("validation_failed", String(error), {
+					rowKey: key,
+					column: candidate.edit.column
+				}));
+				continue;
+			}
+			const validation = runValidation(() => host.validateRow(next, previous), key);
+			const accept = (problem) => {
+				if (!problem) return group;
+				for (const candidate of group) if (current(candidate)) failures.push(Object.freeze({
+					...problem,
+					column: candidate.edit.column
+				}));
+				return [];
+			};
+			results.push(isPromise(validation) ? validation.then(accept) : accept(validation));
+		}
+		return results.some(isPromise) ? Promise.all(results.map((result) => Promise.resolve(result))).then((groups) => groups.flat()) : results.flat();
+	}
+	function settle(accepted, all, failures, asynchronous) {
+		return host.batch(() => {
+			const live = accepted.filter(current);
+			const liveKeys = new Set(live);
+			const active = all.filter(current);
+			for (const candidate of active) {
+				const key = candidate.edit.rowKey;
+				pending.get(key)?.delete(candidate.edit.column);
+				if (pending.get(key)?.size === 0) pending.delete(key);
+			}
+			const visibleFailures = failures;
+			setIssues(visibleFailures);
+			let result;
+			if (asynchronous && host.optimistic) {
+				const rollback = active.filter((candidate) => !liveKeys.has(candidate)).map((candidate) => ({
+					...candidate.edit,
+					value: candidate.previous
+				}));
+				result = host.apply(rollback, false, visibleFailures);
+				const changes = live.map((candidate) => Object.freeze({
+					rowKey: candidate.edit.rowKey,
+					column: candidate.edit.column,
+					previous: candidate.previous,
+					value: candidate.edit.value,
+					row: host.snapshot().getRow(candidate.edit.rowKey).original
+				}));
+				if (changes.length) host.record(changes);
+				result = Object.freeze({
+					...result,
+					changes: Object.freeze(changes),
+					status: changes.length ? visibleFailures.length ? "partial" : "applied" : visibleFailures.length ? "rejected" : "unchanged"
+				});
+			} else result = host.apply(live.map((candidate) => candidate.edit), true, visibleFailures);
+			setIssues(result.issues);
+			if (!result.changes.length && (all.length || result.issues.length) || asynchronous && host.optimistic) host.notify();
+			if (asynchronous && !result.issues.length && active.length) host.onIssues([]);
+			return result;
+		});
+	}
+	return {
+		cells: () => Object.freeze([...pending.values()].flatMap((row) => [...row.values()])),
+		problems: () => new Map([...problems].filter(([, row]) => row.size).map(([key, row]) => [key, readonlyMap(row)])),
+		cancel(keys) {
+			if (!keys) {
+				tokens.clear();
+				pending.clear();
+				problems.clear();
+			} else for (const key of keys) {
+				tokens.delete(key);
+				pending.delete(key);
+				problems.delete(key);
+			}
+		},
+		edit(edits, recovered = []) {
+			const metadataChanged = edits.some((edit) => pending.get(edit.rowKey)?.has(edit.column) || problems.get(edit.rowKey)?.has(edit.column) || host.validateRow && pending.get(edit.rowKey)?.size);
+			const snapshot = host.snapshot();
+			const failures = [...recovered];
+			const candidates = [];
+			const drafts = /* @__PURE__ */ new Map();
+			const samples = /* @__PURE__ */ new Map();
+			if (host.validateRow) for (const key of new Set(edits.map((edit) => edit.rowKey))) {
+				tokens.delete(key);
+				pending.delete(key);
+			}
+			for (const edit of edits) {
+				const token = tokenFor(edit.rowKey, edit.column);
+				const row = snapshot.getRow(edit.rowKey);
+				const column = snapshot.getColumn(edit.column);
+				const fail = (code, message) => {
+					failures.push(issue(code, message, {
+						rowKey: edit.rowKey,
+						column: edit.column
+					}));
+				};
+				if (!isSafePath(edit.column)) {
+					fail("unsafe_path", "This path addresses a prototype and cannot be written.");
+					continue;
+				}
+				if (!row) {
+					fail("unknown_row", `No row has the key "${String(edit.rowKey)}".`);
+					continue;
+				}
+				if (!column) {
+					fail("unknown_column", `No column has the id "${edit.column}".`);
+					continue;
+				}
+				const original = drafts.get(row.key) ?? row.original;
+				try {
+					if (!column.isEditable(original)) {
+						fail("read_only_cell", `The "${column.id}" cell is read-only.`);
+						continue;
+					}
+					let value;
+					if ("input" in edit) {
+						if (!samples.has(column.id)) samples.set(column.id, snapshot.processedRows.find((candidate) => candidate.getValue(column.id) !== null && candidate.getValue(column.id) !== void 0)?.getValue(column.id));
+						const parsed = column.parse(edit.input, original, samples.get(column.id));
+						if (!parsed.ok) {
+							fail("invalid_value", parsed.message);
+							continue;
+						}
+						value = parsed.value;
+					} else value = edit.value;
+					const previous = column.getValue(original);
+					if (Object.is(previous, value)) continue;
+					const constraint = editorFailure(column.definition.editor, value);
+					if (constraint) {
+						fail("validation_failed", constraint);
+						continue;
+					}
+					const next = column.setValue(original, value);
+					if (next === void 0) {
+						fail("read_only_cell", "The column has no way to write a value.");
+						continue;
+					}
+					const writeProblem = host.writeIssue(row, next);
+					if (writeProblem) {
+						failures.push(Object.freeze({
+							...writeProblem,
+							column: column.id
+						}));
+						continue;
+					}
+					const validate = column.definition.validate;
+					const validation = validate ? runValidation(() => validate(value, row.original), row.key, column.id) : void 0;
+					if (validation && !isPromise(validation)) {
+						failures.push(validation);
+						continue;
+					}
+					drafts.set(row.key, next);
+					candidates.push({
+						edit: {
+							rowKey: row.key,
+							column: column.id,
+							value
+						},
+						previous: column.getValue(row.original),
+						original: row.original,
+						column,
+						validation,
+						token
+					});
+				} catch (error) {
+					fail("invalid_value", error instanceof Error ? error.message : String(error));
+				}
+			}
+			const asynchronous = candidates.some((candidate) => isPromise(candidate.validation));
+			const validateRows = (accepted) => rowValidation(accepted.filter(current), failures);
+			const outcome = asynchronous ? Promise.all(candidates.map(async (candidate) => {
+				const problem = await candidate.validation;
+				if (problem) {
+					if (current(candidate)) failures.push(problem);
+					return;
+				}
+				return candidate;
+			})).then((accepted) => validateRows(accepted.filter((candidate) => candidate !== void 0))) : validateRows(candidates);
+			if (!isPromise(outcome)) {
+				const result = settle(outcome, candidates, failures, false);
+				if (metadataChanged && !candidates.length && !failures.length) host.notify();
+				return result;
+			}
+			for (const candidate of candidates) {
+				const row = pending.get(candidate.edit.rowKey) ?? /* @__PURE__ */ new Map();
+				row.set(candidate.edit.column, Object.freeze({ ...candidate.edit }));
+				pending.set(candidate.edit.rowKey, row);
+			}
+			setIssues(failures);
+			const optimistic = host.optimistic ? host.apply(candidates.map((candidate) => candidate.edit), false, failures) : void 0;
+			if (!optimistic?.changes.length) host.notify();
+			if (!host.optimistic && failures.length) host.onIssues(failures);
+			outcome.then((accepted) => {
+				if (candidates.some(current)) settle(accepted, candidates, failures, true);
+			});
+			return Object.freeze({
+				status: "pending",
+				changes: optimistic?.changes ?? Object.freeze([]),
+				rowChanges: Object.freeze([]),
+				issues: Object.freeze([...failures]),
+				pendingCells: Object.freeze(candidates.map((candidate) => Object.freeze({ ...candidate.edit })))
+			});
+		}
+	};
+}
+
+//#endregion
+//#region src/pending-changes.ts
+/** A saved baseline only for touched rows; viewing changes never scans source data. */
+function createPendingChanges() {
+	const entries = /* @__PURE__ */ new Map();
+	return {
+		entries,
+		snapshot() {
+			const inserted = [];
+			const removed = [];
+			const updated = [];
+			for (const [rowKey, entry] of entries) if (entry.previous === void 0 && entry.row !== void 0) inserted.push(Object.freeze({
+				kind: "inserted",
+				rowKey,
+				row: entry.row,
+				position: entry.position
+			}));
+			else if (entry.row === void 0 && entry.previous !== void 0) removed.push(Object.freeze({
+				kind: "removed",
+				rowKey,
+				row: entry.previous,
+				position: entry.position
+			}));
+			else if (entry.row !== void 0 && entry.previous !== void 0) updated.push(Object.freeze({
+				rowKey,
+				row: entry.row,
+				previous: entry.previous,
+				changes: Object.freeze([...entry.cells.values()])
+			}));
+			return Object.freeze({
+				inserted: Object.freeze(inserted),
+				updated: Object.freeze(updated),
+				removed: Object.freeze(removed)
+			});
+		},
+		record(key, previous, row, position, changes) {
+			const entry = entries.get(key) ?? {
+				previous,
+				row,
+				position: Object.freeze({ ...position }),
+				cells: /* @__PURE__ */ new Map()
+			};
+			entry.row = row;
+			for (const change of changes) {
+				const original = entry.cells.has(change.column) ? entry.cells.get(change.column).previous : change.previous;
+				if (Object.is(original, change.value)) entry.cells.delete(change.column);
+				else entry.cells.set(change.column, Object.freeze({
+					...change,
+					previous: original
+				}));
+			}
+			if (entry.previous === void 0 && row === void 0 || entry.previous !== void 0 && row !== void 0 && entry.cells.size === 0) entries.delete(key);
+			else entries.set(key, entry);
+		}
+	};
+}
+
 //#endregion
 //#region src/tree.ts
 function buildTree(data, columns, readKey, options, lazy) {
@@ -1223,6 +1585,7 @@ function createTable(options) {
 	const pendingLoads = /* @__PURE__ */ new Map();
 	let destroyed = false;
 	const undoStack = createUndoStack(options.historyLimit);
+	const pendingChanges = createPendingChanges();
 	const listeners = /* @__PURE__ */ new Set();
 	const optionIssues = [];
 	const maxPasteCells = pasteLimit(options.pasteLimit?.maxCells, 1e5, "maxCells", optionIssues);
@@ -1239,6 +1602,36 @@ function createTable(options) {
 	});
 	let state = initialState;
 	let snapshot;
+	let transaction = false;
+	let deferValidationNotify = false;
+	let validationNotifyRequested = false;
+	const validation = createEditValidation({
+		snapshot: getSnapshot,
+		apply: applyChanges,
+		notify,
+		writeIssue(row, next) {
+			const node = treeEnabled ? treeStage(data, resolveColumns(definitions).byId, lazyVersion).byKey.get(row.key) : void 0;
+			if (node && (!node.writable || node.parent && options.getChildren && !options.setChildren)) return issue("read_only_cell", "This nested row has no immutable writable source path.", { rowKey: row.key });
+			if (readKey(next, row.index) !== readKey(row.original, row.index)) return issue("invalid_row_operation", "Editing a row key is not supported; remove and insert the row instead.", { rowKey: row.key });
+		},
+		batch(run) {
+			deferValidationNotify = true;
+			validationNotifyRequested = false;
+			try {
+				return run();
+			} finally {
+				deferValidationNotify = false;
+				if (validationNotifyRequested) notify();
+			}
+		},
+		record: (changes) => undoStack.record({
+			kind: "cells",
+			changes
+		}),
+		onIssues: (issues) => options.onEditIssues?.(issues),
+		optimistic: options.asyncValidation === "optimistic",
+		validateRow: options.validateRow
+	});
 	const readKey = (row, index) => {
 		const { rowKey } = options;
 		if (typeof rowKey === "function") return rowKey(row, index);
@@ -1280,6 +1673,23 @@ function createTable(options) {
 		};
 	});
 	const treeStage = memo((rows, byId, _version) => buildTree(rows, byId, readKey, options, lazyChildren));
+	const treeIndex = memo((model) => ({
+		rows: model.rows,
+		byKey: new Map(model.rows.map((row) => [row.key, row])),
+		issues: model.issues
+	}));
+	const treePositions = memo((model) => {
+		const result = /* @__PURE__ */ new Map();
+		const index = (siblings, parent) => {
+			siblings.forEach((node, position) => result.set(node.row.key, Object.freeze({
+				parent,
+				before: siblings[position + 1]?.row.key
+			})));
+		};
+		index(model.roots);
+		for (const node of model.nodes) index(node.children, node.row.key);
+		return result;
+	});
 	const processedTreeStage = memo((model, columns, search, filters, sorting) => processTree(model, columns, {
 		...state,
 		search,
@@ -1382,6 +1792,13 @@ function createTable(options) {
 		return issues;
 	}
 	function computeSnapshot() {
+		const cellProblems = validation.problems();
+		const dirty = new Set(pendingChanges.entries.keys());
+		const metadata = (row) => dirty.has(row.key) || cellProblems.has(row.key) ? Object.freeze({
+			...row,
+			isDirty: dirty.has(row.key),
+			cellIssues: cellProblems.get(row.key)
+		}) : row;
 		const { columns, byId, issues: columnIssues } = resolveColumns(definitions);
 		const model = treeEnabled ? treeStage(data, byId, lazyVersion) : void 0;
 		const indexed = model ? {
@@ -1396,7 +1813,8 @@ function createTable(options) {
 			...indexed.issues,
 			...stateIssues(byId),
 			...loadIssues.values(),
-			...Array.from(loadValidationIssues.values()).flat()
+			...Array.from(loadValidationIssues.values()).flat(),
+			...Array.from(cellProblems.values()).flatMap((row) => [...row.values()])
 		];
 		const requestedSize = state.pagination.pageSize;
 		let pageSize = Number.isInteger(requestedSize) && requestedSize >= 1 ? requestedSize : 10;
@@ -1426,6 +1844,8 @@ function createTable(options) {
 				const canExpand = node.children.length > 0 || status !== "loaded" || (options.getRowCanExpand?.(node.row.original) ?? false);
 				const result = Object.freeze({
 					...node.row,
+					isDirty: dirty.has(key),
+					cellIssues: cellProblems.get(key),
 					depth: node.depth,
 					parentKey: node.parent?.row.key,
 					childCount: status === "loaded" ? node.children.length : void 0,
@@ -1479,6 +1899,20 @@ function createTable(options) {
 			pageCount = 1;
 			pageSize = Math.max(1, rows.length);
 		}
+		const flatProjected = /* @__PURE__ */ new Map();
+		if (!model) {
+			const project = (row) => {
+				let result = flatProjected.get(row.key);
+				if (!result) {
+					result = metadata(row);
+					flatProjected.set(row.key, result);
+				}
+				return result;
+			};
+			const shared = rows === processedRows;
+			processedRows = processedRows.map(project);
+			rows = shared ? processedRows : rows.map(project);
+		}
 		const selected = selectedSet(state.selection);
 		const pageSelected = rows.filter((row) => selected.has(row.key)).length;
 		const scopeRows = selectScope === "page" || manual ? rows : processedRows;
@@ -1526,10 +1960,11 @@ function createTable(options) {
 			canUndo: undoStack.canUndo,
 			canRedo: undoStack.canRedo,
 			issues: Object.freeze(issues),
+			pendingCells: validation.cells(),
 			isSelected: (key) => selected.has(key),
 			getSort: (columnId) => sortIndex.get(columnId),
 			getColumn: (columnId) => byId.get(columnId),
-			getRow: (key) => treeRow ? treeRow(key) : expanded.byKey.get(key)
+			getRow: (key) => treeRow ? treeRow(key) : flatProjected.get(key) ?? (expanded.byKey.get(key) ? metadata(expanded.byKey.get(key)) : void 0)
 		});
 	}
 	function getSnapshot() {
@@ -1538,6 +1973,11 @@ function createTable(options) {
 	}
 	function notify() {
 		snapshot = void 0;
+		if (deferValidationNotify) {
+			validationNotifyRequested = true;
+			return;
+		}
+		if (transaction) return;
 		if (listeners.size === 0) return;
 		const next = getSnapshot();
 		for (const listener of listeners) listener(next);
@@ -1702,6 +2142,7 @@ function createTable(options) {
 		const working = [...data];
 		const model = treeEnabled ? treeStage(data, resolveColumns(definitions).byId, lazyVersion) : void 0;
 		const replacements = /* @__PURE__ */ new Map();
+		const cache = new Map(lazyChildren);
 		const originalOf = (node) => replacements.get(node) ?? node.row.original;
 		const issues = [...recoveredIssues];
 		const changes = [];
@@ -1777,7 +2218,16 @@ function createTable(options) {
 			} else value = edit.value;
 			const previous = column.getValue(original);
 			if (Object.is(previous, value)) continue;
-			const updated = column.setValue(original, value);
+			let updated;
+			try {
+				updated = column.setValue(original, value);
+			} catch (error) {
+				issues.push(issue("invalid_value", error instanceof Error ? error.message : String(error), {
+					rowKey: row.key,
+					column: column.id
+				}));
+				continue;
+			}
 			if (updated === void 0) {
 				issues.push(issue("read_only_cell", `The "${column.id}" column has no way to write a value.`, {
 					rowKey: row.key,
@@ -1785,20 +2235,37 @@ function createTable(options) {
 				}));
 				continue;
 			}
+			if (readKey(updated, row.index) !== readKey(original, row.index)) {
+				issues.push(issue("invalid_row_operation", "Editing a row key is not supported; remove and insert the row instead.", {
+					rowKey: row.key,
+					column: column.id
+				}));
+				continue;
+			}
 			if (!node) working[row.index] = updated;
 			else {
+				const planned = /* @__PURE__ */ new Map([[node, updated]]);
+				const plannedCache = /* @__PURE__ */ new Map();
 				let cursor = node;
-				replacements.set(cursor, updated);
-				if (!options.getChildren && !cursor.lazy) working[cursor.sourceIndex] = updated;
-				while (cursor.parent) {
-					const parent = cursor.parent;
-					const children = parent.children.map(originalOf);
-					if (cursor.lazy) lazyChildren.set(parent.row.key, children);
-					if (options.setChildren) replacements.set(parent, options.setChildren(originalOf(parent), children));
-					cursor = parent;
+				try {
+					while (cursor.parent) {
+						const parent = cursor.parent;
+						const children = parent.children.map((child) => planned.get(child) ?? originalOf(child));
+						if (cursor.lazy) plannedCache.set(parent.row.key, children);
+						if (options.setChildren) planned.set(parent, options.setChildren(originalOf(parent), children));
+						cursor = parent;
+					}
+				} catch (error) {
+					issues.push(issue("invalid_value", error instanceof Error ? error.message : String(error), {
+						rowKey: row.key,
+						column: column.id
+					}));
+					continue;
 				}
+				for (const [item, plannedRow] of planned) replacements.set(item, plannedRow);
+				for (const [key, children] of plannedCache) cache.set(key, children);
+				if (!options.getChildren && !node.lazy) working[node.sourceIndex] = updated;
 				if (options.getChildren || options.setChildren) working[cursor.sourceIndex] = originalOf(cursor);
-				lazyVersion++;
 			}
 			changes.push({
 				rowKey: row.key,
@@ -1813,17 +2280,390 @@ function createTable(options) {
 		else {
 			status = issues.length > 0 ? "partial" : "applied";
 			data = working;
-			if (record) undoStack.record(changes);
-			options.onDataChange?.(data, changes);
+			if (model) {
+				lazyChildren.clear();
+				for (const [key, children] of cache) lazyChildren.set(key, children);
+				lazyVersion++;
+			}
+			if (record) {
+				if (!transaction) undoStack.record({
+					kind: "cells",
+					changes
+				});
+			}
+			const groups = /* @__PURE__ */ new Map();
+			for (const change of changes) {
+				const group = groups.get(change.rowKey) ?? [];
+				group.push(change);
+				groups.set(change.rowKey, group);
+			}
+			for (const [key, group] of groups) pendingChanges.record(key, current.getRow(key).original, group.at(-1).row, positionOf(key), group);
+			if (!transaction) options.onDataChange?.(data, changes);
 			notify();
 		}
-		if (issues.length > 0) options.onEditIssues?.(issues);
+		if (issues.length > 0 && !transaction) options.onEditIssues?.(issues);
 		return Object.freeze({
 			status,
 			changes: Object.freeze(changes),
-			issues: Object.freeze(issues)
+			issues: Object.freeze(issues),
+			rowChanges: Object.freeze([]),
+			pendingCells: Object.freeze([])
+		});
+	}
+	function sourceRows() {
+		const { byId } = resolveColumns(definitions);
+		const model = treeEnabled ? treeStage(data, byId, lazyVersion) : void 0;
+		return model ? treeIndex(model) : indexRows(data, byId);
+	}
+	function positionOf(key) {
+		const { byId } = resolveColumns(definitions);
+		if (treeEnabled) {
+			const model = treeStage(data, byId, lazyVersion);
+			return treePositions(model).get(key) ?? Object.freeze({});
+		}
+		const indexed = indexRows(data, byId);
+		const row = indexed.byKey.get(key);
+		return Object.freeze({ before: row ? indexed.rows[row.index + 1]?.key : void 0 });
+	}
+	function scene() {
+		return {
+			data,
+			lazy: new Map(lazyChildren)
+		};
+	}
+	function resultForRows(changes, issues, cells = []) {
+		return Object.freeze({
+			status: changes.length || cells.length ? issues.length ? "partial" : "applied" : issues.length ? "rejected" : "unchanged",
+			changes: Object.freeze([...cells]),
+			rowChanges: Object.freeze([...changes]),
+			pendingCells: Object.freeze([]),
+			issues: Object.freeze([...issues])
 		});
 	}
+	function rowProblem(message, rowKey) {
+		return issue("invalid_row_operation", message, { rowKey });
+	}
+	function stableRows(rows) {
+		return options.rowKey !== void 0 || rows.every((row) => {
+			const key = getPath(row, "id");
+			return typeof key === "string" || typeof key === "number";
+		});
+	}
+	function cellDifferences(previous, row, key) {
+		return resolveColumns(definitions).columns.flatMap((column) => {
+			const before = column.getValue(previous);
+			const value = column.getValue(row);
+			return Object.is(before, value) ? [] : [{
+				rowKey: key,
+				column: column.id,
+				previous: before,
+				value,
+				row
+			}];
+		});
+	}
+	function recordRows(previous, keys, positions, baselines = /* @__PURE__ */ new Map()) {
+		const next = sourceRows();
+		const rowChanges = [];
+		for (const key of keys) {
+			const before = previous.byKey.get(key)?.original;
+			const row = next.byKey.get(key)?.original;
+			const position = positions.get(key) ?? positionOf(key);
+			const cells = before !== void 0 && row !== void 0 ? cellDifferences(before, row, key) : [];
+			const baseline = baselines.get(key);
+			const pending = pendingChanges.entries.get(key);
+			if (row === void 0 && baseline !== void 0 && pending?.previous !== void 0) pending.previous = baseline;
+			pendingChanges.record(key, row === void 0 ? baseline ?? before : before, row, position, cells);
+			if (before === void 0 && row !== void 0) rowChanges.push(Object.freeze({
+				kind: "inserted",
+				rowKey: key,
+				row,
+				position: positionOf(key)
+			}));
+			else if (row === void 0 && before !== void 0) rowChanges.push(Object.freeze({
+				kind: "removed",
+				rowKey: key,
+				row: before,
+				position
+			}));
+		}
+		return rowChanges;
+	}
+	function publishRows(before, previous, keys, positions, issues, baselines = /* @__PURE__ */ new Map()) {
+		const rowChanges = recordRows(previous, keys, positions, baselines);
+		if (!transaction) {
+			undoStack.record({
+				kind: "rows",
+				before,
+				after: scene(),
+				keys
+			});
+			options.onDataChange?.(data, []);
+			if (issues.length) options.onEditIssues?.(issues);
+		}
+		notify();
+		return resultForRows(rowChanges, issues);
+	}
+	function restoreScene(entry, direction) {
+		const previous = sourceRows();
+		const baselines = removalBaselines();
+		const positions = new Map(entry.keys.map((key) => [key, positionOf(key)]));
+		const target = direction === "undo" ? entry.before : entry.after;
+		data = target.data;
+		const changed = /* @__PURE__ */ new Set([...entry.before.lazy.keys(), ...entry.after.lazy.keys()]);
+		for (const key of changed) {
+			if (entry.before.lazy.get(key) === entry.after.lazy.get(key)) continue;
+			const rows = target.lazy.get(key);
+			if (rows) lazyChildren.set(key, rows);
+			else lazyChildren.delete(key);
+		}
+		lazyVersion++;
+		recordRows(previous, entry.keys, positions, baselines);
+		options.onDataChange?.(data, []);
+		notify();
+	}
+	function removalBaselines() {
+		const baselines = /* @__PURE__ */ new Map();
+		if (!options.getChildren || !options.setChildren) return baselines;
+		const model = treeStage(data, resolveColumns(definitions).byId, lazyVersion);
+		for (const node of model.nodes.toReversed()) {
+			const entry = pendingChanges.entries.get(node.row.key);
+			if (entry && entry.previous === void 0) continue;
+			let baseline = entry?.previous ?? node.row.original;
+			const children = node.children.filter((child) => !pendingChanges.entries.has(child.row.key) || pendingChanges.entries.get(child.row.key).previous !== void 0).map((child) => baselines.get(child.row.key) ?? child.row.original);
+			const originalChildren = options.getChildren(baseline) ?? [];
+			if (children.length !== originalChildren.length || children.some((child, index) => child !== originalChildren[index])) baseline = options.setChildren(baseline, children);
+			baselines.set(node.row.key, baseline);
+		}
+		return baselines;
+	}
+	function rewriteNested(model, removed, overrides, cache) {
+		const replacements = /* @__PURE__ */ new Map();
+		for (const node of model.nodes.toReversed()) {
+			if (removed.has(node.row.key)) continue;
+			const children = overrides.get(node.row.key) ?? node.children.filter((child) => !removed.has(child.row.key)).map((child) => replacements.get(child) ?? child.row.original);
+			if (!(overrides.has(node.row.key) || children.length !== node.children.length || children.some((child, index) => child !== node.children[index]?.row.original))) continue;
+			if (!options.setChildren) throw new Error("Changing nested children requires setChildren.");
+			replacements.set(node, options.setChildren(node.row.original, children));
+			if (cache.has(node.row.key)) cache.set(node.row.key, children);
+		}
+		const roots = new Map(model.roots.filter((node) => node.writable).map((node) => [node.sourceIndex, node]));
+		return data.flatMap((row, index) => {
+			const node = roots.get(index);
+			return node && removed.has(node.row.key) ? [] : [node ? replacements.get(node) ?? row : row];
+		});
+	}
+	function insertRows(rows, at = {}) {
+		const before = scene();
+		const previous = sourceRows();
+		const problems = [];
+		const reject = (problem) => {
+			if (!transaction) options.onEditIssues?.([problem]);
+			return resultForRows([], [problem]);
+		};
+		let incoming;
+		try {
+			incoming = rows ?? (options.createRow ? [options.createRow()] : []);
+		} catch (error) {
+			return reject(rowProblem(error instanceof Error ? error.message : String(error)));
+		}
+		if (rows === void 0 && !options.createRow) return reject(rowProblem("insertRows() requires rows or a createRow callback."));
+		if (!incoming.length) return resultForRows([], []);
+		if (!stableRows(data) || !stableRows(incoming)) return reject(rowProblem("Row operations require stable row keys; supply rowKey or an id on every row."));
+		const { byId } = resolveColumns(definitions);
+		const model = treeEnabled ? treeStage(data, byId, lazyVersion) : void 0;
+		const parent = at.parent === void 0 ? void 0 : model?.byKey.get(at.parent);
+		const sibling = at.before === void 0 ? void 0 : previous.byKey.get(at.before);
+		if (at.parent !== void 0 && !parent) return reject(issue("unknown_row", "The insertion parent does not exist.", { rowKey: at.parent }));
+		if (at.before !== void 0 && !sibling) return reject(issue("unknown_row", "The insertion sibling does not exist.", { rowKey: at.before }));
+		if (sibling && (model?.byKey.get(sibling.key)?.parent?.row.key ?? sibling.parentKey) !== at.parent) return reject(rowProblem("The before row must belong to the requested parent.", sibling.key));
+		if (parent && !parent.writable) return reject(rowProblem("A recovered parent has no writable source path.", parent.row.key));
+		if (parent && getSnapshot().getRow(parent.row.key)?.childStatus !== "loaded") return reject(rowProblem("Load the parent's children before inserting rows.", parent.row.key));
+		const cache = new Map(lazyChildren);
+		let next;
+		try {
+			if (options.getChildren && parent && model) {
+				const children = parent.children.map((child) => child.row.original);
+				const index = at.before === void 0 ? children.length : parent.children.findIndex((child) => child.row.key === at.before);
+				children.splice(index, 0, ...incoming);
+				next = rewriteNested(model, /* @__PURE__ */ new Set(), /* @__PURE__ */ new Map([[parent.row.key, children]]), cache);
+			} else if (parent && cache.has(parent.row.key)) {
+				incoming = incoming.map((row) => options.setParentKey ? options.setParentKey(row, parent.row.key) : row);
+				const children = [...cache.get(parent.row.key)];
+				const index = at.before === void 0 ? children.length : parent.children.findIndex((child) => child.row.key === at.before);
+				children.splice(index, 0, ...incoming);
+				cache.set(parent.row.key, children);
+				next = [...data];
+			} else {
+				if (parent && options.getParentKey) {
+					incoming = incoming.map((row) => options.setParentKey ? options.setParentKey(row, parent.row.key) : row);
+					if (incoming.some((row) => options.getParentKey(row) !== parent.row.key)) return reject(rowProblem("Supply setParentKey or rows already addressed to the requested parent."));
+				}
+				const working = [...data];
+				working.splice(sibling?.index ?? working.length, 0, ...incoming);
+				next = working;
+			}
+			const candidate = treeEnabled ? buildTree(next, byId, readKey, options, cache) : indexRows(next, byId);
+			if (!stableRows(candidate.rows.map((row) => row.original))) return reject(rowProblem("Every inserted descendant must have a stable key."));
+			const baseline = /* @__PURE__ */ new Map();
+			for (const problem of previous.issues) {
+				const key = `${problem.code}:${String(problem.rowKey)}`;
+				baseline.set(key, (baseline.get(key) ?? 0) + 1);
+			}
+			problems.push(...candidate.issues.filter((problem) => {
+				const key = `${problem.code}:${String(problem.rowKey)}`;
+				const remaining = baseline.get(key) ?? 0;
+				if (!remaining) return true;
+				baseline.set(key, remaining - 1);
+				return false;
+			}));
+			if (problems.length) {
+				if (!transaction) options.onEditIssues?.(problems);
+				return resultForRows([], problems);
+			}
+			const keys = candidate.rows.filter((row) => !previous.byKey.has(row.key)).map((row) => row.key);
+			if (!keys.length) return reject(rowProblem("No unique rows can be inserted."));
+			data = next;
+			lazyChildren.clear();
+			for (const [key, value] of cache) lazyChildren.set(key, value);
+			lazyVersion++;
+			return publishRows(before, previous, keys, /* @__PURE__ */ new Map(), []);
+		} catch (error) {
+			return reject(rowProblem(error instanceof Error ? error.message : String(error)));
+		}
+	}
+	function removeRows(keys) {
+		const before = scene();
+		const previous = sourceRows();
+		const problems = [];
+		const removed = /* @__PURE__ */ new Set();
+		const { byId } = resolveColumns(definitions);
+		const model = treeEnabled ? treeStage(data, byId, lazyVersion) : void 0;
+		if (!stableRows(data)) {
+			const problem = rowProblem("Row operations require stable row keys.");
+			if (!transaction) options.onEditIssues?.([problem]);
+			return resultForRows([], [problem]);
+		}
+		for (const key of keys) {
+			if (!previous.byKey.has(key)) {
+				problems.push(issue("unknown_row", "The row to remove does not exist.", { rowKey: key }));
+				continue;
+			}
+			const node = model?.byKey.get(key);
+			if (node && !node.writable) {
+				problems.push(rowProblem("A recovered row has no writable source path.", key));
+				continue;
+			}
+			const stack = node ? [node] : [];
+			removed.add(key);
+			while (stack.length) {
+				const item = stack.pop();
+				removed.add(item.row.key);
+				for (const child of item.children) stack.push(child);
+			}
+		}
+		if (!removed.size) {
+			if (problems.length && !transaction) options.onEditIssues?.(problems);
+			return resultForRows([], problems);
+		}
+		const positions = new Map([...removed].map((key) => [key, positionOf(key)]));
+		const cache = new Map(lazyChildren);
+		try {
+			const baselines = removalBaselines();
+			const next = options.getChildren && model ? rewriteNested(model, removed, /* @__PURE__ */ new Map(), cache) : data.filter((row, index) => !removed.has(readKey(row, index)));
+			for (const [key, children] of cache) if (removed.has(key)) cache.delete(key);
+			else cache.set(key, children.filter((row, index) => !removed.has(readKey(row, index))));
+			data = next;
+			lazyChildren.clear();
+			for (const [key, value] of cache) lazyChildren.set(key, value);
+			lazyVersion++;
+			validation.cancel([...removed]);
+			abortLoads();
+			return publishRows(before, previous, [...removed], positions, problems, baselines);
+		} catch (error) {
+			problems.push(rowProblem(error instanceof Error ? error.message : String(error)));
+			if (!transaction) options.onEditIssues?.(problems);
+			return resultForRows([], problems);
+		}
+	}
+	function revert(keys) {
+		const selected = new Set(keys ?? pendingChanges.entries.keys());
+		const entries = [...pendingChanges.entries].filter(([key]) => selected.has(key)).map(([key, entry]) => [key, {
+			...entry,
+			cells: new Map(entry.cells)
+		}]);
+		if (!entries.length) return resultForRows([], []);
+		const before = scene();
+		const previous = sourceRows();
+		const positions = new Map([...selected].map((key) => [key, positionOf(key)]));
+		const problems = [];
+		const cells = [];
+		transaction = true;
+		try {
+			problems.push(...removeRows(entries.filter(([, entry]) => entry.previous === void 0).map(([key]) => key)).issues);
+			const missing = entries.filter(([, entry]) => entry.previous !== void 0 && entry.row === void 0);
+			for (let pass = 0; missing.length && pass <= entries.length; pass++) {
+				let progress = false;
+				for (let index = missing.length - 1; index >= 0; index--) {
+					const [key, entry] = missing[index];
+					if (sourceRows().byKey.has(key)) {
+						missing.splice(index, 1);
+						progress = true;
+						continue;
+					}
+					if (entry.position.parent !== void 0 && !sourceRows().byKey.has(entry.position.parent)) continue;
+					const at = {
+						...entry.position,
+						before: entry.position.before !== void 0 && sourceRows().byKey.has(entry.position.before) ? entry.position.before : void 0
+					};
+					const result = insertRows([entry.previous], at);
+					problems.push(...result.issues);
+					missing.splice(index, 1);
+					progress = true;
+				}
+				if (!progress) break;
+			}
+			for (const [key] of missing) problems.push(rowProblem("The saved parent is missing; restore it before this child.", key));
+			const result = applyChanges(entries.flatMap(([key, entry]) => entry.previous !== void 0 && sourceRows().byKey.has(key) ? [...entry.cells.values()].map((change) => ({
+				rowKey: key,
+				column: change.column,
+				value: change.previous
+			})) : []), false);
+			cells.push(...result.changes);
+			problems.push(...result.issues);
+			for (const [key] of entries) if (!problems.some((problem) => problem.rowKey === key)) pendingChanges.entries.delete(key);
+			validation.cancel([...selected]);
+		} finally {
+			transaction = false;
+		}
+		const after = scene();
+		if (before.data !== after.data || cells.length) undoStack.record({
+			kind: "rows",
+			before,
+			after,
+			keys: [...selected]
+		});
+		const next = sourceRows();
+		const rowChanges = [...selected].flatMap((key) => {
+			const old = previous.byKey.get(key);
+			const row = next.byKey.get(key);
+			return !old && row ? [{
+				kind: "inserted",
+				rowKey: key,
+				row: row.original,
+				position: positionOf(key)
+			}] : old && !row ? [{
+				kind: "removed",
+				rowKey: key,
+				row: old.original,
+				position: positions.get(key)
+			}] : [];
+		});
+		if (before.data !== after.data) options.onDataChange?.(data, cells);
+		if (problems.length) options.onEditIssues?.(problems);
+		notify();
+		return resultForRows(rowChanges, problems, cells);
+	}
 	function rangeEdits(origin, matrix) {
 		const { rows, columns } = getSnapshot();
 		const edits = [];
@@ -1854,6 +2694,15 @@ function createTable(options) {
 		snapshot = void 0;
 	}
 	const table = {
+		insertRows,
+		removeRows,
+		revert,
+		getPendingChanges: () => pendingChanges.snapshot(),
+		markSaved(keys) {
+			if (!keys) pendingChanges.entries.clear();
+			else for (const key of keys) pendingChanges.entries.delete(key);
+			notify();
+		},
 		getSnapshot,
 		getState: () => state,
 		subscribe(listener) {
@@ -1875,6 +2724,8 @@ function createTable(options) {
 		},
 		setData(next) {
 			if (next === data) return;
+			validation.cancel();
+			pendingChanges.entries.clear();
 			abortLoads(true);
 			lazyChildren.clear();
 			childStatuses.clear();
@@ -1889,6 +2740,7 @@ function createTable(options) {
 		setColumns(next) {
 			if (next === definitions) return;
 			definitions = next;
+			validation.cancel();
 			notify();
 		},
 		setRowCount(next) {
@@ -2024,18 +2876,22 @@ function createTable(options) {
 			commit({ columnOrder: order });
 		},
 		edit(edits) {
-			return applyChanges(Array.isArray(edits) ? edits : [edits], true);
+			return validation.edit(Array.isArray(edits) ? edits : [edits]);
 		},
 		undo() {
-			const changes = undoStack.undo();
-			if (!changes) return false;
-			replay(changes, "undo");
+			const entry = undoStack.undo();
+			if (!entry) return false;
+			validation.cancel();
+			if (entry.kind === "cells") replay(entry.changes, "undo");
+			else restoreScene(entry, "undo");
 			return true;
 		},
 		redo() {
-			const changes = undoStack.redo();
-			if (!changes) return false;
-			replay(changes, "redo");
+			const entry = undoStack.redo();
+			if (!entry) return false;
+			validation.cancel();
+			if (entry.kind === "cells") replay(entry.changes, "redo");
+			else restoreScene(entry, "redo");
 			return true;
 		},
 		copy(range, { escapeFormulas = false } = {}) {
@@ -2057,7 +2913,7 @@ function createTable(options) {
 			return toDelimited(matrix);
 		},
 		paste(origin, text) {
-			if (!Number.isInteger(origin.row) || !Number.isInteger(origin.column) || origin.row < 0 || origin.column < 0) return applyChanges([], true, [issue("invalid_value", "The paste origin must use non-negative whole row and column indices.")]);
+			if (!Number.isInteger(origin.row) || !Number.isInteger(origin.column) || origin.row < 0 || origin.column < 0) return validation.edit([], [issue("invalid_value", "The paste origin must use non-negative whole row and column indices.")]);
 			const { rows, columns } = getSnapshot();
 			const parsed = readDelimited(text, {
 				maxRows: Math.max(0, rows.length - origin.row),
@@ -2066,18 +2922,19 @@ function createTable(options) {
 				maxLength: maxPasteLength
 			});
 			const issues = parsed.truncated ? [issue("paste_truncated", "The paste exceeds the visible grid or parsing limits; only complete cells within those limits are applied.")] : [];
-			return applyChanges(rangeEdits(origin, parsed.rows), true, issues);
+			return validation.edit(rangeEdits(origin, parsed.rows), issues);
 		},
 		clear(range) {
 			const matrix = Array.from({ length: range.bottom - range.top + 1 }, () => Array.from({ length: range.right - range.left + 1 }, () => ""));
 			const current = getSnapshot();
-			return applyChanges(rangeEdits({
+			const edits = rangeEdits({
 				row: range.top,
 				column: range.left
 			}, matrix).filter((edit) => {
 				const row = current.getRow(edit.rowKey);
 				return row !== void 0 && current.getColumn(edit.column)?.isEditable(row.original) === true;
-			}), true);
+			});
+			return validation.edit(edits);
 		},
 		exportRows({ format = "csv", columns: ids, pageOnly = false, headers = true, escapeFormulas = true, depth = false, indent = "" } = {}) {
 			const current = getSnapshot();
@@ -2102,6 +2959,7 @@ function createTable(options) {
 		},
 		destroy() {
 			destroyed = true;
+			validation.cancel();
 			abortLoads(true);
 			listeners.clear();
 		}