@blocknote/core 0.24.2 → 0.25.0

package/types/src/comments/threadstore/yjs/RESTYjsThreadStore.d.ts

@@ -0,0 +1,83 @@
+import * as Y from "yjs";
+import { CommentBody } from "../../types.js";
+import { ThreadStoreAuth } from "../ThreadStoreAuth.js";
+import { YjsThreadStoreBase } from "./YjsThreadStoreBase.js";
+/**
+ * This is a REST-based implementation of the YjsThreadStoreBase.
+ * It Reads data directly from the underlying document (same as YjsThreadStore),
+ * but for Writes, it sends data to a REST API that should:
+ * - check the user has the correct permissions to make the desired changes
+ * - apply the updates to the underlying Yjs document
+ *
+ * (see https://github.com/TypeCellOS/BlockNote-demo-nextjs-hocuspocus)
+ *
+ * The reason we still use the Yjs document as underlying storage is that it makes it easy to
+ * sync updates in real-time to other collaborators.
+ * (but technically, you could also implement a different storage altogether
+ * and not store the thread related data in the Yjs document)
+ */
+export declare class RESTYjsThreadStore extends YjsThreadStoreBase {
+    private readonly BASE_URL;
+    private readonly headers;
+    constructor(BASE_URL: string, headers: Record<string, string>, threadsYMap: Y.Map<any>, auth: ThreadStoreAuth);
+    private doRequest;
+    addThreadToDocument: (options: {
+        threadId: string;
+        selection: {
+            prosemirror: {
+                head: number;
+                anchor: number;
+            };
+            yjs: {
+                head: any;
+                anchor: any;
+            };
+        };
+    }) => Promise<any>;
+    createThread: (options: {
+        initialComment: {
+            body: CommentBody;
+            metadata?: any;
+        };
+        metadata?: any;
+    }) => Promise<any>;
+    addComment: (options: {
+        comment: {
+            body: CommentBody;
+            metadata?: any;
+        };
+        threadId: string;
+    }) => Promise<any>;
+    updateComment: (options: {
+        comment: {
+            body: CommentBody;
+            metadata?: any;
+        };
+        threadId: string;
+        commentId: string;
+    }) => Promise<any>;
+    deleteComment: (options: {
+        threadId: string;
+        commentId: string;
+        softDelete?: boolean;
+    }) => Promise<any>;
+    deleteThread: (options: {
+        threadId: string;
+    }) => Promise<any>;
+    resolveThread: (options: {
+        threadId: string;
+    }) => Promise<any>;
+    unresolveThread: (options: {
+        threadId: string;
+    }) => Promise<any>;
+    addReaction: (options: {
+        threadId: string;
+        commentId: string;
+        emoji: string;
+    }) => Promise<any>;
+    deleteReaction: (options: {
+        threadId: string;
+        commentId: string;
+        emoji: string;
+    }) => Promise<any>;
+}

package/types/src/comments/threadstore/yjs/YjsThreadStore.d.ts

@@ -0,0 +1,79 @@
+import * as Y from "yjs";
+import { CommentBody, ThreadData } from "../../types.js";
+import { ThreadStoreAuth } from "../ThreadStoreAuth.js";
+import { YjsThreadStoreBase } from "./YjsThreadStoreBase.js";
+/**
+ * This is a Yjs-based implementation of the ThreadStore interface.
+ *
+ * It reads and writes thread / comments information directly to the underlying Yjs Document.
+ *
+ * @important While this is the easiest to add to your app, there are two challenges:
+ * - The user needs to be able to write to the Yjs document to store the information.
+ *   So a user without write access to the Yjs document cannot leave any comments.
+ * - Even with write access, the operations are not secure. Unless your Yjs server
+ *   guards against malicious operations, it's technically possible for one user to make changes to another user's comments, etc.
+ *   (even though these options are not visible in the UI, a malicious user can make unauthorized changes to the underlying Yjs document)
+ */
+export declare class YjsThreadStore extends YjsThreadStoreBase {
+    private readonly userId;
+    constructor(userId: string, threadsYMap: Y.Map<any>, auth: ThreadStoreAuth);
+    private transact;
+    createThread: (options: {
+        initialComment: {
+            body: CommentBody;
+            metadata?: any;
+        };
+        metadata?: any;
+    }) => Promise<ThreadData>;
+    addThreadToDocument: undefined;
+    addComment: (options: {
+        comment: {
+            body: CommentBody;
+            metadata?: any;
+        };
+        threadId: string;
+    }) => Promise<{
+        type: "comment";
+        id: string;
+        userId: string;
+        createdAt: Date;
+        updatedAt: Date;
+        reactions: import("../../types.js").CommentReactionData[];
+        metadata: any;
+    } & {
+        deletedAt?: undefined;
+        body: any;
+    }>;
+    updateComment: (options: {
+        comment: {
+            body: CommentBody;
+            metadata?: any;
+        };
+        threadId: string;
+        commentId: string;
+    }) => Promise<void>;
+    deleteComment: (options: {
+        threadId: string;
+        commentId: string;
+        softDelete?: boolean | undefined;
+    }) => Promise<void>;
+    deleteThread: (options: {
+        threadId: string;
+    }) => Promise<void>;
+    resolveThread: (options: {
+        threadId: string;
+    }) => Promise<void>;
+    unresolveThread: (options: {
+        threadId: string;
+    }) => Promise<void>;
+    addReaction: (options: {
+        threadId: string;
+        commentId: string;
+        emoji: string;
+    }) => Promise<void>;
+    deleteReaction: (options: {
+        threadId: string;
+        commentId: string;
+        emoji: string;
+    }) => Promise<void>;
+}

