@hocuspocus/provider 3.1.2 → 3.1.4

package/src/OutgoingMessages/SyncStepOneMessage.ts

@@ -1,23 +1,25 @@
-import * as encoding from 'lib0/encoding'
-import * as syncProtocol from 'y-protocols/sync'
-import type { OutgoingMessageArguments } from '../types.ts'
-import { MessageType } from '../types.ts'
-import { OutgoingMessage } from '../OutgoingMessage.ts'
+import * as encoding from "lib0/encoding";
+import * as syncProtocol from "y-protocols/sync";
+import type { OutgoingMessageArguments } from "../types.ts";
+import { MessageType } from "../types.ts";
+import { OutgoingMessage } from "../OutgoingMessage.ts";
 
 export class SyncStepOneMessage extends OutgoingMessage {
-  type = MessageType.Sync
+	type = MessageType.Sync;
 
-  description = 'First sync step'
+	description = "First sync step";
 
-  get(args: Partial<OutgoingMessageArguments>) {
-    if (typeof args.document === 'undefined') {
-      throw new Error('The sync step one message requires document as an argument')
-    }
+	get(args: Partial<OutgoingMessageArguments>) {
+		if (typeof args.document === "undefined") {
+			throw new Error(
+				"The sync step one message requires document as an argument",
+			);
+		}
 
-    encoding.writeVarString(this.encoder, args.documentName!)
-    encoding.writeVarUint(this.encoder, this.type)
-    syncProtocol.writeSyncStep1(this.encoder, args.document)
+		encoding.writeVarString(this.encoder, args.documentName!);
+		encoding.writeVarUint(this.encoder, this.type);
+		syncProtocol.writeSyncStep1(this.encoder, args.document);
 
-    return this.encoder
-  }
+		return this.encoder;
+	}
 }

package/src/OutgoingMessages/SyncStepTwoMessage.ts

@@ -1,23 +1,25 @@
-import * as encoding from 'lib0/encoding'
-import * as syncProtocol from 'y-protocols/sync'
-import type { OutgoingMessageArguments } from '../types.ts'
-import { MessageType } from '../types.ts'
-import { OutgoingMessage } from '../OutgoingMessage.ts'
+import * as encoding from "lib0/encoding";
+import * as syncProtocol from "y-protocols/sync";
+import type { OutgoingMessageArguments } from "../types.ts";
+import { MessageType } from "../types.ts";
+import { OutgoingMessage } from "../OutgoingMessage.ts";
 
 export class SyncStepTwoMessage extends OutgoingMessage {
-  type = MessageType.Sync
+	type = MessageType.Sync;
 
-  description = 'Second sync step'
+	description = "Second sync step";
 
-  get(args: Partial<OutgoingMessageArguments>) {
-    if (typeof args.document === 'undefined') {
-      throw new Error('The sync step two message requires document as an argument')
-    }
+	get(args: Partial<OutgoingMessageArguments>) {
+		if (typeof args.document === "undefined") {
+			throw new Error(
+				"The sync step two message requires document as an argument",
+			);
+		}
 
-    encoding.writeVarString(this.encoder, args.documentName!)
-    encoding.writeVarUint(this.encoder, this.type)
-    syncProtocol.writeSyncStep2(this.encoder, args.document)
+		encoding.writeVarString(this.encoder, args.documentName!);
+		encoding.writeVarUint(this.encoder, this.type);
+		syncProtocol.writeSyncStep2(this.encoder, args.document);
 
-    return this.encoder
-  }
+		return this.encoder;
+	}
 }

package/src/OutgoingMessages/UpdateMessage.ts

@@ -1,20 +1,20 @@
-import { writeVarString, writeVarUint } from 'lib0/encoding'
-import { writeUpdate } from 'y-protocols/sync'
-import type { OutgoingMessageArguments } from '../types.ts'
-import { MessageType } from '../types.ts'
-import { OutgoingMessage } from '../OutgoingMessage.ts'
+import { writeVarString, writeVarUint } from "lib0/encoding";
+import { writeUpdate } from "y-protocols/sync";
+import type { OutgoingMessageArguments } from "../types.ts";
+import { MessageType } from "../types.ts";
+import { OutgoingMessage } from "../OutgoingMessage.ts";
 
 export class UpdateMessage extends OutgoingMessage {
-  type = MessageType.Sync
+	type = MessageType.Sync;
 
-  description = 'A document update'
+	description = "A document update";
 
-  get(args: Partial<OutgoingMessageArguments>) {
-    writeVarString(this.encoder, args.documentName!)
-    writeVarUint(this.encoder, this.type)
+	get(args: Partial<OutgoingMessageArguments>) {
+		writeVarString(this.encoder, args.documentName!);
+		writeVarUint(this.encoder, this.type);
 
-    writeUpdate(this.encoder, args.update)
+		writeUpdate(this.encoder, args.update);
 
-    return this.encoder
-  }
+		return this.encoder;
+	}
 }

package/src/index.ts

@@ -1,3 +1,3 @@
-export * from './HocuspocusProvider.ts'
-export * from './HocuspocusProviderWebsocket.ts'
-export * from './types.ts'
+export * from "./HocuspocusProvider.ts";
+export * from "./HocuspocusProviderWebsocket.ts";
+export * from "./types.ts";

package/src/types.ts

