@hocuspocus/provider 2.1.0-alpha.0 → 2.2.0

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

@@ -1,16 +1,16 @@
-import { Decoder } from 'lib0/decoding';
-import { Encoder } from 'lib0/encoding';
-import { MessageType } from './types';
-export declare class IncomingMessage {
-    data: any;
-    encoder: Encoder;
-    decoder: Decoder;
-    constructor(data: any);
-    readVarUint(): MessageType;
-    readVarString(): string;
-    readVarUint8Array(): Uint8Array;
-    writeVarUint(type: MessageType): void;
-    writeVarString(string: string): void;
-    writeVarUint8Array(data: Uint8Array): void;
-    length(): number;
-}
+import { Decoder } from 'lib0/decoding';
+import { Encoder } from 'lib0/encoding';
+import { MessageType } from './types.js';
+export declare class IncomingMessage {
+    data: any;
+    encoder: Encoder;
+    decoder: Decoder;
+    constructor(data: any);
+    readVarUint(): MessageType;
+    readVarString(): string;
+    readVarUint8Array(): Uint8Array;
+    writeVarUint(type: MessageType): void;
+    writeVarString(string: string): void;
+    writeVarUint8Array(data: Uint8Array): void;
+    length(): number;
+}

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

@@ -1,13 +1,13 @@
-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;
-    private applyAuthMessage;
-    private applyQueryAwarenessMessage;
-}
+import { HocuspocusProvider } from './HocuspocusProvider.js';
+import { IncomingMessage } from './IncomingMessage.js';
+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;
+    private applyAuthMessage;
+    private applyQueryAwarenessMessage;
+}

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

@@ -1,10 +1,10 @@
-import { Encoder } from 'lib0/encoding';
-import { ConstructableOutgoingMessage } from './types';
-export declare class MessageSender {
-    encoder: Encoder;
-    message: any;
-    constructor(Message: ConstructableOutgoingMessage, args?: any);
-    create(): Uint8Array;
-    send(webSocket: any): void;
-    broadcast(channel: string): void;
-}
+import { Encoder } from 'lib0/encoding';
+import { ConstructableOutgoingMessage } from './types.js';
+export declare class MessageSender {
+    encoder: Encoder;
+    message: 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,9 +1,9 @@
-import { Encoder } from 'lib0/encoding';
-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;
-}
+import { Encoder } from 'lib0/encoding';
+import { MessageType, OutgoingMessageArguments, OutgoingMessageInterface } from './types.js';
+export declare class OutgoingMessage implements OutgoingMessageInterface {
+    encoder: Encoder;
+    type?: MessageType;
+    constructor();
+    get(args: Partial<OutgoingMessageArguments>): Encoder | undefined;
+    toUint8Array(): Uint8Array;
+}

package/dist/packages/provider/src/OutgoingMessages/AuthenticationMessage.d.ts

@@ -1,7 +1,7 @@
-import { MessageType, OutgoingMessageArguments } from '../types';
-import { OutgoingMessage } from '../OutgoingMessage';
-export declare class AuthenticationMessage extends OutgoingMessage {
-    type: MessageType;
-    description: string;
-    get(args: Partial<OutgoingMessageArguments>): import("lib0/encoding").Encoder;
-}
+import { MessageType, OutgoingMessageArguments } from '../types.js';
+import { OutgoingMessage } from '../OutgoingMessage.js';
+export declare class AuthenticationMessage extends OutgoingMessage {
+    type: MessageType;
+    description: string;
+    get(args: Partial<OutgoingMessageArguments>): import("lib0/encoding").Encoder;
+}

package/dist/packages/provider/src/OutgoingMessages/AwarenessMessage.d.ts

