@datalayer/lexical-loro 0.2.5 → 1.0.0

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

@@ -1,284 +0,0 @@
-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

@@ -1,39 +0,0 @@
-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

@@ -1,351 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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 {};