@@ -1,113 +1,113 @@
-import type { Encoder } from 'lib0/encoding'
-import type { Event, MessageEvent } from 'ws'
-import type { Awareness } from 'y-protocols/awareness'
-import type * as Y from 'yjs'
-import type { CloseEvent } from '@hocuspocus/common'
-import type { IncomingMessage } from './IncomingMessage.ts'
-import type { OutgoingMessage } from './OutgoingMessage.ts'
-import type { AuthenticationMessage } from './OutgoingMessages/AuthenticationMessage.ts'
-import type { AwarenessMessage } from './OutgoingMessages/AwarenessMessage.ts'
-import type { QueryAwarenessMessage } from './OutgoingMessages/QueryAwarenessMessage.ts'
-import type { SyncStepOneMessage } from './OutgoingMessages/SyncStepOneMessage.ts'
-import type { SyncStepTwoMessage } from './OutgoingMessages/SyncStepTwoMessage.ts'
-import type { UpdateMessage } from './OutgoingMessages/UpdateMessage.ts'
+import type { Encoder } from "lib0/encoding";
+import type { Event, MessageEvent } from "ws";
+import type { Awareness } from "y-protocols/awareness";
+import type * as Y from "yjs";
+import type { CloseEvent } from "@hocuspocus/common";
+import type { IncomingMessage } from "./IncomingMessage.ts";
+import type { OutgoingMessage } from "./OutgoingMessage.ts";
+import type { AuthenticationMessage } from "./OutgoingMessages/AuthenticationMessage.ts";
+import type { AwarenessMessage } from "./OutgoingMessages/AwarenessMessage.ts";
+import type { QueryAwarenessMessage } from "./OutgoingMessages/QueryAwarenessMessage.ts";
+import type { SyncStepOneMessage } from "./OutgoingMessages/SyncStepOneMessage.ts";
+import type { SyncStepTwoMessage } from "./OutgoingMessages/SyncStepTwoMessage.ts";
+import type { UpdateMessage } from "./OutgoingMessages/UpdateMessage.ts";
 
 export enum MessageType {
-  Sync = 0,
-  Awareness = 1,
-  Auth = 2,
-  QueryAwareness = 3,
-  Stateless = 5,
-  CLOSE = 7,
-  SyncStatus = 8,
+	Sync = 0,
+	Awareness = 1,
+	Auth = 2,
+	QueryAwareness = 3,
+	Stateless = 5,
+	CLOSE = 7,
+	SyncStatus = 8,
 }
 
 export enum WebSocketStatus {
-  Connecting = 'connecting',
-  Connected = 'connected',
-  Disconnected = 'disconnected',
+	Connecting = "connecting",
+	Connected = "connected",
+	Disconnected = "disconnected",
 }
 
 export interface OutgoingMessageInterface {
-  encoder: Encoder
-  type?: MessageType
+	encoder: Encoder;
+	type?: MessageType;
 }
 
 export interface OutgoingMessageArguments {
-  documentName: string,
-  token: string,
-  document: Y.Doc,
-  awareness: Awareness,
-  clients: number[],
-  states: Map<number, { [key: string]: any; }>,
-  update: any,
-  payload: string,
-  encoder: Encoder,
+	documentName: string;
+	token: string;
+	document: Y.Doc;
+	awareness: Awareness;
+	clients: number[];
+	states: Map<number, { [key: string]: any }>;
+	update: any;
+	payload: string;
+	encoder: Encoder;
 }
 
 export interface Constructable<T> {
-  new(...args: any) : T
+	new (...args: any): T;
 }
 
 export type ConstructableOutgoingMessage =
-  Constructable<AuthenticationMessage> |
-  Constructable<AwarenessMessage> |
-  Constructable<QueryAwarenessMessage> |
-  Constructable<SyncStepOneMessage> |
-  Constructable<SyncStepTwoMessage> |
-  Constructable<UpdateMessage>
+	| Constructable<AuthenticationMessage>
+	| Constructable<AwarenessMessage>
+	| Constructable<QueryAwarenessMessage>
+	| Constructable<SyncStepOneMessage>
+	| Constructable<SyncStepTwoMessage>
+	| Constructable<UpdateMessage>;
 
 export type onAuthenticationFailedParameters = {
-  reason: string,
-}
+	reason: string;
+};
 
 export type onAuthenticatedParameters = {
-  scope: 'read-write' | 'readonly',
-}
+	scope: "read-write" | "readonly";
+};
 
 export type onOpenParameters = {
-  event: Event,
-}
+	event: Event;
+};
 
 export type onMessageParameters = {
-  event: MessageEvent,
-  message: IncomingMessage,
-}
+	event: MessageEvent;
+	message: IncomingMessage;
+};
 
 export type onOutgoingMessageParameters = {
-  message: OutgoingMessage,
-}
+	message: OutgoingMessage;
+};
 
 export type onStatusParameters = {
-  status: WebSocketStatus,
-}
+	status: WebSocketStatus;
+};
 
 export type onSyncedParameters = {
-  state: boolean,
-}
+	state: boolean;
+};
 
 export type onUnsyncedChangesParameters = {
-  number: number,
-}
+	number: number;
+};
 
 export type onDisconnectParameters = {
-  event: CloseEvent,
-}
+	event: CloseEvent;
+};
 
 export type onCloseParameters = {
-  event: CloseEvent,
-}
+	event: CloseEvent;
+};
 
 export type onAwarenessUpdateParameters = {
-  states: StatesArray
-}
+	states: StatesArray;
+};
 
 export type onAwarenessChangeParameters = {
-  states: StatesArray
-}
+	states: StatesArray;
+};
 
 export type onStatelessParameters = {
-  payload: string
-}
+	payload: string;
+};
 
-export type StatesArray = { clientId: number, [key: string | number]: any }[]
+export type StatesArray = { clientId: number; [key: string | number]: any }[];

package/dist/playground/frontend/app/SocketContext.d.ts

@@ -1,2 +0,0 @@
-import type { HocuspocusProviderWebsocket } from "@hocuspocus/provider";
-export declare const SocketContext: import("react").Context<HocuspocusProviderWebsocket | null>;