@hocuspocus/common 1.0.0-alpha.2

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

@@ -0,0 +1,158 @@
+import * as Y from 'yjs';
+import { Awareness } from 'y-protocols/awareness';
+import * as mutex from 'lib0/mutex';
+import { Event, CloseEvent, MessageEvent } from 'ws';
+import EventEmitter from './EventEmitter';
+import { OutgoingMessage } from './OutgoingMessage';
+import { ConstructableOutgoingMessage } from './types';
+export declare enum WebSocketStatus {
+    Connecting = "connecting",
+    Connected = "connected",
+    Disconnected = "disconnected"
+}
+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;
+    /**
+     * 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;
+    /**
+     * 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 }: {
+        reason: string;
+    }) => void;
+    onOpen: (event: Event) => void;
+    onConnect: () => void;
+    onMessage: (event: MessageEvent) => void;
+    onOutgoingMessage: (message: OutgoingMessage) => void;
+    onStatus: (status: any) => void;
+    onSynced: () => void;
+    onDisconnect: (event: CloseEvent) => void;
+    onClose: (event: CloseEvent) => void;
+    onDestroy: () => void;
+    onAwarenessUpdate: (states: any) => void;
+    onAwarenessChange: (states: any) => void;
+}
+export declare class HocuspocusProvider extends EventEmitter {
+    options: HocuspocusProviderOptions;
+    subscribedToBroadcastChannel: boolean;
+    webSocket: WebSocket | null;
+    shouldConnect: boolean;
+    status: WebSocketStatus;
+    isSynced: boolean;
+    isAuthenticated: boolean;
+    lastMessageReceived: number;
+    mux: mutex.mutex;
+    intervals: any;
+    connectionAttempt: {
+        resolve: (value?: any) => void;
+        reject: (reason?: any) => void;
+    } | null;
+    constructor(options?: Partial<HocuspocusProviderOptions>);
+    setOptions(options?: Partial<HocuspocusProviderOptions>): void;
+    connect(): Promise<void>;
+    createWebSocketConnection(): Promise<unknown>;
+    resolveConnectionAttempt(): void;
+    rejectConnectionAttempt(): void;
+    get document(): Y.Doc;
+    get awareness(): Awareness;
+    checkConnection(): void;
+    forceSync(): void;
+    registerBeforeUnloadEventListener(): void;
+    documentUpdateHandler(update: Uint8Array, origin: any): void;
+    awarenessUpdateHandler({ added, updated, removed }: any, origin: any): void;
+    permissionDeniedHandler(reason: string): void;
+    authenticatedHandler(): void;
+    get serverUrl(): string;
+    get url(): string;
+    get synced(): boolean;
+    set synced(state: boolean);
+    get isAuthenticationRequired(): boolean;
+    disconnect(): void;
+    onOpen(event: Event): void;
+    getToken(): Promise<string | null>;
+    webSocketConnectionEstablished(): Promise<void>;
+    startSync(): void;
+    send(Message: ConstructableOutgoingMessage, args: any, broadcast?: boolean): void;
+    onMessage(event: MessageEvent): void;
+    onClose(event: CloseEvent): void;
+    destroy(): void;
+    get broadcastChannel(): string;
+    broadcastChannelSubscriber(data: ArrayBuffer): void;
+    subscribeToBroadcastChannel(): void;
+    disconnectBroadcastChannel(): void;
+    broadcast(Message: ConstructableOutgoingMessage, args?: any): void;
+    setAwarenessField(key: string, value: any): void;
+}

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

@@ -0,0 +1,14 @@
+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;
+    readVarUint8Array(): Uint8Array;
+    writeVarUint(type: MessageType): void;
+    writeVarUint8Array(data: Uint8Array): void;
+    length(): number;
+}

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

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

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

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

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

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

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/AwarenessMessage.d.ts

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,34 @@
+import { Awareness } from 'y-protocols/awareness';
+import * as Y from 'yjs';
+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,
+    Auth = 2,
+    QueryAwareness = 3
+}
+export interface OutgoingMessageInterface {
+    encoder: Encoder;
+    type?: MessageType;
+}
+export interface OutgoingMessageArguments {
+    token: string;
+    document: Y.Doc;
+    awareness: Awareness;
+    clients: number[];
+    states: Map<number, {
+        [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/provider/src/utils/awarenessStatesToArray.d.ts

@@ -0,0 +1,4 @@
+declare const _default: (states: Map<number, Record<string, any>>) => {
+    clientId: number;
+}[];
+export default _default;

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

@@ -0,0 +1 @@
+export { default as awarenessStatesToArray } from './awarenessStatesToArray';

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

@@ -0,0 +1,4 @@
+import { CloseEvent } from './types';
+export declare const Forbidden: CloseEvent;
+export declare const ResetConnection: CloseEvent;
+export declare const CloseEvents: CloseEvent[];

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

@@ -0,0 +1,63 @@
+/// <reference types="node" />
+import AsyncLock from 'async-lock';
+import WebSocket from 'ws';
+import { IncomingMessage as HTTPIncomingMessage } from 'http';
+import Document from './Document';
+import { CloseEvent } from './types';
+import { MessageLogger } from './Debugger';
+declare class Connection {
+    webSocket: WebSocket;
+    context: any;
+    document: Document;
+    pingInterval: NodeJS.Timeout;
+    pongReceived: boolean;
+    request: HTTPIncomingMessage;
+    timeout: number;
+    callbacks: any;
+    socketId: string;
+    lock: AsyncLock;
+    readOnly: Boolean;
+    debugger: MessageLogger;
+    /**
+     * Constructor.
+     */
+    constructor(connection: WebSocket, request: HTTPIncomingMessage, document: Document, timeout: number, socketId: string, context: any, readOnly?: boolean);
+    /**
+     * Set a callback that will be triggered when the connection is closed
+     */
+    onClose(callback: (document: Document) => void): Connection;
+    /**
+     * Send the given message
+     */
+    send(message: any): void;
+    /**
+     * Graceful wrapper around the WebSocket close method.
+     */
+    close(event?: CloseEvent): void;
+    /**
+     * Check if pong was received and close the connection otherwise
+     * @private
+     */
+    private check;
+    /**
+     * Send the current document awareness to the client, if any
+     * @private
+     */
+    private sendCurrentAwareness;
+    /**
+     * Handle an incoming message
+     * @private
+     */
+    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,15 @@
+export declare class MessageLogger {
+    logs: any[];
+    listen: boolean;
+    output: boolean;
+    enable(): void;
+    disable(): void;
+    verbose(): void;
+    quiet(): void;
+    log(message: any): this;
+    flush(): this;
+    get(): {
+        logs: any[];
+    };
+}
+export declare const Debugger: MessageLogger;

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