@@ -1,8 +1,8 @@
-import * as encoding from 'lib0/encoding';
-import { MessageType, OutgoingMessageArguments } from '../types';
-import { OutgoingMessage } from '../OutgoingMessage';
-export declare class AwarenessMessage extends OutgoingMessage {
-    type: MessageType;
-    description: string;
-    get(args: Partial<OutgoingMessageArguments>): encoding.Encoder;
-}
+import * as encoding from 'lib0/encoding';
+import { MessageType, OutgoingMessageArguments } from '../types.js';
+import { OutgoingMessage } from '../OutgoingMessage.js';
+export declare class AwarenessMessage extends OutgoingMessage {
+    type: MessageType;
+    description: string;
+    get(args: Partial<OutgoingMessageArguments>): encoding.Encoder;
+}

package/dist/packages/provider/src/OutgoingMessages/CloseMessage.d.ts

@@ -1,8 +1,8 @@
-import * as encoding from 'lib0/encoding';
-import { MessageType, OutgoingMessageArguments } from '../types';
-import { OutgoingMessage } from '../OutgoingMessage';
-export declare class CloseMessage extends OutgoingMessage {
-    type: MessageType;
-    description: string;
-    get(args: Partial<OutgoingMessageArguments>): encoding.Encoder;
-}
+import * as encoding from 'lib0/encoding';
+import { MessageType, OutgoingMessageArguments } from '../types.js';
+import { OutgoingMessage } from '../OutgoingMessage.js';
+export declare class CloseMessage extends OutgoingMessage {
+    type: MessageType;
+    description: string;
+    get(args: Partial<OutgoingMessageArguments>): encoding.Encoder;
+}

package/dist/packages/provider/src/OutgoingMessages/QueryAwarenessMessage.d.ts

@@ -1,8 +1,8 @@
-import * as encoding from 'lib0/encoding';
-import { MessageType, OutgoingMessageArguments } from '../types';
-import { OutgoingMessage } from '../OutgoingMessage';
-export declare class QueryAwarenessMessage extends OutgoingMessage {
-    type: MessageType;
-    description: string;
-    get(args: Partial<OutgoingMessageArguments>): encoding.Encoder;
-}
+import * as encoding from 'lib0/encoding';
+import { MessageType, OutgoingMessageArguments } from '../types.js';
+import { OutgoingMessage } from '../OutgoingMessage.js';
+export declare class QueryAwarenessMessage extends OutgoingMessage {
+    type: MessageType;
+    description: string;
+    get(args: Partial<OutgoingMessageArguments>): encoding.Encoder;
+}

package/dist/packages/provider/src/OutgoingMessages/StatelessMessage.d.ts

@@ -1,7 +1,7 @@
-import { MessageType, OutgoingMessageArguments } from '../types';
-import { OutgoingMessage } from '../OutgoingMessage';
-export declare class StatelessMessage extends OutgoingMessage {
-    type: MessageType;
-    description: string;
-    get(args: Partial<OutgoingMessageArguments>): import("lib0/encoding").Encoder;
-}
+import { MessageType, OutgoingMessageArguments } from '../types.js';
+import { OutgoingMessage } from '../OutgoingMessage.js';
+export declare class StatelessMessage extends OutgoingMessage {
+    type: MessageType;
+    description: string;
+    get(args: Partial<OutgoingMessageArguments>): import("lib0/encoding").Encoder;
+}

package/dist/packages/provider/src/OutgoingMessages/SyncStepOneMessage.d.ts

@@ -1,8 +1,8 @@
-import * as encoding from 'lib0/encoding';
-import { MessageType, OutgoingMessageArguments } from '../types';
-import { OutgoingMessage } from '../OutgoingMessage';
-export declare class SyncStepOneMessage extends OutgoingMessage {
-    type: MessageType;
-    description: string;
-    get(args: Partial<OutgoingMessageArguments>): encoding.Encoder;
-}
+import * as encoding from 'lib0/encoding';
+import { MessageType, OutgoingMessageArguments } from '../types.js';
+import { OutgoingMessage } from '../OutgoingMessage.js';
+export declare class SyncStepOneMessage extends OutgoingMessage {
+    type: MessageType;
+    description: string;
+    get(args: Partial<OutgoingMessageArguments>): encoding.Encoder;
+}

