@blocknote/core 0.4.2 → 0.4.3

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,96 @@
-import { Editor } from "@tiptap/core";
-import { Editor as EditorAPI } from "./api/Editor";
+import { Block, 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;
     _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 list of all top-level blocks that are in the editor.
+     */
+    get topLevelBlocks(): Block[];
+    /**
+     * Traverses all blocks in the editor, including all nested blocks, and executes a callback for each. The traversal is
+     * depth-first, which is the same order as blocks appear in the editor by y-coordinate.
+     * @param callback The callback to execute for each block.
+     * @param reverse Whether the blocks should be traversed in reverse order.
+     */
+    allBlocks(callback: (block: Block) => void, reverse?: boolean): void;
+    /**
+     * Gets information regarding the position of the text cursor in the editor.
+     */
+    getTextCursorPosition(): TextCursorPosition;
+    setTextCursorPosition(block: Block, placement?: "start" | "end"): void;
+    /**
+     * Inserts multiple blocks before, after, or nested inside an existing block in the editor.
+     * @param blocksToInsert An array of blocks to insert.
+     * @param blockToInsertAt An existing block, marking where the new blocks should be inserted at.
+     * @param placement Determines whether the blocks should be inserted just before, just after, or nested inside the
+     * existing block.
+     */
+    insertBlocks(blocksToInsert: PartialBlock[], blockToInsertAt: Block, placement?: "before" | "after" | "nested"): void;
+    /**
+     * Updates a block in the editor to the given specification.
+     * @param blockToUpdate The block that should be updated.
+     * @param updatedBlock The specification that the block should be updated to.
+     */
+    updateBlock(blockToUpdate: Block, updatedBlock: PartialBlock): void;
+    /**
+     * Removes multiple blocks from the editor. Throws an error if any of the blocks could not be found.
+     * @param blocksToRemove An array of blocks that should be removed.
+     */
+    removeBlocks(blocksToRemove: Block[]): void;
+    /**
+     * Replaces multiple blocks in the editor with several other blocks. If the provided blocks to remove are not adjacent
+     * to each other, the new blocks are inserted at the position of the first block in the array. Throws an error if any
+     * of the blocks could not be found.
+     * @param blocksToRemove An array of blocks that should be replaced.
+     * @param blocksToInsert An array of blocks to replace the old ones with.
+     */
+    replaceBlocks(blocksToRemove: Block[], blocksToInsert: PartialBlock[]): void;
+    /**
+     * Executes a callback function whenever the editor's content changes.
+     * @param callback The callback function to execute.
+     */
+    onContentChange(callback: () => void): void;
+    /**
+     * Serializes a list of blocks into an HTML string. The output is not the same as what's rendered by the editor, and
+     * is simplified in order to better conform to HTML standards. Block structuring elements are removed, children of
+     * blocks which aren't list items are lifted out of them, and list items blocks are wrapped in `ul`/`ol` tags.
+     * @param blocks The list of blocks to serialize into HTML.
+     */
+    blocksToHTML(blocks: Block[]): Promise<string>;
+    /**
+     * Creates a list of blocks from an HTML string.
+     * @param htmlString The HTML string to create a list of blocks from.
+     */
+    HTMLToBlocks(htmlString: string): Promise<Block[]>;
+    /**
+     * Serializes a list of blocks into a Markdown string. The output is simplified as Markdown does not support all
+     * features of BlockNote. Block structuring elements are removed, children of blocks which aren't list items are
+     * lifted out of them, and certain styles are removed.
+     * @param blocks The list of blocks to serialize into Markdown.
+     */
+    blocksToMarkdown(blocks: Block[]): Promise<string>;
+    /**
+     * Creates a list of blocks from a Markdown string.
+     * @param markdownString The Markdown string to create a list of blocks from.
+     */
+    markdownToBlocks(markdownString: 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/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);
 }

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

@@ -2,6 +2,7 @@ import { Editor, Range } from "@tiptap/core";
 import { Plugin, PluginKey } from "prosemirror-state";
 import { SuggestionsMenuFactory } from "./SuggestionsMenuFactoryTypes";
 import { SuggestionItem } from "./SuggestionItem";
