@blocknote/core 0.11.1 → 0.12.0

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

@@ -1,73 +1,41 @@
 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 { DefaultBlockSchema, defaultBlockSpecs, DefaultInlineContentSchema, defaultInlineContentSpecs, DefaultStyleSchema, defaultStyleSpecs } from "../blocks/defaultBlocks";
+import { Block, DefaultBlockSchema, DefaultInlineContentSchema, DefaultStyleSchema, PartialBlock } 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 { SuggestionMenuProseMirrorPlugin } from "../extensions/SuggestionMenu/SuggestionPlugin";
 import { TableHandlesProsemirrorPlugin } from "../extensions/TableHandles/TableHandlesPlugin";
-import { Block, BlockIdentifier, BlockNoteDOMAttributes, BlockSchema, BlockSchemaFromSpecs, BlockSchemaWithBlock, BlockSpecs, InlineContentSchema, InlineContentSchemaFromSpecs, InlineContentSpecs, PartialBlock, Styles, StyleSchema, StyleSchemaFromSpecs, StyleSpecs } from "../schema";
+import { BlockIdentifier, BlockNoteDOMAttributes, BlockSchema, BlockSpecs, InlineContentSchema, InlineContentSpecs, PartialInlineContent, StyleSchema, StyleSpecs, Styles } from "../schema";
+import { NoInfer } from "../util/typescript";
 import { TextCursorPosition } from "./cursorPositionTypes";
 import { Selection } from "./selectionTypes";
 import "./Block.css";
+import { BlockNoteSchema } from "./BlockNoteSchema";
+import { BlockNoteTipTapEditor } from "./BlockNoteTipTapEditor";
 import "./editor.css";
