@hocuspocus/provider 1.0.0-alpha.14 → 1.0.0-alpha.18

package/dist/hocuspocus-provider.esm.js

@@ -1,4 +1,5 @@
 import * as Y from 'yjs';
+import { retry } from '@lifeomic/attempt';
 
 /**
  * Utility module to work with key-value stores.
@@ -258,8 +259,6 @@ hasConf('production');
  */
 
 const floor = Math.floor;
-const round = Math.round;
-const log10 = Math.log10;
 
 /**
  * @function
@@ -1575,7 +1574,8 @@ class MessageReceiver {
         return this;
     }
     apply(provider, emitSynced = true) {
-        const type = this.message.readVarUint();
+        const { message } = this;
+        const type = message.readVarUint();
         switch (type) {
             case MessageType.Sync:
                 this.applySyncMessage(provider, emitSynced);
@@ -1592,16 +1592,6 @@ class MessageReceiver {
             default:
                 throw new Error(`Can’t apply message of unknown type: ${type}`);
         }
-    }
-    applySyncMessage(provider, emitSynced) {
-        const { message } = this;
-        message.writeVarUint(MessageType.Sync);
-        // Apply update
-        const syncMessageType = readSyncMessage(message.decoder, message.encoder, provider.document, provider);
-        // Synced
-        if (emitSynced && syncMessageType === messageYjsSyncStep2) {
-            provider.synced = true;
-        }
         // Reply
         if (message.length() > 1) {
             if (this.broadcasted) {
@@ -1616,6 +1606,16 @@ class MessageReceiver {
             }
         }
     }
+    applySyncMessage(provider, emitSynced) {
+        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;
+        }
+    }
     applyAwarenessMessage(provider) {
         const { message } = this;
         applyAwarenessUpdate(provider.awareness, message.readVarUint8Array(), provider);
@@ -1755,7 +1755,6 @@ var awarenessStatesToArray = (states) => {
     });
 };
 
-// @ts-nocheck
 var WebSocketStatus;
 (function (WebSocketStatus) {
     WebSocketStatus["Connecting"] = "connecting";
@@ -1766,18 +1765,36 @@ class HocuspocusProvider extends EventEmitter {
     constructor(options = {}) {
         super();
         this.options = {
+            // @ts-ignore
+            document: undefined,
+            // @ts-ignore
+            awareness: undefined,
+            WebSocketPolyfill: undefined,
             url: '',
             name: '',
             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,
@@ -1796,7 +1813,6 @@ class HocuspocusProvider extends EventEmitter {
         this.webSocket = null;
         this.shouldConnect = true;
         this.status = WebSocketStatus.Disconnected;
-        this.failedConnectionAttempts = 0;
         this.isSynced = false;
         this.isAuthenticated = false;
         this.lastMessageReceived = 0;
@@ -1805,11 +1821,10 @@ class HocuspocusProvider extends EventEmitter {
             forceSync: null,
             connectionChecker: null,
         };
+        this.connectionAttempt = 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('authenticated', this.options.onAuthenticated);
         this.on('authenticationFailed', this.options.onAuthenticationFailed);
@@ -1824,29 +1839,92 @@ class HocuspocusProvider extends EventEmitter {
         this.on('awarenessUpdate', this.options.onAwarenessUpdate);
         this.on('awarenessChange', this.options.onAwarenessChange);
         this.awareness.on('update', () => {
-            this.emit('awarenessUpdate', {
-                states: awarenessStatesToArray(this.awareness.getStates()),
-            });
+            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();
+        this.intervals.connectionChecker = setInterval(this.checkConnection.bind(this), this.options.messageReconnectTimeout / 10);
         if (this.options.forceSyncInterval) {
             this.intervals.forceSync = setInterval(this.forceSync.bind(this), this.options.forceSyncInterval);
         }
-        if (this.options.connect) {
-            this.connect();
+        if (typeof options.connect !== 'undefined') {
+            this.shouldConnect = options.connect;
+        }
+        if (!this.shouldConnect) {
+            return;
         }
+        this.connect();
     }
     setOptions(options = {}) {
         this.options = { ...this.options, ...options };
     }
+    async connect() {
+        if (this.status === WebSocketStatus.Connected) {
+            return;
+        }
+        this.shouldConnect = true;
+        this.subscribeToBroadcastChannel();
+        try {
+            await retry(this.createWebSocketConnection.bind(this), {
+                delay: this.options.delay,
+                initialDelay: this.options.initialDelay,
+                factor: this.options.factor,
+                maxAttempts: this.options.maxAttempts,
+                minDelay: this.options.minDelay,
+                maxDelay: this.options.maxDelay,
+                jitter: this.options.jitter,
+                timeout: this.options.timeout,
+                beforeAttempt: context => {
+                    if (!this.shouldConnect) {
+                        context.abort();
+                    }
+                },
+            });
+        }
+        catch (err) {
+            // 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 (err.code !== 'ATTEMPT_ABORTED') {
+                throw err;
+            }
+        }
+    }
+    createWebSocketConnection() {
+        return new Promise((resolve, reject) => {
+            // Init the WebSocket connection
+            this.webSocket = new this.options.WebSocketPolyfill(this.url);
+            this.webSocket.binaryType = 'arraybuffer';
+            this.webSocket.onmessage = this.onMessage.bind(this);
+            this.webSocket.onclose = this.onClose.bind(this);
+            this.webSocket.onopen = this.onOpen.bind(this);
+            this.webSocket.onerror = () => {
+                reject();
+            };
+            // Reset the status
+            this.synced = false;
+            this.status = WebSocketStatus.Connecting;
+            this.emit('status', { status: '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;
+    }
+    rejectConnectionAttempt() {
+        var _a;
+        (_a = this.connectionAttempt) === null || _a === void 0 ? void 0 : _a.reject();
+        this.connectionAttempt = null;
+    }
     get document() {
         return this.options.document;
     }
@@ -1854,11 +1932,11 @@ class HocuspocusProvider extends EventEmitter {
         return this.options.awareness;
     }
     checkConnection() {
-        // Don’t close the connection when it’s not established anyway
+        // Don’t check the connection when it’s not even established
         if (this.status !== WebSocketStatus.Connected) {
             return;
         }
-        // Don’t just close then connection while waiting for the first message
+        // Don’t close then connection while waiting for the first message
         if (!this.lastMessageReceived) {
             return;
         }
@@ -1899,7 +1977,6 @@ class HocuspocusProvider extends EventEmitter {
     }
     permissionDeniedHandler(reason) {
         this.emit('authenticationFailed', { reason });
-        this.log('Permission denied', reason);
         this.isAuthenticated = false;
         this.shouldConnect = false;
     }
@@ -1933,13 +2010,6 @@ class HocuspocusProvider extends EventEmitter {
     get isAuthenticationRequired() {
         return !!this.options.token && !this.isAuthenticated;
     }
-    connect() {
-        this.shouldConnect = true;
-        if (this.status !== WebSocketStatus.Connected) {
-            this.createWebSocketConnection();
-            this.subscribeToBroadcastChannel();
-        }
-    }
     disconnect() {
         this.shouldConnect = false;
         this.disconnectBroadcastChannel();
@@ -1953,19 +2023,6 @@ class HocuspocusProvider extends EventEmitter {
             //
         }
     }
-    createWebSocketConnection() {
-        if (this.webSocket !== null) {
-            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' });
-    }
     onOpen(event) {
         this.emit('open', { event });
         if (this.status !== WebSocketStatus.Connected) {
@@ -1980,16 +2037,17 @@ class HocuspocusProvider extends EventEmitter {
         return this.options.token;
     }
     async webSocketConnectionEstablished() {
-        this.failedConnectionAttempts = 0;
         this.status = WebSocketStatus.Connected;
         this.emit('status', { status: 'connected' });
         this.emit('connect');
         if (this.isAuthenticationRequired) {
-            const token = await this.getToken();
-            this.send(AuthenticationMessage, { token });
+            this.send(AuthenticationMessage, {
+                token: await this.getToken(),
+            });
             return;
         }
         this.startSync();
+        this.resolveConnectionAttempt();
     }
     startSync() {
         this.send(SyncStepOneMessage, { document: this.document });
@@ -2002,9 +2060,7 @@ class HocuspocusProvider extends EventEmitter {
     }
     send(Message, args, broadcast = false) {
         if (broadcast) {
-            this.mux(() => {
-                this.broadcast(Message, args);
-            });
+            this.mux(() => { this.broadcast(Message, args); });
         }
         if (this.status === WebSocketStatus.Connected) {
             const messageSender = new MessageSender(Message, args);
@@ -2020,30 +2076,36 @@ class HocuspocusProvider extends EventEmitter {
     }
     onClose(event) {
         this.emit('close', { event });
-        this.isAuthenticated = false;
         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('disconnect', { event });
         }
-        else {
-            this.failedConnectionAttempts += 1;
+        if (this.connectionAttempt) {
+            // Okay, that connection attempt failed …
+            this.rejectConnectionAttempt();
+        }
+        else if (this.shouldConnect) {
+            // The connection was closed by the server, so let’s just try again.
+            this.connect();
         }
+        // If we’ll reconnect anyway, 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: 'disconnected' });
+        this.emit('disconnect', { event });
     }
     destroy() {
         this.emit('destroy');
@@ -2051,6 +2113,11 @@ 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 resolve
+        // it before calling disconnect, otherwise it will be rejected in the onClose
+        // handler and trigger a retry
+        this.resolveConnectionAttempt();
         this.disconnect();
         this.awareness.off('update', this.awarenessUpdateHandler);
         this.document.off('update', this.documentUpdateHandler);
@@ -2062,7 +2129,7 @@ class HocuspocusProvider extends EventEmitter {
     broadcastChannelSubscriber(data) {
         this.mux(() => {
             const message = new IncomingMessage(data);
-            new MessageReceiver(message, this)
+            new MessageReceiver(message)
                 .setBroadcasted(true)
                 .apply(this, false);
         });
@@ -2100,12 +2167,6 @@ class HocuspocusProvider extends EventEmitter {
         }
         new MessageSender(Message, args).broadcast(this.broadcastChannel);
     }
-    log(message) {
-        if (!this.options.debug) {
-            return;
-        }
-        console.log(message);
-    }
     setAwarenessField(key, value) {
         this.awareness.setLocalStateField(key, value);
     }