@datalayer/lexical-loro 0.0.3 → 0.1.0

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

@@ -0,0 +1,88 @@
+import { ObservableV2 } from 'lib0/observable';
+import * as awarenessProtocol from 'y-protocols/awareness';
+export declare const messageSync = 0;
+export declare const messageQueryAwareness = 3;
+export declare const messageAwareness = 1;
+export declare const messageAuth = 2;
+/**
+ * Websocket Provider for Yjs. 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:1234/my-document-name
+ *
+ * @example
+ *   import * as Y from 'yjs'
+ *   import { WebsocketProvider } from 'y-websocket'
+ *   const doc = new Y.Doc()
+ *   const provider = new WebsocketProvider('http://localhost:1234', 'my-document-name', doc)
+ *
+ * @extends {ObservableV2<{ 'connection-close': (event: CloseEvent | null,  provider: WebsocketProvider) => any, 'status': (event: { status: 'connected' | 'disconnected' | 'connecting' }) => any, 'connection-error': (event: Event, provider: WebsocketProvider) => any, 'sync': (state: boolean) => any }>}
+ */
+export declare class WebsocketProvider extends ObservableV2<any> {
+    serverUrl: string;
+    roomname: string;
+    doc: any;
+    _WS: any;
+    protocols: any[];
+    params: {};
+    awareness: any;
+    ws: any;
+    wsconnected: boolean;
+    wsconnecting: boolean;
+    bcconnected: boolean;
+    disableBc: boolean;
+    bcChannel: string;
+    maxBackoffTime: number;
+    wsUnsuccessfulReconnects: number;
+    messageIntegrators: any[];
+    _synced: boolean;
+    wsLastMessageReceived: number;
+    shouldConnect: boolean;
+    _checkInterval: any;
+    _resyncInterval: any;
+    _updateIntegrator: any;
+    _awarenessUpdateIntegrator: any;
+    _exitIntegrator: any;
+    _bcSubscriber: any;
+    /**
+     * @param {string} serverUrl
+     * @param {string} roomname
+     * @param {Y.Doc} doc
+     * @param {object} opts
+     * @param {boolean} [opts.connect]
+     * @param {awarenessProtocol.Awareness} [opts.awareness]
+     * @param {Object<string,string>} [opts.params] specify url parameters
+     * @param {Array<string>} [opts.protocols] specify websocket protocols
+     * @param {typeof WebSocket} [opts.WebSocketPolyfill] Optionall 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(serverUrl: any, roomname: any, doc: any, { connect, awareness, params, protocols, WebSocketPolyfill, resyncInterval, maxBackoffTime, disableBc }?: {
+        connect?: boolean;
+        awareness?: awarenessProtocol.Awareness;
+        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;
+}

package/lib/collab/yjs/provider/websocket.js

@@ -0,0 +1,415 @@
+import { ObservableV2 } from 'lib0/observable';
+import * as syncProtocol from 'y-protocols/sync';
+import * as authProtocol from 'y-protocols/auth';
+import * as bc from 'lib0/broadcastchannel';
+import * as time from 'lib0/time';
+import * as encoding from 'lib0/encoding';
+import * as decoding from 'lib0/decoding';
+import * as awarenessProtocol from 'y-protocols/awareness';
+import * as math from 'lib0/math';
+import * as url from 'lib0/url';
+import * as env from 'lib0/environment';
+export const messageSync = 0;
+export const messageQueryAwareness = 3;
+export const messageAwareness = 1;
+export const messageAuth = 2;
+/**
+ *                       encoder,          decoder,          provider,          emitSynced, messageType
+ * @type {Array<function(encoding.Encoder, decoding.Decoder, WebsocketProvider, boolean,    number):void>}
+ */
+const messageIntegrators = [];
+messageIntegrators[messageSync] = (encoder, decoder, provider, emitSynced, _messageType) => {
+    encoding.writeVarUint(encoder, messageSync);
+    const syncMessageType = syncProtocol.readSyncMessage(decoder, encoder, provider.doc, provider);
+    if (emitSynced && syncMessageType === syncProtocol.messageYjsSyncStep2 &&
+        !provider.synced) {
+        provider.synced = true;
+    }
+};
+messageIntegrators[messageQueryAwareness] = (encoder, _decoder, provider, _emitSynced, _messageType) => {
+    encoding.writeVarUint(encoder, messageAwareness);
+    encoding.writeVarUint8Array(encoder, awarenessProtocol.encodeAwarenessUpdate(provider.awareness, Array.from(provider.awareness.getStates().keys())));
+};
+messageIntegrators[messageAwareness] = (_encoder, decoder, provider, _emitSynced, _messageType) => {
+    awarenessProtocol.applyAwarenessUpdate(provider.awareness, decoding.readVarUint8Array(decoder), provider);
+};
+messageIntegrators[messageAuth] = (_encoder, decoder, provider, _emitSynced, _messageType) => {
+    authProtocol.readAuthMessage(decoder, provider.doc, (_ydoc, reason) => permissionDeniedIntegrator(provider, reason));
+};
+// @todo - this should depend on awareness.outdatedTime
+const messageReconnectTimeout = 30000;
+/**
+ * @param {WebsocketProvider} provider
+ * @param {string} reason
+ */
+const permissionDeniedIntegrator = (provider, reason) => console.warn(`Permission denied to access ${provider.url}.\n${reason}`);
+/**
+ * @param {WebsocketProvider} provider
+ * @param {Uint8Array} buf
+ * @param {boolean} emitSynced
+ * @return {encoding.Encoder}
+ */
+const readMessage = (provider, buf, emitSynced) => {
+    const decoder = decoding.createDecoder(buf);
+    const encoder = encoding.createEncoder();
+    const messageType = decoding.readVarUint(decoder);
+    const messageIntegrator = provider.messageIntegrators[messageType];
+    if ( /** @type {any} */(messageIntegrator)) {
+        messageIntegrator(encoder, decoder, provider, emitSynced, messageType);
+    }
+    else {
+        console.error('Unable to compute message');
+    }
+    return encoder;
+};
+/**
+ * Outsource this function so that a new websocket connection is created immediately.
+ * I suspect that the `ws.onclose` event is not always fired if there are network issues.
+ *
+ * @param {WebsocketProvider} provider
+ * @param {WebSocket} ws
+ * @param {CloseEvent | null} event
+ */
+const closeWebsocketConnection = (provider, ws, event) => {
+    if (ws === provider.ws) {
+        provider.emit('connection-close', [event, provider]);
+        provider.ws = null;
+        ws.close();
+        provider.wsconnecting = false;
+        if (provider.wsconnected) {
+            provider.wsconnected = false;
+            provider.synced = false;
+            // update awareness (all users except local left)
+            awarenessProtocol.removeAwarenessStates(provider.awareness, Array.from(provider.awareness.getStates().keys()).filter((client) => client !== provider.doc.clientID), provider);
+            provider.emit('status', [{
+                    status: 'disconnected'
+                }]);
+        }
+        else {
+            provider.wsUnsuccessfulReconnects++;
+        }
+        // Start with no reconnect timeout and increase timeout by
+        // using exponential backoff starting with 100ms
+        setTimeout(setupWS, math.min(math.pow(2, provider.wsUnsuccessfulReconnects) * 100, provider.maxBackoffTime), provider);
+    }
+};
+/**
+ * @param {WebsocketProvider} provider
+ */
+const setupWS = (provider) => {
+    if (provider.shouldConnect && provider.ws === null) {
+        const websocket = new provider._WS(provider.url, provider.protocols);
+        websocket.binaryType = 'arraybuffer';
+        provider.ws = websocket;
+        provider.wsconnecting = true;
+        provider.wsconnected = false;
+        provider.synced = false;
+        websocket.onmessage = (event) => {
+            provider.wsLastMessageReceived = time.getUnixTime();
+            const encoder = readMessage(provider, new Uint8Array(event.data), true);
+            if (encoding.length(encoder) > 1) {
+                websocket.send(encoding.toUint8Array(encoder));
+            }
+        };
+        websocket.onerror = (event) => {
+            provider.emit('connection-error', [event, provider]);
+        };
+        websocket.onclose = (event) => {
+            closeWebsocketConnection(provider, websocket, event);
+        };
+        websocket.onopen = () => {
+            provider.wsLastMessageReceived = time.getUnixTime();
+            provider.wsconnecting = false;
+            provider.wsconnected = true;
+            provider.wsUnsuccessfulReconnects = 0;
+            provider.emit('status', [{
+                    status: 'connected'
+                }]);
+            // always send sync step 1 when connected
+            const encoder = encoding.createEncoder();
+            encoding.writeVarUint(encoder, messageSync);
+            syncProtocol.writeSyncStep1(encoder, provider.doc);
+            websocket.send(encoding.toUint8Array(encoder));
+            // broadcast local awareness state
+            if (provider.awareness.getLocalState() !== null) {
+                const encoderAwarenessState = encoding.createEncoder();
+                encoding.writeVarUint(encoderAwarenessState, messageAwareness);
+                encoding.writeVarUint8Array(encoderAwarenessState, awarenessProtocol.encodeAwarenessUpdate(provider.awareness, [
+                    provider.doc.clientID
+                ]));
+                websocket.send(encoding.toUint8Array(encoderAwarenessState));
+            }
+        };
+        provider.emit('status', [{
+                status: 'connecting'
+            }]);
+    }
+};
+/**
+ * @param {WebsocketProvider} provider
+ * @param {ArrayBuffer} buf
+ */
+const broadcastMessage = (provider, buf) => {
+    const ws = provider.ws;
+    if (provider.wsconnected && ws && ws.readyState === ws.OPEN) {
+        ws.send(buf);
+    }
+    if (provider.bcconnected) {
+        bc.publish(provider.bcChannel, buf, provider);
+    }
+};
+/**
+ * Websocket Provider for Yjs. 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:1234/my-document-name
+ *
+ * @example
+ *   import * as Y from 'yjs'
+ *   import { WebsocketProvider } from 'y-websocket'
+ *   const doc = new Y.Doc()
+ *   const provider = new WebsocketProvider('http://localhost:1234', 'my-document-name', doc)
+ *
+ * @extends {ObservableV2<{ 'connection-close': (event: CloseEvent | null,  provider: WebsocketProvider) => any, 'status': (event: { status: 'connected' | 'disconnected' | 'connecting' }) => any, 'connection-error': (event: Event, provider: WebsocketProvider) => any, 'sync': (state: boolean) => any }>}
+ */
+export class WebsocketProvider extends ObservableV2 {
+    serverUrl = '';
+    roomname = '';
+    doc = null;
+    _WS = null;
+    protocols = [];
+    params = {};
+    awareness = null;
+    ws = null;
+    wsconnected = false;
+    wsconnecting = false;
+    bcconnected = false;
+    disableBc = false;
+    bcChannel = '';
+    maxBackoffTime = 2500;
+    wsUnsuccessfulReconnects = 0;
+    messageIntegrators = [];
+    _synced = false;
+    wsLastMessageReceived = 0;
+    shouldConnect = false;
+    _checkInterval = null;
+    _resyncInterval = null;
+    _updateIntegrator = null;
+    _awarenessUpdateIntegrator = null;
+    _exitIntegrator = null;
+    _bcSubscriber = null;
+    /**
+     * @param {string} serverUrl
+     * @param {string} roomname
+     * @param {Y.Doc} doc
+     * @param {object} opts
+     * @param {boolean} [opts.connect]
+     * @param {awarenessProtocol.Awareness} [opts.awareness]
+     * @param {Object<string,string>} [opts.params] specify url parameters
+     * @param {Array<string>} [opts.protocols] specify websocket protocols
+     * @param {typeof WebSocket} [opts.WebSocketPolyfill] Optionall 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(serverUrl, roomname, doc, { connect = true, awareness = new awarenessProtocol.Awareness(doc), params = {}, protocols = [], WebSocketPolyfill = WebSocket, resyncInterval = -1, maxBackoffTime = 2500, disableBc = false } = {}) {
+        super();
+        // ensure that serverUrl does not end with /
+        while (serverUrl[serverUrl.length - 1] === '/') {
+            serverUrl = serverUrl.slice(0, serverUrl.length - 1);
+        }
+        this.serverUrl = serverUrl;
+        this.bcChannel = serverUrl + '/' + roomname;
+        this.maxBackoffTime = maxBackoffTime;
+        /**
+         * The specified url parameters. This can be safely updated. The changed parameters will be used
+         * when a new connection is established.
+         * @type {Object<string,string>}
+         */
+        this.params = params;
+        this.protocols = protocols;
+        this.roomname = roomname;
+        this.doc = doc;
+        this._WS = WebSocketPolyfill;
+        this.awareness = awareness;
+        this.wsconnected = false;
+        this.wsconnecting = false;
+        this.bcconnected = false;
+        this.disableBc = disableBc;
+        this.wsUnsuccessfulReconnects = 0;
+        this.messageIntegrators = messageIntegrators.slice();
+        /**
+         * @type {boolean}
+         */
+        this._synced = false;
+        /**
+         * @type {WebSocket?}
+         */
+        this.ws = null;
+        this.wsLastMessageReceived = 0;
+        /**
+         * Whether to connect to other peers or not
+         * @type {boolean}
+         */
+        this.shouldConnect = connect;
+        /**
+         * @type {number}
+         */
+        this._resyncInterval = 0;
+        if (resyncInterval > 0) {
+            this._resyncInterval = /** @type {any} */ (setInterval(() => {
+                if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+                    // resend sync step 1
+                    const encoder = encoding.createEncoder();
+                    encoding.writeVarUint(encoder, messageSync);
+                    syncProtocol.writeSyncStep1(encoder, doc);
+                    this.ws.send(encoding.toUint8Array(encoder));
+                }
+            }, resyncInterval));
+        }
+        /**
+         * @param {ArrayBuffer} data
+         * @param {any} origin
+         */
+        this._bcSubscriber = (data, origin) => {
+            if (origin !== this) {
+                const encoder = readMessage(this, new Uint8Array(data), false);
+                if (encoding.length(encoder) > 1) {
+                    bc.publish(this.bcChannel, encoding.toUint8Array(encoder), this);
+                }
+            }
+        };
+        /**
+         * Listens to Yjs updates and sends them to remote peers (ws and broadcastchannel)
+         * @param {Uint8Array} update
+         * @param {any} origin
+         */
+        this._updateIntegrator = (update, origin) => {
+            if (origin !== this) {
+                const encoder = encoding.createEncoder();
+                encoding.writeVarUint(encoder, messageSync);
+                syncProtocol.writeUpdate(encoder, update);
+                broadcastMessage(this, encoding.toUint8Array(encoder));
+            }
+        };
+        this.doc.on('update', this._updateIntegrator);
+        /**
+         * @param {any} changed
+         * @param {any} _origin
+         */
+        this._awarenessUpdateIntegrator = ({ added, updated, removed }, _origin) => {
+            const changedClients = added.concat(updated).concat(removed);
+            const encoder = encoding.createEncoder();
+            encoding.writeVarUint(encoder, messageAwareness);
+            encoding.writeVarUint8Array(encoder, awarenessProtocol.encodeAwarenessUpdate(awareness, changedClients));
+            broadcastMessage(this, encoding.toUint8Array(encoder));
+        };
+        this._exitIntegrator = () => {
+            awarenessProtocol.removeAwarenessStates(this.awareness, [doc.clientID], 'app closed');
+        };
+        if (env.isNode && typeof process !== 'undefined') {
+            process.on('exit', this._exitIntegrator);
+        }
+        awareness.on('update', this._awarenessUpdateIntegrator);
+        this._checkInterval = /** @type {any} */ (setInterval(() => {
+            if (this.wsconnected &&
+                messageReconnectTimeout <
+                    time.getUnixTime() - this.wsLastMessageReceived) {
+                // no message received in a long time - not even your own awareness
+                // updates (which are updated every 15 seconds)
+                closeWebsocketConnection(this, /** @type {WebSocket} */ (this.ws), null);
+            }
+        }, messageReconnectTimeout / 10));
+        if (connect) {
+            this.connect();
+        }
+    }
+    get url() {
+        const encodedParams = url.encodeQueryParams(this.params);
+        return this.serverUrl + '/' + this.roomname +
+            (encodedParams.length === 0 ? '' : '?' + encodedParams);
+    }
+    /**
+     * @type {boolean}
+     */
+    get synced() {
+        return this._synced;
+    }
+    set synced(state) {
+        if (this._synced !== state) {
+            this._synced = state;
+            super.emit('synced', [state]);
+            super.emit('sync', [state]);
+        }
+    }
+    destroy() {
+        if (this._resyncInterval !== 0) {
+            clearInterval(this._resyncInterval);
+        }
+        clearInterval(this._checkInterval);
+        this.disconnect();
+        if (env.isNode && typeof process !== 'undefined') {
+            process.off('exit', this._exitIntegrator);
+        }
+        this.awareness.off('update', this._awarenessUpdateIntegrator);
+        this.doc.off('update', this._updateIntegrator);
+        super.destroy();
+    }
+    connectBc() {
+        if (this.disableBc) {
+            return;
+        }
+        if (!this.bcconnected) {
+            bc.subscribe(this.bcChannel, this._bcSubscriber);
+            this.bcconnected = true;
+        }
+        // send sync step1 to bc
+        // write sync step 1
+        const encoderSync = encoding.createEncoder();
+        encoding.writeVarUint(encoderSync, messageSync);
+        syncProtocol.writeSyncStep1(encoderSync, this.doc);
+        bc.publish(this.bcChannel, encoding.toUint8Array(encoderSync), this);
+        // broadcast local state
+        const encoderState = encoding.createEncoder();
+        encoding.writeVarUint(encoderState, messageSync);
+        syncProtocol.writeSyncStep2(encoderState, this.doc);
+        bc.publish(this.bcChannel, encoding.toUint8Array(encoderState), this);
+        // write queryAwareness
+        const encoderAwarenessQuery = encoding.createEncoder();
+        encoding.writeVarUint(encoderAwarenessQuery, messageQueryAwareness);
+        bc.publish(this.bcChannel, encoding.toUint8Array(encoderAwarenessQuery), this);
+        // broadcast local awareness state
+        const encoderAwarenessState = encoding.createEncoder();
+        encoding.writeVarUint(encoderAwarenessState, messageAwareness);
+        encoding.writeVarUint8Array(encoderAwarenessState, awarenessProtocol.encodeAwarenessUpdate(this.awareness, [
+            this.doc.clientID
+        ]));
+        bc.publish(this.bcChannel, encoding.toUint8Array(encoderAwarenessState), this);
+    }
+    disconnectBc() {
+        // broadcast message with local awareness state set to null (indicating disconnect)
+        const encoder = encoding.createEncoder();
+        encoding.writeVarUint(encoder, messageAwareness);
+        encoding.writeVarUint8Array(encoder, awarenessProtocol.encodeAwarenessUpdate(this.awareness, [
+            this.doc.clientID
+        ], new Map()));
+        broadcastMessage(this, encoding.toUint8Array(encoder));
+        if (this.bcconnected) {
+            bc.unsubscribe(this.bcChannel, this._bcSubscriber);
+            this.bcconnected = false;
+        }
+    }
+    disconnect() {
+        this.shouldConnect = false;
+        this.disconnectBc();
+        if (this.ws !== null) {
+            closeWebsocketConnection(this, this.ws, null);
+        }
+    }
+    connect() {
+        this.shouldConnect = true;
+        if (!this.wsconnected && this.ws === null) {
+            setupWS(this);
+            this.connectBc();
+        }
+    }
+}

