@hocuspocus/provider 3.1.2 → 3.1.4

package/src/IncomingMessage.ts

@@ -1,66 +1,63 @@
-import type {
-  Decoder} from 'lib0/decoding'
+import type { Decoder } from "lib0/decoding";
 import {
-  createDecoder,
-  peekVarString,
-  readVarUint,
-  readVarUint8Array,
-  readVarString,
-} from 'lib0/decoding'
-import type {
-  Encoder} from 'lib0/encoding'
+	createDecoder,
+	peekVarString,
+	readVarUint,
+	readVarUint8Array,
+	readVarString,
+} from "lib0/decoding";
+import type { Encoder } from "lib0/encoding";
 import {
-  createEncoder,
-  writeVarUint,
-  writeVarUint8Array,
-  writeVarString,
-  length,
-} from 'lib0/encoding'
-import type { MessageType } from './types.ts'
+	createEncoder,
+	writeVarUint,
+	writeVarUint8Array,
+	writeVarString,
+	length,
+} from "lib0/encoding";
+import type { MessageType } from "./types.ts";
 
 export class IncomingMessage {
+	data: any;
 
-  data: any
+	encoder: Encoder;
 
-  encoder: Encoder
+	decoder: Decoder;
 
-  decoder: Decoder
+	constructor(data: any) {
+		this.data = data;
+		this.encoder = createEncoder();
+		this.decoder = createDecoder(new Uint8Array(this.data));
+	}
 
-  constructor(data: any) {
-    this.data = data
-    this.encoder = createEncoder()
-    this.decoder = createDecoder(new Uint8Array(this.data))
-  }
+	peekVarString(): string {
+		return peekVarString(this.decoder);
+	}
 
-  peekVarString(): string {
-    return peekVarString(this.decoder)
-  }
+	readVarUint(): MessageType {
+		return readVarUint(this.decoder);
+	}
 
-  readVarUint(): MessageType {
-    return readVarUint(this.decoder)
-  }
+	readVarString(): string {
+		return readVarString(this.decoder);
+	}
 
-  readVarString(): string {
-    return readVarString(this.decoder)
-  }
+	readVarUint8Array() {
+		return readVarUint8Array(this.decoder);
+	}
 
-  readVarUint8Array() {
-    return readVarUint8Array(this.decoder)
-  }
+	writeVarUint(type: MessageType) {
+		return writeVarUint(this.encoder, type);
+	}
 
-  writeVarUint(type: MessageType) {
-    return writeVarUint(this.encoder, type)
-  }
+	writeVarString(string: string) {
+		return writeVarString(this.encoder, string);
+	}
 
-  writeVarString(string: string) {
-    return writeVarString(this.encoder, string)
-  }
+	writeVarUint8Array(data: Uint8Array) {
+		return writeVarUint8Array(this.encoder, data);
+	}
 
-  writeVarUint8Array(data: Uint8Array) {
-    return writeVarUint8Array(this.encoder, data)
-  }
-
-  length() {
-    return length(this.encoder)
-  }
+	length() {
+		return length(this.encoder);
+	}
 }

package/src/MessageReceiver.ts

