@hocuspocus/extension-throttle 2.2.3 → 2.3.1

package/dist/packages/extension-redis/src/Redis.d.ts

@@ -69,7 +69,7 @@ export declare class Redis implements Extension {
     private subKey;
     private lockKey;
     /**
-     * Once a document is laoded, subscribe to the channel in Redis.
+     * Once a document is loaded, subscribe to the channel in Redis.
      */
     afterLoadDocument({ documentName, document }: afterLoadDocumentPayload): Promise<unknown>;
     /**

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

@@ -1,15 +1,15 @@
-import * as Y from 'yjs';
-import { Awareness } from 'y-protocols/awareness';
 import * as mutex from 'lib0/mutex';
 import type { CloseEvent, Event, MessageEvent } from 'ws';
+import { Awareness } from 'y-protocols/awareness';
+import * as Y from 'yjs';
 import EventEmitter from './EventEmitter.js';
-import { ConstructableOutgoingMessage, onAuthenticationFailedParameters, onCloseParameters, onDisconnectParameters, onMessageParameters, onOpenParameters, onOutgoingMessageParameters, onStatelessParameters, onStatusParameters, onSyncedParameters, WebSocketStatus, onAwarenessChangeParameters, onAwarenessUpdateParameters } from './types.js';
 import { CompleteHocuspocusProviderWebsocketConfiguration, HocuspocusProviderWebsocket } from './HocuspocusProviderWebsocket.js';
+import { ConstructableOutgoingMessage, WebSocketStatus, onAuthenticationFailedParameters, onAwarenessChangeParameters, onAwarenessUpdateParameters, onCloseParameters, onDisconnectParameters, onMessageParameters, onOpenParameters, onOutgoingMessageParameters, onStatelessParameters, onStatusParameters, onSyncedParameters } from './types.js';
 export type HocuspocusProviderConfiguration = Required<Pick<CompleteHocuspocusProviderConfiguration, 'name'>> & Partial<CompleteHocuspocusProviderConfiguration> & (Required<Pick<CompleteHocuspocusProviderWebsocketConfiguration, 'url'>> | Required<Pick<CompleteHocuspocusProviderConfiguration, 'websocketProvider'>>);
 export interface CompleteHocuspocusProviderConfiguration {
     /**
-     * The identifier/name of your document
-     */
+    * The identifier/name of your document
+    */
     name: string;
     /**
      * The actual Y.js document
@@ -59,6 +59,14 @@ export interface CompleteHocuspocusProviderConfiguration {
      * Don’t output any warnings.
      */
     quiet: boolean;
+    /**
+     * Pass `false` to start the connection manually.
+     */
+    connect: boolean;
+    /**
+     * Pass `false` to close the connection manually.
+     */
+    preserveConnection: boolean;
 }
 export declare class HocuspocusProvider extends EventEmitter {
     configuration: CompleteHocuspocusProviderConfiguration;
@@ -73,7 +81,7 @@ export declare class HocuspocusProvider extends EventEmitter {
     isConnected: boolean;
     constructor(configuration: HocuspocusProviderConfiguration);
     boundBroadcastChannelSubscriber: (data: ArrayBuffer) => void;
-    boundBeforeUnload: () => void;
+    boundPageUnload: () => void;
     boundOnOpen: (event: Event) => Promise<void>;
     boundOnMessage: (event: MessageEvent) => void;
     boundOnClose: (event: CloseEvent) => void;
@@ -88,13 +96,20 @@ export declare class HocuspocusProvider extends EventEmitter {
     get document(): Y.Doc;
     get awareness(): Awareness;
     get hasUnsyncedChanges(): boolean;
-    updateUnsyncedChanges(unsyncedChanges?: number): void;
+    incrementUnsyncedChanges(): void;
+    decrementUnsyncedChanges(): void;
     forceSync(): void;
-    beforeUnload(): void;
+    pageUnload(): void;
     registerEventListeners(): void;
     sendStateless(payload: string): void;
     documentUpdateHandler(update: Uint8Array, origin: any): void;
     awarenessUpdateHandler({ added, updated, removed }: any, origin: any): void;
+    /**
+     * Indicates whether a first handshake with the server has been established
+     *
+     * Note: this does not mean all updates from the client have been persisted to the backend. For this,
+     * use `hasUnsyncedChanges`.
+     */
     get synced(): boolean;
     set synced(state: boolean);
     receiveStateless(payload: string): void;

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

@@ -2,8 +2,8 @@ import * as mutex from 'lib0/mutex';
 import type { MessageEvent } from 'ws';
 import { Event } from 'ws';
 import EventEmitter from './EventEmitter.js';
-import { onCloseParameters, onDisconnectParameters, onMessageParameters, onOpenParameters, onOutgoingMessageParameters, onStatusParameters, WebSocketStatus, onAwarenessChangeParameters, onAwarenessUpdateParameters } from './types.js';
 import { HocuspocusProvider } from './HocuspocusProvider.js';
+import { WebSocketStatus, onAwarenessChangeParameters, onAwarenessUpdateParameters, onCloseParameters, onDisconnectParameters, onMessageParameters, onOpenParameters, onOutgoingMessageParameters, onStatusParameters } from './types.js';
 export type HocuspocusProviderWebsocketConfiguration = Required<Pick<CompleteHocuspocusProviderWebsocketConfiguration, 'url'>> & Partial<CompleteHocuspocusProviderWebsocketConfiguration>;
 export interface CompleteHocuspocusProviderWebsocketConfiguration {
     /**
@@ -76,6 +76,7 @@ export interface CompleteHocuspocusProviderWebsocketConfiguration {
     quiet: boolean;
 }
 export declare class HocuspocusProviderWebsocket extends EventEmitter {
+    private messageQueue;
     configuration: CompleteHocuspocusProviderWebsocketConfiguration;
     subscribedToBroadcastChannel: boolean;
     webSocket: WebSocket | null;
@@ -104,6 +105,7 @@ export declare class HocuspocusProviderWebsocket extends EventEmitter {
     resolveConnectionAttempt(): void;
     stopConnectionAttempt(): void;
     rejectConnectionAttempt(): void;
+    closeTries: number;
     checkConnection(): void;
     registerEventListeners(): void;
     get serverUrl(): string;

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

@@ -5,8 +5,9 @@ export declare class MessageReceiver {
     broadcasted: boolean;
     constructor(message: IncomingMessage);
     setBroadcasted(value: boolean): this;
-    apply(provider: HocuspocusProvider, emitSynced?: boolean): void;
+    apply(provider: HocuspocusProvider, emitSynced: boolean): void;
     private applySyncMessage;
+    applySyncStatusMessage(provider: HocuspocusProvider, applied: boolean): void;
     private applyAwarenessMessage;
     private applyAuthMessage;
     private applyQueryAwarenessMessage;

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

@@ -23,6 +23,6 @@ export declare class TiptapCollabProvider extends HocuspocusProvider {
     watchVersions(callback: Parameters<AbstractType<YArrayEvent<AuditHistoryVersion>>['observe']>[0]): void;
     unwatchVersions(callback: Parameters<AbstractType<YArrayEvent<AuditHistoryVersion>>['unobserve']>[0]): void;
     isAutoVersioning(): boolean;
-    enableAutoVersioning(): number;
-    disableAutoVersioning(): number;
+    enableAutoVersioning(): 1;
+    disableAutoVersioning(): 0;
 }

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

@@ -1,7 +1,8 @@
 import { Encoder } from 'lib0/encoding';
-import type { CloseEvent, Event, MessageEvent } from 'ws';
+import type { Event, MessageEvent } from 'ws';
 import { Awareness } from 'y-protocols/awareness';
 import * as Y from 'yjs';
+import { CloseEvent } from '@hocuspocus/common';
 import { IncomingMessage } from './IncomingMessage.js';
 import { OutgoingMessage } from './OutgoingMessage.js';
 import { AuthenticationMessage } from './OutgoingMessages/AuthenticationMessage.js';

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

@@ -5,7 +5,7 @@ import WebSocket, { AddressInfo, WebSocketServer } from 'ws';
 import { Debugger } from './Debugger.js';
 import { DirectConnection } from './DirectConnection.js';
 import Document from './Document.js';
-import { Configuration, ConnectionConfiguration, HookName, HookPayload, onListenPayload, onStoreDocumentPayload } from './types.js';
+import { Configuration, ConnectionConfiguration, HookName, HookPayloadByName, onListenPayload, onStoreDocumentPayload } from './types.js';
 export declare const defaultConfiguration: {
     name: null;
     port: number;
@@ -91,7 +91,8 @@ export declare class Hocuspocus {
      * Run the given hook on all configured extensions.
      * Runs the given callback after each hook.
      */
-    hooks(name: HookName, payload: HookPayload, callback?: Function | null): Promise<any>;
+    hooks<T extends HookName>(name: T, payload: HookPayloadByName[T], callback?: Function | null): Promise<any>;
+    unloadDocument(document: Document): void;
     enableDebugging(): void;
     enableMessageLogging(): void;
     disableLogging(): void;

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

@@ -1,7 +1,7 @@
 import Connection from './Connection.js';
-import { IncomingMessage } from './IncomingMessage.js';
 import { Debugger } from './Debugger.js';
 import Document from './Document.js';
+import { IncomingMessage } from './IncomingMessage.js';
 export declare class MessageReceiver {
     message: IncomingMessage;
     logger: Debugger;

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

@@ -16,5 +16,6 @@ export declare class OutgoingMessage {
     writeUpdate(update: Uint8Array): OutgoingMessage;
     writeStateless(payload: string): OutgoingMessage;
     writeBroadcastStateless(payload: string): OutgoingMessage;
+    writeSyncStatus(updateSaved: boolean): OutgoingMessage;
     toUint8Array(): Uint8Array;
 }

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

@@ -4,9 +4,9 @@
 import { IncomingHttpHeaders, IncomingMessage, ServerResponse } from 'http';
 import { URLSearchParams } from 'url';
 import { Awareness } from 'y-protocols/awareness';
+import Connection from './Connection.js';
 import Document from './Document.js';
 import { Hocuspocus } from './Hocuspocus.js';
-import Connection from './Connection.js';
 export declare enum MessageType {
     Unknown = -1,
     Sync = 0,
@@ -16,7 +16,8 @@ export declare enum MessageType {
     SyncReply = 4,
     Stateless = 5,
     BroadcastStateless = 6,
-    CLOSE = 7
+    CLOSE = 7,
+    SyncStatus = 8
 }
 export interface AwarenessUpdate {
     added: Array<any>;
@@ -47,10 +48,31 @@ export interface Extension {
     onAwarenessUpdate?(data: onAwarenessUpdatePayload): Promise<any>;
     onRequest?(data: onRequestPayload): Promise<any>;
     onDisconnect?(data: onDisconnectPayload): Promise<any>;
+    afterUnloadDocument?(data: onLoadDocumentPayload): Promise<any>;
     onDestroy?(data: onDestroyPayload): Promise<any>;
 }
-export type HookName = 'onConfigure' | 'onListen' | 'onUpgrade' | 'onConnect' | 'connected' | 'onAuthenticate' | 'onLoadDocument' | 'afterLoadDocument' | 'beforeHandleMessage' | 'beforeBroadcastStateless' | 'onStateless' | 'onChange' | 'onStoreDocument' | 'afterStoreDocument' | 'onAwarenessUpdate' | 'onRequest' | 'onDisconnect' | 'onDestroy';
-export type HookPayload = onConfigurePayload | onListenPayload | onUpgradePayload | onConnectPayload | connectedPayload | onAuthenticatePayload | onLoadDocumentPayload | onStatelessPayload | beforeHandleMessagePayload | beforeBroadcastStatelessPayload | onChangePayload | onStoreDocumentPayload | afterStoreDocumentPayload | onAwarenessUpdatePayload | onRequestPayload | onDisconnectPayload | onDestroyPayload;
+export type HookName = 'onConfigure' | 'onListen' | 'onUpgrade' | 'onConnect' | 'connected' | 'onAuthenticate' | 'onLoadDocument' | 'afterLoadDocument' | 'beforeHandleMessage' | 'beforeBroadcastStateless' | 'onStateless' | 'onChange' | 'onStoreDocument' | 'afterStoreDocument' | 'onAwarenessUpdate' | 'onRequest' | 'onDisconnect' | 'afterUnloadDocument' | 'onDestroy';
+export type HookPayloadByName = {
+    onConfigure: onConfigurePayload;
+    onListen: onListenPayload;
+    onUpgrade: onUpgradePayload;
+    onConnect: onConnectPayload;
+    connected: connectedPayload;
+    onAuthenticate: onAuthenticatePayload;
+    onLoadDocument: onLoadDocumentPayload;
+    afterLoadDocument: onLoadDocumentPayload;
+    beforeHandleMessage: beforeHandleMessagePayload;
+    beforeBroadcastStateless: beforeBroadcastStatelessPayload;
+    onStateless: onStatelessPayload;
+    onChange: onChangePayload;
+    onStoreDocument: onStoreDocumentPayload;
+    afterStoreDocument: afterStoreDocumentPayload;
+    onAwarenessUpdate: onAwarenessUpdatePayload;
+    onRequest: onRequestPayload;
+    onDisconnect: onDisconnectPayload;
+    afterUnloadDocument: afterUnloadDocumentPayload;
+    onDestroy: onDestroyPayload;
+};
 export interface Configuration extends Extension {
     /**
      * A name for the instance, used for logging.
@@ -198,14 +220,12 @@ export interface onStoreDocumentPayload {
 export interface afterStoreDocumentPayload extends onStoreDocumentPayload {
 }
 export interface onAwarenessUpdatePayload {
-    clientsCount: number;
     context: any;
     document: Document;
     documentName: string;
     instance: Hocuspocus;
     requestHeaders: IncomingHttpHeaders;
     requestParameters: URLSearchParams;
-    update: Uint8Array;
     socketId: string;
     added: number[];
     updated: number[];
@@ -264,6 +284,10 @@ export interface onConfigurePayload {
     configuration: Configuration;
     version: string;
 }
+export interface afterUnloadDocumentPayload {
+    instance: Hocuspocus;
+    documentName: string;
+}
 export interface DirectConnection {
     transact(transaction: (document: Document) => void): Promise<void>;
     disconnect(): void;

package/dist/tests/provider/hasUnsyncedChanges.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/server/afterUnloadDocument.d.ts

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hocuspocus/extension-throttle",
-  "version": "2.2.3",
+  "version": "2.3.1",
   "description": "hocuspocus throttle extension",
   "homepage": "https://hocuspocus.dev",
   "keywords": [
@@ -28,7 +28,7 @@
     "dist"
   ],
   "dependencies": {
-    "@hocuspocus/server": "^2.2.3"
+    "@hocuspocus/server": "^2.3.1"
   },
   "gitHead": "b3454a4ca289a84ddfb7fa5607a2d4b8d5c37e9d"
 }