@datalayer/lexical-loro 0.1.0 → 0.2.1

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

@@ -1,258 +0,0 @@
-/**
- * Bidirectional mapping between Lexical NodeKeys and Loro TreeIDs
- */
-export class NodeMapper {
-    // Maps Lexical NodeKey to Loro TreeID
-    lexicalToLoro = new Map();
-    // Maps Loro TreeID to Lexical NodeKey
-    loroToLexical = new Map();
-    tree;
-    constructor(binding) {
-        this.tree = binding.tree;
-    }
-    /**
-     * Create a bidirectional mapping between Lexical NodeKey and Loro TreeID
-     */
-    createMapping(nodeKey, treeId) {
-        this.lexicalToLoro.set(nodeKey, treeId);
-        this.loroToLexical.set(treeId, nodeKey);
-    }
-    /**
-     * Remove bidirectional mapping
-     */
-    removeMapping(nodeKey, treeId) {
-        this.lexicalToLoro.delete(nodeKey);
-        this.loroToLexical.delete(treeId);
-    }
-    /**
-     * Get Loro TreeNode based on Lexical NodeKey
-     * If the node doesn't exist, create it with proper parent-child relationship
-     */
-    getLoroNodeByLexicalKey(nodeKey, lexicalNode, parentTreeID, index) {
-        // Check if mapping already exists
-        const existingTreeID = this.lexicalToLoro.get(nodeKey);
-        if (existingTreeID && this.tree.has(existingTreeID)) {
-            return this.tree.getNodeByID(existingTreeID);
-        }
-        // Get parent TreeID from Lexical node if not provided
-        if (!parentTreeID && lexicalNode) {
-            const lexicalParent = lexicalNode.getParent();
-            if (lexicalParent) {
-                const parentKey = lexicalParent.getKey();
-                parentTreeID = this.lexicalToLoro.get(parentKey);
-                // If parent doesn't exist in Loro, create it first
-                if (!parentTreeID) {
-                    const parentLoroNode = this.getLoroNodeByLexicalKey(parentKey, lexicalParent, undefined, undefined);
-                    parentTreeID = parentLoroNode.id;
-                }
-            }
-        }
-        // Get index from Lexical node if not provided
-        if (index === undefined && lexicalNode) {
-            index = lexicalNode.getIndexWithinParent();
-        }
-        // Create new tree node if it doesn't exist
-        const newTreeID = this.createLoroNode(nodeKey, lexicalNode, parentTreeID, index);
-        return this.tree.getNodeByID(newTreeID);
-    }
-    /**
-     * Get Lexical NodeKey based on Loro TreeID
-     * If the node doesn't exist in Lexical, it needs to be created externally
-     */
-    getLexicalKeyByLoroId(treeId) {
-        // Check if mapping exists
-        const existingNodeKey = this.loroToLexical.get(treeId);
-        if (existingNodeKey) {
-            return existingNodeKey;
-        }
-        // If no mapping exists, we can't create a Lexical node here
-        // The caller should integrate Lexical node creation
-        return null;
-    }
-    /**
-     * Get Lexical Node from EditorState based on Loro TreeID
-     */
-    getLexicalNodeByLoroId(treeId, editorState) {
-        const nodeKey = this.getLexicalKeyByLoroId(treeId);
-        if (!nodeKey) {
-            return null;
-        }
-        return editorState._nodeMap.get(nodeKey) || null;
-    }
-    /**
-     * Get Lexical parent node key for a Loro TreeID
-     * Returns null if no parent or if parent not found in Lexical
-     * Note: This method needs the LoroTree API to be clarified for parent relationships
-     */
-    getLexicalParentByLoroId(treeId, loroTree) {
-        // TODO: Implement once LoroTree parent API is confirmed
-        // For now, we'll rely on the bidirectional mapping without tree traversal
-        return null;
-    }
-    /**
-     * Manually set bidirectional mapping between Lexical NodeKey and Loro TreeID
-     */
-    setMapping(nodeKey, treeId) {
-        this.lexicalToLoro.set(nodeKey, treeId);
-        this.loroToLexical.set(treeId, nodeKey);
-    }
-    /**
-     * Create a new Loro TreeNode and establish mapping
-     */
-    createLoroNode(nodeKey, lexicalNode, parentTreeID, index) {
-        // Create the tree node first
-        const treeNode = this.tree.createNode(parentTreeID, index);
-        // Get the TreeID from the created node
-        const treeId = treeNode.id;
-        // Debug logging for parent relationship issues
-        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'}`);
-            }
-        }
-        // Store basic metadata
-        treeNode.data.set('createdAt', Date.now());
-        // Store complete lexical node data if lexical node is provided
-        if (lexicalNode) {
-            try {
-                const lexicalNodeJSON = lexicalNode.exportJSON();
-                // Remove all key-related fields to avoid duplication (TreeID serves as the key)
-                if ('key' in lexicalNodeJSON || '__key' in lexicalNodeJSON || 'lexicalKey' in lexicalNodeJSON) {
-                    const { key, __key, lexicalKey, ...cleanedData } = lexicalNodeJSON;
-                    treeNode.data.set('lexical', cleanedData);
-                }
-                else {
-                    treeNode.data.set('lexical', lexicalNodeJSON);
-                }
-            }
-            catch (error) {
-                console.warn('Failed to export lexical node JSON in NodesMapper:', error);
-            }
-        }
-        // Create bidirectional mapping
-        this.createMapping(nodeKey, treeId);
-        return treeId;
-    }
-    /**
-     * Update the mapping when a node is moved or modified
-     */
-    updateMapping(oldNodeKey, newNodeKey) {
-        const treeId = this.lexicalToLoro.get(oldNodeKey);
-        if (treeId) {
-            this.removeMapping(oldNodeKey, treeId);
-            this.createMapping(newNodeKey, treeId);
-            // Update timestamp in tree node data
-            const treeNode = this.tree.getNodeByID(treeId);
-            if (treeNode) {
-                treeNode.data.set('updatedAt', Date.now());
-            }
-        }
-    }
-    /**
-     * Remove mapping when a node is deleted
-     */
-    deleteMapping(nodeKey) {
-        const treeId = this.lexicalToLoro.get(nodeKey);
-        if (treeId) {
-            this.removeMapping(nodeKey, treeId);
-            // Delete the tree node
-            if (this.tree.has(treeId)) {
-                this.tree.delete(treeId);
-            }
-        }
-    }
-    /**
-     * Get TreeID by Lexical NodeKey (without creating if not found)
-     */
-    getTreeIDByLexicalKey(nodeKey) {
-        return this.lexicalToLoro.get(nodeKey);
-    }
-    /**
-     * Check if a mapping exists for a Lexical NodeKey
-     */
-    hasLexicalMapping(nodeKey) {
-        return this.lexicalToLoro.has(nodeKey);
-    }
-    /**
-     * Check if a mapping exists for a Loro TreeID
-     */
-    hasLoroMapping(treeId) {
-        return this.loroToLexical.has(treeId);
-    }
-    /**
-     * Get all current mappings (for debugging)
-     */
-    getAllMappings() {
-        return {
-            lexicalToLoro: new Map(this.lexicalToLoro),
-            loroToLexical: new Map(this.loroToLexical)
-        };
-    }
-    /**
-     * Clear all mappings (useful for testing or reset)
-     */
-    clearMappings() {
-        this.lexicalToLoro.clear();
-        this.loroToLexical.clear();
-    }
-    /**
-     * Synchronize existing tree nodes with Lexical editor state
-     * This should be called during initialization to establish mappings
-     *
-     * Note: Since lexicalKey is no longer persisted in tree node data,
-     * this method now relies on the TreeIntegrator to create mappings
-     * as nodes are integrated from Loro tree operations.
-     */
-    syncExistingNodes(editorState) {
-        // Since we no longer persist lexicalKey in tree node data,
-        // we cannot automatically establish mappings from existing tree nodes.
-        // 
-        // Instead, mappings will be established through:
-        // 1. TreeIntegrator processing tree diffs during initialization
-        // 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');
-    }
-}
-// Global instance to be shared across the application
-let globalNodeMapper = null;
-/**
- * Initialize the global node mapper
- */
-export function initializeNodeMapper(binding) {
-    globalNodeMapper = new NodeMapper(binding);
-    return globalNodeMapper;
-}
-/**
- * Get the global node mapper instance
- */
-export function getNodeMapper() {
-    if (!globalNodeMapper) {
-        throw new Error('NodeMapper not initialized. Call initializeNodeMapper() first.');
-    }
-    return globalNodeMapper;
-}
-/**
- * Utility functions for common operations
- */
-/**
- * Get Loro TreeNode by Lexical NodeKey (using global mapper)
- */
-export function getLoroNodeByLexicalKey(nodeKey, lexicalNode, parentTreeID, index) {
-    return getNodeMapper().getLoroNodeByLexicalKey(nodeKey, lexicalNode, parentTreeID, index);
-}
-/**
- * Get Lexical NodeKey by Loro TreeID (using global mapper)
- */
-export function getLexicalKeyByLoroId(treeId) {
-    return getNodeMapper().getLexicalKeyByLoroId(treeId);
-}
-/**
- * Get Lexical Node by Loro TreeID (using global mapper)
- */
-export function getLexicalNodeByLoroId(treeId, editorState) {
-    return getNodeMapper().getLexicalNodeByLoroId(treeId, editorState);
-}
-// createLexicalNodeFromLoro function is now imported from NodeFactory

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