package/dist/packages/provider/src/OutgoingMessages/SyncStepTwoMessage.d.ts

@@ -1,8 +1,8 @@
-import * as encoding from 'lib0/encoding';
-import { MessageType, OutgoingMessageArguments } from '../types';
-import { OutgoingMessage } from '../OutgoingMessage';
-export declare class SyncStepTwoMessage extends OutgoingMessage {
-    type: MessageType;
-    description: string;
-    get(args: Partial<OutgoingMessageArguments>): encoding.Encoder;
-}
+import * as encoding from 'lib0/encoding';
+import { MessageType, OutgoingMessageArguments } from '../types.js';
+import { OutgoingMessage } from '../OutgoingMessage.js';
+export declare class SyncStepTwoMessage extends OutgoingMessage {
+    type: MessageType;
+    description: string;
+    get(args: Partial<OutgoingMessageArguments>): encoding.Encoder;
+}

package/dist/packages/provider/src/OutgoingMessages/UpdateMessage.d.ts

@@ -1,7 +1,7 @@
-import { MessageType, OutgoingMessageArguments } from '../types';
-import { OutgoingMessage } from '../OutgoingMessage';
-export declare class UpdateMessage extends OutgoingMessage {
-    type: MessageType;
-    description: string;
-    get(args: Partial<OutgoingMessageArguments>): import("lib0/encoding").Encoder;
-}
+import { MessageType, OutgoingMessageArguments } from '../types.js';
+import { OutgoingMessage } from '../OutgoingMessage.js';
+export declare class UpdateMessage extends OutgoingMessage {
+    type: MessageType;
+    description: string;
+    get(args: Partial<OutgoingMessageArguments>): import("lib0/encoding").Encoder;
+}

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

@@ -1,11 +1,11 @@
-import { HocuspocusProvider, HocuspocusProviderConfiguration } from './HocuspocusProvider';
-export type TiptapCollabProviderConfiguration = Required<Pick<HocuspocusProviderConfiguration, 'name'>> & Partial<HocuspocusProviderConfiguration> & AdditionalTiptapCollabProviderConfiguration;
-export interface AdditionalTiptapCollabProviderConfiguration {
-    /**
-     * A Hocuspocus Cloud App ID, get one here: https://collab.tiptap.dev
-     */
-    appId: string;
-}
-export declare class TiptapCollabProvider extends HocuspocusProvider {
-    constructor(configuration: TiptapCollabProviderConfiguration);
-}
+import { HocuspocusProvider, HocuspocusProviderConfiguration } from './HocuspocusProvider.js';
+export type TiptapCollabProviderConfiguration = Required<Pick<HocuspocusProviderConfiguration, 'name'>> & Partial<HocuspocusProviderConfiguration> & AdditionalTiptapCollabProviderConfiguration;
+export interface AdditionalTiptapCollabProviderConfiguration {
+    /**
+     * A Hocuspocus Cloud App ID, get one here: https://collab.tiptap.dev
+     */
+    appId: string;
+}
+export declare class TiptapCollabProvider extends HocuspocusProvider {
+    constructor(configuration: TiptapCollabProviderConfiguration);
+}

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

@@ -1,11 +1,11 @@
-import { CompleteHocuspocusProviderWebsocketConfiguration, HocuspocusProviderWebsocket } from './HocuspocusProviderWebsocket';
-export type TiptapCollabProviderWebsocketConfiguration = Partial<CompleteHocuspocusProviderWebsocketConfiguration> & AdditionalTiptapCollabProviderWebsocketConfiguration;
-export interface AdditionalTiptapCollabProviderWebsocketConfiguration {
-    /**
-     * A Hocuspocus Cloud App ID, get one here: https://collab.tiptap.dev
-     */
-    appId: string;
-}
-export declare class TiptapCollabProviderWebsocket extends HocuspocusProviderWebsocket {
-    constructor(configuration: TiptapCollabProviderWebsocketConfiguration);
-}
+import { CompleteHocuspocusProviderWebsocketConfiguration, HocuspocusProviderWebsocket } from './HocuspocusProviderWebsocket.js';
+export type TiptapCollabProviderWebsocketConfiguration = Partial<CompleteHocuspocusProviderWebsocketConfiguration> & AdditionalTiptapCollabProviderWebsocketConfiguration;
+export interface AdditionalTiptapCollabProviderWebsocketConfiguration {
+    /**
+     * A Hocuspocus Cloud App ID, get one here: https://collab.tiptap.dev
+     */
+    appId: string;
+}
+export declare class TiptapCollabProviderWebsocket extends HocuspocusProviderWebsocket {
+    constructor(configuration: TiptapCollabProviderWebsocketConfiguration);
+}

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