package/lib/collab/yjs/servers/ws/callback.d.ts

@@ -0,0 +1,5 @@
+export declare const isCallbackSet: boolean;
+/**
+ * @param {import('./utils.js').WSSharedDoc} doc
+ */
+export declare const callbackIntegrator: (doc: any) => void;

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

@@ -0,0 +1,72 @@
+import http from 'http';
+import * as number from 'lib0/number';
+const CALLBACK_URL = process.env.CALLBACK_URL ? new URL(process.env.CALLBACK_URL) : null;
+const CALLBACK_TIMEOUT = number.parseInt(process.env.CALLBACK_TIMEOUT || '5000');
+const CALLBACK_OBJECTS = process.env.CALLBACK_OBJECTS ? JSON.parse(process.env.CALLBACK_OBJECTS) : {};
+export const isCallbackSet = !!CALLBACK_URL;
+/**
+ * @param {import('./utils.js').WSSharedDoc} doc
+ */
+export const callbackIntegrator = (doc) => {
+    const room = doc.name;
+    const dataToSend = {
+        room,
+        data: {}
+    };
+    const sharedObjectList = Object.keys(CALLBACK_OBJECTS);
+    sharedObjectList.forEach(sharedObjectName => {
+        const sharedObjectType = CALLBACK_OBJECTS[sharedObjectName];
+        dataToSend.data[sharedObjectName] = {
+            type: sharedObjectType,
+            content: getContent(sharedObjectName, sharedObjectType, doc).toJSON()
+        };
+    });
+    if (CALLBACK_URL) {
+        callbackRequest(CALLBACK_URL, CALLBACK_TIMEOUT, dataToSend);
+    }
+};
+/**
+ * @param {URL} url
+ * @param {number} timeout
+ * @param {Object} data
+ */
+const callbackRequest = (url, timeout, data) => {
+    data = JSON.stringify(data);
+    const options = {
+        hostname: url.hostname,
+        port: url.port,
+        path: url.pathname,
+        timeout,
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'Content-Length': Buffer.byteLength(data)
+        }
+    };
+    const req = http.request(options);
+    req.on('timeout', () => {
+        console.warn('Callback request timed out.');
+        req.abort();
+    });
+    req.on('error', (e) => {
+        console.error('Callback request error.', e);
+        req.abort();
+    });
+    req.write(data);
+    req.end();
+};
+/**
+ * @param {string} objName
+ * @param {string} objType
+ * @param {import('./utils.js').WSSharedDoc} doc
+ */
+const getContent = (objName, objType, doc) => {
+    switch (objType) {
+        case 'Array': return doc.getArray(objName);
+        case 'Map': return doc.getMap(objName);
+        case 'Text': return doc.getText(objName);
+        case 'XmlFragment': return doc.getXmlFragment(objName);
+        case 'XmlElement': return doc.getXmlElement(objName);
+        default: return {};
+    }
+};

