@datalayer/lexical-loro 0.2.5 → 1.0.0

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

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

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

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

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

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

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

@@ -1,25 +0,0 @@
-#!/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

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