@@ -1,5 +1,5 @@
-export * from './HocuspocusProvider';
-export * from './TiptapCollabProvider';
-export * from './TiptapCollabProviderWebsocket';
-export * from './HocuspocusProviderWebsocket';
-export * from './types';
+export * from './HocuspocusProvider.js';
+export * from './TiptapCollabProvider.js';
+export * from './TiptapCollabProviderWebsocket.js';
+export * from './HocuspocusProviderWebsocket.js';
+export * from './types.js';

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

@@ -1,84 +1,84 @@
-import { Awareness } from 'y-protocols/awareness';
-import * as Y from 'yjs';
-import { Encoder } from 'lib0/encoding';
-import type { Event, CloseEvent, MessageEvent } from 'ws';
-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 { IncomingMessage } from './IncomingMessage';
-import { OutgoingMessage } from './OutgoingMessage';
-export declare enum MessageType {
-    Sync = 0,
-    Awareness = 1,
-    Auth = 2,
-    QueryAwareness = 3,
-    Stateless = 5,
-    CLOSE = 7
-}
-export declare enum WebSocketStatus {
-    Connecting = "connecting",
-    Connected = "connected",
-    Disconnected = "disconnected"
-}
-export interface OutgoingMessageInterface {
-    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;
-}
-export interface Constructable<T> {
-    new (...args: any): T;
-}
-export type ConstructableOutgoingMessage = Constructable<AuthenticationMessage> | Constructable<AwarenessMessage> | Constructable<QueryAwarenessMessage> | Constructable<SyncStepOneMessage> | Constructable<SyncStepTwoMessage> | Constructable<UpdateMessage>;
-export type onAuthenticationFailedParameters = {
-    reason: string;
-};
-export type onOpenParameters = {
-    event: Event;
-};
-export type onMessageParameters = {
-    event: MessageEvent;
-    message: IncomingMessage;
-};
-export type onOutgoingMessageParameters = {
-    message: OutgoingMessage;
-};
-export type onStatusParameters = {
-    status: WebSocketStatus;
-};
-export type onSyncedParameters = {
-    state: boolean;
-};
-export type onDisconnectParameters = {
-    event: CloseEvent;
-};
-export type onCloseParameters = {
-    event: CloseEvent;
-};
-export type onAwarenessUpdateParameters = {
-    states: StatesArray;
-};
-export type onAwarenessChangeParameters = {
-    states: StatesArray;
-};
-export type onStatelessParameters = {
-    payload: string;
-};
-export type StatesArray = {
-    clientId: number;
-    [key: string | number]: any;
-}[];
+import { Awareness } from 'y-protocols/awareness';
+import * as Y from 'yjs';
+import { Encoder } from 'lib0/encoding';
+import type { Event, CloseEvent, MessageEvent } from 'ws';
+import { AuthenticationMessage } from './OutgoingMessages/AuthenticationMessage.js';
+import { AwarenessMessage } from './OutgoingMessages/AwarenessMessage.js';
+import { QueryAwarenessMessage } from './OutgoingMessages/QueryAwarenessMessage.js';
+import { SyncStepOneMessage } from './OutgoingMessages/SyncStepOneMessage.js';
+import { SyncStepTwoMessage } from './OutgoingMessages/SyncStepTwoMessage.js';
+import { UpdateMessage } from './OutgoingMessages/UpdateMessage.js';
+import { IncomingMessage } from './IncomingMessage.js';
+import { OutgoingMessage } from './OutgoingMessage.js';
+export declare enum MessageType {
+    Sync = 0,
+    Awareness = 1,
+    Auth = 2,
+    QueryAwareness = 3,
+    Stateless = 5,
+    CLOSE = 7
+}
+export declare enum WebSocketStatus {
+    Connecting = "connecting",
+    Connected = "connected",
+    Disconnected = "disconnected"
+}
+export interface OutgoingMessageInterface {
+    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;
+}
+export interface Constructable<T> {
+    new (...args: any): T;
+}
+export type ConstructableOutgoingMessage = Constructable<AuthenticationMessage> | Constructable<AwarenessMessage> | Constructable<QueryAwarenessMessage> | Constructable<SyncStepOneMessage> | Constructable<SyncStepTwoMessage> | Constructable<UpdateMessage>;
+export type onAuthenticationFailedParameters = {
+    reason: string;
+};
+export type onOpenParameters = {
+    event: Event;
+};
+export type onMessageParameters = {
+    event: MessageEvent;
+    message: IncomingMessage;
+};
+export type onOutgoingMessageParameters = {
+    message: OutgoingMessage;
+};
+export type onStatusParameters = {
+    status: WebSocketStatus;
+};
+export type onSyncedParameters = {
+    state: boolean;
+};
+export type onDisconnectParameters = {
+    event: CloseEvent;
+};
+export type onCloseParameters = {
+    event: CloseEvent;
+};
+export type onAwarenessUpdateParameters = {
+    states: StatesArray;
+};
+export type onAwarenessChangeParameters = {
+    states: StatesArray;
+};
+export type onStatelessParameters = {
+    payload: string;
+};
+export type StatesArray = {
+    clientId: number;
+    [key: string | number]: any;
+}[];

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

