@blocknote/core 0.7.1-alpha.0 → 0.8.1

package/types/src/BlockNoteEditor.d.ts

@@ -1,24 +1,28 @@
+import { Node } from "prosemirror-model";
 import { Editor as TiptapEditor } from "@tiptap/core/dist/packages/core/src/Editor";
 import * as Y from "yjs";
 import { UiFactories } from "./BlockNoteExtensions";
-import { Block, BlockIdentifier, PartialBlock } from "./extensions/Blocks/api/blockTypes";
+import { Block, BlockIdentifier, 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 { BaseSlashMenuItem } from "./extensions/SlashMenu";
-export type BlockNoteEditorOptions = {
+export type BlockNoteEditorOptions<BSchema extends BlockSchema> = {
     enableBlockNoteExtensions: boolean;
     /**
      * UI element factories for creating a custom UI, including custom positioning
      * & rendering.
      */
-    uiFactories: UiFactories;
+    uiFactories: UiFactories<BSchema>;
     /**
      * TODO: why is this called slashCommands and not slashMenuItems?
      *
+     * (couldn't fix any type, see https://github.com/TypeCellOS/BlockNote/pull/191#discussion_r1210708771)
+     *
      * @default defaultSlashMenuItems from `./extensions/SlashMenu`
      */
-    slashCommands: BaseSlashMenuItem[];
+    slashCommands: BaseSlashMenuItem<any>[];
     /**
      * The HTML element that should be used as the parent element for the editor.
      *
@@ -34,15 +38,15 @@ export type BlockNoteEditorOptions = {
     /**
      *  A callback function that runs when the editor is ready to be used.
      */
-    onEditorReady: (editor: BlockNoteEditor) => void;
+    onEditorReady: (editor: BlockNoteEditor<BSchema>) => void;
     /**
      * A callback function that runs whenever the editor's contents change.
      */
-    onEditorContentChange: (editor: BlockNoteEditor) => void;
+    onEditorContentChange: (editor: BlockNoteEditor<BSchema>) => void;
     /**
      * A callback function that runs whenever the text cursor position changes.
      */
-    onTextCursorPositionChange: (editor: BlockNoteEditor) => void;
+    onTextCursorPositionChange: (editor: BlockNoteEditor<BSchema>) => void;
     /**
      * Locks the editor from being editable by the user if set to `false`.
      */
@@ -50,7 +54,7 @@ export type BlockNoteEditorOptions = {
     /**
      * The content that should be in the editor when it's created, represented as an array of partial block objects.
      */
-    initialContent: PartialBlock[];
+    initialContent: PartialBlock<BSchema>[];
     /**
      * Use default BlockNote font and reset the styles of <p> <li> <h1> elements etc., that are used in BlockNote.
      *
@@ -63,6 +67,10 @@ export type BlockNoteEditorOptions = {
      * @default "light"
      */
     theme: "light" | "dark";
+    /**
+     * A list of block types that should be available in the editor.
+     */
+    blockSchema: BSchema;
     /**
      * When enabled, allows for collaboration between multiple users.
      */
@@ -89,37 +97,44 @@ export type BlockNoteEditorOptions = {
     };
     _tiptapOptions: any;
 };
-export declare class BlockNoteEditor {
+export declare class BlockNoteEditor<BSchema extends BlockSchema = DefaultBlockSchema> {
     private readonly options;
     readonly _tiptapEditor: TiptapEditor & {
         contentComponent: any;
     };
-    private blockCache;
+    blockCache: WeakMap<Node, Block<BSchema>>;
+    readonly schema: BSchema;
     get domElement(): HTMLDivElement;
+    isFocused(): boolean;
     focus(): void;
-    constructor(options?: Partial<BlockNoteEditorOptions>);
+    constructor(options?: Partial<BlockNoteEditorOptions<BSchema>>);
     /**
      * 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[];
+    get topLevelBlocks(): Block<BSchema>[];
     /**
      * 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 | undefined;
+    getBlock(blockIdentifier: BlockIdentifier): Block<BSchema> | 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) => boolean, reverse?: boolean): void;
+    forEachBlock(callback: (block: Block<BSchema>) => boolean, reverse?: boolean): void;
+    /**
+     * Executes a callback whenever the editor's contents change.
+     * @param callback The callback to execute.
+     */
+    onEditorContentChange(callback: () => void): void;
     /**
      * Gets a snapshot of the current text cursor position.
      * @returns A snapshot of the current text cursor position.
      */
-    getTextCursorPosition(): TextCursorPosition;
+    getTextCursorPosition(): TextCursorPosition<BSchema>;
     /**
      * 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.
@@ -130,7 +145,7 @@ export declare class BlockNoteEditor {
     /**
      * Gets a snapshot of the current selection.
      */
-    getSelection(): Selection | undefined;
+    getSelection(): Selection<BSchema> | undefined;
     /**
      * Checks if the editor is currently editable, or if it's locked.
      * @returns True if the editor is editable, false otherwise.
@@ -149,7 +164,7 @@ export declare class BlockNoteEditor {
      * @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[], referenceBlock: BlockIdentifier, placement?: "before" | "after" | "nested"): void;
+    insertBlocks(blocksToInsert: PartialBlock<BSchema>[], 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
@@ -157,7 +172,7 @@ export declare class BlockNoteEditor {
      * @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): void;
+    updateBlock(blockToUpdate: BlockIdentifier, update: PartialBlock<BSchema>): 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.
@@ -170,7 +185,7 @@ export declare class BlockNoteEditor {
      * @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[]): void;
+    replaceBlocks(blocksToRemove: BlockIdentifier[], blocksToInsert: PartialBlock<BSchema>[]): void;
     /**
      * Gets the active text styles at the text cursor position or at the end of the current selection if it's active.
      */
@@ -226,7 +241,7 @@ export declare class BlockNoteEditor {
      * @param blocks An array of blocks that should be serialized into HTML.
      * @returns The blocks, serialized as an HTML string.
      */
-    blocksToHTML(blocks: Block[]): Promise<string>;
+    blocksToHTML(blocks: Block<BSchema>[]): 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
@@ -234,14 +249,14 @@ export declare class BlockNoteEditor {
      * @param html The HTML string to parse blocks from.
      * @returns The blocks parsed from the HTML string.
      */
-    HTMLToBlocks(html: string): Promise<Block[]>;
+    HTMLToBlocks(html: string): Promise<Block<BSchema>[]>;
     /**
      * 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[]): Promise<string>;
+    blocksToMarkdown(blocks: Block<BSchema>[]): 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
@@ -249,7 +264,7 @@ export declare class BlockNoteEditor {
      * @param markdown The Markdown string to parse blocks from.
      * @returns The blocks parsed from the Markdown string.
      */
-    markdownToBlocks(markdown: string): Promise<Block[]>;
+    markdownToBlocks(markdown: string): Promise<Block<BSchema>[]>;
     /**
      * Updates the user info for the current user that's shown to other collaborators.
      */

package/types/src/BlockNoteExtensions.d.ts

@@ -1,24 +1,31 @@
 import { Extensions } from "@tiptap/core";
 import { BlockNoteEditor } from "./BlockNoteEditor";
 import * as Y from "yjs";
+import { BlockSchema } from "./extensions/Blocks/api/blockTypes";
 import { BlockSideMenuFactory } from "./extensions/DraggableBlocks/BlockSideMenuFactoryTypes";
 import { FormattingToolbarFactory } from "./extensions/FormattingToolbar/FormattingToolbarFactoryTypes";
 import { HyperlinkToolbarFactory } from "./extensions/HyperlinkToolbar/HyperlinkToolbarFactoryTypes";
 import { BaseSlashMenuItem } from "./extensions/SlashMenu";
 import { SuggestionsMenuFactory } from "./shared/plugins/suggestion/SuggestionsMenuFactoryTypes";
-export type UiFactories = Partial<{
-    formattingToolbarFactory: FormattingToolbarFactory;
+export type UiFactories<BSchema extends BlockSchema> = Partial<{
+    formattingToolbarFactory: FormattingToolbarFactory<BSchema>;
     hyperlinkToolbarFactory: HyperlinkToolbarFactory;
-    slashMenuFactory: SuggestionsMenuFactory<BaseSlashMenuItem>;
-    blockSideMenuFactory: BlockSideMenuFactory;
+    slashMenuFactory: SuggestionsMenuFactory<BaseSlashMenuItem<BSchema>>;
+    blockSideMenuFactory: BlockSideMenuFactory<BSchema>;
 }>;
 /**
  * Get all the Tiptap extensions BlockNote is configured with by default
  */
-export declare const getBlockNoteExtensions: (opts: {
-    editor: BlockNoteEditor;
-    uiFactories: UiFactories;
-    slashCommands: BaseSlashMenuItem[];
+export declare const getBlockNoteExtensions: <BSchema extends Record<string, import("./extensions/Blocks/api/blockTypes").BlockSpec<string, import("./extensions/Blocks/api/blockTypes").PropSchema>>>(opts: {
+    editor: BlockNoteEditor<BSchema>;
+    uiFactories: Partial<{
+        formattingToolbarFactory: FormattingToolbarFactory<BSchema>;
+        hyperlinkToolbarFactory: HyperlinkToolbarFactory;
+        slashMenuFactory: SuggestionsMenuFactory<BaseSlashMenuItem<BSchema>>;
+        blockSideMenuFactory: BlockSideMenuFactory<BSchema>;
+    }>;
+    slashCommands: BaseSlashMenuItem<any>[];
+    blockSchema: BSchema;
     collaboration?: {
         fragment: Y.XmlFragment;
         user: {

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

@@ -1,6 +1,6 @@
 import { Editor } from "@tiptap/core";
-import { BlockIdentifier, PartialBlock } from "../../extensions/Blocks/api/blockTypes";
-export declare function insertBlocks(blocksToInsert: PartialBlock[], referenceBlock: BlockIdentifier, placement: "before" | "after" | "nested" | undefined, editor: Editor): void;
-export declare function updateBlock(blockToUpdate: BlockIdentifier, update: PartialBlock, editor: Editor): void;
+import { BlockIdentifier, BlockSchema, PartialBlock } from "../../extensions/Blocks/api/blockTypes";
+export declare function insertBlocks<BSchema extends BlockSchema>(blocksToInsert: PartialBlock<BSchema>[], referenceBlock: BlockIdentifier, placement: "before" | "after" | "nested" | undefined, editor: Editor): void;
+export declare function updateBlock<BSchema extends BlockSchema>(blockToUpdate: BlockIdentifier, update: PartialBlock<BSchema>, editor: Editor): void;
 export declare function removeBlocks(blocksToRemove: BlockIdentifier[], editor: Editor): void;
-export declare function replaceBlocks(blocksToRemove: BlockIdentifier[], blocksToInsert: PartialBlock[], editor: Editor): void;
+export declare function replaceBlocks<BSchema extends BlockSchema>(blocksToRemove: BlockIdentifier[], blocksToInsert: PartialBlock<BSchema>[], editor: Editor): void;

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

@@ -1,6 +1,6 @@
 import { Schema } from "prosemirror-model";
-import { Block } from "../../extensions/Blocks/api/blockTypes";
-export declare function blocksToHTML(blocks: Block[], schema: Schema): Promise<string>;
-export declare function HTMLToBlocks(html: string, schema: Schema): Promise<Block[]>;
-export declare function blocksToMarkdown(blocks: Block[], schema: Schema): Promise<string>;
-export declare function markdownToBlocks(markdown: string, schema: Schema): Promise<Block[]>;
+import { Block, BlockSchema } from "../../extensions/Blocks/api/blockTypes";
+export declare function blocksToHTML<BSchema extends BlockSchema>(blocks: Block<BSchema>[], schema: Schema): Promise<string>;
+export declare function HTMLToBlocks<BSchema extends BlockSchema>(html: string, blockSchema: BSchema, schema: Schema): Promise<Block<BSchema>[]>;
+export declare function blocksToMarkdown<BSchema extends BlockSchema>(blocks: Block<BSchema>[], schema: Schema): Promise<string>;
+export declare function markdownToBlocks<BSchema extends BlockSchema>(markdown: string, blockSchema: BSchema, schema: Schema): Promise<Block<BSchema>[]>;

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

@@ -1,5 +1,5 @@
 import { Node, Schema } from "prosemirror-model";
-import { Block, PartialBlock } from "../../extensions/Blocks/api/blockTypes";
+import { Block, BlockSchema, PartialBlock } from "../../extensions/Blocks/api/blockTypes";
 import { PartialInlineContent } from "../../extensions/Blocks/api/inlineContentTypes";
 /**
  * converts an array of inline content elements to prosemirror nodes
@@ -8,8 +8,8 @@ export declare function inlineContentToNodes(blockContent: PartialInlineContent[
 /**
  * Converts a BlockNote block to a TipTap node.
  */
-export declare function blockToNode(block: PartialBlock, schema: Schema): Node;
+export declare function blockToNode<BSchema extends BlockSchema>(block: PartialBlock<BSchema>, schema: Schema): Node;
 /**
  * Convert a TipTap node to a BlockNote block.
  */
-export declare function nodeToBlock(node: Node, blockCache?: WeakMap<Node, Block>): Block;
+export declare function nodeToBlock<BSchema extends BlockSchema>(node: Node, blockSchema: BSchema, blockCache?: WeakMap<Node, Block<BSchema>>): Block<BSchema>;

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

@@ -1,2 +1,2 @@
-import { Block, PartialBlock } from "../../extensions/Blocks/api/blockTypes";
-export declare function partialBlockToBlockForTesting(partialBlock: PartialBlock): Block;
+import { Block, BlockSchema, PartialBlock } from "../../extensions/Blocks/api/blockTypes";
+export declare function partialBlockToBlockForTesting<BSchema extends BlockSchema>(partialBlock: PartialBlock<BSchema>): Block<BSchema>;

package/types/src/extensions/Blocks/api/block.d.ts

@@ -1,9 +1,8 @@
-import { Attribute, Extension } from "@tiptap/core";
+import { Attribute } from "@tiptap/core";
 import { BlockConfig, BlockSchema, BlockSpec, PropSchema, TipTapNode, TipTapNodeConfig } from "./blockTypes";
+export declare function camelToDataKebab(str: string): string;
 export declare function propsToAttributes<BType extends string, PSchema extends PropSchema, ContainsInlineContent extends boolean, BSchema extends BlockSchema>(blockConfig: Omit<BlockConfig<BType, PSchema, ContainsInlineContent, BSchema>, "render">): Record<string, Attribute>;
 export declare function parse<BType extends string, PSchema extends PropSchema, ContainsInlineContent extends boolean, BSchema extends BlockSchema>(blockConfig: Omit<BlockConfig<BType, PSchema, ContainsInlineContent, BSchema>, "render">): {
-    getAttrs: (node: HTMLElement | string) => false | import("./blockTypes").Props<PSchema>;
-}[] | {
     tag: string;
 }[];
 export declare function render<BType extends string, PSchema extends PropSchema, ContainsInlineContent extends boolean, BSchema extends BlockSchema>(blockConfig: Omit<BlockConfig<BType, PSchema, ContainsInlineContent, BSchema>, "render">, HTMLAttributes: Record<string, any>): {
@@ -15,4 +14,3 @@ export declare function render<BType extends string, PSchema extends PropSchema,
 };
 export declare function createBlockSpec<BType extends string, PSchema extends PropSchema, ContainsInlineContent extends boolean, BSchema extends BlockSchema>(blockConfig: BlockConfig<BType, PSchema, ContainsInlineContent, BSchema>): BlockSpec<BType, PSchema>;
 export declare function createTipTapBlock<Type extends string>(config: TipTapNodeConfig<Type>): TipTapNode<Type>;
-export declare const CustomBlockSerializerExtension: Extension<any, any>;

package/types/src/extensions/Blocks/api/blockTypes.d.ts

@@ -1,37 +1,81 @@
 /** Define the main block types **/
+import { Node, NodeConfig } from "@tiptap/core";
+import { BlockNoteEditor } from "../../../BlockNoteEditor";
 import { InlineContent, PartialInlineContent } from "./inlineContentTypes";
-export type BlockTemplate<Type extends string, Props extends Record<string, string>> = {
-    id: string;
+export type TipTapNodeConfig<Name extends string, Options = any, Storage = any> = {
+    [K in keyof NodeConfig<Options, Storage>]: K extends "name" ? Name : K extends "group" ? never : NodeConfig<Options, Storage>[K];
+};
+export type TipTapNode<Name extends string, Options = any, Storage = any> = Node<Options, Storage> & {
+    name: Name;
+    group: "blockContent";
+};
+export type PropSpec = {
+    values?: readonly string[];
+    default: string;
+};
+export type PropSchema = Record<string, PropSpec>;
+export type Props<PSchema extends PropSchema> = {
+    [PType in keyof PSchema]: PSchema[PType]["values"] extends readonly string[] ? PSchema[PType]["values"][number] : string;
+};
+export type BlockConfig<Type extends string, PSchema extends PropSchema, ContainsInlineContent extends boolean, BSchema extends BlockSchema> = {
     type: Type;
-    props: Props;
-    content: InlineContent[];
-    children: Block[];
-};
-export type DefaultBlockProps = {
-    backgroundColor: string;
-    textColor: string;
-    textAlignment: "left" | "center" | "right" | "justify";
-};
-export type NumberedListItemBlock = BlockTemplate<"numberedListItem", DefaultBlockProps>;
-export type BulletListItemBlock = BlockTemplate<"bulletListItem", DefaultBlockProps>;
-export type HeadingBlock = BlockTemplate<"heading", DefaultBlockProps & {
-    level: "1" | "2" | "3";
+    readonly propSchema: PSchema;
+    containsInlineContent: ContainsInlineContent;
+    render: (
+    /**
+     * The custom block to render
+     */
+    block: SpecificBlock<BSchema & {
+        [k in Type]: BlockSpec<Type, PSchema>;
+    }, Type>, 
+    /**
+     * The BlockNote editor instance
+     * This is typed generically. If you want an editor with your custom schema, you need to
+     * cast it manually, e.g.: `const e = editor as BlockNoteEditor<typeof mySchema>;`
+     */
+    editor: BlockNoteEditor<BSchema & {
+        [k in Type]: BlockSpec<Type, PSchema>;
+    }>) => ContainsInlineContent extends true ? {
+        dom: HTMLElement;
+        contentDOM: HTMLElement;
+    } : {
+        dom: HTMLElement;
+    };
+};
+export type BlockSpec<Type extends string, PSchema extends PropSchema> = {
+    readonly propSchema: PSchema;
+    node: TipTapNode<Type>;
+};
+export type TypesMatch<Blocks extends Record<string, BlockSpec<string, PropSchema>>> = Blocks extends {
+    [Type in keyof Blocks]: Type extends string ? Blocks[Type] extends BlockSpec<Type, PropSchema> ? Blocks[Type] : never : never;
+} ? Blocks : never;
+export type BlockSchema = TypesMatch<Record<string, BlockSpec<string, PropSchema>>>;
+type BlocksWithoutChildren<BSchema extends BlockSchema> = {
+    [BType in keyof BSchema]: {
+        id: string;
+        type: BType;
+        props: Props<BSchema[BType]["propSchema"]>;
+        content: InlineContent[];
+    };
+};
+export type Block<BSchema extends BlockSchema> = BlocksWithoutChildren<BSchema>[keyof BlocksWithoutChildren<BSchema>] & {
+    children: Block<BSchema>[];
+};
+export type SpecificBlock<BSchema extends BlockSchema, BlockType extends keyof BSchema> = BlocksWithoutChildren<BSchema>[BlockType] & {
+    children: Block<BSchema>[];
+};
+type PartialBlocksWithoutChildren<BSchema extends BlockSchema> = {
+    [BType in keyof BSchema]: Partial<{
+        id: string;
+        type: BType;
+        props: Partial<Props<BSchema[BType]["propSchema"]>>;
+        content: PartialInlineContent[] | string;
+    }>;
+};
+export type PartialBlock<BSchema extends BlockSchema> = PartialBlocksWithoutChildren<BSchema>[keyof PartialBlocksWithoutChildren<BSchema>] & Partial<{
+    children: PartialBlock<BSchema>[];
 }>;
-export type ParagraphBlock = BlockTemplate<"paragraph", DefaultBlockProps>;
-export type Block = ParagraphBlock | HeadingBlock | BulletListItemBlock | NumberedListItemBlock;
-export type BlockIdentifier = string | Block;
-/** Define "Partial Blocks", these are for updating or creating blocks */
-export type PartialBlockTemplate<B extends Block> = B extends Block ? Partial<Omit<B, "props" | "children" | "content" | "type">> & {
-    type?: B["type"];
-    props?: Partial<B["props"]>;
-    content?: string | PartialInlineContent[];
-    children?: PartialBlock[];
-} : never;
-export type PartialBlock = PartialBlockTemplate<Block>;
-export type BlockPropsTemplate<Props> = Props extends Block["props"] ? keyof Props : never;
-/**
- * Expose blockProps. This is currently not very nice, but it's expected this
- * will change anyway once we allow for custom blocks
- */
-export declare const globalProps: Array<keyof DefaultBlockProps>;
-export declare const blockProps: Record<Block["type"], Set<string>>;
+export type BlockIdentifier = {
+    id: string;
+} | string;
+export {};

package/types/src/extensions/Blocks/api/cursorPositionTypes.d.ts

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

package/types/src/extensions/Blocks/api/defaultBlocks.d.ts

@@ -26,7 +26,7 @@ export declare const defaultBlockSchema: {
                 values: readonly ["left", "center", "right", "justify"];
             };
         };
-        readonly node: import("./blockTypes").TipTapNode<"paragraph", any, any>;
+        readonly node: import("./blockTypes").TipTapNode<"paragraph">;
     };
     readonly heading: {
         readonly propSchema: {
@@ -45,7 +45,7 @@ export declare const defaultBlockSchema: {
                 values: readonly ["left", "center", "right", "justify"];
             };
         };
-        readonly node: import("./blockTypes").TipTapNode<"heading", any, any>;
+        readonly node: import("./blockTypes").TipTapNode<"heading">;
     };
     readonly bulletListItem: {
         readonly propSchema: {
@@ -60,7 +60,7 @@ export declare const defaultBlockSchema: {
                 values: readonly ["left", "center", "right", "justify"];
             };
         };
-        readonly node: import("./blockTypes").TipTapNode<"bulletListItem", any, any>;
+        readonly node: import("./blockTypes").TipTapNode<"bulletListItem">;
     };
     readonly numberedListItem: {
         readonly propSchema: {
@@ -75,7 +75,7 @@ export declare const defaultBlockSchema: {
                 values: readonly ["left", "center", "right", "justify"];
             };
         };
-        readonly node: import("./blockTypes").TipTapNode<"numberedListItem", any, any>;
+        readonly node: import("./blockTypes").TipTapNode<"numberedListItem">;
     };
 };
 export type DefaultBlockSchema = TypesMatch<typeof defaultBlockSchema>;

package/types/src/extensions/Blocks/api/selectionTypes.d.ts

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

package/types/src/extensions/Blocks/api/serialization.d.ts

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

package/types/src/extensions/Blocks/nodes/BlockContainer.d.ts

@@ -1,5 +1,5 @@
 import { Node } from "@tiptap/core";
-import { PartialBlock } from "../api/blockTypes";
+import { BlockSchema, PartialBlock } from "../api/blockTypes";
 export interface IBlock {
     HTMLAttributes: Record<string, any>;
 }
@@ -10,8 +10,8 @@ declare module "@tiptap/core" {
             BNDeleteBlock: (posInBlock: number) => ReturnType;
             BNMergeBlocks: (posBetweenBlocks: number) => ReturnType;
             BNSplitBlock: (posInBlock: number, keepType: boolean) => ReturnType;
-            BNUpdateBlock: (posInBlock: number, block: PartialBlock) => ReturnType;
-            BNCreateOrUpdateBlock: (posInBlock: number, block: PartialBlock) => ReturnType;
+            BNUpdateBlock: <BSchema extends BlockSchema>(posInBlock: number, block: PartialBlock<BSchema>) => ReturnType;
+            BNCreateOrUpdateBlock: <BSchema extends BlockSchema>(posInBlock: number, block: PartialBlock<BSchema>) => ReturnType;
         };
     }
 }

package/types/src/extensions/Blocks/nodes/BlockContent/HeadingBlockContent/HeadingBlockContent.d.ts

@@ -1,2 +1 @@
-import { Node } from "@tiptap/core";
-export declare const HeadingBlockContent: Node<any, any>;
+export declare const HeadingBlockContent: import("../../../api/blockTypes").TipTapNode<"heading">;

package/types/src/extensions/Blocks/nodes/BlockContent/ListItemBlockContent/BulletListItemBlockContent/BulletListItemBlockContent.d.ts

@@ -1,2 +1 @@
-import { Node } from "@tiptap/core";
-export declare const BulletListItemBlockContent: Node<any, any>;
+export declare const BulletListItemBlockContent: import("../../../../api/blockTypes").TipTapNode<"bulletListItem">;

package/types/src/extensions/Blocks/nodes/BlockContent/ListItemBlockContent/NumberedListItemBlockContent/NumberedListItemBlockContent.d.ts

@@ -1,2 +1 @@
-import { Node } from "@tiptap/core";
-export declare const NumberedListItemBlockContent: Node<any, any>;
+export declare const NumberedListItemBlockContent: import("../../../../api/blockTypes").TipTapNode<"numberedListItem">;

package/types/src/extensions/Blocks/nodes/BlockContent/ParagraphBlockContent/ParagraphBlockContent.d.ts

@@ -1,2 +1 @@
-import { Node } from "@tiptap/core";
-export declare const ParagraphBlockContent: Node<any, any>;
+export declare const ParagraphBlockContent: import("../../../api/blockTypes").TipTapNode<"paragraph">;

package/types/src/extensions/DraggableBlocks/BlockSideMenuFactoryTypes.d.ts

@@ -1,17 +1,17 @@
 import { EditorElement, ElementFactory } from "../../shared/EditorElement";
 import { BlockNoteEditor } from "../../BlockNoteEditor";
-import { Block } from "../Blocks/api/blockTypes";
-export type BlockSideMenuStaticParams = {
-    editor: BlockNoteEditor;
+import { Block, BlockSchema } from "../Blocks/api/blockTypes";
+export type BlockSideMenuStaticParams<BSchema extends BlockSchema> = {
+    editor: BlockNoteEditor<BSchema>;
     addBlock: () => void;
     blockDragStart: (event: DragEvent) => void;
     blockDragEnd: () => void;
     freezeMenu: () => void;
     unfreezeMenu: () => void;
 };
-export type BlockSideMenuDynamicParams = {
-    block: Block;
+export type BlockSideMenuDynamicParams<BSchema extends BlockSchema> = {
+    block: Block<BSchema>;
     referenceRect: DOMRect;
 };
-export type BlockSideMenu = EditorElement<BlockSideMenuDynamicParams>;
-export type BlockSideMenuFactory = ElementFactory<BlockSideMenuStaticParams, BlockSideMenuDynamicParams>;
+export type BlockSideMenu<BSchema extends BlockSchema> = EditorElement<BlockSideMenuDynamicParams<BSchema>>;
+export type BlockSideMenuFactory<BSchema extends BlockSchema> = ElementFactory<BlockSideMenuStaticParams<BSchema>, BlockSideMenuDynamicParams<BSchema>>;

package/types/src/extensions/DraggableBlocks/DraggableBlocksExtension.d.ts

@@ -1,10 +1,11 @@
 import { Editor, Extension } from "@tiptap/core";
 import { BlockSideMenuFactory } from "./BlockSideMenuFactoryTypes";
 import { BlockNoteEditor } from "../../BlockNoteEditor";
-export type DraggableBlocksOptions = {
+import { BlockSchema } from "../Blocks/api/blockTypes";
+export type DraggableBlocksOptions<BSchema extends BlockSchema> = {
     tiptapEditor: Editor;
-    editor: BlockNoteEditor;
-    blockSideMenuFactory: BlockSideMenuFactory;
+    editor: BlockNoteEditor<BSchema>;
+    blockSideMenuFactory: BlockSideMenuFactory<BSchema>;
 };
 /**
  * This extension adds a menu to the side of blocks which features various BlockNote functions such as adding and
@@ -12,4 +13,4 @@ export type DraggableBlocksOptions = {
  *
  * code based on https://github.com/ueberdosis/tiptap/issues/323#issuecomment-506637799
  */
-export declare const DraggableBlocksExtension: Extension<DraggableBlocksOptions, any>;
+export declare const createDraggableBlocksExtension: <BSchema extends Record<string, import("../Blocks/api/blockTypes").BlockSpec<string, import("../Blocks/api/blockTypes").PropSchema>>>() => Extension<DraggableBlocksOptions<BSchema>, any>;

package/types/src/extensions/DraggableBlocks/DraggableBlocksPlugin.d.ts

@@ -3,23 +3,24 @@ import { Plugin } from "prosemirror-state";
 import { BlockSideMenu, BlockSideMenuDynamicParams, BlockSideMenuFactory, BlockSideMenuStaticParams } from "./BlockSideMenuFactoryTypes";
 import { DraggableBlocksOptions } from "./DraggableBlocksExtension";
 import { BlockNoteEditor } from "../../BlockNoteEditor";
-export type BlockMenuViewProps = {
+import { BlockSchema } from "../Blocks/api/blockTypes";
+export type BlockMenuViewProps<BSchema extends BlockSchema> = {
     tiptapEditor: Editor;
-    editor: BlockNoteEditor;
-    blockMenuFactory: BlockSideMenuFactory;
+    editor: BlockNoteEditor<BSchema>;
+    blockMenuFactory: BlockSideMenuFactory<BSchema>;
     horizontalPosAnchoredAtRoot: boolean;
 };
-export declare class BlockMenuView {
-    editor: BlockNoteEditor;
+export declare class BlockMenuView<BSchema extends BlockSchema> {
+    editor: BlockNoteEditor<BSchema>;
     private ttEditor;
     horizontalPosAnchoredAtRoot: boolean;
     horizontalPosAnchor: number;
-    blockMenu: BlockSideMenu;
+    blockMenu: BlockSideMenu<BSchema>;
     hoveredBlock: HTMLElement | undefined;
     isDragging: boolean;
     menuOpen: boolean;
     menuFrozen: boolean;
-    constructor({ tiptapEditor, editor, blockMenuFactory, horizontalPosAnchoredAtRoot, }: BlockMenuViewProps);
+    constructor({ tiptapEditor, editor, blockMenuFactory, horizontalPosAnchoredAtRoot, }: BlockMenuViewProps<BSchema>);
     /**
      * Sets isDragging when dragging text.
      */
@@ -31,7 +32,7 @@ export declare class BlockMenuView {
      */
     onDrop: (event: DragEvent) => void;
     /**
-     * If the event is outside of the editor contents,
+     * If the event is outside the editor contents,
      * we dispatch a fake event, so that we can still drop the content
      * when dragging / dropping to the side of the editor
      */
@@ -42,7 +43,7 @@ export declare class BlockMenuView {
     onScroll: () => void;
     destroy(): void;
     addBlock(): void;
-    getStaticParams(): BlockSideMenuStaticParams;
-    getDynamicParams(): BlockSideMenuDynamicParams;
+    getStaticParams(): BlockSideMenuStaticParams<BSchema>;
+    getDynamicParams(): BlockSideMenuDynamicParams<BSchema>;
 }
-export declare const createDraggableBlocksPlugin: (options: DraggableBlocksOptions) => Plugin<any>;
+export declare const createDraggableBlocksPlugin: <BSchema extends Record<string, import("../Blocks/api/blockTypes").BlockSpec<string, import("../Blocks/api/blockTypes").PropSchema>>>(options: DraggableBlocksOptions<BSchema>) => Plugin<any>;