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

package/dist/index.js

@@ -893,6 +893,11 @@ function createRow(original, key, index, columns, canExpand = false) {
 		original,
 		canExpand,
 		isExpanded: false,
+		depth: 0,
+		parentKey: void 0,
+		childCount: 0,
+		childStatus: "loaded",
+		selection: "none",
 		getValue,
 		getDisplay(columnId) {
 			const cached = displays.get(columnId);
@@ -961,6 +966,216 @@ function freezeState(state, previous) {
 	});
 }
 
+//#endregion
+//#region src/tree.ts
+function buildTree(data, columns, readKey, options, lazy) {
+	const nodes = [];
+	const byKey = /* @__PURE__ */ new Map();
+	const issues = [];
+	const nested = options.getChildren !== void 0;
+	let maxDepth = options.maxDepth ?? 1e3;
+	if (!Number.isSafeInteger(maxDepth) || maxDepth < 1) {
+		issues.push(issue("invalid_tree_option", "maxDepth must be a positive safe integer; 1,000 is used."));
+		maxDepth = 1e3;
+	}
+	if (nested && options.getParentKey) issues.push(issue("invalid_tree_option", "Both tree inputs were supplied; getChildren takes precedence."));
+	const seen = /* @__PURE__ */ new Set();
+	const stack = data.map((original, sourceIndex) => ({
+		original,
+		sourceIndex,
+		parent: void 0,
+		lazy: false
+	})).reverse();
+	while (stack.length) {
+		const entry = stack.pop();
+		const index = nodes.length;
+		let key = readKey(entry.original, index);
+		let parent = entry.parent;
+		const reference = entry.original !== null && (typeof entry.original === "object" || typeof entry.original === "function");
+		const repeated = nested && reference && seen.has(entry.original);
+		if (repeated) {
+			issues.push(issue("tree_cycle", "A repeated nested value recovers as a root without traversing it again.", { rowKey: key }));
+			parent = void 0;
+		}
+		if (reference) seen.add(entry.original);
+		if (byKey.has(key)) {
+			issues.push(issue(entry.lazy ? "tree_duplicate_key" : "duplicate_row_key", entry.lazy ? "A loaded child repeats an existing key and is rejected." : "A repeated row key is replaced with a unique key.", { rowKey: key }));
+			if (entry.lazy) continue;
+			const prefix = `${String(key)}#${index}`;
+			key = prefix;
+			let suffix = 0;
+			while (byKey.has(key)) key = `${prefix}#${++suffix}`;
+		}
+		if (parent && parent.depth + 1 > maxDepth) {
+			issues.push(issue("tree_depth_exceeded", "The maximum tree depth was exceeded; this row recovers as a root.", { rowKey: key }));
+			parent = void 0;
+		}
+		const children = repeated ? void 0 : lazy.get(key) ?? options.getChildren?.(entry.original);
+		const node = {
+			row: createRow(entry.original, key, index, columns),
+			parent,
+			children: [],
+			depth: parent ? parent.depth + 1 : 0,
+			sourceIndex: entry.sourceIndex,
+			lazy: entry.lazy,
+			writable: parent?.writable ?? entry.parent === void 0,
+			unloaded: children === void 0 && (options.hasChildren?.(entry.original) ?? false)
+		};
+		nodes.push(node);
+		byKey.set(key, node);
+		if (parent) parent.children.push(node);
+		if (children) for (let i = children.length - 1; i >= 0; i--) stack.push({
+			original: children[i],
+			sourceIndex: i,
+			parent: node,
+			lazy: entry.lazy || lazy.has(key)
+		});
+	}
+	if (!nested && options.getParentKey) {
+		for (const node of nodes) {
+			if (node.lazy) continue;
+			const key = options.getParentKey(node.row.original);
+			if (key === void 0 || key === null) continue;
+			const parent = byKey.get(key);
+			if (!parent) issues.push(issue("tree_orphan", "The parent is missing; this row recovers as a root.", { rowKey: node.row.key }));
+			else node.parent = parent;
+		}
+		const done = /* @__PURE__ */ new Set();
+		for (const node of nodes) {
+			const path = [];
+			const visiting = /* @__PURE__ */ new Set();
+			let cursor = node;
+			while (cursor && !done.has(cursor)) {
+				if (visiting.has(cursor)) {
+					issues.push(issue("tree_cycle", "A cyclic parent reference is detached to a root.", { rowKey: cursor.row.key }));
+					cursor.parent = void 0;
+					break;
+				}
+				visiting.add(cursor);
+				path.push(cursor);
+				cursor = cursor.parent;
+			}
+			for (let i = path.length - 1; i >= 0; i--) {
+				const current = path[i];
+				done.add(current);
+			}
+		}
+		for (const node of nodes) node.children = [];
+		for (const node of nodes) if (node.parent) node.parent.children.push(node);
+		const pending = nodes.filter((node) => !node.parent);
+		while (pending.length) {
+			const node = pending.pop();
+			node.depth = node.parent ? node.parent.depth + 1 : 0;
+			if (node.depth > maxDepth) {
+				node.parent = void 0;
+				node.depth = 0;
+				issues.push(issue("tree_depth_exceeded", "The maximum tree depth was exceeded; this row recovers as a root.", { rowKey: node.row.key }));
+			}
+			for (const child of node.children) pending.push(child);
+		}
+		for (const node of nodes) node.children = node.children.filter((child) => child.parent === node);
+	}
+	return {
+		nodes,
+		rows: nodes.map((node) => node.row),
+		roots: nodes.filter((node) => !node.parent),
+		byKey,
+		issues
+	};
+}
+function processTree(model, columns, state, mode, manual) {
+	const raw = model.nodes.map((node) => node.row);
+	const matched = manual ? raw : filterRows(raw, columns, state.search, state.filters);
+	const active = matched !== raw;
+	const included = new Set(matched.map((row) => row.key));
+	const autoExpanded = /* @__PURE__ */ new Set();
+	if (active && mode !== "strict") {
+		if (mode === "descendants") {
+			const stack = matched.map((row) => model.byKey.get(row.key));
+			const visited = /* @__PURE__ */ new Set();
+			while (stack.length) {
+				const node = stack.pop();
+				if (visited.has(node.row.key)) continue;
+				visited.add(node.row.key);
+				included.add(node.row.key);
+				if (node.children.length) autoExpanded.add(node.row.key);
+				for (const child of node.children) stack.push(child);
+			}
+		}
+		for (const row of matched) {
+			let parent = model.byKey.get(row.key).parent;
+			while (parent && !autoExpanded.has(parent.row.key)) {
+				included.add(parent.row.key);
+				autoExpanded.add(parent.row.key);
+				parent = parent.parent;
+			}
+		}
+	}
+	if (active && mode === "strict") return {
+		model,
+		roots: ordered(model.nodes.filter((node) => included.has(node.row.key) && node.children.length === 0 && !node.unloaded)),
+		children: /* @__PURE__ */ new Map(),
+		autoExpanded
+	};
+	const children = /* @__PURE__ */ new Map();
+	for (const node of model.nodes) if (node.children.length) children.set(node, ordered(node.children.filter((child) => included.has(child.row.key))));
+	return {
+		model,
+		roots: ordered(model.roots.filter((node) => included.has(node.row.key))),
+		children,
+		autoExpanded
+	};
+	function ordered(nodes) {
+		if (manual || !state.sorting.length || nodes.length < 2) return nodes;
+		return sortRows(nodes.map((node) => node.row), columns, state.sorting).map((row) => model.byKey.get(row.key));
+	}
+}
+/** Expansion changes reuse filtering and sibling order, splicing only a changed subtree. */
+function createTreeFlattener() {
+	let previous;
+	let previousExpanded = [];
+	let visible = [];
+	let previousAncestors;
+	return (tree, expanded, ancestors) => {
+		if (tree === previous && expanded === previousExpanded && ancestors === previousAncestors) return visible;
+		const keys = expanded === true ? void 0 : new Set(expanded);
+		const open = (node) => expanded === true || (keys?.has(node.row.key) ?? false) || ancestors.has(node.row.key) || tree.autoExpanded.has(node.row.key);
+		const walk = (roots) => {
+			const output = [];
+			const stack = [...roots].reverse();
+			while (stack.length) {
+				const node = stack.pop();
+				output.push(node);
+				if (open(node)) {
+					const children = tree.children.get(node) ?? [];
+					for (let i = children.length - 1; i >= 0; i--) stack.push(children[i]);
+				}
+			}
+			return output;
+		};
+		let changed;
+		if (previous === tree && ancestors === previousAncestors && expanded !== true && previousExpanded !== true) {
+			const before = new Set(previousExpanded);
+			const after = new Set(expanded);
+			changed = [...previousExpanded.filter((key) => !after.has(key)), ...expanded.filter((key) => !before.has(key))];
+		}
+		if (changed?.length === 1 && !tree.autoExpanded.has(changed[0])) {
+			const index = visible.findIndex((node) => node.row.key === changed[0]);
+			if (index >= 0) {
+				const node = visible[index];
+				let end = index + 1;
+				while (end < visible.length && visible[end].depth > node.depth) end++;
+				const inserted = walk(open(node) ? tree.children.get(node) ?? [] : []);
+				visible = visible.slice(0, index + 1).concat(inserted, visible.slice(end));
+			}
+		} else visible = walk(tree.roots);
+		previous = tree;
+		previousExpanded = expanded;
+		previousAncestors = ancestors;
+		return visible;
+	};
+}
+
 //#endregion
 //#region src/table.ts
 function isRecord(value) {
@@ -998,6 +1213,15 @@ function createTable(options) {
 	const selectionMode = options.selectionMode ?? "multiple";
 	const selectScope = options.selectScope ?? "all";
 	const manual = options.manual ?? false;
+	const treeEnabled = Boolean(options.getChildren || options.getParentKey || options.hasChildren || options.loadChildren);
+	const rootPagination = treeEnabled && (manual || (options.paginateBy ?? "root") === "root");
+	let lazyVersion = 0;
+	const lazyChildren = /* @__PURE__ */ new Map();
+	const childStatuses = /* @__PURE__ */ new Map();
+	const loadIssues = /* @__PURE__ */ new Map();
+	const loadValidationIssues = /* @__PURE__ */ new Map();
+	const pendingLoads = /* @__PURE__ */ new Map();
+	let destroyed = false;
 	const undoStack = createUndoStack(options.historyLimit);
 	const listeners = /* @__PURE__ */ new Set();
 	const optionIssues = [];
@@ -1055,6 +1279,60 @@ function createTable(options) {
 			issues
 		};
 	});