+import { BlockNoteEditor } from "../../../BlockNoteEditor";
 export type SuggestionPluginOptions<T extends SuggestionItem> = {
     /**
      * The name of the plugin.
@@ -10,9 +11,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.
      */
@@ -27,8 +28,7 @@ export type SuggestionPluginOptions<T extends SuggestionItem> = {
      */
     onSelectItem?: (props: {
         item: T;
-        editor: Editor;
-        range: Range;
+        editor: BlockNoteEditor;
     }) => void;
     /**
      * A function that should supply the plugin with items to suggest, based on a certain query string.

package/src/api/Editor.ts

@@ -1,226 +0,0 @@
-import { Editor as TiptapEditor } from "@tiptap/core";
-import { Node } from "prosemirror-model";
-import { getBlockInfoFromPos } from "../extensions/Blocks/helpers/getBlockInfoFromPos";
-import {
-  Block,
-  BlockIdentifier,
-  PartialBlock,
-} from "../extensions/Blocks/api/blockTypes";
-import { TextCursorPosition } from "../extensions/Blocks/api/cursorPositionTypes";
-import { nodeToBlock } from "./nodeConversions/nodeConversions";
-import {
-  insertBlocks,
-  removeBlocks,
-  replaceBlocks,
-  updateBlock,
-} from "./blockManipulation/blockManipulation";
-import {
-  blocksToHTML,
-  blocksToMarkdown,
-  HTMLToBlocks,
-  markdownToBlocks,
-} from "./formatConversions/formatConversions";
-
-export class Editor {
-  constructor(
-    private tiptapEditor: TiptapEditor,
-    private blockCache = new WeakMap<Node, Block>()
-  ) {}
-
-  /**
-   * Gets a snapshot of all top-level blocks that are in the editor.
-   * @returns An array containing a snapshot of all top-level (non-nested) blocks in the editor.
-   */
-  public get topLevelBlocks(): Block[] {
-    const blocks: Block[] = [];
-
-    this.tiptapEditor.state.doc.firstChild!.descendants((node) => {
-      blocks.push(nodeToBlock(node, this.blockCache));
-
-      return false;
-    });
-
-    return blocks;
-  }
-
-  /**
-   * Retrieves a snapshot of an existing block from the editor.
-   * @param block 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.
-   */
-  public getBlock(block: BlockIdentifier): Block | undefined {
-    const id = typeof block === "string" ? block : block.id;
-    let newBlock: Block | undefined = undefined;
-
-    this.tiptapEditor.state.doc.firstChild!.descendants((node) => {
-      if (typeof newBlock !== "undefined") {
-        return false;
-      }
-
-      if (node.type.name !== "blockContainer" || node.attrs.id !== id) {
-        return true;
-      }
-
-      newBlock = nodeToBlock(node, this.blockCache);
-
-      return false;
-    });
-
-    return newBlock;
-  }
-
-  /**
-   * Traverses all blocks in the editor, including all nested blocks, and executes a callback for each. The traversal is
-   * depth-first, which is the same order as blocks appear in the editor by y-coordinate. Stops traversal if the callback
-   * returns false;
-   * @param callback The callback to execute for each block.
-   * @param reverse Whether the blocks should be traversed in reverse order.
-   */
-  public forEachBlock(
-    callback: (block: Block) => boolean,
-    reverse: boolean = false
-  ): void {
-    let stop = false;
-
-    function helper(blocks: Block[]) {
-      if (reverse) {
-        for (const block of blocks.reverse()) {
-          helper(block.children);
-
-          if (stop) {
-            return;
-          }
-
-          stop = !callback(block);
-
-          if (stop) {
-            return;
-          }
-        }
-      } else {
-        for (const block of blocks) {
-          stop = !callback(block);
-
-          if (stop) {
-            return;
-          }
-
-          helper(block.children);
-
-          if (stop) {
-            return;
-          }
-        }
-      }
-    }
-
-    helper(this.topLevelBlocks);
-  }
-
-  /**
-   * Gets a snapshot of the text cursor position within the editor.
-   * @returns A snapshot of the text cursor position.
-   */
-  public get textCursorPosition(): TextCursorPosition {
-    const { node } = getBlockInfoFromPos(
-      this.tiptapEditor.state.doc,
-      this.tiptapEditor.state.selection.from
-    )!;
-
-    return { block: nodeToBlock(node, this.blockCache) };
-  }
-
-  /**
-   * Inserts multiple blocks before, after, or nested inside an existing block in the editor.
-   * @param blocksToInsert An array of blocks to insert.
-   * @param blockToInsertAt An existing block, marking where the new blocks should be inserted at.
-   * @param placement Determines whether the blocks should be inserted just before, just after, or nested inside the
-   * existing block.
-   */
-  public insertBlocks(
-    blocksToInsert: PartialBlock[],
-    blockToInsertAt: Block,
-    placement: "before" | "after" | "nested" = "before"
-  ): void {
-    insertBlocks(blocksToInsert, blockToInsertAt, placement, this.tiptapEditor);
-  }
-
-  /**
-   * Updates a block in the editor to the given specification.
-   * @param blockToUpdate The block that should be updated.
-   * @param updatedBlock The specification that the block should be updated to.
-   */
-  public updateBlock(blockToUpdate: Block, updatedBlock: PartialBlock) {
-    updateBlock(blockToUpdate, updatedBlock, this.tiptapEditor);
-  }
-
-  /**
-   * Removes multiple blocks from the editor. Throws an error if any of the blocks could not be found.
-   * @param blocksToRemove An array of blocks that should be removed.
-   */
-  public removeBlocks(blocksToRemove: Block[]) {
-    removeBlocks(blocksToRemove, this.tiptapEditor);
-  }
-
-  /**
-   * Replaces multiple blocks in the editor with several other blocks. If the provided blocks to remove are not adjacent
-   * to each other, the new blocks are inserted at the position of the first block in the array. Throws an error if any
-   * of the blocks could not be found.
-   * @param blocksToRemove An array of blocks that should be replaced.
-   * @param blocksToInsert An array of blocks to replace the old ones with.
-   */
-  public replaceBlocks(
-    blocksToRemove: Block[],
-    blocksToInsert: PartialBlock[]
-  ) {
-    replaceBlocks(blocksToRemove, blocksToInsert, this.tiptapEditor);
-  }
-
-  /**
-   * Executes a callback function whenever the editor's contents change.
-   * @param callback The callback function to execute.
-   */
-  public onContentChange(callback: () => void) {
-    this.tiptapEditor.on("update", callback);
-  }
-
-  /**
-   * Serializes a list of blocks into an HTML string. The output is not the same as what's rendered by the editor, and
-   * is simplified in order to better conform to HTML standards. Block structuring elements are removed, children of
-   * blocks which aren't list items are lifted out of them, and list items blocks are wrapped in `ul`/`ol` tags.
-   * @param blocks The list of blocks to serialize into HTML.
-   * @returns An HTML representation of the blocks.
-   */
-  public async blocksToHTML(blocks: Block[]): Promise<string> {
-    return blocksToHTML(blocks, this.tiptapEditor.schema);
-  }
-
-  /**
-   * Creates a list of blocks from an HTML string.
-   * @param htmlString The HTML string to create a list of blocks from.
-   * @returns A list of blocks parsed from the HTML string.
-   */
-  public async HTMLToBlocks(htmlString: string): Promise<Block[]> {
-    return HTMLToBlocks(htmlString, this.tiptapEditor.schema);
-  }
-
-  /**
-   * Serializes a list of blocks into a Markdown string. The output is simplified as Markdown does not support all
-   * features of BlockNote. Block structuring elements are removed, children of blocks which aren't list items are
-   * un-nested, and certain styles are removed.
-   * @param blocks The list of blocks to serialize into Markdown.
-   * @returns A Markdown representation of the blocks.
-   */
-  public async blocksToMarkdown(blocks: Block[]): Promise<string> {
-    return blocksToMarkdown(blocks, this.tiptapEditor.schema);
-  }
-
-  /**
-   * Creates a list of blocks from a Markdown string.
-   * @param markdownString The Markdown string to create a list of blocks from.
-   * @returns A list of blocks parsed from the Markdown string.
-   */
-  public async markdownToBlocks(markdownString: string): Promise<Block[]> {
-    return markdownToBlocks(markdownString, this.tiptapEditor.schema);
-  }
-}

package/src/extensions/SlashMenu/SlashMenuItem.ts

@@ -1,34 +0,0 @@
-import { Editor, Range } from "@tiptap/core";
-import { SuggestionItem } from "../../shared/plugins/suggestion/SuggestionItem";
-
-/**
- * A class that defines a slash command (/<command>).
- *
- * Not to be confused with ProseMirror commands nor TipTap commands.
- */
-export class SlashMenuItem implements SuggestionItem {
-  /**
-   * 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(
-    public readonly name: string,
-    public readonly execute: (editor: Editor, range: Range) => void,
-    public readonly aliases: string[] = [],
-    public readonly group: string,
-    public readonly hint?: string,
-    public readonly shortcut?: string
-  ) {}
-
-  match(query: string): boolean {
-    return (
-      this.name.toLowerCase().startsWith(query.toLowerCase()) ||
-      this.aliases.filter((alias) =>
-        alias.toLowerCase().startsWith(query.toLowerCase())
-      ).length !== 0
-    );
-  }
-}