@hocuspocus/provider 2.9.1-rc.0 → 2.10.0

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

@@ -121,7 +121,7 @@ export declare class HocuspocusProvider extends EventEmitter {
     set synced(state: boolean);
     receiveStateless(payload: string): void;
     get isAuthenticationRequired(): boolean;
-    connect(): Promise<unknown>;
+    connect(): Promise<any>;
     disconnect(): void;
     onOpen(event: Event): Promise<void>;
     getToken(): Promise<string | null>;

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

@@ -102,7 +102,7 @@ export declare class HocuspocusProviderWebsocket extends EventEmitter {
     receivedOnStatusPayload?: onStatusParameters | undefined;
     onOpen(event: Event): Promise<void>;
     onStatus(data: onStatusParameters): Promise<void>;
-    attach(provider: HocuspocusProvider): void;
+    attach(provider: HocuspocusProvider): Promise<any> | undefined;
     detach(provider: HocuspocusProvider): void;
     setConfiguration(configuration?: Partial<HocuspocusProviderWebsocketConfiguration>): void;
     cancelWebsocketRetry?: () => void;

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

@@ -1,7 +1,7 @@
 import type { AbstractType, YArrayEvent } from 'yjs';
 import { HocuspocusProvider, HocuspocusProviderConfiguration } from './HocuspocusProvider.js';
 import { TiptapCollabProviderWebsocket } from './TiptapCollabProviderWebsocket.js';
-import type { THistoryVersion } from './types.js';
+import type { TCollabComment, TCollabThread, THistoryVersion } from './types.js';
 export type TiptapCollabProviderConfiguration = Required<Pick<HocuspocusProviderConfiguration, 'name'>> & Partial<HocuspocusProviderConfiguration> & (Required<Pick<AdditionalTiptapCollabProviderConfiguration, 'websocketProvider'>> | Required<Pick<AdditionalTiptapCollabProviderConfiguration, 'appId'>> | Required<Pick<AdditionalTiptapCollabProviderConfiguration, 'baseUrl'>>);
 export interface AdditionalTiptapCollabProviderConfiguration {
     /**
@@ -40,4 +40,19 @@ export declare class TiptapCollabProvider extends HocuspocusProvider {
     isAutoVersioning(): boolean;
     enableAutoVersioning(): 1;
     disableAutoVersioning(): 0;
+    private getYThreads;
+    getThreads<Data, CommentData>(): TCollabThread<Data, CommentData>[];
+    private getThreadIndex;
+    getThread<Data, CommentData>(id: string): TCollabThread<Data, CommentData> | null;
+    private getYThread;
+    createThread(data: Omit<TCollabThread, '_id' | 'createdAt' | 'updatedAt' | 'comments'>): TCollabThread | null;
+    updateThread(id: TCollabThread['id'], data: Partial<Pick<TCollabThread, 'data' | 'resolvedAt'>>): TCollabThread | null;
+    deleteThread(id: TCollabThread['id']): void;
+    getThreadComments(threadId: TCollabThread['id']): TCollabComment[] | null;
+    getThreadComment(threadId: TCollabThread['id'], commentId: TCollabComment['id']): TCollabComment | null;
+    addComment(threadId: TCollabThread['id'], data: Omit<TCollabComment, 'id' | 'updatedAt' | 'createdAt'>): TCollabThread | null;
+    updateComment(threadId: TCollabThread['id'], commentId: TCollabComment['id'], data: Partial<Pick<TCollabComment, 'data' | 'content'>>): TCollabThread | null;
+    deleteComment(threadId: TCollabThread['id'], commentId: TCollabComment['id']): TCollabThread | null;
+    watchThreads(callback: () => void): void;
+    unwatchThreads(callback: () => void): void;
 }

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

@@ -84,6 +84,21 @@ export type StatesArray = {
     clientId: number;
     [key: string | number]: any;
 }[];
+export type TCollabThread<Data = any, CommentData = any> = {
+    id: string;
+    createdAt: number;
+    updatedAt: number;
+    resolvedAt?: string;
+    comments: TCollabComment<CommentData>[];
+    data: Data;
+};
+export type TCollabComment<Data = any> = {
+    id: string;
+    createdAt: number;
+    updatedAt: number;
+    data: Data;
+    content: any;
+};
 export type THistoryVersion = {
     name?: string;
     version: number;

package/dist/playground/frontend/vite.config.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("vite").UserConfigExport;
+declare const _default: import("vite").UserConfig;
 export default _default;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hocuspocus/provider",
-  "version": "2.9.1-rc.0",
+  "version": "2.10.0",
   "description": "hocuspocus provider",
   "homepage": "https://hocuspocus.dev",
   "keywords": [
@@ -29,7 +29,7 @@
     "dist"
   ],
   "dependencies": {
-    "@hocuspocus/common": "^2.9.1-rc.0",
+    "@hocuspocus/common": "^2.10.0",
     "@lifeomic/attempt": "^3.0.2",
     "lib0": "^0.2.87",
     "ws": "^8.14.2"

package/src/HocuspocusProvider.ts

@@ -367,7 +367,9 @@ export class HocuspocusProvider extends EventEmitter {
       this.subscribeToBroadcastChannel()
     }
 
-    return this.configuration.websocketProvider.connect()
+    this.configuration.websocketProvider.shouldConnect = true
+
+    return this.configuration.websocketProvider.attach(this)
   }
 
   disconnect() {

package/src/HocuspocusProviderWebsocket.ts

@@ -217,10 +217,11 @@ export class HocuspocusProviderWebsocket extends EventEmitter {
   }
 
   attach(provider: HocuspocusProvider) {
+    let connectPromise: Promise<any> | undefined
     this.configuration.providerMap.set(provider.configuration.name, provider)
 
     if (this.status === WebSocketStatus.Disconnected && this.shouldConnect) {
-      this.connect()
+      connectPromise = this.connect()
     }
 
     if (this.receivedOnOpenPayload) {
@@ -230,6 +231,8 @@ export class HocuspocusProviderWebsocket extends EventEmitter {
     if (this.receivedOnStatusPayload) {
       provider.onStatus(this.receivedOnStatusPayload)
     }
+
+    return connectPromise
   }
 
   detach(provider: HocuspocusProvider) {

package/src/TiptapCollabProvider.ts

@@ -1,11 +1,15 @@
 import type { AbstractType, YArrayEvent } from 'yjs'
+import * as Y from 'yjs'
+import { uuidv4 } from 'lib0/random'
 import {
   HocuspocusProvider,
   HocuspocusProviderConfiguration,
 } from './HocuspocusProvider.js'
 
 import { TiptapCollabProviderWebsocket } from './TiptapCollabProviderWebsocket.js'
-import type { THistoryVersion } from './types.js'
+import type {
+  TCollabComment, TCollabThread, THistoryVersion,
+} from './types.js'
 
 export type TiptapCollabProviderConfiguration =
   Required<Pick<HocuspocusProviderConfiguration, 'name'>> &
@@ -93,4 +97,181 @@ export class TiptapCollabProvider extends HocuspocusProvider {
     return this.configuration.document.getMap<number>(`${this.tiptapCollabConfigurationPrefix}config`).set('autoVersioning', 0)
   }
 
+  private getYThreads() {
+    return this.configuration.document.getArray<Y.Map<any>>(`${this.tiptapCollabConfigurationPrefix}threads`)
+  }
+
+  getThreads<Data, CommentData>(): TCollabThread<Data, CommentData>[] {
+    return this.getYThreads().toJSON() as TCollabThread<Data, CommentData>[]
+  }
+
+  private getThreadIndex(id: string): number | null {
+    let index = null
+
+    let i = 0
+    // eslint-disable-next-line no-restricted-syntax
+    for (const thread of this.getThreads()) {
+      if (thread.id === id) {
+        index = i
+        break
+      }
+      i += 1
+    }
+
+    return index
+  }
+
+  getThread<Data, CommentData>(id: string): TCollabThread<Data, CommentData> | null {
+    const index = this.getThreadIndex(id)
+
+    if (index === null) {
+      return null
+    }
+
+    return this.getYThreads().get(index).toJSON() as TCollabThread<Data, CommentData>
+  }
+
+  private getYThread(id: string) {
+    const index = this.getThreadIndex(id)
+
+    if (index === null) {
+      return null
+    }
+
+    return this.getYThreads().get(index)
+  }
+
+  createThread(data: Omit<TCollabThread, '_id' | 'createdAt' | 'updatedAt' | 'comments'>) {
+    const thread = new Y.Map()
+    thread.set('id', uuidv4())
+    thread.set('createdAt', (new Date()).toISOString())
+    thread.set('comments', new Y.Array())
+
+    this.getYThreads().push([thread])
+    return this.updateThread(String(thread.get('id')), data)
+  }
+
+  updateThread(id: TCollabThread['id'], data: Partial<Pick<TCollabThread, 'data' | 'resolvedAt'>>) {
+    const thread = this.getYThread(id)
+
+    if (thread === null) {
+      return null
+    }
+
+    thread.set('updatedAt', (new Date()).toISOString())
+
+    if (data.data) {
+      thread.set('data', data.data)
+    }
+
+    if (data.resolvedAt || data.resolvedAt === null) {
+      thread.set('resolvedAt', data.resolvedAt)
+    }
+
+    return thread.toJSON() as TCollabThread
+  }
+
+  deleteThread(id: TCollabThread['id']) {
+    const index = this.getThreadIndex(id)
+
+    if (index === null) {
+      return
+    }
+
+    this.getYThreads().delete(index, 1)
+  }
+
+  getThreadComments(threadId: TCollabThread['id']): TCollabComment[] | null {
+    const index = this.getThreadIndex(threadId)
+
+    if (index === null) {
+      return null
+    }
+
+    return this.getThread(threadId)?.comments ?? []
+  }
+
+  getThreadComment(threadId: TCollabThread['id'], commentId: TCollabComment['id']): TCollabComment | null {
+    const index = this.getThreadIndex(threadId)
+
+    if (index === null) {
+      return null
+    }
+
+    return this.getThread(threadId)?.comments.find(comment => comment.id === commentId) ?? null
+  }
+
+  addComment(threadId: TCollabThread['id'], data: Omit<TCollabComment, 'id' | 'updatedAt' | 'createdAt'>) {
+    const thread = this.getYThread(threadId)
+
+    if (thread === null) return null
+
+    const commentMap = new Y.Map()
+    commentMap.set('id', uuidv4())
+    commentMap.set('createdAt', (new Date()).toISOString())
+    thread.get('comments').push([commentMap])
+
+    this.updateComment(threadId, String(commentMap.get('id')), data)
+
+    return thread.toJSON() as TCollabThread
+  }
+
+  updateComment(threadId: TCollabThread['id'], commentId: TCollabComment['id'], data: Partial<Pick<TCollabComment, 'data' | 'content'>>) {
+    const thread = this.getYThread(threadId)
+
+    if (thread === null) return null
+
+    let comment = null
+    // eslint-disable-next-line no-restricted-syntax
+    for (const c of thread.get('comments')) {
+      if (c.get('id') === commentId) {
+        comment = c
+        break
+      }
+    }
+
+    if (comment === null) return null
+
+    comment.set('updatedAt', (new Date()).toISOString())
+
+    if (data.data) {
+      comment.set('data', data.data)
+    }
+
+    if (data.content) {
+      comment.set('content', data.content)
+    }
+
+    return thread.toJSON() as TCollabThread
+  }
+
+  deleteComment(threadId: TCollabThread['id'], commentId: TCollabComment['id']) {
+    const thread = this.getYThread(threadId)
+
+    if (thread === null) return null
+
+    let commentIndex = 0
+    // eslint-disable-next-line no-restricted-syntax
+    for (const c of thread.get('comments')) {
+      if (c.get('id') === commentId) {
+        break
+      }
+      commentIndex += 1
+    }
+
+    if (commentIndex >= 0) {
+      thread.get('comments').delete(commentIndex)
+    }
+
+    return thread.toJSON() as TCollabThread
+  }
+
+  watchThreads(callback: () => void) {
+    this.getYThreads().observeDeep(callback)
+  }
+
+  unwatchThreads(callback: () => void) {
+    this.getYThreads().unobserveDeep(callback)
+  }
+
 }

package/src/types.ts

@@ -106,6 +106,23 @@ export type StatesArray = { clientId: number, [key: string | number]: any }[]
 
 // hocuspocus-pro types
 
+export type TCollabThread<Data = any, CommentData = any> = {
+  id: string;
+  createdAt: number;
+  updatedAt: number;
+  resolvedAt?: string; // (new Date()).toISOString()
+  comments: TCollabComment<CommentData>[];
+  data: Data
+}
+
+export type TCollabComment<Data = any> = {
+  id: string;
+  createdAt: number;
+  updatedAt: number;
+  data: Data
+  content: any
+}
+
 export type THistoryVersion = {
   name?: string;
   version: number;