@lobehub/editor 4.29.0 → 4.29.2

package/es/plugins/litexml/command/index.js

@@ -1,18 +1,22 @@
 import { createDebugLogger, init_debug } from "../../../utils/debug.js";
-import { $closest, getKernelFromEditor, init_utils } from "../../../editor-kernel/utils.js";
-import { findNewIllegalDiffPaths, projectLiteXmlOperation } from "../diff-validation.js";
+import { $ensureUniqueNodeIds, $findNodeById, $getNodeId, init_node_id } from "../../common/node/node-id.js";
+import { exportNodeToJSON, init_utils } from "../../common/utils/index.js";
+import { $closest, init_utils as init_utils$1 } from "../../../editor-kernel/utils.js";
+import { findNewIllegalDiffPaths, hasActiveLiteXmlNodeId, projectLiteXmlOperation } from "../diff-validation.js";
 import { $createDiffContentNode, $isDiffContentNode } from "../node/DiffContentNode.js";
 import { $createDiffNode, $isDiffNode, DiffNode } from "../node/DiffNode.js";
 import { $isTableCellDiffNode } from "../node/TableCellDiffNode.js";
-import { $cloneNode, $parseSerializedNodeImpl, charToId } from "../utils/index.js";
+import { $cloneNode, $parseSerializedNodeImpl } from "../utils/index.js";
 import { $createTableCellDiffFromCell, $getLogicalRowWidth, $getTableCellColumnIndex, $getTableForCell, $shrinkTableWidthsAfterCellRemoval, $updateTableWidthsForCellInsertion } from "../table-cell-diff.js";
 import { $areTableRowStructuresCompatible, $createTableRowDiffFromRow } from "../table-row-diff.js";
-import { LITEXML_APPLY_COMMAND, LITEXML_INSERT_COMMAND, LITEXML_MODIFY_COMMAND, LITEXML_REMOVE_COMMAND } from "./symbols.js";
+import { LITEXML_APPLY_COMMAND, LITEXML_INSERT_COMMAND, LITEXML_MODIFY_COMMAND, LITEXML_MODIFY_WITH_RESULTS_COMMAND, LITEXML_REMOVE_COMMAND } from "./symbols.js";
 import { $isTableCellNode, $isTableNode, $isTableRowNode } from "@lexical/table";
 import { $createParagraphNode, $getNodeByKey, $getRoot, $insertNodes, $isElementNode, COMMAND_PRIORITY_EDITOR } from "lexical";
 import { mergeRegister } from "@lexical/utils";
-import { $isListItemNode } from "@lexical/list";
+import { $isListItemNode, $isListNode } from "@lexical/list";
 //#region src/plugins/litexml/command/index.ts
+init_utils$1();
+init_node_id();
 init_utils();
 init_debug();
 const logger = createDebugLogger("plugin", "litexml");
