@hocuspocus/provider 1.0.0-alpha.8 → 1.0.0-beta.2

package/dist/hocuspocus-provider.esm.js

@@ -1,4 +1,6 @@
 import * as Y from 'yjs';
+import { retry } from '@lifeomic/attempt';
+import { readAuthMessage, writeAuthentication, awarenessStatesToArray, WsReadyStates, Unauthorized, Forbidden } from '@hocuspocus/common';
 
 /**
  * Utility module to work with key-value stores.
@@ -258,8 +260,6 @@ hasConf('production');
  */
 
 const floor = Math.floor;
-const round = Math.round;
-const log10 = Math.log10;
 
 /**
  * @function
@@ -1372,23 +1372,26 @@ class EventEmitter {
     }
 }
 
-var MessageType;
-(function (MessageType) {
-    MessageType[MessageType["Sync"] = 0] = "Sync";
-    MessageType[MessageType["Awareness"] = 1] = "Awareness";
-    MessageType[MessageType["Auth"] = 2] = "Auth";
-    MessageType[MessageType["QueryAwareness"] = 3] = "QueryAwareness";
-})(MessageType || (MessageType = {}));
-
 class IncomingMessage {
     constructor(data) {
         this.data = data;
         this.encoder = createEncoder();
         this.decoder = createDecoder(new Uint8Array(this.data));
-        this.type = readVarUint(this.decoder);
     }
-    get name() {
-        return MessageType[this.type];
+    readVarUint() {
+        return readVarUint(this.decoder);
+    }
+    readVarUint8Array() {
+        return readVarUint8Array(this.decoder);
+    }
+    writeVarUint(type) {
+        return writeVarUint(this.encoder, type);
+    }
+    writeVarUint8Array(data) {
+        return writeVarUint8Array(this.encoder, data);
+    }
+    length() {
+        return length$1(this.encoder);
     }
 }
 
@@ -1519,32 +1522,45 @@ const readSyncMessage = (decoder, encoder, doc, transactionOrigin) => {
   return messageType
 };
 
-const messagePermissionDenied = 0;
-
-/**
- * @callback PermissionDeniedHandler
- * @param {any} y
- * @param {string} reason
- */
+var MessageType;
+(function (MessageType) {
+    MessageType[MessageType["Sync"] = 0] = "Sync";
+    MessageType[MessageType["Awareness"] = 1] = "Awareness";
+    MessageType[MessageType["Auth"] = 2] = "Auth";
+    MessageType[MessageType["QueryAwareness"] = 3] = "QueryAwareness";
+})(MessageType || (MessageType = {}));
+var WebSocketStatus;
+(function (WebSocketStatus) {
+    WebSocketStatus["Connecting"] = "connecting";
+    WebSocketStatus["Connected"] = "connected";
+    WebSocketStatus["Disconnected"] = "disconnected";
+})(WebSocketStatus || (WebSocketStatus = {}));
 