@@ -1,60 +0,0 @@
-import { TreeID, LoroTree } from 'loro-crdt';
-import { DecoratorNode, UpdateListenerPayload, NodeKey, ElementNode } from 'lexical';
-import { Binding } from '../Bindings';
-/**
- * DecoratorNode Propagator for Loro Tree Collaboration
- *
- * DecoratorNode characteristics:
- * - Wraps arbitrary view (React components, DOM nodes, etc.)
- * - Acts as opaque wrapper around external components
- * - Cannot have children in the traditional sense
- * - Renders through decorate() method which returns the view
- * - Examples: Images, Videos, Tweets, Charts, Custom Widgets
- */
-export interface DecoratorNodeMutatorOptions {
-    binding: Binding;
-    tree: LoroTree;
-    peerId: number;
-}
-/**
- * Create DecoratorNode in Loro tree
- */
-export declare function createDecoratorNodeInLoro(nodeKey: NodeKey, decoratorType: string, // 'image', 'video', 'tweet', 'chart', etc.
-decoratorData: any, // The data needed to render the decorator
-parentId?: TreeID, index?: number, metadata?: Record<string, any>, lexicalNodeJSON?: any, // JSON object from exportJSON()
-options?: DecoratorNodeMutatorOptions): TreeID;
-/**
- * Update DecoratorNode in Loro tree
- */
-export declare function updateDecoratorNodeInLoro(nodeKey: NodeKey, decoratorType?: string, decoratorData?: any, parentId?: TreeID, index?: number, metadata?: Record<string, any>, lexicalNodeJSON?: any, // JSON object from exportJSON()
-options?: DecoratorNodeMutatorOptions): void;
-/**
- * Delete DecoratorNode from Loro tree
- */
-export declare function deleteDecoratorNodeInLoro(nodeKey: NodeKey, options: DecoratorNodeMutatorOptions): void;
-/**
- * Create DecoratorNode in Lexical from Loro tree data
- * Note: This is a generic implementation. In practice, you'd need
- * specific decorator node classes for each type (ImageNode, VideoNode, etc.)
- */
-export declare function createDecoratorNodeFromLoro(treeId: TreeID, parentNode: ElementNode, index?: number, options?: DecoratorNodeMutatorOptions): DecoratorNode<any> | null;
-/**
- * Update DecoratorNode in Lexical from Loro tree data
- */
-export declare function updateDecoratorNodeFromLoro(treeId: TreeID, lexicalNode: DecoratorNode<any>, newParentNode?: ElementNode, newIndex?: number, options?: DecoratorNodeMutatorOptions): void;
-/**
- * Delete DecoratorNode from Lexical
- */
-export declare function deleteDecoratorNodeFromLoro(treeId: TreeID, lexicalNode: DecoratorNode<any>, options?: DecoratorNodeMutatorOptions): void;
-/**
- * Utility to check if a tree node represents a DecoratorNode
- */
-export declare function isDecoratorNodeInTree(treeId: TreeID, tree: LoroTree): boolean;
-/**
- * Get DecoratorNode data from Loro tree
- */
-export declare function getDecoratorNodeDataFromTree(treeId: TreeID, tree: LoroTree): any;
-/**
- * Main propagate method for DecoratorNode - propagates all mutation types
- */
-export declare function propagateDecoratorNode(update: UpdateListenerPayload, mutation: 'created' | 'updated' | 'destroyed', nodeKey: NodeKey, options: DecoratorNodeMutatorOptions): void;

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