@@ -1,135 +1,138 @@
-import { readAuthMessage } from '@hocuspocus/common'
-import { readVarInt, readVarString } from 'lib0/decoding'
-import * as awarenessProtocol from 'y-protocols/awareness'
-import { messageYjsSyncStep2, readSyncMessage } from 'y-protocols/sync'
-import type { CloseEvent } from 'ws'
-import type { HocuspocusProvider } from './HocuspocusProvider.ts'
-import type { IncomingMessage } from './IncomingMessage.ts'
-import { OutgoingMessage } from './OutgoingMessage.ts'
-import { MessageType } from './types.ts'
+import { readAuthMessage } from "@hocuspocus/common";
+import { readVarInt, readVarString } from "lib0/decoding";
+import * as awarenessProtocol from "y-protocols/awareness";
+import { messageYjsSyncStep2, readSyncMessage } from "y-protocols/sync";
+import type { CloseEvent } from "ws";
+import type { HocuspocusProvider } from "./HocuspocusProvider.ts";
+import type { IncomingMessage } from "./IncomingMessage.ts";
+import { OutgoingMessage } from "./OutgoingMessage.ts";
+import { MessageType } from "./types.ts";
 
 export class MessageReceiver {
-
-  message: IncomingMessage
-
-  constructor(message: IncomingMessage) {
-    this.message = message
-  }
-
-  public apply(provider: HocuspocusProvider, emitSynced: boolean) {
-    const { message } = this
-    const type = message.readVarUint()
-
-    const emptyMessageLength = message.length()
-
-    switch (type) {
-      case MessageType.Sync:
-        this.applySyncMessage(provider, emitSynced)
-        break
-
-      case MessageType.Awareness:
-        this.applyAwarenessMessage(provider)
-        break
-
-      case MessageType.Auth:
-        this.applyAuthMessage(provider)
-        break
-
-      case MessageType.QueryAwareness:
-        this.applyQueryAwarenessMessage(provider)
-        break
-
-      case MessageType.Stateless:
-        provider.receiveStateless(readVarString(message.decoder))
-        break
-
-      case MessageType.SyncStatus:
-        this.applySyncStatusMessage(provider, readVarInt(message.decoder) === 1)
-        break
-
-      case MessageType.CLOSE:
-        // eslint-disable-next-line no-case-declarations
-        const event: CloseEvent = {
-          code: 1000,
-          reason: readVarString(message.decoder),
-          // @ts-ignore
-          target: provider.configuration.websocketProvider.webSocket!,
-          type: 'close',
-        }
-        provider.onClose()
-        provider.configuration.onClose({ event })
-        provider.forwardClose(event)
-      break
-
-      default:
-        throw new Error(`Can’t apply message of unknown type: ${type}`)
-    }
-
-    // Reply
-    if (message.length() > emptyMessageLength + 1) { // length of documentName (considered in emptyMessageLength plus length of yjs sync type, set in applySyncMessage)
-      // @ts-ignore
-      provider.send(OutgoingMessage, { encoder: message.encoder })
-    }
-  }
-
-  private applySyncMessage(provider: HocuspocusProvider, emitSynced: boolean) {
-    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
-    }
-  }
-
-  applySyncStatusMessage(provider: HocuspocusProvider, applied: boolean) {
-    if (applied) {
-      provider.decrementUnsyncedChanges()
-    }
-  }
-
-  private applyAwarenessMessage(provider: HocuspocusProvider) {
-    if (!provider.awareness) return
-
-    const { message } = this
-
-    awarenessProtocol.applyAwarenessUpdate(
-      provider.awareness,
-      message.readVarUint8Array(),
-      provider,
-    )
-  }
-
-  private applyAuthMessage(provider: HocuspocusProvider) {
-    const { message } = this
-
-    readAuthMessage(
-      message.decoder,
-      provider.permissionDeniedHandler.bind(provider),
-      provider.authenticatedHandler.bind(provider),
-    )
-  }
-
-  private applyQueryAwarenessMessage(provider: HocuspocusProvider) {
-    if (!provider.awareness) return
-
-    const { message } = this
-
-    message.writeVarUint(MessageType.Awareness)
-    message.writeVarUint8Array(
-      awarenessProtocol.encodeAwarenessUpdate(
-        provider.awareness,
-        Array.from(provider.awareness.getStates().keys()),
-      ),
-    )
-  }
+	message: IncomingMessage;
+
+	constructor(message: IncomingMessage) {
+		this.message = message;
+	}
+
+	public apply(provider: HocuspocusProvider, emitSynced: boolean) {
+		const { message } = this;
+		const type = message.readVarUint();
+
+		const emptyMessageLength = message.length();
+
+		switch (type) {
+			case MessageType.Sync:
+				this.applySyncMessage(provider, emitSynced);
+				break;
+
+			case MessageType.Awareness:
+				this.applyAwarenessMessage(provider);
+				break;
+
+			case MessageType.Auth:
+				this.applyAuthMessage(provider);
+				break;
+
+			case MessageType.QueryAwareness:
+				this.applyQueryAwarenessMessage(provider);
+				break;
+
+			case MessageType.Stateless:
+				provider.receiveStateless(readVarString(message.decoder));
+				break;
+
+			case MessageType.SyncStatus:
+				this.applySyncStatusMessage(
+					provider,
+					readVarInt(message.decoder) === 1,
+				);
+				break;
+
+			case MessageType.CLOSE:
+				// eslint-disable-next-line no-case-declarations
+				const event: CloseEvent = {
+					code: 1000,
+					reason: readVarString(message.decoder),
+					// @ts-ignore
+					target: provider.configuration.websocketProvider.webSocket!,
+					type: "close",
+				};
+				provider.onClose();
+				provider.configuration.onClose({ event });
+				provider.forwardClose(event);
+				break;
+
+			default:
+				throw new Error(`Can’t apply message of unknown type: ${type}`);
+		}
+
+		// Reply
+		if (message.length() > emptyMessageLength + 1) {
+			// length of documentName (considered in emptyMessageLength plus length of yjs sync type, set in applySyncMessage)
+			// @ts-ignore
+			provider.send(OutgoingMessage, { encoder: message.encoder });
+		}
+	}
+
+	private applySyncMessage(provider: HocuspocusProvider, emitSynced: boolean) {
+		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;
+		}
+	}
+
+	applySyncStatusMessage(provider: HocuspocusProvider, applied: boolean) {
+		if (applied) {
+			provider.decrementUnsyncedChanges();
+		}
+	}
+
+	private applyAwarenessMessage(provider: HocuspocusProvider) {
+		if (!provider.awareness) return;
+
+		const { message } = this;
+
+		awarenessProtocol.applyAwarenessUpdate(
+			provider.awareness,
+			message.readVarUint8Array(),
+			provider,
+		);
+	}
+
+	private applyAuthMessage(provider: HocuspocusProvider) {
+		const { message } = this;
+
+		readAuthMessage(
+			message.decoder,
+			provider.permissionDeniedHandler.bind(provider),
+			provider.authenticatedHandler.bind(provider),
+		);
+	}
+
+	private applyQueryAwarenessMessage(provider: HocuspocusProvider) {
+		if (!provider.awareness) return;
+
+		const { message } = this;
+
+		message.writeVarUint(MessageType.Awareness);
+		message.writeVarUint8Array(
+			awarenessProtocol.encodeAwarenessUpdate(
+				provider.awareness,
+				Array.from(provider.awareness.getStates().keys()),
+			),
+		);
+	}
 }

