@datalayer/lexical-loro 0.2.4 → 0.2.5

package/lib/collab/yjs/servers/ws/utils.js

@@ -0,0 +1,284 @@
+import * as Y from 'yjs';
+import * as syncProtocol from 'y-protocols/sync';
+import * as awarenessProtocol from 'y-protocols/awareness';
+import * as encoding from 'lib0/encoding';
+import * as decoding from 'lib0/decoding';
+import * as map from 'lib0/map';
+import * as eventloop from 'lib0/eventloop';
+import * as yleveldb from 'y-leveldb';
+import { callbackIntegrator, isCallbackSet } from './callback';
+const CALLBACK_DEBOUNCE_WAIT = parseInt(process.env.CALLBACK_DEBOUNCE_WAIT || '2000');
+const CALLBACK_DEBOUNCE_MAXWAIT = parseInt(process.env.CALLBACK_DEBOUNCE_MAXWAIT || '10000');
+const debouncer = eventloop.createDebouncer(CALLBACK_DEBOUNCE_WAIT, CALLBACK_DEBOUNCE_MAXWAIT);
+const wsReadyStateConnecting = 0;
+const wsReadyStateOpen = 1;
+const wsReadyStateClosing = 2; // eslint-disable-line
+const wsReadyStateClosed = 3; // eslint-disable-line
+// disable gc when using snapshots!
+const gcEnabled = process.env.GC !== 'false' && process.env.GC !== '0';
+const persistenceDir = process.env.YPERSISTENCE;
+/**
+ * @type {{bindState: function(string,WSSharedDoc):void, writeState:function(string,WSSharedDoc):Promise<any>, provider: any}|null}
+ */
+let persistence = null;
+if (typeof persistenceDir === 'string') {
+    console.info('Persisting documents to "' + persistenceDir + '"');
+    // @ts-ignore
+    const ldb = new yleveldb.LeveldbPersistence(persistenceDir);
+    persistence = {
+        provider: ldb,
+        bindState: async (docName, ydoc) => {
+            const persistedYdoc = await ldb.getYDoc(docName);
+            const newUpdates = Y.encodeStateAsUpdate(ydoc);
+            ldb.storeUpdate(docName, newUpdates);
+            Y.applyUpdate(ydoc, Y.encodeStateAsUpdate(persistedYdoc));
+            ydoc.on('update', update => {
+                ldb.storeUpdate(docName, update);
+            });
+        },
+        writeState: async (docName, ydoc) => { }
+    };
+}
+/**
+ * @param {{bindState: function(string,WSSharedDoc):void,
+ * writeState:function(string,WSSharedDoc):Promise<any>,provider:any}|null} persistence_
+ */
+export const setPersistence = persistence_ => {
+    persistence = persistence_;
+};
+/**
+ * @return {null|{bindState: function(string,WSSharedDoc):void,
+  * writeState:function(string,WSSharedDoc):Promise<any>}|null} used persistence layer
+  */
+export const getPersistence = () => persistence;
+/**
+ * @type {Map<string,WSSharedDoc>}
+ */
+export const docs = new Map();
+const messageSync = 0;
+const messageAwareness = 1;
+// const messageAuth = 2
+/**
+ * @param {Uint8Array} update
+ * @param {any} _origin
+ * @param {WSSharedDoc} doc
+ * @param {any} _tr
+ */
+const updateIntegrator = (update, _origin, doc, _tr) => {
+    const encoder = encoding.createEncoder();
+    encoding.writeVarUint(encoder, messageSync);
+    syncProtocol.writeUpdate(encoder, update);
+    const message = encoding.toUint8Array(encoder);
+    doc.conns.forEach((_, conn) => send(doc, conn, message));
+};
+/**
+ * @type {(ydoc: Y.Doc) => Promise<void>}
+ */
+let contentInitializor = _ydoc => Promise.resolve();
+/**
+ * This function is called once every time a Yjs document is created. You can
+ * use it to pull data from an external source or initialize content.
+ *
+ * @param {(ydoc: Y.Doc) => Promise<void>} f
+ */
+export const setContentInitializor = (f) => {
+    contentInitializor = f;
+};
+export class WSSharedDoc extends Y.Doc {
+    name = '';
+    conns = null;
+    awareness = null;
+    whenInitialized = null;
+    /**
+     * @param {string} name
+     */
+    constructor(name) {
+        super({ gc: gcEnabled });
+        this.name = name;
+        /**
+         * Maps from conn to set of controlled user ids. Delete all user ids from awareness when this conn is closed
+         * @type {Map<Object, Set<number>>}
+         */
+        this.conns = new Map();
+        /**
+         * @type {awarenessProtocol.Awareness}
+         */
+        this.awareness = new awarenessProtocol.Awareness(this);
+        this.awareness.setLocalState(null);
+        /**
+         * @param {{ added: Array<number>, updated: Array<number>, removed: Array<number> }} changes
+         * @param {Object | null} conn Origin is the connection that made the change
+         */
+        const awarenessChangeIntegrator = ({ added, updated, removed }, conn) => {
+            const changedClients = added.concat(updated, removed);
+            if (conn !== null) {
+                const connControlledIDs = /** @type {Set<number>} */ (this.conns.get(conn));
+                if (connControlledIDs !== undefined) {
+                    added.forEach(clientID => { connControlledIDs.add(clientID); });
+                    removed.forEach(clientID => { connControlledIDs.delete(clientID); });
+                }
+            }
+            // broadcast awareness update
+            const encoder = encoding.createEncoder();
+            encoding.writeVarUint(encoder, messageAwareness);
+            encoding.writeVarUint8Array(encoder, awarenessProtocol.encodeAwarenessUpdate(this.awareness, changedClients));
+            const buff = encoding.toUint8Array(encoder);
+            this.conns.forEach((_, c) => {
+                send(this, c, buff);
+            });
+        };
+        this.awareness.on('update', awarenessChangeIntegrator);
+        this.on('update', /** @type {any} */ (updateIntegrator));
+        if (isCallbackSet) {
+            this.on('update', (_update, _origin, doc) => {
+                debouncer(() => callbackIntegrator(/** @type {WSSharedDoc} */ (doc)));
+            });
+        }
+        this.whenInitialized = contentInitializor(this);
+    }
+}
+/**
+ * Gets a Y.Doc by name, whether in memory or on disk
+ *
+ * @param {string} docname - the name of the Y.Doc to find or create
+ * @param {boolean} gc - whether to allow gc on the doc (applies only when created)
+ * @return {WSSharedDoc}
+ */
+export const getYDoc = (docname, gc = true) => map.setIfUndefined(docs, docname, () => {
+    const doc = new WSSharedDoc(docname);
+    doc.gc = gc;
+    if (persistence !== null) {
+        persistence.bindState(docname, doc);
+    }
+    docs.set(docname, doc);
+    return doc;
+});
+/**
+ * @param {any} conn
+ * @param {WSSharedDoc} doc
+ * @param {Uint8Array} message
+ */
+const messageListener = (conn, doc, message) => {
+    try {
+        const encoder = encoding.createEncoder();
+        const decoder = decoding.createDecoder(message);
+        const messageType = decoding.readVarUint(decoder);
+        switch (messageType) {
+            case messageSync:
+                encoding.writeVarUint(encoder, messageSync);
+                syncProtocol.readSyncMessage(decoder, encoder, doc, conn);
+                // If the `encoder` only contains the type of reply message and no
+                // message, there is no need to send the message. When `encoder` only
+                // contains the type of reply, its length is 1.
+                if (encoding.length(encoder) > 1) {
+                    send(doc, conn, encoding.toUint8Array(encoder));
+                }
+                break;
+            case messageAwareness: {
+                awarenessProtocol.applyAwarenessUpdate(doc.awareness, decoding.readVarUint8Array(decoder), conn);
+                break;
+            }
+        }
+    }
+    catch (err) {
+        console.error(err);
+        // @ts-ignore
+        doc.emit('error', [err]);
+    }
+};
+/**
+ * @param {WSSharedDoc} doc
+ * @param {any} conn
+ */
+const closeConn = (doc, conn) => {
+    if (doc.conns.has(conn)) {
+        /**
+         * @type {Set<number>}
+         */
+        // @ts-ignore
+        const controlledIds = doc.conns.get(conn);
+        doc.conns.delete(conn);
+        awarenessProtocol.removeAwarenessStates(doc.awareness, Array.from(controlledIds), null);
+        if (doc.conns.size === 0 && persistence !== null) {
+            // if persisted, we store state and destroy ydocument
+            persistence.writeState(doc.name, doc).then(() => {
+                doc.destroy();
+            });
+            docs.delete(doc.name);
+        }
+    }
+    conn.close();
+};
+/**
+ * @param {WSSharedDoc} doc
+ * @param {import('ws').WebSocket} conn
+ * @param {Uint8Array} m
+ */
+const send = (doc, conn, m) => {
+    if (conn.readyState !== wsReadyStateConnecting && conn.readyState !== wsReadyStateOpen) {
+        closeConn(doc, conn);
+    }
+    try {
+        conn.send(m, {}, err => { err != null && closeConn(doc, conn); });
+    }
+    catch (e) {
+        closeConn(doc, conn);
+    }
+};
+const pingTimeout = 30000;
+/**
+ * @param {import('ws').WebSocket} conn
+ * @param {import('http').IncomingMessage} req
+ * @param {any} opts
+ */
+export const setupWSConnection = (conn, req, { docName = (req.url || '').slice(1).split('?')[0], gc = true } = {}) => {
+    conn.binaryType = 'arraybuffer';
+    // get doc, initialize if it does not exist yet
+    const doc = getYDoc(docName, gc);
+    doc.conns.set(conn, new Set());
+    // listen and reply to events
+    conn.on('message', /** @param {ArrayBuffer} message */ /** @param {ArrayBuffer} message */ message => messageListener(conn, doc, new Uint8Array(message)));
+    // Check if connection is still alive
+    let pongReceived = true;
+    const pingInterval = setInterval(() => {
+        if (!pongReceived) {
+            if (doc.conns.has(conn)) {
+                closeConn(doc, conn);
+            }
+            clearInterval(pingInterval);
+        }
+        else if (doc.conns.has(conn)) {
+            pongReceived = false;
+            try {
+                conn.ping();
+            }
+            catch (e) {
+                closeConn(doc, conn);
+                clearInterval(pingInterval);
+            }
+        }
+    }, pingTimeout);
+    conn.on('close', () => {
+        closeConn(doc, conn);
+        clearInterval(pingInterval);
+    });
+    conn.on('pong', () => {
+        pongReceived = true;
+    });
+    // put the following in a variables in a block so the interval handlers don't keep in in
+    // scope
+    {
+        // send sync step 1
+        const encoder = encoding.createEncoder();
+        encoding.writeVarUint(encoder, messageSync);
+        syncProtocol.writeSyncStep1(encoder, doc);
+        send(doc, conn, encoding.toUint8Array(encoder));
+        const awarenessStates = doc.awareness.getStates();
+        if (awarenessStates.size > 0) {
+            const encoder = encoding.createEncoder();
+            encoding.writeVarUint(encoder, messageAwareness);
+            encoding.writeVarUint8Array(encoder, awarenessProtocol.encodeAwarenessUpdate(doc.awareness, Array.from(awarenessStates.keys())));
+            send(doc, conn, encoding.toUint8Array(encoder));
+        }
+    }
+};

