@datalayer/lexical-loro 0.2.4 → 0.2.5

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

@@ -0,0 +1,49 @@
+/**
+ * Lexical Node Propagator for Loro Tree Collaboration
+ *
+ * This module exports mutator functions for all Lexical node types
+ * to enable bidirectional synchronization with Loro Tree Loro.
+ */
+import { ElementNode, NodeKey } from 'lexical';
+import { Binding } from '../Bindings';
+import { LoroTree } from 'loro-crdt/bundler/loro_wasm';
+export * from './RootNodePropagator';
+export * from './LineBreakNodePropagator';
+export * from './ElementNodePropagator';
+export * from './TextNodePropagator';
+export * from './DecoratorNodePropagator';
+export { propagateRootNode } from './RootNodePropagator';
+export { propagateLineBreakNode } from './LineBreakNodePropagator';
+export { propagateElementNode } from './ElementNodePropagator';
+export { propagateTextNode } from './TextNodePropagator';
+export { propagateDecoratorNode } from './DecoratorNodePropagator';
+/**
+ * Type definitions for mutator options
+ */
+export interface BasePropagatorOptions {
+    binding: Binding;
+    tree: LoroTree;
+    peerId: number;
+}
+/**
+ * Unified mutator interface for all node types
+ */
+export interface NodePropagator<T = any> {
+    create: (nodeKey: NodeKey, ...args: any[]) => string;
+    update: (nodeKey: NodeKey, ...args: any[]) => void;
+    delete: (nodeKey: NodeKey, options: BasePropagatorOptions) => void;
+    createFromLoro: (treeId: string, parentNode: ElementNode, index?: number, options?: BasePropagatorOptions) => T | null;
+    updateFromLoro: (treeId: string, lexicalNode: T, newParentNode?: ElementNode, newIndex?: number, options?: BasePropagatorOptions) => void;
+    deleteFromLoro: (treeId: string, lexicalNode: T, options?: BasePropagatorOptions) => void;
+}
+/**
+ * Node type constants for identifying different Lexical node types in Loro tree
+ */
+export declare const NODE_TYPES: {
+    readonly ROOT: "root";
+    readonly ELEMENT: "element";
+    readonly TEXT: "text";
+    readonly LINEBREAK: "linebreak";
+    readonly DECORATOR: "decorator";
+};
+export type NodeType = typeof NODE_TYPES[keyof typeof NODE_TYPES];

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

@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the MIT License.
+ */
+// Root Node Propagator
+export * from './RootNodePropagator';
+// Line Break Node Propagator  
+export * from './LineBreakNodePropagator';
+// Element Node Propagator
+export * from './ElementNodePropagator';
+// Text Node Propagator
+export * from './TextNodePropagator';
+// Decorator Node Propagator
+export * from './DecoratorNodePropagator';
+// Main mutator functions for delegation
+export { propagateRootNode } from './RootNodePropagator';
+export { propagateLineBreakNode } from './LineBreakNodePropagator';
+export { propagateElementNode } from './ElementNodePropagator';
+export { propagateTextNode } from './TextNodePropagator';
+export { propagateDecoratorNode } from './DecoratorNodePropagator';
+/**
+ * Node type constants for identifying different Lexical node types in Loro tree
+ */
+export const NODE_TYPES = {
+    ROOT: 'root',
+    ELEMENT: 'element',
+    TEXT: 'text',
+    LINEBREAK: 'linebreak',
+    DECORATOR: 'decorator',
+};

package/lib/collab/loro/provider/websocket.d.ts