package/src/OutgoingMessage.ts

@@ -1,21 +1,25 @@
-import type { Encoder} from 'lib0/encoding'
-import { createEncoder, toUint8Array } from 'lib0/encoding'
-import type { MessageType, OutgoingMessageArguments, OutgoingMessageInterface } from './types.ts'
+import type { Encoder } from "lib0/encoding";
+import { createEncoder, toUint8Array } from "lib0/encoding";
+import type {
+	MessageType,
+	OutgoingMessageArguments,
+	OutgoingMessageInterface,
+} from "./types.ts";
 
 export class OutgoingMessage implements OutgoingMessageInterface {
-  encoder: Encoder
+	encoder: Encoder;
 
-  type?: MessageType
+	type?: MessageType;
 
-  constructor() {
-    this.encoder = createEncoder()
-  }
+	constructor() {
+		this.encoder = createEncoder();
+	}
 
-  get(args: Partial<OutgoingMessageArguments>) {
-    return args.encoder
-  }
+	get(args: Partial<OutgoingMessageArguments>) {
+		return args.encoder;
+	}
 
-  toUint8Array() {
-    return toUint8Array(this.encoder)
-  }
+	toUint8Array() {
+		return toUint8Array(this.encoder);
+	}
 }

package/src/OutgoingMessages/AuthenticationMessage.ts

