@hocuspocus/extension-throttle 2.5.0-rc.0 → 2.6.0

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

@@ -1,3 +1,4 @@
+/// <reference types="node" />
 import RedisClient, { ClusterNode, ClusterOptions, RedisOptions } from 'ioredis';
 import Redlock from 'redlock';
 import { Extension, afterLoadDocumentPayload, afterStoreDocumentPayload, onDisconnectPayload, onStoreDocumentPayload, onAwarenessUpdatePayload, onChangePayload, Debugger, onConfigurePayload, beforeBroadcastStatelessPayload, Hocuspocus } from '@hocuspocus/server';
@@ -56,18 +57,22 @@ export declare class Redis implements Extension {
      */
     priority: number;
     configuration: Configuration;
+    redisTransactionOrigin: string;
     pub: RedisInstance;
     sub: RedisInstance;
     instance: Hocuspocus;
     redlock: Redlock;
     locks: Map<string, Redlock.Lock>;
     logger: Debugger;
+    messagePrefix: Buffer;
     constructor(configuration: Partial<Configuration>);
     onConfigure({ instance }: onConfigurePayload): Promise<void>;
     private getKey;
     private pubKey;
     private subKey;
     private lockKey;
+    private encodeMessage;
+    private decodeMessage;
     /**
      * Once a document is loaded, subscribe to the channel in Redis.
      */
@@ -94,7 +99,7 @@ export declare class Redis implements Extension {
      */
     onAwarenessUpdate({ documentName, awareness, added, updated, removed, }: onAwarenessUpdatePayload): Promise<number>;
     /**
-     * Handle incoming messages published on all subscribed document channels.
+     * Handle incoming messages published on subscribed document channels.
      * Note that this will also include messages from ourselves as it is not possible
      * in Redis to filter these.
     */

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

@@ -4,6 +4,9 @@ import { Event } from 'ws';
 import EventEmitter from './EventEmitter.js';
 import { HocuspocusProvider } from './HocuspocusProvider.js';
 import { WebSocketStatus, onAwarenessChangeParameters, onAwarenessUpdateParameters, onCloseParameters, onDisconnectParameters, onMessageParameters, onOpenParameters, onOutgoingMessageParameters, onStatusParameters } from './types.js';
+export type HocusPocusWebSocket = WebSocket & {
+    identifier: string;
+};
 export type HocuspocusProviderWebsocketConfiguration = Required<Pick<CompleteHocuspocusProviderWebsocketConfiguration, 'url'>> & Partial<CompleteHocuspocusProviderWebsocketConfiguration>;
 export interface CompleteHocuspocusProviderWebsocketConfiguration {
     /**
@@ -79,10 +82,14 @@ export declare class HocuspocusProviderWebsocket extends EventEmitter {
     private messageQueue;
     configuration: CompleteHocuspocusProviderWebsocketConfiguration;
     subscribedToBroadcastChannel: boolean;
-    webSocket: WebSocket | null;
+    webSocket: HocusPocusWebSocket | null;
+    webSocketHandlers: {
+        [key: string]: any;
+    };
     shouldConnect: boolean;
     status: WebSocketStatus;
     lastMessageReceived: number;
+    identifier: number;
     mux: mutex.mutex;
     intervals: any;
     connectionAttempt: {
@@ -100,6 +107,8 @@ export declare class HocuspocusProviderWebsocket extends EventEmitter {
     boundConnect: () => Promise<unknown>;
     cancelWebsocketRetry?: () => void;
     connect(): Promise<unknown>;
+    attachWebSocketListeners(ws: HocusPocusWebSocket, reject: Function): void;
+    cleanupWebSocket(): void;
     createWebSocketConnection(): Promise<unknown>;
     onMessage(event: MessageEvent): void;
     resolveConnectionAttempt(): void;
@@ -107,7 +116,6 @@ export declare class HocuspocusProviderWebsocket extends EventEmitter {
     rejectConnectionAttempt(): void;
     closeTries: number;
     checkConnection(): void;
-    registerEventListeners(): void;
     get serverUrl(): string;
     get url(): string;
     disconnect(): void;

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

@@ -1,6 +1,7 @@
 import type { AbstractType, YArrayEvent } from 'yjs';
 import { HocuspocusProvider, HocuspocusProviderConfiguration } from './HocuspocusProvider.js';
 import { TiptapCollabProviderWebsocket } from './TiptapCollabProviderWebsocket.js';
+import type { THistoryVersion } from './types';
 export type TiptapCollabProviderConfiguration = Required<Pick<HocuspocusProviderConfiguration, 'name'>> & Partial<HocuspocusProviderConfiguration> & (Required<Pick<AdditionalTiptapCollabProviderConfiguration, 'websocketProvider'>> | Required<Pick<AdditionalTiptapCollabProviderConfiguration, 'appId'>>);
 export interface AdditionalTiptapCollabProviderConfiguration {
     /**
@@ -9,19 +10,29 @@ export interface AdditionalTiptapCollabProviderConfiguration {
     appId?: string;
     websocketProvider?: TiptapCollabProviderWebsocket;
 }
-export type AuditHistoryVersion = {
-    name?: string;
-    version: number;
-    date: number;
-};
 export declare class TiptapCollabProvider extends HocuspocusProvider {
     tiptapCollabConfigurationPrefix: string;
     constructor(configuration: TiptapCollabProviderConfiguration);
+    /**
+     * note: this will only work if your server loaded @hocuspocus-pro/extension-history, or if you are on a Tiptap business plan.
+     */
     createVersion(name?: string): void;
+    /**
+     * note: this will only work if your server loaded @hocuspocus-pro/extension-history, or if you are on a Tiptap business plan.
+     */
     revertToVersion(targetVersion: number): void;
-    getVersions(): AuditHistoryVersion[];
-    watchVersions(callback: Parameters<AbstractType<YArrayEvent<AuditHistoryVersion>>['observe']>[0]): void;
-    unwatchVersions(callback: Parameters<AbstractType<YArrayEvent<AuditHistoryVersion>>['unobserve']>[0]): void;
+    /**
+     * note: this will only work if your server loaded @hocuspocus-pro/extension-history, or if you are on a Tiptap business plan.
+     *
+     * The server will reply with a stateless message (THistoryVersionPreviewEvent)
+     */
+    previewVersion(targetVersion: number): void;
+    /**
+     * note: this will only work if your server loaded @hocuspocus-pro/extension-history, or if you are on a Tiptap business plan.
+     */
+    getVersions(): THistoryVersion[];
+    watchVersions(callback: Parameters<AbstractType<YArrayEvent<THistoryVersion>>['observe']>[0]): void;
+    unwatchVersions(callback: Parameters<AbstractType<YArrayEvent<THistoryVersion>>['unobserve']>[0]): void;
     isAutoVersioning(): boolean;
     enableAutoVersioning(): 1;
     disableAutoVersioning(): 0;

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

@@ -84,3 +84,48 @@ export type StatesArray = {
     clientId: number;
     [key: string | number]: any;
 }[];
+export type THistoryVersion = {
+    name?: string;
+    version: number;
+    date: number;
+};
+export type THistoryConfiguration = {
+    autoVersioning: boolean;
+    currentVersion: number;
+    stateCaptured: number;
+};
+export type THistoryAction = THistoryDocumentRevertAction | THistoryVersionCreateAction | THistoryVersionPreviewAction;
+export type THistoryDocumentRevertAction = {
+    action: 'document.revert';
+    /**
+     * if changes havent been persisted to a version yet, we'll create one with the specified name,
+     * expect when `false` is passed.
+     */
+    currentVersionName?: string | false;
+    /**
+     * Name of the version that is created after the revert. Pass `false` to avoid generating a new version.
+     */
+    newVersionName?: string | false;
+};
+export type THistoryVersionCreateAction = {
+    action: 'version.create';
+    name?: string;
+};
+export type THistoryVersionPreviewAction = {
+    action: 'version.preview';
+    version: number;
+};
+export type THistoryEvent = THistoryVersionPreviewEvent | THistoryVersionCreatedEvent | THistoryDocumentRevertedEvent;
+export type THistoryVersionCreatedEvent = {
+    event: 'version.created';
+    version: number;
+};
+export type THistoryVersionPreviewEvent = {
+    event: 'version.preview';
+    version: number;
+    ydoc: string;
+};
+export type THistoryDocumentRevertedEvent = {
+    event: 'document.reverted';
+    version: number;
+};

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

@@ -1,5 +1,4 @@
 /// <reference types="node" />
-/// <reference types="node" />
 import { IncomingMessage } from 'http';
 import WebSocket, { AddressInfo } from 'ws';
 import { Server as HocuspocusServer } from './Server';
@@ -29,6 +28,7 @@ export declare class Hocuspocus {
     documents: Map<string, Document>;
     server?: HocuspocusServer;
     debugger: Debugger;
+    debounce: (id: string, func: Function, debounce: number, maxDebounce: number) => void;
     constructor(configuration?: Partial<Configuration>);
     /**
      * Configure the server
@@ -78,14 +78,6 @@ export declare class Hocuspocus {
      * the update is incoming from the provider, but can be anything if the updates is originated from an extension.
      */
     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
      */

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

@@ -5,7 +5,8 @@ import { IncomingMessage } from './IncomingMessage.js';
 export declare class MessageReceiver {
     message: IncomingMessage;
     logger: Debugger;
-    constructor(message: IncomingMessage, logger: Debugger);
+    defaultTransactionOrigin?: string;
+    constructor(message: IncomingMessage, logger: Debugger, defaultTransactionOrigin?: string);
     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(document: Document, reply?: (message: Uint8Array) => void): void;

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

@@ -6,3 +6,4 @@ export * from './IncomingMessage.js';
 export * from './MessageReceiver.js';
 export * from './OutgoingMessage.js';
 export * from './types.js';
+export * from './util/debounce.js';

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

@@ -39,7 +39,7 @@ export interface Extension {
     connected?(data: connectedPayload): Promise<any>;
     onAuthenticate?(data: onAuthenticatePayload): Promise<any>;
     onLoadDocument?(data: onLoadDocumentPayload): Promise<any>;
-    afterLoadDocument?(data: onLoadDocumentPayload): Promise<any>;
+    afterLoadDocument?(data: afterLoadDocumentPayload): Promise<any>;
     beforeHandleMessage?(data: beforeHandleMessagePayload): Promise<any>;
     beforeBroadcastStateless?(data: beforeBroadcastStatelessPayload): Promise<any>;
     onStateless?(payload: onStatelessPayload): Promise<any>;
@@ -49,7 +49,7 @@ export interface Extension {
     onAwarenessUpdate?(data: onAwarenessUpdatePayload): Promise<any>;
     onRequest?(data: onRequestPayload): Promise<any>;
     onDisconnect?(data: onDisconnectPayload): Promise<any>;
-    afterUnloadDocument?(data: onLoadDocumentPayload): Promise<any>;
+    afterUnloadDocument?(data: afterUnloadDocumentPayload): 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' | 'afterUnloadDocument' | 'onDestroy';
@@ -61,7 +61,7 @@ export type HookPayloadByName = {
     connected: connectedPayload;
     onAuthenticate: onAuthenticatePayload;
     onLoadDocument: onLoadDocumentPayload;
-    afterLoadDocument: onLoadDocumentPayload;
+    afterLoadDocument: afterLoadDocumentPayload;
     beforeHandleMessage: beforeHandleMessagePayload;
     beforeBroadcastStateless: beforeBroadcastStatelessPayload;
     onStateless: onStatelessPayload;
@@ -123,15 +123,6 @@ export interface Configuration extends Extension {
         gc: boolean;
         gcFilter: () => boolean;
     };
-    /**
-     * Function which returns the (customized) document name based on the request
-     */
-    getDocumentName?(data: getDocumentNamePayload): string | Promise<string>;
-}
-export interface getDocumentNamePayload {
-    documentName: string;
-    request: IncomingMessage;
-    requestParameters: URLSearchParams;
 }
 export interface onStatelessPayload {
     connection: Connection;
@@ -149,6 +140,7 @@ export interface onAuthenticatePayload {
     connection: ConnectionConfiguration;
 }
 export interface onConnectPayload {
+    context: any;
     documentName: string;
     instance: Hocuspocus;
     request: IncomingMessage;

package/dist/packages/server/src/util/debounce.d.ts

@@ -0,0 +1 @@
+export declare const useDebounce: () => (id: string, func: Function, debounce: number, maxDebounce: number) => void;

package/package.json

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

package/dist/tests/extension-redis/closeConnections.d.ts

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

package/dist/tests/extension-redis/getConnectionCount.d.ts

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

package/dist/tests/extension-redis/getDocumentsCount.d.ts

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