@hocuspocus/provider 1.0.0-alpha.14 → 1.0.0-alpha.18

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

@@ -4,30 +4,94 @@ import * as mutex from 'lib0/mutex';
 import { CloseEvent, MessageEvent, OpenEvent } 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;
-    token: string | (() => string) | (() => Promise<string>);
+    /**
+     * 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;
-    reconnectTimeoutBase: number;
-    maxReconnectTimeout: 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: string }: {
-        reason: any;
+    onAuthenticationFailed: ({ reason }: {
+        reason: string;
     }) => void;
     onOpen: (event: OpenEvent) => void;
     onConnect: () => void;
@@ -40,23 +104,28 @@ export interface HocuspocusProviderOptions {
     onDestroy: () => void;
     onAwarenessUpdate: (states: any) => void;
     onAwarenessChange: (states: any) => void;
-    debug: boolean;
 }
 export declare class HocuspocusProvider extends EventEmitter {
     options: HocuspocusProviderOptions;
-    awareness: Awareness;
     subscribedToBroadcastChannel: boolean;
     webSocket: any;
     shouldConnect: boolean;
     status: WebSocketStatus;
-    failedConnectionAttempts: number;
     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;
@@ -71,14 +140,12 @@ export declare class HocuspocusProvider extends EventEmitter {
     get synced(): boolean;
     set synced(state: boolean);
     get isAuthenticationRequired(): boolean;
-    connect(): void;
     disconnect(): void;
-    createWebSocketConnection(): void;
     onOpen(event: OpenEvent): void;
-    getToken(): Promise<string>;
+    getToken(): Promise<string | null>;
     webSocketConnectionEstablished(): Promise<void>;
     startSync(): void;
-    send(Message: OutgoingMessage, args: any, broadcast?: boolean): void;
+    send(Message: ConstructableOutgoingMessage, args: any, broadcast?: boolean): void;
     onMessage(event: MessageEvent): void;
     onClose(event: CloseEvent): void;
     destroy(): void;
@@ -86,7 +153,6 @@ export declare class HocuspocusProvider extends EventEmitter {
     broadcastChannelSubscriber(data: ArrayBuffer): void;
     subscribeToBroadcastChannel(): void;
     disconnectBroadcastChannel(): void;
-    broadcast(Message: OutgoingMessage, args: any): void;
-    log(message: string): void;
+    broadcast(Message: ConstructableOutgoingMessage, args?: any): void;
     setAwarenessField(key: string, value: any): void;
 }

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

@@ -1,15 +1,9 @@
 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';
-import { Constructable } from './types';
+import { ConstructableOutgoingMessage } from './types';
 export declare class MessageSender {
     encoder: Encoder;
     message: any;
-    constructor(Message: Constructable<AuthenticationMessage> | 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/types.d.ts

@@ -1,6 +1,12 @@
 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,
@@ -25,3 +31,4 @@ export interface OutgoingMessageArguments {
 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/server/src/Connection.d.ts

@@ -40,9 +40,10 @@ declare class Connection {
      */
     private check;
     /**
-     * Send first sync step
+     * Send the current document awareness to the client, if any
      * @private
      */
+    private sendCurrentAwareness;
     /**
      * Handle an incoming message
      * @private

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

@@ -43,9 +43,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

@@ -25,6 +25,14 @@ export declare class Hocuspocus {
      * 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
      */

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

@@ -77,6 +77,7 @@ export interface onCreateDocumentPayload {
     context: any;
     document: Document;
     documentName: string;
+    instance: Hocuspocus;
     requestHeaders: IncomingHttpHeaders;
     requestParameters: URLSearchParams;
     socketId: string;
@@ -87,6 +88,7 @@ export interface onChangePayload {
     context: any;
     document: Document;
     documentName: string;
+    instance: Hocuspocus;
     requestHeaders: IncomingHttpHeaders;
     requestParameters: URLSearchParams;
     update: Uint8Array;
@@ -97,6 +99,7 @@ export interface onDisconnectPayload {
     context: any;
     document: Document;
     documentName: string;
+    instance: Hocuspocus;
     requestHeaders: IncomingHttpHeaders;
     requestParameters: URLSearchParams;
     socketId: string;
@@ -116,6 +119,7 @@ export interface onListenPayload {
     port: number;
 }
 export interface onDestroyPayload {
+    instance: Hocuspocus;
 }
 export interface onConfigurePayload {
     configuration: Configuration;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hocuspocus/provider",
-  "version": "1.0.0-alpha.14",
+  "version": "1.0.0-alpha.18",
   "description": "hocuspocus provider",
   "homepage": "https://hocuspocus.dev",
   "keywords": [
@@ -23,11 +23,12 @@
     "dist"
   ],
   "dependencies": {
+    "@lifeomic/attempt": "^3.0.0",
     "lib0": "^0.2.42",
     "y-protocols": "^1.0.5",
     "yjs": "^13.5.8"
   },
-  "gitHead": "3b1ae61a70eca44992e40e545b2d893a4cef75b2",
+  "gitHead": "b3f043fa2f99dd35bd68940efcb0d5b86a165585",
   "publishConfig": {
     "access": "public"
   }