@blocknote/core 0.9.6 → 0.10.1

package/types/src/{BlockNoteEditor.d.ts → editor/BlockNoteEditor.d.ts}

@@ -2,18 +2,20 @@ import { EditorOptions } from "@tiptap/core";
 import { Node } from "prosemirror-model";
 import { Editor as TiptapEditor } from "@tiptap/core/dist/packages/core/src/Editor";
 import * as Y from "yjs";
-import { Block, BlockIdentifier, BlockNoteDOMAttributes, BlockSchema, PartialBlock } from "./extensions/Blocks/api/blockTypes";
-import { TextCursorPosition } from "./extensions/Blocks/api/cursorPositionTypes";
-import { DefaultBlockSchema } from "./extensions/Blocks/api/defaultBlocks";
-import { Styles } from "./extensions/Blocks/api/inlineContentTypes";
-import { Selection } from "./extensions/Blocks/api/selectionTypes";
-import { FormattingToolbarProsemirrorPlugin } from "./extensions/FormattingToolbar/FormattingToolbarPlugin";
-import { HyperlinkToolbarProsemirrorPlugin } from "./extensions/HyperlinkToolbar/HyperlinkToolbarPlugin";
-import { ImageToolbarProsemirrorPlugin } from "./extensions/ImageToolbar/ImageToolbarPlugin";
-import { SideMenuProsemirrorPlugin } from "./extensions/SideMenu/SideMenuPlugin";
-import { BaseSlashMenuItem } from "./extensions/SlashMenu/BaseSlashMenuItem";
-import { SlashMenuProsemirrorPlugin } from "./extensions/SlashMenu/SlashMenuPlugin";
-export type BlockNoteEditorOptions<BSchema extends BlockSchema> = {
+import { DefaultBlockSchema, DefaultInlineContentSchema, DefaultStyleSchema, defaultBlockSpecs, defaultInlineContentSpecs, defaultStyleSpecs } from "../blocks/defaultBlocks";
+import { FormattingToolbarProsemirrorPlugin } from "../extensions/FormattingToolbar/FormattingToolbarPlugin";
+import { HyperlinkToolbarProsemirrorPlugin } from "../extensions/HyperlinkToolbar/HyperlinkToolbarPlugin";
+import { ImageToolbarProsemirrorPlugin } from "../extensions/ImageToolbar/ImageToolbarPlugin";
+import { SideMenuProsemirrorPlugin } from "../extensions/SideMenu/SideMenuPlugin";
+import { BaseSlashMenuItem } from "../extensions/SlashMenu/BaseSlashMenuItem";
+import { SlashMenuProsemirrorPlugin } from "../extensions/SlashMenu/SlashMenuPlugin";
+import { TableHandlesProsemirrorPlugin } from "../extensions/TableHandles/TableHandlesPlugin";
+import { Block, BlockIdentifier, BlockNoteDOMAttributes, BlockSchema, BlockSchemaFromSpecs, BlockSchemaWithBlock, BlockSpecs, InlineContentSchema, InlineContentSchemaFromSpecs, InlineContentSpecs, PartialBlock, StyleSchema, StyleSchemaFromSpecs, StyleSpecs, Styles } from "../schema";
+import { TextCursorPosition } from "./cursorPositionTypes";
+import { Selection } from "./selectionTypes";
+import "./Block.css";
+import "./editor.css";
+export type BlockNoteEditorOptions<BSpecs extends BlockSpecs, ISpecs extends InlineContentSpecs, SSpecs extends StyleSpecs> = {
     enableBlockNoteExtensions: boolean;
     /**
      *
@@ -21,7 +23,7 @@ export type BlockNoteEditorOptions<BSchema extends BlockSchema> = {
      *
      * @default defaultSlashMenuItems from `./extensions/SlashMenu`
      */
-    slashMenuItems: BaseSlashMenuItem<any>[];
+    slashMenuItems: BaseSlashMenuItem<any, any, any>[];
     /**
      * The HTML element that should be used as the parent element for the editor.
      *
@@ -37,15 +39,15 @@ export type BlockNoteEditorOptions<BSchema extends BlockSchema> = {
     /**
      *  A callback function that runs when the editor is ready to be used.
      */
-    onEditorReady: (editor: BlockNoteEditor<BSchema>) => void;
+    onEditorReady: (editor: BlockNoteEditor<BlockSchemaFromSpecs<BSpecs>, InlineContentSchemaFromSpecs<ISpecs>, StyleSchemaFromSpecs<SSpecs>>) => void;
     /**
      * A callback function that runs whenever the editor's contents change.
      */
-    onEditorContentChange: (editor: BlockNoteEditor<BSchema>) => void;
+    onEditorContentChange: (editor: BlockNoteEditor<BlockSchemaFromSpecs<BSpecs>, InlineContentSchemaFromSpecs<ISpecs>, StyleSchemaFromSpecs<SSpecs>>) => void;
     /**
      * A callback function that runs whenever the text cursor position changes.
      */
-    onTextCursorPositionChange: (editor: BlockNoteEditor<BSchema>) => void;
+    onTextCursorPositionChange: (editor: BlockNoteEditor<BlockSchemaFromSpecs<BSpecs>, InlineContentSchemaFromSpecs<ISpecs>, StyleSchemaFromSpecs<SSpecs>>) => void;
     /**
      * Locks the editor from being editable by the user if set to `false`.
      */
@@ -53,7 +55,7 @@ export type BlockNoteEditorOptions<BSchema extends BlockSchema> = {
     /**
      * The content that should be in the editor when it's created, represented as an array of partial block objects.
      */
-    initialContent: PartialBlock<BSchema>[];
+    initialContent: PartialBlock<BlockSchemaFromSpecs<BSpecs>, InlineContentSchemaFromSpecs<ISpecs>, StyleSchemaFromSpecs<SSpecs>>[];
     /**
      * Use default BlockNote font and reset the styles of <p> <li> <h1> elements etc., that are used in BlockNote.
      *
@@ -63,7 +65,9 @@ export type BlockNoteEditorOptions<BSchema extends BlockSchema> = {
     /**
      * A list of block types that should be available in the editor.
      */
-    blockSchema: BSchema;
+    blockSpecs: BSpecs;
+    styleSpecs: SSpecs;
+    inlineContentSpecs: ISpecs;
     /**
      * A custom function to handle file uploads.
      * @param file The file that should be uploaded.
@@ -96,21 +100,28 @@ export type BlockNoteEditorOptions<BSchema extends BlockSchema> = {
     };
     _tiptapOptions: Partial<EditorOptions>;
 };
-export declare class BlockNoteEditor<BSchema extends BlockSchema = DefaultBlockSchema> {
+export declare class BlockNoteEditor<BSchema extends BlockSchema = DefaultBlockSchema, ISchema extends InlineContentSchema = DefaultInlineContentSchema, SSchema extends StyleSchema = DefaultStyleSchema> {
     private readonly options;
     readonly _tiptapEditor: TiptapEditor & {
         contentComponent: any;
     };
-    blockCache: WeakMap<Node, Block<BSchema>>;
-    readonly schema: BSchema;
+    blockCache: WeakMap<Node, Block<any, any, any>>;
+    readonly blockSchema: BSchema;
+    readonly inlineContentSchema: ISchema;
+    readonly styleSchema: SSchema;
+    readonly blockImplementations: BlockSpecs;
+    readonly inlineContentImplementations: InlineContentSpecs;
+    readonly styleImplementations: StyleSpecs;
     ready: boolean;
-    readonly sideMenu: SideMenuProsemirrorPlugin<BSchema>;
-    readonly formattingToolbar: FormattingToolbarProsemirrorPlugin<BSchema>;
-    readonly slashMenu: SlashMenuProsemirrorPlugin<BSchema, any>;
-    readonly hyperlinkToolbar: HyperlinkToolbarProsemirrorPlugin<BSchema>;
-    readonly imageToolbar: ImageToolbarProsemirrorPlugin<BSchema>;
+    readonly sideMenu: SideMenuProsemirrorPlugin<BSchema, ISchema, SSchema>;
+    readonly formattingToolbar: FormattingToolbarProsemirrorPlugin;
+    readonly slashMenu: SlashMenuProsemirrorPlugin<BSchema, ISchema, SSchema, any>;
+    readonly hyperlinkToolbar: HyperlinkToolbarProsemirrorPlugin<BSchema, ISchema, SSchema>;
+    readonly imageToolbar: ImageToolbarProsemirrorPlugin<BSchema, ISchema, SSchema>;
+    readonly tableHandles: TableHandlesProsemirrorPlugin<BSchema extends BlockSchemaWithBlock<"table", DefaultBlockSchema["table"]> ? BSchema : any, ISchema, SSchema> | undefined;
     readonly uploadFile: ((file: File) => Promise<string>) | undefined;
-    constructor(options?: Partial<BlockNoteEditorOptions<BSchema>>);
+    static create<BSpecs extends BlockSpecs = typeof defaultBlockSpecs, ISpecs extends InlineContentSpecs = typeof defaultInlineContentSpecs, SSpecs extends StyleSpecs = typeof defaultStyleSpecs>(options?: Partial<BlockNoteEditorOptions<BSpecs, ISpecs, SSpecs>>): BlockNoteEditor<BlockSchemaFromSpecs<BSpecs>, InlineContentSchemaFromSpecs<ISpecs>, StyleSchemaFromSpecs<SSpecs>>;
+    private constructor();
     get prosemirrorView(): import("prosemirror-view").EditorView;
     get domElement(): HTMLDivElement;
     isFocused(): boolean;
@@ -119,19 +130,19 @@ export declare class BlockNoteEditor<BSchema extends BlockSchema = DefaultBlockS
      * Gets a snapshot of all top-level (non-nested) blocks in the editor.
      * @returns A snapshot of all top-level (non-nested) blocks in the editor.
      */
-    get topLevelBlocks(): Block<BSchema>[];
+    get topLevelBlocks(): Block<BSchema, ISchema, SSchema>[];
     /**
      * Gets a snapshot of an existing block from the editor.
      * @param blockIdentifier The identifier of an existing block that should be retrieved.
      * @returns The block that matches the identifier, or `undefined` if no matching block was found.
      */
-    getBlock(blockIdentifier: BlockIdentifier): Block<BSchema> | undefined;
+    getBlock(blockIdentifier: BlockIdentifier): Block<BSchema, ISchema, SSchema> | undefined;
     /**
      * Traverses all blocks in the editor depth-first, and executes a callback for each.
      * @param callback The callback to execute for each block. Returning `false` stops the traversal.
      * @param reverse Whether the blocks should be traversed in reverse order.
      */
-    forEachBlock(callback: (block: Block<BSchema>) => boolean, reverse?: boolean): void;
+    forEachBlock(callback: (block: Block<BSchema, ISchema, SSchema>) => boolean, reverse?: boolean): void;
     /**
      * Executes a callback whenever the editor's contents change.
      * @param callback The callback to execute.
@@ -146,7 +157,7 @@ export declare class BlockNoteEditor<BSchema extends BlockSchema = DefaultBlockS
      * Gets a snapshot of the current text cursor position.
      * @returns A snapshot of the current text cursor position.
      */
-    getTextCursorPosition(): TextCursorPosition<BSchema>;
+    getTextCursorPosition(): TextCursorPosition<BSchema, ISchema, SSchema>;
     /**
      * Sets the text cursor position to the start or end of an existing block. Throws an error if the target block could
      * not be found.
@@ -157,7 +168,7 @@ export declare class BlockNoteEditor<BSchema extends BlockSchema = DefaultBlockS
     /**
      * Gets a snapshot of the current selection.
      */
-    getSelection(): Selection<BSchema> | undefined;
+    getSelection(): Selection<BSchema, ISchema, SSchema> | undefined;
     /**
      * Checks if the editor is currently editable, or if it's locked.
      * @returns True if the editor is editable, false otherwise.
@@ -176,7 +187,7 @@ export declare class BlockNoteEditor<BSchema extends BlockSchema = DefaultBlockS
      * @param placement Whether the blocks should be inserted just before, just after, or nested inside the
      * `referenceBlock`. Inserts the blocks at the start of the existing block's children if "nested" is used.
      */
-    insertBlocks(blocksToInsert: PartialBlock<BSchema>[], referenceBlock: BlockIdentifier, placement?: "before" | "after" | "nested"): void;
+    insertBlocks(blocksToInsert: PartialBlock<BSchema, ISchema, SSchema>[], referenceBlock: BlockIdentifier, placement?: "before" | "after" | "nested"): void;
     /**
      * Updates an existing block in the editor. Since updatedBlock is a PartialBlock object, some fields might not be
      * defined. These undefined fields are kept as-is from the existing block. Throws an error if the block to update could
@@ -184,7 +195,7 @@ export declare class BlockNoteEditor<BSchema extends BlockSchema = DefaultBlockS
      * @param blockToUpdate The block that should be updated.
      * @param update A partial block which defines how the existing block should be changed.
      */
-    updateBlock(blockToUpdate: BlockIdentifier, update: PartialBlock<BSchema>): void;
+    updateBlock(blockToUpdate: BlockIdentifier, update: PartialBlock<BSchema, ISchema, SSchema>): void;
     /**
      * Removes existing blocks from the editor. Throws an error if any of the blocks could not be found.
      * @param blocksToRemove An array of identifiers for existing blocks that should be removed.
@@ -197,26 +208,26 @@ export declare class BlockNoteEditor<BSchema extends BlockSchema = DefaultBlockS
      * @param blocksToRemove An array of blocks that should be replaced.
      * @param blocksToInsert An array of partial blocks to replace the old ones with.
      */
-    replaceBlocks(blocksToRemove: BlockIdentifier[], blocksToInsert: PartialBlock<BSchema>[]): void;
+    replaceBlocks(blocksToRemove: BlockIdentifier[], blocksToInsert: PartialBlock<BSchema, ISchema, SSchema>[]): void;
     /**
      * Gets the active text styles at the text cursor position or at the end of the current selection if it's active.
      */
-    getActiveStyles(): Styles;
+    getActiveStyles(): Styles<SSchema>;
     /**
      * Adds styles to the currently selected content.
      * @param styles The styles to add.
      */
-    addStyles(styles: Styles): void;
+    addStyles(styles: Styles<SSchema>): void;
     /**
      * Removes styles from the currently selected content.
      * @param styles The styles to remove.
      */
-    removeStyles(styles: Styles): void;
+    removeStyles(styles: Styles<SSchema>): void;
     /**
      * Toggles styles on the currently selected content.
      * @param styles The styles to toggle.
      */
-    toggleStyles(styles: Styles): void;
+    toggleStyles(styles: Styles<SSchema>): void;
     /**
      * Gets the currently selected text.
      */
@@ -253,7 +264,7 @@ export declare class BlockNoteEditor<BSchema extends BlockSchema = DefaultBlockS
      * @param blocks An array of blocks that should be serialized into HTML.
      * @returns The blocks, serialized as an HTML string.
      */
-    blocksToHTML(blocks: Block<BSchema>[]): Promise<string>;
+    blocksToHTMLLossy(blocks?: Block<BSchema, ISchema, SSchema>[]): Promise<string>;
     /**
      * Parses blocks from an HTML string. Tries to create `Block` objects out of any HTML block-level elements, and
      * `InlineNode` objects from any HTML inline elements, though not all element types are recognized. If BlockNote
@@ -261,14 +272,14 @@ export declare class BlockNoteEditor<BSchema extends BlockSchema = DefaultBlockS
      * @param html The HTML string to parse blocks from.
      * @returns The blocks parsed from the HTML string.
      */
-    HTMLToBlocks(html: string): Promise<Block<BSchema>[]>;
+    tryParseHTMLToBlocks(html: string): Promise<Block<BSchema, ISchema, SSchema>[]>;
     /**
      * Serializes blocks into a Markdown string. The output is simplified as Markdown does not support all features of
      * BlockNote - children of blocks which aren't list items are un-nested and certain styles are removed.
      * @param blocks An array of blocks that should be serialized into Markdown.
      * @returns The blocks, serialized as a Markdown string.
      */
-    blocksToMarkdown(blocks: Block<BSchema>[]): Promise<string>;
+    blocksToMarkdownLossy(blocks?: Block<BSchema, ISchema, SSchema>[]): Promise<string>;
     /**
      * Creates a list of blocks from a Markdown string. Tries to create `Block` and `InlineNode` objects based on
      * Markdown syntax, though not all symbols are recognized. If BlockNote doesn't recognize a symbol, it will parse it
@@ -276,7 +287,7 @@ export declare class BlockNoteEditor<BSchema extends BlockSchema = DefaultBlockS
      * @param markdown The Markdown string to parse blocks from.
      * @returns The blocks parsed from the Markdown string.
      */
-    markdownToBlocks(markdown: string): Promise<Block<BSchema>[]>;
+    tryParseMarkdownToBlocks(markdown: string): Promise<Block<BSchema, ISchema, SSchema>[]>;
     /**
      * Updates the user info for the current user that's shown to other collaborators.
      */

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

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

package/types/src/{BlockNoteExtensions.d.ts → editor/BlockNoteExtensions.d.ts}

@@ -1,14 +1,17 @@
 import { Extensions } from "@tiptap/core";
-import { BlockNoteEditor } from "./BlockNoteEditor";
+import type { BlockNoteEditor } from "./BlockNoteEditor";
 import * as Y from "yjs";
-import { BlockNoteDOMAttributes } from "./extensions/Blocks/api/blockTypes";
+import { BlockNoteDOMAttributes, BlockSpecs, InlineContentSchema, InlineContentSpecs, StyleSchema, StyleSpecs } from "../schema";
 /**
  * Get all the Tiptap extensions BlockNote is configured with by default
  */
-export declare const getBlockNoteExtensions: <BSchema extends Record<string, import("./extensions/Blocks/api/blockTypes").BlockSpec<string, import("./extensions/Blocks/api/blockTypes").PropSchema, boolean>>>(opts: {
-    editor: BlockNoteEditor<BSchema>;
+export declare const getBlockNoteExtensions: <BSchema extends Record<string, import("../schema").BlockConfig>, I extends InlineContentSchema, S extends StyleSchema>(opts: {
+    editor: BlockNoteEditor<BSchema, I, S>;
     domAttributes: Partial<BlockNoteDOMAttributes>;
     blockSchema: BSchema;
+    blockSpecs: BlockSpecs;
+    inlineContentSpecs: InlineContentSpecs;
+    styleSpecs: StyleSpecs;
     collaboration?: {
         fragment: Y.XmlFragment;
         user: {

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

@@ -0,0 +1,6 @@
+import { Block, BlockSchema, InlineContentSchema, StyleSchema } from "../schema";
+export type TextCursorPosition<BSchema extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema> = {
+    block: Block<BSchema, I, S>;
+    prevBlock: Block<BSchema, I, S> | undefined;
+    nextBlock: Block<BSchema, I, S> | undefined;
+};

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

@@ -0,0 +1,4 @@
+import { Block, BlockSchema, InlineContentSchema, StyleSchema } from "../schema";
+export type Selection<BSchema extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema> = {
+    blocks: Block<BSchema, I, S>[];
+};

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

@@ -0,0 +1,12 @@
+import { Slice } from "@tiptap/pm/model";
+import { EditorView } from "@tiptap/pm/view";
+/**
+ * fix for https://github.com/ProseMirror/prosemirror/issues/1430#issuecomment-1822570821
+ *
+ * Without this fix, pasting two paragraphs would cause the second one to be indented in the other
+ * this fix wraps every element in the slice in it's own blockContainer, to prevent Prosemirror from nesting the
+ * elements on paste.
+ *
+ * The exception is when we encounter blockGroups with listitems, because those actually should be nested
+ */
+export declare function transformPasted(slice: Slice, view: EditorView): Slice;

package/types/src/extensions/BackgroundColor/BackgroundColorExtension.d.ts

@@ -1,9 +1,2 @@
 import { Extension } from "@tiptap/core";
-declare module "@tiptap/core" {
-    interface Commands<ReturnType> {
-        blockBackgroundColor: {
-            setBlockBackgroundColor: (posInBlock: number, color: string) => ReturnType;
-        };
-    }
-}
 export declare const BackgroundColorExtension: Extension<any, any>;

package/types/src/extensions/BackgroundColor/BackgroundColorMark.d.ts

@@ -1,9 +1,7 @@
-import { Mark } from "@tiptap/core";
-declare module "@tiptap/core" {
-    interface Commands<ReturnType> {
-        backgroundColor: {
-            setBackgroundColor: (color: string) => ReturnType;
-        };
-    }
-}
-export declare const BackgroundColorMark: Mark<any, any>;
+export declare const BackgroundColor: {
+    config: {
+        type: string;
+        propSchema: "string";
+    };
+    implementation: import("../../schema").StyleImplementation;
+};

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

@@ -1,10 +1,12 @@
 import { EditorState, Plugin, PluginKey } from "prosemirror-state";
 import { EditorView } from "prosemirror-view";
-import { BaseUiElementCallbacks, BaseUiElementState, BlockNoteEditor, BlockSchema } from "../..";
-import { EventEmitter } from "../../shared/EventEmitter";
+import type { BlockNoteEditor } from "../../editor/BlockNoteEditor";
+import { BaseUiElementCallbacks, BaseUiElementState } from "../../extensions-shared/BaseUiElementTypes";
+import { BlockSchema, InlineContentSchema, StyleSchema } from "../../schema";
+import { EventEmitter } from "../../util/EventEmitter";
 export type FormattingToolbarCallbacks = BaseUiElementCallbacks;
 export type FormattingToolbarState = BaseUiElementState;
-export declare class FormattingToolbarView<BSchema extends BlockSchema> {
+export declare class FormattingToolbarView {
     private readonly editor;
     private readonly pmView;
     private formattingToolbarState?;
@@ -18,7 +20,7 @@ export declare class FormattingToolbarView<BSchema extends BlockSchema> {
         from: number;
         to: number;
     }) => boolean;
-    constructor(editor: BlockNoteEditor<BSchema>, pmView: EditorView, updateFormattingToolbar: (formattingToolbarState: FormattingToolbarState) => void);
+    constructor(editor: BlockNoteEditor<BlockSchema, InlineContentSchema, StyleSchema>, pmView: EditorView, updateFormattingToolbar: (formattingToolbarState: FormattingToolbarState) => void);
     viewMousedownHandler: () => void;
     viewMouseupHandler: () => void;
     dragstartHandler: () => void;
@@ -30,9 +32,9 @@ export declare class FormattingToolbarView<BSchema extends BlockSchema> {
     getSelectionBoundingBox(): DOMRect;
 }
 export declare const formattingToolbarPluginKey: PluginKey<any>;
-export declare class FormattingToolbarProsemirrorPlugin<BSchema extends BlockSchema> extends EventEmitter<any> {
+export declare class FormattingToolbarProsemirrorPlugin extends EventEmitter<any> {
     private view;
     readonly plugin: Plugin;
-    constructor(editor: BlockNoteEditor<BSchema>);
+    constructor(editor: BlockNoteEditor<any, any, any>);
     onUpdate(callback: (state: FormattingToolbarState) => void): () => void;
 }

package/types/src/extensions/HyperlinkToolbar/HyperlinkToolbarPlugin.d.ts

@@ -1,17 +1,17 @@
 import { Plugin, PluginKey } from "prosemirror-state";
-import { BlockNoteEditor } from "../../BlockNoteEditor";
-import { BaseUiElementState } from "../../shared/BaseUiElementTypes";
-import { EventEmitter } from "../../shared/EventEmitter";
-import { BlockSchema } from "../Blocks/api/blockTypes";
+import type { BlockNoteEditor } from "../../editor/BlockNoteEditor";
+import { BaseUiElementState } from "../../extensions-shared/BaseUiElementTypes";
+import { BlockSchema, InlineContentSchema, StyleSchema } from "../../schema";
+import { EventEmitter } from "../../util/EventEmitter";
 export type HyperlinkToolbarState = BaseUiElementState & {
     url: string;
     text: string;
 };
 export declare const hyperlinkToolbarPluginKey: PluginKey<any>;
-export declare class HyperlinkToolbarProsemirrorPlugin<BSchema extends BlockSchema> extends EventEmitter<any> {
+export declare class HyperlinkToolbarProsemirrorPlugin<BSchema extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema> extends EventEmitter<any> {
     private view;
     readonly plugin: Plugin;
-    constructor(editor: BlockNoteEditor<BSchema>);
+    constructor(editor: BlockNoteEditor<BSchema, I, S>);
     onUpdate(callback: (state: HyperlinkToolbarState) => void): () => void;
     /**
      * Edit the currently hovered hyperlink.

package/types/src/extensions/ImageToolbar/ImageToolbarPlugin.d.ts

@@ -1,25 +1,20 @@
 import { EditorState, Plugin, PluginKey } from "prosemirror-state";
 import { EditorView } from "prosemirror-view";
-import { BaseUiElementCallbacks, BaseUiElementState, BlockNoteEditor, BlockSchema, BlockSpec, SpecificBlock } from "../..";
-import { EventEmitter } from "../../shared/EventEmitter";
+import { EventEmitter } from "../../util/EventEmitter";
+import type { BlockNoteEditor } from "../../editor/BlockNoteEditor";
+import { BlockSchema, InlineContentSchema, SpecificBlock, StyleSchema } from "../../schema";
+import { BaseUiElementCallbacks, BaseUiElementState } from "../../extensions-shared/BaseUiElementTypes";
 export type ImageToolbarCallbacks = BaseUiElementCallbacks;
-export type ImageToolbarState = BaseUiElementState & {
-    block: SpecificBlock<BlockSchema & {
-        image: BlockSpec<"image", {
-            src: {
-                default: string;
-            };
-        }, false>;
-    }, "image">;
+export type ImageToolbarState<B extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema = StyleSchema> = BaseUiElementState & {
+    block: SpecificBlock<B, "image", I, S>;
 };
-export declare class ImageToolbarView {
+export declare class ImageToolbarView<BSchema extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema> {
     private readonly pluginKey;
     private readonly pmView;
     private imageToolbarState?;
     updateImageToolbar: () => void;
     prevWasEditable: boolean | null;
-    shouldShow: (state: EditorState) => boolean;
-    constructor(pluginKey: PluginKey, pmView: EditorView, updateImageToolbar: (imageToolbarState: ImageToolbarState) => void);
+    constructor(pluginKey: PluginKey, pmView: EditorView, updateImageToolbar: (imageToolbarState: ImageToolbarState<BSchema, I, S>) => void);
     mouseDownHandler: () => void;
     dragstartHandler: () => void;
     blurHandler: (event: FocusEvent) => void;
@@ -28,9 +23,9 @@ export declare class ImageToolbarView {
     destroy(): void;
 }
 export declare const imageToolbarPluginKey: PluginKey<any>;
-export declare class ImageToolbarProsemirrorPlugin<BSchema extends BlockSchema> extends EventEmitter<any> {
+export declare class ImageToolbarProsemirrorPlugin<BSchema extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema> extends EventEmitter<any> {
     private view;
     readonly plugin: Plugin;
-    constructor(_editor: BlockNoteEditor<BSchema>);
-    onUpdate(callback: (state: ImageToolbarState) => void): () => void;
+    constructor(_editor: BlockNoteEditor<BSchema, I, S>);
+    onUpdate(callback: (state: ImageToolbarState<BSchema, I, S>) => void): () => void;
 }

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

@@ -1,14 +1,21 @@
 import { PluginView } from "@tiptap/pm/state";
 import { Plugin, PluginKey } from "prosemirror-state";
 import { EditorView } from "prosemirror-view";
-import { BlockNoteEditor } from "../../BlockNoteEditor";
-import { BaseUiElementState } from "../../shared/BaseUiElementTypes";
-import { EventEmitter } from "../../shared/EventEmitter";
-import { Block, BlockSchema } from "../Blocks/api/blockTypes";
-export type SideMenuState<BSchema extends BlockSchema> = BaseUiElementState & {
-    block: Block<BSchema>;
+import type { BlockNoteEditor } from "../../editor/BlockNoteEditor";
+import { BaseUiElementState } from "../../extensions-shared/BaseUiElementTypes";
+import { Block, BlockSchema, InlineContentSchema, StyleSchema } from "../../schema";
+import { EventEmitter } from "../../util/EventEmitter";
+export type SideMenuState<BSchema extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema> = BaseUiElementState & {
+    block: Block<BSchema, I, S>;
 };
-export declare class SideMenuView<BSchema extends BlockSchema> implements PluginView {
+export declare function getDraggableBlockFromCoords(coords: {
+    left: number;
+    top: number;
+}, view: EditorView): {
+    node: HTMLElement;
+    id: string;
+} | undefined;
+export declare class SideMenuView<BSchema extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema> implements PluginView {
     private readonly editor;
     private readonly pmView;
     private readonly updateSideMenu;
@@ -18,7 +25,7 @@ export declare class SideMenuView<BSchema extends BlockSchema> implements Plugin
     private hoveredBlock;
     isDragging: boolean;
     menuFrozen: boolean;
-    constructor(editor: BlockNoteEditor<BSchema>, pmView: EditorView, updateSideMenu: (sideMenuState: SideMenuState<BSchema>) => void);
+    constructor(editor: BlockNoteEditor<BSchema, I, S>, pmView: EditorView, updateSideMenu: (sideMenuState: SideMenuState<BSchema, I, S>) => void);
     /**
      * Sets isDragging when dragging text.
      */
@@ -43,12 +50,12 @@ export declare class SideMenuView<BSchema extends BlockSchema> implements Plugin
     addBlock(): void;
 }
 export declare const sideMenuPluginKey: PluginKey<any>;
-export declare class SideMenuProsemirrorPlugin<BSchema extends BlockSchema> extends EventEmitter<any> {
+export declare class SideMenuProsemirrorPlugin<BSchema extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema> extends EventEmitter<any> {
     private readonly editor;
     private sideMenuView;
     readonly plugin: Plugin;
-    constructor(editor: BlockNoteEditor<BSchema>);
-    onUpdate(callback: (state: SideMenuState<BSchema>) => void): () => void;
+    constructor(editor: BlockNoteEditor<BSchema, I, S>);
+    onUpdate(callback: (state: SideMenuState<BSchema, I, S>) => void): () => void;
     /**
      * If the block is empty, opens the slash menu. If the block has content,
      * creates a new block below and opens the slash menu in it.

package/types/src/extensions/SlashMenu/BaseSlashMenuItem.d.ts

@@ -1,8 +1,7 @@
-import { SuggestionItem } from "../../shared/plugins/suggestion/SuggestionItem";
-import { BlockNoteEditor } from "../../BlockNoteEditor";
-import { BlockSchema } from "../Blocks/api/blockTypes";
-import { DefaultBlockSchema } from "../Blocks/api/defaultBlocks";
-export type BaseSlashMenuItem<BSchema extends BlockSchema = DefaultBlockSchema> = SuggestionItem & {
-    execute: (editor: BlockNoteEditor<BSchema>) => void;
+import type { BlockNoteEditor } from "../../editor/BlockNoteEditor";
+import { SuggestionItem } from "../../extensions-shared/suggestion/SuggestionItem";
+import { BlockSchema, InlineContentSchema, StyleSchema } from "../../schema";
+export type BaseSlashMenuItem<BSchema extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema> = SuggestionItem & {
+    execute: (editor: BlockNoteEditor<BSchema, I, S>) => void;
     aliases?: string[];
 };

package/types/src/extensions/SlashMenu/SlashMenuPlugin.d.ts

@@ -1,13 +1,13 @@
 import { Plugin, PluginKey } from "prosemirror-state";
-import { BlockNoteEditor } from "../../BlockNoteEditor";
-import { EventEmitter } from "../../shared/EventEmitter";
-import { SuggestionsMenuState } from "../../shared/plugins/suggestion/SuggestionPlugin";
-import { BlockSchema } from "../Blocks/api/blockTypes";
+import type { BlockNoteEditor } from "../../editor/BlockNoteEditor";
+import { SuggestionsMenuState } from "../../extensions-shared/suggestion/SuggestionPlugin";
+import { BlockSchema, InlineContentSchema, StyleSchema } from "../../schema";
+import { EventEmitter } from "../../util/EventEmitter";
 import { BaseSlashMenuItem } from "./BaseSlashMenuItem";
 export declare const slashMenuPluginKey: PluginKey<any>;
-export declare class SlashMenuProsemirrorPlugin<BSchema extends BlockSchema, SlashMenuItem extends BaseSlashMenuItem<BSchema>> extends EventEmitter<any> {
+export declare class SlashMenuProsemirrorPlugin<BSchema extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema, SlashMenuItem extends BaseSlashMenuItem<BSchema, I, S>> extends EventEmitter<any> {
     readonly plugin: Plugin;
     readonly itemCallback: (item: SlashMenuItem) => void;
-    constructor(editor: BlockNoteEditor<BSchema>, items: SlashMenuItem[]);
+    constructor(editor: BlockNoteEditor<BSchema, I, S>, items: SlashMenuItem[]);
     onUpdate(callback: (state: SuggestionsMenuState<SlashMenuItem>) => void): () => void;
 }

package/types/src/extensions/SlashMenu/defaultSlashMenuItems.d.ts

@@ -1,2 +1,3 @@
+import { InlineContentSchema, StyleSchema } from "../../schema";
 import { BaseSlashMenuItem } from "./BaseSlashMenuItem";
-export declare const getDefaultSlashMenuItems: <BSchema extends Record<string, import("../Blocks/api/blockTypes").BlockSpec<string, import("../Blocks/api/blockTypes").PropSchema, boolean>>>(schema?: BSchema) => BaseSlashMenuItem<BSchema>[];
+export declare const getDefaultSlashMenuItems: <BSchema extends Record<string, import("../../schema").BlockConfig>, I extends InlineContentSchema, S extends StyleSchema>(schema?: BSchema) => BaseSlashMenuItem<BSchema, I, S>[];

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

@@ -0,0 +1,74 @@
+import { Plugin, PluginKey, PluginView } from "prosemirror-state";
+import { EditorView } from "prosemirror-view";
+import { EventEmitter } from "../../util/EventEmitter";
+import { DefaultBlockSchema } from "../../blocks/defaultBlocks";
+import type { BlockNoteEditor } from "../../editor/BlockNoteEditor";
+import { BlockFromConfigNoChildren, BlockSchemaWithBlock, InlineContentSchema, StyleSchema } from "../../schema";
+export type TableHandlesState<I extends InlineContentSchema, S extends StyleSchema> = {
+    show: boolean;
+    referencePosCell: DOMRect;
+    referencePosTable: DOMRect;
+    block: BlockFromConfigNoChildren<DefaultBlockSchema["table"], I, S>;
+    colIndex: number;
+    rowIndex: number;
+    draggingState: {
+        draggedCellOrientation: "row" | "col";
+        originalIndex: number;
+        mousePos: number;
+    } | undefined;
+};
+export declare class TableHandlesView<BSchema extends BlockSchemaWithBlock<"table", DefaultBlockSchema["table"]>, I extends InlineContentSchema, S extends StyleSchema> implements PluginView {
+    private readonly editor;
+    private readonly pmView;
+    state?: TableHandlesState<I, S>;
+    updateState: () => void;
+    tableId: string | undefined;
+    tablePos: number | undefined;
+    menuFrozen: boolean;
+    prevWasEditable: boolean | null;
+    constructor(editor: BlockNoteEditor<BSchema, I, S>, pmView: EditorView, updateState: (state: TableHandlesState<I, S>) => void);
+    mouseMoveHandler: (event: MouseEvent) => false | undefined;
+    dragOverHandler: (event: DragEvent) => void;
+    dropHandler: (event: DragEvent) => void;
+    scrollHandler: () => void;
+    destroy(): void;
+}
+export declare const tableHandlesPluginKey: PluginKey<any>;
+export declare class TableHandlesProsemirrorPlugin<BSchema extends BlockSchemaWithBlock<"table", DefaultBlockSchema["table"]>, I extends InlineContentSchema, S extends StyleSchema> extends EventEmitter<any> {
+    private readonly editor;
+    private view;
+    readonly plugin: Plugin;
+    constructor(editor: BlockNoteEditor<BSchema, I, S>);
+    onUpdate(callback: (state: TableHandlesState<I, S>) => void): () => void;
+    /**
+     * Callback that should be set on the `dragStart` event for whichever element
+     * is used as the column drag handle.
+     */
+    colDragStart: (event: {
+        dataTransfer: DataTransfer | null;
+        clientX: number;
+    }) => void;
+    /**
+     * Callback that should be set on the `dragStart` event for whichever element
+     * is used as the row drag handle.
+     */
+    rowDragStart: (event: {
+        dataTransfer: DataTransfer | null;
+        clientY: number;
+    }) => void;
+    /**
+     * Callback that should be set on the `dragEnd` event for both the element
+     * used as the row drag handle, and the one used as the column drag handle.
+     */
+    dragEnd: () => void;
+    /**
+     * Freezes the drag handles. When frozen, they will stay attached to the same
+     * cell regardless of which cell is hovered by the mouse cursor.
+     */
+    freezeHandles: () => boolean;
+    /**
+     * Unfreezes the drag handles. When frozen, they will stay attached to the
+     * same cell regardless of which cell is hovered by the mouse cursor.
+     */
+    unfreezeHandles: () => boolean;
+}

package/types/src/extensions/TextAlignment/TextAlignmentExtension.d.ts

@@ -1,9 +1,2 @@
 import { Extension } from "@tiptap/core";
-declare module "@tiptap/core" {
-    interface Commands<ReturnType> {
-        textAlignment: {
-            setTextAlignment: (textAlignment: "left" | "center" | "right" | "justify") => ReturnType;
-        };
-    }
-}
 export declare const TextAlignmentExtension: Extension<any, any>;

package/types/src/extensions/TextColor/TextColorExtension.d.ts

@@ -1,9 +1,2 @@
 import { Extension } from "@tiptap/core";
-declare module "@tiptap/core" {
-    interface Commands<ReturnType> {
-        blockTextColor: {
-            setBlockTextColor: (posInBlock: number, color: string) => ReturnType;
-        };
-    }
-}
 export declare const TextColorExtension: Extension<any, any>;