@blocknote/core 0.4.2 → 0.4.4

package/src/extensions/SlashMenu/SlashMenuExtension.ts

@@ -2,10 +2,12 @@ import { Extension } from "@tiptap/core";
 import { PluginKey } from "prosemirror-state";
 import { createSuggestionPlugin } from "../../shared/plugins/suggestion/SuggestionPlugin";
 import { SuggestionsMenuFactory } from "../../shared/plugins/suggestion/SuggestionsMenuFactoryTypes";
-import { SlashMenuItem } from "./SlashMenuItem";
+import { BaseSlashMenuItem } from "./BaseSlashMenuItem";
+import { BlockNoteEditor } from "../../BlockNoteEditor";
 
 export type SlashMenuOptions = {
-  commands: SlashMenuItem[] | undefined;
+  editor: BlockNoteEditor | undefined;
+  commands: BaseSlashMenuItem[] | undefined;
   slashMenuFactory: SuggestionsMenuFactory<any> | undefined;
 };
 
@@ -16,6 +18,7 @@ export const SlashMenuExtension = Extension.create<SlashMenuOptions>({
 
   addOptions() {
     return {
+      editor: undefined,
       commands: undefined,
       slashMenuFactory: undefined,
     };
@@ -29,16 +32,16 @@ export const SlashMenuExtension = Extension.create<SlashMenuOptions>({
     const commands = this.options.commands;
 
     return [
-      createSuggestionPlugin<SlashMenuItem>({
+      createSuggestionPlugin<BaseSlashMenuItem>({
         pluginKey: SlashMenuPluginKey,
-        editor: this.editor,
+        editor: this.options.editor!,
         defaultTriggerCharacter: "/",
         suggestionsMenuFactory: this.options.slashMenuFactory!,
         items: (query) => {
-          return commands.filter((cmd: SlashMenuItem) => cmd.match(query));
+          return commands.filter((cmd: BaseSlashMenuItem) => cmd.match(query));
         },
-        onSelectItem: ({ item, editor, range }) => {
-          item.execute(editor, range);
+        onSelectItem: ({ item, editor }) => {
+          item.execute(editor);
         },
       }),
     ];

package/src/extensions/SlashMenu/{defaultSlashCommands.tsx → defaultSlashMenuItems.tsx}

@@ -1,135 +1,88 @@
-import { Editor, Range } from "@tiptap/core";
-import { formatKeyboardShortcut } from "../../shared/utils";
-import { SlashMenuItem } from "./SlashMenuItem";
+import { BaseSlashMenuItem } from "./BaseSlashMenuItem";
+import { PartialBlock } from "../Blocks/api/blockTypes";
+import { BlockNoteEditor } from "../../BlockNoteEditor";
+
+function insertOrUpdateBlock(editor: BlockNoteEditor, block: PartialBlock) {
+  const currentBlock = editor.getTextCursorPosition().block;
+
+  if (
+    (currentBlock.content.length === 1 &&
+      currentBlock.content[0].type === "text" &&
+      currentBlock.content[0].text === "/") ||
+    currentBlock.content.length === 0
+  ) {
+    editor.updateBlock(currentBlock, block);
+  } else {
+    editor.insertBlocks([block], currentBlock, "after");
+    editor.setTextCursorPosition(editor.getTextCursorPosition().nextBlock!);
+  }
+}
 
 /**
  * An array containing commands for creating all default blocks.
  */
-export const defaultSlashCommands: SlashMenuItem[] = [
+export const defaultSlashMenuItems: BaseSlashMenuItem[] = [
   // Command for creating a level 1 heading
-  new SlashMenuItem(
+  new BaseSlashMenuItem(
     "Heading",
-    (editor: Editor, range: Range) => {
-      return editor
-        .chain()
-        .focus()
-        .deleteRange(range)
-        .BNCreateOrUpdateBlock(range.from, {
-          type: "heading",
-          props: {
-            level: "1",
-          },
-        })
-        .run();
-    },
-    ["h", "heading1", "h1"],
-    "Headings",
-    "Used for a top-level heading",
-    formatKeyboardShortcut("Mod-Alt-1")
+    (editor) =>
+      insertOrUpdateBlock(editor, {
+        type: "heading",
+        props: { level: "1" },
+      }),
+    ["h", "heading1", "h1"]
   ),
 
   // Command for creating a level 2 heading
-  new SlashMenuItem(
+  new BaseSlashMenuItem(
     "Heading 2",
-    (editor: Editor, range: Range) => {
-      return editor
-        .chain()
-        .focus()
-        .deleteRange(range)
-        .BNCreateOrUpdateBlock(range.from, {
-          type: "heading",
-          props: {
-            level: "2",
-          },
-        })
-        .run();
-    },
-    ["h2", "heading2", "subheading"],
-    "Headings",
-    "Used for key sections",
-    formatKeyboardShortcut("Mod-Alt-2")
+    (editor) =>
+      insertOrUpdateBlock(editor, {
+        type: "heading",
+        props: { level: "2" },
+      }),
+    ["h2", "heading2", "subheading"]
   ),
 
   // Command for creating a level 3 heading
-  new SlashMenuItem(
+  new BaseSlashMenuItem(
     "Heading 3",
-    (editor: Editor, range: Range) => {
-      return editor
-        .chain()
-        .focus()
-        .deleteRange(range)
-        .BNCreateOrUpdateBlock(range.from, {
-          type: "heading",
-          props: {
-            level: "3",
-          },
-        })
-        .run();
-    },
-    ["h3", "heading3", "subheading"],
-    "Headings",
-    "Used for subsections and group headings",
-    formatKeyboardShortcut("Mod-Alt-3")
+    (editor) =>
+      insertOrUpdateBlock(editor, {
+        type: "heading",
+        props: { level: "3" },
+      }),
+    ["h3", "heading3", "subheading"]
   ),
 
   // Command for creating an ordered list
-  new SlashMenuItem(
+  new BaseSlashMenuItem(
     "Numbered List",
-    (editor: Editor, range: Range) => {
-      return editor
-        .chain()
-        .focus()
-        .deleteRange(range)
-        .BNCreateOrUpdateBlock(range.from, {
-          type: "numberedListItem",
-          props: {},
-        })
-        .run();
-    },
-    ["li", "list", "numberedlist", "numbered list"],
-    "Basic blocks",
-    "Used to display a numbered list",
-    "Mod-Alt-7"
+    (editor) =>
+      insertOrUpdateBlock(editor, {
+        type: "numberedListItem",
+      }),
+    ["li", "list", "numberedlist", "numbered list"]
   ),
 
   // Command for creating a bullet list
-  new SlashMenuItem(
+  new BaseSlashMenuItem(
     "Bullet List",
-    (editor: Editor, range: Range) => {
-      return editor
-        .chain()
-        .focus()
-        .deleteRange(range)
-        .BNCreateOrUpdateBlock(range.from, {
-          type: "bulletListItem",
-          props: {},
-        })
-        .run();
-    },
-    ["ul", "list", "bulletlist", "bullet list"],
-    "Basic blocks",
-    "Used to display an unordered list",
-    "Mod-Alt-9"
+    (editor) =>
+      insertOrUpdateBlock(editor, {
+        type: "bulletListItem",
+      }),
+    ["ul", "list", "bulletlist", "bullet list"]
   ),
 
   // Command for creating a paragraph (pretty useless)
-  new SlashMenuItem(
+  new BaseSlashMenuItem(
     "Paragraph",
-    (editor: Editor, range: Range) => {
-      return editor
-        .chain()
-        .focus()
-        .deleteRange(range)
-        .BNCreateOrUpdateBlock(range.from, {
-          type: "paragraph",
-          props: {},
-        })
-        .run();
-    },
-    ["p"],
-    "Basic blocks",
-    "Used for the body of your document",
-    "Mod-Alt-0"
+    (editor) =>
+      insertOrUpdateBlock(editor, {
+        type: "paragraph",
+      }),
+    ["p"]
   ),
 
   //     replaceRangeWithNode(editor, range, node);

package/src/extensions/SlashMenu/index.ts

@@ -1,9 +1,5 @@
-import { defaultSlashCommands } from "./defaultSlashCommands";
+import { defaultSlashMenuItems } from "./defaultSlashMenuItems";
 import { SlashMenuExtension } from "./SlashMenuExtension";
-import { SlashMenuItem } from "./SlashMenuItem";
+import { BaseSlashMenuItem } from "./BaseSlashMenuItem";
 
-export {
-  defaultSlashCommands,
-  SlashMenuItem as SlashCommand,
-  SlashMenuExtension,
-};
+export { defaultSlashMenuItems, BaseSlashMenuItem, SlashMenuExtension };

package/src/index.ts

@@ -4,9 +4,8 @@ export * from "./extensions/Blocks/api/blockTypes";
 export * from "./extensions/DraggableBlocks/BlockSideMenuFactoryTypes";
 export * from "./extensions/FormattingToolbar/FormattingToolbarFactoryTypes";
 export * from "./extensions/HyperlinkToolbar/HyperlinkToolbarFactoryTypes";
-export { defaultSlashCommands } from "./extensions/SlashMenu/defaultSlashCommands";
-export * from "./extensions/SlashMenu/SlashMenuItem";
+export { defaultSlashMenuItems } from "./extensions/SlashMenu/defaultSlashMenuItems";
+export * from "./extensions/SlashMenu/BaseSlashMenuItem";
 export * from "./shared/EditorElement";
 export type { SuggestionItem } from "./shared/plugins/suggestion/SuggestionItem";
 export * from "./shared/plugins/suggestion/SuggestionsMenuFactoryTypes";
-export * from "../src/api/Editor";

package/src/shared/plugins/suggestion/SuggestionItem.ts

@@ -1,17 +1,6 @@
 /**
  * A generic interface used in all suggestion menus (slash menu, mentions, etc)
  */
-export interface SuggestionItem {
-  /**
-   * The name of the item
-   */
-  name: string;
-
-  /**
-   * This function matches this item against a query string, the function should return **true** if the item
-   * matches the query or **false** otherwise.
-   *
-   * @param query the query string
-   */
-  match(query: string): boolean;
+export class SuggestionItem {
+  constructor(public name: string, public match: (query: string) => boolean) {}
 }

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

@@ -9,6 +9,7 @@ import {
   SuggestionsMenuStaticParams,
 } from "./SuggestionsMenuFactoryTypes";
 import { SuggestionItem } from "./SuggestionItem";
+import { BlockNoteEditor } from "../../../BlockNoteEditor";
 
 export type SuggestionPluginOptions<T extends SuggestionItem> = {
   /**
@@ -19,9 +20,9 @@ export type SuggestionPluginOptions<T extends SuggestionItem> = {
   pluginKey: PluginKey;
 
   /**
-   * The TipTap editor.
+   * The BlockNote editor.
    */
-  editor: Editor;
+  editor: BlockNoteEditor;
 
   /**
    * The character that should trigger the suggestion menu to pop up (e.g. a '/' for commands), when typed by the user.
@@ -37,7 +38,7 @@ export type SuggestionPluginOptions<T extends SuggestionItem> = {
    * this should be done manually. The `editor` and `range` properties passed
    * to the callback function might come in handy when doing this.
    */
-  onSelectItem?: (props: { item: T; editor: Editor; range: Range }) => void;
+  onSelectItem?: (props: { item: T; editor: BlockNoteEditor }) => void;
 
   /**
    * A function that should supply the plugin with items to suggest, based on a certain query string.
@@ -81,14 +82,14 @@ function getDefaultPluginState<
 }
 
 type SuggestionPluginViewOptions<T extends SuggestionItem> = {
-  editor: Editor;
+  editor: BlockNoteEditor;
   pluginKey: PluginKey;
-  onSelectItem: (props: { item: T; editor: Editor; range: Range }) => void;
+  onSelectItem: (props: { item: T; editor: BlockNoteEditor }) => void;
   suggestionsMenuFactory: SuggestionsMenuFactory<T>;
 };
 
 class SuggestionPluginView<T extends SuggestionItem> {
-  editor: Editor;
+  editor: BlockNoteEditor;
   pluginKey: PluginKey;
 
   suggestionsMenu: SuggestionsMenu<T>;
@@ -107,17 +108,23 @@ class SuggestionPluginView<T extends SuggestionItem> {
 
     this.pluginState = getDefaultPluginState<T>();
 
-    this.itemCallback = (item: T) =>
-      selectItemCallback({
-        item: item,
-        editor: editor,
-        range: {
+    this.itemCallback = (item: T) => {
+      editor._tiptapEditor
+        .chain()
+        .focus()
+        .deleteRange({
           from:
             this.pluginState.queryStartPos! -
             this.pluginState.triggerCharacter!.length,
-          to: editor.state.selection.from,
-        },
+          to: editor._tiptapEditor.state.selection.from,
+        })
+        .run();
+
+      selectItemCallback({
+        item: item,
+        editor: editor,
       });
+    };
 
     this.suggestionsMenu = suggestionsMenuFactory(this.getStaticParams());
   }
@@ -220,7 +227,7 @@ export function createSuggestionPlugin<T extends SuggestionItem>({
       new SuggestionPluginView({
         editor: editor,
         pluginKey: pluginKey,
-        onSelectItem: (props: { item: T; editor: Editor; range: Range }) => {
+        onSelectItem: (props: { item: T; editor: BlockNoteEditor }) => {
           deactivate(view);
           selectItemCallback(props);
         },
@@ -378,14 +385,20 @@ export function createSuggestionPlugin<T extends SuggestionItem>({
         // Selects an item and closes the menu.
         if (event.key === "Enter") {
           deactivate(view);
+          editor._tiptapEditor
+            .chain()
+            .focus()
+            .deleteRange({
+              from: queryStartPos! - triggerCharacter!.length,
+              to: editor._tiptapEditor.state.selection.from,
+            })
+            .run();
+
           selectItemCallback({
             item: items[keyboardHoveredItemIndex],
             editor: editor,
-            range: {
-              from: queryStartPos - triggerCharacter.length,
-              to: view.state.selection.from,
-            },
           });
+
           return true;
         }
 

package/types/src/BlockNoteEditor.d.ts

@@ -1,22 +1,114 @@
-import { Editor } from "@tiptap/core";
-import { Editor as EditorAPI } from "./api/Editor";
+import { Block, BlockIdentifier, PartialBlock } from "./extensions/Blocks/api/blockTypes";
 import { UiFactories } from "./BlockNoteExtensions";
-import { SlashCommand } from "./extensions/SlashMenu";
+import { BaseSlashMenuItem } from "./extensions/SlashMenu";
+import { Editor as TiptapEditor } from "@tiptap/core/dist/packages/core/src/Editor";
+import { TextCursorPosition } from "./extensions/Blocks/api/cursorPositionTypes";
 export type BlockNoteEditorOptions = {
     enableBlockNoteExtensions: boolean;
     disableHistoryExtension: boolean;
     uiFactories: UiFactories;
-    slashCommands: SlashCommand[];
+    slashCommands: BaseSlashMenuItem[];
     parentElement: HTMLElement;
     editorDOMAttributes: Record<string, string>;
-    onUpdate: (editor: BlockNoteEditor) => void;
-    onCreate: (editor: BlockNoteEditor) => void;
+    onEditorCreate: (editor: BlockNoteEditor) => void;
+    onEditorContentChange: (editor: BlockNoteEditor) => void;
+    onTextCursorPositionChange: (editor: BlockNoteEditor) => void;
     _tiptapOptions: any;
 };
-export declare class BlockNoteEditor extends EditorAPI {
-    readonly _tiptapEditor: Editor & {
+export declare class BlockNoteEditor {
+    readonly _tiptapEditor: TiptapEditor & {
         contentComponent: any;
     };
+    private blockCache;
     get domElement(): HTMLDivElement;
     constructor(options?: Partial<BlockNoteEditorOptions>);
+    /**
+     * 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[];
+    /**
+     * 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;
+    /**
+     * 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) => void, reverse?: boolean): void;
+    /**
+     * Gets a snapshot of the current text cursor position.
+     * @returns A snapshot of the current text cursor position.
+     */
+    getTextCursorPosition(): TextCursorPosition;
+    /**
+     * 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.
+     * @param targetBlock The identifier of an existing block that the text cursor should be moved to.
+     * @param placement Whether the text cursor should be placed at the start or end of the block.
+     */
+    setTextCursorPosition(targetBlock: BlockIdentifier, placement?: "start" | "end"): void;
+    /**
+     * Inserts new blocks into the editor. If a block's `id` is undefined, BlockNote generates one automatically. Throws an
+     * error if the reference block could not be found.
+     * @param blocksToInsert An array of partial blocks that should be inserted.
+     * @param referenceBlock An identifier for an existing block, at which the new blocks should be inserted.
+     * @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;
+    /**
+     * 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
+     * not be found.
+     * @param blockToUpdate The block that should be updated.
+     * @param update A partial block which defines how the existing block should be changed.
+     */
+    updateBlock(blockToUpdate: Block, update: PartialBlock): 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.
+     */
+    removeBlocks(blocksToRemove: Block[]): void;
+    /**
+     * Replaces existing blocks in the editor with new blocks. If the blocks that should be removed are not adjacent or
+     * are at different nesting levels, `blocksToInsert` will be inserted at the position of the first block in
+     * `blocksToRemove`. Throws an error if any of the blocks to remove could not be found.
+     * @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: Block[], blocksToInsert: PartialBlock[]): void;
+    /**
+     * Serializes blocks into an HTML string. To better conform to HTML standards, children of blocks which aren't list
+     * items are un-nested in the output HTML.
+     * @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>;
+    /**
+     * 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
+     * doesn't recognize an HTML element's tag, it will parse it as a paragraph or plain text.
+     * @param html The HTML string to parse blocks from.
+     * @returns The blocks parsed from the HTML string.
+     */
+    HTMLToBlocks(html: string): Promise<Block[]>;
+    /**
+     * 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>;
+    /**
+     * 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
+     * as text.
+     * @param markdown The Markdown string to parse blocks from.
+     * @returns The blocks parsed from the Markdown string.
+     */
+    markdownToBlocks(markdown: string): Promise<Block[]>;
 }

package/types/src/BlockNoteExtensions.d.ts

@@ -1,20 +1,21 @@
 import { Extensions } from "@tiptap/core";
+import { BlockNoteEditor } from "./BlockNoteEditor";
 import { BlockSideMenuFactory } from "./extensions/DraggableBlocks/BlockSideMenuFactoryTypes";
 import { FormattingToolbarFactory } from "./extensions/FormattingToolbar/FormattingToolbarFactoryTypes";
 import { HyperlinkToolbarFactory } from "./extensions/HyperlinkToolbar/HyperlinkToolbarFactoryTypes";
-import { SlashCommand } from "./extensions/SlashMenu";
-import { SlashMenuItem } from "./extensions/SlashMenu/SlashMenuItem";
+import { BaseSlashMenuItem } from "./extensions/SlashMenu";
 import { SuggestionsMenuFactory } from "./shared/plugins/suggestion/SuggestionsMenuFactoryTypes";
 export type UiFactories = Partial<{
     formattingToolbarFactory: FormattingToolbarFactory;
     hyperlinkToolbarFactory: HyperlinkToolbarFactory;
-    slashMenuFactory: SuggestionsMenuFactory<SlashMenuItem>;
+    slashMenuFactory: SuggestionsMenuFactory<BaseSlashMenuItem>;
     blockSideMenuFactory: BlockSideMenuFactory;
 }>;
 /**
  * Get all the Tiptap extensions BlockNote is configured with by default
  */
 export declare const getBlockNoteExtensions: (opts: {
+    editor: BlockNoteEditor;
     uiFactories: UiFactories;
-    slashCommands: SlashCommand[];
+    slashCommands: BaseSlashMenuItem[];
 }) => Extensions;

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(htmlString: string, schema: Schema): Promise<Block[]>;
+export declare function HTMLToBlocks(html: string, schema: Schema): Promise<Block[]>;
 export declare function blocksToMarkdown(blocks: Block[], schema: Schema): Promise<string>;
-export declare function markdownToBlocks(markdownString: string, schema: Schema): Promise<Block[]>;
+export declare function markdownToBlocks(markdown: string, schema: Schema): Promise<Block[]>;

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

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

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

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

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

@@ -1,9 +1,11 @@
 import { Extension } from "@tiptap/core";
 import { PluginKey } from "prosemirror-state";
 import { SuggestionsMenuFactory } from "../../shared/plugins/suggestion/SuggestionsMenuFactoryTypes";
-import { SlashMenuItem } from "./SlashMenuItem";
+import { BaseSlashMenuItem } from "./BaseSlashMenuItem";
+import { BlockNoteEditor } from "../../BlockNoteEditor";
 export type SlashMenuOptions = {
-    commands: SlashMenuItem[] | undefined;
+    editor: BlockNoteEditor | undefined;
+    commands: BaseSlashMenuItem[] | undefined;
     slashMenuFactory: SuggestionsMenuFactory<any> | undefined;
 };
 export declare const SlashMenuPluginKey: PluginKey<any>;

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

@@ -0,0 +1,5 @@
+import { BaseSlashMenuItem } from "./BaseSlashMenuItem";
+/**
+ * An array containing commands for creating all default blocks.
+ */
+export declare const defaultSlashMenuItems: BaseSlashMenuItem[];

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

@@ -1,4 +1,4 @@
-import { defaultSlashCommands } from "./defaultSlashCommands";
+import { defaultSlashMenuItems } from "./defaultSlashMenuItems";
 import { SlashMenuExtension } from "./SlashMenuExtension";
-import { SlashMenuItem } from "./SlashMenuItem";
-export { defaultSlashCommands, SlashMenuItem as SlashCommand, SlashMenuExtension, };
+import { BaseSlashMenuItem } from "./BaseSlashMenuItem";
+export { defaultSlashMenuItems, BaseSlashMenuItem, SlashMenuExtension };

package/types/src/index.d.ts

@@ -4,9 +4,8 @@ export * from "./extensions/Blocks/api/blockTypes";
 export * from "./extensions/DraggableBlocks/BlockSideMenuFactoryTypes";
 export * from "./extensions/FormattingToolbar/FormattingToolbarFactoryTypes";
 export * from "./extensions/HyperlinkToolbar/HyperlinkToolbarFactoryTypes";
-export { defaultSlashCommands } from "./extensions/SlashMenu/defaultSlashCommands";
-export * from "./extensions/SlashMenu/SlashMenuItem";
+export { defaultSlashMenuItems } from "./extensions/SlashMenu/defaultSlashMenuItems";
+export * from "./extensions/SlashMenu/BaseSlashMenuItem";
 export * from "./shared/EditorElement";
 export type { SuggestionItem } from "./shared/plugins/suggestion/SuggestionItem";
 export * from "./shared/plugins/suggestion/SuggestionsMenuFactoryTypes";
-export * from "../src/api/Editor";

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

@@ -1,16 +1,8 @@
 /**
  * A generic interface used in all suggestion menus (slash menu, mentions, etc)
  */
-export interface SuggestionItem {
-    /**
-     * The name of the item
-     */
+export declare class SuggestionItem {
     name: string;
-    /**
-     * This function matches this item against a query string, the function should return **true** if the item
-     * matches the query or **false** otherwise.
-     *
-     * @param query the query string
-     */
-    match(query: string): boolean;
+    match: (query: string) => boolean;
+    constructor(name: string, match: (query: string) => boolean);
 }