@hocuspocus/extension-database 1.0.0-alpha.1 → 1.0.0-alpha.12

package/dist/hocuspocus-database.cjs

@@ -33,8 +33,8 @@ class Database {
          * Default configuration
          */
         this.configuration = {
-            fetchUpdates: async () => [],
-            storeUpdate: async () => null,
+            fetch: async () => null,
+            store: async () => null,
         };
         this.configuration = {
             ...this.configuration,
@@ -45,20 +45,20 @@ class Database {
      * Get stored data from the database.
      */
     async onLoadDocument({ document, documentName }) {
-        const updates = await this.configuration.fetchUpdates({ documentName });
-        if (updates && updates.length) {
-            updates.forEach((update) => {
-                Y__namespace.applyUpdate(document, update);
-            });
+        const update = await this.configuration.fetch({ documentName });
+        if (update) {
+            Y__namespace.applyUpdate(document, update);
         }
         return document;
     }
     /**
      * Store new updates in the database.
      */
-    async onChange({ document, documentName }) {
-        const update = Buffer.from(Y__namespace.encodeStateAsUpdate(document));
-        return this.configuration.storeUpdate({ update, documentName });
+    async onStoreDocument(data) {
+        return this.configuration.store({
+            ...data,
+            state: Buffer.from(Y__namespace.encodeStateAsUpdate(data.document)),
+        });
     }
 }
 

package/dist/hocuspocus-database.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"hocuspocus-database.cjs","sources":["../src/Database.ts"],"sourcesContent":["import { Extension, onChangePayload, onLoadDocumentPayload } from '@hocuspocus/server'\nimport * as Y from 'yjs'\n\nexport interface DatabaseConfiguration {\n  /**\n   * Pass a Promise to retrieve updates from your database. The Promise should resolve to\n   * an array of items with Y.js-compatible binary data.\n   */\n  fetchUpdates: ({ documentName }: { documentName: string}) => Promise<Uint8Array[]>,\n  /**\n   * Pass a function to store updates in your database.\n   */\n  storeUpdate: ({ update, documentName }: { update: Buffer, documentName: string}) => void,\n}\n\nexport class Database implements Extension {\n  /**\n   * Default configuration\n   */\n  configuration: DatabaseConfiguration = {\n    fetchUpdates: async () => [],\n    storeUpdate: async () => null,\n  }\n\n  /**\n   * Constructor\n   */\n  constructor(configuration: Partial<DatabaseConfiguration>) {\n    this.configuration = {\n      ...this.configuration,\n      ...configuration,\n    }\n  }\n\n  /**\n   * Get stored data from the database.\n   */\n  async onLoadDocument({ document, documentName }: onLoadDocumentPayload): Promise<any> {\n    const updates = await this.configuration.fetchUpdates({ documentName })\n\n    if (updates && updates.length) {\n      updates.forEach((update: any) => {\n        Y.applyUpdate(document, update)\n      })\n    }\n\n    return document\n  }\n\n  /**\n   * Store new updates in the database.\n   */\n  async onChange({ document, documentName }: onChangePayload) {\n    const update = Buffer.from(\n      Y.encodeStateAsUpdate(document),\n    )\n\n    return this.configuration.storeUpdate({ update, documentName })\n  }\n}\n"],"names":["Y"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;MAea,QAAQ;;;;IAYnB,YAAY,aAA6C;;;;QARzD,kBAAa,GAA0B;YACrC,YAAY,EAAE,YAAY,EAAE;YAC5B,WAAW,EAAE,YAAY,IAAI;SAC9B,CAAA;QAMC,IAAI,CAAC,aAAa,GAAG;YACnB,GAAG,IAAI,CAAC,aAAa;YACrB,GAAG,aAAa;SACjB,CAAA;KACF;;;;IAKD,MAAM,cAAc,CAAC,EAAE,QAAQ,EAAE,YAAY,EAAyB;QACpE,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC,EAAE,YAAY,EAAE,CAAC,CAAA;QAEvE,IAAI,OAAO,IAAI,OAAO,CAAC,MAAM,EAAE;YAC7B,OAAO,CAAC,OAAO,CAAC,CAAC,MAAW;gBAC1BA,YAAC,CAAC,WAAW,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAA;aAChC,CAAC,CAAA;SACH;QAED,OAAO,QAAQ,CAAA;KAChB;;;;IAKD,MAAM,QAAQ,CAAC,EAAE,QAAQ,EAAE,YAAY,EAAmB;QACxD,MAAM,MAAM,GAAG,MAAM,CAAC,IAAI,CACxBA,YAAC,CAAC,mBAAmB,CAAC,QAAQ,CAAC,CAChC,CAAA;QAED,OAAO,IAAI,CAAC,aAAa,CAAC,WAAW,CAAC,EAAE,MAAM,EAAE,YAAY,EAAE,CAAC,CAAA;KAChE;;;;;"}
+{"version":3,"file":"hocuspocus-database.cjs","sources":["../src/Database.ts"],"sourcesContent":["import {\n  Extension, onChangePayload, onLoadDocumentPayload, storePayload,\n} from '@hocuspocus/server'\nimport * as Y from 'yjs'\n\nexport interface DatabaseConfiguration {\n  /**\n   * Pass a Promise to retrieve updates from your database. The Promise should resolve to\n   * an array of items with Y.js-compatible binary data.\n   */\n  fetch: ({ documentName }: { documentName: string}) => Promise<Uint8Array | null>,\n  /**\n   * Pass a function to store updates in your database.\n   */\n  store: (data: storePayload) => void,\n}\n\nexport class Database implements Extension {\n  /**\n   * Default configuration\n   */\n  configuration: DatabaseConfiguration = {\n    fetch: async () => null,\n    store: async () => null,\n  }\n\n  /**\n   * Constructor\n   */\n  constructor(configuration: Partial<DatabaseConfiguration>) {\n    this.configuration = {\n      ...this.configuration,\n      ...configuration,\n    }\n  }\n\n  /**\n   * Get stored data from the database.\n   */\n  async onLoadDocument({ document, documentName }: onLoadDocumentPayload): Promise<any> {\n    const update = await this.configuration.fetch({ documentName })\n\n    if (update) {\n      Y.applyUpdate(document, update)\n    }\n\n    return document\n  }\n\n  /**\n   * Store new updates in the database.\n   */\n  async onStoreDocument(data: onChangePayload) {\n    return this.configuration.store({\n      ...data,\n      state: Buffer.from(\n        Y.encodeStateAsUpdate(data.document),\n      ),\n    })\n  }\n}\n"],"names":["Y"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;MAiBa,QAAQ,CAAA;AASnB;;AAEG;AACH,IAAA,WAAA,CAAY,aAA6C,EAAA;AAXzD;;AAEG;AACH,QAAA,IAAA,CAAA,aAAa,GAA0B;AACrC,YAAA,KAAK,EAAE,YAAY,IAAI;AACvB,YAAA,KAAK,EAAE,YAAY,IAAI;SACxB,CAAA;QAMC,IAAI,CAAC,aAAa,GAAG;YACnB,GAAG,IAAI,CAAC,aAAa;AACrB,YAAA,GAAG,aAAa;SACjB,CAAA;KACF;AAED;;AAEG;AACH,IAAA,MAAM,cAAc,CAAC,EAAE,QAAQ,EAAE,YAAY,EAAyB,EAAA;AACpE,QAAA,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,EAAE,YAAY,EAAE,CAAC,CAAA;AAE/D,QAAA,IAAI,MAAM,EAAE;AACV,YAAAA,YAAC,CAAC,WAAW,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAA;AAChC,SAAA;AAED,QAAA,OAAO,QAAQ,CAAA;KAChB;AAED;;AAEG;IACH,MAAM,eAAe,CAAC,IAAqB,EAAA;AACzC,QAAA,OAAO,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC;AAC9B,YAAA,GAAG,IAAI;AACP,YAAA,KAAK,EAAE,MAAM,CAAC,IAAI,CAChBA,YAAC,CAAC,mBAAmB,CAAC,IAAI,CAAC,QAAQ,CAAC,CACrC;AACF,SAAA,CAAC,CAAA;KACH;AACF;;;;"}

package/dist/hocuspocus-database.esm.js

@@ -9,8 +9,8 @@ class Database {
          * Default configuration
          */
         this.configuration = {
-            fetchUpdates: async () => [],
-            storeUpdate: async () => null,
+            fetch: async () => null,
+            store: async () => null,
         };
         this.configuration = {
             ...this.configuration,
@@ -21,20 +21,20 @@ class Database {
      * Get stored data from the database.
      */
     async onLoadDocument({ document, documentName }) {
-        const updates = await this.configuration.fetchUpdates({ documentName });
-        if (updates && updates.length) {
-            updates.forEach((update) => {
-                Y.applyUpdate(document, update);
-            });
+        const update = await this.configuration.fetch({ documentName });
+        if (update) {
+            Y.applyUpdate(document, update);
         }
         return document;
     }
     /**
      * Store new updates in the database.
      */
-    async onChange({ document, documentName }) {
-        const update = Buffer.from(Y.encodeStateAsUpdate(document));
-        return this.configuration.storeUpdate({ update, documentName });
+    async onStoreDocument(data) {
+        return this.configuration.store({
+            ...data,
+            state: Buffer.from(Y.encodeStateAsUpdate(data.document)),
+        });
     }
 }
 

package/dist/hocuspocus-database.esm.js.map

@@ -1 +1 @@
-{"version":3,"file":"hocuspocus-database.esm.js","sources":["../src/Database.ts"],"sourcesContent":["import { Extension, onChangePayload, onLoadDocumentPayload } from '@hocuspocus/server'\nimport * as Y from 'yjs'\n\nexport interface DatabaseConfiguration {\n  /**\n   * Pass a Promise to retrieve updates from your database. The Promise should resolve to\n   * an array of items with Y.js-compatible binary data.\n   */\n  fetchUpdates: ({ documentName }: { documentName: string}) => Promise<Uint8Array[]>,\n  /**\n   * Pass a function to store updates in your database.\n   */\n  storeUpdate: ({ update, documentName }: { update: Buffer, documentName: string}) => void,\n}\n\nexport class Database implements Extension {\n  /**\n   * Default configuration\n   */\n  configuration: DatabaseConfiguration = {\n    fetchUpdates: async () => [],\n    storeUpdate: async () => null,\n  }\n\n  /**\n   * Constructor\n   */\n  constructor(configuration: Partial<DatabaseConfiguration>) {\n    this.configuration = {\n      ...this.configuration,\n      ...configuration,\n    }\n  }\n\n  /**\n   * Get stored data from the database.\n   */\n  async onLoadDocument({ document, documentName }: onLoadDocumentPayload): Promise<any> {\n    const updates = await this.configuration.fetchUpdates({ documentName })\n\n    if (updates && updates.length) {\n      updates.forEach((update: any) => {\n        Y.applyUpdate(document, update)\n      })\n    }\n\n    return document\n  }\n\n  /**\n   * Store new updates in the database.\n   */\n  async onChange({ document, documentName }: onChangePayload) {\n    const update = Buffer.from(\n      Y.encodeStateAsUpdate(document),\n    )\n\n    return this.configuration.storeUpdate({ update, documentName })\n  }\n}\n"],"names":[],"mappings":";;MAea,QAAQ;;;;IAYnB,YAAY,aAA6C;;;;QARzD,kBAAa,GAA0B;YACrC,YAAY,EAAE,YAAY,EAAE;YAC5B,WAAW,EAAE,YAAY,IAAI;SAC9B,CAAA;QAMC,IAAI,CAAC,aAAa,GAAG;YACnB,GAAG,IAAI,CAAC,aAAa;YACrB,GAAG,aAAa;SACjB,CAAA;KACF;;;;IAKD,MAAM,cAAc,CAAC,EAAE,QAAQ,EAAE,YAAY,EAAyB;QACpE,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC,EAAE,YAAY,EAAE,CAAC,CAAA;QAEvE,IAAI,OAAO,IAAI,OAAO,CAAC,MAAM,EAAE;YAC7B,OAAO,CAAC,OAAO,CAAC,CAAC,MAAW;gBAC1B,CAAC,CAAC,WAAW,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAA;aAChC,CAAC,CAAA;SACH;QAED,OAAO,QAAQ,CAAA;KAChB;;;;IAKD,MAAM,QAAQ,CAAC,EAAE,QAAQ,EAAE,YAAY,EAAmB;QACxD,MAAM,MAAM,GAAG,MAAM,CAAC,IAAI,CACxB,CAAC,CAAC,mBAAmB,CAAC,QAAQ,CAAC,CAChC,CAAA;QAED,OAAO,IAAI,CAAC,aAAa,CAAC,WAAW,CAAC,EAAE,MAAM,EAAE,YAAY,EAAE,CAAC,CAAA;KAChE;;;;;"}
+{"version":3,"file":"hocuspocus-database.esm.js","sources":["../src/Database.ts"],"sourcesContent":["import {\n  Extension, onChangePayload, onLoadDocumentPayload, storePayload,\n} from '@hocuspocus/server'\nimport * as Y from 'yjs'\n\nexport interface DatabaseConfiguration {\n  /**\n   * Pass a Promise to retrieve updates from your database. The Promise should resolve to\n   * an array of items with Y.js-compatible binary data.\n   */\n  fetch: ({ documentName }: { documentName: string}) => Promise<Uint8Array | null>,\n  /**\n   * Pass a function to store updates in your database.\n   */\n  store: (data: storePayload) => void,\n}\n\nexport class Database implements Extension {\n  /**\n   * Default configuration\n   */\n  configuration: DatabaseConfiguration = {\n    fetch: async () => null,\n    store: async () => null,\n  }\n\n  /**\n   * Constructor\n   */\n  constructor(configuration: Partial<DatabaseConfiguration>) {\n    this.configuration = {\n      ...this.configuration,\n      ...configuration,\n    }\n  }\n\n  /**\n   * Get stored data from the database.\n   */\n  async onLoadDocument({ document, documentName }: onLoadDocumentPayload): Promise<any> {\n    const update = await this.configuration.fetch({ documentName })\n\n    if (update) {\n      Y.applyUpdate(document, update)\n    }\n\n    return document\n  }\n\n  /**\n   * Store new updates in the database.\n   */\n  async onStoreDocument(data: onChangePayload) {\n    return this.configuration.store({\n      ...data,\n      state: Buffer.from(\n        Y.encodeStateAsUpdate(data.document),\n      ),\n    })\n  }\n}\n"],"names":[],"mappings":";;MAiBa,QAAQ,CAAA;AASnB;;AAEG;AACH,IAAA,WAAA,CAAY,aAA6C,EAAA;AAXzD;;AAEG;AACH,QAAA,IAAA,CAAA,aAAa,GAA0B;AACrC,YAAA,KAAK,EAAE,YAAY,IAAI;AACvB,YAAA,KAAK,EAAE,YAAY,IAAI;SACxB,CAAA;QAMC,IAAI,CAAC,aAAa,GAAG;YACnB,GAAG,IAAI,CAAC,aAAa;AACrB,YAAA,GAAG,aAAa;SACjB,CAAA;KACF;AAED;;AAEG;AACH,IAAA,MAAM,cAAc,CAAC,EAAE,QAAQ,EAAE,YAAY,EAAyB,EAAA;AACpE,QAAA,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,EAAE,YAAY,EAAE,CAAC,CAAA;AAE/D,QAAA,IAAI,MAAM,EAAE;AACV,YAAA,CAAC,CAAC,WAAW,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAA;AAChC,SAAA;AAED,QAAA,OAAO,QAAQ,CAAA;KAChB;AAED;;AAEG;IACH,MAAM,eAAe,CAAC,IAAqB,EAAA;AACzC,QAAA,OAAO,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC;AAC9B,YAAA,GAAG,IAAI;AACP,YAAA,KAAK,EAAE,MAAM,CAAC,IAAI,CAChB,CAAC,CAAC,mBAAmB,CAAC,IAAI,CAAC,QAAQ,CAAC,CACrC;AACF,SAAA,CAAC,CAAA;KACH;AACF;;;;"}

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

@@ -0,0 +1,23 @@
+export interface CloseEvent {
+    code: number;
+    reason: string;
+}
+/**
+ * The server successfully processed the request, asks that the requester reset
+ * its document view, and is not returning any content.
+ */
+export declare const ResetConnection: CloseEvent;
+/**
+ * Similar to Forbidden, but specifically for use when authentication is required and has
+ * failed or has not yet been provided.
+ */
+export declare const Unauthorized: CloseEvent;
+/**
+ * The request contained valid data and was understood by the server, but the server
+ * is refusing action.
+ */
+export declare const Forbidden: CloseEvent;
+/**
+ * The server timed out waiting for the request.
+ */
+export declare const ConnectionTimeout: CloseEvent;

package/dist/packages/common/src/awarenessStatesToArray.d.ts

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

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

@@ -1 +1,4 @@
 export * from './auth';
+export * from './CloseEvents';
+export * from './awarenessStatesToArray';
+export * from './types';

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

@@ -0,0 +1,10 @@
+/**
+ * State of the WebSocket connection.
+ * https://developer.mozilla.org/de/docs/Web/API/WebSocket/readyState
+ */
+export declare enum WsReadyStates {
+    Connecting = 0,
+    Open = 1,
+    Closing = 2,
+    Closed = 3
+}

package/dist/packages/extension-database/src/Database.d.ts

@@ -1,20 +1,16 @@
-/// <reference types="node" />
-import { Extension, onChangePayload, onLoadDocumentPayload } from '@hocuspocus/server';
+import { Extension, onChangePayload, onLoadDocumentPayload, storePayload } from '@hocuspocus/server';
 export interface DatabaseConfiguration {
     /**
      * Pass a Promise to retrieve updates from your database. The Promise should resolve to
      * an array of items with Y.js-compatible binary data.
      */
-    fetchUpdates: ({ documentName }: {
+    fetch: ({ documentName }: {
         documentName: string;
-    }) => Promise<Uint8Array[]>;
+    }) => Promise<Uint8Array | null>;
     /**
      * Pass a function to store updates in your database.
      */
-    storeUpdate: ({ update, documentName }: {
-        update: Buffer;
-        documentName: string;
-    }) => void;
+    store: (data: storePayload) => void;
 }
 export declare class Database implements Extension {
     /**
@@ -32,5 +28,5 @@ export declare class Database implements Extension {
     /**
      * Store new updates in the database.
      */
-    onChange({ document, documentName }: onChangePayload): Promise<void>;
+    onStoreDocument(data: onChangePayload): Promise<void>;
 }

package/dist/packages/extension-logger/src/Logger.d.ts

@@ -14,6 +14,10 @@ export interface LoggerConfiguration {
      * Whether to log something for the `onChange` hook.
      */
     onChange: boolean;
+    /**
+     * Whether to log something for the `onStoreDocument` hook.
+     */
+    onStoreDocument: boolean;
     /**
      * Whether to log something for the `onConnect` hook.
      */
@@ -53,6 +57,7 @@ export declare class Logger implements Extension {
     onConfigure(data: onConfigurePayload): Promise<void>;
     onLoadDocument(data: onLoadDocumentPayload): Promise<void>;
     onChange(data: onChangePayload): Promise<void>;
+    onStoreDocument(data: onDisconnectPayload): Promise<void>;
     onConnect(data: onConnectPayload): Promise<void>;
     onDisconnect(data: onDisconnectPayload): Promise<void>;
     onUpgrade(data: onUpgradePayload): Promise<void>;

package/dist/packages/extension-monitor/src/Collector.d.ts

@@ -3,7 +3,6 @@ import { Configuration, onConnectPayload, onDisconnectPayload, onLoadDocumentPay
 export declare class Collector {
     serverConfiguration: Partial<Configuration>;
     version: string;
-    yjsVersion: string;
     connections: {};
     messages: {};
     messageCounter: number;
@@ -56,7 +55,6 @@ export declare class Collector {
         platform: NodeJS.Platform;
         started: string;
         version: string;
-        yjsVersion: string;
     }>;
     private static readableYDoc;
 }

package/dist/packages/extension-monitor/src/index.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { Extension, onChangePayload, onConfigurePayload, onConnectPayload, onLoadDocumentPayload, onDisconnectPayload, onRequestPayload, onUpgradePayload } from '@hocuspocus/server';
+import { Extension, onChangePayload, onConfigurePayload, onLoadDocumentPayload, onDisconnectPayload, onRequestPayload, onUpgradePayload, connectedPayload } from '@hocuspocus/server';
 import { IncomingMessage, ServerResponse } from 'http';
 import WebSocket from 'ws';
 import { Storage } from './Storage';
@@ -30,7 +30,7 @@ export declare class Monitor implements Extension {
     handleConnection(websocket: WebSocket, request: IncomingMessage): void | undefined;
     onRequest({ request, response }: onRequestPayload): Promise<void>;
     onUpgrade({ request, socket, head }: onUpgradePayload): Promise<void>;
-    onConnect(data: onConnectPayload): Promise<void>;
+    connected(data: connectedPayload): Promise<void>;
     onDisconnect(data: onDisconnectPayload): Promise<void>;
     onLoadDocument(data: onLoadDocumentPayload): Promise<void>;
     onChange(data: onChangePayload): Promise<void>;

package/dist/packages/extension-sqlite/src/SQLite.d.ts

@@ -1,5 +1,8 @@
 import { Database, DatabaseConfiguration } from '@hocuspocus/extension-database';
 import sqlite3 from 'sqlite3';
+export declare const schema = "CREATE TABLE IF NOT EXISTS \"documents\" (\n  \"name\" varchar(255) NOT NULL,\n  \"data\" blob NOT NULL,\n  UNIQUE(name)\n)";
+export declare const selectQuery = "\n  SELECT data FROM \"documents\" WHERE name = $name ORDER BY rowid DESC\n";
+export declare const upsertQuery = "\n  INSERT INTO \"documents\" (\"name\", \"data\") VALUES ($name, $data)\n    ON CONFLICT(name) DO UPDATE SET data = $data\n";
 export interface SQLiteConfiguration extends DatabaseConfiguration {
     /**
      * Valid values are filenames, ":memory:" for an anonymous in-memory database and an empty
@@ -17,10 +20,7 @@ export interface SQLiteConfiguration extends DatabaseConfiguration {
 export declare class SQLite extends Database {
     db?: sqlite3.Database;
     configuration: SQLiteConfiguration;
-    /**
-     * Constructor
-     */
     constructor(configuration?: Partial<SQLiteConfiguration>);
-    onListen(): Promise<void>;
     onConfigure(): Promise<void>;
+    onListen(): Promise<void>;
 }

package/dist/packages/extension-throttle/src/index.d.ts

@@ -1,12 +1,16 @@
 import { Extension, onConnectPayload } from '@hocuspocus/server';
-export interface Configuration {
+export interface ThrottleConfiguration {
     throttle: number | null | false;
     banTime: number;
 }
 export declare class Throttle implements Extension {
-    configuration: Configuration;
+    configuration: ThrottleConfiguration;
     connectionsByIp: Map<string, Array<number>>;
     bannedIps: Map<string, number>;
+    /**
+     * Constructor
+     */
+    constructor(configuration?: Partial<ThrottleConfiguration>);
     /**
      * Throttle requests
      * @private

package/dist/packages/extension-webhook/src/index.d.ts

@@ -3,7 +3,6 @@ import { Extension, onChangePayload, onConnectPayload, onLoadDocumentPayload, on
 import { Doc } from 'yjs';
 import { Transformer } from '@hocuspocus/transformer';
 import { AxiosResponse } from 'axios';
-import Timeout = NodeJS.Timeout;
 export declare enum Events {
     onChange = "change",
     onConnect = "connect",
@@ -24,7 +23,7 @@ export interface Configuration {
 export declare class Webhook implements Extension {
     configuration: Configuration;
     debounced: Map<string, {
-        timeout: Timeout;
+        timeout: NodeJS.Timeout;
         start: number;
     }>;
     /**

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

@@ -5,5 +5,5 @@ export default class EventEmitter {
     on(event: string, fn: Function): this;
     protected emit(event: string, ...args: any): this;
     off(event: string, fn?: Function): this;
-    protected removeAllListeners(): void;
+    removeAllListeners(): void;
 }

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

@@ -1,10 +1,11 @@
-import { HocuspocusProvider, HocuspocusProviderOptions } from './HocuspocusProvider';
-export interface HocuspocusCloudProviderOptions extends HocuspocusProviderOptions {
+import { HocuspocusProvider, HocuspocusProviderConfiguration } from './HocuspocusProvider';
+export declare type HocuspocusCloudProviderConfiguration = Required<Pick<HocuspocusProviderConfiguration, 'name'>> & Partial<HocuspocusProviderConfiguration> & AdditionalHocuspocusCloudProviderConfiguration;
+export interface AdditionalHocuspocusCloudProviderConfiguration {
     /**
      * A Hocuspocus Cloud key, get one here: https://hocuspocus.cloud/
      */
     key: string;
 }
 export declare class HocuspocusCloudProvider extends HocuspocusProvider {
-    constructor(options: HocuspocusCloudProviderOptions);
+    constructor(configuration: HocuspocusCloudProviderConfiguration);
 }

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

@@ -1,16 +1,12 @@
 import * as Y from 'yjs';
 import { Awareness } from 'y-protocols/awareness';
 import * as mutex from 'lib0/mutex';
-import { Event, CloseEvent, MessageEvent } from 'ws';
+import type { 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 {
+import { ConstructableOutgoingMessage, onAuthenticationFailedParameters, onCloseParameters, onDisconnectParameters, onMessageParameters, onOpenParameters, onOutgoingMessageParameters, onStatusParameters, onSyncedParameters, WebSocketStatus } from './types';
+import { onAwarenessChangeParameters, onAwarenessUpdateParameters } from '.';
+export declare type HocuspocusProviderConfiguration = Required<Pick<CompleteHocuspocusProviderConfiguration, 'url' | 'name'>> & Partial<CompleteHocuspocusProviderConfiguration>;
+export interface CompleteHocuspocusProviderConfiguration {
     /**
      * URL of your @hocuspocus/server instance
      */
@@ -90,23 +86,25 @@ export interface HocuspocusProviderOptions {
      */
     timeout: number;
     onAuthenticated: () => void;
-    onAuthenticationFailed: ({ reason }: {
-        reason: string;
-    }) => void;
-    onOpen: (event: Event) => void;
+    onAuthenticationFailed: (data: onAuthenticationFailedParameters) => void;
+    onOpen: (data: onOpenParameters) => 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;
+    onMessage: (data: onMessageParameters) => void;
+    onOutgoingMessage: (data: onOutgoingMessageParameters) => void;
+    onStatus: (data: onStatusParameters) => void;
+    onSynced: (data: onSyncedParameters) => void;
+    onDisconnect: (data: onDisconnectParameters) => void;
+    onClose: (data: onCloseParameters) => void;
     onDestroy: () => void;
-    onAwarenessUpdate: (states: any) => void;
-    onAwarenessChange: (states: any) => void;
+    onAwarenessUpdate: (data: onAwarenessUpdateParameters) => void;
+    onAwarenessChange: (data: onAwarenessChangeParameters) => void;
+    /**
+     * Don’t output any warnings.
+     */
+    quiet: boolean;
 }
 export declare class HocuspocusProvider extends EventEmitter {
-    options: HocuspocusProviderOptions;
+    configuration: CompleteHocuspocusProviderConfiguration;
     subscribedToBroadcastChannel: boolean;
     webSocket: WebSocket | null;
     shouldConnect: boolean;
@@ -120,11 +118,12 @@ export declare class HocuspocusProvider extends EventEmitter {
         resolve: (value?: any) => void;
         reject: (reason?: any) => void;
     } | null;
-    constructor(options?: Partial<HocuspocusProviderOptions>);
-    setOptions(options?: Partial<HocuspocusProviderOptions>): void;
+    constructor(configuration: HocuspocusProviderConfiguration);
+    setConfiguration(configuration?: Partial<HocuspocusProviderConfiguration>): void;
     connect(): Promise<void>;
     createWebSocketConnection(): Promise<unknown>;
     resolveConnectionAttempt(): void;
+    stopConnectionAttempt(): void;
     rejectConnectionAttempt(): void;
     get document(): Y.Doc;
     get awareness(): Awareness;
@@ -141,9 +140,8 @@ export declare class HocuspocusProvider extends EventEmitter {
     set synced(state: boolean);
     get isAuthenticationRequired(): boolean;
     disconnect(): void;
-    onOpen(event: Event): void;
+    onOpen(event: Event): Promise<void>;
     getToken(): Promise<string | null>;
-    webSocketConnectionEstablished(): Promise<void>;
     startSync(): void;
     send(Message: ConstructableOutgoingMessage, args: any, broadcast?: boolean): void;
     onMessage(event: MessageEvent): void;

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

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

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

@@ -1,18 +1,26 @@
 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
 }
+export declare enum WebSocketStatus {
+    Connecting = "connecting",
+    Connected = "connected",
+    Disconnected = "disconnected"
+}
 export interface OutgoingMessageInterface {
     encoder: Encoder;
     type?: MessageType;
@@ -32,3 +40,38 @@ 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,10 +2,10 @@
 import AsyncLock from 'async-lock';
 import WebSocket from 'ws';
 import { IncomingMessage as HTTPIncomingMessage } from 'http';
+import { CloseEvent } from '@hocuspocus/common';
 import Document from './Document';
-import { CloseEvent } from './types';
-import { MessageLogger } from './Debugger';
-declare class Connection {
+import { Debugger } from './Debugger';
+export declare class Connection {
     webSocket: WebSocket;
     context: any;
     document: Document;
@@ -17,11 +17,11 @@ declare class Connection {
     socketId: string;
     lock: AsyncLock;
     readOnly: Boolean;
-    debugger: MessageLogger;
+    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
      */

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

@@ -1,4 +1,4 @@
-export declare class MessageLogger {
+export declare class Debugger {
     logs: any[];
     listen: boolean;
     output: boolean;
@@ -12,4 +12,3 @@ export declare class MessageLogger {
         logs: any[];
     };
 }
-export declare const Debugger: MessageLogger;

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

@@ -3,20 +3,23 @@ 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 {
+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;
-    debugger: MessageLogger;
+    logger: Debugger;
     /**
      * Constructor.
      */
-    constructor(name: string);
+    constructor(name: string, logger: Debugger);
     /**
      * Check if the Document is empty
      */