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

package/dist/packages/provider/src/IncomingMessage.d.ts

@@ -10,4 +10,5 @@ export declare class IncomingMessage {
     readVarUint8Array(): Uint8Array;
     writeVarUint(type: MessageType): void;
     writeVarUint8Array(data: Uint8Array): void;
+    length(): number;
 }

package/dist/packages/provider/src/MessageReceiver.d.ts

@@ -2,7 +2,9 @@ import { HocuspocusProvider } from './HocuspocusProvider';
 import { IncomingMessage } from './IncomingMessage';
 export declare class MessageReceiver {
     message: IncomingMessage;
+    broadcasted: boolean;
     constructor(message: IncomingMessage);
+    setBroadcasted(value: boolean): this;
     apply(provider: HocuspocusProvider, emitSynced?: boolean): void;
     private applySyncMessage;
     private applyAwarenessMessage;

package/dist/packages/provider/src/MessageSender.d.ts

@@ -1,15 +1,9 @@
 import { Encoder } from 'lib0/encoding';
-import { AuthenticationMessage } from './OutgoingMessages/AuthenticationMessage';
-import { AwarenessMessage } from './OutgoingMessages/AwarenessMessage';
-import { QueryAwarenessMessage } from './OutgoingMessages/QueryAwarenessMessage';
-import { SyncStepOneMessage } from './OutgoingMessages/SyncStepOneMessage';
-import { SyncStepTwoMessage } from './OutgoingMessages/SyncStepTwoMessage';
-import { UpdateMessage } from './OutgoingMessages/UpdateMessage';
-import { Constructable } from './types';
+import { ConstructableOutgoingMessage } from './types';
 export declare class MessageSender {
     encoder: Encoder;
     message: any;
-    constructor(Message: Constructable<AuthenticationMessage> | Constructable<AwarenessMessage> | Constructable<QueryAwarenessMessage> | Constructable<SyncStepOneMessage> | Constructable<SyncStepTwoMessage> | Constructable<UpdateMessage>, args?: any);
+    constructor(Message: ConstructableOutgoingMessage, args?: any);
     create(): Uint8Array;
     send(webSocket: any): void;
     broadcast(channel: string): void;

package/dist/packages/provider/src/OutgoingMessage.d.ts

@@ -1,8 +1,9 @@
 import { Encoder } from 'lib0/encoding';
-import { MessageType, OutgoingMessageInterface } from './types';
+import { MessageType, OutgoingMessageArguments, OutgoingMessageInterface } from './types';
 export declare class OutgoingMessage implements OutgoingMessageInterface {
     encoder: Encoder;
     type?: MessageType;
     constructor();
+    get(args: Partial<OutgoingMessageArguments>): Encoder | undefined;
     toUint8Array(): Uint8Array;
 }

package/dist/packages/provider/src/types.d.ts

@@ -1,6 +1,12 @@
 import { Awareness } from 'y-protocols/awareness';
 import * as Y from 'yjs';
-import * as encoding from 'lib0/encoding';
+import { Encoder } from 'lib0/encoding';
+import { AuthenticationMessage } from './OutgoingMessages/AuthenticationMessage';
+import { AwarenessMessage } from './OutgoingMessages/AwarenessMessage';
+import { QueryAwarenessMessage } from './OutgoingMessages/QueryAwarenessMessage';
+import { SyncStepOneMessage } from './OutgoingMessages/SyncStepOneMessage';
+import { SyncStepTwoMessage } from './OutgoingMessages/SyncStepTwoMessage';
+import { UpdateMessage } from './OutgoingMessages/UpdateMessage';
 export declare enum MessageType {
     Sync = 0,
     Awareness = 1,
@@ -8,7 +14,7 @@ export declare enum MessageType {
     QueryAwareness = 3
 }
 export interface OutgoingMessageInterface {
-    encoder: encoding.Encoder;
+    encoder: Encoder;
     type?: MessageType;
 }
 export interface OutgoingMessageArguments {
@@ -20,7 +26,9 @@ export interface OutgoingMessageArguments {
         [key: string]: any;
     }>;
     update: any;
+    encoder: Encoder;
 }
 export interface Constructable<T> {
     new (...args: any): T;
 }
+export declare type ConstructableOutgoingMessage = Constructable<AuthenticationMessage> | Constructable<AwarenessMessage> | Constructable<QueryAwarenessMessage> | Constructable<SyncStepOneMessage> | Constructable<SyncStepTwoMessage> | Constructable<UpdateMessage>;

package/dist/packages/server/src/Connection.d.ts

@@ -40,10 +40,10 @@ declare class Connection {
      */
     private check;
     /**
-     * Send first sync step
+     * Send the current document awareness to the client, if any
      * @private
      */
-    private sendFirstSyncStep;
+    private sendCurrentAwareness;
     /**
      * Handle an incoming message
      * @private

package/dist/packages/server/src/Document.d.ts

@@ -43,9 +43,9 @@ declare class Document extends Doc {
      */
     removeConnection(connection: Connection): Document;
     /**
-     * Get the number of active connections
+     * Get the number of active connections for this document
      */
-    connectionsCount(): number;
+    getConnectionsCount(): number;
     /**
      * Get an array of registered connections
      */

package/dist/packages/server/src/Hocuspocus.d.ts

@@ -8,7 +8,7 @@ export declare const defaultConfiguration: {
     timeout: number;
 };
 /**
- * Hocuspocus yjs websocket server
+ * Hocuspocus server
  */
 export declare class Hocuspocus {
     configuration: Configuration;
@@ -26,7 +26,15 @@ export declare class Hocuspocus {
      */
     listen(): Promise<void>;
     /**
-     * Force closes one or more connections
+     * Get the total number of active documents
+     */
+    getDocumentsCount(): number;
+    /**
+     * Get the total number of active connections
+     */
+    getConnectionsCount(): number;
+    /**
+     * Force close one or more connections
      */
     closeConnections(documentName?: string): void;
     /**
@@ -34,7 +42,7 @@ export declare class Hocuspocus {
      */
     destroy(): Promise<any>;
     /**
-     * Handle the incoming websocket connection
+     * Handle the incoming WebSocket connection
      */
     handleConnection(incoming: WebSocket, request: IncomingMessage, documentName: string, context?: any): void;
     /**
@@ -69,7 +77,7 @@ export declare class Hocuspocus {
      */
     private static getDocumentName;
     enableDebugging(): void;
-    enableLogging(): void;
+    enableMessageLogging(): void;
     disableLogging(): void;
     disableDebugging(): void;
     flushMessageLogs(): this;

package/dist/packages/server/src/types.d.ts

@@ -77,6 +77,7 @@ export interface onCreateDocumentPayload {
     context: any;
     document: Document;
     documentName: string;
+    instance: Hocuspocus;
     requestHeaders: IncomingHttpHeaders;
     requestParameters: URLSearchParams;
     socketId: string;
@@ -87,6 +88,7 @@ export interface onChangePayload {
     context: any;
     document: Document;
     documentName: string;
+    instance: Hocuspocus;
     requestHeaders: IncomingHttpHeaders;
     requestParameters: URLSearchParams;
     update: Uint8Array;
@@ -97,6 +99,7 @@ export interface onDisconnectPayload {
     context: any;
     document: Document;
     documentName: string;
+    instance: Hocuspocus;
     requestHeaders: IncomingHttpHeaders;
     requestParameters: URLSearchParams;
     socketId: string;
@@ -116,6 +119,7 @@ export interface onListenPayload {
     port: number;
 }
 export interface onDestroyPayload {
+    instance: Hocuspocus;
 }
 export interface onConfigurePayload {
     configuration: Configuration;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hocuspocus/provider",
-  "version": "1.0.0-alpha.12",
+  "version": "1.0.0-alpha.16",
   "description": "hocuspocus provider",
   "homepage": "https://hocuspocus.dev",
   "keywords": [
@@ -23,11 +23,12 @@
     "dist"
   ],
   "dependencies": {
+    "@lifeomic/attempt": "^3.0.0",
     "lib0": "^0.2.42",
     "y-protocols": "^1.0.5",
     "yjs": "^13.5.8"
   },
-  "gitHead": "f4b2c62f0322daa4c95f6be2009fc7a9c48557cb",
+  "gitHead": "981e76320fd0bac82cbbdb027ec3c91a4c6cfce4",
   "publishConfig": {
     "access": "public"
   }

package/src/HocuspocusProvider.ts

@@ -1,13 +1,11 @@
-// @ts-nocheck
 import * as Y from 'yjs'
 import * as bc from 'lib0/broadcastchannel'
 import * as time from 'lib0/time'
 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 { retry } from '@lifeomic/attempt'
 import EventEmitter from './EventEmitter'
 import { IncomingMessage } from './IncomingMessage'
 import { MessageReceiver } from './MessageReceiver'
@@ -20,6 +18,7 @@ import { AwarenessMessage } from './OutgoingMessages/AwarenessMessage'
 import { UpdateMessage } from './OutgoingMessages/UpdateMessage'
 import { OutgoingMessage } from './OutgoingMessage'
 import awarenessStatesToArray from './utils/awarenessStatesToArray'
+import { ConstructableOutgoingMessage } from './types'
 
 export enum WebSocketStatus {
   Connecting = 'connecting',
@@ -28,21 +27,84 @@ export enum WebSocketStatus {
 }
 
 export interface HocuspocusProviderOptions {
+  /**
+   * 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,
-  token: string,
+  /**
+   * 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,
+  /**
+   * 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: ({ reason: string }) => void,
+  onAuthenticationFailed: ({ reason }: { reason: string }) => void,
   onOpen: (event: OpenEvent) => void,
   onConnect: () => void,
   onMessage: (event: MessageEvent) => void,
@@ -54,23 +116,40 @@ export interface HocuspocusProviderOptions {
   onDestroy: () => void,
   onAwarenessUpdate: (states: any) => void,
   onAwarenessChange: (states: any) => void,
-  debug: boolean,
 }
 
 export class HocuspocusProvider extends EventEmitter {
   public options: HocuspocusProviderOptions = {
+    // @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,
@@ -86,17 +165,13 @@ export class HocuspocusProvider extends EventEmitter {
     onAwarenessChange: () => null,
   }
 
-  awareness: Awareness
-
   subscribedToBroadcastChannel = false
 
   webSocket: any = null
 
   shouldConnect = true
 
-  status: WebSocketStatus = WebSocketStatus.Disconnected
-
-  failedConnectionAttempts = 0
+  status = WebSocketStatus.Disconnected
 
   isSynced = false
 
@@ -111,15 +186,17 @@ export class HocuspocusProvider extends EventEmitter {
     connectionChecker: null,
   }
 
+  connectionAttempt: {
+    resolve: (value?: any) => void
+    reject: (reason?: any) => void
+  } | null = null
+
   constructor(options: Partial<HocuspocusProviderOptions> = {}) {
     super()
-
     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)
@@ -136,26 +213,22 @@ export class HocuspocusProvider extends EventEmitter {
     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.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,
     )
 
-    this.document.on('update', this.documentUpdateHandler.bind(this))
-    this.awareness.on('update', this.awarenessUpdateHandler.bind(this))
-    this.registerBeforeUnloadEventListener()
-
     if (this.options.forceSyncInterval) {
       this.intervals.forceSync = setInterval(
         this.forceSync.bind(this),
@@ -163,15 +236,76 @@ export class HocuspocusProvider extends EventEmitter {
       )
     }
 
-    if (this.options.connect) {
-      this.connect()
+    if (typeof options.connect !== 'undefined') {
+      this.shouldConnect = options.connect
     }
+
+    if (!this.shouldConnect) {
+      return
+    }
+
+    this.connect()
   }
 
   public setOptions(options: Partial<HocuspocusProviderOptions> = {}): void {
     this.options = { ...this.options, ...options }
   }
 
+  connect() {
+    if (this.status === WebSocketStatus.Connected) {
+      return
+    }
+
+    this.shouldConnect = true
+    this.subscribeToBroadcastChannel()
+
+    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 = WebSocketStatus.Connecting
+      this.emit('status', { status: 'connecting' })
+
+      // Store resolve/reject for later use
+      this.connectionAttempt = {
+        resolve,
+        reject,
+      }
+    })
+  }
+
+  resolveConnectionAttempt() {
+    this.connectionAttempt?.resolve()
+    this.connectionAttempt = null
+  }
+
+  rejectConnectionAttempt() {
+    this.connectionAttempt?.reject()
+    this.connectionAttempt = null
+  }
+
   get document() {
     return this.options.document
   }
@@ -181,12 +315,12 @@ export class HocuspocusProvider extends EventEmitter {
   }
 
   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
     }
@@ -238,8 +372,6 @@ export class HocuspocusProvider extends EventEmitter {
 
   permissionDeniedHandler(reason: string) {
     this.emit('authenticationFailed', { reason })
-    this.log('Permission denied', reason)
-
     this.isAuthenticated = false
     this.shouldConnect = false
   }
@@ -284,15 +416,6 @@ export class HocuspocusProvider extends EventEmitter {
     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()
@@ -308,24 +431,6 @@ export 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: OpenEvent) {
     this.emit('open', { event })
 
@@ -334,18 +439,30 @@ export class HocuspocusProvider extends EventEmitter {
     }
   }
 
-  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 = 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() {
@@ -359,11 +476,9 @@ export class HocuspocusProvider extends EventEmitter {
     }
   }
 
-  send(Message: OutgoingMessage, args: any, broadcast = false) {
+  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) {
@@ -382,23 +497,16 @@ export class HocuspocusProvider extends EventEmitter {
     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: CloseEvent) {
     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,
@@ -409,27 +517,30 @@ export class HocuspocusProvider extends EventEmitter {
       this.status = WebSocketStatus.Disconnected
       this.emit('status', { status: '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,
-      ))
-
-      this.log(`[close] Reconnecting in ${wait}ms …`)
-      setTimeout(this.createWebSocketConnection.bind(this), wait)
+    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) {
       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() {
@@ -456,12 +567,9 @@ export class HocuspocusProvider extends EventEmitter {
   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)
     })
   }
 
@@ -493,7 +601,7 @@ export class HocuspocusProvider extends EventEmitter {
     }
   }
 
-  broadcast(Message: OutgoingMessage, args: any) {
+  broadcast(Message: ConstructableOutgoingMessage, args?: any) {
     if (!this.options.broadcast) {
       return
     }
@@ -505,14 +613,6 @@ export class HocuspocusProvider extends EventEmitter {
     new MessageSender(Message, args).broadcast(this.broadcastChannel)
   }
 
-  log(message: string): void {
-    if (!this.options.debug) {
-      return
-    }
-
-    console.log(message)
-  }
-
   setAwarenessField(key: string, value: any) {
     this.awareness.setLocalStateField(key, value)
   }