@@ -1,302 +0,0 @@
-import { DecoratorNode, $isDecoratorNode } from 'lexical';
-import { getNodeMapper } from '../nodes/NodesMapper';
-/**
- * Create DecoratorNode in Loro tree
- */
-export function createDecoratorNodeInLoro(nodeKey, decoratorType, // 'image', 'video', 'tweet', 'chart', etc.
-decoratorData, // The data needed to render the decorator
-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, // 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', 'decorator');
-    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 DecoratorNode in Loro tree
- */
-export function updateDecoratorNodeInLoro(nodeKey, decoratorType, decoratorData, parentId, index, metadata, lexicalNodeJSON, // JSON object from exportJSON()
-options) {
-    const mapper = getNodeMapper();
-    // Get the existing Loro node from the mapper
-    const treeNode = mapper.getLoroNodeByLexicalKey(nodeKey, undefined);
-    if (!treeNode) {
-        return;
-    }
-    const { tree } = options;
-    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);
-    }
-    // All decorator information is now contained in lexical data object
-    // 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', 'decorator');
-    treeNode.data.set('lastUpdated', Date.now());
-}
-/**
- * Delete DecoratorNode from Loro tree
- */
-export function deleteDecoratorNodeInLoro(nodeKey, options) {
-    const mapper = getNodeMapper();
-    // Use the mapper's delete method which propagates TreeID lookup internally
-    mapper.deleteMapping(nodeKey);
-}
-/**
- * Create DecoratorNode in Lexical from Loro tree data
- * Note: This is a generic implementation. In practice, you'd need
- * specific decorator node classes for each type (ImageNode, VideoNode, etc.)
- */
-export function createDecoratorNodeFromLoro(treeId, parentNode, 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 decoratorNode;
-    if (lexicalData && typeof lexicalData === 'object') {
-        // For DecoratorNode, we need to propagate this case appropriately
-        // But DecoratorNodes are complex and might need special handling
-        console.warn(`DecoratorNode creation from JSON object not fully implemented for TreeID: ${treeId}`);
-        return null;
-    }
-    else {
-        // No lexical JSON data found - cannot create DecoratorNode
-        console.warn('No lexical JSON data found for DecoratorNode TreeID:', treeId);
-        return null;
-    }
-    // Insert into the parent at the specified index
-    if (index !== undefined && index >= 0) {
-        parentNode.splice(index, 0, [decoratorNode]);
-    }
-    else {
-        parentNode.append(decoratorNode);
-    }
-    return decoratorNode;
-}
-/**
- * Update DecoratorNode in Lexical from Loro tree data
- */
-export function updateDecoratorNodeFromLoro(treeId, lexicalNode, newParentNode, newIndex, options) {
-    const { tree } = options;
-    if (!tree.has(treeId)) {
-        return;
-    }
-    const treeNode = tree.getNodeByID(treeId);
-    if (!treeNode || treeNode.data.get('nodeType') !== 'decorator') {
-        return;
-    }
-    // Update decorator data if it has changed
-    const decoratorDataStr = treeNode.data.get('decoratorData');
-    let decoratorData;
-    try {
-        decoratorData = decoratorDataStr && typeof decoratorDataStr === 'string'
-            ? JSON.parse(decoratorDataStr) : {};
-    }
-    catch (error) {
-        console.warn('Failed to parse decorator data:', error);
-        decoratorData = {};
-    }
-    // Update the decorator's data (implementation depends on the specific decorator type)
-    if (typeof lexicalNode.updateData === 'function') {
-        lexicalNode.updateData(decoratorData);
-    }
-    // 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 DecoratorNode from Lexical
- */
-export function deleteDecoratorNodeFromLoro(treeId, lexicalNode, options) {
-    if ($isDecoratorNode(lexicalNode)) {
-        lexicalNode.remove();
-    }
-}
-/**
- * Utility to check if a tree node represents a DecoratorNode
- */
-export function isDecoratorNodeInTree(treeId, tree) {
-    if (!tree.has(treeId)) {
-        return false;
-    }
-    const treeNode = tree.getNodeByID(treeId);
-    return treeNode?.data.get('nodeType') === 'decorator';
-}
-/**
- * Get DecoratorNode data from Loro tree
- */
-export function getDecoratorNodeDataFromTree(treeId, tree) {
-    if (!tree.has(treeId)) {
-        return null;
-    }
-    const treeNode = tree.getNodeByID(treeId);
-    if (!treeNode || treeNode.data.get('nodeType') !== 'decorator') {
-        return null;
-    }
-    const decoratorDataStr = treeNode.data.get('decoratorData');
-    let decoratorData;
-    try {
-        decoratorData = decoratorDataStr && typeof decoratorDataStr === 'string'
-            ? JSON.parse(decoratorDataStr) : {};
-    }
-    catch (error) {
-        console.warn('Failed to parse decorator data:', error);
-        decoratorData = {};
-    }
-    return {
-        nodeType: 'decorator',
-        decoratorType: treeNode.data.get('decoratorType'),
-        decoratorData,
-        createdAt: treeNode.data.get('createdAt'),
-        lastUpdated: treeNode.data.get('lastUpdated'),
-    };
-}
-/**
- * Generic DecoratorNode implementation for demonstration purposes
- * In a real application, you'd have specific decorator node classes
- */
-class GenericDecoratorNode extends DecoratorNode {
-    __decoratorType;
-    __decoratorData;
-    constructor(decoratorType, decoratorData, key) {
-        super(key);
-        this.__decoratorType = decoratorType;
-        this.__decoratorData = decoratorData;
-    }
-    static getType() {
-        return 'generic-decorator';
-    }
-    static clone(node) {
-        return new GenericDecoratorNode(node.__decoratorType, node.__decoratorData, node.__key);
-    }
-    createDOM() {
-        const div = document.createElement('div');
-        div.className = `decorator-${this.__decoratorType}`;
-        div.textContent = `[${this.__decoratorType}]`;
-        return div;
-    }
-    updateDOM() {
-        return false;
-    }
-    decorate() {
-        return {
-            type: this.__decoratorType,
-            data: this.__decoratorData,
-        };
-    }
-    isInline() {
-        return false;
-    }
-    updateData(newData) {
-        const writable = this.getWritable();
-        writable.__decoratorData = newData;
-    }
-}
-/**
- * Main propagate method for DecoratorNode - propagates all mutation types
- */
-export function propagateDecoratorNode(update, mutation, nodeKey, options) {
-    const { tree, peerId } = options;
-    switch (mutation) {
-        case 'created': {
-            const currentNode = update.editorState._nodeMap.get(nodeKey);
-            if (currentNode && $isDecoratorNode(currentNode)) {
-                // Get node data using editor state context
-                const { parentId, index, decoratorType, decoratorData, metadata, lexicalNodeJSON } = update.editorState.read(() => {
-                    // Get parent and index for proper positioning
-                    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();
-                    // Get decorator type and data
-                    const decoratorType = currentNode.getType();
-                    // For DecoratorNode, we'll store the node's internal data instead of calling decorate
-                    const decoratorData = currentNode.__decoratorData || {};
-                    // Collect additional metadata
-                    const metadata = {};
-                    if (typeof currentNode.isInline === 'function') {
-                        metadata.isInline = currentNode.isInline();
-                    }
-                    // 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 propagateDecoratorNode created:', error);
-                    }
-                    return { parentId, index, decoratorType, decoratorData, metadata, lexicalNodeJSON };
-                });
-                createDecoratorNodeInLoro(nodeKey, decoratorType, decoratorData, parentId, index, metadata, lexicalNodeJSON, options);
-            }
-            break;
-        }
-        case 'updated': {
-            const currentNode = update.editorState._nodeMap.get(nodeKey);
-            if (currentNode && $isDecoratorNode(currentNode)) {
-                // Get node data using editor state context
-                const { parentId, index, decoratorType, decoratorData, metadata, lexicalNodeJSON } = update.editorState.read(() => {
-                    // Get current position
-                    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();
-                    // Get updated decorator type and data
-                    const decoratorType = currentNode.getType();
-                    // For DecoratorNode, we'll store the node's internal data instead of calling decorate
-                    const decoratorData = currentNode.__decoratorData || {};
-                    // Collect metadata
-                    const metadata = {};
-                    if (typeof currentNode.isInline === 'function') {
-                        metadata.isInline = currentNode.isInline();
-                    }
-                    // 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 propagateDecoratorNode updated:', error);
-                    }
-                    return { parentId, index, decoratorType, decoratorData, metadata, lexicalNodeJSON };
-                });
-                updateDecoratorNodeInLoro(nodeKey, decoratorType, decoratorData, parentId, index, metadata, lexicalNodeJSON, options);
-            }
-            break;
-        }
-        case 'destroyed': {
-            deleteDecoratorNodeInLoro(nodeKey, options);
-            break;
-        }
-    }
-}

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

