@hocuspocus/provider 1.0.0-alpha.12 → 1.0.0-alpha.16

package/CHANGELOG.md

@@ -3,6 +3,41 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [1.0.0-alpha.16](https://github.com/ueberdosis/hocuspocus/compare/@hocuspocus/provider@1.0.0-alpha.15...@hocuspocus/provider@1.0.0-alpha.16) (2021-09-17)
+
+
+### Bug Fixes
+
+* Remote client awareness not immediately available ([37703f6](https://github.com/ueberdosis/hocuspocus/commit/37703f695f6bf3b0508c287294c5d26d2e888c37))
+
+
+
+
+
+# [1.0.0-alpha.15](https://github.com/ueberdosis/hocuspocus/compare/@hocuspocus/provider@1.0.0-alpha.14...@hocuspocus/provider@1.0.0-alpha.15) (2021-09-14)
+
+**Note:** Version bump only for package @hocuspocus/provider
+
+
+
+
+
+# [1.0.0-alpha.14](https://github.com/ueberdosis/hocuspocus/compare/@hocuspocus/provider@1.0.0-alpha.13...@hocuspocus/provider@1.0.0-alpha.14) (2021-09-03)
+
+**Note:** Version bump only for package @hocuspocus/provider
+
+
+
+
+
+# [1.0.0-alpha.13](https://github.com/ueberdosis/hocuspocus/compare/@hocuspocus/provider@1.0.0-alpha.12...@hocuspocus/provider@1.0.0-alpha.13) (2021-09-01)
+
+**Note:** Version bump only for package @hocuspocus/provider
+
+
+
+
+
 # [1.0.0-alpha.12](https://github.com/ueberdosis/hocuspocus/compare/@hocuspocus/provider@1.0.0-alpha.11...@hocuspocus/provider@1.0.0-alpha.12) (2021-08-31)
 
 **Note:** Version bump only for package @hocuspocus/provider

package/dist/hocuspocus-provider.cjs

@@ -3,6 +3,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var Y = require('yjs');
+var attempt = require('@lifeomic/attempt');
 
 function _interopNamespace(e) {
   if (e && e.__esModule) return e;
@@ -284,8 +285,6 @@ hasConf('production');
  */
 
 const floor = Math.floor;
-const round = Math.round;
-const log10 = Math.log10;
 
 /**
  * @function
@@ -1416,6 +1415,9 @@ class IncomingMessage {
     writeVarUint8Array(data) {
         return writeVarUint8Array(this.encoder, data);
     }
+    length() {
+        return length$1(this.encoder);
+    }
 }
 
 /**
@@ -1576,12 +1578,30 @@ const readAuthMessage = (decoder, permissionDeniedHandler, authenticatedHandler)
     }
 };
 
+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) {
-        const type = this.message.readVarUint();
+        const { message } = this;
+        const type = message.readVarUint();
         switch (type) {
             case exports.MessageType.Sync:
                 this.applySyncMessage(provider, emitSynced);
@@ -1598,11 +1618,26 @@ class MessageReceiver {
             default:
                 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 });
+            }
+        }
     }
     applySyncMessage(provider, emitSynced) {
         const { message } = this;
         message.writeVarUint(exports.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;
         }
@@ -1638,15 +1673,6 @@ class MessageSender {
     }
 }
 
-class OutgoingMessage {
-    constructor() {
-        this.encoder = createEncoder();
-    }
-    toUint8Array() {
-        return toUint8Array(this.encoder);
-    }
-}
-
 class SyncStepOneMessage extends OutgoingMessage {
     constructor() {
         super(...arguments);
@@ -1755,7 +1781,6 @@ var awarenessStatesToArray = (states) => {
     });
 };
 
-// @ts-nocheck
 exports.WebSocketStatus = void 0;
 (function (WebSocketStatus) {
     WebSocketStatus["Connecting"] = "connecting";
@@ -1766,18 +1791,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 +1839,6 @@ class HocuspocusProvider extends EventEmitter {
         this.webSocket = null;
         this.shouldConnect = true;
         this.status = exports.WebSocketStatus.Disconnected;
-        this.failedConnectionAttempts = 0;
         this.isSynced = false;
         this.isAuthenticated = false;
         this.lastMessageReceived = 0;
@@ -1805,11 +1847,10 @@ class HocuspocusProvider extends EventEmitter {
             forceSync: null,
             connectionChecker: null,
         };
+        this.connectionAttempt = null;
         this.setOptions(options);
-        this.options.document = options.document ? options.document : new Y__namespace.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 +1865,78 @@ 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 };
     }
+    connect() {
+        if (this.status === exports.WebSocketStatus.Connected) {
+            return;
+        }
+        this.shouldConnect = true;
+        this.subscribeToBroadcastChannel();
+        attempt.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,
+        });
+    }
+    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 = exports.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 +1944,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 !== exports.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 +1989,6 @@ class HocuspocusProvider extends EventEmitter {
     }
     permissionDeniedHandler(reason) {
         this.emit('authenticationFailed', { reason });
-        this.log('Permission denied', reason);
         this.isAuthenticated = false;
         this.shouldConnect = false;
     }
@@ -1933,13 +2022,6 @@ class HocuspocusProvider extends EventEmitter {
     get isAuthenticationRequired() {
         return !!this.options.token && !this.isAuthenticated;
     }
-    connect() {
-        this.shouldConnect = true;
-        if (this.status !== exports.WebSocketStatus.Connected) {
-            this.createWebSocketConnection();
-            this.subscribeToBroadcastChannel();
-        }
-    }
     disconnect() {
         this.shouldConnect = false;
         this.disconnectBroadcastChannel();
@@ -1953,35 +2035,31 @@ class HocuspocusProvider extends EventEmitter {
             //
         }
     }
-    createWebSocketConnection() {
-        if (this.webSocket !== null) {
-            return;
-        }
-        this.webSocket = new this.options.WebSocketPolyfill(this.url);
-        this.webSocket.binaryType = 'arraybuffer';
-        this.status = exports.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 !== exports.WebSocketStatus.Connected) {
             this.webSocketConnectionEstablished();
         }
     }
-    webSocketConnectionEstablished() {
-        this.failedConnectionAttempts = 0;
+    async getToken() {
+        if (typeof this.options.token === 'function') {
+            const token = await this.options.token();
+            return token;
+        }
+        return this.options.token;
+    }
+    async webSocketConnectionEstablished() {
         this.status = exports.WebSocketStatus.Connected;
         this.emit('status', { status: 'connected' });
         this.emit('connect');
         if (this.isAuthenticationRequired) {
-            this.send(AuthenticationMessage, { token: this.options.token });
+            this.send(AuthenticationMessage, {
+                token: await this.getToken(),
+            });
             return;
         }
         this.startSync();
+        this.resolveConnectionAttempt();
     }
     startSync() {
         this.send(SyncStepOneMessage, { document: this.document });
@@ -1994,9 +2072,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 === exports.WebSocketStatus.Connected) {
             const messageSender = new MessageSender(Message, args);
@@ -2009,38 +2085,39 @@ class HocuspocusProvider extends EventEmitter {
         const message = new IncomingMessage(event.data);
         this.emit('message', { event, message });
         new MessageReceiver(message).apply(this);
-        // TODO: What’s that doing?
-        // Move to the MessageReceiver
-        // if (encoding.length(encoder) > 1) {
-        //   this.send(encoding.toUint8Array(encoder))
-        // }
     }
     onClose(event) {
         this.emit('close', { event });
-        this.isAuthenticated = false;
         this.webSocket = null;
+        this.isAuthenticated = false;
+        this.synced = false;
         if (this.status === exports.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 = exports.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 !== exports.WebSocketStatus.Disconnected) {
-            this.status = exports.WebSocketStatus.Disconnected;
-            this.emit('status', { status: 'disconnected' });
-            this.emit('disconnect', { event });
+        // 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: 'disconnected' });
+        this.emit('disconnect', { event });
     }
     destroy() {
         this.emit('destroy');
@@ -2059,11 +2136,9 @@ class HocuspocusProvider extends EventEmitter {
     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() {
@@ -2099,12 +2174,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);
     }