@@ -0,0 +1,56 @@
+/// <reference types="node" />
+import { IncomingMessage } from 'http';
+import WebSocket from 'ws';
+import { Debugger } from './Debugger.js';
+import Document from './Document.js';
+import { Hocuspocus } from './Hocuspocus.js';
+import { onDisconnectPayload } from './types.js';
+/**
+ * The `ClientConnection` class is responsible for handling an incoming WebSocket
+ *
+ * TODO-refactor:
+ * - use event handlers instead of calling hooks directly, hooks should probably be called from Hocuspocus.ts
+ */
+export declare class ClientConnection {
+    private readonly websocket;
+    private readonly request;
+    private readonly documentProvider;
+    private readonly hooks;
+    private readonly debuggerTool;
+    private readonly opts;
+    private readonly defaultContext;
+    private readonly documentConnections;
+    private readonly incomingMessageQueue;
+    private readonly documentConnectionsEstablished;
+    private readonly hookPayloads;
+    private readonly callbacks;
+    private readonly closeIdleConnectionTimeout;
+    private readonly socketId;
+    /**
+      * The `ClientConnection` class receives incoming WebSocket connections,
+      * runs all hooks:
+      *
+      *  - onConnect for all connections
+      *  - onAuthenticate only if required
+      *
+      * … and if nothings fails it’ll fully establish the connection and
+      * load the Document then.
+      */
+    constructor(websocket: WebSocket, request: IncomingMessage, documentProvider: {
+        createDocument: Hocuspocus['createDocument'];
+    }, hooks: Hocuspocus['hooks'], debuggerTool: Debugger, opts: {
+        requiresAuthentication: boolean;
+        timeout: number;
+    }, defaultContext?: any);
+    /**
+     * Set a callback that will be triggered when the connection is closed
+     */
+    onClose(callback: (document: Document, payload: onDisconnectPayload) => void): ClientConnection;
+    /**
+     * Create a new connection by the given request and document
+     */
+    private createConnection;
+    private setUpNewConnection;
+    private handleQueueingMessage;
+    private messageHandler;
+}