package/lib/collab/yjs/sync/SyncCursors.d.ts

@@ -0,0 +1,39 @@
+import type { BaseSelection, NodeKey } from 'lexical';
+import type { Binding } from '../Bindings';
+import { UserState, Provider } from '../State';
+import { AnyCollabNode } from '../nodes/AnyCollabNode';
+/*****************************************************************************/
+export type CursorSelection = {
+    anchor: {
+        key: NodeKey;
+        offset: number;
+    };
+    caret: HTMLElement;
+    color: string;
+    focus: {
+        key: NodeKey;
+        offset: number;
+    };
+    name: HTMLSpanElement;
+    selections: Array<HTMLElement>;
+};
+export type Cursor = {
+    color: string;
+    name: string;
+    selection: null | CursorSelection;
+};
+export type SyncCursorPositionsOptions = {
+    getAwarenessStates?: (binding: Binding, provider: Provider) => Map<number, UserState>;
+};
+export type SyncCursorPositionsFn = (binding: Binding, provider: Provider, options?: SyncCursorPositionsOptions) => void;
+/*****************************************************************************/
+export declare function $syncLocalCursorPosition(binding: Binding, provider: Provider): void;
+/*****************************************************************************/
+export declare function getAnchorAndFocusCollabNodesForUserState(binding: Binding, userState: UserState): {
+    anchorCollabNode: AnyCollabNode;
+    anchorOffset: number;
+    focusCollabNode: AnyCollabNode;
+    focusOffset: number;
+};
+export declare function syncCursorPositions(binding: Binding, provider: Provider, options?: SyncCursorPositionsOptions): void;
+export declare function syncLexicalSelectionToYjs(binding: Binding, provider: Provider, prevSelection: null | BaseSelection, nextSelection: null | BaseSelection): void;