@@ -0,0 +1,75 @@
+import WebSocket from 'ws';
+import { Awareness } from 'y-protocols/awareness';
+import { Doc } from 'yjs';
+import { mutex } from 'lib0/mutex.js';
+import Connection from './Connection';
+import { MessageLogger } from './Debugger';
+declare class Document extends Doc {
+    awareness: Awareness;
+    callbacks: {
+        onUpdate: (document: Document, connection: Connection, update: Uint8Array) => void;
+    };
+    connections: Map<any, any>;
+    name: string;
+    mux: mutex;
+    debugger: MessageLogger;
+    /**
+     * Constructor.
+     */
+    constructor(name: string);
+    /**
+     * Check if the Document is empty
+     */
+    isEmpty(fieldName: string): boolean;
+    /**
+     * Merge the given document(s) into this one
+     */
+    merge(documents: Doc | Array<Doc>): Document;
+    /**
+     * Set a callback that will be triggered when the document is updated
+     */
+    onUpdate(callback: (document: Document, connection: Connection, update: Uint8Array) => void): Document;
+    /**
+     * Register a connection and a set of clients on this document keyed by the
+     * underlying websocket connection
+     */
+    addConnection(connection: Connection): Document;
+    /**
+     * Is the given connection registered on this document
+     */
+    hasConnection(connection: Connection): boolean;
+    /**
+     * Remove the given connection from this document
+     */
+    removeConnection(connection: Connection): Document;
+    /**
+     * Get the number of active connections for this document
+     */
+    getConnectionsCount(): number;
+    /**
+     * Get an array of registered connections
+     */
+    getConnections(): Array<Connection>;
+    /**
+     * Get the client ids for the given connection instance
+     */
+    getClients(connectionInstance: WebSocket): Set<any>;
+    /**
+     * Has the document awareness states
+     */
+    hasAwarenessStates(): boolean;
+    /**
+     * Apply the given awareness update
+     */
+    applyAwarenessUpdate(connection: Connection, update: Uint8Array): Document;
+    /**
+     * Handle an awareness update and sync changes to clients
+     * @private
+     */
+    private handleAwarenessUpdate;
+    /**
+     * Handle an updated document and sync changes to clients
+     */
+    private handleUpdate;
+}
+export default Document;

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

@@ -0,0 +1,86 @@
+/// <reference types="node" />
+import WebSocket, { WebSocketServer } from 'ws';
+import { IncomingMessage, Server as HTTPServer } from 'http';
+import { Configuration, Hook } from './types';
+import { MessageLogger } from './Debugger';
+export declare const defaultConfiguration: {
+    name: null;
+    port: number;
+    timeout: number;
+};
+/**
+ * Hocuspocus server
+ */
+export declare class Hocuspocus {
+    configuration: Configuration;
+    documents: Map<any, any>;
+    httpServer?: HTTPServer;
+    webSocketServer?: WebSocketServer;
+    debugger: MessageLogger;
+    /**
+     * Configure the server
+     */
+    configure(configuration: Partial<Configuration>): Hocuspocus;
+    get authenticationRequired(): boolean;
+    /**
+     * Start the server
+     */
+    listen(): Promise<void>;
+    /**
+     * 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
+     */
+    handleConnection(incoming: WebSocket, request: IncomingMessage, documentName: string, context?: any): void;
+    /**
+     * Handle update of the given document
+     * @private
+     */
+    private handleDocumentUpdate;
+    /**
+     * 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
+     */
+    hooks(name: Hook, payload: any, 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;
+    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

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

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

@@ -0,0 +1,10 @@
+import Connection from './Connection';
+import { IncomingMessage } from './IncomingMessage';
+import { MessageLogger } from './Debugger';
+export declare class MessageReceiver {
+    message: IncomingMessage;
+    debugger: MessageLogger;
+    constructor(message: IncomingMessage);
+    apply(connection: Connection): void;
+    readSyncMessage(message: IncomingMessage, connection: Connection): 0 | 1 | 2;
+}

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

@@ -0,0 +1,16 @@
+import { Encoder } from 'lib0/encoding';
+import { Awareness } from 'y-protocols/awareness';
+import Document from './Document';
+export declare class OutgoingMessage {
+    encoder: Encoder;
+    type?: number;
+    category?: string;
+    constructor();
+    createSyncMessage(): OutgoingMessage;
+    createAwarenessUpdateMessage(awareness: Awareness, changedClients?: Array<any>): 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

@@ -0,0 +1,2 @@
+export * from './Hocuspocus';
+export * from './types';