@datalayer/lexical-loro 0.1.0 → 0.2.1

package/lib/collab/yjs/LexicalCollaborationPlugin.js

@@ -1,63 +0,0 @@
-import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
-import { useEffect, useRef, useState } from 'react';
-import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext';
-import { useCollaborationContext, } from './LexicalCollaborationContext';
-import { useCollaboration, useFocusTracking, useHistory, } from './useCollaboration';
-import { createBinding } from './Bindings';
-export function CollaborationPlugin({ id, providerFactory, shouldBootstrap, username, cursorColor, cursorsContainerRef, initialEditorState, excludedProperties, awarenessData, syncCursorPositionsFn, }) {
-    const isBindingInitialized = useRef(false);
-    const isProviderInitialized = useRef(false);
-    const collabContext = useCollaborationContext(username, cursorColor);
-    const { docMap, name, color } = collabContext;
-    const [editor] = useLexicalComposerContext();
-    useEffect(() => {
-        collabContext.isCollabActive = true;
-        return () => {
-            // Resetting flag only when unmount top level editor collab plugin. Nested
-            // editors (e.g. image caption) should unmount without affecting it
-            if (editor._parentEditor == null) {
-                collabContext.isCollabActive = false;
-            }
-        };
-    }, [collabContext, editor]);
-    const [provider, setProvider] = useState();
-    const [doc, setDoc] = useState();
-    useEffect(() => {
-        if (isProviderInitialized.current) {
-            return;
-        }
-        isProviderInitialized.current = true;
-        const provider = providerFactory(id, docMap);
-        setProvider(provider);
-        setDoc(docMap.get(id));
-        return () => {
-            provider.disconnect();
-        };
-    }, [id, providerFactory, docMap]);
-    const [binding, setBinding] = useState();
-    useEffect(() => {
-        if (!provider) {
-            return;
-        }
-        if (isBindingInitialized.current) {
-            return;
-        }
-        isBindingInitialized.current = true;
-        const binding = createBinding(editor, provider, id, doc || docMap.get(id), docMap, excludedProperties);
-        setBinding(binding);
-        return () => {
-            binding.root.destroy(binding);
-        };
-    }, [editor, provider, id, docMap, doc, excludedProperties]);
-    if (!provider || !binding) {
-        return _jsx(_Fragment, {});
-    }
-    return (_jsx(YjsCollaborationCursors, { awarenessData: awarenessData, binding: binding, collabContext: collabContext, color: color, cursorsContainerRef: cursorsContainerRef, editor: editor, id: id, initialEditorState: initialEditorState, name: name, provider: provider, setDoc: setDoc, shouldBootstrap: shouldBootstrap, docMap: docMap, syncCursorPositionsFn: syncCursorPositionsFn }));
-}
-function YjsCollaborationCursors({ editor, id, provider, docMap, name, color, shouldBootstrap, cursorsContainerRef, initialEditorState, awarenessData, collabContext, binding, setDoc, syncCursorPositionsFn, }) {
-    const cursorsElement = useCollaboration(editor, id, provider, docMap, name, color, shouldBootstrap, binding, setDoc, cursorsContainerRef, initialEditorState, awarenessData, syncCursorPositionsFn);
-    collabContext.clientID = binding.clientID;
-    useHistory(editor, binding);
-    useFocusTracking(editor, provider, name, color, awarenessData);
-    return cursorsElement;
-}

package/lib/collab/yjs/State.d.ts

@@ -1,51 +0,0 @@
-import type { LexicalCommand } from 'lexical';
-import type { Doc, RelativePosition, UndoManager, XmlText } from 'yjs';
-import type { Binding } from './Bindings';
-export type UserState = {
-    anchorPos: RelativePosition | null;
-    color: string;
-    focusing: boolean;
-    focusPos: RelativePosition | null;
-    name: string;
-    awarenessData: object;
-    [key: string]: unknown;
-};
-export declare const CONNECTED_COMMAND: LexicalCommand<boolean>;
-export declare const TOGGLE_CONNECT_COMMAND: LexicalCommand<boolean>;
-export type AwarenessProvider = {
-    getLocalState: () => UserState | null;
-    getStates: () => Map<number, UserState>;
-    off: (type: 'update', cb: () => void) => void;
-    on: (type: 'update', cb: () => void) => void;
-    setLocalState: (userState: UserState) => void;
-    setLocalStateField: (field: string, value: unknown) => void;
-};
-export type Provider = {
-    awareness: AwarenessProvider;
-    connect(): void | Promise<void>;
-    disconnect(): void;
-    off(type: 'sync', cb: (isSynced: boolean) => void): void;
-    off(type: 'update', cb: (update: unknown) => void): void;
-    off(type: 'status', cb: (status: {
-        status: string;
-    }) => void): void;
-    off(type: 'reload', cb: (doc: Doc) => void): void;
-    on(type: 'sync', cb: (isSynced: boolean) => void): void;
-    on(type: 'status', cb: (status: {
-        status: string;
-    }) => void): void;
-    on(type: 'update', cb: (update: unknown) => void): void;
-    on(type: 'reload', cb: (doc: Doc) => void): void;
-};
-export type Operation = {
-    attributes: {
-        __type: string;
-    };
-    insert: string | Record<string, unknown>;
-};
-export type Delta = Array<Operation>;
-export type YjsNode = Record<string, unknown>;
-export type YjsEvent = Record<string, unknown>;
-export declare function createUndoManager(binding: Binding, root: XmlText): UndoManager;
-export declare function initLocalState(provider: Provider, name: string, color: string, focusing: boolean, awarenessData: object): void;
-export declare function setLocalStateFocus(provider: Provider, name: string, color: string, focusing: boolean, awarenessData: object): void;