package/types/src/comments/threadstore/yjs/YjsThreadStore.test.d.ts

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

package/types/src/comments/threadstore/yjs/YjsThreadStoreBase.d.ts

@@ -0,0 +1,15 @@
+import * as Y from "yjs";
+import { ThreadData } from "../../types.js";
+import { ThreadStore } from "../ThreadStore.js";
+import { ThreadStoreAuth } from "../ThreadStoreAuth.js";
+/**
+ * This is an abstract class that only implements the READ methods required by the ThreadStore interface.
+ * The data is read from a Yjs Map.
+ */
+export declare abstract class YjsThreadStoreBase extends ThreadStore {
+    protected readonly threadsYMap: Y.Map<any>;
+    constructor(threadsYMap: Y.Map<any>, auth: ThreadStoreAuth);
+    getThread(threadId: string): ThreadData;
+    getThreads(): Map<string, ThreadData>;
+    subscribe(cb: (threads: Map<string, ThreadData>) => void): () => void;
+}

package/types/src/comments/threadstore/yjs/yjsHelpers.d.ts

@@ -0,0 +1,13 @@
+import * as Y from "yjs";
+import { CommentData, ThreadData } from "../../types.js";
+export declare function commentToYMap(comment: CommentData): Y.Map<any>;
+export declare function threadToYMap(thread: ThreadData): Y.Map<unknown>;
+type SingleUserCommentReactionData = {
+    emoji: string;
+    createdAt: Date;
+    userId: string;
+};
+export declare function yMapToReaction(yMap: Y.Map<any>): SingleUserCommentReactionData;
+export declare function yMapToComment(yMap: Y.Map<any>): CommentData;
+export declare function yMapToThread(yMap: Y.Map<any>): ThreadData;
+export {};

package/types/src/comments/types.d.ts

@@ -0,0 +1,109 @@
+/**
+ * The body of a comment. This actually is a BlockNote document (array of blocks)
+ */
+export type CommentBody = any;
+/**
+ * A reaction to a comment.
+ */
+export type CommentReactionData = {
+    /**
+     * The emoji that was reacted to the comment.
+     */
+    emoji: string;
+    /**
+     * The date the first user reacted to the comment with this emoji.
+     */
+    createdAt: Date;
+    /**
+     * The user ids of the users that have reacted to the comment with this emoji
+     */
+    userIds: string[];
+};
+/**
+ * Information about a comment.
+ */
+export type CommentData = {
+    type: "comment";
+    /**
+     * The unique identifier for the comment.
+     */
+    id: string;
+    /**
+     * The user id of the author of the comment.
+     */
+    userId: string;
+    /**
+     * The date when the comment was created.
+     */
+    createdAt: Date;
+    /**
+     * The date when the comment was last updated.
+     */
+    updatedAt: Date;
+    /**
+     * The reactions (emoji reactions) to the comment.
+     */
+    reactions: CommentReactionData[];
+    /**
+     * You can use this store any additional information about the comment.
+     */
+    metadata: any;
+} & ({
+    /**
+     * The date when the comment was deleted. This applies only for "soft deletes",
+     * otherwise the comment is removed entirely.
+     */
+    deletedAt: Date;
+    /**
+     * The body of the comment is undefined if the comment is deleted.
+     */
+    body: undefined;
+} | {
+    /**
+     * In case of a non-deleted comment, this is not set
+     */
+    deletedAt?: never;
+    /**
+     * The body of the comment.
+     */
+    body: CommentBody;
+});
+/**
+ * Information about a thread. A thread holds a list of comments.
+ */
+export type ThreadData = {
+    type: "thread";
+    /**
+     * The unique identifier for the thread.
+     */
+    id: string;
+    /**
+     * The date when the thread was created.
+     */
+    createdAt: Date;
+    /**
+     * The date when the thread was last updated.
+     */
+    updatedAt: Date;
+    /**
+     * The comments in the thread.
+     */
+    comments: CommentData[];
+    /**
+     * Whether the thread has been marked as resolved.
+     */
+    resolved: boolean;
+    /**
+     * The date when the thread was marked as resolved.
+     */
+    resolvedUpdatedAt?: Date;
+    /**
+     * You can use this store any additional information about the thread.
+     */
+    metadata: any;
+    /**
+     * The date when the thread was deleted. (or undefined if it is not deleted)
+     * This only applies for "soft deletes", otherwise the thread is removed entirely.
+     */
+    deletedAt?: Date;
+};

