@datalayer/lexical-loro 0.1.0 → 0.2.2

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

@@ -1,335 +0,0 @@
-import { $createParagraphNode, $isElementNode } from 'lexical';
-import { getNodeMapper } from '../nodes/NodesMapper';
-/**
- * Create ElementNode in Loro tree
- */
-export function createElementNodeInLoro(nodeKey, elementType, // 'paragraph', 'heading', 'quote', 'link', etc.
-parentId, index, metadata, lexicalNodeJSON, // JSON object from exportJSON()
-options) {
-    const mapper = getNodeMapper();
-    // Use mapper to get or create the tree node (don't pass lexicalNode to avoid context issues)
-    const treeNode = mapper.getLoroNodeByLexicalKey(nodeKey, undefined, parentId, index);
-    // Store complete lexical node data as JSON object (without the key) if provided
-    if (lexicalNodeJSON) {
-        // Remove all key-related fields from lexical node data and store the cleaned object
-        const { key, __key, lexicalKey, ...cleanedLexicalData } = lexicalNodeJSON;
-        treeNode.data.set('lexical', cleanedLexicalData);
-    }
-    // Store only essential metadata (elementType for debug panel)
-    treeNode.data.set('elementType', elementType);
-    treeNode.data.set('createdAt', Date.now());
-    // Return the TreeID from the node's ID
-    return treeNode.id;
-}
-/**
- * Update ElementNode in Loro tree
- */
-export function updateElementNodeInLoro(nodeKey, elementType, parentId, index, metadata, lexicalNodeJSON, // JSON object from exportJSON()
-options) {
-    const mapper = getNodeMapper();
-    // Get the existing tree node using the mapper (don't pass lexicalNode to avoid context issues)
-    const treeNode = mapper.getLoroNodeByLexicalKey(nodeKey, undefined);
-    // Store the lexical node data if provided
-    if (lexicalNodeJSON) {
-        const { key, __key, lexicalKey, ...cleanedLexicalData } = lexicalNodeJSON;
-        treeNode.data.set('lexical', cleanedLexicalData);
-    }
-    // Update only essential metadata
-    if (elementType !== undefined) {
-        treeNode.data.set('elementType', elementType);
-    }
-    // Move the node if parent or position changed
-    if (parentId !== undefined || index !== undefined) {
-        // Note: For moving, we need access to tree - this might need to be propagated differently
-        const { tree } = options;
-        // CRITICAL: Prevent cycle moves - a node cannot be its own parent
-        if (parentId && treeNode.id === parentId) {
-            console.warn(`🚨 CYCLE MOVE DETECTED: Node ${treeNode.id} cannot be its own parent! Skipping move operation.`);
-            return;
-        }
-        // Debug: Check if the parent exists and its children count
-        const parentNode = parentId ? tree.getNodeByID(parentId) : null;
-        const parentChildCount = parentNode ? parentNode.children.length : tree.roots().length;
-        // Check if the node is already a child of the target parent
-        const currentParent = treeNode.parent();
-        const isAlreadyChild = currentParent?.id === parentId;
-        if (index !== undefined) {
-            let adjustedIndex = index;
-            if (!isAlreadyChild) {
-                // Moving to a new parent - check bounds against current child count
-                if (index > parentChildCount) {
-                    adjustedIndex = parentChildCount;
-                }
-            }
-            tree.move(treeNode.id, parentId, adjustedIndex);
-        }
-        else {
-            // No specific index, append to end
-            tree.move(treeNode.id, parentId, parentChildCount);
-        }
-    }
-    // The exported Lexical node data is already propagated by the mapper
-    // No additional JSON export needed since mapper propagates exportJSON automatically
-    try {
-        treeNode.data.set('lastUpdated', Date.now());
-    }
-    catch (error) {
-        console.warn(`🔄 ElementNode ${treeNode.id} container deleted during timestamp update (normal during operations):`, error.message);
-    }
-}
-/**
- * Delete ElementNode from Loro tree
- */
-export function deleteElementNodeInLoro(nodeKey, options) {
-    const mapper = getNodeMapper();
-    mapper.deleteMapping(nodeKey);
-}
-/**
- * Create ElementNode in Lexical from Loro tree data
- */
-export function createElementNodeFromLoro(treeId, parentNode, // The Lexical parent node where this should be inserted
-index, options) {
-    const { tree } = options;
-    if (!tree.has(treeId)) {
-        return null;
-    }
-    const treeNode = tree.getNodeByID(treeId);
-    if (!treeNode) {
-        return null;
-    }
-    // Get LexicalNodeData (JSON object format only)
-    const lexicalData = treeNode.data.get('lexical');
-    let elementNode;
-    if (lexicalData && typeof lexicalData === 'object') {
-        try {
-            // lexicalData is a direct JSON object, create the appropriate node type
-            const lexicalDataObj = lexicalData;
-            const nodeType = lexicalDataObj.type || lexicalDataObj.__type;
-            if (nodeType === 'paragraph') {
-                elementNode = $createParagraphNode();
-            }
-            else {
-                // For other node types, fall back to paragraph for now
-                console.warn(`Unsupported ElementNode type: ${nodeType}, creating paragraph instead`);
-                elementNode = $createParagraphNode();
-            }
-            // Apply formatting if available
-            if (lexicalDataObj.format || lexicalDataObj.__format) {
-                elementNode.setFormat(lexicalDataObj.format || lexicalDataObj.__format);
-            }
-        }
-        catch (error) {
-            console.warn('Failed to create ElementNode from JSON data for TreeID:', treeId, error);
-            return null;
-        }
-    }
-    else {
-        // No lexical JSON data found - cannot create ElementNode
-        console.warn('No lexical JSON data found for ElementNode TreeID:', treeId);
-        return null;
-    }
-    // Insert into the parent at the specified index
-    if (index !== undefined && index >= 0) {
-        parentNode.splice(index, 0, [elementNode]);
-    }
-    else {
-        parentNode.append(elementNode);
-    }
-    return elementNode;
-}
-/**
- * Update ElementNode in Lexical from Loro tree data
- */
-export function updateElementNodeFromLoro(treeId, lexicalNode, newParentNode, newIndex, options) {
-    const { tree } = options;
-    if (!tree.has(treeId)) {
-        return;
-    }
-    const treeNode = tree.getNodeByID(treeId);
-    if (!treeNode || treeNode.data.get('nodeType') !== 'element') {
-        return;
-    }
-    // Update formatting if it has changed
-    const format = treeNode.data.get('format');
-    if (format !== undefined && typeof lexicalNode.setFormat === 'function' && typeof format === 'number') {
-        lexicalNode.setFormat(format);
-    }
-    const style = treeNode.data.get('style');
-    if (style !== undefined && typeof lexicalNode.setStyle === 'function' && typeof style === 'string') {
-        lexicalNode.setStyle(style);
-    }
-    const direction = treeNode.data.get('direction');
-    if (direction !== undefined && typeof lexicalNode.setDirection === 'function' &&
-        (direction === 'ltr' || direction === 'rtl')) {
-        lexicalNode.setDirection(direction);
-    }
-    // If parent or position changed, move the node
-    if (newParentNode && newIndex !== undefined) {
-        // Remove from current location
-        lexicalNode.remove();
-        // Insert at new location
-        newParentNode.splice(newIndex, 0, [lexicalNode]);
-    }
-}
-/**
- * Delete ElementNode from Lexical
- */
-export function deleteElementNodeFromLoro(treeId, lexicalNode, options) {
-    if ($isElementNode(lexicalNode)) {
-        lexicalNode.remove();
-    }
-}
-/**
- * Utility to check if a tree node represents an ElementNode
- */
-export function isElementNodeInTree(treeId, tree) {
-    if (!tree.has(treeId)) {
-        return false;
-    }
-    const treeNode = tree.getNodeByID(treeId);
-    return treeNode?.data.get('nodeType') === 'element';
-}
-/**
- * Get ElementNode data from Loro tree
- */
-export function getElementNodeDataFromTree(treeId, tree) {
-    if (!tree.has(treeId)) {
-        return null;
-    }
-    const treeNode = tree.getNodeByID(treeId);
-    if (!treeNode || treeNode.data.get('nodeType') !== 'element') {
-        return null;
-    }
-    return {
-        nodeType: 'element',
-        elementType: treeNode.data.get('elementType'),
-        format: treeNode.data.get('format'),
-        style: treeNode.data.get('style'),
-        direction: treeNode.data.get('direction'),
-        level: treeNode.data.get('level'), // For headings
-        createdAt: treeNode.data.get('createdAt'),
-        lastUpdated: treeNode.data.get('lastUpdated'),
-    };
-}
-/**
- * Sync ElementNode children relationships in Loro tree
- */
-export function syncElementNodeChildrenInLoro(nodeKey, childKeys, options) {
-    const mapper = getNodeMapper();
-    const { tree } = options;
-    // Get the existing Loro node from the mapper
-    const treeNode = mapper.getLoroNodeByLexicalKey(nodeKey);
-    if (!treeNode || treeNode.data.get('nodeType') !== 'element') {
-        return;
-    }
-    // Store children relationships for collaborative editing
-    treeNode.data.set('childKeys', childKeys);
-    treeNode.data.set('childrenLastUpdated', Date.now());
-}
-/**
- * Main propagate method for ElementNode - propagates all mutation types
- */
-export function propagateElementNode(update, mutation, nodeKey, options) {
-    const { tree, peerId } = options;
-    switch (mutation) {
-        case 'created': {
-            const currentNode = update.editorState._nodeMap.get(nodeKey);
-            if (currentNode && $isElementNode(currentNode)) {
-                // Export node data and collect metadata within editor context
-                let parent, parentId, index;
-                let elementType;
-                const metadata = {};
-                let lexicalNodeJSON;
-                update.editorState.read(() => {
-                    // Get parent and index for proper positioning within editor state context
-                    parent = currentNode.getParent();
-                    // Get parentId from the mapper instead of constructing it manually
-                    const mapper = getNodeMapper();
-                    parentId = parent ? mapper.getTreeIDByLexicalKey(parent.getKey()) : undefined;
-                    index = currentNode.getIndexWithinParent();
-                    if (parentId) {
-                        const ownTreeID = mapper.getTreeIDByLexicalKey(nodeKey);
-                        if (ownTreeID === parentId) {
-                            parentId = undefined; // Prevent cycle
-                        }
-                    }
-                    // Determine element type
-                    elementType = currentNode.getType(); // 'paragraph', 'heading', etc.
-                    // If parent exists but doesn't have mapping yet, defer parent assignment
-                    if (parent && !parentId) {
-                        // Store the node creation but defer parent assignment
-                        parentId = undefined; // Create as orphan temporarily
-                    }
-                    // Collect metadata (format, style, direction, etc.)
-                    if (typeof currentNode.getFormat === 'function') {
-                        metadata.format = currentNode.getFormat();
-                    }
-                    if (typeof currentNode.getStyle === 'function') {
-                        metadata.style = currentNode.getStyle();
-                    }
-                    if (typeof currentNode.getDirection === 'function') {
-                        metadata.direction = currentNode.getDirection();
-                    }
-                    // Export node data within editor context where node methods are available
-                    lexicalNodeJSON = currentNode.exportJSON();
-                });
-                // Create the node in Loro after safely reading from editor state
-                createElementNodeInLoro(nodeKey, elementType, parentId, index, metadata, lexicalNodeJSON, options);
-                // If this node was created without a parent, schedule a retry to fix parent assignment
-                if (parent && !parentId) {
-                    setTimeout(() => {
-                        const mapper = getNodeMapper();
-                        const retryParentId = mapper.getTreeIDByLexicalKey(parent.getKey());
-                        if (retryParentId) {
-                            // Move the node to its correct parent now that the parent exists
-                            const loroNode = mapper.getLoroNodeByLexicalKey(nodeKey);
-                            if (loroNode && tree.has(loroNode.id)) {
-                                tree.move(loroNode.id, retryParentId, index);
-                            }
-                        }
-                    }, 10); // Small delay to allow parent to be created
-                }
-            }
-            break;
-        }
-        case 'updated': {
-            const currentNode = update.editorState._nodeMap.get(nodeKey);
-            if (currentNode && $isElementNode(currentNode)) {
-                // Use editorState.read() to safely access node methods
-                let parent, parentId, index;
-                let elementType;
-                const metadata = {};
-                // Export node data and collect metadata within editor context
-                let lexicalNodeJSON;
-                update.editorState.read(() => {
-                    // Get current position within editor state context
-                    parent = currentNode.getParent();
-                    // Get parentId from the mapper instead of constructing it manually
-                    const mapper = getNodeMapper();
-                    parentId = parent ? mapper.getTreeIDByLexicalKey(parent.getKey()) : undefined;
-                    index = currentNode.getIndexWithinParent();
-                    // Get element type and metadata
-                    elementType = currentNode.getType();
-                    if (typeof currentNode.getFormat === 'function') {
-                        metadata.format = currentNode.getFormat();
-                    }
-                    if (typeof currentNode.getStyle === 'function') {
-                        metadata.style = currentNode.getStyle();
-                    }
-                    if (typeof currentNode.getDirection === 'function') {
-                        metadata.direction = currentNode.getDirection();
-                    }
-                    // Export node data within editor context where node methods are available
-                    lexicalNodeJSON = currentNode.exportJSON();
-                });
-                // Update the node in Loro after safely reading from editor state
-                updateElementNodeInLoro(nodeKey, elementType, parentId, index, metadata, lexicalNodeJSON, options);
-            }
-            break;
-        }
-        case 'destroyed': {
-            deleteElementNodeInLoro(nodeKey, options);
-            break;
-        }
-    }
-}

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