package/lib/collab/yjs/State.js

@@ -1,35 +0,0 @@
-import { createCommand } from 'lexical';
-import { UndoManager as YjsUndoManager } from 'yjs';
-export const CONNECTED_COMMAND = createCommand('CONNECTED_COMMAND');
-export const TOGGLE_CONNECT_COMMAND = createCommand('TOGGLE_CONNECT_COMMAND');
-export function createUndoManager(binding, root) {
-    return new YjsUndoManager(root, {
-        trackedOrigins: new Set([binding, null]),
-    });
-}
-export function initLocalState(provider, name, color, focusing, awarenessData) {
-    provider.awareness.setLocalState({
-        anchorPos: null,
-        awarenessData,
-        color,
-        focusPos: null,
-        focusing,
-        name,
-    });
-}
-export function setLocalStateFocus(provider, name, color, focusing, awarenessData) {
-    const { awareness } = provider;
-    let localState = awareness.getLocalState();
-    if (localState === null) {
-        localState = {
-            anchorPos: null,
-            awarenessData,
-            color,
-            focusPos: null,
-            focusing: focusing,
-            name,
-        };
-    }
-    localState.focusing = focusing;
-    awareness.setLocalState(localState);
-}

package/lib/collab/yjs/nodes/AnyCollabNode.d.ts

@@ -1,5 +0,0 @@
-import { CollabDecoratorNode } from "./CollabDecoratorNode";
-import { CollabElementNode } from "./CollabElementNode";
-import { CollabLineBreakNode } from "./CollabLineBreakNode";
-import { CollabTextNode } from "./CollabTextNode";
-export type AnyCollabNode = CollabDecoratorNode | CollabElementNode | CollabTextNode | CollabLineBreakNode;

package/lib/collab/yjs/nodes/AnyCollabNode.js

@@ -1 +0,0 @@
-export {};

package/lib/collab/yjs/nodes/CollabDecoratorNode.d.ts

@@ -1,22 +0,0 @@
-import type { XmlElement } from 'yjs';
-import type { DecoratorNode, NodeKey, NodeMap } from 'lexical';
-import type { Binding } from '../Bindings';
-import type { CollabElementNode } from './CollabElementNode';
-export declare class CollabDecoratorNode {
-    _xmlElem: XmlElement;
-    _key: NodeKey;
-    _parent: CollabElementNode;
-    _type: string;
-    constructor(xmlElem: XmlElement, parent: CollabElementNode, type: string);
-    getPrevNode(nodeMap: null | NodeMap): null | DecoratorNode<unknown>;
-    getNode(): null | DecoratorNode<unknown>;
-    getSharedType(): XmlElement;
-    getType(): string;
-    getKey(): NodeKey;
-    getSize(): number;
-    getOffset(): number;
-    syncPropertiesFromLexical(binding: Binding, nextLexicalNode: DecoratorNode<unknown>, prevNodeMap: null | NodeMap): void;
-    syncPropertiesFromYjs(binding: Binding, keysChanged: null | Set<string>): void;
-    destroy(binding: Binding): void;
-}
-export declare function $createCollabDecoratorNode(xmlElem: XmlElement, parent: CollabElementNode, type: string): CollabDecoratorNode;

package/lib/collab/yjs/nodes/CollabDecoratorNode.js

