@blocknote/core 0.42.2 → 0.43.0

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

@@ -1,38 +1,20 @@
-import { AnyExtension, EditorOptions, FocusPosition, Editor as TiptapEditor } from "@tiptap/core";
+import { EditorOptions, FocusPosition, Editor as TiptapEditor } from "@tiptap/core";
 import { type Command, type Plugin, type Transaction } from "@tiptap/pm/state";
 import { Node, Schema } from "prosemirror-model";
 import * as Y from "yjs";
 import type { BlocksChanged } from "../api/getBlocksChangedByTransaction.js";
 import { Block, BlockNoteSchema, DefaultBlockSchema, DefaultInlineContentSchema, DefaultStyleSchema, PartialBlock } from "../blocks/index.js";
-import type { ThreadStore, User } from "../comments/index.js";
-import type { CommentsPlugin } from "../extensions/Comments/CommentsPlugin.js";
-import type { FilePanelProsemirrorPlugin } from "../extensions/FilePanel/FilePanelPlugin.js";
-import type { FormattingToolbarProsemirrorPlugin } from "../extensions/FormattingToolbar/FormattingToolbarPlugin.js";
-import type { LinkToolbarProsemirrorPlugin } from "../extensions/LinkToolbar/LinkToolbarPlugin.js";
-import type { ShowSelectionPlugin } from "../extensions/ShowSelection/ShowSelectionPlugin.js";
-import type { SideMenuProsemirrorPlugin } from "../extensions/SideMenu/SideMenuPlugin.js";
-import type { SuggestionMenuProseMirrorPlugin } from "../extensions/SuggestionMenu/SuggestionPlugin.js";
-import type { TableHandlesProsemirrorPlugin } from "../extensions/TableHandles/TableHandlesPlugin.js";
 import type { Dictionary } from "../i18n/dictionary.js";
 import type { BlockIdentifier, BlockNoteDOMAttributes, BlockSchema, BlockSpecs, CustomBlockNoteSchema, InlineContentSchema, InlineContentSpecs, PartialInlineContent, Styles, StyleSchema, StyleSpecs } from "../schema/index.js";
+import "../style.css";
 import { EventEmitter } from "../util/EventEmitter.js";
 import type { NoInfer } from "../util/typescript.js";
-import { BlockNoteExtension } from "./BlockNoteExtension.js";
+import { ExtensionFactoryInstance } from "./BlockNoteExtension.js";
 import type { TextCursorPosition } from "./cursorPositionTypes.js";
+import { ExtensionManager } from "./managers/index.js";
 import type { Selection } from "./selectionTypes.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;
-/**
- * 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> = {
+export interface BlockNoteEditorOptions<BSchema extends BlockSchema, ISchema extends InlineContentSchema, SSchema extends StyleSchema> {
     /**
      * Whether changes to blocks (like indentation, creating lists, changing headings) should be animated or not. Defaults to `true`.
      *
@@ -79,16 +61,6 @@ export type BlockNoteEditorOptions<BSchema extends BlockSchema, ISchema extends
          */
         showCursorLabels?: "always" | "activity";
     };
-    /**
-     * Configuration for the comments feature, requires a `threadStore`.
-     *
-     * See [Comments](https://www.blocknotejs.org/docs/features/collaboration/comments) for more info.
-     * @remarks `CommentsOptions`
-     */
-    comments?: {
-        schema?: BlockNoteSchema<any, any, any>;
-        threadStore: ThreadStore;
-    };
     /**
      * Use default BlockNote font and reset the styles of <p> <li> <h1> elements etc., that are used in BlockNote.
      *
@@ -183,12 +155,6 @@ export type BlockNoteEditorOptions<BSchema extends BlockSchema, ISchema extends
      * @returns The URL that's
      */
     resolveFileUrl?: (url: string) => Promise<string>;
-    /**
-     * Resolve user information for comments.
-     *
-     * See [Comments](https://www.blocknotejs.org/docs/features/collaboration/comments) for more info.
-     */
-    resolveUsers?: (userIds: string[]) => Promise<User[]>;
     /**
      * The schema of the editor. The schema defines which Blocks, InlineContent, and Styles are available in the editor.
      *
@@ -267,28 +233,15 @@ export type BlockNoteEditorOptions<BSchema extends BlockSchema, ISchema extends
      * @internal
      */
     _tiptapOptions?: Partial<EditorOptions>;