@@ -1,62 +0,0 @@
-import { TreeID, LoroTree } from 'loro-crdt';
-import { ElementNode, UpdateListenerPayload, NodeKey } from 'lexical';
-import { Binding } from '../Bindings';
-/**
- * ElementNode Propagator for Loro Tree Collaboration
- *
- * ElementNode characteristics:
- * - Parent nodes that can contain other nodes (including other ElementNodes)
- * - Examples: ParagraphNode, HeadingNode, QuoteNode, LinkNode, etc.
- * - Can have formatting (bold, italic, etc.) and styles
- * - Can have children and maintain parent/child relationships
- * - Can be extended to create custom element types
- */
-export interface ElementNodeMutatorOptions {
-    binding: Binding;
-    tree: LoroTree;
-    peerId: number;
-}
-/**
- * Create ElementNode in Loro tree
- */
-export declare function createElementNodeInLoro(nodeKey: NodeKey, elementType: string, // 'paragraph', 'heading', 'quote', 'link', etc.
-parentId?: TreeID, index?: number, metadata?: Record<string, any>, lexicalNodeJSON?: any, // JSON object from exportJSON()
-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()
-options?: ElementNodeMutatorOptions): void;
-/**
- * Delete ElementNode from Loro tree
- */
-export declare function deleteElementNodeInLoro(nodeKey: NodeKey, options: ElementNodeMutatorOptions): void;
-/**
- * Create ElementNode in Lexical from Loro tree data
- */
-export declare function createElementNodeFromLoro(treeId: TreeID, parentNode: ElementNode, // The Lexical parent node where this should be inserted
-index?: number, options?: ElementNodeMutatorOptions): ElementNode | null;
-/**
- * Update ElementNode in Lexical from Loro tree data
- */
-export declare function updateElementNodeFromLoro(treeId: TreeID, lexicalNode: ElementNode, newParentNode?: ElementNode, newIndex?: number, options?: ElementNodeMutatorOptions): void;
-/**
- * Delete ElementNode from Lexical
- */
-export declare function deleteElementNodeFromLoro(treeId: TreeID, lexicalNode: ElementNode, options?: ElementNodeMutatorOptions): void;
-/**
- * Utility to check if a tree node represents an ElementNode
- */
-export declare function isElementNodeInTree(treeId: TreeID, tree: LoroTree): boolean;
-/**
- * Get ElementNode data from Loro tree
- */
-export declare function getElementNodeDataFromTree(treeId: TreeID, tree: LoroTree): any;
-/**
- * Sync ElementNode children relationships in Loro tree
- */
-export declare function syncElementNodeChildrenInLoro(nodeKey: NodeKey, childKeys: string[], options: ElementNodeMutatorOptions): void;
-/**
- * Main propagate method for ElementNode - propagates all mutation types
- */
-export declare function propagateElementNode(update: UpdateListenerPayload, mutation: 'created' | 'updated' | 'destroyed', nodeKey: NodeKey, options: ElementNodeMutatorOptions): void;