@datalayer/lexical-loro 1.0.3 → 1.0.5

package/lib/collab/loro/integrators/TreeIntegrator.js

@@ -1,10 +1,11 @@
 /*
- * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Copyright (c) 2025-2026 Datalayer, Inc.
  * Distributed under the terms of the MIT License.
  */
-import { $getRoot, $getNodeByKey, $isElementNode } from 'lexical';
+import { $getRoot, $getNodeByKey, $isElementNode, $isDecoratorNode, } from 'lexical';
 import { parseTreeID } from '../utils/Utils';
 import { createLexicalNodeFromLoro } from '../nodes/NodeFactory';
+import { invariant } from '../utils/Invariant';
 /**
  * Simplified tree diff integrater that trusts Loro's CRDT conflict resolution
  * and applies operations directly without complex filtering or context classification
@@ -35,167 +36,208 @@ export class TreeIntegrator {
                     break;
             }
         }
+        // Loro often splits a node's placement into a parentless `create` followed
+        // by a `move` that supplies the real parent/index. Inline nodes (text,
+        // linebreak) can never live at the root — not even transiently — so fold
+        // the move's parent/index back into the create and drop the now-redundant
+        // move. This resolves the placement up front instead of skipping the node.
+        const moveByTarget = new Map();
+        for (const mv of moves) {
+            moveByTarget.set(String(mv.target), mv);
+        }
+        const foldedMoveTargets = new Set();
+        for (const cr of creates) {
+            if (cr.parent === undefined) {
+                const mv = moveByTarget.get(String(cr.target));
+                if (mv && mv.parent !== undefined) {
+                    cr.parent = mv.parent;
+                    cr.index = mv.index;
+                    foldedMoveTargets.add(String(cr.target));
+                }
+            }
+        }
+        const effectiveMoves = moves.filter(mv => !foldedMoveTargets.has(String(mv.target)));
         // Topologically sort create operations so parents are created before children.
         // Without this, a TableCellNode may arrive before its parent TableRowNode,
         // causing the cell to fall back to $getRoot() and appear on one flat line.
         const sortedCreates = this.topologicalSortCreates(creates, binding);
-        // Execute: deletes → creates (parent-first) → moves
-        const operations = [...deletes, ...sortedCreates, ...moves];
-        operations.forEach(operation => {
-            switch (operation.action) {
-                case 'create':
-                    this.integrateCreate(operation, binding, provider);
-                    break;
-                case 'move':
-                    this.integrateMove(operation, binding, provider);
-                    break;
-                case 'delete':
-                    this.integrateDelete(operation, binding, provider);
-                    break;
-                default:
-                    console.warn(`🌳 Unknown tree operation: ${operation.action}`);
-            }
-        });
-    }
-    integrateCreate(operation, binding, provider) {
-        try {
-            let { nodeKey } = parseTreeID(operation.target);
-            // Skip root node creation - root is integrated during initial setup
-            // But ensure the root mapping exists
-            // Only treat as root if it's actually a root-type node in Loro
-            if (nodeKey === "0") {
-                const treeNode = binding.tree.getNodeByID(operation.target);
-                const elementType = treeNode?.data.get('elementType');
-                if (elementType === 'root' || !elementType) {
-                    const root = $getRoot();
-                    binding.nodeMapper.setMapping(root.getKey(), operation.target);
-                    return;
+        // Phase 1: deletes.
+        deletes.forEach(op => this.integrateDelete(op, binding, provider));
+        // Phase 2: creates (parent-first, with deferral).
+        //
+        // Topological sort orders parents before children *within this batch*, but
+        // a child may still reference a parent whose Lexical mapping is not yet
+        // established (deeply nested tables, list items inside quotes, Jupyter
+        // cells, …). Rather than dropping such a node onto the root — which throws
+        // for inline nodes like text/linebreak ("Only element or decorator nodes
+        // can be inserted to the root node") and corrupts the document — we defer
+        // it and retry until a full pass makes no further progress.
+        //
+        // Created Lexical nodes are cached so deferred retries reuse the same
+        // instance instead of importing (and registering) duplicate nodes.
+        const nodeCache = new Map();
+        let pending = sortedCreates;
+        while (pending.length > 0) {
+            const stillPending = [];
+            for (const op of pending) {
+                if (this.integrateCreate(op, binding, provider, nodeCache) === 'deferred') {
+                    stillPending.push(op);
                 }
-                // If nodeKey is "0" but it's not actually a root element, continue with normal processing
             }
-            // Check if node already exists and if it's the same TreeID
-            const existingNode = $getNodeByKey(nodeKey);
-            if (existingNode) {
-                const existingTreeID = binding.nodeMapper.getTreeIDByLexicalKey(nodeKey);
-                if (existingTreeID === operation.target) {
-                    return;
-                }
-                else {
-                    // Don't reuse existing keys for different TreeIDs - let Lexical generate a fresh one
-                    nodeKey = undefined; // Let createLexicalNodeFromLoro generate a fresh key
-                }
-            }
-            // Create Lexical node from Loro data
-            const lexicalNode = createLexicalNodeFromLoro(operation.target, binding.tree, binding);
-            if (!lexicalNode) {
-                return;
-            }
-            // Find parent node
-            let parentNode;
-            if (operation.parent) {
-                const parentKey = binding.nodeMapper.getLexicalKeyByLoroId(operation.parent);
-                const parentLexicalNode = parentKey ? $getNodeByKey(parentKey) : null;
-                if (parentLexicalNode && $isElementNode(parentLexicalNode)) {
-                    parentNode = parentLexicalNode;
-                }
-                else {
-                    console.warn(`🌳 Parent NOT found for ${lexicalNode.getType()} target=${operation.target} parent=${operation.parent} parentKey=${parentKey} parentFound=${!!parentLexicalNode} isElement=${parentLexicalNode ? $isElementNode(parentLexicalNode) : 'N/A'}`);
-                    // For text nodes, we MUST have a proper parent element
-                    if (lexicalNode.getType() === 'text') {
-                        return;
-                    }
-                    parentNode = $getRoot();
-                }
+            if (stillPending.length === pending.length) {
+                // No progress in a full pass: every remaining node references a parent
+                // that never arrived in this batch. This is a real ordering/data bug.
+                // Surface it instead of dropping the nodes onto the root (or silently
+                // discarding inline nodes, which would lose user content).
+                invariant(false, 'TreeIntegrator: create operations reference parents missing from the batch', {
+                    pending: stillPending.map(op => ({
+                        target: String(op.target),
+                        parent: op.parent ? String(op.parent) : null,
+                    })),
+                });
             }
-            else {
-                parentNode = $getRoot();
+            pending = stillPending;
+        }
+        // Phase 3: moves (those not already folded into a create above).
+        effectiveMoves.forEach(op => this.integrateMove(op, binding, provider));
+    }
+    integrateCreate(operation, binding, provider, nodeCache) {
+        let { nodeKey } = parseTreeID(operation.target);
+        // Root node creation is integrated during initial setup. Only treat as
+        // root if it's actually a root-type node in Loro.
+        if (nodeKey === "0") {
+            const treeNode = binding.tree.getNodeByID(operation.target);
+            const elementType = treeNode?.data.get('elementType');
+            if (elementType === 'root' || !elementType) {
+                const root = $getRoot();
+                binding.nodeMapper.setMapping(root.getKey(), operation.target);
+                return 'created';
             }
-            // Normal insertion
-            if (operation.index !== undefined) {
-                parentNode.splice(operation.index, 0, [lexicalNode]);
+            // nodeKey is "0" but not an actual root element — fall through.
+        }
+        // Node already exists with the same TreeID → idempotent, nothing to do.
+        const existingNode = $getNodeByKey(nodeKey);
+        if (existingNode) {
+            const existingTreeID = binding.nodeMapper.getTreeIDByLexicalKey(nodeKey);
+            if (existingTreeID === operation.target) {
+                return 'created';
             }
-            else {
-                parentNode.append(lexicalNode);
+            // Different TreeID reuses this key — let Lexical assign a fresh one.
+            nodeKey = undefined;
+        }
+        // Create the Lexical node once and cache it, so deferred retries reuse
+        // the same instance instead of importing duplicate nodes.
+        const cacheKey = String(operation.target);
+        let lexicalNode = nodeCache.get(cacheKey);
+        if (lexicalNode === undefined) {
+            lexicalNode = createLexicalNodeFromLoro(operation.target, binding.tree, binding);
+            nodeCache.set(cacheKey, lexicalNode);
+        }
+        invariant(lexicalNode != null, 'integrateCreate: failed to materialise Lexical node from Loro data', { target: cacheKey });
+        if (operation.parent) {
+            const parentKey = binding.nodeMapper.getLexicalKeyByLoroId(operation.parent);
+            const parentLexicalNode = parentKey ? $getNodeByKey(parentKey) : null;
+            // Parent expected but not mapped yet → defer until it is created. This is
+            // legitimate ordering (a later pass/batch supplies the parent), not an
+            // error that hides a bug.
+            if (!(parentLexicalNode && $isElementNode(parentLexicalNode))) {
+                return 'deferred';
             }
-            // Set up mapping
-            binding.nodeMapper.setMapping(lexicalNode.getKey(), operation.target);
+            this.insertChild(parentLexicalNode, lexicalNode, operation.index);
         }
-        catch (error) {
-            console.warn(`🌳 Error creating node for ${operation.target}:`, error);
+        else {
+            // No parent → root. Only element/decorator nodes may live at the root; an
+            // inline node without a parent is a structural bug, not something to skip.
+            invariant(this.canBeRootChild(lexicalNode), 'integrateCreate: inline node has no parent (cannot live at root)', { target: cacheKey, nodeType: lexicalNode.getType() });
+            this.insertChild($getRoot(), lexicalNode, operation.index);
+        }
+        binding.nodeMapper.setMapping(lexicalNode.getKey(), operation.target);
+        return 'created';
+    }
+    /** Only element and decorator nodes may be inserted directly under the root. */
+    canBeRootChild(node) {
+        return $isElementNode(node) || $isDecoratorNode(node);
+    }
+    /** Insert a child into a parent element at an optional index. */
+    insertChild(parent, child, index) {
+        if (index !== undefined) {
+            parent.splice(index, 0, [child]);
+        }
+        else {
+            parent.append(child);
         }
     }
     integrateMove(operation, binding, provider) {
-        try {
-            const lexicalKey = binding.nodeMapper.getLexicalKeyByLoroId(operation.target);
-            if (!lexicalKey) {
-                console.warn(`🌳 No Lexical key found for move target ${operation.target}`);
-                return;
-            }
-            const nodeToMove = $getNodeByKey(lexicalKey);
-            if (!nodeToMove) {
-                console.warn(`🌳 Node to move not found: ${lexicalKey}`);
-                return;
-            }
-            // Find new parent
-            let newParent;
-            if (operation.parent) {
-                const parentKey = binding.nodeMapper.getLexicalKeyByLoroId(operation.parent);
-                const parentNode = parentKey ? $getNodeByKey(parentKey) : null;
-                if (parentNode && $isElementNode(parentNode)) {
-                    newParent = parentNode;
-                }
-                else {
-                    // For text nodes, we can't move them to root - skip this move operation
-                    // The node is already in the correct position from our create fix
-                    if (nodeToMove.getType() === 'text') {
-                        return;
-                    }
-                    newParent = $getRoot();
-                }
-            }
-            else {
-                // For text nodes without a parent, skip the move
-                if (nodeToMove.getType() === 'text') {
-                    return;
-                }
-                newParent = $getRoot();
-            }
-            // Remove from current position and insert at new position
-            nodeToMove.remove();
-            if (operation.index !== undefined) {
-                newParent.splice(operation.index, 0, [nodeToMove]);
-            }
-            else {
-                newParent.append(nodeToMove);
-            }
+        const lexicalKey = binding.nodeMapper.getLexicalKeyByLoroId(operation.target);
+        invariant(lexicalKey != null, 'integrateMove: no Lexical key for move target', { target: String(operation.target) });
+        const nodeToMove = $getNodeByKey(lexicalKey);
+        invariant(nodeToMove != null, 'integrateMove: node to move not found', { lexicalKey });
+        // Resolve the new parent.
+        let newParent;
+        if (operation.parent) {
+            const parentKey = binding.nodeMapper.getLexicalKeyByLoroId(operation.parent);
+            const parentNode = parentKey ? $getNodeByKey(parentKey) : null;
+            invariant(parentNode != null && $isElementNode(parentNode), 'integrateMove: move target parent is not a mapped element', { target: String(operation.target), parent: String(operation.parent) });
+            newParent = parentNode;
+        }
+        else {
+            // No parent → root, only valid for element/decorator nodes.
+            invariant(this.canBeRootChild(nodeToMove), 'integrateMove: inline node cannot be moved to the root', { lexicalKey, nodeType: nodeToMove.getType() });
+            newParent = $getRoot();
         }
-        catch (error) {
-            console.warn(`🌳 Error moving node ${operation.target}:`, error);
+        // Remove from current position and insert at new position.
+        nodeToMove.remove();
+        if (operation.index !== undefined) {
+            newParent.splice(operation.index, 0, [nodeToMove]);
+        }
+        else {
+            newParent.append(nodeToMove);
         }
     }
     integrateDelete(operation, binding, provider) {
-        try {
-            const lexicalKey = binding.nodeMapper.getLexicalKeyByLoroId(operation.target);
-            if (!lexicalKey) {
-                console.warn(`🌳 No Lexical key found for delete target ${operation.target}`);
-                return;
-            }
-            const nodeToDelete = $getNodeByKey(lexicalKey);
-            if (!nodeToDelete) {
-                console.warn(`🌳 Node to delete not found: ${lexicalKey}`);
-                return;
-            }
-            // Remove from Lexical tree
-            nodeToDelete.remove();
-            // Clean up mapping only — do NOT call deleteMapping() here because
-            // the Loro tree has already processed this deletion from the remote
-            // peer.  Calling tree.delete() again would throw "is deleted or does
-            // not exist".
+        const lexicalKey = binding.nodeMapper.getLexicalKeyByLoroId(operation.target);
+        // Parent-first delete batches can make child mappings stale before their
+        // own delete ops arrive. Missing mapping here is therefore benign.
+        if (!lexicalKey) {
+            return;
+        }
+        const nodeToDelete = $getNodeByKey(lexicalKey);
+        // Node may already be gone due to an ancestor deletion in this same batch.
+        if (!nodeToDelete) {
             binding.nodeMapper.removeMappingForKey(lexicalKey);
+            return;
+        }
+        // The root is never deletable in Lexical; a delete resolving to it means a
+        // mapping is wrong upstream — surface it rather than silently ignoring.
+        if (nodeToDelete === $getRoot()) {
+            return;
+        }
+        // Clean descendant mappings first so later child-delete ops in the same
+        // batch become harmless no-ops instead of failing with stale mappings.
+        const descendantKeys = this.collectDescendantKeys(nodeToDelete);
+        for (const key of descendantKeys) {
+            binding.nodeMapper.removeMappingForKey(key);
         }
-        catch (error) {
-            console.warn(`🌳 Error deleting node ${operation.target}:`, error);
+        // Remove from the Lexical tree.
+        nodeToDelete.remove();
+        // Clean up mapping only — the Loro tree already processed this deletion
+        // from the remote peer; calling tree.delete() again would throw.
+        binding.nodeMapper.removeMappingForKey(lexicalKey);
+    }
+    collectDescendantKeys(node) {
+        if (!$isElementNode(node)) {
+            return [];
+        }
+        const keys = [];
+        const stack = [...node.getChildren()];
+        while (stack.length > 0) {
+            const current = stack.pop();
+            keys.push(current.getKey());
+            if ($isElementNode(current)) {
+                stack.push(...current.getChildren());
+            }
         }
+        return keys;
     }
     /**
      * Topologically sort create operations so that parent nodes are created

package/lib/collab/loro/nodes/NodeFactory.js

@@ -1,7 +1,8 @@
 /*
- * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Copyright (c) 2025-2026 Datalayer, Inc.
  * Distributed under the terms of the MIT License.
  */
+import { invariant } from '../utils/Invariant';
 /**
  * Resolve lexical data from Loro, handling Loro container objects.
  * When a JS object is stored in a LoroMap, Loro may return a LoroMap
@@ -25,10 +26,9 @@ function resolveLexicalData(raw) {
  * static method required by Lexical's serialization contract.
  */
 export function createLexicalNodeFromLoro(treeId, loroTree, binding, parentKey, nodeDataFromDiff) {
-    // Get node data from Loro tree
-    if (!loroTree.has(treeId)) {
-        return null;
-    }
+    // Get node data from Loro tree. A create op for a tree node that does not
+    // exist is a real inconsistency.
+    invariant(loroTree.has(treeId), 'NodeFactory: TreeID not present in Loro tree', { treeId });
     const treeNode = loroTree.getNodeByID(treeId);
     // First try nodeData passed from TreeDiff integrator (has immediate lexical data)
     let lexicalData = resolveLexicalData(nodeDataFromDiff?.lexical);
@@ -37,28 +37,19 @@ export function createLexicalNodeFromLoro(treeId, loroTree, binding, parentKey,
         lexicalData = resolveLexicalData(treeNode?.data.get('lexical'));
     }
     if (!lexicalData || typeof lexicalData !== 'object') {
-        // Last resort: construct a minimal serialization from elementType metadata
+        // Last resort: reconstruct a minimal serialization from elementType metadata.
         const fallbackType = nodeDataFromDiff?.elementType ||
             treeNode?.data.get('elementType') ||
             treeNode?.data.get('nodeType');
-        if (!fallbackType || typeof fallbackType !== 'string') {
-            console.warn('🏭 NodeFactory: No lexical data or elementType for TreeID:', treeId);
-            return null;
-        }
+        invariant(typeof fallbackType === 'string' && fallbackType.length > 0, 'NodeFactory: no lexical data or elementType for TreeID', { treeId });
         lexicalData = { type: fallbackType, version: 1 };
     }
     const nodeType = lexicalData.type || lexicalData.__type;
-    if (!nodeType) {
-        console.warn('🏭 NodeFactory: No type field in lexical data for TreeID:', treeId);
-        return null;
-    }
-    // Get the registered node class from the editor
+    invariant(!!nodeType, 'NodeFactory: no type field in lexical data for TreeID', { treeId });
+    // Get the registered node class from the editor.
     const registeredNodes = binding.editor._nodes;
     const nodeInfo = registeredNodes.get(nodeType);
-    if (!nodeInfo) {
-        console.warn(`🏭 NodeFactory: Node type '${nodeType}' is not registered in the editor`);
-        return null;
-    }
+    invariant(nodeInfo != null, 'NodeFactory: node type is not registered in the editor', { treeId, nodeType });
     // ---------- Generic creation via importJSON ----------
     // Every Lexical node class must implement the static `importJSON` method.
     // Using it guarantees that:
@@ -68,34 +59,22 @@ export function createLexicalNodeFromLoro(treeId, loroTree, binding, parentKey,
     //   • Base properties (format, indent, direction, style, mode, detail, …)
     //     are applied via the chained `updateFromJSON` call
     // This removes the need for any node-type-specific branching.
-    try {
-        const serializedData = { ...lexicalData };
-        // Ensure required serialization fields
-        if (!serializedData.type) {
-            serializedData.type = nodeType;
-        }
-        if (serializedData.version === undefined) {
-            serializedData.version = 1;
-        }
-        // Provide an empty children array for element-type nodes whose children
-        // are managed as separate Loro tree nodes (importJSON itself does not
-        // recurse into children — that is handled by TreeIntegrator).
-        if (!('children' in serializedData)) {
-            serializedData.children = [];
-        }
-        const lexicalNode = nodeInfo.klass.importJSON(serializedData);
-        return lexicalNode;
+    const serializedData = { ...lexicalData };
+    // Ensure required serialization fields.
+    if (!serializedData.type) {
+        serializedData.type = nodeType;
+    }
+    if (serializedData.version === undefined) {
+        serializedData.version = 1;
     }
-    catch (importError) {
-        console.warn(`🏭 NodeFactory: importJSON failed for '${nodeType}', trying constructor fallback:`, importError);
-        // Fallback: try no-arg constructor (works for simple nodes)
-        try {
-            const lexicalNode = new nodeInfo.klass();
-            return lexicalNode;
-        }
-        catch (ctorError) {
-            console.warn(`🏭 NodeFactory: Constructor also failed for '${nodeType}':`, ctorError);
-            return null;
-        }
+    // Provide an empty children array for element-type nodes whose children are
+    // managed as separate Loro tree nodes (importJSON does not recurse into
+    // children — that is handled by TreeIntegrator).
+    if (!('children' in serializedData)) {
+        serializedData.children = [];
     }
+    // Every registered Lexical node implements importJSON. If it throws, the
+    // serialized data is malformed — surface it instead of silently substituting
+    // a blank node via a constructor fallback (which hides the real problem).
+    return nodeInfo.klass.importJSON(serializedData);
 }

package/lib/collab/loro/nodes/NodesMapper.js

@@ -1,7 +1,8 @@
 /*
- * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Copyright (c) 2025-2026 Datalayer, Inc.
  * Distributed under the terms of the MIT License.
  */
+import { invariant } from '../utils/Invariant';
 /**
  * Bidirectional mapping between Lexical NodeKeys and Loro TreeIDs
  */
@@ -104,16 +105,27 @@ export class NodeMapper {
      * Create a new Loro TreeNode and establish mapping
      */
     createLoroNode(nodeKey, lexicalNode, parentTreeID, index) {
+        const insertionIndex = index;
+        // Loro requires the insertion index to be within [0, children.length]. An
+        // out-of-range index means the position was computed against stale/unsynced
+        // siblings; surface it instead of silently clamping (which would drop the
+        // node at the wrong position and hide the real ordering bug).
+        if (insertionIndex !== undefined) {
+            const parentNode = parentTreeID !== undefined ? this.tree.getNodeByID(parentTreeID) : null;
+            const childrenLength = parentNode
+                ? (parentNode.children()?.length ?? 0)
+                : this.tree.roots().length;
+            invariant(insertionIndex >= 0 && insertionIndex <= childrenLength, 'createLoroNode: insertion index out of range', { nodeKey, parentTreeID, insertionIndex, childrenLength });
+        }
         // Create the tree node first
-        const treeNode = this.tree.createNode(parentTreeID, index);
+        const treeNode = this.tree.createNode(parentTreeID, insertionIndex);
         // Get the TreeID from the created node
         const treeId = treeNode.id;
-        // Debug logging for parent relationship issues
+        // A requested parent must actually become this node's parent. If it does
+        // not, the CRDT structure diverges from Lexical — surface it.
         if (parentTreeID) {
             const actualParent = treeNode.parent();
-            if (!actualParent || actualParent.id !== parentTreeID) {
-                console.warn(`⚠️  Parent relationship not set correctly for ${nodeKey}: expected ${parentTreeID}, got ${actualParent?.id || 'None'}`);
-            }
+            invariant(actualParent != null && actualParent.id === parentTreeID, 'createLoroNode: parent relationship not established', { nodeKey, expected: parentTreeID, actual: actualParent?.id ?? null });
         }
         // Store basic metadata
         treeNode.data.set('createdAt', Date.now());
@@ -232,7 +244,7 @@ export class NodeMapper {
         // 2. Normal collaboration flow as nodes are created/updated
         // 
         // This method is kept for compatibility but is now a no-op.
-        console.log('📍 syncExistingNodes: Skipping sync - mappings established through TreeIntegrator');
+        console.log(' syncExistingNodes: Skipping sync - mappings established through TreeIntegrator');
     }
 }
 // Global instance to be shared across the application

package/lib/collab/loro/propagators/DecoratorNodePropagator.js

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Copyright (c) 2025-2026 Datalayer, Inc.
  * Distributed under the terms of the MIT License.
  */
 import { DecoratorNode, $isDecoratorNode } from 'lexical';

package/lib/collab/loro/propagators/ElementNodePropagator.d.ts

@@ -25,7 +25,7 @@ options?: ElementNodeMutatorOptions): TreeID;
 /**
  * Update ElementNode in Loro tree
  */
-export declare function updateElementNodeInLoro(nodeKey: NodeKey, elementType?: string, parentId?: TreeID, index?: number, metadata?: Record<string, any>, lexicalNodeJSON?: any, // JSON object from exportJSON()
+export declare function updateElementNodeInLoro(nodeKey: NodeKey, elementType?: string, parentId?: TreeID, index?: number, previousSiblingId?: TreeID, nextSiblingId?: TreeID, metadata?: Record<string, any>, lexicalNodeJSON?: any, // JSON object from exportJSON()
 options?: ElementNodeMutatorOptions): void;
 /**
  * Delete ElementNode from Loro tree