package/types/src/editor/BlockNoteEditor.d.ts

@@ -2,6 +2,7 @@ import { AnyExtension, EditorOptions } from "@tiptap/core";
 import { Node, Schema } from "prosemirror-model";
 import * as Y from "yjs";
 import { Block, DefaultBlockSchema, DefaultInlineContentSchema, DefaultStyleSchema, PartialBlock } from "../blocks/defaultBlocks.js";
+import type { CommentsPlugin } from "../extensions/Comments/CommentsPlugin.js";
 import { FilePanelProsemirrorPlugin } from "../extensions/FilePanel/FilePanelPlugin.js";
 import { FormattingToolbarProsemirrorPlugin } from "../extensions/FormattingToolbar/FormattingToolbarPlugin.js";
 import { LinkToolbarProsemirrorPlugin } from "../extensions/LinkToolbar/LinkToolbarPlugin.js";
@@ -17,7 +18,9 @@ import { BlockNoteTipTapEditor } from "./BlockNoteTipTapEditor.js";
 import { Dictionary } from "../i18n/dictionary.js";
 import { Plugin, Transaction } from "@tiptap/pm/state";
 import { EditorView } from "prosemirror-view";
+import type { ThreadStore, User } from "../comments/index.js";
 import "../style.css";
+import { EventEmitter } from "../util/EventEmitter.js";
 export type BlockNoteExtensionFactory = (editor: BlockNoteEditor<any, any, any>) => BlockNoteExtension;
 export type BlockNoteExtension = AnyExtension | {
     plugin: Plugin;
@@ -29,51 +32,6 @@ export type BlockNoteEditorOptions<BSchema extends BlockSchema, ISchema extends
      * @default true
      */
     animations?: boolean;
-    /**
-     * Disable internal extensions (based on keys / extension name)
-     */
-    disableExtensions: string[];
-    /**
-     * A dictionary object containing translations for the editor.
-     */
-    dictionary?: Dictionary & Record<string, any>;
-    /**
-     * @deprecated, provide placeholders via dictionary instead
-     */
-    placeholders: Record<string | "default" | "emptyDocument", string | undefined>;
-    /**
-     * An object containing attributes that should be added to HTML elements of the editor.
-     *
-     * @example { editor: { class: "my-editor-class" } }
-     */
-    domAttributes: Partial<BlockNoteDOMAttributes>;
-    /**
-     * The content that should be in the editor when it's created, represented as an array of partial block objects.
-     */
-    initialContent: PartialBlock<NoInfer<BSchema>, NoInfer<ISchema>, NoInfer<SSchema>>[];
-    /**
-     * Use default BlockNote font and reset the styles of <p> <li> <h1> elements etc., that are used in BlockNote.
-     *
-     * @default true
-     */
-    defaultStyles: boolean;
-    schema: BlockNoteSchema<BSchema, ISchema, SSchema>;
-    /**
-     * The `uploadFile` method is what the editor uses when files need to be uploaded (for example when selecting an image to upload).
-     * This method should set when creating the editor as this is application-specific.
-     *
-     * `undefined` means the application doesn't support file uploads.
-     *
-     * @param file The file that should be uploaded.
-     * @returns The URL of the uploaded file OR an object containing props that should be set on the file block (such as an id)
-     */
-    uploadFile: (file: File, blockId?: string) => Promise<string | Record<string, any>>;
-    /**
-     * Resolve a URL of a file block to one that can be displayed or downloaded. This can be used for creating authenticated URL or
-     * implementing custom protocols / schemes
-     * @returns The URL that's
-     */
-    resolveFileUrl: (url: string) => Promise<string>;
     /**
      * When enabled, allows for collaboration between multiple users.
      */
@@ -105,23 +63,51 @@ export type BlockNoteEditorOptions<BSchema extends BlockSchema, ISchema extends
          */
         showCursorLabels?: "always" | "activity";
     };