@@ -0,0 +1,116 @@
+import { LoroDoc, EphemeralStore, VersionVector } from 'loro-crdt';
+import { ObservableV2 } from 'lib0/observable';
+export declare const messageUpdate = "update";
+export declare const messageQuerySnapshot = "query-snapshot";
+export declare const messageEphemeral = "ephemeral";
+export declare const messageQueryEphemeral = "query-ephemeral";
+export interface LoroUpdateMessage {
+    type: 'update';
+    update: number[];
+    docId: string;
+}
+export interface EphemeralMessage {
+    type: 'ephemeral';
+    ephemeral: number[];
+    docId: string;
+}
+export interface QueryEphemeralMessage {
+    type: 'query-ephemeral';
+    docId: string;
+    clientId?: string;
+}
+export interface QuerySnapshotMessage {
+    type: 'query-snapshot';
+    docId: string;
+    clientId?: string;
+}
+export type LoroWebSocketMessage = LoroUpdateMessage | EphemeralMessage | QueryEphemeralMessage | QuerySnapshotMessage;
+/**
+ * Websocket Provider for Loro. Creates a websocket connection to sync the shared document.
+ * The document name is attached to the provided url. I.e. the following example
+ * creates a websocket connection to http://localhost:1235/my-document-name
+ */
+export declare class WebsocketProvider extends ObservableV2<any> {
+    static globalEphemeralStore: EphemeralStore | null;
+    wsServerUrl: string;
+    docId: string;
+    doc: LoroDoc | null;
+    _WS: any;
+    protocols: any[];
+    params: {};
+    ephemeralStore: any;
+    awareness: any;
+    ws: any;
+    wsconnected: boolean;
+    wsconnecting: boolean;
+    bcconnected: boolean;
+    disableBc: boolean;
+    bcChannel: string;
+    maxBackoffTime: number;
+    wsUnsuccessfulReconnects: number;
+    messageHandlers: any[];
+    _synced: boolean;
+    wsLastMessageReceived: number;
+    shouldConnect: boolean;
+    snapshotLoaded: boolean;
+    _checkInterval: any;
+    _resyncInterval: any;
+    _updateHandler: any;
+    _ephemeralUpdateIntegrator: any;
+    _exitIntegrator: any;
+    _bcSubscriber: any;
+    _lastExportedVersion: VersionVector;
+    /**
+     * @param {string} wsServerUrl
+     * @param {string} docId
+     * @param {LoroDoc} doc
+     * @param {object} opts
+     * @param {boolean} [opts.connect]
+     * @param {EphemeralStore} [opts.ephemeralStore]
+     * @param {Object<string,string>} [opts.params] specify url parameters
+     * @param {Array<string>} [opts.protocols] specify websocket protocols
+     * @param {typeof WebSocket} [opts.WebSocketPolyfill] Optionally provide a WebSocket polyfill
+     * @param {number} [opts.resyncInterval] Request server state every `resyncInterval` milliseconds
+     * @param {number} [opts.maxBackoffTime] Maximum amount of time to wait before trying to reconnect (we try to reconnect using exponential backoff)
+     * @param {boolean} [opts.disableBc] Disable cross-tab BroadcastChannel communication
+     */
+    constructor(wsServerUrl: string, docId: string, doc: LoroDoc, { connect, ephemeralStore, params, protocols, WebSocketPolyfill, resyncInterval, maxBackoffTime, disableBc }?: {
+        connect?: boolean;
+        ephemeralStore?: any;
+        params?: {};
+        protocols?: any[];
+        WebSocketPolyfill?: {
+            new (url: string | URL, protocols?: string | string[]): WebSocket;
+            prototype: WebSocket;
+            readonly CONNECTING: 0;
+            readonly OPEN: 1;
+            readonly CLOSING: 2;
+            readonly CLOSED: 3;
+        };
+        resyncInterval?: number;
+        maxBackoffTime?: number;
+        disableBc?: boolean;
+    });
+    get url(): string;
+    /**
+     * @type {boolean}
+     */
+    get synced(): boolean;
+    set synced(state: boolean);
+    destroy(): void;
+    connectBc(): void;
+    disconnectBc(): void;
+    disconnect(): void;
+    connect(): void;
+    /**
+     * Manually send a Loro document update to connected peers
+     * Call this method after making changes to the LoroDoc
+     * @param {Uint8Array} update The update bytes from LoroDoc
+     */
+    sendUpdate(update: Uint8Array): void;
+    /**
+     * Force cleanup of stale ephemeral states (for debugging)
+     * Removes user states that haven't been active for more than 5 minutes
+     */
+    cleanupStaleStates(): void;
+}