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

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

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

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

@@ -1,10 +1,11 @@
-import * as encoding from 'lib0/encoding';
 import { HocuspocusProvider } from './HocuspocusProvider';
 import { IncomingMessage } from './IncomingMessage';
 export declare class MessageReceiver {
     message: IncomingMessage;
+    broadcasted: boolean;
     constructor(message: IncomingMessage);
-    apply(provider: HocuspocusProvider, emitSynced?: boolean): encoding.Encoder;
+    setBroadcasted(value: boolean): this;
+    apply(provider: HocuspocusProvider, emitSynced?: boolean): void;
     private applySyncMessage;
     private applyAwarenessMessage;
     private applyAuthMessage;

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

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

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

@@ -0,0 +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;
+}

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

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

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

@@ -1,3 +1,3 @@
 export * from './HocuspocusProvider';
+export * from './HocuspocusCloudProvider';
 export * from './types';
-export * from './utils';

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

@@ -1,17 +1,32 @@
 import { Awareness } from 'y-protocols/awareness';
 import * as Y from 'yjs';
-import * as encoding from 'lib0/encoding';
+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
 }
+export declare enum WebSocketStatus {
+    Connecting = "connecting",
+    Connected = "connected",
+    Disconnected = "disconnected"
+}
 export interface OutgoingMessageInterface {
-    encoder: encoding.Encoder;
+    encoder: Encoder;
     type?: MessageType;
 }
 export interface OutgoingMessageArguments {
+    token: string;
     document: Y.Doc;
     awareness: Awareness;
     clients: number[];
@@ -19,7 +34,44 @@ 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>;
+export declare type onAuthenticationFailedParameters = {
+    reason: string;
+};
+export declare type onOpenParameters = {
+    event: Event;
+};
+export declare type onMessageParameters = {
+    event: MessageEvent;
+    message: IncomingMessage;
+};
+export declare type onOutgoingMessageParameters = {
+    message: OutgoingMessage;
+};
+export declare type onStatusParameters = {
+    status: WebSocketStatus;
+};
+export declare type onSyncedParameters = {
+    state: boolean;
+};
+export declare type onDisconnectParameters = {
+    event: CloseEvent;
+};
+export declare type onCloseParameters = {
+    event: CloseEvent;
+};
+export declare type onAwarenessUpdateParameters = {
+    states: StatesArray;
+};
+export declare type onAwarenessChangeParameters = {
+    states: StatesArray;
+};
+export declare type StatesArray = {
+    clientId: number;
+    [key: string | number]: any;
+}[];

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

@@ -2,9 +2,11 @@
 import AsyncLock from 'async-lock';
 import WebSocket from 'ws';
 import { IncomingMessage as HTTPIncomingMessage } from 'http';
+import { CloseEvent } from '@hocuspocus/common';
 import Document from './Document';
-declare class Connection {
-    connection: WebSocket;
+import { Debugger } from './Debugger';
+export declare class Connection {
+    webSocket: WebSocket;
     context: any;
     document: Document;
     pingInterval: NodeJS.Timeout;
@@ -15,10 +17,11 @@ declare class Connection {
     socketId: string;
     lock: AsyncLock;
     readOnly: Boolean;
+    logger: Debugger;
     /**
      * Constructor.
      */
-    constructor(connection: WebSocket, request: HTTPIncomingMessage, document: Document, timeout: number, socketId: string, context: any, readOnly?: boolean);
+    constructor(connection: WebSocket, request: HTTPIncomingMessage, document: Document, timeout: number, socketId: string, context: any, readOnly: boolean | undefined, logger: Debugger);
     /**
      * Set a callback that will be triggered when the connection is closed
      */
@@ -28,19 +31,19 @@ declare class Connection {
      */
     send(message: any): void;
     /**
-     * Close the connection
+     * Graceful wrapper around the WebSocket close method.
      */
-    close(): void;
+    close(event?: CloseEvent): void;
     /**
      * Check if pong was received and close the connection otherwise
      * @private
      */
     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
@@ -48,7 +51,13 @@ declare class Connection {
     private handleMessage;
     /**
      * Get the underlying connection instance
+     * @deprecated
      */
     get instance(): WebSocket;
+    /**
+     * Get the underlying connection instance
+     * @deprecated
+     */
+    get connection(): WebSocket;
 }
 export default Connection;

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

@@ -0,0 +1,14 @@
+export declare class Debugger {
+    logs: any[];
+    listen: boolean;
+    output: boolean;
+    enable(): void;
+    disable(): void;
+    verbose(): void;
+    quiet(): void;
+    log(message: any): this;
+    flush(): this;
+    get(): {
+        logs: any[];
+    };
+}

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

@@ -3,18 +3,24 @@ import { Awareness } from 'y-protocols/awareness';
 import { Doc } from 'yjs';
 import { mutex } from 'lib0/mutex.js';
 import Connection from './Connection';
-declare class Document extends Doc {
+import { Debugger } from './Debugger';
+export declare class Document extends Doc {
     awareness: Awareness;
     callbacks: {
         onUpdate: (document: Document, connection: Connection, update: Uint8Array) => void;
     };
-    connections: Map<any, any>;
+    connections: Map<WebSocket, {
+        clients: Set<any>;
+        connection: Connection;
+    }>;
     name: string;
     mux: mutex;
+    logger: Debugger;
+    isLoading: boolean;
     /**
      * Constructor.
      */
-    constructor(name: string);
+    constructor(name: string, logger: Debugger, yDocOptions: {});
     /**
      * Check if the Document is empty
      */
@@ -41,9 +47,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

@@ -1,65 +1,111 @@
 /// <reference types="node" />
-import WebSocket from 'ws';
+import WebSocket, { AddressInfo, WebSocketServer } from 'ws';
 import { IncomingMessage, Server as HTTPServer } from 'http';
-import { Configuration } from './types';
+import { Configuration, HookName, HookPayload } from './types';
+import Document from './Document';
+import { Debugger } from './Debugger';
+import { onListenPayload } from '.';
 export declare const defaultConfiguration: {
+    name: null;
     port: number;
     timeout: number;
+    debounce: number;
+    maxDebounce: number;
+    quiet: boolean;
+    yDocOptions: {
+        gc: boolean;
+        gcFilter: () => boolean;
+    };
 };
 /**
- * Hocuspocus yjs websocket server
+ * Hocuspocus Server
  */
 export declare class Hocuspocus {
     configuration: Configuration;
-    documents: Map<any, any>;
+    documents: Map<string, Document>;
     httpServer?: HTTPServer;
-    websocketServer?: WebSocket.Server;
+    webSocketServer?: WebSocketServer;
+    debugger: Debugger;
+    constructor(configuration?: Partial<Configuration>);
     /**
      * Configure the server
      */
     configure(configuration: Partial<Configuration>): Hocuspocus;
+    get requiresAuthentication(): boolean;
     /**
      * Start the server
      */
-    listen(): Promise<void>;
+    listen(portOrCallback?: number | ((data: onListenPayload) => Promise<any>) | null, callback?: any): Promise<Hocuspocus>;
+    get address(): AddressInfo;
+    get URL(): string;
+    get webSocketURL(): string;
+    get httpURL(): string;
+    private showStartScreen;
+    /**
+     * 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;
     /**
      * Destroy the server
      */
     destroy(): Promise<any>;
     /**
-     * Handle the incoming websocket connection
+     * The `handleConnection` method 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.
      */
     handleConnection(incoming: WebSocket, request: IncomingMessage, documentName: string, context?: any): void;
     /**
      * Handle update of the given document
-     * @private
      */
     private handleDocumentUpdate;
+    timers: Map<string, {
+        timeout: NodeJS.Timeout;
+        start: number;
+    }>;
+    /**
+     * debounce the given function, using the given identifier
+     */
+    debounce(id: string, func: Function, immediately?: boolean): void;
     /**
      * Create a new document by the given request
-     * @private
      */
     private createDocument;
     /**
      * Create a new connection by the given request and document
-     * @private
      */
     private createConnection;
     /**
-     * Run the given hook on all configured extensions
-     * Runs the given callback after each hook
-     * @private
+     * Run the given hook on all configured extensions.
+     * Runs the given callback after each hook.
      */
-    private hooks;
+    hooks(name: HookName, payload: HookPayload, callback?: Function | null): Promise<any>;
     /**
      * Get parameters by the given request
-     * @private
      */
     private static getParameters;
     /**
      * Get document name by the given request
-     * @private
      */
-    private static getDocumentName;
+    private getDocumentNameFromRequest;
+    enableDebugging(): void;
+    enableMessageLogging(): void;
+    disableLogging(): void;
+    disableDebugging(): void;
+    flushMessageLogs(): this;
+    getMessageLogs(): any[];
 }
 export declare const Server: Hocuspocus;

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

@@ -1,15 +1,19 @@
 import { Decoder } from 'lib0/decoding';
 import { Encoder } from 'lib0/encoding';
-import Document from './Document';
-import Connection from './Connection';
+import { MessageType } from './types';
 export declare class IncomingMessage {
+    /**
+     * Access to the received message.
+     */
     decoder: Decoder;
-    syncMessageEncoder?: Encoder;
+    /**
+     * Access to the reply.
+     */
+    encoder: Encoder;
     constructor(input: any);
-    readSyncMessageAndApplyItTo(document: Document, connection?: Connection): void;
-    readUint8Array(): Uint8Array;
+    readVarUint8Array(): Uint8Array;
+    readVarUint(): number;
     toUint8Array(): Uint8Array;
+    writeVarUint(type: MessageType): void;
     get length(): number;
-    get messageType(): number;
-    private get encoder();
 }

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

@@ -0,0 +1,13 @@
+import { Awareness } from 'y-protocols/awareness';
+import Connection from './Connection';
+import { IncomingMessage } from './IncomingMessage';
+import { Debugger } from './Debugger';
+import Document from './Document';
+export declare class MessageReceiver {
+    message: IncomingMessage;
+    logger: Debugger;
+    constructor(message: IncomingMessage, logger: Debugger);
+    apply(document: Document, connection?: Connection, reply?: (message: Uint8Array) => void): void;
+    readSyncMessage(message: IncomingMessage, document: Document, connection?: Connection, reply?: (message: Uint8Array) => void, requestFirstSync?: boolean): 0 | 2 | 1;
+    applyQueryAwarenessMessage(awareness: Awareness, reply?: (message: Uint8Array) => void): void;
+}

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

@@ -3,9 +3,15 @@ import { Awareness } from 'y-protocols/awareness';
 import Document from './Document';
 export declare class OutgoingMessage {
     encoder: Encoder;
+    type?: number;
+    category?: string;
     constructor();
     createSyncMessage(): OutgoingMessage;
+    createSyncReplyMessage(): OutgoingMessage;
     createAwarenessUpdateMessage(awareness: Awareness, changedClients?: Array<any>): OutgoingMessage;
+    writeQueryAwareness(): OutgoingMessage;
+    writeAuthenticated(): OutgoingMessage;
+    writePermissionDenied(reason: string): OutgoingMessage;
     writeFirstSyncStepFor(document: Document): OutgoingMessage;
     writeUpdate(update: Uint8Array): OutgoingMessage;
     toUint8Array(): Uint8Array;

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

@@ -1,2 +1,8 @@
+export * from './Connection';
+export * from './Debugger';
+export * from './Document';
 export * from './Hocuspocus';
+export * from './IncomingMessage';
+export * from './MessageReceiver';
+export * from './OutgoingMessage';
 export * from './types';