@lobehub/editor 4.29.0 → 4.29.2

package/es/plugins/litexml/command/symbols.d.ts

@@ -22,21 +22,32 @@ declare enum DiffAction {
   Reject = 0,
   Accept = 1
 }
-declare const LITEXML_MODIFY_COMMAND: import("lexical").LexicalCommand<({
-  action: "insert";
+type LiteXmlModifyOperation = {
+  action: 'insert';
   beforeId: string;
   litexml: string;
 } | {
-  action: "insert";
+  action: 'insert';
   afterId: string;
   litexml: string;
 } | {
-  action: "remove";
+  action: 'remove';
   id: string;
 } | {
-  action: "modify";
+  action: 'modify';
   litexml: string | string[];
-})[]>;
+};
+interface LiteXmlOperationResult {
+  action: LiteXmlModifyOperation['action'];
+  index: number;
+  reason?: string;
+  status: 'applied' | 'failed';
+}
+declare const LITEXML_MODIFY_COMMAND: import("lexical").LexicalCommand<LiteXmlModifyOperation[]>;
+declare const LITEXML_MODIFY_WITH_RESULTS_COMMAND: import("lexical").LexicalCommand<{
+  onResults: (results: LiteXmlOperationResult[]) => void;
+  operations: ReadonlyArray<LiteXmlModifyOperation>;
+}>;
 declare const LITEXML_APPLY_COMMAND: import("lexical").LexicalCommand<{
   delay?: boolean;
   litexml: string | string[];
@@ -62,4 +73,4 @@ declare const LITEXML_DIFFNODE_ALL_COMMAND: import("lexical").LexicalCommand<{
   action: DiffAction;
 }>;
 //#endregion
-export { DiffAction, LITEXML_APPLY_COMMAND, LITEXML_DIFFNODE_ALL_COMMAND, LITEXML_DIFFNODE_COMMAND, LITEXML_INSERT_COMMAND, LITEXML_MODIFY_COMMAND, LITEXML_REMOVE_COMMAND };
+export { DiffAction, LITEXML_APPLY_COMMAND, LITEXML_DIFFNODE_ALL_COMMAND, LITEXML_DIFFNODE_COMMAND, LITEXML_INSERT_COMMAND, LITEXML_MODIFY_COMMAND, LITEXML_MODIFY_WITH_RESULTS_COMMAND, LITEXML_REMOVE_COMMAND, LiteXmlModifyOperation, LiteXmlOperationResult };

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

@@ -25,10 +25,11 @@ let DiffAction = /* @__PURE__ */ function(DiffAction) {
 	return DiffAction;
 }({});
 const LITEXML_MODIFY_COMMAND = createCommand("LITEXML_MODIFY_COMMAND");
+const LITEXML_MODIFY_WITH_RESULTS_COMMAND = createCommand("LITEXML_MODIFY_WITH_RESULTS_COMMAND");
 const LITEXML_APPLY_COMMAND = createCommand("LITEXML_APPLY_COMMAND");
 const LITEXML_REMOVE_COMMAND = createCommand("LITEXML_REMOVE_COMMAND");
 const LITEXML_INSERT_COMMAND = createCommand("LITEXML_INSERT_COMMAND");
 const LITEXML_DIFFNODE_COMMAND = createCommand("LITEXML_DIFFNODE_COMMAND");
 const LITEXML_DIFFNODE_ALL_COMMAND = createCommand("LITEXML_DIFFNODE_ALL_COMMAND");
 //#endregion
-export { DiffAction, LITEXML_APPLY_COMMAND, LITEXML_DIFFNODE_ALL_COMMAND, LITEXML_DIFFNODE_COMMAND, LITEXML_INSERT_COMMAND, LITEXML_MODIFY_COMMAND, LITEXML_REMOVE_COMMAND };
+export { DiffAction, LITEXML_APPLY_COMMAND, LITEXML_DIFFNODE_ALL_COMMAND, LITEXML_DIFFNODE_COMMAND, LITEXML_INSERT_COMMAND, LITEXML_MODIFY_COMMAND, LITEXML_MODIFY_WITH_RESULTS_COMMAND, LITEXML_REMOVE_COMMAND };

package/es/plugins/litexml/data-source/litexml-data-source.js

@@ -1,13 +1,14 @@
 import { createDebugLogger, init_debug } from "../../../utils/debug.js";
 import { INodeHelper, init_helper } from "../../../editor-kernel/inode/helper.js";
+import { $getNodeId, $normalizeNodeIds, init_node_id } from "../../common/node/node-id.js";
 import DataSource from "../../../editor-kernel/data-source.js";
-import { $parseSerializedNodeImpl, charToId, idToChar } from "../utils/index.js";
 import { INodeService } from "../../inode/service/index.js";
 import { LitexmlService } from "../service/litexml-service.js";
 import { $getRoot, $getSelection, $isElementNode, $isRangeSelection } from "lexical";
 import { DOMParser } from "@xmldom/xmldom";
 //#region src/plugins/litexml/data-source/litexml-data-source.ts
 init_helper();
+init_node_id();
 init_debug();
 const logger = createDebugLogger("plugin", "litexml");
 var IXmlWriterContext = class {
@@ -48,13 +49,8 @@ var LitexmlDataSource = class extends DataSource {
 	read(editor, data) {
 		try {
 			const inode = this.readLiteXMLToInode(data);
-			const newState = editor.parseEditorState({ root: INodeHelper.createRootNode() }, (state) => {
-				try {
-					const root = $parseSerializedNodeImpl(inode.root, editor, true, state);
-					state._nodeMap.set(root.getKey(), root);
-				} catch (error) {
-					console.error(error);
-				}
+			const newState = editor.parseEditorState(inode, () => {
+				$normalizeNodeIds($getRoot());
 			});
 			editor.setEditorState(newState);
 		} catch (error) {
@@ -120,6 +116,22 @@ var LitexmlDataSource = class extends DataSource {
 	processXMLElement(xmlElement, parentNode) {
 		const tagName = xmlElement.tagName.toLowerCase();
 		const customReaders = this.litexmlService.getXMLReaders();
+		const publicId = xmlElement.getAttribute("id") || void 0;
+		const attachPublicId = (node, id = publicId) => {
+			if (!node || !id) return;
+			node.id = id;
+			node.$ = {
+				...node.$,
+				properties: {
+					...node.$?.properties,
+					nodeId: id
+				}
+			};
+		};
+		const append = (node) => {
+			attachPublicId(node);
+			INodeHelper.appendChild(parentNode, node);
+		};
 		if (customReaders[tagName]) {
 			const readerOrReaders = customReaders[tagName];
 			const readers = Array.isArray(readerOrReaders) ? readerOrReaders : [readerOrReaders];
@@ -129,16 +141,9 @@ var LitexmlDataSource = class extends DataSource {
 				const result = reader(xmlElement, children);
 				if (result !== false) {
 					if (Array.isArray(result)) {
-						if (result.length > 0) {
-							const attrId = xmlElement.getAttribute("id");
-							result[0].id = attrId ? charToId(attrId) : void 0;
-						}
+						if (result.length > 0) attachPublicId(result[0]);
 						INodeHelper.appendChild(parentNode, ...result);
-					} else if (result) {
-						const attrId = xmlElement.getAttribute("id");
-						result.id = attrId ? charToId(attrId) : void 0;
-						INodeHelper.appendChild(parentNode, result);
-					}
+					} else if (result) append(result);
 					return;
 				}
 			}
@@ -148,7 +153,7 @@ var LitexmlDataSource = class extends DataSource {
 			case "paragraph": {
 				const paragraph = INodeHelper.createParagraph();
 				this.processXMLChildren(xmlElement, paragraph);
-				INodeHelper.appendChild(parentNode, paragraph);
+				append(paragraph);
 				break;
 			}
 			case "h1":
@@ -163,7 +168,7 @@ var LitexmlDataSource = class extends DataSource {
 					tag: `h${level}`
 				});
 				this.processXMLChildren(xmlElement, heading);
-				INodeHelper.appendChild(parentNode, heading);
+				append(heading);
 				break;
 			}
 			case "ul":
@@ -175,6 +180,7 @@ var LitexmlDataSource = class extends DataSource {
 						children: [],
 						value: 1
 					});
+					attachPublicId(listItem, child.getAttribute("id") || void 0);
 					this.processXMLChildren(child, listItem);
 					INodeHelper.appendChild(parentNode, listItem);
 				});
@@ -182,20 +188,15 @@ var LitexmlDataSource = class extends DataSource {
 			case "blockquote": {
 				const quote = INodeHelper.createElementNode("quote", { children: [] });
 				this.processXMLChildren(xmlElement, quote);
-				INodeHelper.appendChild(parentNode, quote);
+				append(quote);
 				break;
 			}
-			case "code": {
-				const codeNode = INodeHelper.createElementNode("codeInline", { children: [INodeHelper.createTextNode(xmlElement.textContent || "")] });
-				INodeHelper.appendChild(parentNode, codeNode);
+			case "code":
+				append(INodeHelper.createElementNode("codeInline", { children: [INodeHelper.createTextNode(xmlElement.textContent || "")] }));
 				break;
-			}
 			case "text": {
 				const textContent = xmlElement.textContent || "";
-				if (textContent) {
-					const textNode = INodeHelper.createTextNode(textContent);
-					INodeHelper.appendChild(parentNode, textNode);
-				}
+				if (textContent) append(INodeHelper.createTextNode(textContent));
 				break;
 			}
 			default: this.processXMLChildren(xmlElement, parentNode);
@@ -246,10 +247,12 @@ var LitexmlDataSource = class extends DataSource {
 						lines.push(...handled.lines);
 						return;
 					}
-					const attrs = this.buildXMLAttributes({
-						id: idToChar(node.getKey()),
+					const attributes = {
+						id: $getNodeId(node),
 						...handled.attributes
-					});
+					};
+					attributes.id = $getNodeId(node);
+					const attrs = this.buildXMLAttributes(attributes);
 					const openTag = `${indentStr}<${handled.tagName}${attrs}>`;
 					const closeTag = `</${handled.tagName}>`;
 					if (handled.textContent) lines.push(`${openTag}${handled.textContent}${closeTag}`);
@@ -281,7 +284,7 @@ var LitexmlDataSource = class extends DataSource {
 	* Escape XML special characters
 	*/
 	escapeXML(text) {
-		return text.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;").replaceAll("'", "&apos;");
+		return text.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;").replaceAll("'", "&apos;").replaceAll("	", "&#9;").replaceAll("\n", "&#10;").replaceAll("\r", "&#13;");
 	}
 };
 //#endregion

package/es/plugins/litexml/diff-validation.js

@@ -1,3 +1,4 @@
+import { getLiteXmlIdentityProjection } from "./node/identity-policy.js";
 //#region src/plugins/litexml/diff-validation.ts
 const ACTIONABLE_DIFF_TYPES = /* @__PURE__ */ new Set([
 	"add",
@@ -9,6 +10,11 @@ const ACTIONABLE_DIFF_TYPES = /* @__PURE__ */ new Set([
 ]);
 const isActionableDiff = (node) => node?.type === "diff" && ACTIONABLE_DIFF_TYPES.has(node.diffType || "");
 const isElementNode = (node) => Array.isArray(node.children);
+const getNodeId = (node) => {
+	if (typeof node.id === "string" && node.id.length > 0) return node.id;
+	const properties = node.$?.properties;
+	return typeof properties?.nodeId === "string" ? properties.nodeId : void 0;
+};
 const cloneNode = (node) => structuredClone(node);
 function hasActionableDiffDescendant(node) {
 	return (node.children || []).some((child) => isActionableDiff(child) || hasActionableDiffDescendant(child));
@@ -34,10 +40,10 @@ function collectIllegalNestedDiffPaths(root) {
 		}
 		if (!isElementNode(node)) return;
 		node.children?.forEach((child) => {
-			visit(child, [...ancestors, node], `${path}/${child.id || child.type || "node"}`);
+			visit(child, [...ancestors, node], `${path}/${getNodeId(child) || child.type || "node"}`);
 		});
 	};
-	visit(root, [], root.id || root.type || "root");
+	visit(root, [], getNodeId(root) || root.type || "root");
 	return violations;
 }
 function findNewIllegalDiffPaths(previous, projected) {
@@ -54,25 +60,52 @@ function findNewIllegalDiffPaths(previous, projected) {
 	});
 	return newPaths;
 }
-function findNodeLocation(root, id, ancestors = []) {
-	if (root.id === id) return {
+function findActiveNodeLocation(root, id, ancestors = []) {
+	const projection = getLiteXmlIdentityProjection({
+		diffType: root.diffType,
+		firstChildDiffType: root.children?.[0]?.diffType,
+		firstChildType: root.children?.[0]?.type,
+		type: root.type
+	});
+	if (projection === "hidden") return null;
+	if (projection === "content" && getNodeId(root) === id) {
+		const parent = ancestors.at(-1) || null;
+		return {
+			ancestors,
+			index: parent ? (parent.children || []).indexOf(root) : -1,
+			node: root,
+			parent
+		};
+	}
+	const activeChildren = typeof projection === "object" ? root.children?.[projection.childIndex] ? [root.children[projection.childIndex]] : [] : root.children || [];
+	for (const child of activeChildren) {
+		const nested = findActiveNodeLocation(child, id, [...ancestors, root]);
+		if (nested) return nested;
+	}
+	return null;
+}
+function findNodeLocationByNode(root, target, ancestors = []) {
+	if (root === target) return {
 		ancestors,
 		index: -1,
 		node: root,
 		parent: null
 	};
 	for (const [index, child] of (root.children || []).entries()) {
-		if (child.id === id) return {
+		if (child === target) return {
 			ancestors: [...ancestors, root],
 			index,
 			node: child,
 			parent: root
 		};
-		const nested = findNodeLocation(child, id, [...ancestors, root]);
+		const nested = findNodeLocationByNode(child, target, [...ancestors, root]);
 		if (nested) return nested;
 	}
 	return null;
 }
+function hasActiveLiteXmlNodeId(root, id) {
+	return findActiveNodeLocation(root, id) !== null;
+}
 function replaceNode(location, replacements) {
 	if (!location.parent || location.index < 0) return;
 	location.parent.children?.splice(location.index, 1, ...replacements);
@@ -92,8 +125,9 @@ function createDiffContent(side, children) {
 	};
 }
 function projectModifyTarget(root, incoming) {
-	if (!incoming.id) return;
-	const location = findNodeLocation(root, incoming.id);
+	const incomingId = getNodeId(incoming);
+	if (!incomingId) return;
+	const location = findActiveNodeLocation(root, incomingId);
 	if (!location) return;
 	const target = location.node;
 	const next = cloneNode(incoming);
@@ -127,10 +161,30 @@ function projectModifyTarget(root, incoming) {
 		replaceNode(location, [next]);
 		return;
 	}
+	if (target.type === "listitem") {
+		const existingDiff = (target.children || []).find((child) => child.type === "diff");
+		if (existingDiff?.diffType === "listItemModify") {
+			const after = existingDiff.children?.[1];
+			if (after) after.children = cloneNode(next.children || []);
+			return;
+		}
+		if (existingDiff?.diffType === "listItemAdd") {
+			existingDiff.children = cloneNode(next.children || []);
+			return;
+		}
+		target.children = [createDiff("listItemModify", [{
+			children: cloneNode(target.children || []),
+			type: "paragraph"
+		}, {
+			children: cloneNode(next.children || []),
+			type: "paragraph"
+		}])];
+		return;
+	}
 	replaceNode(location, [createDiff("modify", [cloneNode(target), next])]);
 }
 function projectRemoveTarget(root, id) {
-	const location = findNodeLocation(root, id);
+	const location = findActiveNodeLocation(root, id);
 	if (!location) return;
 	if (location.ancestors.some(isActionableDiff)) {
 		replaceNode(location, []);
@@ -157,13 +211,13 @@ function projectRemoveTarget(root, id) {
 }
 function projectInsert(root, operation, readXml) {
 	const referenceId = "beforeId" in operation ? operation.beforeId : operation.afterId;
-	const reference = referenceId === "root" ? null : findNodeLocation(root, referenceId)?.node || null;
+	const reference = referenceId === "root" ? null : findActiveNodeLocation(root, referenceId)?.node || null;
 	const location = referenceId === "root" ? {
 		ancestors: [root],
 		index: "beforeId" in operation ? 0 : (root.children || []).length - 1,
 		node: root.children?.[0] || root,
 		parent: root
-	} : findNodeLocation(root, referenceId);
+	} : findActiveNodeLocation(root, referenceId);
 	if (!location) return;
 	const incoming = (readXml(operation.litexml).root?.children || []).map(cloneNode);
 	if (incoming.length === 0 || !location.parent) return;
@@ -202,12 +256,12 @@ function projectInsert(root, operation, readXml) {
 	].includes(node.type || ""));
 	if (!actionableAncestor && blockAncestor && hasActionableDiffDescendant(blockAncestor)) {
 		const wrapped = createDiff("modify", [cloneNode(blockAncestor), cloneNode(blockAncestor)]);
-		const blockLocation = findNodeLocation(root, blockAncestor.id || "");
+		const blockLocation = findNodeLocationByNode(root, blockAncestor);
 		if (blockLocation) replaceNode(blockLocation, [wrapped]);
 		return;
 	}
 	if (actionableAncestor && !isInlineReference) {
-		const originLocation = actionableAncestor.id ? findNodeLocation(root, actionableAncestor.id) : null;
+		const originLocation = findNodeLocationByNode(root, actionableAncestor);
 		if (originLocation?.parent && originLocation.index >= 0) {
 			const originInsertAt = "beforeId" in operation ? originLocation.index : originLocation.index + 1;
 			originLocation.parent.children?.splice(originInsertAt, 0, ...incoming.map((node) => createDiff("add", [node])));
@@ -234,4 +288,4 @@ function projectLiteXmlOperation(document, operation, readXml) {
 	return projected;
 }
 //#endregion
-export { collectIllegalNestedDiffPaths, findNewIllegalDiffPaths, hasActionableDiffDescendant, projectLiteXmlOperation };
+export { collectIllegalNestedDiffPaths, findNewIllegalDiffPaths, hasActionableDiffDescendant, hasActiveLiteXmlNodeId, projectLiteXmlOperation };

package/es/plugins/litexml/index.d.ts

@@ -1,9 +1,9 @@
 import { ILitexmlService, LitexmlService, XMLReaderFunc, XMLReaderRecord, XMLWriterFunc, XMLWriterRecord } from "./service/litexml-service.js";
 import LitexmlDataSource from "./data-source/litexml-data-source.js";
-import { DiffAction, LITEXML_APPLY_COMMAND, LITEXML_DIFFNODE_ALL_COMMAND, LITEXML_DIFFNODE_COMMAND, LITEXML_INSERT_COMMAND, LITEXML_MODIFY_COMMAND, LITEXML_REMOVE_COMMAND } from "./command/symbols.js";
+import { DiffAction, LITEXML_APPLY_COMMAND, LITEXML_DIFFNODE_ALL_COMMAND, LITEXML_DIFFNODE_COMMAND, LITEXML_INSERT_COMMAND, LITEXML_MODIFY_COMMAND, LITEXML_MODIFY_WITH_RESULTS_COMMAND, LITEXML_REMOVE_COMMAND, LiteXmlModifyOperation, LiteXmlOperationResult } from "./command/symbols.js";
 import "./command/index.js";
 import "./command/diffCommand.js";
 import { LitexmlPlugin, LitexmlPluginOptions } from "./plugin/index.js";
 import { ReactLiteXmlPlugin } from "./react/index.js";
 import { useHasDiffNode } from "./react/hooks/useHasDiffNode.js";
-export { DiffAction, ILitexmlService, LITEXML_APPLY_COMMAND, LITEXML_DIFFNODE_ALL_COMMAND, LITEXML_DIFFNODE_COMMAND, LITEXML_INSERT_COMMAND, LITEXML_MODIFY_COMMAND, LITEXML_REMOVE_COMMAND, LitexmlDataSource, LitexmlPlugin, type LitexmlPluginOptions, LitexmlService, ReactLiteXmlPlugin, type XMLReaderFunc, type XMLReaderRecord, type XMLWriterFunc, type XMLWriterRecord, useHasDiffNode };
+export { DiffAction, ILitexmlService, LITEXML_APPLY_COMMAND, LITEXML_DIFFNODE_ALL_COMMAND, LITEXML_DIFFNODE_COMMAND, LITEXML_INSERT_COMMAND, LITEXML_MODIFY_COMMAND, LITEXML_MODIFY_WITH_RESULTS_COMMAND, LITEXML_REMOVE_COMMAND, type LiteXmlModifyOperation, LitexmlDataSource, LitexmlPlugin, type LitexmlPluginOptions, LitexmlService, ReactLiteXmlPlugin, type XMLReaderFunc, type XMLReaderRecord, type XMLWriterFunc, type XMLWriterRecord, useHasDiffNode };

package/es/plugins/litexml/node/identity-policy.js

@@ -0,0 +1,91 @@
+import { $isElementNode } from "lexical";
+//#region src/plugins/litexml/node/identity-policy.ts
+const afterRepresentation = Object.freeze({ childIndex: 1 });
+/** Shared active-view rule for live Lexical nodes and serialized preflight trees. */
+function getLiteXmlIdentityProjection(node) {
+	if (node.type === "root" || node.type === "diff-content") return "container";
+	if (node.type === "diff") {
+		if (node.diffType === "remove" || node.diffType === "listItemRemove") return "hidden";
+		if (node.diffType === "modify" || node.diffType === "listItemModify") return afterRepresentation;
+		return "container";
+	}
+	if ((node.type === "table-cell-diff" || node.type === "table-row-diff") && node.diffType === "remove") return "hidden";
+	if (node.type === "listitem" && node.firstChildType === "diff" && node.firstChildDiffType === "listItemRemove") return "hidden";
+	return "content";
+}
+/** Review containers and the document root are physical structure, not addressable content. */
+function isLiteXmlIdentityNode(type) {
+	return type !== "root" && type !== "diff" && type !== "diff-content";
+}
+function getDiffType(node) {
+	if (!node) return void 0;
+	if ("diffType" in node && typeof node.diffType === "string") return node.diffType;
+	if ("getDiffType" in node && typeof node.getDiffType === "function") return node.getDiffType();
+}
+function getLiveProjection(node) {
+	const type = node.getType();
+	if (type === "root" || type === "diff-content") return "container";
+	if (type !== "diff" && type !== "table-cell-diff" && type !== "table-row-diff" && type !== "listitem") return "content";
+	const firstChild = $isElementNode(node) ? node.getFirstChild() : null;
+	return getLiteXmlIdentityProjection({
+		diffType: getDiffType(node),
+		firstChildDiffType: getDiffType(firstChild),
+		firstChildType: firstChild?.getType(),
+		type
+	});
+}
+function getTableReviewSide(node) {
+	const type = node.getType();
+	if (type !== "table-cell-diff" && type !== "table-row-diff") return null;
+	if (!("getChangeId" in node) || typeof node.getChangeId !== "function") return null;
+	const changeId = node.getChangeId();
+	const side = getDiffType(node);
+	return changeId && side ? {
+		group: `${type}:${changeId}`,
+		side
+	} : null;
+}
+function getReviewSide(node) {
+	const selfSide = getTableReviewSide(node);
+	if (selfSide) return selfSide;
+	let branch = node;
+	for (let parent = node.getParent(); parent; branch = parent, parent = parent.getParent()) {
+		const parentDiffType = getDiffType(parent);
+		if (parent.getType() === "diff") {
+			if (parentDiffType === "modify") {
+				if (branch.getType() === "diff-content" && "side" in branch) return {
+					group: `diff:${parent.getKey()}`,
+					side: String(branch.side)
+				};
+				const branchIndex = parent.getChildren().indexOf(branch);
+				if (branchIndex >= 0 && branchIndex < 2) return {
+					group: `diff:${parent.getKey()}`,
+					side: branchIndex === 0 ? "before" : "after"
+				};
+			}
+			if (parentDiffType === "listItemModify") {
+				const branchIndex = parent.getChildren().indexOf(branch);
+				if (branchIndex >= 0 && branchIndex < 2) return {
+					group: `diff:${parent.getKey()}`,
+					side: branchIndex === 0 ? "before" : "after"
+				};
+			}
+		}
+		const tableSide = getTableReviewSide(parent);
+		if (tableSide) return tableSide;
+	}
+	return null;
+}
+const liteXmlIdentityPolicy = {
+	canShareId(left, right) {
+		const leftSide = getReviewSide(left);
+		const rightSide = getReviewSide(right);
+		return Boolean(leftSide && rightSide && leftSide.group === rightSide.group && leftSide.side !== rightSide.side);
+	},
+	isIdentityNode(node) {
+		return isLiteXmlIdentityNode(node.getType());
+	},
+	project: getLiveProjection
+};
+//#endregion
+export { getLiteXmlIdentityProjection, isLiteXmlIdentityNode, liteXmlIdentityPolicy };

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

@@ -1,4 +1,6 @@
+import { init_node_identity_policy, registerNodeIdentityPolicy } from "../../common/node/node-identity-policy.js";
 import { KernelPlugin, init_plugin } from "../../../editor-kernel/plugin.js";
+import { liteXmlIdentityPolicy } from "../node/identity-policy.js";
 import { $isDiffContentNode, DiffContentNode } from "../node/DiffContentNode.js";
 import { DiffNode } from "../node/DiffNode.js";
 import { $isTableCellDiffNode, TableCellDiffNode } from "../node/TableCellDiffNode.js";
@@ -14,6 +16,7 @@ import { $isTableNode } from "@lexical/table";
 import { $nodesOfType, HISTORIC_TAG } from "lexical";
 //#region src/plugins/litexml/plugin/index.ts
 init_plugin();
+init_node_identity_policy();
 /**
 * LitexmlPlugin - A plugin that provides XML-based data source support
 * Allows converting between Lexical editor state and XML format
@@ -52,6 +55,7 @@ const LitexmlPlugin = class extends KernelPlugin {
 		if (config?.enabled !== false) kernel.registerDataSource(this.datasource);
 	}
 	onInit(editor) {
+		this.register(registerNodeIdentityPolicy(editor, liteXmlIdentityPolicy));
 		this.register(registerLiteXMLCommand(editor, this.datasource));
 		this.register(registerLiteXMLDiffCommand(editor));
 		this.register(registerLegacyTableCellDiffNormalization(editor));
@@ -91,6 +95,7 @@ const LitexmlPlugin = class extends KernelPlugin {
 					diffNode.getChildren().forEach((child) => nodeToXML(child, lines, indent));
 					break;
 				case "remove": break;
+				case "listItemRemove": break;
 				case "listItemModify": diffNode.getChildAtIndex(1).getChildren().forEach((child) => {
 					nodeToXML(child, lines, indent);
 				});
@@ -143,6 +148,7 @@ const LitexmlPlugin = class extends KernelPlugin {
 					diffNode.getChildren().forEach((child) => ctx.processChild(ctx, child));
 					break;
 				case "remove": break;
+				case "listItemRemove": break;
 				case "listItemModify": diffNode.getChildAtIndex(1).getChildren().forEach((child) => {
 					ctx.processChild(ctx, child);
 				});

package/es/plugins/litexml/table-cell-diff.js

@@ -1,9 +1,11 @@
+import { $copyNodeProperties, init_node_id } from "../common/node/node-id.js";
 import { $createDiffNode, DiffNode } from "./node/DiffNode.js";
 import { $createTableCellDiffNode, TableCellDiffNode } from "./node/TableCellDiffNode.js";
 import { $cloneNode } from "./utils/index.js";
 import { $createTableCellNode, $isTableCellNode, $isTableNode, $isTableRowNode, TableNode } from "@lexical/table";
 import { $nodesOfType } from "lexical";
 //#region src/plugins/litexml/table-cell-diff.ts
+init_node_id();
 function copyCellStructure(source, target) {
 	target.setRowSpan(source.getRowSpan());
 	target.setBackgroundColor(source.getBackgroundColor());
@@ -11,6 +13,7 @@ function copyCellStructure(source, target) {
 }
 function $createTableCellDiffFromCell(editor, cell, diffType, changeId) {
 	const diffCell = $createTableCellDiffNode(diffType, changeId, cell.getHeaderStyles(), cell.getColSpan(), cell.getWidth());
+	$copyNodeProperties(cell, diffCell);
 	copyCellStructure(cell, diffCell);
 	const diff = $createDiffNode(diffType);
 	diff.append(...cell.getChildren().map((child) => $cloneNode(child, editor)));
@@ -19,6 +22,7 @@ function $createTableCellDiffFromCell(editor, cell, diffType, changeId) {
 }
 function $createPlainTableCellFromDiff(editor, cell) {
 	const plainCell = $createTableCellNode(cell.getHeaderStyles(), cell.getColSpan(), cell.getWidth());
+	$copyNodeProperties(cell, plainCell);
 	copyCellStructure(cell, plainCell);
 	const diff = cell.getFirstChild();
 	if (diff instanceof DiffNode) plainCell.append(...diff.getChildren().map((child) => $cloneNode(child, editor)));

package/es/plugins/litexml/table-row-diff.js

@@ -1,8 +1,10 @@
+import { $copyNodeProperties, init_node_id } from "../common/node/node-id.js";
 import { $cloneNode } from "./utils/index.js";
 import { $createTableRowDiffNode, TableRowDiffNode } from "./node/TableRowDiffNode.js";
 import { $createTableRowNode, $isTableCellNode, $isTableNode } from "@lexical/table";
 import { $nodesOfType } from "lexical";
 //#region src/plugins/litexml/table-row-diff.ts
+init_node_id();
 function $areTableRowStructuresCompatible(previousRow, nextRow) {
 	const previousCells = previousRow.getChildren();
 	const nextCells = nextRow.getChildren();
@@ -15,11 +17,13 @@ function $areTableRowStructuresCompatible(previousRow, nextRow) {
 function $createTableRowDiffFromRow(editor, row, diffType, changeId) {
 	const source = $cloneNode(row, editor);
 	const diffRow = $createTableRowDiffNode(diffType, changeId, row.getHeight());
+	$copyNodeProperties(row, diffRow);
 	diffRow.append(...source.getChildren());
 	return diffRow;
 }
 function $createPlainTableRowFromDiff(editor, row) {
 	const plainRow = $createTableRowNode(row.getHeight());
+	$copyNodeProperties(row, plainRow);
 	plainRow.append(...row.getChildren().map((child) => $cloneNode(child, editor)));
 	return plainRow;
 }

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

@@ -1,26 +1,22 @@
-import { $isElementNode, resetRandomKey } from "lexical";
+import { $clearNodeId, $getNodeId, $setNodeId, init_node_id, isValidContentNodeId } from "../../common/node/node-id.js";
+import { $isElementNode } from "lexical";
 //#region src/plugins/litexml/utils/index.ts
-const getNumericId = (id) => {
-	if (typeof id !== "number" && typeof id !== "string") return null;
-	const numericId = Number(id);
-	return Number.isInteger(numericId) && numericId >= 0 ? numericId : null;
-};
-function $parseSerializedNodeImpl(serializedNode, editor, keepId = false, state = null) {
+init_node_id();
+function $parseSerializedNodeImpl(serializedNode, editor) {
 	const type = serializedNode.type;
 	const registeredNode = editor._nodes.get(type);
 	if (registeredNode === void 0) throw new Error(`parseEditorState: type "${type}" not found`);
 	const nodeClass = registeredNode.klass;
 	if (serializedNode.type !== nodeClass.getType()) throw new Error(`LexicalNode: Node ${nodeClass.name} does not implement .importJSON().`);
-	if (keepId) {
-		const id = getNumericId(serializedNode.id);
-		if (id !== null) resetRandomKey(id);
-	}
 	const node = nodeClass.importJSON(serializedNode);
+	const nodeId = isValidContentNodeId(serializedNode.id) ? serializedNode.id : $getNodeId(node);
+	if (isValidContentNodeId(nodeId)) $setNodeId(node, nodeId);
+	else if (nodeId) $clearNodeId(node);
 	const children = serializedNode.children;
 	if ($isElementNode(node) && Array.isArray(children)) {
 		const childNodes = [];
 		for (const serializedJSONChildNode of children) {
-			const childNode = $parseSerializedNodeImpl(serializedJSONChildNode, editor, keepId, state);
+			const childNode = $parseSerializedNodeImpl(serializedJSONChildNode, editor);
 			childNodes.push(childNode);
 		}
 		node.append(...childNodes);
@@ -30,6 +26,7 @@ function $parseSerializedNodeImpl(serializedNode, editor, keepId = false, state
 function exportNodeToJSON(node) {
 	const serializedNode = node.exportJSON();
 	const nodeClass = node.constructor;
+	serializedNode.id = $getNodeId(node);
 	if (serializedNode.type !== nodeClass.getType()) throw new Error(`LexicalNode: Node ${nodeClass.name} does not match the serialized type. Check if .exportJSON() is implemented and it is returning the correct type.`);
 	if ($isElementNode(node)) {
 		const serializedChildren = serializedNode.children;
@@ -45,15 +42,5 @@ function exportNodeToJSON(node) {
 function $cloneNode(node, editor) {
 	return $parseSerializedNodeImpl(exportNodeToJSON(node), editor);
 }
-const maxId = 1679616;
-const startId = 1e6;
-const step = 7211;
-const modInverse = 1394051;
-function idToChar(id) {
-	return ((Number(id) * step + startId) % maxId).toString(36).padStart(4, "0");
-}
-function charToId(char) {
-	return String((parseInt(char, 36) - startId + maxId) * modInverse % maxId);
-}
 //#endregion
-export { $cloneNode, $parseSerializedNodeImpl, charToId, idToChar };
+export { $cloneNode, $parseSerializedNodeImpl };