@blocknote/core 0.30.1 → 0.31.1

package/types/src/api/blockManipulation/commands/updateBlock/updateBlock.d.ts

@@ -1,4 +1,5 @@
 import type { Transaction } from "prosemirror-state";
+import { Transform } from "prosemirror-transform";
 import type { Block, PartialBlock } from "../../../../blocks/defaultBlocks.js";
 import type { BlockIdentifier, BlockSchema } from "../../../../schema/blocks/types.js";
 import type { InlineContentSchema } from "../../../../schema/inlineContent/types.js";
@@ -7,4 +8,5 @@ export declare const updateBlockCommand: <BSchema extends BlockSchema, I extends
     tr: Transaction;
     dispatch?: () => void;
 }) => boolean;
-export declare function updateBlock<BSchema extends BlockSchema = any, I extends InlineContentSchema = any, S extends StyleSchema = any>(tr: Transaction, blockToUpdate: BlockIdentifier, update: PartialBlock<BSchema, I, S>): Block<BSchema, I, S>;
+export declare function updateBlockTr<BSchema extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema>(tr: Transform, posBeforeBlock: number, block: PartialBlock<BSchema, I, S>, replaceFromPos?: number, replaceToPos?: number): void;
+export declare function updateBlock<BSchema extends BlockSchema = any, I extends InlineContentSchema = any, S extends StyleSchema = any>(tr: Transaction, blockToUpdate: BlockIdentifier, update: PartialBlock<BSchema, I, S>, replaceFromPos?: number, replaceToPos?: number): Block<BSchema, I, S>;

package/types/src/api/blockManipulation/selections/selection.d.ts

@@ -1,5 +1,15 @@
 import { type Transaction } from "prosemirror-state";
+import { Block } from "../../../blocks/defaultBlocks.js";
 import { Selection } from "../../../editor/selectionTypes.js";
 import { BlockIdentifier, BlockSchema, InlineContentSchema, StyleSchema } from "../../../schema/index.js";
 export declare function getSelection<BSchema extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema>(tr: Transaction): Selection<BSchema, I, S> | undefined;
 export declare function setSelection(tr: Transaction, startBlock: BlockIdentifier, endBlock: BlockIdentifier): void;
+export declare function getSelectionCutBlocks(tr: Transaction): {
+    blocks: Block<Record<string, import("../../../index.js").BlockConfig>, InlineContentSchema, StyleSchema>[];
+    blockCutAtStart: string | undefined;
+    blockCutAtEnd: string | undefined;
+    _meta: {
+        startPos: number;
+        endPos: number;
+    };
+};

package/types/src/api/blockManipulation/selections/{textCursorPosition/textCursorPosition.d.ts → textCursorPosition.d.ts}

@@ -1,5 +1,5 @@
 import { type Transaction } from "prosemirror-state";
-import type { TextCursorPosition } from "../../../../editor/cursorPositionTypes.js";
-import type { BlockIdentifier, BlockSchema, InlineContentSchema, StyleSchema } from "../../../../schema/index.js";
+import type { TextCursorPosition } from "../../../editor/cursorPositionTypes.js";
+import type { BlockIdentifier, BlockSchema, InlineContentSchema, StyleSchema } from "../../../schema/index.js";
 export declare function getTextCursorPosition<BSchema extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema>(tr: Transaction): TextCursorPosition<BSchema, I, S>;
 export declare function setTextCursorPosition(tr: Transaction, targetBlock: BlockIdentifier, placement?: "start" | "end"): void;

package/types/src/api/nodeConversions/nodeToBlock.d.ts

@@ -1,6 +1,6 @@
-import { Node, Schema } from "@tiptap/pm/model";
-import type { BlockSchema, InlineContent, InlineContentSchema, StyleSchema, TableContent } from "../../schema/index.js";
+import { Node, Schema, Slice } from "@tiptap/pm/model";
 import type { Block } from "../../blocks/defaultBlocks.js";
+import type { BlockSchema, InlineContent, InlineContentSchema, StyleSchema, TableContent } from "../../schema/index.js";
 /**
  * Converts an internal (prosemirror) table node contentto a BlockNote Tablecontent
  */