@@ -1,23 +1,25 @@
-import { writeVarString, writeVarUint } from 'lib0/encoding'
-import { writeAuthentication } from '@hocuspocus/common'
-import type { OutgoingMessageArguments } from '../types.ts'
-import { MessageType } from '../types.ts'
-import { OutgoingMessage } from '../OutgoingMessage.ts'
+import { writeVarString, writeVarUint } from "lib0/encoding";
+import { writeAuthentication } from "@hocuspocus/common";
+import type { OutgoingMessageArguments } from "../types.ts";
+import { MessageType } from "../types.ts";
+import { OutgoingMessage } from "../OutgoingMessage.ts";
 
 export class AuthenticationMessage extends OutgoingMessage {
-  type = MessageType.Auth
+	type = MessageType.Auth;
 
-  description = 'Authentication'
+	description = "Authentication";
 
-  get(args: Partial<OutgoingMessageArguments>) {
-    if (typeof args.token === 'undefined') {
-      throw new Error('The authentication message requires `token` as an argument.')
-    }
+	get(args: Partial<OutgoingMessageArguments>) {
+		if (typeof args.token === "undefined") {
+			throw new Error(
+				"The authentication message requires `token` as an argument.",
+			);
+		}
 
-    writeVarString(this.encoder, args.documentName!)
-    writeVarUint(this.encoder, this.type)
-    writeAuthentication(this.encoder, args.token)
+		writeVarString(this.encoder, args.documentName!);
+		writeVarUint(this.encoder, this.type);
+		writeAuthentication(this.encoder, args.token);
 
-    return this.encoder
-  }
+		return this.encoder;
+	}
 }

package/src/OutgoingMessages/AwarenessMessage.ts

@@ -1,35 +1,41 @@
-import * as encoding from 'lib0/encoding'
-import { encodeAwarenessUpdate } from 'y-protocols/awareness'
-import type { OutgoingMessageArguments } from '../types.ts'
-import { MessageType } from '../types.ts'
-import { OutgoingMessage } from '../OutgoingMessage.ts'
+import * as encoding from "lib0/encoding";
+import { encodeAwarenessUpdate } from "y-protocols/awareness";
+import type { OutgoingMessageArguments } from "../types.ts";
+import { MessageType } from "../types.ts";
+import { OutgoingMessage } from "../OutgoingMessage.ts";
 
 export class AwarenessMessage extends OutgoingMessage {
-  type = MessageType.Awareness
-
-  description = 'Awareness states update'
-
-  get(args: Partial<OutgoingMessageArguments>) {
-    if (typeof args.awareness === 'undefined') {
-      throw new Error('The awareness message requires awareness as an argument')
-    }
-
-    if (typeof args.clients === 'undefined') {
-      throw new Error('The awareness message requires clients as an argument')
-    }
-
-    encoding.writeVarString(this.encoder, args.documentName!)
-    encoding.writeVarUint(this.encoder, this.type)
-
-    let awarenessUpdate
-    if (args.states === undefined) {
-      awarenessUpdate = encodeAwarenessUpdate(args.awareness, args.clients)
-    } else {
-      awarenessUpdate = encodeAwarenessUpdate(args.awareness, args.clients, args.states)
-    }
-
-    encoding.writeVarUint8Array(this.encoder, awarenessUpdate)
-
-    return this.encoder
-  }
+	type = MessageType.Awareness;
+
+	description = "Awareness states update";
+
+	get(args: Partial<OutgoingMessageArguments>) {
+		if (typeof args.awareness === "undefined") {
+			throw new Error(
+				"The awareness message requires awareness as an argument",
+			);
+		}
+
+		if (typeof args.clients === "undefined") {
+			throw new Error("The awareness message requires clients as an argument");
+		}
+
+		encoding.writeVarString(this.encoder, args.documentName!);
+		encoding.writeVarUint(this.encoder, this.type);
+
+		let awarenessUpdate;
+		if (args.states === undefined) {
+			awarenessUpdate = encodeAwarenessUpdate(args.awareness, args.clients);
+		} else {
+			awarenessUpdate = encodeAwarenessUpdate(
+				args.awareness,
+				args.clients,
+				args.states,
+			);
+		}
+
+		encoding.writeVarUint8Array(this.encoder, awarenessUpdate);
+
+		return this.encoder;
+	}
 }

