@hocuspocus/provider 2.0.0-alpha.1 → 2.0.0

package/dist/hocuspocus-provider.cjs

@@ -1766,151 +1766,477 @@ class UpdateMessage extends OutgoingMessage {
     }
 }
 
-class StatelessMessage extends OutgoingMessage {
-    constructor() {
-        super(...arguments);
-        this.type = exports.MessageType.Stateless;
-        this.description = 'A stateless message';
-    }
-    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;
-    }
-}
+/**
+ * Utility module to work with urls.
+ *
+ * @module url
+ */
 
-class CloseMessage extends OutgoingMessage {
-    constructor() {
-        super(...arguments);
-        this.type = exports.MessageType.CLOSE;
-        this.description = 'Ask the server to close the connection';
-    }
-    get(args) {
-        writeVarString(this.encoder, args.documentName);
-        writeVarUint(this.encoder, this.type);
-        return this.encoder;
-    }
-}
+/**
+ * @param {Object<string,string>} params
+ * @return {string}
+ */
+const encodeQueryParams = params =>
+  map(params, (val, key) => `${encodeURIComponent(key)}=${encodeURIComponent(val)}`).join('&');
 
-class HocuspocusProvider extends EventEmitter {
+class HocuspocusProviderWebsocket extends EventEmitter {
     constructor(configuration) {
         super();
         this.configuration = {
-            name: '',
+            url: '',
             // @ts-ignore
             document: undefined,
             // @ts-ignore
             awareness: undefined,
-            token: null,
+            WebSocketPolyfill: undefined,
             parameters: {},
+            connect: true,
             broadcast: true,
             forceSyncInterval: false,
-            onAuthenticated: () => null,
-            onAuthenticationFailed: () => null,
+            // 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,
             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.webSocket = null;
+        this.shouldConnect = true;
         this.status = exports.WebSocketStatus.Disconnected;
-        this.isAuthenticated = false;
+        this.lastMessageReceived = 0;
         this.mux = createMutex();
         this.intervals = {
             forceSync: null,
+            connectionChecker: null,
         };
-        this.boundBeforeUnload = this.beforeUnload.bind(this);
-        this.boundBroadcastChannelSubscriber = this.broadcastChannelSubscriber.bind(this);
+        this.connectionAttempt = null;
+        this.receivedOnOpenPayload = undefined;
+        this.receivedOnStatusPayload = undefined;
+        this.boundConnect = this.connect.bind(this);
         this.setConfiguration(configuration);
-        this.configuration.document = configuration.document ? configuration.document : new Y__namespace.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('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.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: common.awarenessStatesToArray(this.awareness.getStates()) });
-        });
-        this.awareness.on('change', () => {
-            this.emit('awarenessChange', { states: common.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();
-        if (this.configuration.forceSyncInterval) {
-            this.intervals.forceSync = setInterval(this.forceSync.bind(this), this.configuration.forceSyncInterval);
+        this.intervals.connectionChecker = setInterval(this.checkConnection.bind(this), this.configuration.messageReconnectTimeout / 10);
+        if (typeof configuration.connect !== 'undefined') {
+            this.shouldConnect = configuration.connect;
         }
-        this.configuration.websocketProvider.attach(this);
+        if (!this.shouldConnect) {
+            return;
+        }
+        this.connect();
     }
-    onStatus({ status }) {
-        this.status = status;
-        this.configuration.onStatus({ status });
-        this.emit('status', { status });
+    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 };
     }
-    get document() {
-        return this.configuration.document;
+    async connect() {
+        if (this.status === exports.WebSocketStatus.Connected) {
+            return;
+        }
+        // Always cancel any previously initiated connection retryer instances
+        if (this.cancelWebsocketRetry) {
+            this.cancelWebsocketRetry();
+            this.cancelWebsocketRetry = undefined;
+        }
+        this.shouldConnect = true;
+        const abortableRetry = () => {
+            let cancelAttempt = false;
+            const retryPromise = attempt.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;
     }
-    get awareness() {
-        return this.configuration.awareness;
+    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 = (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.status = exports.WebSocketStatus.Connecting;
+            this.emit('status', { status: exports.WebSocketStatus.Connecting });
+            // Store resolve/reject for later use
+            this.connectionAttempt = {
+                resolve,
+                reject,
+            };
+        });
     }
-    get hasUnsyncedChanges() {
-        return this.unsyncedChanges > 0;
+    onMessage(event) {
+        this.resolveConnectionAttempt();
     }
-    forceSync() {
-        this.send(SyncStepOneMessage, { document: this.document, documentName: this.configuration.name });
+    resolveConnectionAttempt() {
+        if (this.connectionAttempt) {
+            this.connectionAttempt.resolve();
+            this.connectionAttempt = null;
+            this.status = exports.WebSocketStatus.Connected;
+            this.emit('status', { status: exports.WebSocketStatus.Connected });
+            this.emit('connect');
+        }
     }
-    beforeUnload() {
-        removeAwarenessStates(this.awareness, [this.document.clientID], 'window unload');
+    stopConnectionAttempt() {
+        this.connectionAttempt = null;
     }
-    registerEventListeners() {
-        if (typeof window === 'undefined') {
+    rejectConnectionAttempt() {
+        var _a;
+        (_a = this.connectionAttempt) === null || _a === void 0 ? void 0 : _a.reject();
+        this.connectionAttempt = null;
+    }
+    checkConnection() {
+        var _a;
+        // Don’t check the connection when it’s not even established
+        if (this.status !== exports.WebSocketStatus.Connected) {
             return;
         }
-        window.addEventListener('beforeunload', this.boundBeforeUnload);
-    }
-    sendStateless(payload) {
-        this.send(StatelessMessage, { documentName: this.configuration.name, payload });
-    }
-    documentUpdateHandler(update, origin) {
-        if (origin === this) {
+        // Don’t close then connection while waiting for the first message
+        if (!this.lastMessageReceived) {
             return;
         }
-        this.unsyncedChanges += 1;
+        // 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.
+        (_a = this.webSocket) === null || _a === void 0 ? void 0 : _a.close();
+    }
+    registerEventListeners() {
+        if (typeof window === 'undefined') {
+            return;
+        }
+        window.addEventListener('online', this.boundConnect);
+    }
+    // Ensure that the URL always ends with /
+    get serverUrl() {
+        while (this.configuration.url[this.configuration.url.length - 1] === '/') {
+            return this.configuration.url.slice(0, this.configuration.url.length - 1);
+        }
+        return this.configuration.url;
+    }
+    get url() {
+        const encodedParams = encodeQueryParams(this.configuration.parameters);
+        return `${this.serverUrl}${encodedParams.length === 0 ? '' : `?${encodedParams}`}`;
+    }
+    disconnect() {
+        this.shouldConnect = false;
+        if (this.webSocket === null) {
+            return;
+        }
+        try {
+            this.webSocket.close();
+        }
+        catch {
+            //
+        }
+    }
+    send(message) {
+        var _a;
+        if (((_a = this.webSocket) === null || _a === void 0 ? void 0 : _a.readyState) === common.WsReadyStates.Open) {
+            this.webSocket.send(message);
+        }
+    }
+    onClose({ event }) {
+        this.webSocket = null;
+        if (this.status === exports.WebSocketStatus.Connected) {
+            this.status = exports.WebSocketStatus.Disconnected;
+            this.emit('status', { status: exports.WebSocketStatus.Disconnected });
+            this.emit('disconnect', { event });
+        }
+        if (event.code === common.Unauthorized.code) {
+            if (event.reason === common.Unauthorized.reason) {
+                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.');
+            }
+            else {
+                console.warn(`[HocuspocusProvider] Connection closed with status Unauthorized: ${event.reason}`);
+            }
+            this.shouldConnect = false;
+        }
+        if (event.code === common.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) {
+            // 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) {
+            return;
+        }
+        // The status is set correctly already.
+        if (this.status === exports.WebSocketStatus.Disconnected) {
+            return;
+        }
+        // Let’s update the connection status.
+        this.status = exports.WebSocketStatus.Disconnected;
+        this.emit('status', { status: exports.WebSocketStatus.Disconnected });
+        this.emit('disconnect', { event });
+    }
+    destroy() {
+        this.emit('destroy');
+        if (this.intervals.forceSync) {
+            clearInterval(this.intervals.forceSync);
+        }
+        clearInterval(this.intervals.connectionChecker);
+        // 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.removeAllListeners();
+        if (typeof window === 'undefined') {
+            return;
+        }
+        window.removeEventListener('online', this.boundConnect);
+    }
+}
+
+class StatelessMessage extends OutgoingMessage {
+    constructor() {
+        super(...arguments);
+        this.type = exports.MessageType.Stateless;
+        this.description = 'A stateless message';
+    }
+    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;
+    }
+}
+
+class CloseMessage extends OutgoingMessage {
+    constructor() {
+        super(...arguments);
+        this.type = exports.MessageType.CLOSE;
+        this.description = 'Ask the server to close the connection';
+    }
+    get(args) {
+        writeVarString(this.encoder, args.documentName);
+        writeVarUint(this.encoder, this.type);
+        return this.encoder;
+    }
+}
+
+class HocuspocusProvider extends EventEmitter {
+    constructor(configuration) {
+        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 = exports.WebSocketStatus.Disconnected;
+        this.isAuthenticated = false;
+        this.mux = createMutex();
+        this.intervals = {
+            forceSync: null,
+        };
+        this.isConnected = true;
+        this.boundBeforeUnload = this.beforeUnload.bind(this);
+        this.boundBroadcastChannelSubscriber = this.broadcastChannelSubscriber.bind(this);
+        this.setConfiguration(configuration);
+        this.configuration.document = configuration.document ? configuration.document : new Y__namespace.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: common.awarenessStatesToArray(this.awareness.getStates()) });
+        });
+        this.awareness.on('change', () => {
+            this.emit('awarenessChange', { states: common.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 = {}) {
+        if (!configuration.websocketProvider && configuration.url) {
+            this.configuration.websocketProvider = new HocuspocusProviderWebsocket({ url: configuration.url });
+        }
+        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) {
@@ -1974,6 +2300,8 @@ class HocuspocusProvider extends EventEmitter {
         }
     }
     send(message, args, broadcast = false) {
+        if (!this.isConnected)
+            return;
         if (broadcast) {
             this.mux(() => { this.broadcast(message, args); });
         }
@@ -2008,6 +2336,7 @@ class HocuspocusProvider extends EventEmitter {
         this.document.off('update', this.documentUpdateHandler);
         this.removeAllListeners();
         this.send(CloseMessage, { documentName: this.configuration.name });
+        this.isConnected = false;
         if (typeof window === 'undefined') {
             return;
         }
@@ -2076,342 +2405,19 @@ class HocuspocusProvider extends EventEmitter {
     }
 }
 
-/**
- * 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,
-            parameters: {},
-            connect: true,
-            broadcast: true,
-            forceSyncInterval: false,
-            // 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,
-            onOpen: () => null,
-            onConnect: () => null,
-            onMessage: () => null,
-            onOutgoingMessage: () => null,
-            onStatus: () => null,
-            onDisconnect: () => null,
-            onClose: () => null,
-            onDestroy: () => null,
-            onAwarenessUpdate: () => null,
-            onAwarenessChange: () => null,
-            quiet: false,
-        };
-        this.subscribedToBroadcastChannel = false;
-        this.webSocket = null;
-        this.shouldConnect = true;
-        this.status = exports.WebSocketStatus.Disconnected;
-        this.lastMessageReceived = 0;
-        this.mux = createMutex();
-        this.intervals = {
-            forceSync: null,
-            connectionChecker: null,
-        };
-        this.connectionAttempt = null;
-        this.receivedOnOpenPayload = undefined;
-        this.receivedOnStatusPayload = undefined;
-        this.boundConnect = this.connect.bind(this);
-        this.setConfiguration(configuration);
-        this.configuration.WebSocketPolyfill = configuration.WebSocketPolyfill ? configuration.WebSocketPolyfill : WebSocket;
-        this.on('open', this.configuration.onOpen);
-        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('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('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 (typeof configuration.connect !== 'undefined') {
-            this.shouldConnect = configuration.connect;
-        }
-        if (!this.shouldConnect) {
-            return;
-        }
-        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 };
-    }
-    async connect() {
-        if (this.status === exports.WebSocketStatus.Connected) {
-            return;
-        }
-        // Always cancel any previously initiated connection retryer instances
-        if (this.cancelWebsocketRetry) {
-            this.cancelWebsocketRetry();
-            this.cancelWebsocketRetry = undefined;
-        }
-        this.shouldConnect = true;
-        const abortableRetry = () => {
-            let cancelAttempt = false;
-            const retryPromise = attempt.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 = (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.status = exports.WebSocketStatus.Connecting;
-            this.emit('status', { status: exports.WebSocketStatus.Connecting });
-            // Store resolve/reject for later use
-            this.connectionAttempt = {
-                resolve,
-                reject,
-            };
-        });
-    }
-    onMessage(event) {
-        this.resolveConnectionAttempt();
-    }
-    resolveConnectionAttempt() {
-        if (this.connectionAttempt) {
-            this.connectionAttempt.resolve();
-            this.connectionAttempt = null;
-            this.status = exports.WebSocketStatus.Connected;
-            this.emit('status', { status: exports.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;
-    }
-    checkConnection() {
-        var _a;
-        // Don’t check the connection when it’s not even established
-        if (this.status !== exports.WebSocketStatus.Connected) {
-            return;
-        }
-        // 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.
-        (_a = this.webSocket) === null || _a === void 0 ? void 0 : _a.close();
-    }
-    registerEventListeners() {
-        if (typeof window === 'undefined') {
-            return;
-        }
-        window.addEventListener('online', this.boundConnect);
-    }
-    // Ensure that the URL always ends with /
-    get serverUrl() {
-        while (this.configuration.url[this.configuration.url.length - 1] === '/') {
-            return this.configuration.url.slice(0, this.configuration.url.length - 1);
-        }
-        return this.configuration.url;
-    }
-    get url() {
-        const encodedParams = encodeQueryParams(this.configuration.parameters);
-        return `${this.serverUrl}${encodedParams.length === 0 ? '' : `?${encodedParams}`}`;
-    }
-    disconnect() {
-        this.shouldConnect = false;
-        if (this.webSocket === null) {
-            return;
-        }
-        try {
-            this.webSocket.close();
-        }
-        catch {
-            //
-        }
-    }
-    send(message) {
-        var _a;
-        if (((_a = this.webSocket) === null || _a === void 0 ? void 0 : _a.readyState) === common.WsReadyStates.Open) {
-            this.webSocket.send(message);
-        }
-    }
-    onClose({ event }) {
-        this.webSocket = null;
-        if (this.status === exports.WebSocketStatus.Connected) {
-            this.status = exports.WebSocketStatus.Disconnected;
-            this.emit('status', { status: exports.WebSocketStatus.Disconnected });
-            this.emit('disconnect', { event });
-        }
-        if (event.code === common.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 === common.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) {
-            // 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) {
-            return;
-        }
-        // The status is set correctly already.
-        if (this.status === exports.WebSocketStatus.Disconnected) {
-            return;
-        }
-        // Let’s update the connection status.
-        this.status = exports.WebSocketStatus.Disconnected;
-        this.emit('status', { status: exports.WebSocketStatus.Disconnected });
-        this.emit('disconnect', { event });
-    }
-    destroy() {
-        this.emit('destroy');
-        if (this.intervals.forceSync) {
-            clearInterval(this.intervals.forceSync);
-        }
-        clearInterval(this.intervals.connectionChecker);
-        // 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.removeAllListeners();
-        if (typeof window === 'undefined') {
-            return;
-        }
-        window.removeEventListener('online', this.boundConnect);
-    }
-}
-
-class HocuspocusCloudProvider extends HocuspocusProvider {
+class TiptapCollabProvider extends HocuspocusProvider {
     constructor(configuration) {
-        if (!configuration.url) {
-            configuration.url = 'wss://connect.hocuspocus.cloud';
+        if (!configuration.websocketProvider) {
+            configuration.websocketProvider = new HocuspocusProviderWebsocket({ url: `wss://${configuration.appId}.collab.tiptap.cloud` });
         }
-        if (configuration.key) {
-            if (!configuration.parameters) {
-                configuration.parameters = {};
-            }
-            configuration.parameters.key = configuration.key;
+        if (!configuration.token) {
+            configuration.token = 'notoken';
         }
-        configuration.websocketProvider = new HocuspocusProviderWebsocket({ url: configuration.url });
         super(configuration);
     }
 }
 
-exports.HocuspocusCloudProvider = HocuspocusCloudProvider;
 exports.HocuspocusProvider = HocuspocusProvider;
 exports.HocuspocusProviderWebsocket = HocuspocusProviderWebsocket;
+exports.TiptapCollabProvider = TiptapCollabProvider;
 //# sourceMappingURL=hocuspocus-provider.cjs.map