-    /**
-     * (experimental) add extra extensions to the editor
-     *
-     * @deprecated, should use `extensions` instead
-     * @internal
-     */
-    _extensions?: Record<string, {
-        plugin: Plugin;
-        priority?: number;
-    } | ((editor: BlockNoteEditor<any, any, any>) => {
-        plugin: Plugin;
-        priority?: number;
-    })>;
     /**
      * Register extensions to the editor.
      *
      * See [Extensions](/docs/features/extensions) for more info.
      *
-     * @remarks `BlockNoteExtension[]`
+     * @remarks `ExtensionFactory[]`
      */
-    extensions?: Array<BlockNoteExtension | BlockNoteExtensionFactory>;
-};
+    extensions?: Array<ExtensionFactoryInstance>;
+}
 export declare class BlockNoteEditor<BSchema extends BlockSchema = DefaultBlockSchema, ISchema extends InlineContentSchema = DefaultInlineContentSchema, SSchema extends StyleSchema = DefaultStyleSchema> extends EventEmitter<{
     create: void;
 }> {
@@ -297,10 +250,6 @@ export declare class BlockNoteEditor<BSchema extends BlockSchema = DefaultBlockS
      * The underlying prosemirror schema
      */
     readonly pmSchema: Schema;
-    /**
-     * extensions that are added to the editor, can be tiptap extensions or prosemirror plugins
-     */
-    extensions: Record<string, SupportedExtension>;
     readonly _tiptapEditor: TiptapEditor & {
         contentComponent: any;
     };
@@ -326,18 +275,6 @@ export declare class BlockNoteEditor<BSchema extends BlockSchema = DefaultBlockS
     readonly blockImplementations: BlockSpecs;
     readonly inlineContentImplementations: InlineContentSpecs;
     readonly styleImplementations: StyleSpecs;
-    get formattingToolbar(): FormattingToolbarProsemirrorPlugin;
-    get linkToolbar(): LinkToolbarProsemirrorPlugin<BSchema, ISchema, SSchema>;
-    get sideMenu(): SideMenuProsemirrorPlugin<BSchema, ISchema, SSchema>;
-    get suggestionMenus(): SuggestionMenuProseMirrorPlugin<BSchema, ISchema, SSchema>;
-    get filePanel(): FilePanelProsemirrorPlugin<ISchema, SSchema> | undefined;
-    get tableHandles(): TableHandlesProsemirrorPlugin<ISchema, SSchema> | undefined;
-    get comments(): CommentsPlugin | undefined;
-    get showSelectionPlugin(): ShowSelectionPlugin;
-    /**
-     * The plugin for forking a document, only defined if in collaboration mode
-     */
-    get forkYDocPlugin(): import("../extensions/Collaboration/ForkYDocPlugin.js").ForkYDocPlugin | undefined;
     /**
      * 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.
@@ -351,7 +288,6 @@ export declare class BlockNoteEditor<BSchema extends BlockSchema = DefaultBlockS
     private onUploadStartCallbacks;
     private onUploadEndCallbacks;
     readonly resolveFileUrl?: (url: string) => Promise<string>;
-    readonly resolveUsers?: (userIds: string[]) => Promise<User[]>;
     /**
      * Editor settings
      */
@@ -368,13 +304,16 @@ export declare class BlockNoteEditor<BSchema extends BlockSchema = DefaultBlockS
     } ? BlockNoteEditor<BSchema, ISchema, SSchema> : BlockNoteEditor<DefaultBlockSchema, DefaultInlineContentSchema, DefaultStyleSchema>;
     protected constructor(options: Partial<BlockNoteEditorOptions<BSchema, ISchema, SSchema>>);
     private readonly _blockManager;
-    private readonly _collaborationManager?;
     private readonly _eventManager;
     private readonly _exportManager;
     private readonly _extensionManager;
     private readonly _selectionManager;
     private readonly _stateManager;
     private readonly _styleManager;
+    /**
+     * BlockNote extensions that are added to the editor, keyed by the extension key
+     */
+    get extensions(): Map<string, import("./BlockNoteExtension.js").Extension<any, string>>;
     /**
      * Execute a prosemirror command. This is mostly for backwards compatibility with older code.
      *
@@ -427,16 +366,17 @@ export declare class BlockNoteEditor<BSchema extends BlockSchema = DefaultBlockS
      */
     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