+    comments: {
+        threadStore: ThreadStore;
+    };
     /**
-     * additional tiptap options, undocumented
+     * Use default BlockNote font and reset the styles of <p> <li> <h1> elements etc., that are used in BlockNote.
+     *
+     * @default true
      */
-    _tiptapOptions: Partial<EditorOptions>;
+    defaultStyles: boolean;
     /**
-     * (experimental) add extra prosemirror plugins or tiptap extensions to the editor
+     * A dictionary object containing translations for the editor.
      */
-    _extensions: Record<string, BlockNoteExtension | BlockNoteExtensionFactory>;
-    trailingBlock?: boolean;
+    dictionary?: Dictionary & Record<string, any>;
     /**
-     * Boolean indicating whether the editor is in headless mode.
-     * Headless mode means we can use features like importing / exporting blocks,
-     * but there's no underlying editor (UI) instantiated.
+     * Disable internal extensions (based on keys / extension name)
+     */
+    disableExtensions: string[];
+    /**
+     * An object containing attributes that should be added to HTML elements of the editor.
      *
-     * You probably don't need to set this manually, but use the `server-util` package instead that uses this option internally
+     * @example { editor: { class: "my-editor-class" } }
      */
-    _headless: boolean;
+    domAttributes: Partial<BlockNoteDOMAttributes>;
+    dropCursor?: (opts: {
+        editor: BlockNoteEditor<NoInfer<BSchema>, NoInfer<ISchema>, NoInfer<SSchema>>;
+        color?: string | false;
+        width?: number;
+        class?: string;
+    }) => Plugin;
+    /**
+     * The content that should be in the editor when it's created, represented as an array of partial block objects.
+     */
+    initialContent: PartialBlock<NoInfer<BSchema>, NoInfer<ISchema>, NoInfer<SSchema>>[];
+    /**
+     * @deprecated, provide placeholders via dictionary instead
+     */
+    placeholders: Record<string | "default" | "emptyDocument", string | undefined>;
+    /**
+     * Resolve a URL of a file block to one that can be displayed or downloaded. This can be used for creating authenticated URL or
+     * implementing custom protocols / schemes
+     * @returns The URL that's
+     */
+    resolveFileUrl: (url: string) => Promise<string>;
+    resolveUsers: (userIds: string[]) => Promise<User[]>;
+    schema: BlockNoteSchema<BSchema, ISchema, SSchema>;
     /**
      * A flag indicating whether to set an HTML ID for every block
      *
@@ -131,7 +117,14 @@ export type BlockNoteEditorOptions<BSchema extends BlockSchema, ISchema extends
      * (note that the id is always set on the `data-id` attribute)
      */
     setIdAttribute?: boolean;
-    dropCursor?: (opts: any) => Plugin;
+    /**
+     * The detection mode for showing the side menu - "viewport" always shows the
+     * side menu for the block next to the mouse cursor, while "editor" only shows
+     * it when hovering the editor or the side menu itself.
+     *
+     * @default "viewport"
+     */
+    sideMenuDetection: "viewport" | "editor";
     /**
      Select desired behavior when pressing `Tab` (or `Shift-Tab`). Specifically,
      what should happen when a user has selected multiple blocks while a toolbar
@@ -147,17 +140,70 @@ export type BlockNoteEditorOptions<BSchema extends BlockSchema, ISchema extends
      */
     tabBehavior: "prefer-navigate-ui" | "prefer-indent";
     /**
-     * The detection mode for showing the side menu - "viewport" always shows the
-     * side menu for the block next to the mouse cursor, while "editor" only shows
-     * it when hovering the editor or the side menu itself.
+     * Allows enabling / disabling features of tables.
+     */
+    tables?: {
+        /**
+         * Whether to allow splitting and merging cells within a table.
+         *
+         * @default false
+         */
+        splitCells?: boolean;
+        /**
+         * Whether to allow changing the background color of cells.
+         *
+         * @default false
+         */
+        cellBackgroundColor?: boolean;
+        /**
+         * Whether to allow changing the text color of cells.
+         *
+         * @default false
+         */
+        cellTextColor?: boolean;
+        /**
+         * Whether to allow changing cells into headers.
+         *
+         * @default false
+         */
+        headers?: boolean;
+    };
+    trailingBlock?: boolean;
+    /**
+     * The `uploadFile` method is what the editor uses when files need to be uploaded (for example when selecting an image to upload).
+     * This method should set when creating the editor as this is application-specific.
      *
-     * @default "viewport"
+     * `undefined` means the application doesn't support file uploads.
+     *
+     * @param file The file that should be uploaded.
+     * @returns The URL of the uploaded file OR an object containing props that should be set on the file block (such as an id)
      */
