@blocknote/core 0.7.1-alpha.0 → 0.8.0

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.
      */
@@ -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>;

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

@@ -1,10 +1,11 @@
 import { Extension } from "@tiptap/core";
-import { BlockNoteEditor } from "../..";
+import { BlockNoteEditor, BlockSchema } from "../..";
 import { FormattingToolbarFactory } from "./FormattingToolbarFactoryTypes";
+export type FormattingToolbarOptions<BSchema extends BlockSchema> = {
+    formattingToolbarFactory: FormattingToolbarFactory<BSchema>;
+    editor: BlockNoteEditor<BSchema>;
+};
 /**
  * The menu that is displayed when selecting a piece of text.
  */
-export declare const FormattingToolbarExtension: Extension<{
-    formattingToolbarFactory: FormattingToolbarFactory;
-    editor: BlockNoteEditor;
-}, any>;
+export declare const createFormattingToolbarExtension: <BSchema extends Record<string, import("../..").BlockSpec<string, import("../..").PropSchema>>>() => Extension<FormattingToolbarOptions<BSchema>, any>;

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

@@ -1,10 +1,11 @@
 import { EditorElement, ElementFactory } from "../../shared/EditorElement";
 import { BlockNoteEditor } from "../../BlockNoteEditor";
-export type FormattingToolbarStaticParams = {
-    editor: BlockNoteEditor;
+import { BlockSchema } from "../Blocks/api/blockTypes";
+export type FormattingToolbarStaticParams<BSchema extends BlockSchema> = {
+    editor: BlockNoteEditor<BSchema>;
 };
 export type FormattingToolbarDynamicParams = {
     referenceRect: DOMRect;
 };
 export type FormattingToolbar = EditorElement<FormattingToolbarDynamicParams>;
-export type FormattingToolbarFactory = ElementFactory<FormattingToolbarStaticParams, FormattingToolbarDynamicParams>;
+export type FormattingToolbarFactory<BSchema extends BlockSchema> = ElementFactory<FormattingToolbarStaticParams<BSchema>, FormattingToolbarDynamicParams>;

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

@@ -1,27 +1,19 @@
 import { Editor } from "@tiptap/core";
 import { EditorState, Plugin, PluginKey } from "prosemirror-state";
 import { EditorView } from "prosemirror-view";
-import { BlockNoteEditor } from "../..";
+import { BlockNoteEditor, BlockSchema } from "../..";
 import { FormattingToolbar, FormattingToolbarDynamicParams, FormattingToolbarFactory, FormattingToolbarStaticParams } from "./FormattingToolbarFactoryTypes";
-export interface FormattingToolbarPluginProps {
+export interface FormattingToolbarPluginProps<BSchema extends BlockSchema> {
     pluginKey: PluginKey;
     tiptapEditor: Editor;
-    editor: BlockNoteEditor;
-    formattingToolbarFactory: FormattingToolbarFactory;
-    shouldShow?: ((props: {
-        editor: BlockNoteEditor;
-        view: EditorView;
-        state: EditorState;
-        oldState?: EditorState;
-        from: number;
-        to: number;
-    }) => boolean) | null;
+    editor: BlockNoteEditor<BSchema>;
+    formattingToolbarFactory: FormattingToolbarFactory<BSchema>;
 }
-export type FormattingToolbarViewProps = FormattingToolbarPluginProps & {
+export type FormattingToolbarViewProps<BSchema extends BlockSchema> = FormattingToolbarPluginProps<BSchema> & {
     view: EditorView;
 };
-export declare class FormattingToolbarView {
-    editor: BlockNoteEditor;
+export declare class FormattingToolbarView<BSchema extends BlockSchema> {
+    editor: BlockNoteEditor<BSchema>;
     private ttEditor;
     view: EditorView;
     formattingToolbar: FormattingToolbar;
@@ -29,8 +21,13 @@ export declare class FormattingToolbarView {
     preventShow: boolean;
     toolbarIsOpen: boolean;
     prevWasEditable: boolean | null;
-    shouldShow: Exclude<FormattingToolbarPluginProps["shouldShow"], null>;
-    constructor({ editor, tiptapEditor, formattingToolbarFactory, view, shouldShow, }: FormattingToolbarViewProps);
+    shouldShow: (props: {
+        view: EditorView;
+        state: EditorState;
+        from: number;
+        to: number;
+    }) => boolean;
+    constructor({ editor, tiptapEditor, formattingToolbarFactory, view, }: FormattingToolbarViewProps<BSchema>);
     viewMousedownHandler: () => void;
     viewMouseupHandler: () => void;
     dragstartHandler: () => void;
@@ -42,7 +39,7 @@ export declare class FormattingToolbarView {
     update(view: EditorView, oldState?: EditorState): void;
     destroy(): void;
     getSelectionBoundingBox(): DOMRect;
-    getStaticParams(): FormattingToolbarStaticParams;
+    getStaticParams(): FormattingToolbarStaticParams<BSchema>;
     getDynamicParams(): FormattingToolbarDynamicParams;
 }
-export declare const createFormattingToolbarPlugin: (options: FormattingToolbarPluginProps) => Plugin<any>;
+export declare const createFormattingToolbarPlugin: <BSchema extends Record<string, import("../..").BlockSpec<string, import("../..").PropSchema>>>(options: FormattingToolbarPluginProps<BSchema>) => Plugin<any>;

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

@@ -1,13 +1,14 @@
 import { SuggestionItem } from "../../shared/plugins/suggestion/SuggestionItem";
 import { BlockNoteEditor } from "../../BlockNoteEditor";
+import { BlockSchema } from "../Blocks/api/blockTypes";
 /**
  * A class that defines a slash command (/<command>).
  *
  * (Not to be confused with ProseMirror commands nor TipTap commands.)
  */
-export declare class BaseSlashMenuItem extends SuggestionItem {
+export declare class BaseSlashMenuItem<BSchema extends BlockSchema> extends SuggestionItem {
     readonly name: string;
-    readonly execute: (editor: BlockNoteEditor) => void;
+    readonly execute: (editor: BlockNoteEditor<BSchema>) => void;
     readonly aliases: string[];
     /**
      * Constructs a new slash-command.
@@ -16,5 +17,5 @@ export declare class BaseSlashMenuItem extends SuggestionItem {
      * @param execute The callback for creating a new node
      * @param aliases Aliases for this command
      */
-    constructor(name: string, execute: (editor: BlockNoteEditor) => void, aliases?: string[]);
+    constructor(name: string, execute: (editor: BlockNoteEditor<BSchema>) => void, aliases?: string[]);
 }

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

@@ -3,10 +3,11 @@ import { PluginKey } from "prosemirror-state";
 import { SuggestionsMenuFactory } from "../../shared/plugins/suggestion/SuggestionsMenuFactoryTypes";
 import { BaseSlashMenuItem } from "./BaseSlashMenuItem";
 import { BlockNoteEditor } from "../../BlockNoteEditor";
-export type SlashMenuOptions = {
-    editor: BlockNoteEditor | undefined;
-    commands: BaseSlashMenuItem[] | undefined;
+import { BlockSchema } from "../Blocks/api/blockTypes";
+export type SlashMenuOptions<BSchema extends BlockSchema> = {
+    editor: BlockNoteEditor<BSchema> | undefined;
+    commands: BaseSlashMenuItem<BSchema>[] | undefined;
     slashMenuFactory: SuggestionsMenuFactory<any> | undefined;
 };
 export declare const SlashMenuPluginKey: PluginKey<any>;
-export declare const SlashMenuExtension: Extension<SlashMenuOptions, any>;
+export declare const createSlashMenuExtension: <BSchema extends Record<string, import("../Blocks/api/blockTypes").BlockSpec<string, import("../Blocks/api/blockTypes").PropSchema>>>() => Extension<SlashMenuOptions<BSchema>, any>;

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

@@ -2,4 +2,69 @@ import { BaseSlashMenuItem } from "./BaseSlashMenuItem";
 /**
  * An array containing commands for creating all default blocks.
  */
-export declare const defaultSlashMenuItems: BaseSlashMenuItem[];
+export declare const defaultSlashMenuItems: BaseSlashMenuItem<{
+    readonly paragraph: {
+        readonly propSchema: {
+            backgroundColor: {
+                default: "transparent";
+            };
+            textColor: {
+                default: "black";
+            };
+            textAlignment: {
+                default: "left";
+                values: readonly ["left", "center", "right", "justify"];
+            };
+        };
+        readonly node: import("../Blocks/api/blockTypes").TipTapNode<"paragraph">;
+    };
+    readonly heading: {
+        readonly propSchema: {
+            readonly level: {
+                readonly default: "1";
+                readonly values: readonly ["1", "2", "3"];
+            };
+            readonly backgroundColor: {
+                default: "transparent";
+            };
+            readonly textColor: {
+                default: "black";
+            };
+            readonly textAlignment: {
+                default: "left";
+                values: readonly ["left", "center", "right", "justify"];
+            };
+        };
+        readonly node: import("../Blocks/api/blockTypes").TipTapNode<"heading">;
+    };
+    readonly bulletListItem: {
+        readonly propSchema: {
+            backgroundColor: {
+                default: "transparent";
+            };
+            textColor: {
+                default: "black";
+            };
+            textAlignment: {
+                default: "left";
+                values: readonly ["left", "center", "right", "justify"];
+            };
+        };
+        readonly node: import("../Blocks/api/blockTypes").TipTapNode<"bulletListItem">;
+    };
+    readonly numberedListItem: {
+        readonly propSchema: {
+            backgroundColor: {
+                default: "transparent";
+            };
+            textColor: {
+                default: "black";
+            };
+            textAlignment: {
+                default: "left";
+                values: readonly ["left", "center", "right", "justify"];
+            };
+        };
+        readonly node: import("../Blocks/api/blockTypes").TipTapNode<"numberedListItem">;
+    };
+}>[];

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

@@ -1,4 +1,4 @@
 import { defaultSlashMenuItems } from "./defaultSlashMenuItems";
-import { SlashMenuExtension } from "./SlashMenuExtension";
+import { createSlashMenuExtension } from "./SlashMenuExtension";
 import { BaseSlashMenuItem } from "./BaseSlashMenuItem";
-export { defaultSlashMenuItems, BaseSlashMenuItem, SlashMenuExtension };
+export { defaultSlashMenuItems, BaseSlashMenuItem, createSlashMenuExtension };

package/types/src/index.d.ts

@@ -1,6 +1,8 @@
 export * from "./BlockNoteEditor";
 export * from "./BlockNoteExtensions";
+export * from "./extensions/Blocks/api/block";
 export * from "./extensions/Blocks/api/blockTypes";
+export * from "./extensions/Blocks/api/defaultBlocks";
 export * from "./extensions/DraggableBlocks/BlockSideMenuFactoryTypes";
 export * from "./extensions/FormattingToolbar/FormattingToolbarFactoryTypes";
 export * from "./extensions/HyperlinkToolbar/HyperlinkToolbarFactoryTypes";
@@ -10,3 +12,5 @@ export * from "./shared/EditorElement";
 export type { SuggestionItem } from "./shared/plugins/suggestion/SuggestionItem";
 export * from "./shared/plugins/suggestion/SuggestionsMenuFactoryTypes";
 export * from "./extensions/Blocks/api/inlineContentTypes";
+export * from "./extensions/Blocks/api/serialization";
+export * as blockStyles from "./extensions/Blocks/nodes/Block.module.css";

package/types/src/shared/plugins/suggestion/SuggestionPlugin.d.ts

@@ -3,7 +3,8 @@ import { Plugin, PluginKey } from "prosemirror-state";
 import { SuggestionsMenuFactory } from "./SuggestionsMenuFactoryTypes";
 import { SuggestionItem } from "./SuggestionItem";
 import { BlockNoteEditor } from "../../../BlockNoteEditor";
-export type SuggestionPluginOptions<T extends SuggestionItem> = {
+import { BlockSchema } from "../../../extensions/Blocks/api/blockTypes";
+export type SuggestionPluginOptions<T extends SuggestionItem, BSchema extends BlockSchema> = {
     /**
      * The name of the plugin.
      *
@@ -13,7 +14,7 @@ export type SuggestionPluginOptions<T extends SuggestionItem> = {
     /**
      * The BlockNote editor.
      */
-    editor: BlockNoteEditor;
+    editor: BlockNoteEditor<BSchema>;
     /**
      * The character that should trigger the suggestion menu to pop up (e.g. a '/' for commands), when typed by the user.
      */
@@ -28,7 +29,7 @@ export type SuggestionPluginOptions<T extends SuggestionItem> = {
      */
     onSelectItem?: (props: {
         item: T;
-        editor: BlockNoteEditor;
+        editor: BlockNoteEditor<BSchema>;
     }) => void;
     /**
      * A function that should supply the plugin with items to suggest, based on a certain query string.
@@ -61,5 +62,5 @@ type SuggestionPluginState<T extends SuggestionItem> = {
  * @param options options for configuring the plugin
  * @returns the prosemirror plugin
  */
-export declare function createSuggestionPlugin<T extends SuggestionItem>({ pluginKey, editor, defaultTriggerCharacter, suggestionsMenuFactory, onSelectItem: selectItemCallback, items, }: SuggestionPluginOptions<T>): Plugin<SuggestionPluginState<T>>;
+export declare function createSuggestionPlugin<T extends SuggestionItem, BSchema extends BlockSchema>({ pluginKey, editor, defaultTriggerCharacter, suggestionsMenuFactory, onSelectItem: selectItemCallback, items, }: SuggestionPluginOptions<T, BSchema>): Plugin<SuggestionPluginState<T>>;
 export {};