+     * Remove extension(s) from the editor
      */
-    extension<T extends BlockNoteExtension>(ext: {
-        new (...args: any[]): T;
-    } & typeof BlockNoteExtension, key?: string): T;
+    unregisterExtension: ExtensionManager["unregisterExtension"];
+    /**
+     * Register extension(s) to the editor
+     */
+    registerExtension: ExtensionManager["registerExtension"];
+    /**
+     * Get an extension from the editor
+     */
+    getExtension: ExtensionManager["getExtension"];
     /**
      * Mount the editor to a DOM element.
      *
@@ -461,7 +401,13 @@ export declare class BlockNoteEditor<BSchema extends BlockSchema = DefaultBlockS
     get domElement(): HTMLDivElement | undefined;
     isFocused(): boolean;
     get headless(): boolean;
+    /**
+     * Focus on the editor
+     */
     focus(): void;
+    /**
+     * Blur the editor
+     */
     blur(): void;
     onUploadStart(callback: (blockId?: string) => void): () => void;
     onUploadEnd(callback: (blockId?: string) => void): () => void;
@@ -731,13 +677,6 @@ export declare class BlockNoteEditor<BSchema extends BlockSchema = DefaultBlockS
      * @returns The blocks parsed from the Markdown string.
      */
     tryParseMarkdownToBlocks(markdown: string): Block<BSchema, ISchema, SSchema>[];
-    /**
-     * Updates the user info for the current user that's shown to other collaborators.
-     */
-    updateCollaborationUserInfo(user: {
-        name: string;
-        color: string;
-    }): void;
     /**
      * A callback function that runs whenever the editor's contents change.
      *
@@ -749,23 +688,19 @@ export declare class BlockNoteEditor<BSchema extends BlockSchema = DefaultBlockS
          * Returns the blocks that were inserted, updated, or deleted by the change that occurred.
          */
         getChanges(): BlocksChanged<BSchema, ISchema, SSchema>;
-    }) => void): import("./managers/EventManager.js").Unsubscribe;
+    }) => void, 
     /**
-     * A callback function that runs whenever the text cursor position or selection changes.
-     *
-     * @param callback The callback to execute.
-     * @returns A function to remove the callback.
+     * If true, the callback will be triggered when the changes are caused by a remote user
+     * @default true
      */
-    onSelectionChange(callback: (editor: BlockNoteEditor<BSchema, ISchema, SSchema>) => void, includeSelectionChangedByRemote?: boolean): import("./managers/EventManager.js").Unsubscribe;
+    includeUpdatesFromRemote?: boolean): import("./managers/EventManager.js").Unsubscribe;
     /**
-     * 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.
+     * A callback function that runs whenever the text cursor position or selection changes.
      *
      * @param callback The callback to execute.
      * @returns A function to remove the callback.
      */
-    onCreate(callback: () => void): () => void;
+    onSelectionChange(callback: (editor: BlockNoteEditor<BSchema, ISchema, SSchema>) => void, includeSelectionChangedByRemote?: boolean): import("./managers/EventManager.js").Unsubscribe;
     /**
      * A callback function that runs when the editor has been mounted.
      *
@@ -794,12 +729,6 @@ export declare class BlockNoteEditor<BSchema extends BlockSchema = DefaultBlockS
      */
     getSelectionBoundingBox(): DOMRect | undefined;
     get isEmpty(): boolean;
