@hocuspocus/provider 2.2.1 → 2.2.3

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

@@ -72,6 +72,17 @@ export declare class HocuspocusProvider extends EventEmitter {
     intervals: any;
     isConnected: boolean;
     constructor(configuration: HocuspocusProviderConfiguration);
+    boundBroadcastChannelSubscriber: (data: ArrayBuffer) => void;
+    boundBeforeUnload: () => void;
+    boundOnOpen: (event: Event) => Promise<void>;
+    boundOnMessage: (event: MessageEvent) => void;
+    boundOnClose: (event: CloseEvent) => void;
+    boundOnStatus: ({ status }: onStatusParameters) => void;
+    forwardConnect: (e: any) => this;
+    forwardOpen: (e: any) => this;
+    forwardClose: (e: any) => this;
+    forwardDisconnect: (e: any) => this;
+    forwardDestroy: (e: any) => this;
     onStatus({ status }: onStatusParameters): void;
     setConfiguration(configuration?: Partial<HocuspocusProviderConfiguration>): void;
     get document(): Y.Doc;
@@ -79,7 +90,6 @@ export declare class HocuspocusProvider extends EventEmitter {
     get hasUnsyncedChanges(): boolean;
     updateUnsyncedChanges(unsyncedChanges?: number): void;
     forceSync(): void;
-    boundBeforeUnload: () => void;
     beforeUnload(): void;
     registerEventListeners(): void;
     sendStateless(payload: string): void;
@@ -101,7 +111,6 @@ export declare class HocuspocusProvider extends EventEmitter {
     permissionDeniedHandler(reason: string): void;
     authenticatedHandler(scope: string): void;
     get broadcastChannel(): string;
-    boundBroadcastChannelSubscriber: (data: ArrayBuffer) => void;
     broadcastChannelSubscriber(data: ArrayBuffer): void;
     subscribeToBroadcastChannel(): void;
     disconnectBroadcastChannel(): void;

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

@@ -1,11 +1,28 @@
+import type { AbstractType, YArrayEvent } from 'yjs';
 import { HocuspocusProvider, HocuspocusProviderConfiguration } from './HocuspocusProvider.js';
-export type TiptapCollabProviderConfiguration = Required<Pick<HocuspocusProviderConfiguration, 'name'>> & Partial<HocuspocusProviderConfiguration> & AdditionalTiptapCollabProviderConfiguration;
+import { TiptapCollabProviderWebsocket } from './TiptapCollabProviderWebsocket.js';
+export type TiptapCollabProviderConfiguration = Required<Pick<HocuspocusProviderConfiguration, 'name'>> & Partial<HocuspocusProviderConfiguration> & (Required<Pick<AdditionalTiptapCollabProviderConfiguration, 'websocketProvider'>> | Required<Pick<AdditionalTiptapCollabProviderConfiguration, 'appId'>>);
 export interface AdditionalTiptapCollabProviderConfiguration {
     /**
      * A Hocuspocus Cloud App ID, get one here: https://collab.tiptap.dev
      */
-    appId: string;
+    appId?: string;
+    websocketProvider?: TiptapCollabProviderWebsocket;
 }
+export type AuditHistoryVersion = {
+    name?: string;
+    version: number;
+    date: number;
+};
 export declare class TiptapCollabProvider extends HocuspocusProvider {
+    tiptapCollabConfigurationPrefix: string;
     constructor(configuration: TiptapCollabProviderConfiguration);
+    createVersion(name?: string): void;
+    revertToVersion(targetVersion: number): void;
+    getVersions(): AuditHistoryVersion[];
+    watchVersions(callback: Parameters<AbstractType<YArrayEvent<AuditHistoryVersion>>['observe']>[0]): void;
+    unwatchVersions(callback: Parameters<AbstractType<YArrayEvent<AuditHistoryVersion>>['unobserve']>[0]): void;
+    isAutoVersioning(): boolean;
+    enableAutoVersioning(): number;
+    disableAutoVersioning(): number;
 }

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

@@ -1,22 +1,23 @@
+import { Encoder } from 'lib0/encoding';
+import type { CloseEvent, Event, MessageEvent } from 'ws';
 import { Awareness } from 'y-protocols/awareness';
 import * as Y from 'yjs';
-import { Encoder } from 'lib0/encoding';
-import type { Event, CloseEvent, MessageEvent } from 'ws';
+import { IncomingMessage } from './IncomingMessage.js';
+import { OutgoingMessage } from './OutgoingMessage.js';
 import { AuthenticationMessage } from './OutgoingMessages/AuthenticationMessage.js';
 import { AwarenessMessage } from './OutgoingMessages/AwarenessMessage.js';
 import { QueryAwarenessMessage } from './OutgoingMessages/QueryAwarenessMessage.js';
 import { SyncStepOneMessage } from './OutgoingMessages/SyncStepOneMessage.js';
 import { SyncStepTwoMessage } from './OutgoingMessages/SyncStepTwoMessage.js';
 import { UpdateMessage } from './OutgoingMessages/UpdateMessage.js';
-import { IncomingMessage } from './IncomingMessage.js';
-import { OutgoingMessage } from './OutgoingMessage.js';
 export declare enum MessageType {
     Sync = 0,
     Awareness = 1,
     Auth = 2,
     QueryAwareness = 3,
     Stateless = 5,
-    CLOSE = 7
+    CLOSE = 7,
+    SyncStatus = 8
 }
 export declare enum WebSocketStatus {
     Connecting = "connecting",

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

@@ -1,6 +1,6 @@
 import Document from './Document.js';
 import type { Hocuspocus } from './Hocuspocus.js';
-import type { DirectConnection as DirectConnectionInterface } from './types';
+import type { DirectConnection as DirectConnectionInterface } from './types.js';
 export declare class DirectConnection implements DirectConnectionInterface {
     document: Document | null;
     instance: Hocuspocus;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hocuspocus/provider",
-  "version": "2.2.1",
+  "version": "2.2.3",
   "description": "hocuspocus provider",
   "homepage": "https://hocuspocus.dev",
   "keywords": [
@@ -29,7 +29,7 @@
     "dist"
   ],
   "dependencies": {
-    "@hocuspocus/common": "^2.2.1",
+    "@hocuspocus/common": "^2.2.3",
     "@lifeomic/attempt": "^3.0.2",
     "lib0": "^0.2.47",
     "ws": "^7.5.9"

package/src/HocuspocusProvider.ts

@@ -166,24 +166,24 @@ export class HocuspocusProvider extends EventEmitter {
     this.on('authenticationFailed', this.configuration.onAuthenticationFailed)
 
     this.configuration.websocketProvider.on('connect', this.configuration.onConnect)
-    this.configuration.websocketProvider.on('connect', (e: Event) => this.emit('connect', e))
+    this.configuration.websocketProvider.on('connect', this.forwardConnect)
 
-    this.configuration.websocketProvider.on('open', this.onOpen.bind(this))
-    this.configuration.websocketProvider.on('open', (e: Event) => this.emit('open', e))
+    this.configuration.websocketProvider.on('open', this.boundOnOpen)
+    this.configuration.websocketProvider.on('open', this.forwardOpen)
 
-    this.configuration.websocketProvider.on('message', this.onMessage.bind(this))
+    this.configuration.websocketProvider.on('message', this.boundOnMessage)
 
-    this.configuration.websocketProvider.on('close', this.onClose.bind(this))
+    this.configuration.websocketProvider.on('close', this.boundOnClose)
     this.configuration.websocketProvider.on('close', this.configuration.onClose)
-    this.configuration.websocketProvider.on('close', (e: Event) => this.emit('close', e))
+    this.configuration.websocketProvider.on('close', this.forwardClose)
 
-    this.configuration.websocketProvider.on('status', this.onStatus.bind(this))
+    this.configuration.websocketProvider.on('status', this.boundOnStatus)
 
     this.configuration.websocketProvider.on('disconnect', this.configuration.onDisconnect)
-    this.configuration.websocketProvider.on('disconnect', (e: Event) => this.emit('disconnect', e))
+    this.configuration.websocketProvider.on('disconnect', this.forwardDisconnect)
 
     this.configuration.websocketProvider.on('destroy', this.configuration.onDestroy)
-    this.configuration.websocketProvider.on('destroy', (e: Event) => this.emit('destroy', e))
+    this.configuration.websocketProvider.on('destroy', this.forwardDestroy)
 
     this.awareness.on('update', () => {
       this.emit('awarenessUpdate', { states: awarenessStatesToArray(this.awareness.getStates()) })
@@ -207,6 +207,28 @@ export class HocuspocusProvider extends EventEmitter {
     this.configuration.websocketProvider.attach(this)
   }
 
+  boundBroadcastChannelSubscriber = this.broadcastChannelSubscriber.bind(this)
+
+  boundBeforeUnload = this.beforeUnload.bind(this)
+
+  boundOnOpen = this.onOpen.bind(this)
+
+  boundOnMessage = this.onMessage.bind(this)
+
+  boundOnClose = this.onClose.bind(this)
+
+  boundOnStatus = this.onStatus.bind(this)
+
+  forwardConnect = (e: any) => this.emit('connect', e)
+
+  forwardOpen = (e: any) => this.emit('open', e)
+
+  forwardClose = (e: any) => this.emit('close', e)
+
+  forwardDisconnect = (e: any) => this.emit('disconnect', e)
+
+  forwardDestroy = (e: any) => this.emit('destroy', e)
+
   public onStatus({ status } : onStatusParameters) {
     this.status = status
 
@@ -248,8 +270,6 @@ export class HocuspocusProvider extends EventEmitter {
     this.send(SyncStepOneMessage, { document: this.document, documentName: this.configuration.name })
   }
 
-  boundBeforeUnload = this.beforeUnload.bind(this)
-
   beforeUnload() {
     removeAwarenessStates(this.awareness, [this.document.clientID], 'window unload')
   }
@@ -414,6 +434,20 @@ export class HocuspocusProvider extends EventEmitter {
 
     this.removeAllListeners()
 
+    this.configuration.websocketProvider.off('connect', this.configuration.onConnect)
+    this.configuration.websocketProvider.off('connect', this.forwardConnect)
+    this.configuration.websocketProvider.off('open', this.boundOnOpen)
+    this.configuration.websocketProvider.off('open', this.forwardOpen)
+    this.configuration.websocketProvider.off('message', this.boundOnMessage)
+    this.configuration.websocketProvider.off('close', this.boundOnClose)
+    this.configuration.websocketProvider.off('close', this.configuration.onClose)
+    this.configuration.websocketProvider.off('close', this.forwardClose)
+    this.configuration.websocketProvider.off('status', this.boundOnStatus)
+    this.configuration.websocketProvider.off('disconnect', this.configuration.onDisconnect)
+    this.configuration.websocketProvider.off('disconnect', this.forwardDisconnect)
+    this.configuration.websocketProvider.off('destroy', this.configuration.onDestroy)
+    this.configuration.websocketProvider.off('destroy', this.forwardDestroy)
+
     this.send(CloseMessage, { documentName: this.configuration.name })
     this.isConnected = false
 
@@ -443,8 +477,6 @@ export class HocuspocusProvider extends EventEmitter {
     return `${this.configuration.name}`
   }
 
-  boundBroadcastChannelSubscriber = this.broadcastChannelSubscriber.bind(this)
-
   broadcastChannelSubscriber(data: ArrayBuffer) {
     this.mux(() => {
       const message = new IncomingMessage(data)

package/src/MessageReceiver.ts

@@ -50,6 +50,10 @@ export class MessageReceiver {
         provider.receiveStateless(readVarString(message.decoder))
         break
 
+      case MessageType.SyncStatus:
+        // nothing for now; forward-compatability
+        break
+
       default:
         throw new Error(`Can’t apply message of unknown type: ${type}`)
     }

package/src/TiptapCollabProvider.ts

@@ -1,3 +1,4 @@
+import type { AbstractType, YArrayEvent } from 'yjs'
 import {
   HocuspocusProvider,
   HocuspocusProviderConfiguration,
@@ -8,19 +9,30 @@ import { TiptapCollabProviderWebsocket } from './TiptapCollabProviderWebsocket.j
 export type TiptapCollabProviderConfiguration =
   Required<Pick<HocuspocusProviderConfiguration, 'name'>> &
   Partial<HocuspocusProviderConfiguration> &
-  AdditionalTiptapCollabProviderConfiguration
+  (Required<Pick<AdditionalTiptapCollabProviderConfiguration, 'websocketProvider'>> |
+  Required<Pick<AdditionalTiptapCollabProviderConfiguration, 'appId'>>)
 
 export interface AdditionalTiptapCollabProviderConfiguration {
   /**
    * A Hocuspocus Cloud App ID, get one here: https://collab.tiptap.dev
    */
-  appId: string,
+  appId?: string,
+
+  websocketProvider?: TiptapCollabProviderWebsocket
+}
+
+export type AuditHistoryVersion = {
+  name?: string;
+  version: number;
+  date: number;
 }
 
 export class TiptapCollabProvider extends HocuspocusProvider {
+  tiptapCollabConfigurationPrefix = '__tiptapcollab__'
+
   constructor(configuration: TiptapCollabProviderConfiguration) {
     if (!configuration.websocketProvider) {
-      configuration.websocketProvider = new TiptapCollabProviderWebsocket({ appId: configuration.appId })
+      configuration.websocketProvider = new TiptapCollabProviderWebsocket({ appId: (configuration as Required<Pick<AdditionalTiptapCollabProviderConfiguration, 'appId'>>).appId })
     }
 
     if (!configuration.token) {
@@ -29,4 +41,45 @@ export class TiptapCollabProvider extends HocuspocusProvider {
 
     super(configuration as HocuspocusProviderConfiguration)
   }
+
+  createVersion(name?: string) {
+    console.error('This doesnt work yet! If you want to join as a beta tester, send an email to humans@tiptap.dev')
+    return this.sendStateless(JSON.stringify({ action: 'version.create', name }))
+  }
+
+  revertToVersion(targetVersion: number) {
+    console.error('This doesnt work yet! If you want to join as a beta tester, send an email to humans@tiptap.dev')
+    return this.sendStateless(JSON.stringify({ action: 'version.revert', version: targetVersion }))
+  }
+
+  getVersions(): AuditHistoryVersion[] {
+    console.error('This doesnt work yet! If you want to join as a beta tester, send an email to humans@tiptap.dev')
+    return this.configuration.document.getArray<AuditHistoryVersion>(`${this.tiptapCollabConfigurationPrefix}versions`).toArray()
+  }
+
+  watchVersions(callback: Parameters<AbstractType<YArrayEvent<AuditHistoryVersion>>['observe']>[0]) {
+    console.error('This doesnt work yet! If you want to join as a beta tester, send an email to humans@tiptap.dev')
+    return this.configuration.document.getArray<AuditHistoryVersion>('__tiptapcollab__versions').observe(callback)
+  }
+
+  unwatchVersions(callback: Parameters<AbstractType<YArrayEvent<AuditHistoryVersion>>['unobserve']>[0]) {
+    console.error('This doesnt work yet! If you want to join as a beta tester, send an email to humans@tiptap.dev')
+    return this.configuration.document.getArray<AuditHistoryVersion>('__tiptapcollab__versions').unobserve(callback)
+  }
+
+  isAutoVersioning(): boolean {
+    console.error('This doesnt work yet! If you want to join as a beta tester, send an email to humans@tiptap.dev')
+    return !!this.configuration.document.getMap<number>(`${this.tiptapCollabConfigurationPrefix}config`).get('autoVersioning')
+  }
+
+  enableAutoVersioning() {
+    console.error('This doesnt work yet! If you want to join as a beta tester, send an email to humans@tiptap.dev')
+    return this.configuration.document.getMap<number>(`${this.tiptapCollabConfigurationPrefix}config`).set('autoVersioning', 1)
+  }
+
+  disableAutoVersioning() {
+    console.error('This doesnt work yet! If you want to join as a beta tester, send an email to humans@tiptap.dev')
+    return this.configuration.document.getMap<number>(`${this.tiptapCollabConfigurationPrefix}config`).set('autoVersioning', 0)
+  }
+
 }

package/src/types.ts

@@ -1,15 +1,15 @@
+import { Encoder } from 'lib0/encoding'
+import type { CloseEvent, Event, MessageEvent } from 'ws'
 import { Awareness } from 'y-protocols/awareness'
 import * as Y from 'yjs'
-import { Encoder } from 'lib0/encoding'
-import type { Event, CloseEvent, MessageEvent } from 'ws'
+import { IncomingMessage } from './IncomingMessage.js'
+import { OutgoingMessage } from './OutgoingMessage.js'
 import { AuthenticationMessage } from './OutgoingMessages/AuthenticationMessage.js'
 import { AwarenessMessage } from './OutgoingMessages/AwarenessMessage.js'
 import { QueryAwarenessMessage } from './OutgoingMessages/QueryAwarenessMessage.js'
 import { SyncStepOneMessage } from './OutgoingMessages/SyncStepOneMessage.js'
 import { SyncStepTwoMessage } from './OutgoingMessages/SyncStepTwoMessage.js'
 import { UpdateMessage } from './OutgoingMessages/UpdateMessage.js'
-import { IncomingMessage } from './IncomingMessage.js'
-import { OutgoingMessage } from './OutgoingMessage.js'
 
 export enum MessageType {
   Sync = 0,
@@ -18,6 +18,7 @@ export enum MessageType {
   QueryAwareness = 3,
   Stateless = 5,
   CLOSE = 7,
+  SyncStatus = 8,
 }
 
 export enum WebSocketStatus {