@@ -1,64 +0,0 @@
-import { $getNodeByKey, $isDecoratorNode } from 'lexical';
-import invariant from '../../utils/invariant';
-import { $syncPropertiesFromYjs, syncPropertiesFromLexical } from '../utils/Utils';
-export class CollabDecoratorNode {
-    _xmlElem;
-    _key;
-    _parent;
-    _type;
-    constructor(xmlElem, parent, type) {
-        this._key = '';
-        this._xmlElem = xmlElem;
-        this._parent = parent;
-        this._type = type;
-    }
-    getPrevNode(nodeMap) {
-        if (nodeMap === null) {
-            return null;
-        }
-        const node = nodeMap.get(this._key);
-        return $isDecoratorNode(node) ? node : null;
-    }
-    getNode() {
-        const node = $getNodeByKey(this._key);
-        return $isDecoratorNode(node) ? node : null;
-    }
-    getSharedType() {
-        return this._xmlElem;
-    }
-    getType() {
-        return this._type;
-    }
-    getKey() {
-        return this._key;
-    }
-    getSize() {
-        return 1;
-    }
-    getOffset() {
-        const collabElementNode = this._parent;
-        return collabElementNode.getChildOffset(this);
-    }
-    syncPropertiesFromLexical(binding, nextLexicalNode, prevNodeMap) {
-        const prevLexicalNode = this.getPrevNode(prevNodeMap);
-        const xmlElem = this._xmlElem;
-        syncPropertiesFromLexical(binding, xmlElem, prevLexicalNode, nextLexicalNode);
-    }
-    syncPropertiesFromYjs(binding, keysChanged) {
-        const lexicalNode = this.getNode();
-        invariant(lexicalNode !== null, 'syncPropertiesFromYjs: could not find decorator node');
-        const xmlElem = this._xmlElem;
-        $syncPropertiesFromYjs(binding, xmlElem, lexicalNode, keysChanged);
-    }
-    destroy(binding) {
-        const collabNodeMap = binding.collabNodeMap;
-        if (collabNodeMap.get(this._key) === this) {
-            collabNodeMap.delete(this._key);
-        }
-    }
-}
-export function $createCollabDecoratorNode(xmlElem, parent, type) {
-    const collabNode = new CollabDecoratorNode(xmlElem, parent, type);
-    xmlElem._collabNode = collabNode;
-    return collabNode;
-}

package/lib/collab/yjs/nodes/CollabElementNode.d.ts

@@ -1,40 +0,0 @@
-import type { ElementNode, NodeKey, NodeMap } from 'lexical';
-import type { AbstractType, XmlText } from 'yjs';
-import type { Binding } from '../Bindings';
-import { AnyCollabNode } from './AnyCollabNode';
-type IntentionallyMarkedAsDirtyElement = boolean;
-export declare class CollabElementNode {
-    _key: NodeKey;
-    _children: Array<AnyCollabNode>;
-    _xmlText: XmlText;
-    _type: string;
-    _parent: null | CollabElementNode;
-    constructor(xmlText: XmlText, parent: null | CollabElementNode, type: string);
-    getPrevNode(nodeMap: null | NodeMap): null | ElementNode;
-    getNode(): null | ElementNode;
-    getSharedType(): XmlText;
-    getType(): string;
-    getKey(): NodeKey;
-    isEmpty(): boolean;
-    getSize(): number;
-    getOffset(): number;
-    syncPropertiesFromYjs(binding: Binding, keysChanged: null | Set<string>): void;
-    applyChildrenYjsDelta(binding: Binding, deltas: Array<{
-        insert?: string | object | AbstractType<unknown>;
-        delete?: number;
-        retain?: number;
-        attributes?: {
-            [x: string]: unknown;
-        };
-    }>): void;
-    syncChildrenFromYjs(binding: Binding): void;
-    syncPropertiesFromLexical(binding: Binding, nextLexicalNode: ElementNode, prevNodeMap: null | NodeMap): void;
-    _syncChildFromLexical(binding: Binding, index: number, key: NodeKey, prevNodeMap: null | NodeMap, dirtyElements: null | Map<NodeKey, IntentionallyMarkedAsDirtyElement>, dirtyLeaves: null | Set<NodeKey>): void;
-    syncChildrenFromLexical(binding: Binding, nextLexicalNode: ElementNode, prevNodeMap: null | NodeMap, dirtyElements: null | Map<NodeKey, IntentionallyMarkedAsDirtyElement>, dirtyLeaves: null | Set<NodeKey>): void;
-    append(collabNode: AnyCollabNode): void;
-    splice(binding: Binding, index: number, delCount: number, collabNode?: AnyCollabNode): void;
-    getChildOffset(collabNode: AnyCollabNode): number;
-    destroy(binding: Binding): void;
-}
-export declare function $createCollabElementNode(xmlText: XmlText, parent: null | CollabElementNode, type: string): CollabElementNode;
-export {};