@hocuspocus/provider 2.13.7 → 2.15.0

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

@@ -88,6 +88,8 @@ export declare class HocuspocusProvider extends EventEmitter {
     intervals: any;
     isConnected: boolean;
     constructor(configuration: HocuspocusProviderConfiguration);
+    boundDocumentUpdateHandler: (update: Uint8Array, origin: any) => void;
+    boundAwarenessUpdateHandler: ({ added, updated, removed }: any, origin: any) => void;
     boundBroadcastChannelSubscriber: (data: ArrayBuffer) => void;
     boundPageHide: () => void;
     boundOnOpen: (event: Event) => Promise<void>;

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

@@ -2,8 +2,13 @@ import type { AbstractType, YArrayEvent } from 'yjs';
 import * as Y from 'yjs';
 import { HocuspocusProvider, HocuspocusProviderConfiguration } from './HocuspocusProvider.js';
 import { TiptapCollabProviderWebsocket } from './TiptapCollabProviderWebsocket.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'>>) & Pick<AdditionalTiptapCollabProviderConfiguration, 'user'>;
+import { type DeleteCommentOptions, type DeleteThreadOptions, type GetThreadsOptions, type TCollabComment, type TCollabThread, type 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'>>) & Pick<AdditionalTiptapCollabProviderConfiguration, 'user'> & {
+    /**
+     * Pass `true` if you want to delete a thread when the first comment is deleted.
+     */
+    deleteThreadOnFirstCommentDelete?: boolean;
+};
 export interface AdditionalTiptapCollabProviderConfiguration {
     /**
      * A Hocuspocus Cloud App ID, get one here: https://cloud.tiptap.dev
@@ -43,21 +48,114 @@ export declare class TiptapCollabProvider extends HocuspocusProvider {
     isAutoVersioning(): boolean;
     enableAutoVersioning(): 1;
     disableAutoVersioning(): 0;
+    /**
+     * Returns all users in the document as Y.Map objects
+     * @returns An array of Y.Map objects
+     */
     private getYThreads;
-    getThreads<Data, CommentData>(): TCollabThread<Data, CommentData>[];
+    /**
+     * Finds all threads in the document and returns them as JSON objects
+     * @options Options to control the output of the threads (e.g. include deleted threads)
+     * @returns An array of threads as JSON objects
+     */
+    getThreads<Data, CommentData>(options?: GetThreadsOptions): TCollabThread<Data, CommentData>[];
+    /**
+     * Find the index of a thread by its id
+     * @param id The thread id
+     * @returns The index of the thread or null if not found
+     */
     private getThreadIndex;
+    /**
+     * Gets a single thread by its id
+     * @param id The thread id
+     * @returns The thread as a JSON object or null if not found
+     */
     getThread<Data, CommentData>(id: string): TCollabThread<Data, CommentData> | null;
+    /**
+     * Gets a single thread by its id as a Y.Map object
+     * @param id The thread id
+     * @returns The thread as a Y.Map object or null if not found
+     */
     private getYThread;
-    createThread(data: Omit<TCollabThread, 'id' | 'createdAt' | 'updatedAt' | 'comments'>): TCollabThread;
+    /**
+     * Create a new thread
+     * @param data The thread data
+     * @returns The created thread
+     */
+    createThread(data: Omit<TCollabThread, 'id' | 'createdAt' | 'updatedAt' | 'deletedAt' | 'comments' | 'deletedComments'>): TCollabThread;
+    /**
+     * Update a specific thread
+     * @param id The thread id
+     * @param data New data for the thread
+     * @returns The updated thread or null if the thread is not found
+     */
     updateThread(id: TCollabThread['id'], data: Partial<Pick<TCollabThread, 'data'> & {
         resolvedAt: TCollabThread['resolvedAt'] | null;
     }>): TCollabThread;
-    deleteThread(id: TCollabThread['id']): void;
-    getThreadComments(threadId: TCollabThread['id']): TCollabComment[] | null;
-    getThreadComment(threadId: TCollabThread['id'], commentId: TCollabComment['id']): TCollabComment | null;
+    /**
+     * Handle the deletion of a thread. By default, the thread and it's comments are not deleted, but marked as deleted
+     * via the `deletedAt` property. Forceful deletion can be enabled by setting the `force` option to `true`.
+     *
+     * If you only want to delete the comments of a thread, you can set the `deleteComments` option to `true`.
+     * @param id The thread id
+     * @param options A set of options that control how the thread is deleted
+     * @returns The deleted thread or null if the thread is not found
+     */
+    deleteThread(id: TCollabThread['id'], options?: DeleteThreadOptions): TCollabThread | null | undefined;
+    /**
+     * Tries to restore a deleted thread
+     * @param id The thread id
+     * @returns The restored thread or null if the thread is not found
+     */
+    restoreThread(id: TCollabThread['id']): TCollabThread | null;
+    /**
+     * Returns comments from a thread, either deleted or not
+     * @param threadId The thread id
+     * @param includeDeleted If you want to include deleted comments, defaults to `false`
+     * @returns The comments or null if the thread is not found
+     */
+    getThreadComments(threadId: TCollabThread['id'], includeDeleted?: boolean): TCollabComment[] | null;
+    /**
+     * Get a single comment from a specific thread
+     * @param threadId The thread id
+     * @param commentId The comment id
+     * @param includeDeleted If you want to include deleted comments in the search
+     * @returns The comment or null if not found
+     */
+    getThreadComment(threadId: TCollabThread['id'], commentId: TCollabComment['id'], includeDeleted?: boolean): TCollabComment | null;
+    /**
+     * Adds a comment to a thread
+     * @param threadId The thread id
+     * @param data The comment data
+     * @returns The updated thread or null if the thread is not found
+     * @example addComment('123', { content: 'Hello world', data: { author: 'Maria Doe' } })
+     */
     addComment(threadId: TCollabThread['id'], data: Omit<TCollabComment, 'id' | 'updatedAt' | 'createdAt'>): TCollabThread;
+    /**
+     * Update a comment in a thread
+     * @param threadId The thread id
+     * @param commentId The comment id
+     * @param data The new comment data
+     * @returns The updated thread or null if the thread or comment is not found
+     * @example updateComment('123', { content: 'The new content', data: { attachments: ['file1.jpg'] }})
+     */
     updateComment(threadId: TCollabThread['id'], commentId: TCollabComment['id'], data: Partial<Pick<TCollabComment, 'data' | 'content'>>): TCollabThread;
-    deleteComment(threadId: TCollabThread['id'], commentId: TCollabComment['id']): TCollabThread | null | undefined;
+    /**
+     * Deletes a comment from a thread
+     * @param threadId The thread id
+     * @param commentId The comment id
+     * @param options A set of options that control how the comment is deleted
+     * @returns The updated thread or null if the thread or comment is not found
+     */
+    deleteComment(threadId: TCollabThread['id'], commentId: TCollabComment['id'], options: DeleteCommentOptions): TCollabThread | null | undefined;
+    /**
+     * Start watching threads for changes
+     * @param callback The callback function to be called when a thread changes
+     */
     watchThreads(callback: () => void): void;
+    /**
+     * Stop watching threads for changes
+     * @param callback The callback function to be removed
+     */
     unwatchThreads(callback: () => void): void;
 }

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