-export type BlockNoteEditorOptions<BSpecs extends BlockSpecs, ISpecs extends InlineContentSpecs, SSpecs extends StyleSpecs> = {
+export type BlockNoteEditorOptions<BSchema extends BlockSchema, ISchema extends InlineContentSchema, SSchema extends StyleSchema> = {
     enableBlockNoteExtensions: boolean;
-    /**
-     *
-     * (couldn't fix any type, see https://github.com/TypeCellOS/BlockNote/pull/191#discussion_r1210708771)
-     *
-     * @default defaultSlashMenuItems from `./extensions/SlashMenu`
-     */
-    slashMenuItems: BaseSlashMenuItem<any, any, any>[];
-    /**
-     * The HTML element that should be used as the parent element for the editor.
-     *
-     * @default: undefined, the editor is not attached to the DOM
-     */
-    parentElement: HTMLElement;
+    placeholders: Record<string | "default", string>;
     /**
      * An object containing attributes that should be added to HTML elements of the editor.
      *
      * @example { editor: { class: "my-editor-class" } }
      */
     domAttributes: Partial<BlockNoteDOMAttributes>;
-    /**
-     *  A callback function that runs when the editor is ready to be used.
-     */
-    onEditorReady: (editor: BlockNoteEditor<BlockSchemaFromSpecs<BSpecs>, InlineContentSchemaFromSpecs<ISpecs>, StyleSchemaFromSpecs<SSpecs>>) => void;
-    /**
-     * A callback function that runs whenever the editor's contents change.
-     */
-    onEditorContentChange: (editor: BlockNoteEditor<BlockSchemaFromSpecs<BSpecs>, InlineContentSchemaFromSpecs<ISpecs>, StyleSchemaFromSpecs<SSpecs>>) => void;
-    /**
-     * A callback function that runs whenever the text cursor position changes.
-     */
-    onTextCursorPositionChange: (editor: BlockNoteEditor<BlockSchemaFromSpecs<BSpecs>, InlineContentSchemaFromSpecs<ISpecs>, StyleSchemaFromSpecs<SSpecs>>) => void;
-    /**
-     * Locks the editor from being editable by the user if set to `false`.
-     */
-    editable: boolean;
     /**
      * The content that should be in the editor when it's created, represented as an array of partial block objects.
      */
-    initialContent: PartialBlock<BlockSchemaFromSpecs<BSpecs>, InlineContentSchemaFromSpecs<ISpecs>, StyleSchemaFromSpecs<SSpecs>>[];
+    initialContent: PartialBlock<NoInfer<BSchema>, NoInfer<ISchema>, NoInfer<SSchema>>[];
     /**
      * Use default BlockNote font and reset the styles of <p> <li> <h1> elements etc., that are used in BlockNote.
      *
      * @default true
      */
     defaultStyles: boolean;
-    /**
-     * A list of block types that should be available in the editor.
-     */
-    blockSpecs: BSpecs;
-    styleSpecs: SSpecs;
-    inlineContentSpecs: ISpecs;
+    schema: BlockNoteSchema<BSchema, ISchema, SSchema>;
     /**
      * A custom function to handle file uploads.
      * @param file The file that should be uploaded.
@@ -102,35 +70,42 @@ export type BlockNoteEditorOptions<BSpecs extends BlockSpecs, ISpecs extends Inl
 };
 export declare class BlockNoteEditor<BSchema extends BlockSchema = DefaultBlockSchema, ISchema extends InlineContentSchema = DefaultInlineContentSchema, SSchema extends StyleSchema = DefaultStyleSchema> {
     private readonly options;
-    readonly _tiptapEditor: TiptapEditor & {
+    readonly _tiptapEditor: BlockNoteTipTapEditor & {
         contentComponent: any;
     };
     blockCache: WeakMap<Node, Block<any, any, any>>;
-    readonly blockSchema: BSchema;
-    readonly inlineContentSchema: ISchema;
-    readonly styleSchema: SSchema;
+    readonly schema: BlockNoteSchema<BSchema, ISchema, SSchema>;
     readonly blockImplementations: BlockSpecs;
     readonly inlineContentImplementations: InlineContentSpecs;
     readonly styleImplementations: StyleSpecs;
-    ready: boolean;
-    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 sideMenu: SideMenuProsemirrorPlugin<BSchema, ISchema, SSchema>;
+    readonly suggestionMenus: SuggestionMenuProseMirrorPlugin<BSchema, ISchema, SSchema>;
+    readonly imageToolbar?: ImageToolbarProsemirrorPlugin<ISchema, SSchema>;
+    readonly tableHandles?: TableHandlesProsemirrorPlugin<ISchema, SSchema>;
     readonly uploadFile: ((file: File) => Promise<string>) | undefined;
-    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>>;
+    static create<BSchema extends BlockSchema = DefaultBlockSchema, ISchema extends InlineContentSchema = DefaultInlineContentSchema, SSchema extends StyleSchema = DefaultStyleSchema>(options?: Partial<BlockNoteEditorOptions<BSchema, ISchema, SSchema>>): BlockNoteEditor<BSchema, ISchema, SSchema>;
     private constructor();
+    /**
+     * Mount the editor to a parent DOM element. Call mount(undefined) to clean up
+     *
+     * @warning Not needed for React, use BlockNoteView to take care of this
+     */
+    mount(parentElement?: HTMLElement | null): void;
     get prosemirrorView(): import("prosemirror-view").EditorView;
     get domElement(): HTMLDivElement;
     isFocused(): boolean;
     focus(): void;
+    /**
+     * @deprecated, use `editor.document` instead
+     */
+    get topLevelBlocks(): Block<BSchema, ISchema, SSchema>[];
     /**
      * 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, ISchema, SSchema>[];
+    get document(): 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.
@@ -212,6 +187,12 @@ export declare class BlockNoteEditor<BSchema extends BlockSchema = DefaultBlockS
         insertedBlocks: Block<BSchema, ISchema, SSchema>[];
         removedBlocks: Block<BSchema, ISchema, SSchema>[];
     };
+    /**
+     * Insert a piece of content at the current cursor position.
+     *
+     * @param content can be a string, or array of partial inline content elements
+     */
+    insertInlineContent(content: PartialInlineContent<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.
      */
@@ -298,4 +279,18 @@ export declare class BlockNoteEditor<BSchema extends BlockSchema = DefaultBlockS
         name: string;
         color: string;
     }): void;
+    /**
+     * A callback function that runs whenever the editor's contents change.
+     *
+     * @param callback The callback to execute.
+     * @returns A function to remove the callback.
+     */
+    onChange(callback: (editor: BlockNoteEditor<BSchema, ISchema, SSchema>) => void): () => void;
+    /**
+     * A callback function that runs whenever the text cursor position or selection changes.
+     *
+     * @param callback The callback to execute.
+     * @returns A function to remove the callback.
+     */
+    onSelectionChange(callback: (editor: BlockNoteEditor<BSchema, ISchema, SSchema>) => void): () => void;
 }

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