-    sideMenuDetection: "viewport" | "editor";
+    uploadFile: (file: File, blockId?: string) => Promise<string | Record<string, any>>;
+    /**
+     * additional tiptap options, undocumented
+     */
+    _tiptapOptions: Partial<EditorOptions>;
+    /**
+     * (experimental) add extra prosemirror plugins or tiptap extensions to the editor
+     */
+    _extensions: Record<string, BlockNoteExtension | BlockNoteExtensionFactory>;
+    /**
+     * Boolean indicating whether the editor is in headless mode.
+     * Headless mode means we can use features like importing / exporting blocks,
+     * but there's no underlying editor (UI) instantiated.
+     *
+     * You probably don't need to set this manually, but use the `server-util` package instead that uses this option internally
+     */
+    _headless: boolean;
 };
-export declare class BlockNoteEditor<BSchema extends BlockSchema = DefaultBlockSchema, ISchema extends InlineContentSchema = DefaultInlineContentSchema, SSchema extends StyleSchema = DefaultStyleSchema> {
+export declare class BlockNoteEditor<BSchema extends BlockSchema = DefaultBlockSchema, ISchema extends InlineContentSchema = DefaultInlineContentSchema, SSchema extends StyleSchema = DefaultStyleSchema> extends EventEmitter<{
+    create: void;
+}> {
     protected readonly options: Partial<BlockNoteEditorOptions<any, any, any>>;
-    private readonly _pmSchema;
+    /**
+     * The underlying prosemirror schema
+     */
+    readonly pmSchema: Schema;
     /**
      * extensions that are added to the editor, can be tiptap extensions or prosemirror plugins
      */
@@ -202,6 +248,8 @@ export declare class BlockNoteEditor<BSchema extends BlockSchema = DefaultBlockS
     readonly suggestionMenus: SuggestionMenuProseMirrorPlugin<BSchema, ISchema, SSchema>;
     readonly filePanel?: FilePanelProsemirrorPlugin<ISchema, SSchema>;
     readonly tableHandles?: TableHandlesProsemirrorPlugin<ISchema, SSchema>;
+    readonly comments?: CommentsPlugin;
+    private readonly showSelectionPlugin;
     /**
      * The `uploadFile` method is what the editor uses when files need to be uploaded (for example when selecting an image to upload).
      * This method should set when creating the editor as this is application-specific.
@@ -215,17 +263,35 @@ export declare class BlockNoteEditor<BSchema extends BlockSchema = DefaultBlockS
     private onUploadStartCallbacks;
     private onUploadEndCallbacks;
     readonly resolveFileUrl?: (url: string) => Promise<string>;
-    get pmSchema(): Schema<any, any>;
+    readonly resolveUsers?: (userIds: string[]) => Promise<User[]>;
+    /**
+     * Editor settings
+     */
+    readonly settings: {
+        tables: {
+            splitCells: boolean;
+            cellBackgroundColor: boolean;
+            cellTextColor: boolean;
+            headers: boolean;
+        };
+    };
     static create<BSchema extends BlockSchema = DefaultBlockSchema, ISchema extends InlineContentSchema = DefaultInlineContentSchema, SSchema extends StyleSchema = DefaultStyleSchema>(options?: Partial<BlockNoteEditorOptions<BSchema, ISchema, SSchema>>): BlockNoteEditor<BSchema, ISchema, SSchema>;
     protected constructor(options: Partial<BlockNoteEditorOptions<any, any, any>>);
-    dispatch(tr: Transaction): void;
+    dispatch: (tr: Transaction) => void;
     /**
      * Mount the editor to a parent DOM element. Call mount(undefined) to clean up
      *
      * @warning Not needed to call manually when using React, use BlockNoteView to take care of mounting
      */
     mount: (parentElement?: HTMLElement | null, contentComponent?: any) => void;
+    /**
+     * Get the underlying prosemirror view
+     */
     get prosemirrorView(): EditorView | undefined;
+    /**
+     * Get the underlying prosemirror state
+     */
+    get prosemirrorState(): import("prosemirror-state").EditorState;
     get domElement(): HTMLDivElement | undefined;
     isFocused(): boolean;
     focus(): void;
@@ -284,11 +350,15 @@ export declare class BlockNoteEditor<BSchema extends BlockSchema = DefaultBlockS
     /**
      * Executes a callback whenever the editor's contents change.
      * @param callback The callback to execute.
+     *
+     * @deprecated use `onChange` instead
      */
     onEditorContentChange(callback: () => void): void;
     /**
      * Executes a callback whenever the editor's selection changes.
      * @param callback The callback to execute.
+     *
+     * @deprecated use `onSelectionChange` instead
      */
     onEditorSelectionChange(callback: () => void): void;
     /**
@@ -479,9 +549,19 @@ export declare class BlockNoteEditor<BSchema extends BlockSchema = DefaultBlockS
      * @param callback The callback to execute.
      * @returns A function to remove the callback.
      */
-    onSelectionChange(callback: (editor: BlockNoteEditor<BSchema, ISchema, SSchema>) => void): (() => void) | undefined;
+    onSelectionChange(callback: (editor: BlockNoteEditor<BSchema, ISchema, SSchema>) => void, includeSelectionChangedByRemote?: boolean): (() => void) | undefined;
+    /**
+     * A callback function that runs when the editor has been initialized.
+     *
+     * This can be useful for plugins to initialize themselves after the editor has been initialized.
+     */
+    onCreate(callback: () => void): () => void;
+    getSelectionBoundingBox(): DOMRect | undefined;
+    get isEmpty(): boolean;
     openSuggestionMenu(triggerCharacter: string, pluginState?: {
         deleteTriggerCharacter?: boolean;
         ignoreQueryLength?: boolean;
     }): void;
+    getForceSelectionVisible(): boolean;
+    setForceSelectionVisible(forceSelectionVisible: boolean): void;
 }

package/types/src/editor/BlockNoteExtensions.d.ts

@@ -1,5 +1,6 @@
 import { Plugin } from "prosemirror-state";
 import * as Y from "yjs";
+import type { ThreadStore } from "../comments/index.js";
 import { BlockNoteDOMAttributes, BlockSchema, BlockSpecs, InlineContentSchema, InlineContentSpecs, StyleSchema, StyleSpecs } from "../schema/index.js";
 import type { BlockNoteEditor, BlockNoteExtension } from "./BlockNoteEditor.js";
 type ExtensionOptions<BSchema extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema> = {
@@ -28,6 +29,9 @@ type ExtensionOptions<BSchema extends BlockSchema, I extends InlineContentSchema
     placeholders: Record<string | "default" | "emptyDocument", string | undefined>;
     tabBehavior?: "prefer-navigate-ui" | "prefer-indent";
     sideMenuDetection: "viewport" | "editor";
+    comments?: {
+        threadStore: ThreadStore;
+    };
 };
 /**
  * Get all the Tiptap extensions BlockNote is configured with by default

package/types/src/extensions/Collaboration/createCollaborationExtensions.d.ts

@@ -9,7 +9,7 @@ export declare const createCollaborationExtensions: (collaboration: {
     provider: any;
     renderCursor?: (user: any) => HTMLElement;
     showCursorLabels?: "always" | "activity";
-}) => (import("@tiptap/core").Extension<import("@tiptap/extension-collaboration").CollaborationOptions, any> | import("@tiptap/core").Extension<import("@tiptap/extension-collaboration-cursor").CollaborationCursorOptions, {
+}) => (import("@tiptap/core").Extension<import("@tiptap/extension-collaboration").CollaborationOptions, import("@tiptap/extension-collaboration").CollaborationStorage> | import("@tiptap/core").Extension<import("@tiptap/extension-collaboration-cursor").CollaborationCursorOptions, {
     users: {
         [key: string]: any;
         clientId: number;

package/types/src/extensions/Comments/CommentMark.d.ts

@@ -0,0 +1,2 @@
+import { Mark } from "@tiptap/core";
+export declare const CommentMark: Mark<any, any>;