@@ -16,3 +16,40 @@ export declare function nodeToCustomInlineContent<I extends InlineContentSchema,
  * TODO: test changes
  */
 export declare function nodeToBlock<BSchema extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema>(node: Node, schema: Schema, blockSchema?: BSchema, inlineContentSchema?: I, styleSchema?: S, blockCache?: import("../../index.js").BlockCache<any, any, any>): Block<BSchema, I, S>;
+/**
+ * Convert a Prosemirror document to a BlockNote document (array of blocks)
+ */
+export declare function docToBlocks<BSchema extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema>(doc: Node, schema: Schema, blockSchema?: BSchema, inlineContentSchema?: I, styleSchema?: S, blockCache?: import("../../index.js").BlockCache<any, any, any>): Block<BSchema, I, S>[];
+/**
+ *
+ * Parse a Prosemirror Slice into a BlockNote selection. The prosemirror schema looks like this:
+ *
+ * <blockGroup>
+ *   <blockContainer> (main content of block)
+ *       <p, heading, etc.>
+ *   <blockGroup> (only if blocks has children)
+ *     <blockContainer> (child block)
+ *       <p, heading, etc.>
+ *     </blockContainer>
+ *    <blockContainer> (child block 2)
+ *       <p, heading, etc.>
+ *     </blockContainer>
+ *   </blockContainer>
+ *  </blockGroup>
+ * </blockGroup>
+ *
+ */
+export declare function prosemirrorSliceToSlicedBlocks<BSchema extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema>(slice: Slice, schema: Schema, blockSchema?: BSchema, inlineContentSchema?: I, styleSchema?: S, blockCache?: WeakMap<Node, Block<BSchema, I, S>>): {
+    /**
+     * The blocks that are included in the selection.
+     */
+    blocks: Block<BSchema, I, S>[];
+    /**
+     * If a block was "cut" at the start of the selection, this will be the id of the block that was cut.
+     */
+    blockCutAtStart: string | undefined;
+    /**
+     * If a block was "cut" at the end of the selection, this will be the id of the block that was cut.
+     */
+    blockCutAtEnd: string | undefined;
+};

package/types/src/api/pmUtil.d.ts

@@ -1,10 +1,10 @@
 import type { Node, Schema } from "prosemirror-model";
-import type { Transaction } from "prosemirror-state";
+import { Transform } from "prosemirror-transform";
+import { BlockNoteSchema } from "../editor/BlockNoteSchema.js";
 import type { BlockSchema } from "../schema/blocks/types.js";
 import type { InlineContentSchema } from "../schema/inlineContent/types.js";
 import type { StyleSchema } from "../schema/styles/types.js";
-import { BlockNoteSchema } from "../editor/BlockNoteSchema.js";
-export declare function getPmSchema(trOrNode: Transaction | Node): Schema<any, any>;
+export declare function getPmSchema(trOrNode: Transform | Node): Schema<any, any>;
 export declare function getBlockNoteSchema<BSchema extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema>(schema: Schema): BlockNoteSchema<BSchema, I, S>;
 export declare function getBlockSchema<BSchema extends BlockSchema>(schema: Schema): BSchema;
 export declare function getInlineContentSchema<I extends InlineContentSchema>(schema: Schema): I;

package/types/src/blocks/TableBlockContent/TableBlockContent.d.ts

@@ -1,14 +1,22 @@
+import { Node } from "@tiptap/core";
 export declare const tablePropSchema: {
     textColor: {
         default: "default";
     };
 };