@@ -7,6 +7,7 @@ import { BlockNoteDOMAttributes, BlockSpecs, InlineContentSchema, InlineContentS
  */
 export declare const getBlockNoteExtensions: <BSchema extends Record<string, import("../schema").BlockConfig>, I extends InlineContentSchema, S extends StyleSchema>(opts: {
     editor: BlockNoteEditor<BSchema, I, S>;
+    placeholders?: Record<string, string> | undefined;
     domAttributes: Partial<BlockNoteDOMAttributes>;
     blockSchema: BSchema;
     blockSpecs: BlockSpecs;

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

@@ -0,0 +1,34 @@
+import { defaultBlockSpecs, defaultInlineContentSpecs, defaultStyleSpecs } from "../blocks/defaultBlocks";
+import { BlockSchema, BlockSchemaFromSpecs, BlockSpecs, InlineContentSchema, InlineContentSchemaFromSpecs, InlineContentSpecs, StyleSchema, StyleSchemaFromSpecs, StyleSpecs } from "../schema";
+import type { BlockNoDefaults, PartialBlockNoDefaults } from "../schema/blocks/types";
+import type { BlockNoteEditor } from "./BlockNoteEditor";
+export declare class BlockNoteSchema<BSchema extends BlockSchema, ISchema extends InlineContentSchema, SSchema extends StyleSchema> {
+    readonly blockSpecs: BlockSpecs;
+    readonly inlineContentSpecs: InlineContentSpecs;
+    readonly styleSpecs: StyleSpecs;
+    readonly blockSchema: BSchema;
+    readonly inlineContentSchema: ISchema;
+    readonly styleSchema: SSchema;
+    readonly BlockNoteEditor: BlockNoteEditor<BSchema, ISchema, SSchema>;
+    readonly Block: BlockNoDefaults<BSchema, ISchema, SSchema>;
+    readonly PartialBlock: PartialBlockNoDefaults<BSchema, ISchema, SSchema>;
+    static create<BSpecs extends BlockSpecs = typeof defaultBlockSpecs, ISpecs extends InlineContentSpecs = typeof defaultInlineContentSpecs, SSpecs extends StyleSpecs = typeof defaultStyleSpecs>(options?: {
+        /**
+         * A list of custom block types that should be available in the editor.
+         */
+        blockSpecs?: BSpecs;
+        /**
+         * A list of custom InlineContent types that should be available in the editor.
+         */
+        inlineContentSpecs?: ISpecs;
+        /**
+         * A list of custom Styles that should be available in the editor.
+         */
+        styleSpecs?: SSpecs;
+    }): BlockNoteSchema<BlockSchemaFromSpecs<BSpecs>, InlineContentSchemaFromSpecs<ISpecs>, StyleSchemaFromSpecs<SSpecs>>;
+    constructor(opts?: {
+        blockSpecs?: BlockSpecs;
+        inlineContentSpecs?: InlineContentSpecs;
+        styleSpecs?: StyleSpecs;
+    });
+}

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

@@ -0,0 +1,28 @@
+import { EditorOptions } from "@tiptap/core";
+import { Editor as TiptapEditor } from "@tiptap/core";
+import { EditorState } from "prosemirror-state";
+import { PartialBlock } from "../blocks/defaultBlocks";
+import { StyleSchema } from "../schema";
+export type BlockNoteTipTapEditorOptions = Partial<Omit<EditorOptions, "content">> & {
+    content: PartialBlock<any, any, any>[];
+};
+/**
+ * Custom Editor class that extends TiptapEditor and separates
+ * the creation of the view from the constructor.
+ */
+export declare class BlockNoteTipTapEditor extends TiptapEditor {
+    private _state;
+    constructor(options: BlockNoteTipTapEditorOptions, styleSchema: StyleSchema);
+    get state(): EditorState;
+    createView(): void;
+    /**
+     * Replace the default `createView` method with a custom one - which we call on mount
+     */
+    private createViewAlternative;
+    /**
+     * Mounts / unmounts the editor to a dom element
+     *
+     * @param element DOM element to mount to, ur null / undefined to destroy
+     */
+    mount: (element?: HTMLElement | null) => void;
+}

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

@@ -1,4 +1,5 @@
-import { Block, BlockSchema, InlineContentSchema, StyleSchema } from "../schema";
+import { Block } from "../blocks/defaultBlocks";
+import { 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;

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

@@ -1,4 +1,5 @@
-import { Block, BlockSchema, InlineContentSchema, StyleSchema } from "../schema";
+import { Block } from "../blocks/defaultBlocks";
+import { 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/extensions/FormattingToolbar/FormattingToolbarPlugin.d.ts

@@ -1,16 +1,15 @@
 import { EditorState, Plugin, PluginKey } from "prosemirror-state";
 import { EditorView } from "prosemirror-view";
 import type { BlockNoteEditor } from "../../editor/BlockNoteEditor";
-import { BaseUiElementCallbacks, BaseUiElementState } from "../../extensions-shared/BaseUiElementTypes";
+import { UiElementPosition } from "../../extensions-shared/UiElementPosition";
 import { BlockSchema, InlineContentSchema, StyleSchema } from "../../schema";
 import { EventEmitter } from "../../util/EventEmitter";
-export type FormattingToolbarCallbacks = BaseUiElementCallbacks;
-export type FormattingToolbarState = BaseUiElementState;
+export type FormattingToolbarState = UiElementPosition;
 export declare class FormattingToolbarView {
     private readonly editor;
     private readonly pmView;
-    private formattingToolbarState?;
-    updateFormattingToolbar: () => void;
+    state?: FormattingToolbarState;
+    emitUpdate: () => void;
     preventHide: boolean;
     preventShow: boolean;
     prevWasEditable: boolean | null;
@@ -20,7 +19,7 @@ export declare class FormattingToolbarView {
         from: number;
         to: number;
     }) => boolean;
-    constructor(editor: BlockNoteEditor<BlockSchema, InlineContentSchema, StyleSchema>, pmView: EditorView, updateFormattingToolbar: (formattingToolbarState: FormattingToolbarState) => void);
+    constructor(editor: BlockNoteEditor<BlockSchema, InlineContentSchema, StyleSchema>, pmView: EditorView, emitUpdate: (state: FormattingToolbarState) => void);
     viewMousedownHandler: () => void;
     viewMouseupHandler: () => void;
     dragHandler: () => void;

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

@@ -1,9 +1,9 @@
 import { Plugin, PluginKey } from "prosemirror-state";
 import type { BlockNoteEditor } from "../../editor/BlockNoteEditor";
-import { BaseUiElementState } from "../../extensions-shared/BaseUiElementTypes";
 import { BlockSchema, InlineContentSchema, StyleSchema } from "../../schema";
+import { UiElementPosition } from "../../extensions-shared/UiElementPosition";
 import { EventEmitter } from "../../util/EventEmitter";
-export type HyperlinkToolbarState = BaseUiElementState & {
+export type HyperlinkToolbarState = UiElementPosition & {
     url: string;
     text: string;
 };

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

@@ -1,20 +1,20 @@
 import { EditorState, Plugin, PluginKey } from "prosemirror-state";
 import { EditorView } from "prosemirror-view";
-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<B extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema = StyleSchema> = BaseUiElementState & {
-    block: SpecificBlock<B, "image", I, S>;
+import type { BlockFromConfig, InlineContentSchema, StyleSchema } from "../../schema";
+import { UiElementPosition } from "../../extensions-shared/UiElementPosition";
+import { EventEmitter } from "../../util/EventEmitter";
+import { DefaultBlockSchema } from "../../blocks/defaultBlocks";
+export type ImageToolbarState<I extends InlineContentSchema, S extends StyleSchema> = UiElementPosition & {
+    block: BlockFromConfig<DefaultBlockSchema["image"], I, S>;
 };
-export declare class ImageToolbarView<BSchema extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema> {
+export declare class ImageToolbarView<I extends InlineContentSchema, S extends StyleSchema> {
     private readonly pluginKey;
     private readonly pmView;
-    private imageToolbarState?;
-    updateImageToolbar: () => void;
+    state?: ImageToolbarState<I, S>;
+    emitUpdate: () => void;
     prevWasEditable: boolean | null;
-    constructor(pluginKey: PluginKey, pmView: EditorView, updateImageToolbar: (imageToolbarState: ImageToolbarState<BSchema, I, S>) => void);
+    constructor(pluginKey: PluginKey, pmView: EditorView, emitUpdate: (state: ImageToolbarState<I, S>) => void);
     mouseDownHandler: () => void;
     dragstartHandler: () => void;
     blurHandler: (event: FocusEvent) => void;
@@ -22,10 +22,11 @@ export declare class ImageToolbarView<BSchema extends BlockSchema, I extends Inl
     update(view: EditorView, prevState: EditorState): void;
     destroy(): void;
 }
-export declare const imageToolbarPluginKey: PluginKey<any>;
-export declare class ImageToolbarProsemirrorPlugin<BSchema extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema> extends EventEmitter<any> {
+export declare class ImageToolbarProsemirrorPlugin<I extends InlineContentSchema, S extends StyleSchema> extends EventEmitter<any> {
     private view;
     readonly plugin: Plugin;
-    constructor(_editor: BlockNoteEditor<BSchema, I, S>);
-    onUpdate(callback: (state: ImageToolbarState<BSchema, I, S>) => void): () => void;
+    constructor(_editor: BlockNoteEditor<{
+        image: DefaultBlockSchema["image"];
+    }, I, S>);
+    onUpdate(callback: (state: ImageToolbarState<I, S>) => void): () => void;
 }

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

@@ -1,5 +1,4 @@
-import { Editor, Extension } from "@tiptap/core";
-import { Node as ProsemirrorNode } from "prosemirror-model";
+import { Extension } from "@tiptap/core";
 /**
  * This is a modified version of the tiptap
  * placeholder plugin, that also sets hasAnchorClass
@@ -8,18 +7,6 @@ import { Node as ProsemirrorNode } from "prosemirror-model";
  *
  */
 export interface PlaceholderOptions {
-    emptyEditorClass: string;
-    emptyNodeClass: string;
-    isFilterClass: string;
-    hasAnchorClass: string;
-    placeholder: ((PlaceholderProps: {
-        editor: Editor;
-        node: ProsemirrorNode;
-        pos: number;
-        hasAnchor: boolean;
-    }) => string) | string;
-    showOnlyWhenEditable: boolean;
-    showOnlyCurrent: boolean;
-    includeChildren: boolean;
+    placeholders: Record<string | "default", string>;
 }
 export declare const Placeholder: Extension<PlaceholderOptions, any>;

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

@@ -1,11 +1,12 @@
 import { PluginView } from "@tiptap/pm/state";
 import { Plugin, PluginKey } from "prosemirror-state";
 import { EditorView } from "prosemirror-view";
+import { Block } from "../../blocks/defaultBlocks";
 import type { BlockNoteEditor } from "../../editor/BlockNoteEditor";
-import { BaseUiElementState } from "../../extensions-shared/BaseUiElementTypes";
-import { Block, BlockSchema, InlineContentSchema, StyleSchema } from "../../schema";
+import { UiElementPosition } from "../../extensions-shared/UiElementPosition";
+import { BlockSchema, InlineContentSchema, StyleSchema } from "../../schema";
 import { EventEmitter } from "../../util/EventEmitter";
-export type SideMenuState<BSchema extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema> = BaseUiElementState & {
+export type SideMenuState<BSchema extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema> = UiElementPosition & {
     block: Block<BSchema, I, S>;
 };
 export declare function getDraggableBlockFromCoords(coords: {
@@ -18,14 +19,14 @@ export declare function getDraggableBlockFromCoords(coords: {
 export declare class SideMenuView<BSchema extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema> implements PluginView {
     private readonly editor;
     private readonly pmView;
-    private readonly updateSideMenu;
-    private sideMenuState?;
+    private state?;
+    private readonly emitUpdate;
     private horizontalPosAnchoredAtRoot;
     private horizontalPosAnchor;
     private hoveredBlock;
     isDragging: boolean;
     menuFrozen: boolean;
-    constructor(editor: BlockNoteEditor<BSchema, I, S>, pmView: EditorView, updateSideMenu: (sideMenuState: SideMenuState<BSchema, I, S>) => void);
+    constructor(editor: BlockNoteEditor<BSchema, I, S>, pmView: EditorView, emitUpdate: (state: SideMenuState<BSchema, I, S>) => void);
     /**
      * Sets isDragging when dragging text.
      */
@@ -52,7 +53,7 @@ export declare class SideMenuView<BSchema extends BlockSchema, I extends InlineC
 export declare const sideMenuPluginKey: PluginKey<any>;
 export declare class SideMenuProsemirrorPlugin<BSchema extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema> extends EventEmitter<any> {
     private readonly editor;
-    private sideMenuView;
+    view: SideMenuView<BSchema, I, S> | undefined;
     readonly plugin: Plugin;
     constructor(editor: BlockNoteEditor<BSchema, I, S>);
     onUpdate(callback: (state: SideMenuState<BSchema, I, S>) => void): () => void;

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

@@ -0,0 +1,8 @@
+export type DefaultSuggestionItem = {
+    title: string;
+    onItemClick: () => void;
+    subtext?: string;
+    badge?: string;
+    aliases?: string[];
+    group?: string;
+};

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

@@ -0,0 +1,31 @@
+import { Plugin, PluginKey } from "prosemirror-state";
+import type { BlockNoteEditor } from "../../editor/BlockNoteEditor";
+import { BlockSchema, InlineContentSchema, StyleSchema } from "../../schema";
+import { UiElementPosition } from "../../extensions-shared/UiElementPosition";
+import { EventEmitter } from "../../util/EventEmitter";
+export type SuggestionMenuState = UiElementPosition & {
+    query: string;
+};
+export declare const suggestionMenuPluginKey: PluginKey<any>;
+/**
+ * A ProseMirror plugin for suggestions, designed to make '/'-commands possible as well as mentions.
+ *
+ * This is basically a simplified version of TipTap's [Suggestions](https://github.com/ueberdosis/tiptap/tree/db92a9b313c5993b723c85cd30256f1d4a0b65e1/packages/suggestion) plugin.
+ *
+ * This version is adapted from the aforementioned version in the following ways:
+ * - This version supports generic items instead of only strings (to allow for more advanced filtering for example)
+ * - This version hides some unnecessary complexity from the user of the plugin.
+ * - This version handles key events differently
+ */
+export declare class SuggestionMenuProseMirrorPlugin<BSchema extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema> extends EventEmitter<any> {
+    private view;
+    readonly plugin: Plugin;
+    private triggerCharacters;
+    constructor(editor: BlockNoteEditor<BSchema, I, S>);
+    onUpdate(triggerCharacter: string, callback: (state: SuggestionMenuState) => void): () => void;
+    addTriggerCharacter: (triggerCharacter: string) => void;
+    removeTriggerCharacter: (triggerCharacter: string) => void;
+    closeMenu: () => void;
+    clearQuery: () => void;
+}
+export declare function createSuggestionMenu<BSchema extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema>(editor: BlockNoteEditor<BSchema, I, S>, triggerCharacter: string): void;

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

@@ -0,0 +1,10 @@
+import { Block, PartialBlock } from "../../blocks/defaultBlocks";
+import { BlockNoteEditor } from "../../editor/BlockNoteEditor";
+import { BlockSchema, InlineContentSchema, StyleSchema } from "../../schema";
+import { DefaultSuggestionItem } from "./DefaultSuggestionItem";
+export declare function insertOrUpdateBlock<BSchema extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema>(editor: BlockNoteEditor<BSchema, I, S>, block: PartialBlock<BSchema, I, S>): Block<BSchema, I, S>;
+export declare function getDefaultSlashMenuItems<BSchema extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema>(editor: BlockNoteEditor<BSchema, I, S>): DefaultSuggestionItem[];
+export declare function filterSuggestionItems<T extends {
+    title: string;
+    aliases?: readonly string[];
+}>(items: T[], query: string): T[];

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

@@ -1,9 +1,9 @@
 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";
+import { EventEmitter } from "../../util/EventEmitter";
 export type TableHandlesState<I extends InlineContentSchema, S extends StyleSchema> = {
     show: boolean;
     referencePosCell: DOMRect;
@@ -21,12 +21,12 @@ export declare class TableHandlesView<BSchema extends BlockSchemaWithBlock<"tabl
     private readonly editor;
     private readonly pmView;
     state?: TableHandlesState<I, S>;
-    updateState: () => void;
+    emitUpdate: () => 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);
+    constructor(editor: BlockNoteEditor<BlockSchemaWithBlock<"table", DefaultBlockSchema["table"]>, I, S>, pmView: EditorView, emitUpdate: (state: TableHandlesState<I, S>) => void);
     mouseMoveHandler: (event: MouseEvent) => false | undefined;
     dragOverHandler: (event: DragEvent) => void;
     dropHandler: (event: DragEvent) => void;
@@ -34,11 +34,11 @@ export declare class TableHandlesView<BSchema extends BlockSchemaWithBlock<"tabl
     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> {
+export declare class TableHandlesProsemirrorPlugin<I extends InlineContentSchema, S extends StyleSchema> extends EventEmitter<any> {
     private readonly editor;
     private view;
     readonly plugin: Plugin;
-    constructor(editor: BlockNoteEditor<BSchema, I, S>);
+    constructor(editor: BlockNoteEditor<BlockSchemaWithBlock<"table", DefaultBlockSchema["table"]>, I, S>);
     onUpdate(callback: (state: TableHandlesState<I, S>) => void): () => void;
     /**
      * Callback that should be set on the `dragStart` event for whichever element
@@ -65,10 +65,10 @@ export declare class TableHandlesProsemirrorPlugin<BSchema extends BlockSchemaWi
      * 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;
+    freezeHandles: () => void;
     /**
      * 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;
+    unfreezeHandles: () => void;
 }

package/types/src/extensions-shared/UiElementPosition.d.ts

@@ -0,0 +1,4 @@
+export type UiElementPosition = {
+    show: boolean;
+    referencePos: DOMRect;
+};

package/types/src/index.d.ts

@@ -2,21 +2,21 @@ export * from "./api/exporters/html/externalHTMLExporter";
 export * from "./api/exporters/html/internalHTMLSerializer";
 export * from "./api/testUtil";
 export * from "./blocks/ImageBlockContent/uploadToTmpFilesDotOrg_DEV_ONLY";
+export * from "./blocks/defaultBlockTypeGuards";
 export * from "./blocks/defaultBlocks";
 export * from "./blocks/defaultProps";
 export * from "./editor/BlockNoteEditor";
 export * from "./editor/BlockNoteExtensions";
+export * from "./editor/BlockNoteSchema";
 export * from "./editor/selectionTypes";
-export * from "./extensions-shared/BaseUiElementTypes";
-export type { SuggestionItem } from "./extensions-shared/suggestion/SuggestionItem";
-export * from "./extensions-shared/suggestion/SuggestionPlugin";
+export * from "./extensions-shared/UiElementPosition";
 export * from "./extensions/FormattingToolbar/FormattingToolbarPlugin";
 export * from "./extensions/HyperlinkToolbar/HyperlinkToolbarPlugin";
 export * from "./extensions/ImageToolbar/ImageToolbarPlugin";
 export * from "./extensions/SideMenu/SideMenuPlugin";
-export * from "./extensions/SlashMenu/BaseSlashMenuItem";
-export * from "./extensions/SlashMenu/SlashMenuPlugin";
-export { getDefaultSlashMenuItems } from "./extensions/SlashMenu/defaultSlashMenuItems";
+export * from "./extensions/SuggestionMenu/DefaultSuggestionItem";
+export * from "./extensions/SuggestionMenu/SuggestionPlugin";
+export * from "./extensions/SuggestionMenu/getDefaultSlashMenuItems";
 export * from "./extensions/TableHandles/TableHandlesPlugin";
 export * from "./schema";
 export * from "./util/browser";

package/types/src/pm-nodes/BlockContainer.d.ts

@@ -1,6 +1,7 @@
 import { Node } from "@tiptap/core";
+import { PartialBlock } from "../blocks/defaultBlocks";
 import type { BlockNoteEditor } from "../editor/BlockNoteEditor";
-import { BlockSchema, InlineContentSchema, PartialBlock, StyleSchema } from "../schema";
+import { BlockSchema, InlineContentSchema, StyleSchema } from "../schema";
 declare module "@tiptap/core" {
     interface Commands<ReturnType> {
         block: {
@@ -18,8 +19,8 @@ declare module "@tiptap/core" {
  */
 export declare const BlockContainer: Node<{
     domAttributes?: Partial<{
-        blockContainer: Record<string, string>;
         blockGroup: Record<string, string>;
+        block: Record<string, string>;
         editor: Record<string, string>;
         blockContent: Record<string, string>;
         inlineContent: Record<string, string>;

package/types/src/pm-nodes/BlockGroup.d.ts

@@ -1,8 +1,8 @@
 import { Node } from "@tiptap/core";
 export declare const BlockGroup: Node<{
     domAttributes?: Partial<{
-        blockContainer: Record<string, string>;
         blockGroup: Record<string, string>;
+        block: Record<string, string>;
         editor: Record<string, string>;
         blockContent: Record<string, string>;
         inlineContent: Record<string, string>;