package/src/OutgoingMessages/CloseMessage.ts

@@ -1,17 +1,17 @@
-import * as encoding from 'lib0/encoding'
-import type { OutgoingMessageArguments } from '../types.ts'
-import { MessageType } from '../types.ts'
-import { OutgoingMessage } from '../OutgoingMessage.ts'
+import * as encoding from "lib0/encoding";
+import type { OutgoingMessageArguments } from "../types.ts";
+import { MessageType } from "../types.ts";
+import { OutgoingMessage } from "../OutgoingMessage.ts";
 
 export class CloseMessage extends OutgoingMessage {
-  type = MessageType.CLOSE
+	type = MessageType.CLOSE;
 
-  description = 'Ask the server to close the connection'
+	description = "Ask the server to close the connection";
 
-  get(args: Partial<OutgoingMessageArguments>) {
-    encoding.writeVarString(this.encoder, args.documentName!)
-    encoding.writeVarUint(this.encoder, this.type)
+	get(args: Partial<OutgoingMessageArguments>) {
+		encoding.writeVarString(this.encoder, args.documentName!);
+		encoding.writeVarUint(this.encoder, this.type);
 
-    return this.encoder
-  }
+		return this.encoder;
+	}
 }

package/src/OutgoingMessages/QueryAwarenessMessage.ts

@@ -1,18 +1,17 @@
-import * as encoding from 'lib0/encoding'
-import type { OutgoingMessageArguments } from '../types.ts'
-import { MessageType } from '../types.ts'
-import { OutgoingMessage } from '../OutgoingMessage.ts'
+import * as encoding from "lib0/encoding";
+import type { OutgoingMessageArguments } from "../types.ts";
+import { MessageType } from "../types.ts";
+import { OutgoingMessage } from "../OutgoingMessage.ts";
 
 export class QueryAwarenessMessage extends OutgoingMessage {
-  type = MessageType.QueryAwareness
+	type = MessageType.QueryAwareness;
 
-  description = 'Queries awareness states'
+	description = "Queries awareness states";
 
-  get(args: Partial<OutgoingMessageArguments>) {
+	get(args: Partial<OutgoingMessageArguments>) {
+		encoding.writeVarString(this.encoder, args.documentName!);
+		encoding.writeVarUint(this.encoder, this.type);
 
-    encoding.writeVarString(this.encoder, args.documentName!)
-    encoding.writeVarUint(this.encoder, this.type)
-
-    return this.encoder
-  }
+		return this.encoder;
+	}
 }

package/src/OutgoingMessages/StatelessMessage.ts

@@ -1,18 +1,18 @@
-import { writeVarString, writeVarUint } from 'lib0/encoding'
-import type { OutgoingMessageArguments } from '../types.ts'
-import { MessageType } from '../types.ts'
-import { OutgoingMessage } from '../OutgoingMessage.ts'
+import { writeVarString, writeVarUint } from "lib0/encoding";
+import type { OutgoingMessageArguments } from "../types.ts";
+import { MessageType } from "../types.ts";
+import { OutgoingMessage } from "../OutgoingMessage.ts";
 
 export class StatelessMessage extends OutgoingMessage {
-  type = MessageType.Stateless
+	type = MessageType.Stateless;
 
-  description = 'A stateless message'
+	description = "A stateless message";
 
-  get(args: Partial<OutgoingMessageArguments>) {
-    writeVarString(this.encoder, args.documentName!)
-    writeVarUint(this.encoder, this.type)
-    writeVarString(this.encoder, args.payload ?? '')
+	get(args: Partial<OutgoingMessageArguments>) {
+		writeVarString(this.encoder, args.documentName!);
+		writeVarUint(this.encoder, this.type);
+		writeVarString(this.encoder, args.payload ?? "");
 
-    return this.encoder
-  }
+		return this.encoder;
+	}
 }