-/**
- *
- * @param {decoding.Decoder} decoder
- * @param {Y.Doc} y
- * @param {PermissionDeniedHandler} permissionDeniedHandler
- */
-const readAuthMessage = (decoder, y, permissionDeniedHandler) => {
-  switch (readVarUint(decoder)) {
-    case messagePermissionDenied: permissionDeniedHandler(y, readVarString(decoder));
-  }
-};
+class OutgoingMessage {
+    constructor() {
+        this.encoder = createEncoder();
+    }
+    get(args) {
+        return args.encoder;
+    }
+    toUint8Array() {
+        return toUint8Array(this.encoder);
+    }
+}
 
 class MessageReceiver {
     constructor(message) {
+        this.broadcasted = false;
         this.message = message;
     }
+    setBroadcasted(value) {
+        this.broadcasted = value;
+        return this;
+    }
     apply(provider, emitSynced = true) {
-        switch (this.message.type) {
+        const { message } = this;
+        const type = message.readVarUint();
+        switch (type) {
             case MessageType.Sync:
                 this.applySyncMessage(provider, emitSynced);
                 break;
@@ -1558,31 +1574,49 @@ class MessageReceiver {
                 this.applyQueryAwarenessMessage(provider);
                 break;
             default:
-                throw new Error(`Can’t apply unknown type of message: ${this.message.type}`);
+                throw new Error(`Can’t apply message of unknown type: ${type}`);
+        }
+        // Reply
+        if (message.length() > 1) {
+            if (this.broadcasted) {
+                // TODO: Some weird TypeScript error
+                // @ts-ignore
+                provider.broadcast(OutgoingMessage, { encoder: message.encoder });
+            }
+            else {
+                // TODO: Some weird TypeScript error
+                // @ts-ignore
+                provider.send(OutgoingMessage, { encoder: message.encoder });
+            }
         }
-        return this.message.encoder;
     }
     applySyncMessage(provider, emitSynced) {
-        writeVarUint(this.message.encoder, MessageType.Sync);
-        const syncMessageType = readSyncMessage(this.message.decoder, this.message.encoder, provider.document, provider);
-        if (emitSynced && syncMessageType === messageYjsSyncStep2) {
+        const { message } = this;
+        message.writeVarUint(MessageType.Sync);
+        // Apply update
+        const syncMessageType = readSyncMessage(message.decoder, message.encoder, provider.document, provider);
+        // Synced once we receive Step2
+        if (emitSynced && (syncMessageType === messageYjsSyncStep2)) {
             provider.synced = true;
         }
+        if (syncMessageType === messageYjsUpdate || syncMessageType === messageYjsSyncStep2) {
+            if (provider.unsyncedChanges > 0) {
+                provider.unsyncedChanges -= 1;
+            }
+        }
     }
     applyAwarenessMessage(provider) {
-        applyAwarenessUpdate(provider.awareness, readVarUint8Array(this.message.decoder), provider);
+        const { message } = this;
+        applyAwarenessUpdate(provider.awareness, message.readVarUint8Array(), provider);
     }
-    // TODO: This isn’t really used. Needs to be implemented in the server, or removed here.
     applyAuthMessage(provider) {
-        readAuthMessage(this.message.decoder, provider.document, 
-        // TODO: Add a configureable hook
-        (provider, reason) => {
-            console.warn(`Permission denied to access ${provider.url}.\n${reason}`);
-        });
+        const { message } = this;
+        readAuthMessage(message.decoder, provider.permissionDeniedHandler.bind(provider), provider.authenticatedHandler.bind(provider));
     }
     applyQueryAwarenessMessage(provider) {
-        writeVarUint(this.message.encoder, MessageType.Awareness);
-        writeVarUint8Array(this.message.encoder, encodeAwarenessUpdate(provider.awareness, Array.from(provider.awareness.getStates().keys())));
+        const { message } = this;
+        message.writeVarUint(MessageType.Awareness);
+        message.writeVarUint8Array(encodeAwarenessUpdate(provider.awareness, Array.from(provider.awareness.getStates().keys())));
     }
 }
 
@@ -1602,18 +1636,6 @@ class MessageSender {
     }
 }
 
-class OutgoingMessage {
-    constructor() {
-        this.encoder = createEncoder();
-    }
-    get name() {
-        if (typeof this.type === 'number') {
-            return MessageType[this.type];
-        }
-        throw new Error('Type for outgoing message not set.');
-    }
-}
-
 class SyncStepOneMessage extends OutgoingMessage {
     constructor() {
         super(...arguments);
@@ -1658,6 +1680,22 @@ class QueryAwarenessMessage extends OutgoingMessage {
     }
 }
 
+class AuthenticationMessage extends OutgoingMessage {
+    constructor() {
+        super(...arguments);
+        this.type = MessageType.Auth;
+        this.description = 'Authentication';
+    }
+    get(args) {
+        if (typeof args.token === 'undefined') {
+            throw new Error('The authentication message requires `token` as an argument.');
+        }
+        writeVarUint(this.encoder, this.type);
+        writeAuthentication(this.encoder, args.token);
+        return this.encoder;
+    }
+}
+
 class AwarenessMessage extends OutgoingMessage {
     constructor() {
         super(...arguments);
@@ -1697,36 +1735,42 @@ class UpdateMessage extends OutgoingMessage {
     }
 }
 
-var awarenessStatesToArray = (states) => {
-    return Array.from(states.entries()).map(([key, value]) => {
-        return {
-            clientId: key,
-            ...value,
-        };
-    });
-};
-
-// @ts-nocheck
-var WebSocketStatus;
-(function (WebSocketStatus) {
-    WebSocketStatus["Connecting"] = "connecting";
-    WebSocketStatus["Connected"] = "connected";
-    WebSocketStatus["Disconnected"] = "disconnected";
-})(WebSocketStatus || (WebSocketStatus = {}));
 class HocuspocusProvider extends EventEmitter {
-    constructor(options = {}) {
+    constructor(configuration) {
         super();
-        this.options = {
-            url: '',
+        this.configuration = {
             name: '',
+            url: '',
+            // @ts-ignore
+            document: undefined,
+            // @ts-ignore
+            awareness: undefined,
+            WebSocketPolyfill: undefined,
+            token: null,
             parameters: {},
-            debug: false,
             connect: true,
+            broadcast: true,
             forceSyncInterval: false,
-            reconnectTimeoutBase: 1200,
-            maxReconnectTimeout: 2500,
             // TODO: this should depend on awareness.outdatedTime
             messageReconnectTimeout: 30000,
+            // 1 second
+            delay: 1000,
+            // instant
+            initialDelay: 0,
+            // double the delay each time
+            factor: 2,
+            // unlimited retries
+            maxAttempts: 0,
+            // wait at least 1 second
+            minDelay: 1000,
+            // at least every 30 seconds
+            maxDelay: 30000,
+            // randomize
+            jitter: true,
+            // retry forever
+            timeout: 0,
+            onAuthenticated: () => null,
+            onAuthenticationFailed: () => null,
             onOpen: () => null,
             onConnect: () => null,
             onMessage: () => null,
@@ -1736,70 +1780,183 @@ class HocuspocusProvider extends EventEmitter {
             onDisconnect: () => null,
             onClose: () => null,
             onDestroy: () => null,
+            onAwarenessUpdate: () => null,
             onAwarenessChange: () => null,
+            quiet: false,
         };
         this.subscribedToBroadcastChannel = false;
         this.webSocket = null;
         this.shouldConnect = true;
         this.status = WebSocketStatus.Disconnected;
-        this.failedConnectionAttempts = 0;
         this.isSynced = false;
+        this.unsyncedChanges = 0;
+        this.isAuthenticated = false;
         this.lastMessageReceived = 0;
         this.mux = createMutex();
         this.intervals = {
             forceSync: null,
             connectionChecker: null,
         };
-        this.setOptions(options);
-        this.options.document = options.document ? options.document : new Y.Doc();
-        this.options.awareness = options.awareness ? options.awareness : new Awareness(this.document);
-        this.options.WebSocketPolyfill = options.WebSocketPolyfill ? options.WebSocketPolyfill : WebSocket;
-        this.shouldConnect = options.connect !== undefined ? options.connect : this.shouldConnect;
-        this.on('open', this.options.onOpen);
-        this.on('connect', this.options.onConnect);
-        this.on('message', this.options.onMessage);
-        this.on('outgoingMessage', this.options.onOutgoingMessage);
-        this.on('synced', this.options.onSynced);
-        this.on('status', this.options.onStatus);
-        this.on('disconnect', this.options.onDisconnect);
-        this.on('close', this.options.onClose);
-        this.on('destroy', this.options.onDestroy);
-        this.on('awarenessChange', this.options.onAwarenessChange);
+        this.connectionAttempt = null;
+        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('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('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.awareness.on('update', () => {
+            this.emit('awarenessUpdate', { states: awarenessStatesToArray(this.awareness.getStates()) });
+        });
         this.awareness.on('change', () => {
-            this.emit('awarenessChange', {
-                states: awarenessStatesToArray(this.awareness.getStates()),
-            });
+            this.emit('awarenessChange', { states: awarenessStatesToArray(this.awareness.getStates()) });
         });
-        this.intervals.connectionChecker = setInterval(this.checkConnection.bind(this), this.options.messageReconnectTimeout / 10);
         this.document.on('update', this.documentUpdateHandler.bind(this));
         this.awareness.on('update', this.awarenessUpdateHandler.bind(this));
-        this.registerBeforeUnloadEventListener();
-        if (this.options.forceSyncInterval) {
-            this.intervals.forceSync = setInterval(this.forceSync.bind(this), this.options.forceSyncInterval);
+        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 (this.options.connect) {
-            this.connect();
+        if (typeof configuration.connect !== 'undefined') {
+            this.shouldConnect = configuration.connect;
         }
+        if (!this.shouldConnect) {
+            return;
+        }
+        this.connect();
     }
-    setOptions(options = {}) {
-        this.options = { ...this.options, ...options };
+    setConfiguration(configuration = {}) {
+        this.configuration = { ...this.configuration, ...configuration };
+    }
+    async connect() {
+        if (this.status === WebSocketStatus.Connected) {
+            return;
+        }
+        // Always cancel any previously initiated connection retryer instances
+        if (this.cancelWebsocketRetry) {
+            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), {
+                delay: this.configuration.delay,
+                initialDelay: this.configuration.initialDelay,
+                factor: this.configuration.factor,
+                maxAttempts: this.configuration.maxAttempts,
+                minDelay: this.configuration.minDelay,
+                maxDelay: this.configuration.maxDelay,
+                jitter: this.configuration.jitter,
+                timeout: this.configuration.timeout,
+                beforeAttempt: context => {
+                    if (!this.shouldConnect || cancelAttempt) {
+                        context.abort();
+                    }
+                },
+            }).catch((error) => {
+                // If we aborted the connection attempt then don’t throw an error
+                // ref: https://github.com/lifeomic/attempt/blob/master/src/index.ts#L136
+                if (error && error.code !== 'ATTEMPT_ABORTED') {
+                    throw error;
+                }
+            });
+            return {
+                retryPromise,
+                cancelFunc: () => {
+                    cancelAttempt = true;
+                },
+            };
+        };
+        const { retryPromise, cancelFunc } = abortableRetry();
+        this.cancelWebsocketRetry = cancelFunc;
+        return retryPromise;
+    }
+    createWebSocketConnection() {
+        return new Promise((resolve, reject) => {
+            if (this.webSocket) {
+                this.webSocket.close();
+                this.webSocket = null;
+            }
+            // 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.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
+            this.connectionAttempt = {
+                resolve,
+                reject,
+            };
+        });
+    }
+    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');
+    }
+    stopConnectionAttempt() {
+        this.connectionAttempt = null;
+    }
+    rejectConnectionAttempt() {
+        var _a;
+        (_a = this.connectionAttempt) === null || _a === void 0 ? void 0 : _a.reject();
+        this.connectionAttempt = null;
     }
     get document() {
-        return this.options.document;
+        return this.configuration.document;
     }
     get awareness() {
-        return this.options.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
         if (this.status !== WebSocketStatus.Connected) {
             return;
         }
-        if (this.options.messageReconnectTimeout >= getUnixTime() - this.lastMessageReceived) {
+        // Don’t close then connection while waiting for the first message
+        if (!this.lastMessageReceived) {
+            return;
+        }
+        // Don’t close the connection when a message was received recently
+        if (this.configuration.messageReconnectTimeout >= getUnixTime() - this.lastMessageReceived) {
             return;
         }
         // No message received in a long time, not even your own
         // Awareness updates, which are updated every 15 seconds.
-        this.webSocket.close();
+        (_a = this.webSocket) === null || _a === void 0 ? void 0 : _a.close();
     }
     forceSync() {
         if (!this.webSocket) {
@@ -1807,18 +1964,21 @@ class HocuspocusProvider extends EventEmitter {
         }
         this.send(SyncStepOneMessage, { document: this.document });
     }
-    registerBeforeUnloadEventListener() {
+    beforeUnload() {
+        removeAwarenessStates(this.awareness, [this.document.clientID], 'window unload');
+    }
+    registerEventListeners() {
         if (typeof window === 'undefined') {
             return;
         }
-        window.addEventListener('beforeunload', () => {
-            removeAwarenessStates(this.awareness, [this.document.clientID], 'window unload');
-        });
+        window.addEventListener('online', this.boundConnect);
+        window.addEventListener('beforeunload', this.boundBeforeUnload);
     }
     documentUpdateHandler(update, origin) {
         if (origin === this) {
             return;
         }
+        this.unsyncedChanges += 1;
         this.send(UpdateMessage, { update }, true);
     }
     awarenessUpdateHandler({ added, updated, removed }, origin) {
@@ -1828,16 +1988,26 @@ class HocuspocusProvider extends EventEmitter {
             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() {
-        while (this.options.url[this.options.url.length - 1] === '/') {
-            return this.options.url.slice(0, this.options.url.length - 1);
+        while (this.configuration.url[this.configuration.url.length - 1] === '/') {
+            return this.configuration.url.slice(0, this.configuration.url.length - 1);
         }
-        return this.options.url;
+        return this.configuration.url;
     }
     get url() {
-        const encodedParams = encodeQueryParams(this.options.parameters);
-        return `${this.serverUrl}/${this.options.name}${encodedParams.length === 0 ? '' : `?${encodedParams}`}`;
+        const encodedParams = encodeQueryParams(this.configuration.parameters);
+        return `${this.serverUrl}/${this.configuration.name}${encodedParams.length === 0 ? '' : `?${encodedParams}`}`;
     }
     get synced() {
         return this.isSynced;
@@ -1850,12 +2020,8 @@ class HocuspocusProvider extends EventEmitter {
         this.emit('synced', { state });
         this.emit('sync', { state });
     }
-    connect() {
-        this.shouldConnect = true;
-        if (this.status !== WebSocketStatus.Connected) {
-            this.createWebSocketConnection();
-            this.subscribeToBroadcastChannel();
-        }
+    get isAuthenticationRequired() {
+        return !!this.configuration.token && !this.isAuthenticated;
     }
     disconnect() {
         this.shouldConnect = false;
@@ -1870,27 +2036,24 @@ class HocuspocusProvider extends EventEmitter {
             //
         }
     }
-    createWebSocketConnection() {
-        if (this.webSocket !== null) {
+    async onOpen(event) {
+        this.emit('open', { event });
+        if (this.isAuthenticationRequired) {
+            this.send(AuthenticationMessage, {
+                token: await this.getToken(),
+            });
             return;
         }
-        this.webSocket = new this.options.WebSocketPolyfill(this.url);
-        this.webSocket.binaryType = 'arraybuffer';
-        this.status = WebSocketStatus.Connecting;
-        this.synced = false;
-        this.webSocket.onmessage = this.onMessage.bind(this);
-        this.webSocket.onclose = this.onClose.bind(this);
-        this.webSocket.onopen = this.onOpen.bind(this);
-        this.emit('status', { status: 'connecting' });
+        this.startSync();
     }
-    onOpen(event) {
-        this.emit('open', { event });
+    async getToken() {
+        if (typeof this.configuration.token === 'function') {
+            const token = await this.configuration.token();
+            return token;
+        }
+        return this.configuration.token;
     }
-    webSocketConnectionEstablished() {
-        this.failedConnectionAttempts = 0;
-        this.status = WebSocketStatus.Connected;
-        this.emit('status', { status: 'connected' });
-        this.emit('connect');
+    startSync() {
         this.send(SyncStepOneMessage, { document: this.document });
         if (this.awareness.getLocalState() !== null) {
             this.send(AwarenessMessage, {
@@ -1900,55 +2063,66 @@ class HocuspocusProvider extends EventEmitter {
         }
     }
     send(Message, args, broadcast = false) {
+        var _a;
         if (broadcast) {
-            this.mux(() => {
-                this.broadcast(Message, args);
-            });
+            this.mux(() => { this.broadcast(Message, args); });
         }
-        if (this.status === WebSocketStatus.Connected) {
+        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);
         }
     }
     onMessage(event) {
-        if (this.status !== WebSocketStatus.Connected) {
-            this.webSocketConnectionEstablished();
-        }
+        this.resolveConnectionAttempt();
         this.lastMessageReceived = getUnixTime();
         const message = new IncomingMessage(event.data);
         this.emit('message', { event, message });
-        new MessageReceiver(message, this).apply(this);
-        // TODO: What’s that doing?
-        // if (encoding.length(encoder) > 1) {
-        //   this.send(encoding.toUint8Array(encoder))
-        // }
+        new MessageReceiver(message).apply(this);
     }
     onClose(event) {
         this.emit('close', { event });
         this.webSocket = null;
+        this.isAuthenticated = false;
+        this.synced = false;
         if (this.status === WebSocketStatus.Connected) {
-            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);
             this.status = WebSocketStatus.Disconnected;
-            this.emit('status', { status: 'disconnected' });
+            this.emit('status', { status: WebSocketStatus.Disconnected });
             this.emit('disconnect', { event });
         }
-        else {
-            this.failedConnectionAttempts += 1;
+        if (event.code === Unauthorized.code) {
+            if (!this.configuration.quiet) {
+                console.warn('[HocuspocusProvider] An authentication token is required, but you didn’t send one. Try adding a `token` to your HocuspocusProvider configuration. Won’t try again.');
+            }
+            this.shouldConnect = false;
         }
+        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.');
+            }
+        }
+        if (this.connectionAttempt) {
+            // That connection attempt failed.
+            this.rejectConnectionAttempt();
+        }
+        else if (this.shouldConnect) {
+            // The connection was closed by the server. Let’s just try again.
+            this.connect();
+        }
+        // If we’ll reconnect, we’re done for now.
         if (this.shouldConnect) {
-            const wait = round(min(log10(this.failedConnectionAttempts + 1) * this.options.reconnectTimeoutBase, this.options.maxReconnectTimeout));
-            this.log(`[close] Reconnecting in ${wait}ms …`);
-            setTimeout(this.createWebSocketConnection.bind(this), wait);
             return;
         }
-        if (this.status !== WebSocketStatus.Disconnected) {
-            this.status = WebSocketStatus.Disconnected;
-            this.emit('status', { status: 'disconnected' });
-            this.emit('disconnect', { event });
+        // The status is set correctly already.
+        if (this.status === WebSocketStatus.Disconnected) {
+            return;
         }
+        // Let’s update the connection status.
+        this.status = WebSocketStatus.Disconnected;
+        this.emit('status', { status: WebSocketStatus.Disconnected });
+        this.emit('disconnect', { event });
     }
     destroy() {
         this.emit('destroy');
@@ -1956,27 +2130,35 @@ 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.options.name}`;
+        return `${this.serverUrl}/${this.configuration.name}`;
     }
     broadcastChannelSubscriber(data) {
         this.mux(() => {
             const message = new IncomingMessage(data);
-            new MessageReceiver(message, this).apply(this, false);
-            // TODO: What’s that doing?
-            // if (encoding.length(encoder) > 1) {
-            //   this.broadcast(encoding.toUint8Array(encoder))
-            // }
+            new MessageReceiver(message)
+                .setBroadcasted(true)
+                .apply(this, false);
         });
     }
     subscribeToBroadcastChannel() {
         if (!this.subscribedToBroadcastChannel) {
-            subscribe(this.broadcastChannel, this.broadcastChannelSubscriber.bind(this));
+            subscribe(this.broadcastChannel, this.boundBroadcastChannelSubscriber);
             this.subscribedToBroadcastChannel = true;
         }
         this.mux(() => {
@@ -1994,25 +2176,38 @@ class HocuspocusProvider extends EventEmitter {
             states: new Map(),
         }, true);
         if (this.subscribedToBroadcastChannel) {
-            unsubscribe(this.broadcastChannel, this.broadcastChannelSubscriber.bind(this));
+            unsubscribe(this.broadcastChannel, this.boundBroadcastChannelSubscriber);
             this.subscribedToBroadcastChannel = false;
         }
     }
     broadcast(Message, args) {
-        if (this.subscribedToBroadcastChannel) {
-            new MessageSender(Message, args).broadcast(this.broadcastChannel);
+        if (!this.configuration.broadcast) {
+            return;
         }
-    }
-    log(message) {
-        if (!this.options.debug) {
+        if (!this.subscribedToBroadcastChannel) {
             return;
         }
-        console.log(message);
+        new MessageSender(Message, args).broadcast(this.broadcastChannel);
     }
     setAwarenessField(key, value) {
         this.awareness.setLocalStateField(key, value);
     }
 }
 
-export { HocuspocusProvider, MessageType, WebSocketStatus, awarenessStatesToArray };
+class HocuspocusCloudProvider extends HocuspocusProvider {
+    constructor(configuration) {
+        if (!configuration.url) {
+            configuration.url = 'wss://connect.hocuspocus.cloud';
+        }
+        if (configuration.key) {
+            if (!configuration.parameters) {
+                configuration.parameters = {};
+            }
+            configuration.parameters.key = configuration.key;
+        }
+        super(configuration);
+    }
+}
+
+export { HocuspocusCloudProvider, HocuspocusProvider, MessageType, WebSocketStatus };
 //# sourceMappingURL=hocuspocus-provider.esm.js.map