@hocuspocus/provider 1.1.0 → 2.0.0-alpha.0

package/dist/hocuspocus-provider.esm.js

@@ -1,6 +1,6 @@
 import * as Y from 'yjs';
-import { retry } from '@lifeomic/attempt';
 import { readAuthMessage, writeAuthentication, awarenessStatesToArray, WsReadyStates, Unauthorized, Forbidden } from '@hocuspocus/common';
+import { retry } from '@lifeomic/attempt';
 
 /**
  * Utility module to work with key-value stores.
@@ -1324,19 +1324,6 @@ const createMutex = () => {
   }
 };
 
-/**
- * Utility module to work with urls.
- *
- * @module url
- */
-
-/**
- * @param {Object<string,string>} params
- * @return {string}
- */
-const encodeQueryParams = params =>
-  map(params, (val, key) => `${encodeURIComponent(key)}=${encodeURIComponent(val)}`).join('&');
-
 class EventEmitter {
     constructor() {
         this.callbacks = {};
@@ -1381,12 +1368,18 @@ class IncomingMessage {
     readVarUint() {
         return readVarUint(this.decoder);
     }
+    readVarString() {
+        return readVarString(this.decoder);
+    }
     readVarUint8Array() {
         return readVarUint8Array(this.decoder);
     }
     writeVarUint(type) {
         return writeVarUint(this.encoder, type);
     }
+    writeVarString(string) {
+        return writeVarString(this.encoder, string);
+    }
     writeVarUint8Array(data) {
         return writeVarUint8Array(this.encoder, data);
     }
@@ -1561,6 +1554,7 @@ class MessageReceiver {
     apply(provider, emitSynced = true) {
         const { message } = this;
         const type = message.readVarUint();
+        const emptyMessageLength = message.length();
         switch (type) {
             case MessageType.Sync:
                 this.applySyncMessage(provider, emitSynced);
@@ -1581,7 +1575,7 @@ class MessageReceiver {
                 throw new Error(`Can’t apply message of unknown type: ${type}`);
         }
         // Reply
-        if (message.length() > 1) {
+        if (message.length() > emptyMessageLength + 1) { // length of documentName (considered in emptyMessageLength plus length of yjs sync type, set in applySyncMessage)
             if (this.broadcasted) {
                 // TODO: Some weird TypeScript error
                 // @ts-ignore
@@ -1600,7 +1594,7 @@ class MessageReceiver {
         // Apply update
         const syncMessageType = readSyncMessage(message.decoder, message.encoder, provider.document, provider);
         // Synced once we receive Step2
-        if (emitSynced && (syncMessageType === messageYjsSyncStep2)) {
+        if (emitSynced && syncMessageType === messageYjsSyncStep2) {
             provider.synced = true;
         }
         if (syncMessageType === messageYjsUpdate || syncMessageType === messageYjsSyncStep2) {
@@ -1650,6 +1644,7 @@ class SyncStepOneMessage extends OutgoingMessage {
         if (typeof args.document === 'undefined') {
             throw new Error('The sync step one message requires document as an argument');
         }
+        writeVarString(this.encoder, args.documentName);
         writeVarUint(this.encoder, this.type);
         writeSyncStep1(this.encoder, args.document);
         return this.encoder;
@@ -1666,6 +1661,7 @@ class SyncStepTwoMessage extends OutgoingMessage {
         if (typeof args.document === 'undefined') {
             throw new Error('The sync step two message requires document as an argument');
         }
+        writeVarString(this.encoder, args.documentName);
         writeVarUint(this.encoder, this.type);
         writeSyncStep2(this.encoder, args.document);
         return this.encoder;
@@ -1679,6 +1675,9 @@ class QueryAwarenessMessage extends OutgoingMessage {
         this.description = 'Queries awareness states';
     }
     get(args) {
+        console.log('queryAwareness: writing string docName', args.documentName);
+        console.log(this.encoder.cpos);
+        writeVarString(this.encoder, args.documentName);
         writeVarUint(this.encoder, this.type);
         return this.encoder;
     }
@@ -1694,6 +1693,7 @@ class AuthenticationMessage extends OutgoingMessage {
         if (typeof args.token === 'undefined') {
             throw new Error('The authentication message requires `token` as an argument.');
         }
+        writeVarString(this.encoder, args.documentName);
         writeVarUint(this.encoder, this.type);
         writeAuthentication(this.encoder, args.token);
         return this.encoder;
@@ -1713,6 +1713,7 @@ class AwarenessMessage extends OutgoingMessage {
         if (typeof args.clients === 'undefined') {
             throw new Error('The awareness message requires clients as an argument');
         }
+        writeVarString(this.encoder, args.documentName);
         writeVarUint(this.encoder, this.type);
         let awarenessUpdate;
         if (args.states === undefined) {
@@ -1733,6 +1734,7 @@ class UpdateMessage extends OutgoingMessage {
         this.description = 'A document update';
     }
     get(args) {
+        writeVarString(this.encoder, args.documentName);
         writeVarUint(this.encoder, this.type);
         writeUpdate(this.encoder, args.update);
         return this.encoder;
@@ -1747,6 +1749,7 @@ class StatelessMessage extends OutgoingMessage {
     }
     get(args) {
         var _a;
+        writeVarString(this.encoder, args.documentName);
         writeVarUint(this.encoder, this.type);
         writeVarString(this.encoder, (_a = args.payload) !== null && _a !== void 0 ? _a : '');
         return this.encoder;
@@ -1758,13 +1761,302 @@ class HocuspocusProvider extends EventEmitter {
         super();
         this.configuration = {
             name: '',
+            // @ts-ignore
+            document: undefined,
+            // @ts-ignore
+            awareness: undefined,
+            token: null,
+            parameters: {},
+            broadcast: true,
+            forceSyncInterval: false,
+            onAuthenticated: () => null,
+            onAuthenticationFailed: () => null,
+            onOpen: () => null,
+            onConnect: () => null,
+            onMessage: () => null,
+            onOutgoingMessage: () => null,
+            onStatus: () => null,
+            onSynced: () => null,
+            onDisconnect: () => null,
+            onClose: () => null,
+            onDestroy: () => null,
+            onAwarenessUpdate: () => null,
+            onAwarenessChange: () => null,
+            onStateless: () => null,
+            quiet: false,
+        };
+        this.subscribedToBroadcastChannel = false;
+        this.isSynced = false;
+        this.unsyncedChanges = 0;
+        this.status = WebSocketStatus.Disconnected;
+        this.isAuthenticated = false;
+        this.mux = createMutex();
+        this.intervals = {
+            forceSync: null,
+        };
+        this.boundBeforeUnload = this.beforeUnload.bind(this);
+        this.boundBroadcastChannelSubscriber = this.broadcastChannelSubscriber.bind(this);
+        this.setConfiguration(configuration);
+        this.configuration.document = configuration.document ? configuration.document : new Y.Doc();
+        this.configuration.awareness = configuration.awareness ? configuration.awareness : new Awareness(this.document);
+        this.on('open', this.configuration.onOpen);
+        this.on('message', this.configuration.onMessage);
+        this.on('outgoingMessage', this.configuration.onOutgoingMessage);
+        this.on('synced', this.configuration.onSynced);
+        this.on('destroy', this.configuration.onDestroy);
+        this.on('awarenessUpdate', this.configuration.onAwarenessUpdate);
+        this.on('awarenessChange', this.configuration.onAwarenessChange);
+        this.on('stateless', this.configuration.onStateless);
+        this.on('authenticated', this.configuration.onAuthenticated);
+        this.on('authenticationFailed', this.configuration.onAuthenticationFailed);
+        this.configuration.websocketProvider.on('connect', this.configuration.onConnect);
+        this.configuration.websocketProvider.on('connect', (e) => this.emit('connect', e));
+        this.configuration.websocketProvider.on('open', this.onOpen.bind(this));
+        this.configuration.websocketProvider.on('open', (e) => this.emit('open', e));
+        this.configuration.websocketProvider.on('message', this.onMessage.bind(this));
+        this.configuration.websocketProvider.on('close', this.onClose.bind(this));
+        this.configuration.websocketProvider.on('close', this.configuration.onClose);
+        this.configuration.websocketProvider.on('close', (e) => this.emit('close', e));
+        this.configuration.websocketProvider.on('status', this.onStatus.bind(this));
+        this.configuration.websocketProvider.on('disconnect', this.configuration.onDisconnect);
+        this.configuration.websocketProvider.on('disconnect', (e) => this.emit('disconnect', e));
+        this.configuration.websocketProvider.on('destroy', this.configuration.onDestroy);
+        this.configuration.websocketProvider.on('destroy', (e) => this.emit('destroy', e));
+        this.awareness.on('update', () => {
+            this.emit('awarenessUpdate', { states: awarenessStatesToArray(this.awareness.getStates()) });
+        });
+        this.awareness.on('change', () => {
+            this.emit('awarenessChange', { states: awarenessStatesToArray(this.awareness.getStates()) });
+        });
+        this.document.on('update', this.documentUpdateHandler.bind(this));
+        this.awareness.on('update', this.awarenessUpdateHandler.bind(this));
+        this.registerEventListeners();
+        if (this.configuration.forceSyncInterval) {
+            this.intervals.forceSync = setInterval(this.forceSync.bind(this), this.configuration.forceSyncInterval);
+        }
+        this.configuration.websocketProvider.attach(this);
+    }
+    onStatus({ status }) {
+        this.status = status;
+        this.configuration.onStatus({ status });
+        this.emit('status', { status });
+    }
+    setConfiguration(configuration = {}) {
+        this.configuration = { ...this.configuration, ...configuration };
+    }
+    get document() {
+        return this.configuration.document;
+    }
+    get awareness() {
+        return this.configuration.awareness;
+    }
+    get hasUnsyncedChanges() {
+        return this.unsyncedChanges > 0;
+    }
+    forceSync() {
+        this.send(SyncStepOneMessage, { document: this.document, documentName: this.configuration.name });
+    }
+    beforeUnload() {
+        removeAwarenessStates(this.awareness, [this.document.clientID], 'window unload');
+    }
+    registerEventListeners() {
+        if (typeof window === 'undefined') {
+            return;
+        }
+        window.addEventListener('beforeunload', this.boundBeforeUnload);
+    }
+    sendStateless(payload) {
+        this.send(StatelessMessage, { documentName: this.configuration.name, payload });
+    }
+    documentUpdateHandler(update, origin) {
+        if (origin === this) {
+            return;
+        }
+        this.unsyncedChanges += 1;
+        this.send(UpdateMessage, { update, documentName: this.configuration.name }, true);
+    }
+    awarenessUpdateHandler({ added, updated, removed }, origin) {
+        const changedClients = added.concat(updated).concat(removed);
+        this.send(AwarenessMessage, {
+            awareness: this.awareness,
+            clients: changedClients,
+            documentName: this.configuration.name,
+        }, true);
+    }
+    get synced() {
+        return this.isSynced;
+    }
+    set synced(state) {
+        if (this.isSynced === state) {
+            return;
+        }
+        this.isSynced = state;
+        this.emit('synced', { state });
+        this.emit('sync', { state });
+    }
+    receiveStateless(payload) {
+        this.emit('stateless', { payload });
+    }
+    get isAuthenticationRequired() {
+        return !!this.configuration.token && !this.isAuthenticated;
+    }
+    disconnect() {
+        this.disconnectBroadcastChannel();
+        this.configuration.websocketProvider.detach(this);
+    }
+    async onOpen(event) {
+        this.emit('open', { event });
+        if (this.isAuthenticationRequired) {
+            this.send(AuthenticationMessage, {
+                token: await this.getToken(),
+                documentName: this.configuration.name,
+            });
+            return;
+        }
+        this.startSync();
+    }
+    async getToken() {
+        if (typeof this.configuration.token === 'function') {
+            const token = await this.configuration.token();
+            return token;
+        }
+        return this.configuration.token;
+    }
+    startSync() {
+        this.send(SyncStepOneMessage, { document: this.document, documentName: this.configuration.name });
+        if (this.awareness.getLocalState() !== null) {
+            this.send(AwarenessMessage, {
+                awareness: this.awareness,
+                clients: [this.document.clientID],
+                documentName: this.configuration.name,
+            });
+        }
+    }
+    send(message, args, broadcast = false) {
+        if (broadcast) {
+            this.mux(() => { this.broadcast(message, args); });
+        }
+        const messageSender = new MessageSender(message, args);
+        this.emit('outgoingMessage', { message: messageSender.message });
+        messageSender.send(this.configuration.websocketProvider);
+    }
+    onMessage(event) {
+        const message = new IncomingMessage(event.data);
+        const documentName = message.readVarString();
+        if (documentName !== this.configuration.name) {
+            return; // message is meant for another provider
+        }
+        message.writeVarString(documentName);
+        this.emit('message', { event, message: new IncomingMessage(event.data) });
+        new MessageReceiver(message).apply(this);
+    }
+    onClose(event) {
+        this.isAuthenticated = false;
+        this.synced = false;
+        // update awareness (all users except local left)
+        removeAwarenessStates(this.awareness, Array.from(this.awareness.getStates().keys()).filter(client => client !== this.document.clientID), this);
+    }
+    destroy() {
+        this.emit('destroy');
+        if (this.intervals.forceSync) {
+            clearInterval(this.intervals.forceSync);
+        }
+        removeAwarenessStates(this.awareness, [this.document.clientID], 'provider destroy');
+        this.disconnect();
+        this.awareness.off('update', this.awarenessUpdateHandler);
+        this.document.off('update', this.documentUpdateHandler);
+        this.removeAllListeners();
+        if (typeof window === 'undefined') {
+            return;
+        }
+        window.removeEventListener('beforeunload', this.boundBeforeUnload);
+    }
+    permissionDeniedHandler(reason) {
+        this.emit('authenticationFailed', { reason });
+        this.isAuthenticated = false;
+        this.disconnect();
+        this.status = WebSocketStatus.Disconnected;
+    }
+    authenticatedHandler() {
+        this.isAuthenticated = true;
+        this.emit('authenticated');
+        this.startSync();
+    }
+    get broadcastChannel() {
+        return `${this.configuration.name}`;
+    }
+    broadcastChannelSubscriber(data) {
+        this.mux(() => {
+            const message = new IncomingMessage(data);
+            const documentName = message.readVarString();
+            message.writeVarString(documentName);
+            new MessageReceiver(message)
+                .setBroadcasted(true)
+                .apply(this, false);
+        });
+    }
+    subscribeToBroadcastChannel() {
+        if (!this.subscribedToBroadcastChannel) {
+            subscribe(this.broadcastChannel, this.boundBroadcastChannelSubscriber);
+            this.subscribedToBroadcastChannel = true;
+        }
+        this.mux(() => {
+            this.broadcast(SyncStepOneMessage, { document: this.document });
+            this.broadcast(SyncStepTwoMessage, { document: this.document });
+            this.broadcast(QueryAwarenessMessage, { document: this.document });
+            this.broadcast(AwarenessMessage, { awareness: this.awareness, clients: [this.document.clientID], document: this.document });
+        });
+    }
+    disconnectBroadcastChannel() {
+        // broadcast message with local awareness state set to null (indicating disconnect)
+        this.send(AwarenessMessage, {
+            awareness: this.awareness,
+            clients: [this.document.clientID],
+            states: new Map(),
+            documentName: this.configuration.name,
+        }, true);
+        if (this.subscribedToBroadcastChannel) {
+            unsubscribe(this.broadcastChannel, this.boundBroadcastChannelSubscriber);
+            this.subscribedToBroadcastChannel = false;
+        }
+    }
+    broadcast(Message, args) {
+        if (!this.configuration.broadcast) {
+            return;
+        }
+        if (!this.subscribedToBroadcastChannel) {
+            return;
+        }
+        new MessageSender(Message, args).broadcast(this.broadcastChannel);
+    }
+    setAwarenessField(key, value) {
+        this.awareness.setLocalStateField(key, value);
+    }
+}
+
+/**
+ * Utility module to work with urls.
+ *
+ * @module url
+ */
+
+/**
+ * @param {Object<string,string>} params
+ * @return {string}
+ */
+const encodeQueryParams = params =>
+  map(params, (val, key) => `${encodeURIComponent(key)}=${encodeURIComponent(val)}`).join('&');
+
+class HocuspocusProviderWebsocket extends EventEmitter {
+    constructor(configuration) {
+        super();
+        this.configuration = {
             url: '',
             // @ts-ignore
             document: undefined,
             // @ts-ignore
             awareness: undefined,
             WebSocketPolyfill: undefined,
-            token: null,
             parameters: {},
             connect: true,
             broadcast: true,
@@ -1787,29 +2079,22 @@ class HocuspocusProvider extends EventEmitter {
             jitter: true,
             // retry forever
             timeout: 0,
-            onAuthenticated: () => null,
-            onAuthenticationFailed: () => null,
             onOpen: () => null,
             onConnect: () => null,
             onMessage: () => null,
             onOutgoingMessage: () => null,
             onStatus: () => null,
-            onSynced: () => null,
             onDisconnect: () => null,
             onClose: () => null,
             onDestroy: () => null,
             onAwarenessUpdate: () => null,
             onAwarenessChange: () => null,
-            onStateless: () => null,
             quiet: false,
         };
         this.subscribedToBroadcastChannel = false;
         this.webSocket = null;
         this.shouldConnect = true;
         this.status = WebSocketStatus.Disconnected;
-        this.isSynced = false;
-        this.unsyncedChanges = 0;
-        this.isAuthenticated = false;
         this.lastMessageReceived = 0;
         this.mux = createMutex();
         this.intervals = {
@@ -1817,40 +2102,27 @@ class HocuspocusProvider extends EventEmitter {
             connectionChecker: null,
         };
         this.connectionAttempt = null;
+        this.receivedOnOpenPayload = undefined;
+        this.receivedOnStatusPayload = undefined;
         this.boundConnect = this.connect.bind(this);
-        this.boundBeforeUnload = this.beforeUnload.bind(this);
-        this.boundBroadcastChannelSubscriber = this.broadcastChannelSubscriber.bind(this);
         this.setConfiguration(configuration);
-        this.configuration.document = configuration.document ? configuration.document : new Y.Doc();
-        this.configuration.awareness = configuration.awareness ? configuration.awareness : new Awareness(this.document);
         this.configuration.WebSocketPolyfill = configuration.WebSocketPolyfill ? configuration.WebSocketPolyfill : WebSocket;
         this.on('open', this.configuration.onOpen);
-        this.on('authenticated', this.configuration.onAuthenticated);
-        this.on('authenticationFailed', this.configuration.onAuthenticationFailed);
+        this.on('open', this.onOpen.bind(this));
         this.on('connect', this.configuration.onConnect);
         this.on('message', this.configuration.onMessage);
         this.on('outgoingMessage', this.configuration.onOutgoingMessage);
-        this.on('synced', this.configuration.onSynced);
         this.on('status', this.configuration.onStatus);
+        this.on('status', this.onStatus.bind(this));
         this.on('disconnect', this.configuration.onDisconnect);
         this.on('close', this.configuration.onClose);
         this.on('destroy', this.configuration.onDestroy);
         this.on('awarenessUpdate', this.configuration.onAwarenessUpdate);
         this.on('awarenessChange', this.configuration.onAwarenessChange);
-        this.on('stateless', this.configuration.onStateless);
-        this.awareness.on('update', () => {
-            this.emit('awarenessUpdate', { states: awarenessStatesToArray(this.awareness.getStates()) });
-        });
-        this.awareness.on('change', () => {
-            this.emit('awarenessChange', { states: awarenessStatesToArray(this.awareness.getStates()) });
-        });
-        this.document.on('update', this.documentUpdateHandler.bind(this));
-        this.awareness.on('update', this.awarenessUpdateHandler.bind(this));
+        this.on('close', this.onClose.bind(this));
+        this.on('message', this.onMessage.bind(this));
         this.registerEventListeners();
         this.intervals.connectionChecker = setInterval(this.checkConnection.bind(this), this.configuration.messageReconnectTimeout / 10);
-        if (this.configuration.forceSyncInterval) {
-            this.intervals.forceSync = setInterval(this.forceSync.bind(this), this.configuration.forceSyncInterval);
-        }
         if (typeof configuration.connect !== 'undefined') {
             this.shouldConnect = configuration.connect;
         }
@@ -1859,6 +2131,23 @@ class HocuspocusProvider extends EventEmitter {
         }
         this.connect();
     }
+    async onOpen(event) {
+        this.receivedOnOpenPayload = event;
+    }
+    async onStatus(data) {
+        this.receivedOnStatusPayload = data;
+    }
+    attach(provider) {
+        if (this.receivedOnOpenPayload) {
+            provider.onOpen(this.receivedOnOpenPayload);
+        }
+        if (this.receivedOnStatusPayload) {
+            provider.onStatus(this.receivedOnStatusPayload);
+        }
+    }
+    detach(provider) {
+        // tell the server to remove the listener
+    }
     setConfiguration(configuration = {}) {
         this.configuration = { ...this.configuration, ...configuration };
     }
@@ -1871,9 +2160,7 @@ class HocuspocusProvider extends EventEmitter {
             this.cancelWebsocketRetry();
             this.cancelWebsocketRetry = undefined;
         }
-        this.unsyncedChanges = 0; // set to 0 in case we got reconnected
         this.shouldConnect = true;
-        this.subscribeToBroadcastChannel();
         const abortableRetry = () => {
             let cancelAttempt = false;
             const retryPromise = retry(this.createWebSocketConnection.bind(this), {
@@ -1917,15 +2204,14 @@ class HocuspocusProvider extends EventEmitter {
             // Init the WebSocket connection
             const ws = new this.configuration.WebSocketPolyfill(this.url);
             ws.binaryType = 'arraybuffer';
-            ws.onmessage = this.onMessage.bind(this);
-            ws.onclose = this.onClose.bind(this);
-            ws.onopen = this.onOpen.bind(this);
+            ws.onmessage = (payload) => this.emit('message', payload);
+            ws.onclose = (payload) => this.emit('close', { event: payload });
+            ws.onopen = (payload) => this.emit('open', payload);
             ws.onerror = (err) => {
                 reject(err);
             };
             this.webSocket = ws;
             // Reset the status
-            this.synced = false;
             this.status = WebSocketStatus.Connecting;
             this.emit('status', { status: WebSocketStatus.Connecting });
             // Store resolve/reject for later use
@@ -1935,13 +2221,17 @@ class HocuspocusProvider extends EventEmitter {
             };
         });
     }
+    onMessage(event) {
+        this.resolveConnectionAttempt();
+    }
     resolveConnectionAttempt() {
-        var _a;
-        (_a = this.connectionAttempt) === null || _a === void 0 ? void 0 : _a.resolve();
-        this.connectionAttempt = null;
-        this.status = WebSocketStatus.Connected;
-        this.emit('status', { status: WebSocketStatus.Connected });
-        this.emit('connect');
+        if (this.connectionAttempt) {
+            this.connectionAttempt.resolve();
+            this.connectionAttempt = null;
+            this.status = WebSocketStatus.Connected;
+            this.emit('status', { status: WebSocketStatus.Connected });
+            this.emit('connect');
+        }
     }
     stopConnectionAttempt() {
         this.connectionAttempt = null;
@@ -1951,15 +2241,6 @@ class HocuspocusProvider extends EventEmitter {
         (_a = this.connectionAttempt) === null || _a === void 0 ? void 0 : _a.reject();
         this.connectionAttempt = null;
     }
-    get document() {
-        return this.configuration.document;
-    }
-    get awareness() {
-        return this.configuration.awareness;
-    }
-    get hasUnsyncedChanges() {
-        return this.unsyncedChanges > 0;
-    }
     checkConnection() {
         var _a;
         // Don’t check the connection when it’s not even established
@@ -1978,48 +2259,11 @@ class HocuspocusProvider extends EventEmitter {
         // Awareness updates, which are updated every 15 seconds.
         (_a = this.webSocket) === null || _a === void 0 ? void 0 : _a.close();
     }
-    forceSync() {
-        if (!this.webSocket) {
-            return;
-        }
-        this.send(SyncStepOneMessage, { document: this.document });
-    }
-    beforeUnload() {
-        removeAwarenessStates(this.awareness, [this.document.clientID], 'window unload');
-    }
     registerEventListeners() {
         if (typeof window === 'undefined') {
             return;
         }
         window.addEventListener('online', this.boundConnect);
-        window.addEventListener('beforeunload', this.boundBeforeUnload);
-    }
-    sendStateless(payload) {
-        this.send(StatelessMessage, { payload });
-    }
-    documentUpdateHandler(update, origin) {
-        if (origin === this) {
-            return;
-        }
-        this.unsyncedChanges += 1;
-        this.send(UpdateMessage, { update }, true);
-    }
-    awarenessUpdateHandler({ added, updated, removed }, origin) {
-        const changedClients = added.concat(updated).concat(removed);
-        this.send(AwarenessMessage, {
-            awareness: this.awareness,
-            clients: changedClients,
-        }, true);
-    }
-    permissionDeniedHandler(reason) {
-        this.emit('authenticationFailed', { reason });
-        this.isAuthenticated = false;
-        this.shouldConnect = false;
-    }
-    authenticatedHandler() {
-        this.isAuthenticated = true;
-        this.emit('authenticated');
-        this.startSync();
     }
     // Ensure that the URL always ends with /
     get serverUrl() {
@@ -2030,28 +2274,10 @@ class HocuspocusProvider extends EventEmitter {
     }
     get url() {
         const encodedParams = encodeQueryParams(this.configuration.parameters);
-        return `${this.serverUrl}/${this.configuration.name}${encodedParams.length === 0 ? '' : `?${encodedParams}`}`;
-    }
-    get synced() {
-        return this.isSynced;
-    }
-    set synced(state) {
-        if (this.isSynced === state) {
-            return;
-        }
-        this.isSynced = state;
-        this.emit('synced', { state });
-        this.emit('sync', { state });
-    }
-    receiveStateless(payload) {
-        this.emit('stateless', { payload });
-    }
-    get isAuthenticationRequired() {
-        return !!this.configuration.token && !this.isAuthenticated;
+        return `${this.serverUrl}${encodedParams.length === 0 ? '' : `?${encodedParams}`}`;
     }
     disconnect() {
         this.shouldConnect = false;
-        this.disconnectBroadcastChannel();
         if (this.webSocket === null) {
             return;
         }
@@ -2062,58 +2288,15 @@ class HocuspocusProvider extends EventEmitter {
             //
         }
     }
-    async onOpen(event) {
-        this.emit('open', { event });
-        if (this.isAuthenticationRequired) {
-            this.send(AuthenticationMessage, {
-                token: await this.getToken(),
-            });
-            return;
-        }
-        this.startSync();
-    }
-    async getToken() {
-        if (typeof this.configuration.token === 'function') {
-            const token = await this.configuration.token();
-            return token;
-        }
-        return this.configuration.token;
-    }
-    startSync() {
-        this.send(SyncStepOneMessage, { document: this.document });
-        if (this.awareness.getLocalState() !== null) {
-            this.send(AwarenessMessage, {
-                awareness: this.awareness,
-                clients: [this.document.clientID],
-            });
-        }
-    }
-    send(Message, args, broadcast = false) {
+    send(message) {
         var _a;
-        if (broadcast) {
-            this.mux(() => { this.broadcast(Message, args); });
-        }
         if (((_a = this.webSocket) === null || _a === void 0 ? void 0 : _a.readyState) === WsReadyStates.Open) {
-            const messageSender = new MessageSender(Message, args);
-            this.emit('outgoingMessage', { message: messageSender.message });
-            messageSender.send(this.webSocket);
+            this.webSocket.send(message);
         }
     }
-    onMessage(event) {
-        this.resolveConnectionAttempt();
-        this.lastMessageReceived = getUnixTime();
-        const message = new IncomingMessage(event.data);
-        this.emit('message', { event, message });
-        new MessageReceiver(message).apply(this);
-    }
-    onClose(event) {
-        this.emit('close', { event });
+    onClose({ event }) {
         this.webSocket = null;
-        this.isAuthenticated = false;
-        this.synced = false;
         if (this.status === WebSocketStatus.Connected) {
-            // update awareness (all users except local left)
-            removeAwarenessStates(this.awareness, Array.from(this.awareness.getStates().keys()).filter(client => client !== this.document.clientID), this);
             this.status = WebSocketStatus.Disconnected;
             this.emit('status', { status: WebSocketStatus.Disconnected });
             this.emit('disconnect', { event });
@@ -2127,6 +2310,7 @@ class HocuspocusProvider extends EventEmitter {
         if (event.code === Forbidden.code) {
             if (!this.configuration.quiet) {
                 console.warn('[HocuspocusProvider] The provided authentication token isn’t allowed to connect to this server. Will try again.');
+                return; // TODO REMOVE ME
             }
         }
         if (this.connectionAttempt) {
@@ -2156,67 +2340,16 @@ class HocuspocusProvider extends EventEmitter {
             clearInterval(this.intervals.forceSync);
         }
         clearInterval(this.intervals.connectionChecker);
-        removeAwarenessStates(this.awareness, [this.document.clientID], 'provider destroy');
         // If there is still a connection attempt outstanding then we should stop
         // it before calling disconnect, otherwise it will be rejected in the onClose
         // handler and trigger a retry
         this.stopConnectionAttempt();
         this.disconnect();
-        this.awareness.off('update', this.awarenessUpdateHandler);
-        this.document.off('update', this.documentUpdateHandler);
         this.removeAllListeners();
         if (typeof window === 'undefined') {
             return;
         }
         window.removeEventListener('online', this.boundConnect);
-        window.removeEventListener('beforeunload', this.boundBeforeUnload);
-    }
-    get broadcastChannel() {
-        return `${this.serverUrl}/${this.configuration.name}`;
-    }
-    broadcastChannelSubscriber(data) {
-        this.mux(() => {
-            const message = new IncomingMessage(data);
-            new MessageReceiver(message)
-                .setBroadcasted(true)
-                .apply(this, false);
-        });
-    }
-    subscribeToBroadcastChannel() {
-        if (!this.subscribedToBroadcastChannel) {
-            subscribe(this.broadcastChannel, this.boundBroadcastChannelSubscriber);
-            this.subscribedToBroadcastChannel = true;
-        }
-        this.mux(() => {
-            this.broadcast(SyncStepOneMessage, { document: this.document });
-            this.broadcast(SyncStepTwoMessage, { document: this.document });
-            this.broadcast(QueryAwarenessMessage);
-            this.broadcast(AwarenessMessage, { awareness: this.awareness, clients: [this.document.clientID] });
-        });
-    }
-    disconnectBroadcastChannel() {
-        // broadcast message with local awareness state set to null (indicating disconnect)
-        this.send(AwarenessMessage, {
-            awareness: this.awareness,
-            clients: [this.document.clientID],
-            states: new Map(),
-        }, true);
-        if (this.subscribedToBroadcastChannel) {
-            unsubscribe(this.broadcastChannel, this.boundBroadcastChannelSubscriber);
-            this.subscribedToBroadcastChannel = false;
-        }
-    }
-    broadcast(Message, args) {
-        if (!this.configuration.broadcast) {
-            return;
-        }
-        if (!this.subscribedToBroadcastChannel) {
-            return;
-        }
-        new MessageSender(Message, args).broadcast(this.broadcastChannel);
-    }
-    setAwarenessField(key, value) {
-        this.awareness.setLocalStateField(key, value);
     }
 }
 
@@ -2231,9 +2364,10 @@ class HocuspocusCloudProvider extends HocuspocusProvider {
             }
             configuration.parameters.key = configuration.key;
         }
+        configuration.websocketProvider = new HocuspocusProviderWebsocket({ url: configuration.url });
         super(configuration);
     }
 }
 
-export { HocuspocusCloudProvider, HocuspocusProvider, MessageType, WebSocketStatus };
+export { HocuspocusCloudProvider, HocuspocusProvider, HocuspocusProviderWebsocket, MessageType, WebSocketStatus };
 //# sourceMappingURL=hocuspocus-provider.esm.js.map