@hocuspocus/provider 1.0.0-alpha.4 → 1.0.0-alpha.40

package/src/HocuspocusProvider.ts

@@ -1,14 +1,14 @@
-// @ts-nocheck
 import * as Y from 'yjs'
 import * as bc from 'lib0/broadcastchannel'
 import * as time from 'lib0/time'
-import * as encoding from 'lib0/encoding'
 import { Awareness, removeAwarenessStates } from 'y-protocols/awareness'
 import * as mutex from 'lib0/mutex'
-import * as math from 'lib0/math'
 import * as url from 'lib0/url'
-
-import { CloseEvent, MessageEvent, OpenEvent } from 'ws'
+import type { Event, CloseEvent, MessageEvent } from 'ws'
+import { retry } from '@lifeomic/attempt'
+import {
+  awarenessStatesToArray, Forbidden, Unauthorized, WsReadyStates,
+} from '@hocuspocus/common'
 import EventEmitter from './EventEmitter'
 import { IncomingMessage } from './IncomingMessage'
 import { MessageReceiver } from './MessageReceiver'
@@ -16,78 +16,176 @@ import { MessageSender } from './MessageSender'
 import { SyncStepOneMessage } from './OutgoingMessages/SyncStepOneMessage'
 import { SyncStepTwoMessage } from './OutgoingMessages/SyncStepTwoMessage'
 import { QueryAwarenessMessage } from './OutgoingMessages/QueryAwarenessMessage'
+import { AuthenticationMessage } from './OutgoingMessages/AuthenticationMessage'
 import { AwarenessMessage } from './OutgoingMessages/AwarenessMessage'
 import { UpdateMessage } from './OutgoingMessages/UpdateMessage'