@@ -22,9 +26,9 @@ function toArrayXml(litexml) {
 function hasNewIllegalDiffs(previous, projected) {
 	return findNewIllegalDiffPaths(previous, projected);
 }
-function projectOperation(dataSource, document, operation) {
+function projectOperation(dataSource, document, operation, readXml = (xml) => dataSource.readLiteXMLToInode(xml)) {
 	try {
-		const projected = projectLiteXmlOperation(document, operation, (xml) => dataSource.readLiteXMLToInode(xml));
+		const projected = projectLiteXmlOperation(document, operation, readXml);
 		const newIllegalDiffs = hasNewIllegalDiffs(document, projected);
 		if (newIllegalDiffs.length > 0) {
 			logger.warn("⚠️ Skipping operation with illegal nested diff", newIllegalDiffs);
@@ -37,19 +41,163 @@ function projectOperation(dataSource, document, operation) {
 	}
 }
 function toProjectionOperation(operation) {
-	if (operation.action === "remove") return {
-		...operation,
-		id: charToId(operation.id)
-	};
-	if (operation.action === "insert") return {
-		...operation,
-		..."beforeId" in operation ? { beforeId: operation.beforeId === "root" ? "root" : charToId(operation.beforeId) } : { afterId: operation.afterId === "root" ? "root" : charToId(operation.afterId) }
-	};
 	return operation;
 }
+function getSerializedNodeId(node) {
+	if (typeof node?.id === "string" && node.id.length > 0) return node.id;
+	const nodeId = node?.$?.properties?.nodeId;
+	return typeof nodeId === "string" && nodeId.length > 0 ? nodeId : void 0;
+}
+function getActiveSerializedDocument() {
+	return { root: exportNodeToJSON($getRoot()) };
+}
+/** Resolve every target before staging any part of one modify operation. */
+function prepareModify(editor, dataSource, xmls) {
+	const pairs = [];
+	const parsed = /* @__PURE__ */ new Map();
+	const targetIds = /* @__PURE__ */ new Set();
+	for (const xml of xmls) {
+		const inode = dataSource.readLiteXMLToInode(xml);
+		parsed.set(xml, inode);
+		const children = inode.root?.children;
+		if (!children?.length) throw new Error("Modify operation contains no LiteXML nodes.");
+		for (const child of children) {
+			const nodeId = getSerializedNodeId(child);
+			if (!nodeId) throw new Error("Modify operation root is missing its public node id.");
+			if (targetIds.has(nodeId)) throw new Error(`Node id "${nodeId}" is targeted more than once.`);
+			targetIds.add(nodeId);
+			const oldNode = $findNodeById(nodeId);
+			if (!oldNode) throw new Error(`Node id "${nodeId}" was not found.`);
+			const newNode = $parseSerializedNodeImpl(child, editor);
+			if (oldNode.isInline() !== newNode.isInline()) throw new Error(`Node id "${nodeId}" cannot change between inline and block structure.`);
+			const parent = oldNode.getParent();
+			if (($isListNode(parent) || $isListItemNode(oldNode) || $isListItemNode(newNode)) && (!$isListNode(parent) || !$isListItemNode(oldNode) || !$isListItemNode(newNode))) throw new Error(`Node id "${nodeId}" has an incompatible list-item structure.`);
+			if ($isTableNode(parent) && (!$isTableRowNode(oldNode) || !$isTableRowNode(newNode)) || $isTableRowNode(parent) && (!$isTableCellNode(oldNode) || !$isTableCellNode(newNode)) || $isTableRowNode(newNode) && !$isTableNode(parent) || $isTableCellNode(newNode) && !$isTableRowNode(parent)) throw new Error(`Node id "${nodeId}" has an incompatible table structure.`);
+			if (($isTableRowNode(oldNode) || $isTableRowNode(newNode)) && (!$isTableRowNode(oldNode) || !$isTableRowNode(newNode) || !$isTableNode(parent) || !$areTableRowStructuresCompatible(oldNode, newNode))) throw new Error(`Node id "${nodeId}" has an incompatible table row structure.`);
+			pairs.push({
+				newNode,
+				oldNode
+			});
+		}
+	}
+	const targetKeys = new Set(pairs.map(({ oldNode }) => oldNode.getKey()));
+	for (const { oldNode } of pairs) for (let parent = oldNode.getParent(); parent; parent = parent.getParent()) if (targetKeys.has(parent.getKey())) throw new Error("Modify operation targets overlapping ancestor and descendant nodes.");
+	return {
+		pairs,
+		readXml: (xml) => parsed.get(xml)
+	};
+}
+function getBatchTargetError(document, operation, dataSource) {
+	if (operation.action === "remove") return hasActiveLiteXmlNodeId(document.root, operation.id) ? void 0 : `Node id "${operation.id}" was not found.`;
+	if (operation.action === "insert") {
+		try {
+			if (!dataSource.readLiteXMLToInode(operation.litexml).root.children?.length) return "Insert operation contains no LiteXML nodes.";
+		} catch (error) {
+			return error instanceof Error ? error.message : String(error);
+		}
+		const anchorId = "beforeId" in operation ? operation.beforeId : operation.afterId;
+		if (anchorId === "root") return (document.root.children?.length || 0) > 0 ? void 0 : "The document has no node to use as an insertion anchor.";
+		return hasActiveLiteXmlNodeId(document.root, anchorId) ? void 0 : `Insertion anchor "${anchorId}" was not found.`;
+	}
+}
+function applyLiteXMLBatch(editor, dataSource, operations) {
+	let projectedDocument = getActiveSerializedDocument();
+	const afterAnchors = /* @__PURE__ */ new Map();
+	const results = [];
+	operations.forEach((operation, index) => {
+		const targetError = getBatchTargetError(projectedDocument, operation, dataSource);
+		if (targetError) {
+			results.push({
+				action: operation.action,
+				index,
+				reason: targetError,
+				status: "failed"
+			});
+			return;
+		}
+		let preparedModify;
+		if (operation.action === "modify") try {
+			preparedModify = prepareModify(editor, dataSource, toArrayXml(operation.litexml));
+		} catch (error) {
+			results.push({
+				action: operation.action,
+				index,
+				reason: error instanceof Error ? error.message : String(error),
+				status: "failed"
+			});
+			return;
+		}
+		if (!projectOperation(dataSource, projectedDocument, toProjectionOperation(operation), preparedModify?.readXml)) {
+			results.push({
+				action: operation.action,
+				index,
+				reason: "The operation would create an invalid nested review diff.",
+				status: "failed"
+			});
+			return;
+		}
+		try {
+			let applied = false;
+			switch (operation.action) {
+				case "modify":
+					applied = applyPreparedModify(editor, preparedModify);
+					break;
+				case "remove":
+					applied = handleRemove(editor, operation.id, true);
+					break;
+				case "insert": {
+					const cursorIds = "afterId" in operation ? afterAnchors.get(operation.afterId) : void 0;
+					let override;
+					if (cursorIds) for (let cursorIndex = cursorIds.length - 1; cursorIndex >= 0; cursorIndex--) {
+						const cursor = $findNodeById(cursorIds[cursorIndex]);
+						if (cursor) {
+							override = cursor;
+							break;
+						}
+					}
+					const insertedNodeId = handleInsert(editor, {
+						...operation,
+						delay: true
+					}, dataSource, override);
+					applied = insertedNodeId !== null;
+					if ("afterId" in operation && insertedNodeId) {
+						const nextCursors = afterAnchors.get(operation.afterId) || [];
+						nextCursors.push(insertedNodeId);
+						afterAnchors.set(operation.afterId, nextCursors);
+					}
+					break;
+				}
+			}
+			if (!applied) {
+				results.push({
+					action: operation.action,
+					index,
+					reason: "The editor could not apply the operation.",
+					status: "failed"
+				});
+				return;
+			}
+			projectedDocument = getActiveSerializedDocument();
+			results.push({
+				action: operation.action,
+				index,
+				status: "applied"
+			});
+		} catch (error) {
+			results.push({
+				action: operation.action,
+				index,
+				reason: error instanceof Error ? error.message : String(error),
+				status: "failed"
+			});
+		}
+	});
+	return results;
+}
 function tryParseChild(child, editor) {
 	try {
-		const oldNode = $getNodeByKey(child.id);
+		const nodeId = typeof child.id === "string" ? child.id : child.$?.properties?.nodeId;
+		const oldNode = typeof nodeId === "string" ? $findNodeById(nodeId) : null;
 		return {
 			newNode: $parseSerializedNodeImpl(child, editor),
 			oldNode
@@ -66,14 +214,14 @@ function handleReplaceForApplyDelay(oldNode, newNode, modifyBlockNodes, diffNode
 	if ($isTableRowNode(oldNode) || $isTableRowNode(newNode)) {
 		if (!$isTableRowNode(oldNode) || !$isTableRowNode(newNode) || !$isTableNode(oldNode.getParent()) || !$areTableRowStructuresCompatible(oldNode, newNode)) {
 			logger.error(`❌ Invalid table row modification for row ${oldNode.getKey()}.`);
-			return;
+			return false;
 		}
 		const changeId = `${oldNode.getKey()}:${newNode.getKey()}`;
 		const removeRow = $createTableRowDiffFromRow(editor, oldNode, "remove", changeId);
 		const addRow = $createTableRowDiffFromRow(editor, newNode, "add", changeId);
 		oldNode.replace(removeRow, false);
 		removeRow.insertAfter(addRow);
-		return;
+		return true;
 	}
 	if ($isTableCellNode(oldNode) && $isTableCellNode(newNode)) {
 		const existingDiff = oldNode.getChildren().find($isDiffNode);
@@ -83,7 +231,7 @@ function handleReplaceForApplyDelay(oldNode, newNode, modifyBlockNodes, diffNode
 				newNode.getChildren().forEach((child) => {
 					existingDiff.append($cloneNode(child, editor));
 				});
-				return;
+				return true;
 			}
 			const after = existingDiff.getChildren().find((child) => $isDiffContentNode(child) && child.side === "after");
 			if (existingDiff.diffType === "modify" && after && $isDiffContentNode(after)) {
@@ -91,7 +239,7 @@ function handleReplaceForApplyDelay(oldNode, newNode, modifyBlockNodes, diffNode
 				newNode.getChildren().forEach((child) => {
 					after.append($cloneNode(child, editor));
 				});
-				return;
+				return true;
 			}
 		}
 		const before = $createDiffContentNode("before");
@@ -102,27 +250,42 @@ function handleReplaceForApplyDelay(oldNode, newNode, modifyBlockNodes, diffNode
 		diffNode.append(before, after);
 		oldNode.clear();
 		oldNode.append(diffNode);
-		return;
+		return true;
 	}
 	const oldBlock = $closest(oldNode, (node) => node.isInline() === false);
 	if (!oldBlock) throw new Error("Old block node not found for diffing.");
 	if ($closest(oldNode, (node) => node.getType() === DiffNode.getType())) {
 		oldNode.replace(newNode, false);
-		return;
+		return true;
 	}
 	if ($isListItemNode(oldNode) && $isListItemNode(newNode)) {
+		const existingListDiff = oldNode.getChildren().find($isDiffNode);
+		if (existingListDiff?.diffType === "listItemModify") {
+			const after = existingListDiff.getChildAtIndex(1);
+			if ($isElementNode(after)) {
+				after.clear();
+				newNode.getChildren().forEach((child) => after.append($cloneNode(child, editor)));
+				return true;
+			}
+		}
+		if (existingListDiff?.diffType === "listItemAdd") {
+			existingListDiff.clear();
+			newNode.getChildren().forEach((child) => existingListDiff.append($cloneNode(child, editor)));
+			return true;
+		}
 		const before = $createParagraphNode();
 		const after = $createParagraphNode();
 		oldNode.getChildren().forEach((child) => before.append(child));
 		newNode.getChildren().forEach((child) => after.append(child));
 		oldNode.clear();
 		oldNode.append($createDiffNode("listItemModify").append(before, after));
-		return;
+		return true;
 	}
 	if (oldNode === oldBlock) {
 		const diffNode = $createDiffNode("modify");
 		oldNode.replace(diffNode, false);
 		diffNode.append($createDiffContentNode("before").append(oldBlock), $createDiffContentNode("after").append(newNode));
+		return true;
 	} else {
 		if (!modifyBlockNodes.has(oldBlock.getKey())) {
 			modifyBlockNodes.add(oldBlock.getKey());
@@ -131,6 +294,7 @@ function handleReplaceForApplyDelay(oldNode, newNode, modifyBlockNodes, diffNode
 			diffNodeMap.set(oldBlock.getKey(), diffNode);
 		}
 		oldNode.replace(newNode, false);
+		return true;
 	}
 }
 function finalizeModifyBlocks(modifyBlockNodes, diffNodeMap, editor) {
@@ -151,6 +315,16 @@ function finalizeModifyBlocks(modifyBlockNodes, diffNodeMap, editor) {
 				newDiffNode.append(p);
 				blockNode.append(newDiffNode);
 				continue;
+			} else if ($isTableCellNode(blockNode) && $isTableRowNode(blockNode.getParent()) && $isTableCellNode(diffNode.getFirstChild())) {
+				const beforeCell = diffNode.getFirstChild();
+				if (!$isTableCellNode(beforeCell)) continue;
+				const before = $createDiffContentNode("before");
+				const after = $createDiffContentNode("after");
+				beforeCell.getChildren().forEach((child) => before.append(child));
+				blockNode.getChildren().forEach((child) => after.append($cloneNode(child, editor)));
+				blockNode.clear();
+				blockNode.append($createDiffNode("modify").append(before, after));
+				continue;
 			} else {
 				diffNode.append($cloneNode(blockNode, editor));
 				blockNode.replace(diffNode, false);
@@ -181,6 +355,18 @@ function wrapBlockModify(oldBlock, editor, changeFn) {
 		oldBlock.append(diffNode);
 		return;
 	}
+	if ($isTableCellNode(oldBlock) && !$isTableCellDiffNode(oldBlock) && $isTableRowNode(oldBlock.getParent())) {
+		const before = $createDiffContentNode("before");
+		oldBlock.getChildren().forEach((child) => before.append($cloneNode(child, editor)));
+		changeFn();
+		const newBlock = $getNodeByKey(oldBlock.getKey());
+		if (!$isTableCellNode(newBlock)) throw new Error("Updated table cell node not found for modify wrapper.");
+		const after = $createDiffContentNode("after");
+		newBlock.getChildren().forEach((child) => after.append($cloneNode(child, editor)));
+		newBlock.clear();
+		newBlock.append($createDiffNode("modify").append(before, after));
+		return;
+	}
 	const diffNode = $createDiffNode("modify");
 	diffNode.append($cloneNode(oldBlock, editor));
 	changeFn();
@@ -190,345 +376,331 @@ function wrapBlockModify(oldBlock, editor, changeFn) {
 	newBlock.replace(diffNode, false);
 }
 function registerLiteXMLCommand(editor, dataSource) {
-	return mergeRegister(editor.registerCommand(LITEXML_MODIFY_COMMAND, (payload) => {
-		const resultPayload = payload.reduce((acc, cur) => {
-			if (cur.action === "insert") acc.unshift(cur);
-			else acc.push(cur);
-			return acc;
-		}, []);
-		let projectedDocument = getKernelFromEditor(editor).getDocument("json");
-		const safePayload = resultPayload.filter((item) => {
-			const nextProjection = projectOperation(dataSource, projectedDocument, toProjectionOperation(item));
-			if (!nextProjection) return false;
-			projectedDocument = nextProjection;
-			return true;
-		});
-		try {
-			safePayload.forEach((item) => {
-				const { action } = item;
-				switch (action) {
-					case "modify": {
-						const { litexml } = item;
-						handleModify(editor, dataSource, toArrayXml(litexml), true);
-						break;
-					}
-					case "remove": {
-						const { id } = item;
-						handleRemove(editor, charToId(id), true);
-						break;
-					}
-					case "insert":
-						handleInsert(editor, {
-							...item,
-							delay: true
-						}, dataSource);
-						break;
-					default: logger.warn(`⚠️ Unknown action type: ${action}`);
-				}
-			});
-			return false;
-		} catch (error) {
-			logger.error("❌ Error processing LITEXML_MODIFY_COMMAND:", error);
-			return false;
-		}
+	return mergeRegister(editor.registerCommand(LITEXML_MODIFY_COMMAND, (operations) => {
+		applyLiteXMLBatch(editor, dataSource, operations);
+		return false;
+	}, COMMAND_PRIORITY_EDITOR), editor.registerCommand(LITEXML_MODIFY_WITH_RESULTS_COMMAND, ({ operations, onResults }) => {
+		onResults(applyLiteXMLBatch(editor, dataSource, operations));
+		return true;
 	}, COMMAND_PRIORITY_EDITOR), editor.registerCommand(LITEXML_APPLY_COMMAND, (payload) => {
 		const { litexml, delay } = payload;
 		const arrayXml = toArrayXml(litexml);
 		if (!delay) {
-			handleModify(editor, dataSource, arrayXml, delay);
+			handleModify(editor, dataSource, arrayXml);
 			return false;
 		}
 		const operation = {
 			action: "modify",
 			litexml
 		};
-		if (projectOperation(dataSource, getKernelFromEditor(editor).getDocument("json"), toProjectionOperation(operation))) handleModify(editor, dataSource, arrayXml, delay);
+		const document = getActiveSerializedDocument();
+		try {
+			const prepared = prepareModify(editor, dataSource, arrayXml);
+			if (projectOperation(dataSource, document, toProjectionOperation(operation), prepared.readXml)) applyPreparedModify(editor, prepared);
+		} catch (error) {
+			logger.error("❌ Failed to apply LiteXML modification:", error);
+		}
 		return false;
 	}, COMMAND_PRIORITY_EDITOR), editor.registerCommand(LITEXML_REMOVE_COMMAND, (payload) => {
 		const { id, delay } = payload;
-		const key = charToId(id);
 		if (!delay) {
-			handleRemove(editor, key, delay);
+			handleRemove(editor, id, delay);
 			return false;
 		}
 		const operation = {
 			action: "remove",
 			id
 		};
-		if (projectOperation(dataSource, getKernelFromEditor(editor).getDocument("json"), toProjectionOperation(operation))) handleRemove(editor, key, delay);
+		if (projectOperation(dataSource, getActiveSerializedDocument(), toProjectionOperation(operation))) handleRemove(editor, id, delay);
 		return false;
 	}, COMMAND_PRIORITY_EDITOR), editor.registerCommand(LITEXML_INSERT_COMMAND, (payload) => {
 		if (!payload.delay) {
 			handleInsert(editor, payload, dataSource);
 			return false;
 		}
-		if (projectOperation(dataSource, getKernelFromEditor(editor).getDocument("json"), toProjectionOperation({
+		if (projectOperation(dataSource, getActiveSerializedDocument(), toProjectionOperation({
 			action: "insert",
 			...payload
 		}))) handleInsert(editor, payload, dataSource);
 		return false;
 	}, COMMAND_PRIORITY_EDITOR));
 }
-function handleModify(editor, dataSource, arrayXml, delay) {
-	if (delay) editor.update(() => {
-		const modifyBlockNodes = /* @__PURE__ */ new Set();
-		const diffNodeMap = /* @__PURE__ */ new Map();
-		arrayXml.forEach((xml) => {
-			dataSource.readLiteXMLToInode(xml).root.children.forEach((child) => {
-				try {
-					const { oldNode, newNode } = tryParseChild(child, editor);
-					if (oldNode && newNode) handleReplaceForApplyDelay(oldNode, newNode, modifyBlockNodes, diffNodeMap, editor);
-					else logger.warn(`⚠️ Node with key ${child.id} not found for diffing.`);
-				} catch (error) {
-					logger.error("❌ Error replacing node:", error);
-				}
-			});
-		});
-		finalizeModifyBlocks(modifyBlockNodes, diffNodeMap, editor);
-	});
-	else editor.update(() => {
-		arrayXml.forEach((xml) => {
-			const inode = dataSource.readLiteXMLToInode(xml);
-			let prevNode = null;
-			inode.root.children.forEach((child) => {
-				try {
-					const { oldNode, newNode } = tryParseChild(child, editor);
-					if (oldNode && newNode) prevNode = oldNode.replace(newNode, false);
-					else if (newNode) {
-						if (prevNode) {
-							if (!newNode.isInline()) {
-								const prevBlock = $closest(prevNode, (node) => node.isInline() === false);
-								if (prevBlock) prevNode = prevBlock.insertAfter(newNode);
-								else {
-									$insertNodes([newNode]);
-									prevNode = newNode;
-								}
-							} else prevNode = prevNode.insertAfter(newNode);
-						} else $insertNodes([newNode]);
+function applyPreparedModify(editor, prepared) {
+	const modifyBlockNodes = /* @__PURE__ */ new Set();
+	const diffNodeMap = /* @__PURE__ */ new Map();
+	for (const { oldNode, newNode } of prepared.pairs) if (!handleReplaceForApplyDelay(oldNode, newNode, modifyBlockNodes, diffNodeMap, editor)) throw new Error(`Node id "${$getNodeId(oldNode)}" could not be modified.`);
+	finalizeModifyBlocks(modifyBlockNodes, diffNodeMap, editor);
+	return prepared.pairs.length > 0;
+}
+function handleModify(editor, dataSource, arrayXml) {
+	let applied = false;
+	arrayXml.forEach((xml) => {
+		const inode = dataSource.readLiteXMLToInode(xml);
+		let prevNode = null;
+		inode.root.children.forEach((child) => {
+			try {
+				const { oldNode, newNode } = tryParseChild(child, editor);
+				if (oldNode && newNode) {
+					prevNode = oldNode.replace(newNode, false);
+					applied = true;
+				} else if (newNode) {
+					if (prevNode) {
+						if (!newNode.isInline()) {
+							const prevBlock = $closest(prevNode, (node) => node.isInline() === false);
+							if (prevBlock) prevNode = prevBlock.insertAfter(newNode);
+							else {
+								$insertNodes([newNode]);
+								prevNode = newNode;
+							}
+							applied = true;
+						} else {
+							prevNode = prevNode.insertAfter(newNode);
+							applied = true;
+						}
+					} else {
+						$insertNodes([newNode]);
+						applied = true;
 					}
-				} catch (error) {
-					logger.error("❌ Error replacing node:", error);
 				}
-			});
+			} catch (error) {
+				logger.error("❌ Error replacing node:", error);
+			}
 		});
 	});
+	return applied;
 }
-function handleRemove(editor, key, delay) {
-	editor.update(() => {
-		const node = $getNodeByKey(key);
-		if (!node) return;
-		if (!delay) {
-			if ($isTableCellNode(node)) {
-				const table = $getTableForCell(node);
-				const columnIndex = $getTableCellColumnIndex(node);
-				const span = node.getColSpan();
-				node.remove();
-				if (table && columnIndex >= 0) $shrinkTableWidthsAfterCellRemoval(table, columnIndex, span);
-				return;
-			}
-			node.remove();
-			return;
-		}
+function handleRemove(editor, nodeId, delay) {
+	let applied = false;
+	const node = $findNodeById(nodeId);
+	if (!node) return false;
+	if (!delay) {
 		if ($isTableCellNode(node)) {
 			const table = $getTableForCell(node);
 			const columnIndex = $getTableCellColumnIndex(node);
-			if (!table || columnIndex < 0) {
-				logger.error(`❌ Table cell ${node.getKey()} is not attached to a valid table row.`);
-				return;
-			}
-			const changeId = `${table.getKey()}:column:${columnIndex}`;
-			node.replace($createTableCellDiffFromCell(editor, node, "remove", changeId), false);
-			return;
+			const span = node.getColSpan();
+			node.remove();
+			applied = true;
+			if (table && columnIndex >= 0) $shrinkTableWidthsAfterCellRemoval(table, columnIndex, span);
+			return true;
 		}
-		if ($isTableRowNode(node) && $isTableNode(node.getParent())) {
-			node.replace($createTableRowDiffFromRow(editor, node, "remove"), false);
-			return;
+		node.remove();
+		applied = true;
+		return true;
+	}
+	if ($isTableCellNode(node)) {
+		const table = $getTableForCell(node);
+		const columnIndex = $getTableCellColumnIndex(node);
+		if (!table || columnIndex < 0) {
+			logger.error(`❌ Table cell ${node.getKey()} is not attached to a valid table row.`);
+			return false;
 		}
-		if (node.isInline() === false) {
-			const originDiffNode = $closest(node, (node) => node.getType() === DiffNode.getType());
-			if (originDiffNode) {
-				switch (originDiffNode.diffType) {
-					case "add":
-						originDiffNode.remove();
-						return;
-					case "modify": {
-						const children = originDiffNode.getChildren();
-						const newDiff = $createDiffNode("remove");
-						const before = children[0];
-						newDiff.append(...$isDiffContentNode(before) ? before.getChildren() : [before]);
-						originDiffNode.replace(newDiff, false);
-						return;
-					}
-					case "listItemModify": {
-						const children = originDiffNode.getChildren();
-						originDiffNode.replace(children[0], false).selectEnd();
-						return;
-					}
+		const changeId = `${table.getKey()}:column:${columnIndex}`;
+		node.replace($createTableCellDiffFromCell(editor, node, "remove", changeId), false);
+		applied = true;
+		return true;
+	}
+	if ($isTableRowNode(node) && $isTableNode(node.getParent())) {
+		node.replace($createTableRowDiffFromRow(editor, node, "remove"), false);
+		applied = true;
+		return true;
+	}
+	if (node.isInline() === false) {
+		const originDiffNode = $closest(node, (node) => node.getType() === DiffNode.getType());
+		if (originDiffNode) {
+			switch (originDiffNode.diffType) {
+				case "add":
+					originDiffNode.remove();
+					applied = true;
+					return true;
+				case "modify": {
+					const children = originDiffNode.getChildren();
+					const newDiff = $createDiffNode("remove");
+					const before = children[0];
+					newDiff.append(...$isDiffContentNode(before) ? before.getChildren() : [before]);
+					originDiffNode.replace(newDiff, false);
+					applied = true;
+					return true;
+				}
+				case "listItemModify": {
+					const children = originDiffNode.getChildren();
+					originDiffNode.replace(children[0], false).selectEnd();
+					applied = true;
+					return true;
 				}
-				return;
-			}
-			if ($isListItemNode(node)) {
-				const diffNode = $createDiffNode("listItemRemove");
-				node.getChildren().forEach((child) => {
-					diffNode.append($cloneNode(child, editor));
-				});
-				node.clear();
-				node.append(diffNode);
-			} else {
-				const diffNode = $createDiffNode("remove");
-				diffNode.append($cloneNode(node, editor));
-				node.replace(diffNode, false);
-			}
-		} else {
-			const oldBlock = $closest(node, (node) => node.isInline() === false);
-			if (!oldBlock) throw new Error("Old block node not found for removal.");
-			if ($closest(node, (node) => node.getType() === DiffNode.getType())) {
-				node.remove();
-				return;
 			}
-			wrapBlockModify(oldBlock, editor, () => {
-				node.remove();
+			return false;
+		}
+		if ($isListItemNode(node)) {
+			const diffNode = $createDiffNode("listItemRemove");
+			node.getChildren().forEach((child) => {
+				diffNode.append($cloneNode(child, editor));
 			});
+			node.clear();
+			node.append(diffNode);
+			applied = true;
+		} else {
+			const diffNode = $createDiffNode("remove");
+			diffNode.append($cloneNode(node, editor));
+			node.replace(diffNode, false);
+			applied = true;
 		}
-	});
+	} else {
+		const oldBlock = $closest(node, (node) => node.isInline() === false);
+		if (!oldBlock) throw new Error("Old block node not found for removal.");
+		if ($closest(node, (node) => node.getType() === DiffNode.getType())) {
+			node.remove();
+			applied = true;
+			return true;
+		}
+		wrapBlockModify(oldBlock, editor, () => {
+			node.remove();
+		});
+		applied = true;
+	}
+	return applied;
 }
-function handleInsert(editor, payload, dataSource) {
+function handleInsert(editor, payload, dataSource, referenceNodeOverride) {
 	const { litexml, delay } = payload;
 	const isBefore = "beforeId" in payload;
 	const inode = dataSource.readLiteXMLToInode(litexml);
-	editor.update(() => {
-		try {
-			let referenceNode = null;
+	let insertedNodeId = null;
+	try {
+		let referenceNode = referenceNodeOverride || null;
+		if (!referenceNode) {
 			if (isBefore) {
 				if (payload.beforeId === "root") referenceNode = $getRoot().getFirstChild();
-				else referenceNode = $getNodeByKey(charToId(payload.beforeId));
+				else referenceNode = $findNodeById(payload.beforeId);
 			} else if (payload.afterId === "root") referenceNode = $getRoot().getLastChild();
-			else referenceNode = $getNodeByKey(charToId(payload.afterId));
-			if (!referenceNode) throw new Error("Reference node not found for insertion.");
-			const newNodes = inode.root.children.map((child) => $parseSerializedNodeImpl(child, editor));
-			const referencesTableCell = $isTableCellNode(referenceNode);
-			const insertsOnlyTableCells = newNodes.length > 0 && newNodes.every($isTableCellNode);
-			if (referencesTableCell || insertsOnlyTableCells) {
-				if (!referencesTableCell || !insertsOnlyTableCells) {
-					logger.error("❌ Table cells can only be inserted next to another cell in the same row.");
-					return;
-				}
-				const cellReference = referenceNode;
-				const table = $getTableForCell(cellReference);
-				const referenceIndex = $getTableCellColumnIndex(cellReference);
-				if (!table || referenceIndex < 0) {
-					logger.error("❌ Table cell insertion requires a valid table parent.");
-					return;
-				}
-				const rowWidthBefore = $getLogicalRowWidth(cellReference);
-				const insertionIndex = isBefore ? referenceIndex : referenceIndex + cellReference.getColSpan();
-				const insertedSpan = newNodes.reduce((total, node) => total + ($isTableCellNode(node) ? node.getColSpan() : 0), 0);
-				$updateTableWidthsForCellInsertion(table, rowWidthBefore, insertionIndex, insertedSpan);
-				let spanOffset = 0;
-				const cells = newNodes.map((node) => {
-					const result = delay ? $createTableCellDiffFromCell(editor, node, "add", `${table.getKey()}:column:${insertionIndex + spanOffset}`) : node;
-					spanOffset += node.getColSpan();
-					return result;
-				});
-				if (isBefore) cells.reverse().forEach((cell) => {
-					referenceNode = referenceNode.insertBefore(cell);
-				});
-				else cells.forEach((cell) => {
-					referenceNode = referenceNode.insertAfter(cell);
-				});
-				return;
+			else referenceNode = $findNodeById(payload.afterId);
+		}
+		if (!referenceNode) throw new Error("Reference node not found for insertion.");
+		const newNodes = inode.root.children.map((child) => $parseSerializedNodeImpl(child, editor));
+		$ensureUniqueNodeIds(newNodes);
+		insertedNodeId = newNodes.length ? $getNodeId(newNodes.at(-1)) || null : null;
+		const referencesTableCell = $isTableCellNode(referenceNode);
+		const insertsOnlyTableCells = newNodes.length > 0 && newNodes.every($isTableCellNode);
+		if (referencesTableCell || insertsOnlyTableCells) {
+			if (!referencesTableCell || !insertsOnlyTableCells) {
+				logger.error("❌ Table cells can only be inserted next to another cell in the same row.");
+				return null;
 			}
-			if (!delay) {
-				if (isBefore) newNodes.reverse().forEach((node) => {
-					referenceNode = referenceNode.insertBefore(node);
-				});
-				else newNodes.forEach((node) => {
-					if (referenceNode) referenceNode = referenceNode.insertAfter(node);
-				});
-				return;
+			const cellReference = referenceNode;
+			const table = $getTableForCell(cellReference);
+			const referenceIndex = $getTableCellColumnIndex(cellReference);
+			if (!table || referenceIndex < 0) {
+				logger.error("❌ Table cell insertion requires a valid table parent.");
+				return null;
 			}
-			const referencesTableRow = $isTableRowNode(referenceNode);
-			const insertsOnlyTableRows = newNodes.every($isTableRowNode);
-			if (referencesTableRow || insertsOnlyTableRows) {
-				if (!referencesTableRow || !insertsOnlyTableRows || !$isTableNode(referenceNode.getParent())) {
-					logger.error("❌ Table rows can only be inserted next to another row in the same table.");
-					return;
-				}
-				if (isBefore) newNodes.reverse().forEach((node) => {
-					if (!$isTableRowNode(node)) return;
-					const diffRow = $createTableRowDiffFromRow(editor, node, "add");
-					referenceNode = referenceNode.insertBefore(diffRow);
-				});
-				else newNodes.forEach((node) => {
-					if (!$isTableRowNode(node)) return;
-					const diffRow = $createTableRowDiffFromRow(editor, node, "add");
-					referenceNode = referenceNode.insertAfter(diffRow);
-				});
-				return;
+			const rowWidthBefore = $getLogicalRowWidth(cellReference);
+			const insertionIndex = isBefore ? referenceIndex : referenceIndex + cellReference.getColSpan();
+			const insertedSpan = newNodes.reduce((total, node) => total + ($isTableCellNode(node) ? node.getColSpan() : 0), 0);
+			$updateTableWidthsForCellInsertion(table, rowWidthBefore, insertionIndex, insertedSpan);
+			let spanOffset = 0;
+			const cells = newNodes.map((node) => {
+				const result = delay ? $createTableCellDiffFromCell(editor, node, "add", `${table.getKey()}:column:${insertionIndex + spanOffset}`) : node;
+				spanOffset += node.getColSpan();
+				return result;
+			});
+			if (isBefore) cells.reverse().forEach((cell) => {
+				referenceNode = referenceNode.insertBefore(cell);
+			});
+			else cells.forEach((cell) => {
+				referenceNode = referenceNode.insertAfter(cell);
+			});
+			return insertedNodeId;
+		}
+		if (!delay) {
+			if (isBefore) newNodes.reverse().forEach((node) => {
+				referenceNode = referenceNode.insertBefore(node);
+			});
+			else newNodes.forEach((node) => {
+				if (referenceNode) referenceNode = referenceNode.insertAfter(node);
+			});
+			return insertedNodeId;
+		}
+		const referencesTableRow = $isTableRowNode(referenceNode);
+		const insertsOnlyTableRows = newNodes.every($isTableRowNode);
+		if (referencesTableRow || insertsOnlyTableRows) {
+			if (!referencesTableRow || !insertsOnlyTableRows || !$isTableNode(referenceNode.getParent())) {
+				logger.error("❌ Table rows can only be inserted next to another row in the same table.");
+				return null;
 			}
-			if (isBefore) {
-				if (referenceNode.isInline() === false) {
-					const originDiffNode = $closest(referenceNode, (node) => node.getType() === DiffNode.getType());
-					if (originDiffNode) referenceNode = originDiffNode;
-					newNodes.map((node) => {
-						if ($isListItemNode(node)) {
-							const diffNode = $createDiffNode("listItemAdd");
-							node.getChildren().forEach((child) => diffNode.append(child));
-							return node.append(diffNode);
-						}
-						const diffNode = $createDiffNode("add");
-						diffNode.append(node);
-						return diffNode;
-					}).reverse().forEach((diffNode) => {
-						if (referenceNode) referenceNode = referenceNode.insertBefore(diffNode);
-					});
-				} else {
-					const refBlock = $closest(referenceNode, (node) => node.isInline() === false);
-					if (!refBlock) throw new Error("Reference block node not found for insertion.");
-					if ($closest(referenceNode, (node) => node.getType() === DiffNode.getType())) newNodes.forEach((node) => {
-						if (referenceNode) referenceNode = referenceNode.insertBefore(node);
-					});
-					else wrapBlockModify(refBlock, editor, () => {
-						newNodes.forEach((node) => {
-							if (referenceNode) referenceNode = referenceNode.insertBefore(node);
-						});
-					});
-				}
-			} else if (referenceNode.isInline() === false) {
+			if (isBefore) newNodes.reverse().forEach((node) => {
+				if (!$isTableRowNode(node)) return;
+				const diffRow = $createTableRowDiffFromRow(editor, node, "add");
+				referenceNode = referenceNode.insertBefore(diffRow);
+			});
+			else newNodes.forEach((node) => {
+				if (!$isTableRowNode(node)) return;
+				const diffRow = $createTableRowDiffFromRow(editor, node, "add");
+				referenceNode = referenceNode.insertAfter(diffRow);
+			});
+			return insertedNodeId;
+		}
+		if (isBefore) {
+			if (referenceNode.isInline() === false) {
 				const originDiffNode = $closest(referenceNode, (node) => node.getType() === DiffNode.getType());
 				if (originDiffNode) referenceNode = originDiffNode;
-				newNodes.forEach((node) => {
-					if (referenceNode) {
-						if ($isListItemNode(node)) {
-							const diffNode = $createDiffNode("listItemAdd");
-							node.getChildren().forEach((child) => {
-								diffNode.append(child);
-							});
-							node.append(diffNode);
-							referenceNode = referenceNode.insertAfter(node);
-						} else {
-							const diffNode = $createDiffNode("add");
-							diffNode.append(node);
-							referenceNode = referenceNode.insertAfter(diffNode);
-						}
+				newNodes.map((node) => {
+					if ($isListItemNode(node)) {
+						const diffNode = $createDiffNode("listItemAdd");
+						node.getChildren().forEach((child) => diffNode.append(child));
+						return node.append(diffNode);
 					}
+					const diffNode = $createDiffNode("add");
+					diffNode.append(node);
+					return diffNode;
+				}).reverse().forEach((diffNode) => {
+					if (referenceNode) referenceNode = referenceNode.insertBefore(diffNode);
 				});
 			} else {
 				const refBlock = $closest(referenceNode, (node) => node.isInline() === false);
 				if (!refBlock) throw new Error("Reference block node not found for insertion.");
 				if ($closest(referenceNode, (node) => node.getType() === DiffNode.getType())) newNodes.forEach((node) => {
-					if (referenceNode) referenceNode = referenceNode.insertAfter(node);
+					if (referenceNode) referenceNode = referenceNode.insertBefore(node);
 				});
 				else wrapBlockModify(refBlock, editor, () => {
 					newNodes.forEach((node) => {
-						if (referenceNode) referenceNode = referenceNode.insertAfter(node);
+						if (referenceNode) referenceNode = referenceNode.insertBefore(node);
 					});
 				});
 			}
-		} catch (error) {
-			logger.error("❌ Error inserting node:", error);
+		} else if (referenceNode.isInline() === false) {
+			const originDiffNode = $closest(referenceNode, (node) => node.getType() === DiffNode.getType());
+			if (originDiffNode) referenceNode = originDiffNode;
+			newNodes.forEach((node) => {
+				if (referenceNode) {
+					if ($isListItemNode(node)) {
+						const diffNode = $createDiffNode("listItemAdd");
+						node.getChildren().forEach((child) => {
+							diffNode.append(child);
+						});
+						node.append(diffNode);
+						referenceNode = referenceNode.insertAfter(node);
+					} else {
+						const diffNode = $createDiffNode("add");
+						diffNode.append(node);
+						referenceNode = referenceNode.insertAfter(diffNode);
+					}
+				}
+			});
+		} else {
+			const refBlock = $closest(referenceNode, (node) => node.isInline() === false);
+			if (!refBlock) throw new Error("Reference block node not found for insertion.");
+			if ($closest(referenceNode, (node) => node.getType() === DiffNode.getType())) newNodes.forEach((node) => {
+				if (referenceNode) referenceNode = referenceNode.insertAfter(node);
+			});
+			else wrapBlockModify(refBlock, editor, () => {
+				newNodes.forEach((node) => {
+					if (referenceNode) referenceNode = referenceNode.insertAfter(node);
+				});
+			});
 		}
-	});
+	} catch (error) {
+		logger.error("❌ Error inserting node:", error);
+		insertedNodeId = null;
+	}
+	return insertedNodeId;
 }
 //#endregion
-export { LITEXML_APPLY_COMMAND, LITEXML_INSERT_COMMAND, LITEXML_MODIFY_COMMAND, LITEXML_REMOVE_COMMAND, registerLiteXMLCommand };
+export { LITEXML_APPLY_COMMAND, LITEXML_INSERT_COMMAND, LITEXML_MODIFY_COMMAND, LITEXML_MODIFY_WITH_RESULTS_COMMAND, LITEXML_REMOVE_COMMAND, registerLiteXMLCommand };