-export declare const TableBlockContent: import("@tiptap/core").Node<any, any> & {
+export declare const TableBlockContent: Node<any, any> & {
     name: "table";
     config: {
         content: "tableRow+";
     };
 };
+/**
+ * This extension allows you to create table rows.
+ * @see https://www.tiptap.dev/api/nodes/table-row
+ */
+export declare const TableRow: Node<{
+    HTMLAttributes: Record<string, any>;
+}, any>;
 export declare const Table: {
     config: {
         type: "table";

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

@@ -21,13 +21,20 @@ import { EditorView } from "prosemirror-view";
 import { BlocksChanged } from "../api/nodeUtil.js";
 import { CodeBlockOptions } from "../blocks/CodeBlockContent/CodeBlockContent.js";
 import type { ThreadStore, User } from "../comments/index.js";
-import "../style.css";
+import type { ForkYDocPlugin } from "../extensions/Collaboration/ForkYDocPlugin.js";
 import { EventEmitter } from "../util/EventEmitter.js";
+import { BlockNoteExtension } from "./BlockNoteExtension.js";
+import "../style.css";
+/**
+ * A factory function that returns a BlockNoteExtension
+ * This is useful so we can create extensions that require an editor instance
+ * in the constructor
+ */
 export type BlockNoteExtensionFactory = (editor: BlockNoteEditor<any, any, any>) => BlockNoteExtension;
-export type BlockNoteExtension = AnyExtension | {
-    plugin: Plugin;
-    priority?: number;
-};
+/**
+ * We support Tiptap extensions and BlockNoteExtension based extensions
+ */
+export type SupportedExtension = AnyExtension | BlockNoteExtension;
 export type BlockCache<BSchema extends BlockSchema = any, ISchema extends InlineContentSchema = any, SSchema extends StyleSchema = any> = WeakMap<Node, Block<BSchema, ISchema, SSchema>>;
 export type BlockNoteEditorOptions<BSchema extends BlockSchema, ISchema extends InlineContentSchema, SSchema extends StyleSchema> = {
     /**
@@ -224,9 +231,21 @@ export type BlockNoteEditorOptions<BSchema extends BlockSchema, ISchema extends
      */
     _tiptapOptions: Partial<EditorOptions>;
     /**
-     * (experimental) add extra prosemirror plugins or tiptap extensions to the editor
+     * (experimental) add extra extensions to the editor
+     *
+     * @deprecated, should use `extensions` instead
+     */
+    _extensions: Record<string, {
+        plugin: Plugin;
+        priority?: number;
+    } | ((editor: BlockNoteEditor<any, any, any>) => {
+        plugin: Plugin;
+        priority?: number;
+    })>;
+    /**
+     * Register
      */
-    _extensions: Record<string, BlockNoteExtension | BlockNoteExtensionFactory>;
+    extensions: Array<BlockNoteExtension | BlockNoteExtensionFactory>;
     /**
      * Boolean indicating whether the editor is in headless mode.
      * Headless mode means we can use features like importing / exporting blocks,
@@ -247,7 +266,7 @@ export declare class BlockNoteEditor<BSchema extends BlockSchema = DefaultBlockS
     /**
      * extensions that are added to the editor, can be tiptap extensions or prosemirror plugins
      */
-    readonly extensions: Record<string, BlockNoteExtension>;
+    extensions: Record<string, SupportedExtension>;
     /**
      * Boolean indicating whether the editor is in headless mode.
      * Headless mode means we can use features like importing / exporting blocks,
@@ -290,7 +309,10 @@ export declare class BlockNoteEditor<BSchema extends BlockSchema = DefaultBlockS
     readonly tableHandles?: TableHandlesProsemirrorPlugin<ISchema, SSchema>;
     readonly comments?: CommentsPlugin;
     private readonly showSelectionPlugin;
-    private readonly cursorPlugin;
+    /**
+     * The plugin for forking a document, only defined if in collaboration mode
+     */
+    readonly forkYDocPlugin?: ForkYDocPlugin;
     /**
      * 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.
@@ -374,6 +396,17 @@ export declare class BlockNoteEditor<BSchema extends BlockSchema = DefaultBlockS
      * If another `transact` call is made within the callback, it will be passed the same transaction as the parent call.
      */
     tr: Transaction) => T): T;
+    /**
+     * Shorthand to get a typed extension from the editor, by
+     * just passing in the extension class.
+     *
+     * @param ext - The extension class to get
+     * @param key - optional, the key of the extension in the extensions object (defaults to the extension name)
+     * @returns The extension instance
+     */
+    extension<T extends BlockNoteExtension>(ext: {
+        new (...args: any[]): T;
+    } & typeof BlockNoteExtension, key?: string): T;
     /**
      * Mount the editor to a parent DOM element. Call mount(undefined) to clean up
      *
@@ -473,9 +506,28 @@ export declare class BlockNoteEditor<BSchema extends BlockSchema = DefaultBlockS
      */
     setTextCursorPosition(targetBlock: BlockIdentifier, placement?: "start" | "end"): void;
     /**
-     * Gets a snapshot of the current selection.
+     * Gets a snapshot of the current selection. This contains all blocks (included nested blocks)
+     * that the selection spans across.
+     *
+     * If the selection starts / ends halfway through a block, the returned data will contain the entire block.
      */
     getSelection(): Selection<BSchema, ISchema, SSchema> | undefined;
+    /**
+     * Gets a snapshot of the current selection. This contains all blocks (included nested blocks)
+     * that the selection spans across.
+     *
+     * If the selection starts / ends halfway through a block, the returned block will be
+     * only the part of the block that is included in the selection.
+     */
+    getSelectionCutBlocks(): {
+        blocks: Block<Record<string, import("../index.js").BlockConfig>, InlineContentSchema, StyleSchema>[];
+        blockCutAtStart: string | undefined;
+        blockCutAtEnd: string | undefined;
+        _meta: {
+            startPos: number;
+            endPos: number;
+        };
+    };
     /**
      * Sets the selection to a range of blocks.
      * @param startBlock The identifier of the block that should be the start of the selection.

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

@@ -0,0 +1,9 @@
+import { Plugin } from "prosemirror-state";
+import { EventEmitter } from "../util/EventEmitter.js";
+export declare abstract class BlockNoteExtension<TEvent extends Record<string, any> = any> extends EventEmitter<TEvent> {
+    static key(): string;
+    protected addProsemirrorPlugin(plugin: Plugin): void;
+    readonly plugins: Plugin[];
+    get priority(): number | undefined;
+    constructor(..._args: any[]);
+}

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

@@ -2,7 +2,7 @@ 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, BlockNoteEditorOptions, BlockNoteExtension } from "./BlockNoteEditor.js";
+import type { BlockNoteEditor, BlockNoteEditorOptions, SupportedExtension } from "./BlockNoteEditor.js";
 type ExtensionOptions<BSchema extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema> = {
     editor: BlockNoteEditor<BSchema, I, S>;
     domAttributes: Partial<BlockNoteDOMAttributes>;
@@ -37,5 +37,5 @@ type ExtensionOptions<BSchema extends BlockSchema, I extends InlineContentSchema
 /**
  * Get all the Tiptap extensions BlockNote is configured with by default
  */
-export declare const getBlockNoteExtensions: <BSchema extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema>(opts: ExtensionOptions<BSchema, I, S>) => Record<string, BlockNoteExtension>;
+export declare const getBlockNoteExtensions: <BSchema extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema>(opts: ExtensionOptions<BSchema, I, S>) => Record<string, SupportedExtension>;
 export {};

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

@@ -1,5 +1,4 @@
-import { Editor, EditorOptions } from "@tiptap/core";
-import { Editor as TiptapEditor } from "@tiptap/core";
+import { Editor, EditorOptions, Editor as TiptapEditor } from "@tiptap/core";
 import { EditorState, Transaction } from "@tiptap/pm/state";
 import { PartialBlock } from "../blocks/defaultBlocks.js";
 import { StyleSchema } from "../schema/index.js";
@@ -17,6 +16,7 @@ export declare class BlockNoteTipTapEditor extends TiptapEditor {
     protected constructor(options: BlockNoteTipTapEditorOptions, styleSchema: StyleSchema);
     get state(): EditorState;
     dispatch(transaction: Transaction): void;
+    forceEnablePlugins(): void;
     /**
      * Replace the default `createView` method with a custom one - which we call on mount
      */

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

@@ -1,14 +1,14 @@
-import { Plugin } from "prosemirror-state";
 import { Awareness } from "y-protocols/awareness.js";
 import * as Y from "yjs";
+import { BlockNoteExtension } from "../../editor/BlockNoteExtension.js";
 export type CollaborationUser = {
     name: string;
     color: string;
     [key: string]: string;
 };
-export declare class CursorPlugin {
+export declare class CursorPlugin extends BlockNoteExtension {
     private collaboration;
-    plugin: Plugin;
+    static key(): string;
     private provider;
     private recentlyUpdatedCursors;
     constructor(collaboration: {

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

@@ -0,0 +1,41 @@
+import { BlockNoteEditor, BlockNoteEditorOptions } from "../../editor/BlockNoteEditor.js";
+import { BlockNoteExtension } from "../../editor/BlockNoteExtension.js";
+export declare class ForkYDocPlugin extends BlockNoteExtension<{
+    forked: boolean;
+}> {
+    static key(): string;
+    private editor;
+    private collaboration;
+    constructor({ editor, collaboration, }: {
+        editor: BlockNoteEditor<any, any, any>;
+        collaboration: BlockNoteEditorOptions<any, any, any>["collaboration"];
+    });
+    /**
+     * To find a fragment in another ydoc, we need to search for it.
+     */
+    private findTypeInOtherYdoc;
+    /**
+     * Whether the editor is editing a forked document,
+     * preserving a reference to the original document and the forked document.
+     */
+    get isForkedFromRemote(): boolean;
+    /**
+     * Stores whether the editor is editing a forked document,
+     * preserving a reference to the original document and the forked document.
+     */
+    private forkedState;
+    /**
+     * Fork the Y.js document from syncing to the remote,
+     * allowing modifications to the document without affecting the remote.
+     * These changes can later be rolled back or applied to the remote.
+     */
+    fork(): void;
+    /**
+     * Resume syncing the Y.js document to the remote
+     * If `keepChanges` is true, any changes that have been made to the forked document will be applied to the original document.
+     * Otherwise, the original document will be restored and the changes will be discarded.
+     */
+    merge({ keepChanges }: {
+        keepChanges: boolean;
+    }): void;
+}

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

@@ -1,7 +1,7 @@
-import { Plugin } from "prosemirror-state";
 import type * as Y from "yjs";
-export declare class SyncPlugin {
-    plugin: Plugin;
+import { BlockNoteExtension } from "../../editor/BlockNoteExtension.js";
+export declare class SyncPlugin extends BlockNoteExtension {
+    static key(): string;
     constructor(fragment: Y.XmlFragment);
     get priority(): number;
 }

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

@@ -1,6 +1,6 @@
-import { Plugin } from "prosemirror-state";
-export declare class UndoPlugin {
-    plugin: Plugin;
+import { BlockNoteExtension } from "../../editor/BlockNoteExtension.js";
+export declare class UndoPlugin extends BlockNoteExtension {
+    static key(): string;
     constructor();
     get priority(): number;
 }

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

@@ -1,13 +1,12 @@
-import { Plugin } from "prosemirror-state";
 import type { CommentBody, ThreadStore, User } from "../../comments/index.js";
 import { BlockNoteEditor } from "../../editor/BlockNoteEditor.js";
-import { EventEmitter } from "../../util/EventEmitter.js";
+import { BlockNoteExtension } from "../../editor/BlockNoteExtension.js";
 import { UserStore } from "./userstore/UserStore.js";
-export declare class CommentsPlugin extends EventEmitter<any> {
+export declare class CommentsPlugin extends BlockNoteExtension {
     private readonly editor;
     readonly threadStore: ThreadStore;
     private readonly markType;
-    readonly plugin: Plugin;
+    static key(): string;
     readonly userStore: UserStore<User>;
     /**
      * Whether a comment is currently being composed

package/types/src/extensions/FilePanel/FilePanelPlugin.d.ts

@@ -1,9 +1,9 @@
-import { EditorState, Plugin, PluginKey, PluginView } from "prosemirror-state";
+import { EditorState, PluginKey, PluginView } from "prosemirror-state";
 import { EditorView } from "prosemirror-view";
 import type { BlockNoteEditor } from "../../editor/BlockNoteEditor.js";
+import { BlockNoteExtension } from "../../editor/BlockNoteExtension.js";
 import { UiElementPosition } from "../../extensions-shared/UiElementPosition.js";
 import type { BlockFromConfig, FileBlockConfig, InlineContentSchema, StyleSchema } from "../../schema/index.js";
-import { EventEmitter } from "../../util/EventEmitter.js";
 export type FilePanelState<I extends InlineContentSchema, S extends StyleSchema> = UiElementPosition & {
     block: BlockFromConfig<FileBlockConfig, I, S>;
 };
@@ -21,9 +21,9 @@ export declare class FilePanelView<I extends InlineContentSchema, S extends Styl
     closeMenu: () => void;
     destroy(): void;
 }
-export declare class FilePanelProsemirrorPlugin<I extends InlineContentSchema, S extends StyleSchema> extends EventEmitter<any> {
+export declare class FilePanelProsemirrorPlugin<I extends InlineContentSchema, S extends StyleSchema> extends BlockNoteExtension {
+    static key(): string;
     private view;
-    readonly plugin: Plugin;
     constructor(editor: BlockNoteEditor<Record<string, FileBlockConfig>, I, S>);
     get shown(): boolean;
     onUpdate(callback: (state: FilePanelState<I, S>) => void): () => void;

package/types/src/extensions/FormattingToolbar/FormattingToolbarPlugin.d.ts

@@ -1,9 +1,9 @@
-import { EditorState, Plugin, PluginKey, PluginView } from "prosemirror-state";
+import { EditorState, PluginKey, PluginView } from "prosemirror-state";
 import { EditorView } from "prosemirror-view";
 import type { BlockNoteEditor } from "../../editor/BlockNoteEditor.js";
+import { BlockNoteExtension } from "../../editor/BlockNoteExtension.js";
 import { UiElementPosition } from "../../extensions-shared/UiElementPosition.js";
 import { BlockSchema, InlineContentSchema, StyleSchema } from "../../schema/index.js";
-import { EventEmitter } from "../../util/EventEmitter.js";
 export type FormattingToolbarState = UiElementPosition;
 export declare class FormattingToolbarView implements PluginView {
     private readonly editor;
@@ -20,7 +20,8 @@ export declare class FormattingToolbarView implements PluginView {
     }) => boolean;
     constructor(editor: BlockNoteEditor<BlockSchema, InlineContentSchema, StyleSchema>, pmView: EditorView, emitUpdate: (state: FormattingToolbarState) => void);
     blurHandler: (event: FocusEvent) => void;
-    viewMousedownHandler: () => void;
+    isElementWithinEditorWrapper: (element: Node | null) => boolean;
+    viewMousedownHandler: (e: MouseEvent) => void;
     mouseupHandler: () => void;
     dragHandler: () => void;
     scrollHandler: () => void;
@@ -30,9 +31,9 @@ export declare class FormattingToolbarView implements PluginView {
     getSelectionBoundingBox(): DOMRect;
 }
 export declare const formattingToolbarPluginKey: PluginKey<any>;
-export declare class FormattingToolbarProsemirrorPlugin extends EventEmitter<any> {
+export declare class FormattingToolbarProsemirrorPlugin extends BlockNoteExtension {
+    static key(): string;
     private view;
-    readonly plugin: Plugin;
     constructor(editor: BlockNoteEditor<any, any, any>);
     get shown(): boolean;
     onUpdate(callback: (state: FormattingToolbarState) => void): () => void;

package/types/src/extensions/LinkToolbar/LinkToolbarPlugin.d.ts

@@ -1,16 +1,16 @@
-import { Plugin, PluginKey } from "prosemirror-state";
+import { PluginKey } from "prosemirror-state";
 import type { BlockNoteEditor } from "../../editor/BlockNoteEditor.js";
+import { BlockNoteExtension } from "../../editor/BlockNoteExtension.js";
 import { UiElementPosition } from "../../extensions-shared/UiElementPosition.js";
 import { BlockSchema, InlineContentSchema, StyleSchema } from "../../schema/index.js";
-import { EventEmitter } from "../../util/EventEmitter.js";
 export type LinkToolbarState = UiElementPosition & {
     url: string;
     text: string;
 };
 export declare const linkToolbarPluginKey: PluginKey<any>;
-export declare class LinkToolbarProsemirrorPlugin<BSchema extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema> extends EventEmitter<any> {
+export declare class LinkToolbarProsemirrorPlugin<BSchema extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema> extends BlockNoteExtension {
+    static key(): string;
     private view;
-    readonly plugin: Plugin;
     constructor(editor: BlockNoteEditor<BSchema, I, S>);
     onUpdate(callback: (state: LinkToolbarState) => void): () => void;
     /**

package/types/src/extensions/NodeSelectionKeyboard/NodeSelectionKeyboardPlugin.d.ts

@@ -1,5 +1,5 @@
-import { Plugin } from "prosemirror-state";
-export declare class NodeSelectionKeyboardPlugin {
-    readonly plugin: Plugin;
+import { BlockNoteExtension } from "../../editor/BlockNoteExtension.js";
+export declare class NodeSelectionKeyboardPlugin extends BlockNoteExtension {
+    static key(): string;
     constructor();
 }

package/types/src/extensions/Placeholder/PlaceholderPlugin.d.ts

@@ -1,6 +1,6 @@
-import { Plugin } from "prosemirror-state";
 import type { BlockNoteEditor } from "../../editor/BlockNoteEditor.js";
-export declare class PlaceholderPlugin {
-    readonly plugin: Plugin;
+import { BlockNoteExtension } from "../../editor/BlockNoteExtension.js";
+export declare class PlaceholderPlugin extends BlockNoteExtension {
+    static key(): string;
     constructor(editor: BlockNoteEditor<any, any, any>, placeholders: Record<string | "default" | "emptyDocument", string | undefined>);
 }

package/types/src/extensions/PreviousBlockType/PreviousBlockTypePlugin.d.ts

@@ -1,4 +1,4 @@
-import { Plugin } from "prosemirror-state";
+import { BlockNoteExtension } from "../../editor/BlockNoteExtension.js";
 /**
  * This plugin tracks transformation of Block node attributes, so we can support CSS transitions.
  *
@@ -7,7 +7,7 @@ import { Plugin } from "prosemirror-state";
  *
  * Solution: When attributes change on a node, this plugin sets a data-* attribute with the "previous" value. This way we can still use CSS transitions. (See block.module.css)
  */
-export declare class PreviousBlockTypePlugin {
-    readonly plugin: Plugin;
+export declare class PreviousBlockTypePlugin extends BlockNoteExtension {
+    static key(): string;
     constructor();
 }

package/types/src/extensions/ShowSelection/ShowSelectionPlugin.d.ts

@@ -1,13 +1,13 @@
-import { Plugin } from "prosemirror-state";
 import { BlockNoteEditor } from "../../editor/BlockNoteEditor.js";
+import { BlockNoteExtension } from "../../editor/BlockNoteExtension.js";
 /**
  * Plugin that shows adds a decoration around the current selection
  * This can be used to highlight the current selection in the UI even when the
  * text editor is not focused.
  */
-export declare class ShowSelectionPlugin {
+export declare class ShowSelectionPlugin extends BlockNoteExtension {
     private readonly editor;
-    readonly plugin: Plugin;
+    static key(): string;
     private enabled;
     constructor(editor: BlockNoteEditor<any, any, any>);
     setEnabled(enabled: boolean): void;

package/types/src/extensions/SideMenu/SideMenuPlugin.d.ts

@@ -1,10 +1,10 @@
-import { EditorState, Plugin, PluginKey, PluginView } from "@tiptap/pm/state";
+import { EditorState, PluginKey, PluginView } from "@tiptap/pm/state";
 import { EditorView } from "@tiptap/pm/view";
 import { Block } from "../../blocks/defaultBlocks.js";
 import type { BlockNoteEditor } from "../../editor/BlockNoteEditor.js";
+import { BlockNoteExtension } from "../../editor/BlockNoteExtension.js";
 import { UiElementPosition } from "../../extensions-shared/UiElementPosition.js";
 import { BlockSchema, InlineContentSchema, StyleSchema } from "../../schema/index.js";
-import { EventEmitter } from "../../util/EventEmitter.js";
 export type SideMenuState<BSchema extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema> = UiElementPosition & {
     block: Block<BSchema, I, S>;
 };
@@ -59,10 +59,10 @@ export declare class SideMenuView<BSchema extends BlockSchema, I extends InlineC
     destroy(): void;
 }
 export declare const sideMenuPluginKey: PluginKey<any>;
-export declare class SideMenuProsemirrorPlugin<BSchema extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema> extends EventEmitter<any> {
+export declare class SideMenuProsemirrorPlugin<BSchema extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema> extends BlockNoteExtension {
     private readonly editor;
+    static key(): string;
     view: SideMenuView<BSchema, I, S> | undefined;
-    readonly plugin: Plugin;
     constructor(editor: BlockNoteEditor<BSchema, I, S>, sideMenuDetection: "viewport" | "editor");
     onUpdate(callback: (state: SideMenuState<BSchema, I, S>) => void): () => void;
     /**

package/types/src/extensions/SuggestionMenu/SuggestionPlugin.d.ts

@@ -1,8 +1,7 @@
-import { Plugin } from "prosemirror-state";
 import type { BlockNoteEditor } from "../../editor/BlockNoteEditor.js";
+import { BlockNoteExtension } from "../../editor/BlockNoteExtension.js";
 import { UiElementPosition } from "../../extensions-shared/UiElementPosition.js";
 import { BlockSchema, InlineContentSchema, StyleSchema } from "../../schema/index.js";
-import { EventEmitter } from "../../util/EventEmitter.js";
 export type SuggestionMenuState = UiElementPosition & {
     query: string;
     ignoreQueryLength?: boolean;
@@ -17,9 +16,9 @@ export type SuggestionMenuState = UiElementPosition & {
  * - This version hides some unnecessary complexity from the user of the plugin.
  * - This version handles key events differently
  */
-export declare class SuggestionMenuProseMirrorPlugin<BSchema extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema> extends EventEmitter<any> {
+export declare class SuggestionMenuProseMirrorPlugin<BSchema extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema> extends BlockNoteExtension {
+    static key(): string;
     private view;
-    readonly plugin: Plugin;
     private triggerCharacters;
     constructor(editor: BlockNoteEditor<BSchema, I, S>);
     onUpdate(triggerCharacter: string, callback: (state: SuggestionMenuState) => void): () => void;

package/types/src/extensions/Suggestions/SuggestionMarks.d.ts

@@ -0,0 +1,4 @@
+import { Mark } from "@tiptap/core";
+export declare const SuggestionAddMark: Mark<any, any>;
+export declare const SuggestionDeleteMark: Mark<any, any>;
+export declare const SuggestionModificationMark: Mark<any, any>;

package/types/src/extensions/TableHandles/TableHandlesPlugin.d.ts

@@ -1,10 +1,10 @@
-import { Plugin, PluginKey, PluginView } from "prosemirror-state";
+import { PluginKey, PluginView } from "prosemirror-state";
 import { EditorView } from "prosemirror-view";
 import { RelativeCellIndices } from "../../api/blockManipulation/tables/tables.js";
 import { DefaultBlockSchema } from "../../blocks/defaultBlocks.js";
 import type { BlockNoteEditor } from "../../editor/BlockNoteEditor.js";
+import { BlockNoteExtension } from "../../editor/BlockNoteExtension.js";
 import { BlockFromConfigNoChildren, BlockSchemaWithBlock, InlineContentSchema, StyleSchema } from "../../schema/index.js";
-import { EventEmitter } from "../../util/EventEmitter.js";
 export type TableHandlesState<I extends InlineContentSchema, S extends StyleSchema> = {
     show: boolean;
     showAddOrRemoveRowsButton: boolean;
@@ -42,10 +42,10 @@ export declare class TableHandlesView<I extends InlineContentSchema, S extends S
     destroy(): void;
 }
 export declare const tableHandlesPluginKey: PluginKey<any>;
-export declare class TableHandlesProsemirrorPlugin<I extends InlineContentSchema, S extends StyleSchema> extends EventEmitter<any> {
+export declare class TableHandlesProsemirrorPlugin<I extends InlineContentSchema, S extends StyleSchema> extends BlockNoteExtension {
     private readonly editor;
+    static key(): string;
     private view;
-    readonly plugin: Plugin;
     constructor(editor: BlockNoteEditor<BlockSchemaWithBlock<"table", DefaultBlockSchema["table"]>, I, S>);
     onUpdate(callback: (state: TableHandlesState<I, S>) => void): () => void;
     /**
@@ -138,9 +138,9 @@ export declare class TableHandlesProsemirrorPlugin<I extends InlineContentSchema
      */
     getMergeDirection: (block: BlockFromConfigNoChildren<DefaultBlockSchema["table"], any, any> | undefined) => "vertical" | "horizontal" | undefined;
     cropEmptyRowsOrColumns: (block: BlockFromConfigNoChildren<DefaultBlockSchema["table"], any, any>, removeEmpty: "columns" | "rows") => {
-        cells: (import("../../index.js").StyledText<any> | import("../../index.js").Link<any> | import("../../index.js").CustomInlineContentFromConfig<any, any>)[][] | import("../../index.js").TableCell<any, any>[];
+        cells: (import("../../index.js").CustomInlineContentFromConfig<any, any> | import("../../index.js").StyledText<any> | import("../../index.js").Link<any>)[][] | import("../../index.js").TableCell<any, any>[];
     }[];
     addRowsOrColumns: (block: BlockFromConfigNoChildren<DefaultBlockSchema["table"], any, any>, addType: "columns" | "rows", numToAdd: number) => {
-        cells: (import("../../index.js").StyledText<any> | import("../../index.js").Link<any> | import("../../index.js").CustomInlineContentFromConfig<any, any>)[][] | import("../../index.js").TableCell<any, any>[];
+        cells: (import("../../index.js").CustomInlineContentFromConfig<any, any> | import("../../index.js").StyledText<any> | import("../../index.js").Link<any>)[][] | import("../../index.js").TableCell<any, any>[];
     }[];
 }