-import { OutgoingMessage } from './OutgoingMessage'
-import awarenessStatesToArray from './utils/awarenessStatesToArray'
-
-export enum WebSocketStatus {
-  Connecting = 'connecting',
-  Connected = 'connected',
-  Disconnected = 'disconnected',
-}
-
-export interface HocuspocusProviderOptions {
-  url: string,
-  name: string,
+import {
+  ConstructableOutgoingMessage, onAuthenticationFailedParameters, onCloseParameters, onDisconnectParameters, onMessageParameters, onOpenParameters, onOutgoingMessageParameters, onStatusParameters, onSyncedParameters, WebSocketStatus,
+} from './types'
+import { onAwarenessChangeParameters, onAwarenessUpdateParameters } from '.'
+
+export type HocuspocusProviderConfiguration =
+  Required<Pick<CompleteHocuspocusProviderConfiguration, 'url' | 'name'>>
+  & Partial<CompleteHocuspocusProviderConfiguration>
+
+export interface CompleteHocuspocusProviderConfiguration {
+  /**
+   * URL of your @hocuspocus/server instance
+   */
+   url: string,
+   /**
+    * The identifier/name of your document
+    */
+   name: string,
+  /**
+   * The actual Y.js document
+   */
   document: Y.Doc,
+  /**
+   * Pass `false` to start the connection manually.
+   */
   connect: boolean,
+  /**
+   * Pass false to disable broadcasting between browser tabs.
+   */
+  broadcast: boolean,
+  /**
+   * An Awareness instance to keep the presence state of all clients.
+   */
   awareness: Awareness,
+  /**
+   * A token that’s sent to the backend for authentication purposes.
+   */
+  token: string | (() => string) | (() => Promise<string>) | null,
+  /**
+   * URL parameters that should be added.
+   */
   parameters: { [key: string]: any },
+  /**
+   * An optional WebSocket polyfill, for example for Node.js
+   */
   WebSocketPolyfill: any,
+  /**
+   * Force syncing the document in the defined interval.
+   */
   forceSyncInterval: false | number,
-  reconnectTimeoutBase: number,
-  maxReconnectTimeout: number,
+  /**
+   * Disconnect when no message is received for the defined amount of milliseconds.
+   */
   messageReconnectTimeout: number,
-  onOpen: (event: OpenEvent) => void,
+  /**
+   * The delay between each attempt in milliseconds. You can provide a factor to have the delay grow exponentially.
+   */
+  delay: number,
+  /**
+   * The intialDelay is the amount of time to wait before making the first attempt. This option should typically be 0 since you typically want the first attempt to happen immediately.
+   */
+  initialDelay: number,
+  /**
+   * The factor option is used to grow the delay exponentially.
+   */
+  factor: number,
+  /**
+   * The maximum number of attempts or 0 if there is no limit on number of attempts.
+   */
+  maxAttempts: number,
+  /**
+   * minDelay is used to set a lower bound of delay when jitter is enabled. This property has no effect if jitter is disabled.
+   */
+  minDelay: number,
+  /**
+   * The maxDelay option is used to set an upper bound for the delay when factor is enabled. A value of 0 can be provided if there should be no upper bound when calculating delay.
+   */
+  maxDelay: number,
+  /**
+   * If jitter is true then the calculated delay will be a random integer value between minDelay and the calculated delay for the current iteration.
+   */
+  jitter: boolean,
+  /**
+   * A timeout in milliseconds. If timeout is non-zero then a timer is set using setTimeout. If the timeout is triggered then future attempts will be aborted.
+   */
+  timeout: number,
+  onAuthenticated: () => void,
+  onAuthenticationFailed: (data: onAuthenticationFailedParameters) => void,
+  onOpen: (data: onOpenParameters) => void,
   onConnect: () => void,
-  onMessage: (event: MessageEvent) => void,
-  onOutgoingMessage: (message: OutgoingMessage) => void,
-  onSynced: () => void,
-  onDisconnect: (event: CloseEvent) => void,
-  onClose: (event: CloseEvent) => void,
+  onMessage: (data: onMessageParameters) => void,
+  onOutgoingMessage: (data: onOutgoingMessageParameters) => void,
+  onStatus: (data: onStatusParameters) => void,
+  onSynced: (data: onSyncedParameters) => void,
+  onDisconnect: (data: onDisconnectParameters) => void,
+  onClose: (data: onCloseParameters) => void,
   onDestroy: () => void,
-  onAwarenessChange: (states: any) => void,
-  debug: boolean,
+  onAwarenessUpdate: (data: onAwarenessUpdateParameters) => void,
+  onAwarenessChange: (data: onAwarenessChangeParameters) => void,
+  /**
+   * Don’t output any warnings.
+   */
+  quiet: boolean,
 }
 
 export class HocuspocusProvider extends EventEmitter {
-  public options: HocuspocusProviderOptions = {
-    url: '',
+  public configuration: CompleteHocuspocusProviderConfiguration = {
     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,
     onOutgoingMessage: () => null,
+    onStatus: () => null,
     onSynced: () => null,
     onDisconnect: () => null,
     onClose: () => null,
     onDestroy: () => null,
+    onAwarenessUpdate: () => null,
     onAwarenessChange: () => null,
+    quiet: false,
   }
 
-  awareness: Awareness
-
   subscribedToBroadcastChannel = false
 
-  webSocket: any = null
+  webSocket: WebSocket | null = null
 
   shouldConnect = true
 
-  status: WebSocketStatus = WebSocketStatus.Disconnected
-
-  failedConnectionAttempts = 0
+  status = WebSocketStatus.Disconnected
 
   isSynced = false
 
+  unsyncedChanges = 0
+
+  isAuthenticated = false
+
   lastMessageReceived = 0
 
   mux = mutex.createMutex()
@@ -97,77 +195,183 @@ export class HocuspocusProvider extends EventEmitter {
     connectionChecker: null,
   }
 
-  constructor(options: Partial<HocuspocusProviderOptions> = {}) {
-    super()
-
-    this.setOptions(options)
+  connectionAttempt: {
+    resolve: (value?: any) => void
+    reject: (reason?: any) => void
+  } | null = null
 
-    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('disconnect', this.options.onDisconnect)
-    this.on('close', this.options.onClose)
-    this.on('destroy', this.options.onDestroy)
-    this.on('awarenessChange', this.options.onAwarenessChange)
+  constructor(configuration: HocuspocusProviderConfiguration) {
+    super()
+    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.document.on('update', this.documentUpdateHandler.bind(this))
+    this.awareness.on('update', this.awarenessUpdateHandler.bind(this))
+    this.registerEventListeners()
+
     this.intervals.connectionChecker = setInterval(
       this.checkConnection.bind(this),
-      this.options.messageReconnectTimeout / 10,
+      this.configuration.messageReconnectTimeout / 10,
     )
 
-    this.document.on('update', this.documentUpdateHandler.bind(this))
-    this.awareness.on('update', this.awarenessUpdateHandler.bind(this))
-    this.registerBeforeUnloadEventListener()
-
-    if (this.options.forceSyncInterval) {
+    if (this.configuration.forceSyncInterval) {
       this.intervals.forceSync = setInterval(
         this.forceSync.bind(this),
-        this.options.forceSyncInterval,
+        this.configuration.forceSyncInterval,
       )
     }
 
-    if (this.options.connect) {
-      this.connect()
+    if (typeof configuration.connect !== 'undefined') {
+      this.shouldConnect = configuration.connect
+    }
+
+    if (!this.shouldConnect) {
+      return
+    }
+
+    this.connect()
+  }
+
+  public setConfiguration(configuration: Partial<HocuspocusProviderConfiguration> = {}): void {
+    this.configuration = { ...this.configuration, ...configuration }
+  }
+
+  boundConnect = this.connect.bind(this)
+
+  async connect() {
+    if (this.status === WebSocketStatus.Connected) {
+      return
     }
+
+    this.unsyncedChanges = 0 // set to 0 in case we got reconnected
+    this.shouldConnect = true
+    this.subscribeToBroadcastChannel()
+
+    try {
+      await 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) {
+            context.abort()
+          }
+        },
+      })
+    } catch (error: any) {
+      // 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
+      }
+    }
+  }
+
+  createWebSocketConnection() {
+    return new Promise((resolve, reject) => {
+      // 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: any) => {
+        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() {
+    this.connectionAttempt?.resolve()
+    this.connectionAttempt = null
+
+    this.status = WebSocketStatus.Connected
+    this.emit('status', { status: WebSocketStatus.Connected })
+    this.emit('connect')
+  }
+
+  stopConnectionAttempt() {
+    this.connectionAttempt = null
   }
 
-  public setOptions(options: Partial<HocuspocusProviderOptions> = {}): void {
-    this.options = { ...this.options, ...options }
+  rejectConnectionAttempt() {
+    this.connectionAttempt?.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() {
+    // Don’t check the connection when it’s not even established
     if (this.status !== WebSocketStatus.Connected) {
       return
     }
 
-    if (this.options.messageReconnectTimeout >= time.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 >= time.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()
+    this.webSocket?.close()
   }
 
   forceSync() {
@@ -178,14 +382,19 @@ export class HocuspocusProvider extends EventEmitter {
     this.send(SyncStepOneMessage, { document: this.document })
   }
 
-  registerBeforeUnloadEventListener() {
+  boundBeforeUnload = this.beforeUnload.bind(this)
+
+  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: Uint8Array, origin: any) {
@@ -193,6 +402,7 @@ export class HocuspocusProvider extends EventEmitter {
       return
     }
 
+    this.unsyncedChanges += 1
     this.send(UpdateMessage, { update }, true)
   }
 
@@ -205,19 +415,32 @@ export class HocuspocusProvider extends EventEmitter {
     }, true)
   }
 
+  permissionDeniedHandler(reason: string) {
+    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 = url.encodeQueryParams(this.options.parameters)
+    const encodedParams = url.encodeQueryParams(this.configuration.parameters)
 
-    return `${this.serverUrl}/${this.options.name}${encodedParams.length === 0 ? '' : `?${encodedParams}`}`
+    return `${this.serverUrl}/${this.configuration.name}${encodedParams.length === 0 ? '' : `?${encodedParams}`}`
   }
 
   get synced(): boolean {
@@ -234,13 +457,8 @@ export class HocuspocusProvider extends EventEmitter {
     this.emit('sync', { state })
   }
 
-  connect() {
-    this.shouldConnect = true
-
-    if (this.status !== WebSocketStatus.Connected) {
-      this.createWebSocketConnection()
-      this.subscribeToBroadcastChannel()
-    }
+  get isAuthenticationRequired(): boolean {
+    return !!this.configuration.token && !this.isAuthenticated
   }
 
   disconnect() {
@@ -258,34 +476,29 @@ export class HocuspocusProvider extends EventEmitter {
     }
   }
 
-  createWebSocketConnection() {
-    if (this.webSocket !== null) {
+  async onOpen(event: 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: OpenEvent) {
-    this.emit('open', { event })
-  }
+  async getToken() {
+    if (typeof this.configuration.token === 'function') {
+      const token = await this.configuration.token()
+      return token
+    }
 
-  webSocketConnectionEstablished() {
-    this.failedConnectionAttempts = 0
-    this.status = WebSocketStatus.Connected
-    this.emit('status', { status: 'connected' })
-    this.emit('connect')
+    return this.configuration.token
+  }
 
+  startSync() {
     this.send(SyncStepOneMessage, { document: this.document })
 
     if (this.awareness.getLocalState() !== null) {
@@ -296,16 +509,12 @@ export class HocuspocusProvider extends EventEmitter {
     }
   }
 
-  send(Message: OutgoingMessage, args: any, broadcast = false) {
-    const message = new Message()
-
+  send(Message: ConstructableOutgoingMessage, args: any, broadcast = false) {
     if (broadcast) {
-      this.mux(() => {
-        this.broadcast(Message, args)
-      })
+      this.mux(() => { this.broadcast(Message, args) })
     }
 
-    if (this.status === WebSocketStatus.Connected) {
+    if (this.webSocket?.readyState === WsReadyStates.Open) {
       const messageSender = new MessageSender(Message, args)
 
       this.emit('outgoingMessage', { message: messageSender.message })
@@ -314,9 +523,7 @@ export class HocuspocusProvider extends EventEmitter {
   }
 
   onMessage(event: MessageEvent) {
-    if (this.status !== WebSocketStatus.Connected) {
-      this.webSocketConnectionEstablished()
-    }
+    this.resolveConnectionAttempt()
 
     this.lastMessageReceived = time.getUnixTime()
 
@@ -324,22 +531,17 @@ export class HocuspocusProvider extends EventEmitter {
 
     this.emit('message', { event, message })
 
-    const encoder = 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: CloseEvent) {
     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,
@@ -348,29 +550,46 @@ export class HocuspocusProvider extends EventEmitter {
       )
 
       this.status = WebSocketStatus.Disconnected
-      this.emit('status', { status: 'disconnected' })
+      this.emit('status', { status: WebSocketStatus.Disconnected })
       this.emit('disconnect', { event })
-    } else {
-      this.failedConnectionAttempts += 1
     }
 
-    if (this.shouldConnect) {
-      const wait = math.round(math.min(
-        math.log10(this.failedConnectionAttempts + 1) * this.options.reconnectTimeoutBase,
-        this.options.maxReconnectTimeout,
-      ))
+    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.log(`[close] Reconnecting in ${wait}ms …`)
-      setTimeout(this.createWebSocketConnection.bind(this), wait)
+      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) {
       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() {
@@ -382,33 +601,46 @@ export class HocuspocusProvider extends EventEmitter {
 
     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}`
   }
 
+  boundBroadcastChannelSubscriber = this.broadcastChannelSubscriber.bind(this)
+
   broadcastChannelSubscriber(data: ArrayBuffer) {
     this.mux(() => {
       const message = new IncomingMessage(data)
-      const encoder = 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) {
-      bc.subscribe(this.broadcastChannel, this.broadcastChannelSubscriber.bind(this))
+      bc.subscribe(this.broadcastChannel, this.boundBroadcastChannelSubscriber)
       this.subscribedToBroadcastChannel = true
     }
 
@@ -429,23 +661,21 @@ export class HocuspocusProvider extends EventEmitter {
     }, true)
 
     if (this.subscribedToBroadcastChannel) {
-      bc.unsubscribe(this.broadcastChannel, this.broadcastChannelSubscriber.bind(this))
+      bc.unsubscribe(this.broadcastChannel, this.boundBroadcastChannelSubscriber)
       this.subscribedToBroadcastChannel = false
     }
   }
 
-  broadcast(Message: OutgoingMessage, args: any) {
-    if (this.subscribedToBroadcastChannel) {
-      new MessageSender(Message, args).broadcast(this.broadcastChannel)
+  broadcast(Message: ConstructableOutgoingMessage, args?: any) {
+    if (!this.configuration.broadcast) {
+      return
     }
-  }
 
-  log(message: string): void {
-    if (!this.options.debug) {
+    if (!this.subscribedToBroadcastChannel) {
       return
     }
 
-    console.log(message)
+    new MessageSender(Message, args).broadcast(this.broadcastChannel)
   }
 
   setAwarenessField(key: string, value: any) {