@@ -1,57 +0,0 @@
-import { TreeID, LoroTree } from 'loro-crdt';
-import { LineBreakNode, UpdateListenerPayload, NodeKey, ElementNode } from 'lexical';
-import { Binding } from '../Bindings';
-/**
- * LineBreakNode Propagator for Loro Tree Collaboration
- *
- * LineBreakNode characteristics:
- * - Represents '\n' characters in the editor
- * - Should never have '\n' in text nodes, use LineBreakNode instead
- * - Works consistently across browsers and operating systems
- * - Is a leaf node (cannot have children)
- * - Cannot be extended/subclassed
- */
-export interface LineBreakNodeMutatorOptions {
-    binding: Binding;
-    tree: LoroTree;
-    peerId: number;
-}
-/**
- * Create LineBreakNode in Loro tree
- */
-export declare function createLineBreakNodeInLoro(nodeKey: NodeKey, parentId?: TreeID, index?: number, lexicalNodeJSON?: any, // JSON object from exportJSON()
-options?: LineBreakNodeMutatorOptions): TreeID;
-/**
- * Update LineBreakNode in Loro tree
- * Note: LineBreakNodes typically don't change much since they represent '\n'
- */
-export declare function updateLineBreakNodeInLoro(nodeKey: NodeKey, parentId?: TreeID, index?: number, lexicalNodeJSON?: any, // JSON object from exportJSON()
-options?: LineBreakNodeMutatorOptions): void;
-/**
- * Delete LineBreakNode from Loro tree
- */
-export declare function deleteLineBreakNodeInLoro(nodeKey: NodeKey, options: LineBreakNodeMutatorOptions): void;
-/**
- * Create LineBreakNode in Lexical from Loro tree data
- */
-export declare function createLineBreakNodeFromLoro(treeId: TreeID, parentNode: ElementNode, index?: number, options?: LineBreakNodeMutatorOptions): LineBreakNode;
-/**
- * Update LineBreakNode in Lexical from Loro tree data
- */
-export declare function updateLineBreakNodeFromLoro(treeId: TreeID, lexicalNode: LineBreakNode, newParentNode?: ElementNode, newIndex?: number, options?: LineBreakNodeMutatorOptions): void;
-/**
- * Delete LineBreakNode from Lexical
- */
-export declare function deleteLineBreakNodeFromLoro(treeId: TreeID, lexicalNode: LineBreakNode, options?: LineBreakNodeMutatorOptions): void;
-/**
- * Utility to check if a tree node represents a LineBreakNode
- */
-export declare function isLineBreakNodeInTree(treeId: TreeID, tree: LoroTree): boolean;
-/**
- * Get LineBreakNode data from Loro tree
- */
-export declare function getLineBreakNodeDataFromTree(treeId: TreeID, tree: LoroTree): any;
-/**
- * Main propagate method for LineBreakNode - propagates all mutation types
- */
-export declare function propagateLineBreakNode(update: UpdateListenerPayload, mutation: 'created' | 'updated' | 'destroyed', nodeKey: NodeKey, options: LineBreakNodeMutatorOptions): void;

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