+	const treeStage = memo((rows, byId, _version) => buildTree(rows, byId, readKey, options, lazyChildren));
+	const processedTreeStage = memo((model, columns, search, filters, sorting) => processTree(model, columns, {
+		...state,
+		search,
+		filters,
+		sorting
+	}, options.treeFilter ?? "ancestors", manual));
+	const flattenTree = createTreeFlattener();
+	const emptyAncestors = /* @__PURE__ */ new Set();
+	const singleTreePath = memo((model, expanded) => {
+		const ancestors = /* @__PURE__ */ new Set();
+		if (expanded !== true) for (const key of expanded) {
+			let parent = model.byKey.get(key)?.parent;
+			while (parent && !ancestors.has(parent.row.key)) {
+				ancestors.add(parent.row.key);
+				parent = parent.parent;
+			}
+		}
+		return ancestors;
+	});
+	const treeSelection = memo((model, selection) => {
+		const selected = new Set(selection);
+		const counts = /* @__PURE__ */ new Map();
+		const stack = model.roots.map((node) => ({
+			node,
+			exit: false
+		}));
+		while (stack.length) {
+			const { node, exit } = stack.pop();
+			if (!exit) {
+				stack.push({
+					node,
+					exit: true
+				});
+				for (const child of node.children) stack.push({
+					node: child,
+					exit: false
+				});
+			} else {
+				let count = selected.has(node.row.key) ? 1 : 0;
+				let total = 1;
+				for (const child of node.children) {
+					const value = counts.get(child);
+					count += value.selected;
+					total += value.total;
+				}
+				counts.set(node, {
+					selected: count,
+					total
+				});
+			}
+		}
+		return counts;
+	});
 	const orderColumns = memo((columns, columnOrder, hiddenColumns) => {
 		const position = new Map(columnOrder.map((id, index) => [id, index]));
 		const ordered = columns.map((column, index) => ({
@@ -1072,12 +1350,17 @@ function createTable(options) {
 	const filterStage = memo(filterRows);
 	const sortStage = memo(sortRows);
 	const selectedSet = memo((selection) => new Set(selection));
-	const expansionStage = memo((indexed, expanded) => {
+	const expansionStage = memo((indexed, expanded, selection) => {
 		const keys = expanded === true ? void 0 : new Set(expanded);
-		const rows = indexed.rows.map((row) => row.canExpand && (expanded === true || keys?.has(row.key)) ? Object.freeze({
-			...row,
-			isExpanded: true
-		}) : row);
+		const selected = new Set(selection);
+		const rows = indexed.rows.map((row) => {
+			const isExpanded = row.canExpand && (expanded === true || (keys?.has(row.key) ?? false));
+			return isExpanded || selected.has(row.key) ? Object.freeze({
+				...row,
+				isExpanded,
+				selection: selected.has(row.key) ? "all" : "none"
+			}) : row;
+		});
 		return {
 			rows,
 			byKey: new Map(rows.map((row) => [row.key, row]))
@@ -1100,14 +1383,20 @@ function createTable(options) {
 	}
 	function computeSnapshot() {
 		const { columns, byId, issues: columnIssues } = resolveColumns(definitions);
-		const indexed = indexRows(data, byId);
-		const expanded = expansionStage(indexed, state.expanded);
+		const model = treeEnabled ? treeStage(data, byId, lazyVersion) : void 0;
+		const indexed = model ? {
+			rows: model.rows,
+			issues: model.issues
+		} : indexRows(data, byId);
+		const expanded = model ? void 0 : expansionStage(indexed, state.expanded, state.selection);
 		const ordered = orderColumns(columns, state.columnOrder, state.hiddenColumns);
 		const issues = [
 			...optionIssues,
 			...columnIssues,
 			...indexed.issues,
-			...stateIssues(byId)
+			...stateIssues(byId),
+			...loadIssues.values(),
+			...Array.from(loadValidationIssues.values()).flat()
 		];
 		const requestedSize = state.pagination.pageSize;
 		let pageSize = Number.isInteger(requestedSize) && requestedSize >= 1 ? requestedSize : 10;
@@ -1116,7 +1405,58 @@ function createTable(options) {
 		let filteredCount;
 		let page;
 		let pageCount;
-		if (manual) {
+		let treeRow;
+		let totalCount = indexed.rows.length;
+		if (model) {
+			const processed = processedTreeStage(model, columns, state.search, state.filters, state.sorting);
+			const ancestors = expandMode === "single" ? singleTreePath(model, state.expanded) : emptyAncestors;
+			const visible = flattenTree(processed, state.expanded, ancestors);
+			const expandedState = state.expanded;
+			const keys = state.expanded === true ? void 0 : new Set(state.expanded);
+			const selected = treeSelection(model, state.selection);
+			const projected = /* @__PURE__ */ new Map();
+			const statuses = new Map(childStatuses);
+			treeRow = (key) => {
+				const cached = projected.get(key);
+				if (cached) return cached;
+				const node = model.byKey.get(key);
+				if (!node) return void 0;
+				const status = statuses.get(key) ?? (node.children.length || !node.unloaded ? "loaded" : "idle");
+				const count = selected.get(node);
+				const canExpand = node.children.length > 0 || status !== "loaded" || (options.getRowCanExpand?.(node.row.original) ?? false);
+				const result = Object.freeze({
+					...node.row,
+					depth: node.depth,
+					parentKey: node.parent?.row.key,
+					childCount: status === "loaded" ? node.children.length : void 0,
+					childStatus: status,
+					canExpand,
+					isExpanded: canExpand && (expandedState === true || (keys?.has(key) ?? false) || ancestors.has(key) || processed.autoExpanded.has(key)),
+					selection: coverage(count.selected, count.total)
+				});
+				projected.set(key, result);
+				return result;
+			};
+			processedRows = visible.map((node) => treeRow(node.row.key));
+			filteredCount = manual ? rowCount ?? model.roots.length : rootPagination ? processed.roots.length : visible.length;
+			totalCount = rootPagination ? model.roots.length : model.nodes.length;
+			pageCount = countPages(filteredCount, pageSize);
+			page = clampPage(state.pagination.page, pageCount);
+			if (manual) rows = processedRows;
+			else if (rootPagination) {
+				const roots = new Set(processed.roots.slice((page - 1) * pageSize, page * pageSize));
+				const allRoots = new Set(processed.roots);
+				let root;
+				rows = processedRows.filter((_row, index) => {
+					const node = visible[index];
+					if (allRoots.has(node)) root = node;
+					return root !== void 0 && roots.has(root);
+				});
+			} else rows = paginateRows(processedRows, {
+				page,
+				pageSize
+			});
+		} else if (manual) {
 			processedRows = expanded.rows;
 			rows = expanded.rows;
 			filteredCount = rowCount ?? indexed.rows.length;
@@ -1160,7 +1500,7 @@ function createTable(options) {
 					row,
 					rowIndex
 				});
-				return row.isExpanded ? [item, Object.freeze({
+				return row.isExpanded && (!model || (options.getRowCanExpand?.(row.original) ?? false)) ? [item, Object.freeze({
 					kind: "detail",
 					key: getRowItemKey(row.key, "detail"),
 					row,
@@ -1173,14 +1513,14 @@ function createTable(options) {
 			pageSize,
 			pageCount,
 			rowCount: filteredCount,
-			totalRowCount: manual ? filteredCount : indexed.rows.length,
+			totalRowCount: manual ? filteredCount : totalCount,
 			pageStart,
-			pageEnd: rows.length === 0 ? 0 : pageStart + rows.length - 1,
+			pageEnd: rows.length === 0 ? 0 : rootPagination ? Math.min(filteredCount, page * pageSize) : pageStart + rows.length - 1,
 			pageItems: paginationItems(page, pageCount),
 			canPreviousPage: page > 1,
 			canNextPage: page < pageCount,
 			selectionMode,
-			selectedCount: state.selection.length,
+			selectedCount: model ? state.selection.filter((key) => model.byKey.has(key)).length : state.selection.length,
 			pageSelection: coverage(pageSelected, rows.length),
 			allSelection: coverage(scopeSelected, scopeRows.length),
 			canUndo: undoStack.canUndo,
@@ -1189,7 +1529,7 @@ function createTable(options) {
 			isSelected: (key) => selected.has(key),
 			getSort: (columnId) => sortIndex.get(columnId),
 			getColumn: (columnId) => byId.get(columnId),
-			getRow: (key) => expanded.byKey.get(key)
+			getRow: (key) => treeRow ? treeRow(key) : expanded.byKey.get(key)
 		});
 	}
 	function getSnapshot() {
@@ -1202,6 +1542,96 @@ function createTable(options) {
 		const next = getSnapshot();
 		for (const listener of listeners) listener(next);
 	}
+	function abortLoads(all = false) {
+		for (const [key, controller] of pendingLoads) {
+			const row = all ? void 0 : getSnapshot().getRow(key);
+			const visible = !all && getSnapshot().processedRows.some((candidate) => candidate.key === key);
+			if (all || !row?.isExpanded || !visible) {
+				pendingLoads.delete(key);
+				childStatuses.delete(key);
+				controller.abort();
+				snapshot = void 0;
+			}
+		}
+	}
+	function requestChildren(row) {
+		if (!options.loadChildren || destroyed || pendingLoads.has(row.key) || lazyChildren.has(row.key) || row.childStatus === "loaded") return;
+		const key = row.key;
+		if (!options.createChildLoadController) {
+			childStatuses.set(key, "error");
+			loadIssues.set(key, issue("invalid_tree_option", "Lazy children require createChildLoadController from the caller's runtime.", { rowKey: key }));
+			notify();
+			return;
+		}
+		let controller;
+		try {
+			controller = options.createChildLoadController();
+		} catch (error) {
+			loadIssues.set(key, issue("tree_load_error", String(error), { rowKey: key }));
+			childStatuses.set(key, "error");
+			notify();
+			return;
+		}
+		pendingLoads.set(key, controller);
+		childStatuses.set(key, "loading");
+		loadIssues.delete(key);
+		loadValidationIssues.delete(key);
+		notify();
+		Promise.resolve().then(() => controller.signal.aborted ? [] : options.loadChildren(row, controller.signal)).then((children) => {
+			if (controller.signal.aborted || pendingLoads.get(key) !== controller || destroyed) return void 0;
+			const { byId } = resolveColumns(definitions);
+			const existing = treeStage(data, byId, lazyVersion);
+			const candidate = buildTree(children, byId, readKey, {
+				...options,
+				getParentKey: void 0
+			}, /* @__PURE__ */ new Map());
+			pendingLoads.delete(key);
+			loadValidationIssues.set(key, candidate.issues.filter((problem) => problem.code === "tree_cycle" || problem.code === "tree_depth_exceeded"));
+			if (candidate.nodes.filter((node) => existing.byKey.has(node.row.key)).length || candidate.issues.some((problem) => problem.code === "duplicate_row_key")) {
+				childStatuses.set(key, "error");
+				loadIssues.set(key, issue("tree_duplicate_key", "Loaded children collide with existing keys; the batch is rejected.", { rowKey: key }));
+			} else {
+				lazyChildren.set(key, children);
+				childStatuses.set(key, "loaded");
+				lazyVersion++;
+				if (state.selection.includes(key) && selectionMode === "multiple") {
+					const nextModel = treeStage(data, byId, lazyVersion);
+					applySelection([...state.selection, ...selectionKeys([key], nextModel)]);
+				}
+			}
+			notify();
+			startVisibleLoads();
+		}).catch((error) => {
+			if (controller.signal.aborted || pendingLoads.get(key) !== controller || destroyed) return;
+			pendingLoads.delete(key);
+			childStatuses.set(key, "error");
+			loadIssues.set(key, issue("tree_load_error", `Children could not be loaded: ${String(error)}`, { rowKey: key }));
+			notify();
+		});
+	}
+	function startVisibleLoads() {
+		if (!treeEnabled || !options.loadChildren || destroyed) return;
+		const current = getSnapshot();
+		for (const row of current.rows) if (row.isExpanded && row.childStatus === "idle") requestChildren(row);
+	}
+	function selectionKeys(keys, model) {
+		if (!treeEnabled || selectionMode !== "multiple") return [...keys];
+		model ??= treeStage(data, resolveColumns(definitions).byId, lazyVersion);
+		const result = new Set(keys);
+		const stack = keys.flatMap((key) => {
+			const node = model.byKey.get(key);
+			return node ? [node] : [];
+		});
+		const visited = /* @__PURE__ */ new Set();
+		while (stack.length) {
+			const node = stack.pop();
+			if (visited.has(node.row.key)) continue;
+			visited.add(node.row.key);
+			result.add(node.row.key);
+			for (const child of node.children) stack.push(child);
+		}
+		return [...result];
+	}
 	/** Apply a change made by a table operation. */
 	function commit(patch) {
 		const previous = state;
@@ -1209,13 +1639,21 @@ function createTable(options) {
 		const next = mergePatch(patch);
 		if (next === previous && previousIssue === expandedIssue) return;
 		state = next;
+		snapshot = void 0;
+		abortLoads();
 		if (next !== previous) options.onStateChange?.(state, previous);
 		notify();
+		startVisibleLoads();
 	}
 	function canonicalExpanded(expanded, candidate = state) {
 		if (expandMode === "multiple") return expanded;
 		if (expanded !== true) return expanded.slice(-1);
 		const { columns, byId } = resolveColumns(definitions);
+		if (treeEnabled) {
+			const model = treeStage(data, byId, lazyVersion);
+			const first = processedTreeStage(model, columns, candidate.search, candidate.filters, candidate.sorting).roots.find((node) => node.children.length > 0 || (options.hasChildren?.(node.row.original) ?? false) || (options.getRowCanExpand?.(node.row.original) ?? false));
+			return first ? [first.row.key] : [];
+		}
 		const indexed = indexRows(data, byId);
 		const first = (manual ? indexed.rows : sortStage(filterStage(indexed.rows, columns, candidate.search, candidate.filters), columns, candidate.sorting)).find((row) => row.canExpand);
 		return first ? [first.key] : [];
@@ -1262,6 +1700,9 @@ function createTable(options) {
 	function applyChanges(edits, record, recoveredIssues = []) {
 		const current = getSnapshot();
 		const working = [...data];
+		const model = treeEnabled ? treeStage(data, resolveColumns(definitions).byId, lazyVersion) : void 0;
+		const replacements = /* @__PURE__ */ new Map();
+		const originalOf = (node) => replacements.get(node) ?? node.row.original;
 		const issues = [...recoveredIssues];
 		const changes = [];
 		const samples = /* @__PURE__ */ new Map();
@@ -1299,7 +1740,22 @@ function createTable(options) {
 				}));
 				continue;
 			}
-			const original = working[row.index];
+			const node = model?.byKey.get(row.key);
+			const original = node ? originalOf(node) : working[row.index];
+			if (node && !node.writable) {
+				issues.push(issue("read_only_cell", "A recovered nested root has no unambiguous source path for editing.", {
+					rowKey: row.key,
+					column: column.id
+				}));
+				continue;
+			}
+			if (node?.parent && options.getChildren && !options.setChildren) {
+				issues.push(issue("read_only_cell", "Editing a nested child requires an immutable setChildren callback.", {
+					rowKey: row.key,
+					column: column.id
+				}));
+				continue;
+			}
 			if (record && !column.isEditable(original)) {
 				issues.push(issue("read_only_cell", `The "${column.id}" cell of row "${String(row.key)}" is read-only.`, {
 					rowKey: row.key,
@@ -1329,7 +1785,21 @@ function createTable(options) {
 				}));
 				continue;
 			}
-			working[row.index] = updated;
+			if (!node) working[row.index] = updated;
+			else {
+				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;
+				}
+				if (options.getChildren || options.setChildren) working[cursor.sourceIndex] = originalOf(cursor);
+				lazyVersion++;
+			}
 			changes.push({
 				rowKey: row.key,
 				column: column.id,
@@ -1372,7 +1842,7 @@ function createTable(options) {
 		return edits;
 	}
 	function replay(changes, direction) {
-		applyChanges(changes.map((change) => ({
+		applyChanges((direction === "undo" ? changes.toReversed() : changes).map((change) => ({
 			rowKey: change.rowKey,
 			column: change.column,
 			value: direction === "undo" ? change.previous : change.value
@@ -1397,14 +1867,24 @@ function createTable(options) {
 			const next = mergePatch(patch);
 			if (next !== state || previousIssue !== expandedIssue) {
 				state = next;
+				snapshot = void 0;
+				abortLoads();
 				notify();
+				startVisibleLoads();
 			}
 		},
 		setData(next) {
 			if (next === data) return;
+			abortLoads(true);
+			lazyChildren.clear();
+			childStatuses.clear();
+			loadIssues.clear();
+			loadValidationIssues.clear();
+			lazyVersion++;
 			data = next;
 			undoStack.clear();
 			notify();
+			startVisibleLoads();
 		},
 		setColumns(next) {
 			if (next === definitions) return;
@@ -1475,14 +1955,14 @@ function createTable(options) {
 			} });
 		},
 		select(keys) {
-			applySelection([...state.selection, ...keys]);
+			applySelection([...state.selection, ...selectionKeys(keys)]);
 		},
 		deselect(keys) {
-			const removed = new Set(keys);
+			const removed = new Set(selectionKeys(keys));
 			applySelection(state.selection.filter((key) => !removed.has(key)));
 		},
 		toggleRow(key, selected) {
-			const isSelected = state.selection.includes(key);
+			const isSelected = treeEnabled ? getSnapshot().getRow(key)?.selection === "all" : state.selection.includes(key);
 			const next = selected ?? !isSelected;
 			if (next === isSelected) return;
 			if (next) table.select([key]);
@@ -1509,12 +1989,16 @@ function createTable(options) {
 			const row = getSnapshot().getRow(key);
 			if (!row?.canExpand) return;
 			const open = expanded ?? !row.isExpanded;
-			if (open === row.isExpanded) return;
+			if (open === row.isExpanded) {
+				if (open && row.childStatus === "error") requestChildren(row);
+				return;
+			}
 			if (expandMode === "single") commit({ expanded: open ? [key] : [] });
 			else if (state.expanded === true) {
 				const { byId } = resolveColumns(definitions);
-				commit({ expanded: indexRows(data, byId).rows.filter((candidate) => candidate.canExpand && candidate.key !== key).map((candidate) => candidate.key) });
+				commit({ expanded: (treeEnabled ? treeStage(data, byId, lazyVersion).rows.map((candidate) => getSnapshot().getRow(candidate.key)) : indexRows(data, byId).rows).filter((candidate) => candidate.canExpand && candidate.key !== key).map((candidate) => candidate.key) });
 			} else commit({ expanded: open ? [...state.expanded, key] : state.expanded.filter((candidate) => candidate !== key) });
+			if (open) requestChildren(getSnapshot().getRow(key));
 		},
 		expandAll() {
 			commit({ expanded: true });
@@ -1595,26 +2079,34 @@ function createTable(options) {
 				return row !== void 0 && current.getColumn(edit.column)?.isEditable(row.original) === true;
 			}), true);
 		},
-		exportRows({ format = "csv", columns: ids, pageOnly = false, headers = true, escapeFormulas = true } = {}) {
+		exportRows({ format = "csv", columns: ids, pageOnly = false, headers = true, escapeFormulas = true, depth = false, indent = "" } = {}) {
 			const current = getSnapshot();
 			const columns = ids ? ids.flatMap((id) => {
 				const column = current.getColumn(id);
 				return column ? [column] : [];
 			}) : current.columns;
-			const matrix = (pageOnly ? current.rows : current.processedRows).map((row) => columns.map((column) => {
-				const display = row.getDisplay(column.id);
+			const rows = pageOnly ? current.rows : current.processedRows;
+			const matrix = rows.map((row) => columns.map((column, index) => {
+				const display = (index === 0 ? indent.repeat(row.depth) : "") + row.getDisplay(column.id);
 				return escapeFormulas ? escapeFormula(display, row.getValue(column.id)) : display;
 			}));
-			if (headers) matrix.unshift(columns.map((column) => escapeFormulas ? escapeFormula(column.header) : column.header));
+			if (depth) matrix.forEach((line, index) => line.unshift(String(rows[index].depth)));
+			if (headers) {
+				matrix.unshift(columns.map((column) => escapeFormulas ? escapeFormula(column.header) : column.header));
+				if (depth) matrix[0].unshift("Depth");
+			}
 			return toDelimited(matrix, format === "csv" ? "," : "	");
 		},
 		reset() {
 			commit(initialState);
 		},
 		destroy() {
+			destroyed = true;
+			abortLoads(true);
 			listeners.clear();
 		}
 	};
+	startVisibleLoads();
 	return table;
 }