package/lib/collab/yjs/sync/SyncCursors.js

@@ -0,0 +1,351 @@
+import { $getNodeByKey, $getSelection, $isElementNode, $isLineBreakNode, $isRangeSelection, $isTextNode, } from 'lexical';
+import { createDOMRange, createRectsFromDOMRange } from '@lexical/selection';
+import { compareRelativePositions, createAbsolutePositionFromRelativePosition, createRelativePositionFromTypeIndex, } from 'yjs';
+import invariant from '../../utils/invariant';
+import { getPositionFromElementAndOffset } from '../utils/Utils';
+import { CollabElementNode } from '../nodes/CollabElementNode';
+import { CollabTextNode } from '../nodes/CollabTextNode';
+/*****************************************************************************/
+function $setPoint(point, key, offset) {
+    if (point.key !== key || point.offset !== offset) {
+        let anchorNode = $getNodeByKey(key);
+        if (anchorNode !== null &&
+            !$isElementNode(anchorNode) &&
+            !$isTextNode(anchorNode)) {
+            const parent = anchorNode.getParentOrThrow();
+            key = parent.getKey();
+            offset = anchorNode.getIndexWithinParent();
+            anchorNode = parent;
+        }
+        point.set(key, offset, $isElementNode(anchorNode) ? 'element' : 'text');
+    }
+}
+/*****************************************************************************/
+export function $syncLocalCursorPosition(binding, provider) {
+    const awareness = provider.awareness;
+    const localState = awareness.getLocalState();
+    if (localState === null) {
+        return;
+    }
+    const { anchorCollabNode, anchorOffset, focusCollabNode, focusOffset } = getAnchorAndFocusCollabNodesForUserState(binding, localState);
+    if (anchorCollabNode !== null && focusCollabNode !== null) {
+        const anchorKey = anchorCollabNode.getKey();
+        const focusKey = focusCollabNode.getKey();
+        const selection = $getSelection();
+        if (!$isRangeSelection(selection)) {
+            return;
+        }
+        $setPoint(selection.anchor, anchorKey, anchorOffset);
+        $setPoint(selection.focus, focusKey, focusOffset);
+    }
+}
+/*****************************************************************************/
+function createRelativePosition(point, binding) {
+    const collabNodeMap = binding.collabNodeMap;
+    const collabNode = collabNodeMap.get(point.key);
+    if (collabNode === undefined) {
+        return null;
+    }
+    let offset = point.offset;
+    let sharedType = collabNode.getSharedType();
+    if (collabNode instanceof CollabTextNode) {
+        sharedType = collabNode._parent._xmlText;
+        const currentOffset = collabNode.getOffset();
+        if (currentOffset === -1) {
+            return null;
+        }
+        offset = currentOffset + 1 + offset;
+    }
+    else if (collabNode instanceof CollabElementNode &&
+        point.type === 'element') {
+        const parent = point.getNode();
+        invariant($isElementNode(parent), 'Element point must be an element node');
+        let accumulatedOffset = 0;
+        let i = 0;
+        let node = parent.getFirstChild();
+        while (node !== null && i++ < offset) {
+            if ($isTextNode(node)) {
+                accumulatedOffset += node.getTextContentSize() + 1;
+            }
+            else {
+                accumulatedOffset++;
+            }
+            node = node.getNextSibling();
+        }
+        offset = accumulatedOffset;
+    }
+    return createRelativePositionFromTypeIndex(sharedType, offset);
+}
+function createAbsolutePosition(relativePosition, binding) {
+    return createAbsolutePositionFromRelativePosition(relativePosition, binding.doc);
+}
+function shouldUpdatePosition(currentPos, pos) {
+    if (currentPos == null) {
+        if (pos != null) {
+            return true;
+        }
+    }
+    else if (pos == null || !compareRelativePositions(currentPos, pos)) {
+        return true;
+    }
+    return false;
+}
+function createCursor(name, color) {
+    return {
+        color: color,
+        name: name,
+        selection: null,
+    };
+}
+function destroySelection(binding, selection) {
+    const cursorsContainer = binding.cursorsContainer;
+    if (cursorsContainer !== null) {
+        const selections = selection.selections;
+        const selectionsLength = selections.length;
+        for (let i = 0; i < selectionsLength; i++) {
+            cursorsContainer.removeChild(selections[i]);
+        }
+    }
+}
+function destroyCursor(binding, cursor) {
+    const selection = cursor.selection;
+    if (selection !== null) {
+        destroySelection(binding, selection);
+    }
+}
+function createCursorSelection(cursor, anchorKey, anchorOffset, focusKey, focusOffset) {
+    const color = cursor.color;
+    const caret = document.createElement('span');
+    caret.style.cssText = `position:absolute;top:0;bottom:0;right:-1px;width:1px;background-color:${color};z-index:10;`;
+    const name = document.createElement('span');
+    name.textContent = cursor.name;
+    name.style.cssText = `position:absolute;left:-2px;top:-16px;background-color:${color};color:#fff;line-height:12px;font-size:12px;padding:2px;font-family:Arial;font-weight:bold;white-space:nowrap;`;
+    caret.appendChild(name);
+    return {
+        anchor: {
+            key: anchorKey,
+            offset: anchorOffset,
+        },
+        caret,
+        color,
+        focus: {
+            key: focusKey,
+            offset: focusOffset,
+        },
+        name,
+        selections: [],
+    };
+}
+function updateCursor(binding, cursor, nextSelection, nodeMap) {
+    const editor = binding.editor;
+    const rootElement = editor.getRootElement();
+    const cursorsContainer = binding.cursorsContainer;
+    if (cursorsContainer === null || rootElement === null) {
+        return;
+    }
+    const cursorsContainerOffsetParent = cursorsContainer.offsetParent;
+    if (cursorsContainerOffsetParent === null) {
+        return;
+    }
+    const containerRect = cursorsContainerOffsetParent.getBoundingClientRect();
+    const prevSelection = cursor.selection;
+    if (nextSelection === null) {
+        if (prevSelection === null) {
+            return;
+        }
+        else {
+            cursor.selection = null;
+            destroySelection(binding, prevSelection);
+            return;
+        }
+    }
+    else {
+        cursor.selection = nextSelection;
+    }
+    const caret = nextSelection.caret;
+    const color = nextSelection.color;
+    const selections = nextSelection.selections;
+    const anchor = nextSelection.anchor;
+    const focus = nextSelection.focus;
+    const anchorKey = anchor.key;
+    const focusKey = focus.key;
+    const anchorNode = nodeMap.get(anchorKey);
+    const focusNode = nodeMap.get(focusKey);
+    if (anchorNode == null || focusNode == null) {
+        return;
+    }
+    let selectionRects;
+    // In the case of a collapsed selection on a linebreak, we need
+    // to improvise as the browser will return nothing here as <br>
+    // apparently take up no visual space :/
+    // This won't work in all cases, but it's better than just showing
+    // nothing all the time.
+    if (anchorNode === focusNode && $isLineBreakNode(anchorNode)) {
+        const brRect = editor.getElementByKey(anchorKey).getBoundingClientRect();
+        selectionRects = [brRect];
+    }
+    else {
+        const range = createDOMRange(editor, anchorNode, anchor.offset, focusNode, focus.offset);
+        if (range === null) {
+            return;
+        }
+        selectionRects = createRectsFromDOMRange(editor, range);
+    }
+    const selectionsLength = selections.length;
+    const selectionRectsLength = selectionRects.length;
+    for (let i = 0; i < selectionRectsLength; i++) {
+        const selectionRect = selectionRects[i];
+        let selection = selections[i];
+        if (selection === undefined) {
+            selection = document.createElement('span');
+            selections[i] = selection;
+            const selectionBg = document.createElement('span');
+            selection.appendChild(selectionBg);
+            cursorsContainer.appendChild(selection);
+        }
+        const top = selectionRect.top - containerRect.top;
+        const left = selectionRect.left - containerRect.left;
+        const style = `position:absolute;top:${top}px;left:${left}px;height:${selectionRect.height}px;width:${selectionRect.width}px;pointer-events:none;z-index:5;`;
+        selection.style.cssText = style;
+        selection.firstChild.style.cssText = `${style}left:0;top:0;background-color:${color};opacity:0.3;`;
+        if (i === selectionRectsLength - 1) {
+            if (caret.parentNode !== selection) {
+                selection.appendChild(caret);
+            }
+        }
+    }
+    for (let i = selectionsLength - 1; i >= selectionRectsLength; i--) {
+        const selection = selections[i];
+        cursorsContainer.removeChild(selection);
+        selections.pop();
+    }
+}
+function getCollabNodeAndOffset(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+sharedType, offset) {
+    const collabNode = sharedType._collabNode;
+    if (collabNode === undefined) {
+        return [null, 0];
+    }
+    if (collabNode instanceof CollabElementNode) {
+        const { node, offset: collabNodeOffset } = getPositionFromElementAndOffset(collabNode, offset, true);
+        if (node === null) {
+            return [collabNode, 0];
+        }
+        else {
+            return [node, collabNodeOffset];
+        }
+    }
+    return [null, 0];
+}
+function getAwarenessStatesDefault(_binding, provider) {
+    return provider.awareness.getStates();
+}
+/*****************************************************************************/
+export function getAnchorAndFocusCollabNodesForUserState(binding, userState) {
+    const { anchorPos, focusPos } = userState;
+    let anchorCollabNode = null;
+    let anchorOffset = 0;
+    let focusCollabNode = null;
+    let focusOffset = 0;
+    if (anchorPos !== null && focusPos !== null) {
+        const anchorAbsPos = createAbsolutePosition(anchorPos, binding);
+        const focusAbsPos = createAbsolutePosition(focusPos, binding);
+        if (anchorAbsPos !== null && focusAbsPos !== null) {
+            [anchorCollabNode, anchorOffset] = getCollabNodeAndOffset(anchorAbsPos.type, anchorAbsPos.index);
+            [focusCollabNode, focusOffset] = getCollabNodeAndOffset(focusAbsPos.type, focusAbsPos.index);
+        }
+    }
+    return {
+        anchorCollabNode,
+        anchorOffset,
+        focusCollabNode,
+        focusOffset,
+    };
+}
+export function syncCursorPositions(binding, provider, options) {
+    const { getAwarenessStates = getAwarenessStatesDefault } = options ?? {};
+    const awarenessStates = Array.from(getAwarenessStates(binding, provider));
+    const localClientID = binding.clientID;
+    const cursors = binding.cursors;
+    const editor = binding.editor;
+    const nodeMap = editor._editorState._nodeMap;
+    const visitedClientIDs = new Set();
+    for (let i = 0; i < awarenessStates.length; i++) {
+        const awarenessState = awarenessStates[i];
+        const [clientID, awareness] = awarenessState;
+        if (clientID !== localClientID) {
+            visitedClientIDs.add(clientID);
+            const { name, color, focusing } = awareness;
+            let selection = null;
+            let cursor = cursors.get(clientID);
+            if (cursor === undefined) {
+                cursor = createCursor(name, color);
+                cursors.set(clientID, cursor);
+            }
+            if (focusing) {
+                const { anchorCollabNode, anchorOffset, focusCollabNode, focusOffset } = getAnchorAndFocusCollabNodesForUserState(binding, awareness);
+                if (anchorCollabNode !== null && focusCollabNode !== null) {
+                    const anchorKey = anchorCollabNode.getKey();
+                    const focusKey = focusCollabNode.getKey();
+                    selection = cursor.selection;
+                    if (selection === null) {
+                        selection = createCursorSelection(cursor, anchorKey, anchorOffset, focusKey, focusOffset);
+                    }
+                    else {
+                        const anchor = selection.anchor;
+                        const focus = selection.focus;
+                        anchor.key = anchorKey;
+                        anchor.offset = anchorOffset;
+                        focus.key = focusKey;
+                        focus.offset = focusOffset;
+                    }
+                }
+            }
+            updateCursor(binding, cursor, selection, nodeMap);
+        }
+    }
+    const allClientIDs = Array.from(cursors.keys());
+    for (let i = 0; i < allClientIDs.length; i++) {
+        const clientID = allClientIDs[i];
+        if (!visitedClientIDs.has(clientID)) {
+            const cursor = cursors.get(clientID);
+            if (cursor !== undefined) {
+                destroyCursor(binding, cursor);
+                cursors.delete(clientID);
+            }
+        }
+    }
+}
+export function syncLexicalSelectionToYjs(binding, provider, prevSelection, nextSelection) {
+    const awareness = provider.awareness;
+    const localState = awareness.getLocalState();
+    if (localState === null) {
+        return;
+    }
+    const { anchorPos: currentAnchorPos, focusPos: currentFocusPos, name, color, focusing, awarenessData, } = localState;
+    let anchorPos = null;
+    let focusPos = null;
+    if (nextSelection === null ||
+        (currentAnchorPos !== null && !nextSelection.is(prevSelection))) {
+        if (prevSelection === null) {
+            return;
+        }
+    }
+    if ($isRangeSelection(nextSelection)) {
+        anchorPos = createRelativePosition(nextSelection.anchor, binding);
+        focusPos = createRelativePosition(nextSelection.focus, binding);
+    }
+    if (shouldUpdatePosition(currentAnchorPos, anchorPos) ||
+        shouldUpdatePosition(currentFocusPos, focusPos)) {
+        awareness.setLocalState({
+            ...localState,
+            anchorPos,
+            awarenessData,
+            color,
+            focusPos,
+            focusing,
+            name,
+        });
+    }
+}

package/lib/collab/yjs/sync/SyncEditorStates.d.ts

@@ -0,0 +1,10 @@
+import type { EditorState, NodeKey } from 'lexical';
+import { Text as YText, YEvent } from 'yjs';
+import { Binding } from '../Bindings';
+import { Provider } from '../State';
+import { SyncCursorPositionsFn } from './SyncCursors';
+/*****************************************************************************/
+type IntentionallyMarkedAsDirtyElement = boolean;
+export declare function syncYjsUpdatesToLexical(binding: Binding, provider: Provider, events: Array<YEvent<YText>>, isFromUndoManger: boolean, syncCursorPositionsFn?: SyncCursorPositionsFn): void;
+export declare function syncLexicalUpdatesToYjs(binding: Binding, provider: Provider, prevEditorState: EditorState, currEditorState: EditorState, dirtyElements: Map<NodeKey, IntentionallyMarkedAsDirtyElement>, dirtyLeaves: Set<NodeKey>, normalizedNodes: Set<NodeKey>, tags: Set<string>): void;
+export {};