@@ -1,196 +0,0 @@
-import { $createLineBreakNode, $isLineBreakNode } from 'lexical';
-import { getNodeMapper } from '../nodes/NodesMapper';
-/**
- * Create LineBreakNode in Loro tree
- */
-export function createLineBreakNodeInLoro(nodeKey, parentId, index, lexicalNodeJSON, // JSON object from exportJSON()
-options) {
-    const mapper = getNodeMapper();
-    // Use mapper to get or create the tree node (don't pass lexicalNode to avoid context issues)
-    const treeNode = mapper.getLoroNodeByLexicalKey(nodeKey, undefined, // don't pass lexicalNode to avoid context issues
-    parentId, index);
-    // Store complete lexical node data as clean JSON if provided
-    if (lexicalNodeJSON) {
-        // Store complete lexical JSON without all key-related fields
-        const { key, __key, lexicalKey, ...cleanedData } = lexicalNodeJSON;
-        treeNode.data.set('lexical', cleanedData);
-    }
-    // Store only essential metadata
-    treeNode.data.set('elementType', 'linebreak');
-    treeNode.data.set('createdAt', Date.now());
-    // The exported Lexical node data is already propagated by the mapper
-    // Return the TreeID from the node's ID
-    return treeNode.id;
-}
-/**
- * Update LineBreakNode in Loro tree
- * Note: LineBreakNodes typically don't change much since they represent '\n'
- */
-export function updateLineBreakNodeInLoro(nodeKey, parentId, index, lexicalNodeJSON, // JSON object from exportJSON()
-options) {
-    const mapper = getNodeMapper();
-    const { tree } = options;
-    // Get the existing Loro node from the mapper
-    const treeNode = mapper.getLoroNodeByLexicalKey(nodeKey, undefined);
-    if (!treeNode) {
-        return;
-    }
-    const treeId = treeNode.id;
-    // Store complete lexical node data as clean JSON if provided
-    if (lexicalNodeJSON) {
-        // Store complete lexical JSON without all key-related fields
-        const { key, __key, lexicalKey, ...cleanedData } = lexicalNodeJSON;
-        treeNode.data.set('lexical', cleanedData);
-    }
-    // Move the node if parent or position changed
-    if (parentId !== undefined || index !== undefined) {
-        tree.move(treeId, parentId, index);
-    }
-    // Update only essential metadata
-    treeNode.data.set('elementType', 'linebreak');
-    treeNode.data.set('lastUpdated', Date.now());
-}
-/**
- * Delete LineBreakNode from Loro tree
- */
-export function deleteLineBreakNodeInLoro(nodeKey, options) {
-    const mapper = getNodeMapper();
-    // Use the mapper's delete method which propagates TreeID lookup internally
-    mapper.deleteMapping(nodeKey);
-}
-/**
- * Create LineBreakNode in Lexical from Loro tree data
- */
-export function createLineBreakNodeFromLoro(treeId, parentNode, index, options) {
-    const { tree } = options;
-    if (!tree.has(treeId)) {
-        return $createLineBreakNode(); // Fallback to empty line break
-    }
-    const treeNode = tree.getNodeByID(treeId);
-    let lineBreakNode;
-    // Get LexicalNodeData (JSON object format only)
-    const lexicalData = treeNode?.data.get('lexical');
-    if (lexicalData && typeof lexicalData === 'object') {
-        // lexicalData is a direct JSON object - LineBreak nodes are simple
-        lineBreakNode = $createLineBreakNode();
-    }
-    else {
-        // No lexical data - just create a new line break node
-        lineBreakNode = $createLineBreakNode();
-    }
-    // Insert into the parent at the specified index
-    if (index !== undefined && index >= 0) {
-        parentNode.splice(index, 0, [lineBreakNode]);
-    }
-    else {
-        parentNode.append(lineBreakNode);
-    }
-    return lineBreakNode;
-}
-/**
- * Update LineBreakNode in Lexical from Loro tree data
- */
-export function updateLineBreakNodeFromLoro(treeId, lexicalNode, newParentNode, newIndex, options) {
-    // If parent or position changed, move the node
-    if (newParentNode && newIndex !== undefined) {
-        // Remove from current location
-        lexicalNode.remove();
-        // Insert at new location
-        newParentNode.splice(newIndex, 0, [lexicalNode]);
-    }
-}
-/**
- * Delete LineBreakNode from Lexical
- */
-export function deleteLineBreakNodeFromLoro(treeId, lexicalNode, options) {
-    if ($isLineBreakNode(lexicalNode)) {
-        lexicalNode.remove();
-    }
-}
-/**
- * Utility to check if a tree node represents a LineBreakNode
- */
-export function isLineBreakNodeInTree(treeId, tree) {
-    if (!tree.has(treeId)) {
-        return false;
-    }
-    const treeNode = tree.getNodeByID(treeId);
-    return treeNode?.data.get('nodeType') === 'linebreak';
-}
-/**
- * Get LineBreakNode data from Loro tree
- */
-export function getLineBreakNodeDataFromTree(treeId, tree) {
-    if (!tree.has(treeId)) {
-        return null;
-    }
-    const treeNode = tree.getNodeByID(treeId);
-    if (!treeNode || treeNode.data.get('nodeType') !== 'linebreak') {
-        return null;
-    }
-    return {
-        nodeType: 'linebreak',
-        createdAt: treeNode.data.get('createdAt'),
-        lastUpdated: treeNode.data.get('lastUpdated'),
-    };
-}
-/**
- * Main propagate method for LineBreakNode - propagates all mutation types
- */
-export function propagateLineBreakNode(update, mutation, nodeKey, options) {
-    const { tree, peerId } = options;
-    switch (mutation) {
-        case 'created': {
-            const currentNode = update.editorState._nodeMap.get(nodeKey);
-            if (currentNode && $isLineBreakNode(currentNode)) {
-                // Get parent, positioning, and JSON data using editor state context
-                const { parentId, index, lexicalNodeJSON } = update.editorState.read(() => {
-                    const parent = currentNode.getParent();
-                    // Get parentId from the mapper instead of constructing it manually
-                    const mapper = getNodeMapper();
-                    const parentId = parent ? mapper.getTreeIDByLexicalKey(parent.getKey()) : undefined;
-                    const index = currentNode.getIndexWithinParent();
-                    // Export node data as JSON object within editor context where node methods are available
-                    let lexicalNodeJSON = undefined;
-                    try {
-                        lexicalNodeJSON = currentNode.exportJSON();
-                    }
-                    catch (error) {
-                        console.warn('Failed to export node JSON in propagateLineBreakNode created:', error);
-                    }
-                    return { parentId, index, lexicalNodeJSON };
-                });
-                createLineBreakNodeInLoro(nodeKey, parentId, index, lexicalNodeJSON, options);
-            }
-            break;
-        }
-        case 'updated': {
-            const currentNode = update.editorState._nodeMap.get(nodeKey);
-            if (currentNode && $isLineBreakNode(currentNode)) {
-                // Check if position changed and export data using editor state context
-                const { parentId, index, lexicalNodeJSON } = update.editorState.read(() => {
-                    const parent = currentNode.getParent();
-                    // Get parentId from the mapper instead of constructing it manually
-                    const mapper = getNodeMapper();
-                    const parentId = parent ? mapper.getTreeIDByLexicalKey(parent.getKey()) : undefined;
-                    const index = currentNode.getIndexWithinParent();
-                    // Export node data within editor context where node methods are available
-                    let lexicalNodeJSON = undefined;
-                    try {
-                        lexicalNodeJSON = currentNode.exportJSON();
-                    }
-                    catch (error) {
-                        console.warn('Failed to export node data in propagateLineBreakNode updated:', error);
-                    }
-                    return { parentId, index, lexicalNodeJSON };
-                });
-                updateLineBreakNodeInLoro(nodeKey, parentId, index, lexicalNodeJSON, options);
-            }
-            break;
-        }
-        case 'destroyed': {
-            deleteLineBreakNodeInLoro(nodeKey, options);
-            break;
-        }
-    }
-}

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