@@ -88,14 +88,17 @@ export type TCollabThread<Data = any, CommentData = any> = {
     id: string;
     createdAt: number;
     updatedAt: number;
+    deletedAt: number | null;
     resolvedAt?: string;
     comments: TCollabComment<CommentData>[];
+    deletedComments: TCollabComment<CommentData>[];
     data: Data;
 };
 export type TCollabComment<Data = any> = {
     id: string;
-    createdAt: number;
-    updatedAt: number;
+    createdAt: string;
+    updatedAt: string;
+    deletedAt?: string;
     data: Data;
     content: any;
 };
@@ -144,3 +147,40 @@ export type THistoryDocumentRevertedEvent = {
     event: 'document.reverted';
     version: number;
 };
+export type DeleteCommentOptions = {
+    /**
+     * If `true`, the thread will also be deleted if the deleted comment was the first comment in the thread.
+     */
+    deleteThread?: boolean;
+    /**
+     * If `true`, will remove the content of the deleted comment
+     */
+    deleteContent?: boolean;
+};
+export type DeleteThreadOptions = {
+    /**
+     * If `true`, will remove the comments on the thread,
+     * otherwise will only mark the thread as deleted
+     * and keep the comments
+     * @default false
+     */
+    deleteComments?: boolean;
+    /**
+     * If `true`, will forcefully remove the thread and all comments,
+     * otherwise will only mark the thread as deleted
+     * and keep the comments
+     * @default false
+     */
+    force?: boolean;
+};
+/**
+ * The type of thread
+ */
+export type ThreadType = 'archived' | 'unarchived';
+export type GetThreadsOptions = {
+    /**
+     * The types of threads to get
+     * @default ['unarchived']
+     */
+    types?: Array<ThreadType>;
+};