-    openSuggestionMenu(triggerCharacter: string, pluginState?: {
-        deleteTriggerCharacter?: boolean;
-        ignoreQueryLength?: boolean;
-    }): void;
-    getForceSelectionVisible(): boolean;
-    setForceSelectionVisible(forceSelectionVisible: boolean): void;
     /**
      * Paste HTML into the editor. Defaults to converting HTML to BlockNote HTML.
      * @param html The HTML to paste.

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

@@ -1,18 +1,50 @@
-import { Plugin } from "prosemirror-state";
-import { EventEmitter } from "../util/EventEmitter.js";
-import { AnyExtension } from "@tiptap/core";
-import { BlockSchema, InlineContentSchema, PartialBlockNoDefaults, StyleSchema } from "../schema/index.js";
-import { BlockNoteEditor } from "./BlockNoteEditor.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[]);
+import { Store, StoreOptions } from "@tanstack/store";
+import { type AnyExtension } from "@tiptap/core";
+import type { Plugin as ProsemirrorPlugin } from "prosemirror-state";
+import type { PartialBlockNoDefaults } from "../schema/index.js";
+import type { BlockNoteEditor } from "./BlockNoteEditor.js";
+/**
+ * This function is called when the extension is destroyed.
+ */
+type OnDestroy = () => void;
+/**
+ * Describes a BlockNote extension.
+ */
+export interface Extension<State = any, Key extends string = string> {
     /**
-     * Input rules for the block
+     * The unique identifier for the extension.
      */
-    inputRules?: InputRule[];
+    readonly key: Key;
+    /**
+     * Triggered when the extension is mounted to the editor.
+     */
+    readonly mount?: (ctx: {
+        /**
+         * The DOM element that the editor is mounted to.
+         */
+        dom: HTMLElement;
+        /**
+         * The root document of the {@link document} that the editor is mounted to.
+         */
+        root: Document | ShadowRoot;
+        /**
+         * An {@link AbortSignal} that will be aborted when the extension is destroyed.
+         */
+        signal: AbortSignal;
+    }) => void | OnDestroy;
+    /**
+     * The store for the extension.
+     */
+    readonly store?: Store<State>;
+    /**
+     * Declares what {@link Extension}s that this extension depends on.
+     */
+    readonly runsBefore?: ReadonlyArray<string>;
+    /**
+     * Input rules for a block: An input rule is what is used to replace text in a block when a regular expression match is found.
+     * As an example, typing `#` in a paragraph block will trigger an input rule to replace the text with a heading block.
+     */
+    readonly inputRules?: ReadonlyArray<InputRule>;
     /**
      * A mapping of a keyboard shortcut to a function that will be called when the shortcut is pressed
      *
@@ -35,12 +67,23 @@ export declare abstract class BlockNoteExtension<TEvent extends Record<string, a
      * }
      * ```
      */
-    keyboardShortcuts?: Record<string, (ctx: {
-        editor: BlockNoteEditor<BlockSchema, InlineContentSchema, StyleSchema>;
+    readonly keyboardShortcuts?: Record<string, (ctx: {
+        editor: BlockNoteEditor<any, any, any>;
     }) => boolean>;
-    tiptapExtensions?: AnyExtension[];
+    /**
+     * Add additional prosemirror plugins to the editor.
+     */
+    readonly prosemirrorPlugins?: ReadonlyArray<ProsemirrorPlugin>;
+    /**
+     * Add additional tiptap extensions to the editor.
+     */
+    readonly tiptapExtensions?: ReadonlyArray<AnyExtension>;
 }
-export type InputRule = {
+/**
+ * An input rule is what is used to replace text in a block when a regular expression match is found.
+ * As an example, typing `#` in a paragraph block will trigger an input rule to replace the text with a heading block.
+ */
+type InputRule = {
     /**
      * The regex to match when to trigger the input rule
      */
@@ -68,9 +111,31 @@ export type InputRule = {
     }) => undefined | PartialBlockNoDefaults<any, any, any>;
 };
 /**
- * This creates an instance of a BlockNoteExtension that can be used to add to a schema.
- * It is a bit of a hack, but it works.
+ * These are the arguments that are passed to an {@link ExtensionFactoryInstance}.
+ */
+export interface ExtensionOptions<Options extends Record<string, any> | undefined = Record<string, any> | undefined> {
+    options: Options;
+    editor: BlockNoteEditor<any, any, any>;
+}
+export type ExtensionMap<T extends ReadonlyArray<ExtensionFactoryInstance>> = {
+    [K in T[number] extends ExtensionFactoryInstance<infer Ext> ? Ext["key"] : never]: T[number] extends ExtensionFactoryInstance<infer Ext> ? Ext : never;
+};
+/**
+ * This is a type that represents the function which will actually create the extension.
+ * It requires the editor instance to be passed in, but will already have the options applied automatically.
+ *
+ * @note Only the BlockNoteEditor should instantiate this function, not the user. Look at {@link createExtension} for user-facing functions.
+ */
+export type ExtensionFactoryInstance<Ext extends Extension<any, any> = Extension<any, any>> = (ctx: Omit<ExtensionOptions<any>, "options">) => Ext;
+/**
+ * This is the return type of the {@link createExtension} function.
+ * It is a function that can be invoked with the extension's options to create a new extension factory.
+ */
+export type ExtensionFactory<State = any, Key extends string = string, Factory extends (ctx: any) => Extension<State, Key> = (ctx: ExtensionOptions<any>) => Extension<State, Key>> = Parameters<Factory>[0] extends ExtensionOptions<infer Options> ? undefined extends Options ? (options?: Exclude<Options, undefined>) => ExtensionFactoryInstance<ReturnType<Factory>> : (options: Options) => ExtensionFactoryInstance<ReturnType<Factory>> : () => ExtensionFactoryInstance<ReturnType<Factory>>;
+/**
+ * Constructs a BlockNote {@link ExtensionFactory} from a factory function or object
  */
-export declare function createBlockNoteExtension(options: Partial<Pick<BlockNoteExtension, "inputRules" | "keyboardShortcuts" | "plugins" | "tiptapExtensions">> & {
-    key: string;
-}): BlockNoteExtension;
+export declare function createExtension<const State = any, const Key extends string = string, const Ext extends Extension<State, Key> = Extension<State, Key>>(factory: Ext): ExtensionFactoryInstance<Ext>;
+export declare function createExtension<const State = any, const Options extends Record<string, any> | undefined = any, const Key extends string = string, const Factory extends (ctx: any) => Extension<State, Key> = (ctx: ExtensionOptions<Options>) => Extension<State, Key>>(factory: Factory): ExtensionFactory<State, Key, Factory>;
+export declare function createStore<T = any>(initialState: T, options?: StoreOptions<T>): Store<T>;
+export {};

package/types/src/editor/managers/EventManager.d.ts

@@ -2,6 +2,7 @@ import type { BlockNoteEditor } from "../BlockNoteEditor.js";
 import { type BlocksChanged } from "../../api/getBlocksChangedByTransaction.js";
 import { Transaction } from "prosemirror-state";
 import { EventEmitter } from "../../util/EventEmitter.js";
+import { BlockSchema, InlineContentSchema, StyleSchema } from "../../schema/index.js";
 /**
  * A function that can be used to unsubscribe from an event.
  */
@@ -9,36 +10,44 @@ export type Unsubscribe = () => void;
 /**
  * EventManager is a class which manages the events of the editor
  */
-export declare class EventManager<Editor extends BlockNoteEditor> extends EventEmitter<{
+export declare class EventManager<BSchema extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema> extends EventEmitter<{
     onChange: [
-        editor: Editor,
         ctx: {
-            getChanges(): BlocksChanged<Editor["schema"]["blockSchema"], Editor["schema"]["inlineContentSchema"], Editor["schema"]["styleSchema"]>;
+            editor: BlockNoteEditor<BSchema, I, S>;
+            transaction: Transaction;
+            appendedTransactions: Transaction[];
+        }
+    ];
+    onSelectionChange: [
+        ctx: {
+            editor: BlockNoteEditor<BSchema, I, S>;
+            transaction: Transaction;
         }
     ];
-    onSelectionChange: [ctx: {
-        editor: Editor;
-        transaction: Transaction;
-    }];
     onMount: [ctx: {
-        editor: Editor;
+        editor: BlockNoteEditor<BSchema, I, S>;
     }];
     onUnmount: [ctx: {
-        editor: Editor;
+        editor: BlockNoteEditor<BSchema, I, S>;
     }];
 }> {
     private editor;
-    constructor(editor: Editor);
+    constructor(editor: BlockNoteEditor<BSchema, I, S>);
     /**
      * Register a callback that will be called when the editor changes.
      */
-    onChange(callback: (editor: Editor, ctx: {
-        getChanges(): BlocksChanged<Editor["schema"]["blockSchema"], Editor["schema"]["inlineContentSchema"], Editor["schema"]["styleSchema"]>;
-    }) => void): Unsubscribe;
+    onChange(callback: (editor: BlockNoteEditor<BSchema, I, S>, ctx: {
+        getChanges(): BlocksChanged<BSchema, I, S>;
+    }) => void, 
+    /**
+     * If true, the callback will be triggered when the changes are caused by a remote user
+     * @default true
+     */
+    includeUpdatesFromRemote?: boolean): Unsubscribe;
     /**
      * Register a callback that will be called when the selection changes.
      */
-    onSelectionChange(callback: (editor: Editor) => void, 
+    onSelectionChange(callback: (editor: BlockNoteEditor<BSchema, I, S>) => void, 
     /**
      * If true, the callback will be triggered when the selection changes due to a yjs sync (i.e.: other user was typing)
      */
@@ -47,12 +56,12 @@ export declare class EventManager<Editor extends BlockNoteEditor> extends EventE
      * Register a callback that will be called when the editor is mounted.
      */
     onMount(callback: (ctx: {
-        editor: Editor;
+        editor: BlockNoteEditor<BSchema, I, S>;
     }) => void): Unsubscribe;
     /**
      * Register a callback that will be called when the editor is unmounted.
      */
     onUnmount(callback: (ctx: {
-        editor: Editor;
+        editor: BlockNoteEditor<BSchema, I, S>;
     }) => void): Unsubscribe;
 }

package/types/src/editor/managers/ExtensionManager/extensions.d.ts

@@ -0,0 +1,8 @@
+import { AnyExtension as AnyTiptapExtension } from "@tiptap/core";
+import { BlockNoteEditor, BlockNoteEditorOptions } from "../../BlockNoteEditor.js";
+import { ExtensionFactoryInstance } from "../../BlockNoteExtension.js";
+/**
+ * Get all the Tiptap extensions BlockNote is configured with by default
+ */
+export declare function getDefaultTiptapExtensions(editor: BlockNoteEditor<any, any, any>, options: BlockNoteEditorOptions<any, any, any>): AnyTiptapExtension[];
+export declare function getDefaultExtensions(editor: BlockNoteEditor<any, any, any>, options: BlockNoteEditorOptions<any, any, any>): ExtensionFactoryInstance[];

package/types/src/editor/managers/ExtensionManager/index.d.ts

@@ -0,0 +1,83 @@
+import { AnyExtension as AnyTiptapExtension } from "@tiptap/core";
+import type { BlockNoteEditor, BlockNoteEditorOptions } from "../../BlockNoteEditor.js";
+import type { Extension, ExtensionFactoryInstance, ExtensionFactory } from "../../BlockNoteExtension.js";
+export declare class ExtensionManager {
+    private editor;
+    private options;
+    /**
+     * A set of extension keys which are disabled by the options
+     */
+    private disabledExtensions;
+    /**
+     * A list of all the extensions that are registered to the editor
+     */
+    private extensions;
+    /**
+     * A map of all the abort controllers for each extension that has an init method defined
+     */
+    private abortMap;
+    /**
+     * A map of all the extension factories that are registered to the editor
+     */
+    private extensionFactories;
+    /**
+     * Because a single blocknote extension can both have it's own prosemirror plugins & additional generated ones (e.g. keymap & input rules plugins)
+     * We need to keep track of all the plugins for each extension, so that we can remove them when the extension is unregistered
+     */
+    private extensionPlugins;
+    constructor(editor: BlockNoteEditor<any, any, any>, options: BlockNoteEditorOptions<any, any, any>);
+    /**
+     * Register one or more extensions to the editor after the editor is initialized.
+     *
+     * This allows users to switch on & off extensions "at runtime".
+     */
+    registerExtension(extension: Extension | ExtensionFactoryInstance | (Extension | ExtensionFactoryInstance)[]): void;
+    /**
+     * Register an extension to the editor
+     * @param extension - The extension to register
+     * @returns The extension instance
+     */
+    private addExtension;
+    /**
+     * Resolve an extension or a list of extensions into a list of extension instances
+     * @param toResolve - The extension or list of extensions to resolve
+     * @returns A list of extension instances
+     */
+    private resolveExtensions;
+    /**
+     * Unregister an extension from the editor
+     * @param toUnregister - The extension to unregister
+     * @returns void
+     */
+    unregisterExtension(toUnregister: undefined | string | Extension | ExtensionFactory | (Extension | ExtensionFactory | string | undefined)[]): void;
+    /**
+     * Allows resetting the current prosemirror state's plugins
+     * @param update - A function that takes the current plugins and returns the new plugins
+     * @returns void
+     */
+    private updatePlugins;
+    /**
+     * Get all the extensions that are registered to the editor
+     */
+    getTiptapExtensions(): AnyTiptapExtension[];
+    /**
+     * This maps a blocknote extension into an array of Prosemirror plugins if it has any of the following:
+     * - plugins
+     * - keyboard shortcuts
+     * - input rules
+     */
+    private getProsemirrorPluginsFromExtension;
+    /**
+     * Get all extensions
+     */
+    getExtensions(): Map<string, Extension>;
+    /**
+     * Get a specific extension by it's instance
+     */
+    getExtension<const Ext extends Extension | ExtensionFactory = Extension>(extension: string): (Ext extends Extension ? Ext : Ext extends ExtensionFactory ? ReturnType<ReturnType<Ext>> : never) | undefined;
+    getExtension<const T extends ExtensionFactory>(extension: T): ReturnType<ReturnType<T>> | undefined;
+    /**
+     * Check if an extension exists
+     */
+    hasExtension(key: string | Extension | ExtensionFactory): boolean;
+}

package/types/src/editor/managers/ExtensionManager/symbol.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Symbol used to track the original factory function for extensions.
+ * This allows us to retrieve the original factory for comparison and other operations.
+ */
+export declare const originalFactorySymbol: unique symbol;

package/types/src/editor/managers/StateManager.d.ts

@@ -1,19 +1,8 @@
-import { redo, undo } from "@tiptap/pm/history";
 import { Command, Transaction } from "prosemirror-state";
 import { BlockNoteEditor } from "../BlockNoteEditor.js";
 export declare class StateManager {
     private editor;
-    private options?;
-    constructor(editor: BlockNoteEditor, options?: {
-        /**
-         * Swap the default undo command with a custom command.
-         */
-        undo?: typeof undo;
-        /**
-         * Swap the default redo command with a custom command.
-         */
-        redo?: typeof redo;
-    } | undefined);
+    constructor(editor: BlockNoteEditor<any, any, any>);
     /**
      * Stores the currently active transaction, which is the accumulated transaction from all {@link dispatch} calls during a {@link transact} calls
      */

package/types/src/editor/managers/index.d.ts

@@ -1,8 +1,7 @@
 export { BlockManager } from "./BlockManager.js";
-export { CollaborationManager, type CollaborationOptions, } from "./CollaborationManager.js";
 export { EventManager } from "./EventManager.js";
 export { ExportManager } from "./ExportManager.js";
-export { ExtensionManager } from "./ExtensionManager.js";
+export { ExtensionManager } from "./ExtensionManager/index.js";
 export { SelectionManager } from "./SelectionManager.js";
 export { StateManager } from "./StateManager.js";
 export { StyleManager } from "./StyleManager.js";

package/types/src/extensions/BlockChange/BlockChange.d.ts

@@ -0,0 +1,16 @@
+import { Plugin, Transaction } from "prosemirror-state";
+import { BlocksChanged } from "../../api/getBlocksChangedByTransaction.js";
+/**
+ * This plugin can filter transactions before they are applied to the editor, but with a higher-level API than `filterTransaction` from prosemirror.
+ */
+export declare const BlockChangeExtension: () => import("../../index.js").ExtensionFactoryInstance<{
+    readonly key: "blockChange";
+    readonly prosemirrorPlugins: readonly [Plugin<any>];
+    /**
+     * Subscribe to the block change events.
+     */
+    readonly subscribe: (callback: (context: {
+        getChanges: () => BlocksChanged<any, any, any>;
+        tr: Transaction;
+    }) => boolean | void) => () => void;
+}>;

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

@@ -0,0 +1,34 @@
+import * as Y from "yjs";
+export declare const ForkYDocExtension: (options: {
+    fragment: Y.XmlFragment;
+    user: {
+        name: string;
+        color: string;
+    };
+    provider: any;
+    renderCursor?: (user: any) => HTMLElement;
+    showCursorLabels?: "always" | "activity";
+}) => import("../../index.js").ExtensionFactoryInstance<{
+    readonly key: "yForkDoc";
+    readonly store: import("@tanstack/store").Store<{
+        isForked: boolean;
+    }, (cb: {
+        isForked: boolean;
+    }) => {
+        isForked: boolean;
+    }>;
+    /**
+     * 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.
+     */
+    readonly 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.
+     */
+    readonly merge: ({ keepChanges }: {
+        keepChanges: boolean;
+    }) => void;
+}>;

package/types/src/extensions/Collaboration/ForkYDoc.test.d.ts

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