@lobehub/editor 4.15.1 → 4.15.2

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

@@ -0,0 +1,333 @@
+import { createDebugLogger, init_debug } from "../../../utils/debug.js";
+import { $closest } from "../../../editor-kernel/utils.js";
+import { $createDiffNode, DiffNode } from "../node/DiffNode.js";
+import { $cloneNode, $parseSerializedNodeImpl, charToId } from "../utils/index.js";
+import { $createParagraphNode, $getNodeByKey, $getRoot, $insertNodes, $isElementNode, COMMAND_PRIORITY_EDITOR, createCommand } from "lexical";
+import { mergeRegister } from "@lexical/utils";
+import { $isListItemNode } from "@lexical/list";
+//#region src/plugins/litexml/command/index.ts
+init_debug();
+const logger = createDebugLogger("plugin", "litexml");
+function toArrayXml(litexml) {
+	return Array.isArray(litexml) ? litexml : [litexml];
+}
+function tryParseChild(child, editor) {
+	try {
+		const oldNode = $getNodeByKey(child.id);
+		return {
+			newNode: $parseSerializedNodeImpl(child, editor),
+			oldNode
+		};
+	} catch (error) {
+		logger.error("❌ Error parsing child node:", error);
+		return {
+			newNode: null,
+			oldNode: null
+		};
+	}
+}
+function handleReplaceForApplyDelay(oldNode, newNode, modifyBlockNodes, diffNodeMap, editor) {
+	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;
+	}
+	if (oldNode === oldBlock) {
+		const diffNode = $createDiffNode("modify");
+		diffNode.append($cloneNode(oldBlock, editor), newNode);
+		oldNode.replace(diffNode, false);
+	} else {
+		if (!modifyBlockNodes.has(oldBlock.getKey())) {
+			modifyBlockNodes.add(oldBlock.getKey());
+			const diffNode = $createDiffNode("modify");
+			diffNode.append($cloneNode(oldBlock, editor));
+			diffNodeMap.set(oldBlock.getKey(), diffNode);
+		}
+		oldNode.replace(newNode, false);
+	}
+}
+function finalizeModifyBlocks(modifyBlockNodes, diffNodeMap, editor) {
+	for (const blockNodeKey of modifyBlockNodes) {
+		const blockNode = $getNodeByKey(blockNodeKey);
+		const diffNode = diffNodeMap.get(blockNodeKey);
+		if (diffNode && blockNode) if (blockNode.getType() === "listitem" && $isElementNode(blockNode)) {
+			const newDiffNode = $createDiffNode("listItemModify");
+			const firstChild = diffNode.getFirstChild();
+			if (firstChild && $isElementNode(firstChild)) newDiffNode.append(firstChild);
+			const children = blockNode.getChildren();
+			const p = $createParagraphNode();
+			children.forEach((child) => {
+				child.remove();
+				p.append(child);
+			});
+			newDiffNode.append(p);
+			blockNode.append(newDiffNode);
+			continue;
+		} else {
+			diffNode.append($cloneNode(blockNode, editor));
+			blockNode.replace(diffNode, false);
+		}
+	}
+}
+/**
+* Wrap a block-level change with a `modify` diff: clone the old block, run the
+* provided changeFn (which should mutate nodes inside the block), then clone
+* the new block and replace it with the diff node. Useful for inline->block
+* transitions where we want to show a modify diff.
+*/
+function wrapBlockModify(oldBlock, editor, changeFn) {
+	if ($isListItemNode(oldBlock)) {
+		const diffNode = $createDiffNode("listItemModify");
+		const p = $createParagraphNode();
+		oldBlock.getChildren().forEach((child) => {
+			p.append($cloneNode(child, editor));
+		});
+		changeFn();
+		diffNode.append(p);
+		const pNew = $createParagraphNode();
+		oldBlock.getChildren().forEach((child) => {
+			pNew.append(child);
+		});
+		diffNode.append(pNew);
+		oldBlock.append(diffNode);
+		return;
+	}
+	const diffNode = $createDiffNode("modify");
+	diffNode.append($cloneNode(oldBlock, editor));
+	changeFn();
+	const newBlock = $getNodeByKey(oldBlock.getKey());
+	if (!newBlock) throw new Error("New block node not found for modify wrapper.");
+	diffNode.append($cloneNode(newBlock, editor));
+	newBlock.replace(diffNode, false);
+}
+const LITEXML_MODIFY_COMMAND = createCommand("LITEXML_MODIFY_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");
+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;
+		}, []);
+		try {
+			resultPayload.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;
+		}
+	}, COMMAND_PRIORITY_EDITOR), editor.registerCommand(LITEXML_APPLY_COMMAND, (payload) => {
+		const { litexml, delay } = payload;
+		handleModify(editor, dataSource, toArrayXml(litexml), delay);
+		return false;
+	}, COMMAND_PRIORITY_EDITOR), editor.registerCommand(LITEXML_REMOVE_COMMAND, (payload) => {
+		const { id, delay } = payload;
+		handleRemove(editor, charToId(id), delay);
+		return false;
+	}, COMMAND_PRIORITY_EDITOR), editor.registerCommand(LITEXML_INSERT_COMMAND, (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]);
+				} catch (error) {
+					logger.error("❌ Error replacing node:", error);
+				}
+			});
+		});
+	});
+}
+function handleRemove(editor, key, delay) {
+	editor.update(() => {
+		const node = $getNodeByKey(key);
+		if (!node) return;
+		if (!delay) {
+			node.remove();
+			return;
+		}
+		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");
+						newDiff.append(children[0]);
+						originDiffNode.replace(newDiff, false);
+						return;
+					}
+					case "listItemModify": {
+						const children = originDiffNode.getChildren();
+						originDiffNode.replace(children[0], false).selectEnd();
+						return;
+					}
+					case "remove":
+					case "unchanged": break;
+				}
+				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();
+			});
+		}
+	});
+}
+function handleInsert(editor, payload, dataSource) {
+	const { litexml, delay } = payload;
+	const isBefore = "beforeId" in payload;
+	const inode = dataSource.readLiteXMLToInode(litexml);
+	editor.update(() => {
+		try {
+			let referenceNode = null;
+			if (isBefore) if (payload.beforeId === "root") referenceNode = $getRoot().getFirstChild();
+			else referenceNode = $getNodeByKey(charToId(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));
+			if (!delay) {
+				if (isBefore) newNodes.reverse().forEach((node) => {
+					referenceNode = referenceNode.insertBefore(node);
+				});
+				else newNodes.forEach((node) => {
+					if (referenceNode) referenceNode = referenceNode.insertAfter(node);
+				});
+				return;
+			}
+			if (isBefore) if (referenceNode.isInline() === false) {
+				const originDiffNode = $closest(referenceNode, (node) => node.getType() === DiffNode.getType());
+				if (originDiffNode) referenceNode = originDiffNode;
+				newNodes.map((node) => {
+					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) {
+				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);
+		}
+	});
+}
+//#endregion
+export { LITEXML_APPLY_COMMAND, LITEXML_INSERT_COMMAND, LITEXML_MODIFY_COMMAND, LITEXML_REMOVE_COMMAND, registerLiteXMLCommand };

package/es/plugins/litexml/data-source/litexml-data-source.d.ts

@@ -0,0 +1,65 @@
+import { DataSource, IWriteOptions } from "../../../editor-kernel/data-source.js";
+import { IServiceID } from "../../../types/kernel.js";
+import { ILitexmlService } from "../service/litexml-service.js";
+import { LexicalEditor } from "lexical";
+
+//#region src/plugins/litexml/data-source/litexml-data-source.d.ts
+/**
+ * LitexmlDataSource - Handles conversion between Lexical editor state and XML format
+ * Provides read (parse XML to Lexical) and write (export Lexical to XML) capabilities
+ */
+declare class LitexmlDataSource extends DataSource {
+  protected dataType: string;
+  protected getService?: (<T>(serviceId: IServiceID<T>) => T | null) | undefined;
+  private litexmlService;
+  private ctx;
+  constructor(dataType?: string, getService?: (<T>(serviceId: IServiceID<T>) => T | null) | undefined, service?: ILitexmlService);
+  readLiteXMLToInode(litexml: string): any;
+  /**
+   * Parse XML string and set it to the editor
+   * @param editor - The Lexical editor instance
+   * @param data - XML string to parse
+   */
+  read(editor: LexicalEditor, data: string): void;
+  /**
+   * Export editor content to XML format
+   * @param editor - The Lexical editor instance
+   * @param options - Write options (e.g., selection flag)
+   * @returns XML string representation of the editor content
+   */
+  write(editor: LexicalEditor, options?: IWriteOptions): any;
+  /**
+   * Parse XML string using browser's built-in parser
+   */
+  private parseXMLString;
+  /**
+   * Convert XML document to Lexical node structure
+   */
+  private xmlToLexical;
+  /**
+   * Recursively process XML elements and convert to Lexical nodes
+   */
+  private processXMLElement;
+  /**
+   * Process XML element's children
+   */
+  private processXMLChildren;
+  /**
+   * Convert Lexical node structure to XML string
+   */
+  private lexicalToXML;
+  /**
+   * Recursively convert Lexical nodes to XML elements
+   */
+  private nodesToXML;
+  /**
+   * Build XML attribute string from attributes object
+   */
+  private buildXMLAttributes;
+  /**
+   * Escape XML special characters
+   */
+  private escapeXML;
+}
+//#endregion
+export { LitexmlDataSource };

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

@@ -0,0 +1,286 @@
+import { createDebugLogger, init_debug } from "../../../utils/debug.js";
+import { INodeHelper, init_helper } from "../../../editor-kernel/inode/helper.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_debug();
+const logger = createDebugLogger("plugin", "litexml");
+var IXmlWriterContext = class {
+	createXmlNode(tagName, attributes, textContent) {
+		return {
+			attributes: attributes || {},
+			children: [],
+			tagName,
+			textContent
+		};
+	}
+};
+/**
+* LitexmlDataSource - Handles conversion between Lexical editor state and XML format
+* Provides read (parse XML to Lexical) and write (export Lexical to XML) capabilities
+*/
+var LitexmlDataSource = class extends DataSource {
+	constructor(dataType = "litexml", getService, service) {
+		super(dataType);
+		this.dataType = dataType;
+		this.getService = getService;
+		this.ctx = new IXmlWriterContext();
+		this.litexmlService = service || new LitexmlService();
+	}
+	readLiteXMLToInode(litexml) {
+		if (typeof litexml !== "string") throw new Error("Invalid data type. Expected string, got " + typeof litexml);
+		const xml = this.parseXMLString(litexml);
+		const inode = this.xmlToLexical(xml);
+		this.getService?.(INodeService)?.processNodeTree(inode);
+		logger.debug("Parsed XML to Lexical State:", inode);
+		return inode;
+	}
+	/**
+	* Parse XML string and set it to the editor
+	* @param editor - The Lexical editor instance
+	* @param data - XML string to parse
+	*/
+	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);
+				}
+			});
+			editor.setEditorState(newState);
+		} catch (error) {
+			logger.error("Failed to parse XML:", error);
+			throw error;
+		}
+	}
+	/**
+	* Export editor content to XML format
+	* @param editor - The Lexical editor instance
+	* @param options - Write options (e.g., selection flag)
+	* @returns XML string representation of the editor content
+	*/
+	write(editor, options) {
+		try {
+			if (options?.selection) return editor.getEditorState().read(() => {
+				const selection = $getSelection();
+				if (!selection) return null;
+				if ($isRangeSelection(selection)) {
+					const selectedNodes = selection.getNodes();
+					const rootNode = INodeHelper.createRootNode();
+					if (selectedNodes.some((node) => node.isInline())) {
+						const p = INodeHelper.createParagraph();
+						INodeHelper.appendChild(p, ...selectedNodes.map((node) => node.exportJSON()));
+						INodeHelper.appendChild(rootNode, p);
+					} else INodeHelper.appendChild(rootNode, ...selectedNodes.map((node) => node.exportJSON()));
+					return editor.parseEditorState({ root: rootNode }).read(() => {
+						const lexicalRootNode = $getRoot();
+						return this.lexicalToXML(lexicalRootNode);
+					});
+				}
+				return null;
+			});
+			return editor.getEditorState().read(() => {
+				const rootNode = $getRoot();
+				return this.lexicalToXML(rootNode);
+			});
+		} catch (error) {
+			logger.error("Failed to export to XML:", error);
+			throw error;
+		}
+	}
+	/**
+	* Parse XML string using browser's built-in parser
+	*/
+	parseXMLString(xmlString) {
+		const doc = new DOMParser().parseFromString(xmlString, "text/xml");
+		if (doc.getElementsByTagName("parsererror").length > 0) throw new Error("Invalid XML: " + xmlString);
+		return doc;
+	}
+	/**
+	* Convert XML document to Lexical node structure
+	*/
+	xmlToLexical(xml) {
+		const rootNode = INodeHelper.createRootNode();
+		const xmlRoot = xml.documentElement;
+		if (xmlRoot) this.processXMLElement(xmlRoot, rootNode);
+		return { root: rootNode };
+	}
+	/**
+	* Recursively process XML elements and convert to Lexical nodes
+	*/
+	processXMLElement(xmlElement, parentNode) {
+		const tagName = xmlElement.tagName.toLowerCase();
+		const customReaders = this.litexmlService.getXMLReaders();
+		if (customReaders[tagName]) {
+			const readerOrReaders = customReaders[tagName];
+			const readers = Array.isArray(readerOrReaders) ? readerOrReaders : [readerOrReaders];
+			for (const reader of readers) {
+				const children = [];
+				this.processXMLChildren(xmlElement, { children });
+				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;
+						}
+						INodeHelper.appendChild(parentNode, ...result);
+					} else if (result) {
+						const attrId = xmlElement.getAttribute("id");
+						result.id = attrId ? charToId(attrId) : void 0;
+						INodeHelper.appendChild(parentNode, result);
+					}
+					return;
+				}
+			}
+		}
+		switch (tagName) {
+			case "p":
+			case "paragraph": {
+				const paragraph = INodeHelper.createParagraph();
+				this.processXMLChildren(xmlElement, paragraph);
+				INodeHelper.appendChild(parentNode, paragraph);
+				break;
+			}
+			case "h1":
+			case "h2":
+			case "h3":
+			case "h4":
+			case "h5":
+			case "h6": {
+				const level = parseInt(tagName.charAt(1));
+				const heading = INodeHelper.createElementNode("heading", {
+					children: [],
+					tag: `h${level}`
+				});
+				this.processXMLChildren(xmlElement, heading);
+				INodeHelper.appendChild(parentNode, heading);
+				break;
+			}
+			case "ul":
+			case "ol":
+				xmlElement.querySelectorAll(":scope > li").forEach((li) => {
+					const listItem = INodeHelper.createElementNode("listitem", {
+						children: [],
+						value: 1
+					});
+					this.processXMLChildren(li, listItem);
+					INodeHelper.appendChild(parentNode, listItem);
+				});
+				break;
+			case "blockquote": {
+				const quote = INodeHelper.createElementNode("quote", { children: [] });
+				this.processXMLChildren(xmlElement, quote);
+				INodeHelper.appendChild(parentNode, quote);
+				break;
+			}
+			case "code": {
+				const codeNode = INodeHelper.createElementNode("codeInline", { children: [INodeHelper.createTextNode(xmlElement.textContent || "")] });
+				INodeHelper.appendChild(parentNode, codeNode);
+				break;
+			}
+			case "text": {
+				const textContent = xmlElement.textContent || "";
+				if (textContent) {
+					const textNode = INodeHelper.createTextNode(textContent);
+					INodeHelper.appendChild(parentNode, textNode);
+				}
+				break;
+			}
+			default: this.processXMLChildren(xmlElement, parentNode);
+		}
+	}
+	/**
+	* Process XML element's children
+	*/
+	processXMLChildren(xmlElement, parentNode) {
+		Array.from(xmlElement.childNodes).forEach((child) => {
+			if (child.nodeType === 1) this.processXMLElement(child, parentNode);
+			else if (child.nodeType === 3) {
+				const text = child.textContent || "";
+				if (text.trim()) {
+					const textNode = INodeHelper.createTextNode(text);
+					INodeHelper.appendChild(parentNode, textNode);
+				}
+			}
+		});
+	}
+	/**
+	* Convert Lexical node structure to XML string
+	*/
+	lexicalToXML(rootNode) {
+		const xmlLines = ["<?xml version=\"1.0\" encoding=\"UTF-8\"?>"];
+		xmlLines.push("<root>");
+		rootNode.getChildren().forEach((child) => {
+			this.nodesToXML(child, xmlLines);
+		});
+		xmlLines.push("</root>");
+		return xmlLines.join("\n");
+	}
+	/**
+	* Recursively convert Lexical nodes to XML elements
+	*/
+	nodesToXML(node, lines, indent = 1) {
+		const indentStr = " ".repeat(indent * 2);
+		const type = node.getType();
+		const customWriters = this.litexmlService.getXMLWriters();
+		const childLines = [];
+		if (customWriters[type]) {
+			const writerOrWriters = customWriters[type];
+			const writers = Array.isArray(writerOrWriters) ? writerOrWriters : [writerOrWriters];
+			for (const writer of writers) {
+				const handled = writer(node, this.ctx, indent, this.nodesToXML.bind(this));
+				if (handled) {
+					if ("lines" in handled) {
+						lines.push(...handled.lines);
+						return;
+					}
+					const attrs = this.buildXMLAttributes({
+						id: idToChar(node.getKey()),
+						...handled.attributes
+					});
+					const openTag = `${indentStr}<${handled.tagName}${attrs}>`;
+					const closeTag = `</${handled.tagName}>`;
+					if (handled.textContent) lines.push(`${openTag}${handled.textContent}${closeTag}`);
+					else if ($isElementNode(node)) {
+						node.getChildren().forEach((child) => {
+							this.nodesToXML(child, childLines, indent + 1);
+						});
+						lines.push(openTag, ...childLines, `${indentStr}${closeTag}`);
+					} else lines.push(openTag, `${indentStr}${closeTag}`);
+					return;
+				}
+			}
+		}
+		if ($isElementNode(node)) node.getChildren().forEach((child) => {
+			this.nodesToXML(child, childLines, indent);
+		});
+		lines.push(...childLines);
+	}
+	/**
+	* Build XML attribute string from attributes object
+	*/
+	buildXMLAttributes(attributes) {
+		if (!attributes || typeof attributes !== "object") return "";
+		return Object.entries(attributes).filter(([, value]) => value !== void 0 && value !== null && value !== "").map(([key, value]) => {
+			return ` ${key}="${this.escapeXML(String(value))}"`;
+		}).join("");
+	}
+	/**
+	* Escape XML special characters
+	*/
+	escapeXML(text) {
+		return text.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;").replaceAll("'", "&apos;");
+	}
+};
+//#endregion
+export { LitexmlDataSource as default };

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

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