package/package.json

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

package/src/HocuspocusProvider.ts

@@ -212,8 +212,8 @@ export class HocuspocusProvider extends EventEmitter {
       this.emit('awarenessChange', { states: awarenessStatesToArray(this.awareness!.getStates()) })
     })
 
-    this.document.on('update', this.documentUpdateHandler.bind(this))
-    this.awareness?.on('update', this.awarenessUpdateHandler.bind(this))
+    this.document.on('update', this.boundDocumentUpdateHandler)
+    this.awareness?.on('update', this.boundAwarenessUpdateHandler)
     this.registerEventListeners()
 
     if (
@@ -229,6 +229,10 @@ export class HocuspocusProvider extends EventEmitter {
     this.configuration.websocketProvider.attach(this)
   }
 
+  boundDocumentUpdateHandler = this.documentUpdateHandler.bind(this)
+
+  boundAwarenessUpdateHandler = this.awarenessUpdateHandler.bind(this)
+
   boundBroadcastChannelSubscriber = this.broadcastChannelSubscriber.bind(this)
 
   boundPageHide = this.pageHide.bind(this)
@@ -490,11 +494,11 @@ export class HocuspocusProvider extends EventEmitter {
 
     if (this.awareness) {
       removeAwarenessStates(this.awareness, [this.document.clientID], 'provider destroy')
-      this.awareness.off('update', this.awarenessUpdateHandler)
+      this.awareness.off('update', this.boundAwarenessUpdateHandler)
       this.awareness.destroy()
     }
 
-    this.document.off('update', this.documentUpdateHandler)
+    this.document.off('update', this.boundDocumentUpdateHandler)
 
     this.removeAllListeners()
 

package/src/TiptapCollabProvider.ts

@@ -7,17 +7,39 @@ import {
 } from './HocuspocusProvider.js'
 
 import { TiptapCollabProviderWebsocket } from './TiptapCollabProviderWebsocket.js'
-import type {
-  TCollabComment, TCollabThread, THistoryVersion,
+import {
+  type DeleteCommentOptions,
+  type DeleteThreadOptions,
+  type GetThreadsOptions,
+  type TCollabComment, type TCollabThread, type THistoryVersion,
 } from './types.js'
 
+const defaultDeleteCommentOptions: DeleteCommentOptions = {
+  deleteContent: false,
+  deleteThread: false,
+}
+
+const defaultGetThreadsOptions: GetThreadsOptions = {
+  types: ['unarchived'],
+}
+
+const defaultDeleteThreadOptions: DeleteThreadOptions = {
+  deleteComments: false,
+  force: false,
+}
+
 export type TiptapCollabProviderConfiguration =
   Required<Pick<HocuspocusProviderConfiguration, 'name'>> &
   Partial<HocuspocusProviderConfiguration> &
   (Required<Pick<AdditionalTiptapCollabProviderConfiguration, 'websocketProvider'>> |
   Required<Pick<AdditionalTiptapCollabProviderConfiguration, 'appId'>>|
   Required<Pick<AdditionalTiptapCollabProviderConfiguration, 'baseUrl'>>) &
-  Pick<AdditionalTiptapCollabProviderConfiguration, 'user'>
+  Pick<AdditionalTiptapCollabProviderConfiguration, 'user'> & {
+    /**
+     * Pass `true` if you want to delete a thread when the first comment is deleted.
+     */
+    deleteThreadOnFirstCommentDelete?: boolean,
+  }
 
 export interface AdditionalTiptapCollabProviderConfiguration {
   /**
@@ -107,20 +129,52 @@ export class TiptapCollabProvider extends HocuspocusProvider {
     return this.configuration.document.getMap<number>(`${this.tiptapCollabConfigurationPrefix}config`).set('autoVersioning', 0)
   }
 
+  /**
+   * Returns all users in the document as Y.Map objects
+   * @returns An array of Y.Map objects
+   */
   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>[]
+  /**
+   * Finds all threads in the document and returns them as JSON objects
+   * @options Options to control the output of the threads (e.g. include deleted threads)
+   * @returns An array of threads as JSON objects
+   */
+  getThreads<Data, CommentData>(options?: GetThreadsOptions): TCollabThread<Data, CommentData>[] {
+    const { types } = { ...defaultGetThreadsOptions, ...options } as GetThreadsOptions
+
+    const threads = this.getYThreads().toJSON() as TCollabThread<Data, CommentData>[]
+
+    if (types?.includes('archived') && types?.includes('unarchived')) {
+      return threads
+    }
+
+    return threads.filter(currentThead => {
+      if (types?.includes('archived') && currentThead.deletedAt) {
+        return true
+      }
+
+      if (types?.includes('unarchived') && !currentThead.deletedAt) {
+        return true
+      }
+
+      return false
+    })
   }
 
+  /**
+   * Find the index of a thread by its id
+   * @param id The thread id
+   * @returns The index of the thread or null if not found
+   */
   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()) {
+    for (const thread of this.getThreads({ types: ['archived', 'unarchived'] })) {
       if (thread.id === id) {
         index = i
         break
@@ -131,6 +185,11 @@ export class TiptapCollabProvider extends HocuspocusProvider {
     return index
   }
 
+  /**
+   * Gets a single thread by its id
+   * @param id The thread id
+   * @returns The thread as a JSON object or null if not found
+   */
   getThread<Data, CommentData>(id: string): TCollabThread<Data, CommentData> | null {
     const index = this.getThreadIndex(id)
 
@@ -141,6 +200,11 @@ export class TiptapCollabProvider extends HocuspocusProvider {
     return this.getYThreads().get(index).toJSON() as TCollabThread<Data, CommentData>
   }
 
+  /**
+   * Gets a single thread by its id as a Y.Map object
+   * @param id The thread id
+   * @returns The thread as a Y.Map object or null if not found
+   */
   private getYThread(id: string) {
     const index = this.getThreadIndex(id)
 
@@ -151,7 +215,12 @@ export class TiptapCollabProvider extends HocuspocusProvider {
     return this.getYThreads().get(index)
   }
 
-  createThread(data: Omit<TCollabThread, 'id' | 'createdAt' | 'updatedAt' | 'comments'>) {
+  /**
+   * Create a new thread
+   * @param data The thread data
+   * @returns The created thread
+   */
+  createThread(data: Omit<TCollabThread, 'id' | 'createdAt' | 'updatedAt' | 'deletedAt' | 'comments' | 'deletedComments'>) {
     let createdThread: TCollabThread = {} as TCollabThread
 
     this.document.transact(() => {
@@ -159,6 +228,8 @@ export class TiptapCollabProvider extends HocuspocusProvider {
       thread.set('id', uuidv4())
       thread.set('createdAt', (new Date()).toISOString())
       thread.set('comments', new Y.Array())
+      thread.set('deletedComments', new Y.Array())
+      thread.set('deletedAt', null)
 
       this.getYThreads().push([thread])
       createdThread = this.updateThread(String(thread.get('id')), data)
@@ -167,6 +238,12 @@ export class TiptapCollabProvider extends HocuspocusProvider {
     return createdThread
   }
 
+  /**
+   * Update a specific thread
+   * @param id The thread id
+   * @param data New data for the thread
+   * @returns The updated thread or null if the thread is not found
+   */
   updateThread(id: TCollabThread['id'], data: Partial<Pick<TCollabThread, 'data'> & {
     resolvedAt: TCollabThread['resolvedAt'] | null
   }>) {
@@ -195,36 +272,106 @@ export class TiptapCollabProvider extends HocuspocusProvider {
     return updatedThread
   }
 
-  deleteThread(id: TCollabThread['id']) {
+  /**
+   * Handle the deletion of a thread. By default, the thread and it's comments are not deleted, but marked as deleted
+   * via the `deletedAt` property. Forceful deletion can be enabled by setting the `force` option to `true`.
+   *
+   * If you only want to delete the comments of a thread, you can set the `deleteComments` option to `true`.
+   * @param id The thread id
+   * @param options A set of options that control how the thread is deleted
+   * @returns The deleted thread or null if the thread is not found
+   */
+  deleteThread(id: TCollabThread['id'], options?: DeleteThreadOptions) {
+    const { deleteComments, force } = { ...defaultDeleteThreadOptions, ...options }
+
     const index = this.getThreadIndex(id)
 
     if (index === null) {
+      return null
+    }
+
+    if (force) {
+      this.getYThreads().delete(index, 1)
       return
     }
 
-    this.getYThreads().delete(index, 1)
+    const thread = this.getYThreads().get(index)
+
+    thread.set('deletedAt', (new Date()).toISOString())
+
+    if (deleteComments) {
+      thread.set('comments', new Y.Array())
+      thread.set('deletedComments', new Y.Array())
+    }
+
+    return thread.toJSON() as TCollabThread
+  }
+
+  /**
+   * Tries to restore a deleted thread
+   * @param id The thread id
+   * @returns The restored thread or null if the thread is not found
+   */
+  restoreThread(id: TCollabThread['id']) {
+    const index = this.getThreadIndex(id)
+
+    if (index === null) {
+      return null
+    }
+
+    const thread = this.getYThreads().get(index)
+
+    thread.set('deletedAt', null)
+
+    return thread.toJSON() as TCollabThread
   }
 
-  getThreadComments(threadId: TCollabThread['id']): TCollabComment[] | null {
+  /**
+   * Returns comments from a thread, either deleted or not
+   * @param threadId The thread id
+   * @param includeDeleted If you want to include deleted comments, defaults to `false`
+   * @returns The comments or null if the thread is not found
+   */
+  getThreadComments(threadId: TCollabThread['id'], includeDeleted?: boolean): TCollabComment[] | null {
     const index = this.getThreadIndex(threadId)
 
     if (index === null) {
       return null
     }
 
-    return this.getThread(threadId)?.comments ?? []
+    const comments = !includeDeleted ? this.getThread(threadId)?.comments : [...(this.getThread(threadId)?.comments || []), ...(this.getThread(threadId)?.deletedComments || [])].sort((a, b) => {
+      return a.createdAt.localeCompare(b.createdAt)
+    })
+
+    return comments ?? []
   }
 
-  getThreadComment(threadId: TCollabThread['id'], commentId: TCollabComment['id']): TCollabComment | null {
+  /**
+   * Get a single comment from a specific thread
+   * @param threadId The thread id
+   * @param commentId The comment id
+   * @param includeDeleted If you want to include deleted comments in the search
+   * @returns The comment or null if not found
+   */
+  getThreadComment(threadId: TCollabThread['id'], commentId: TCollabComment['id'], includeDeleted?: boolean): TCollabComment | null {
     const index = this.getThreadIndex(threadId)
 
     if (index === null) {
       return null
     }
 
-    return this.getThread(threadId)?.comments.find(comment => comment.id === commentId) ?? null
+    const comments = this.getThreadComments(threadId, includeDeleted)
+
+    return comments?.find(comment => comment.id === commentId) ?? null
   }
 
+  /**
+   * Adds a comment to a thread
+   * @param threadId The thread id
+   * @param data The comment data
+   * @returns The updated thread or null if the thread is not found
+   * @example addComment('123', { content: 'Hello world', data: { author: 'Maria Doe' } })
+   */
   addComment(threadId: TCollabThread['id'], data: Omit<TCollabComment, 'id' | 'updatedAt' | 'createdAt'>) {
     let updatedThread: TCollabThread = {} as TCollabThread
 
@@ -246,6 +393,14 @@ export class TiptapCollabProvider extends HocuspocusProvider {
     return updatedThread
   }
 
+  /**
+   * Update a comment in a thread
+   * @param threadId The thread id
+   * @param commentId The comment id
+   * @param data The new comment data
+   * @returns The updated thread or null if the thread or comment is not found
+   * @example updateComment('123', { content: 'The new content', data: { attachments: ['file1.jpg'] }})
+   */
   updateComment(threadId: TCollabThread['id'], commentId: TCollabComment['id'], data: Partial<Pick<TCollabComment, 'data' | 'content'>>) {
     let updatedThread: TCollabThread = {} as TCollabThread
 
@@ -281,7 +436,16 @@ export class TiptapCollabProvider extends HocuspocusProvider {
     return updatedThread
   }
 
-  deleteComment(threadId: TCollabThread['id'], commentId: TCollabComment['id']) {
+  /**
+   * Deletes a comment from a thread
+   * @param threadId The thread id
+   * @param commentId The comment id
+   * @param options A set of options that control how the comment is deleted
+   * @returns The updated thread or null if the thread or comment is not found
+   */
+  deleteComment(threadId: TCollabThread['id'], commentId: TCollabComment['id'], options: DeleteCommentOptions) {
+    const { deleteContent, deleteThread } = { ...defaultDeleteCommentOptions, ...options }
+
     const thread = this.getYThread(threadId)
 
     if (thread === null) return null
@@ -297,22 +461,39 @@ export class TiptapCollabProvider extends HocuspocusProvider {
 
     // if the first comment of a thread is deleted we also
     // delete the thread itself as the source comment is gone
-    if (commentIndex === 0) {
+    if (commentIndex === 0 && (deleteThread || (this.configuration as TiptapCollabProviderConfiguration).deleteThreadOnFirstCommentDelete)) {
       this.deleteThread(threadId)
       return
     }
 
-    if (commentIndex > 0) {
-      thread.get('comments').delete(commentIndex)
-    }
+    const comment = thread.get('comments').get(commentIndex)
+    const newComment = new Y.Map()
+
+    newComment.set('id', comment.get('id'))
+    newComment.set('createdAt', comment.get('createdAt'))
+    newComment.set('updatedAt', (new Date()).toISOString())
+    newComment.set('deletedAt', (new Date()).toISOString())
+    newComment.set('data', comment.get('data'))
+    newComment.set('content', deleteContent ? null : comment.get('content'))
+
+    thread.get('deletedComments').push([newComment])
+    thread.get('comments').delete(commentIndex)
 
     return thread.toJSON() as TCollabThread
   }
 
+  /**
+   * Start watching threads for changes
+   * @param callback The callback function to be called when a thread changes
+   */
   watchThreads(callback: () => void) {
     this.getYThreads().observeDeep(callback)
   }
 
+  /**
+   * Stop watching threads for changes
+   * @param callback The callback function to be removed
+   */
   unwatchThreads(callback: () => void) {
     this.getYThreads().unobserveDeep(callback)
   }

package/src/types.ts

@@ -110,15 +110,18 @@ export type TCollabThread<Data = any, CommentData = any> = {
   id: string;
   createdAt: number;
   updatedAt: number;
+  deletedAt: number | null;
   resolvedAt?: string; // (new Date()).toISOString()
   comments: TCollabComment<CommentData>[];
+  deletedComments: TCollabComment<CommentData>[];
   data: Data
 }
 
 export type TCollabComment<Data = any> = {
   id: string;
-  createdAt: number;
-  updatedAt: number;
+  createdAt: string;
+  updatedAt: string;
+  deletedAt?: string;
   data: Data
   content: any
 }
@@ -183,3 +186,46 @@ export type THistoryDocumentRevertedEvent = {
   event: 'document.reverted';
   version: number;
 };
+
+export type DeleteCommentOptions = {
+  /**
+   * If `true`, the thread will also be deleted if the deleted comment was the first comment in the thread.
+   */
+  deleteThread?: boolean
+
+  /**
+   * If `true`, will remove the content of the deleted comment
+   */
+  deleteContent?: boolean
+}
+
+export type DeleteThreadOptions = {
+  /**
+   * If `true`, will remove the comments on the thread,
+   * otherwise will only mark the thread as deleted
+   * and keep the comments
+   * @default false
+   */
+  deleteComments?: boolean
+
+  /**
+   * If `true`, will forcefully remove the thread and all comments,
+   * otherwise will only mark the thread as deleted
+   * and keep the comments
+   * @default false
+   */
+  force?: boolean,
+}
+
+/**
+ * The type of thread
+ */
+export type ThreadType = 'archived' | 'unarchived'
+
+export type GetThreadsOptions = {
+  /**
+   * The types of threads to get
+   * @default ['unarchived']
+   */
+  types?: Array<ThreadType>
+}