@@ -1,55 +0,0 @@
-import { TreeID, LoroTree } from 'loro-crdt';
-import { UpdateListenerPayload, NodeKey, RootNode } from 'lexical';
-import { Binding } from '../Bindings';
-/**
- * RootNode Propagator for Loro Tree Collaboration
- *
- * The RootNode is special in Lexical:
- * - Only one RootNode exists per EditorState
- * - Cannot be subclassed or replaced
- * - Represents the contenteditable element itself
- * - Does not participate in mutation listeners
- * - Has no parent or siblings
- *
- * Note: RootNode typically doesn't need mutation handling since it's
- * always present and doesn't change structure, but we include it for completeness
- */
-export interface RootNodeMutatorOptions {
-    binding: Binding;
-    tree: LoroTree;
-    peerId: number;
-}
-/**
- * Handle RootNode creation (typically only happens once during initialization)
- */
-export declare function createRootNodeInLoro(nodeKey: NodeKey, lexicalNodeJSON?: any, // JSON object from exportJSON()
-options?: RootNodeMutatorOptions): TreeID;
-/**
- * Handle RootNode updates (rarely needed since root doesn't change much)
- */
-export declare function updateRootNodeInLoro(nodeKey: NodeKey, lexicalNodeJSON?: any, // JSON object from exportJSON()
-options?: RootNodeMutatorOptions): void;
-/**
- * Handle RootNode deletion (should rarely happen, but included for completeness)
- */
-export declare function deleteRootNodeInLoro(nodeKey: NodeKey, options: RootNodeMutatorOptions): void;
-/**
- * Create RootNode in Lexical from Loro tree data
- */
-export declare function createRootNodeFromLoro(treeId: TreeID, options: RootNodeMutatorOptions): RootNode | null;
-/**
- * Update RootNode in Lexical from Loro tree data
- */
-export declare function updateRootNodeFromLoro(treeId: TreeID, options: RootNodeMutatorOptions): void;
-/**
- * Delete RootNode in Lexical (should not happen in normal operation)
- */
-export declare function deleteRootNodeFromLoro(treeId: TreeID, options: RootNodeMutatorOptions): void;
-/**
- * Utility to check if a tree node represents a RootNode
- */
-export declare function isRootNodeInTree(treeId: TreeID, tree: LoroTree): boolean;
-/**
- * Main propagate method for RootNode - propagates all mutation types
- */
-export declare function propagateRootNode(update: UpdateListenerPayload, mutation: 'created' | 'updated' | 'destroyed', nodeKey: NodeKey, options: RootNodeMutatorOptions): void;