package/lib/collab/yjs/servers/ws/server.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

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

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+import { WebSocketServer } from 'ws';
+import http from 'http';
+import * as number from 'lib0/number';
+import { setupWSConnection } from './utils';
+const wss = new WebSocketServer({ noServer: true });
+const host = process.env.HOST || 'localhost';
+const port = number.parseInt(process.env.PORT || '1234');
+const server = http.createServer((_request, response) => {
+    response.writeHead(200, { 'Content-Type': 'text/plain' });
+    response.end('okay');
+});
+wss.on('connection', setupWSConnection);
+server.on('upgrade', (request, socket, head) => {
+    // You may check auth of request here..
+    // Call `wss.HandleUpgrade` *after* you checked whether the client has access
+    // (e.g. by checking cookies, or url parameters).
+    // See https://github.com/websockets/ws#client-authentication
+    wss.handleUpgrade(request, socket, head, /** @param {any} ws */ /** @param {any} ws */ ws => {
+        wss.emit('connection', ws, request);
+    });
+});
+server.listen(port, host, () => {
+    console.log(`running at '${host}' on port ${port}`);
+});

package/lib/collab/yjs/servers/ws/utils.d.ts

@@ -0,0 +1,49 @@
+import * as Y from 'yjs';
+/**
+ * @param {{bindState: function(string,WSSharedDoc):void,
+ * writeState:function(string,WSSharedDoc):Promise<any>,provider:any}|null} persistence_
+ */
+export declare const setPersistence: (persistence_: any) => void;
+/**
+ * @return {null|{bindState: function(string,WSSharedDoc):void,
+  * writeState:function(string,WSSharedDoc):Promise<any>}|null} used persistence layer
+  */
+export declare const getPersistence: () => any;
+/**
+ * @type {Map<string,WSSharedDoc>}
+ */
+export declare const docs: Map<any, any>;
+/**
+ * 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 declare const setContentInitializor: (f: any) => void;
+export declare class WSSharedDoc extends Y.Doc {
+    name: string;
+    conns: any;
+    awareness: any;
+    whenInitialized: any;
+    /**
+     * @param {string} name
+     */
+    constructor(name: any);
+}
+/**
+ * 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 declare const getYDoc: (docname: any, gc?: boolean) => WSSharedDoc;
+/**
+ * @param {import('ws').WebSocket} conn
+ * @param {import('http').IncomingMessage} req
+ * @param {any} opts
+ */
+export declare const setupWSConnection: (conn: any, req: any, { docName, gc }?: {
+    docName?: any;
+    gc?: boolean;
+}) => void;