@blocknote/core 0.4.0 → 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/src/shared/utils.ts

@@ -10,3 +10,9 @@ export function formatKeyboardShortcut(shortcut: string) {
     return shortcut.replace("Mod", "Ctrl");
   }
 }
+
+export class UnreachableCaseError extends Error {
+  constructor(val: never) {
+    super(`Unreachable case: ${val}`);
+  }
+}

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: () => void;
-    onCreate: () => void;
+    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/api/Editor.d.ts

@@ -1,17 +1,33 @@
 import { Editor as TiptapEditor } from "@tiptap/core";
 import { Node } from "prosemirror-model";
-import { Block, PartialBlock } from "../extensions/Blocks/api/blockTypes";
+import { Block, BlockIdentifier, PartialBlock } from "../extensions/Blocks/api/blockTypes";
 import { TextCursorPosition } from "../extensions/Blocks/api/cursorPositionTypes";
 export declare class Editor {
     private tiptapEditor;
     private blockCache;
     constructor(tiptapEditor: TiptapEditor, blockCache?: WeakMap<Node, Block>);
     /**
-     * Gets a list of all top-level blocks that are in the editor.
+     * 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.
      */
-    get allBlocks(): Block[];
+    get topLevelBlocks(): Block[];
     /**
-     * Gets information regarding the position of the text cursor in the editor.
+     * 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.
+     */
+    getBlock(block: BlockIdentifier): Block | undefined;
+    /**
+     * 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.
+     */
+    forEachBlock(callback: (block: Block) => boolean, reverse?: boolean): void;
+    /**
+     * Gets a snapshot of the text cursor position within the editor.
+     * @returns A snapshot of the text cursor position.
      */
     get textCursorPosition(): TextCursorPosition;
     /**
@@ -42,7 +58,7 @@ export declare class Editor {
      */
     replaceBlocks(blocksToRemove: Block[], blocksToInsert: PartialBlock[]): void;
     /**
-     * Executes a callback function whenever the editor's content changes.
+     * Executes a callback function whenever the editor's contents change.
      * @param callback The callback function to execute.
      */
     onContentChange(callback: () => void): void;
@@ -51,23 +67,27 @@ export declare class Editor {
      * 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.
      */
     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.
+     * @returns A list of blocks parsed from the HTML string.
      */
     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.
+     * un-nested, and certain styles are removed.
      * @param blocks The list of blocks to serialize into Markdown.
+     * @returns A Markdown representation of the blocks.
      */
     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.
+     * @returns A list of blocks parsed from the Markdown string.
      */
     markdownToBlocks(markdownString: string): Promise<Block[]>;
 }

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

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

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1 @@
+export {};

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

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

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

@@ -0,0 +1 @@
+export {};

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

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

package/types/src/api/util/nodeUtil.d.ts

@@ -0,0 +1,8 @@
+import { Node } from "prosemirror-model";
+/**
+ * Get a TipTap node by id
+ */
+export declare function getNodeById(id: string, doc: Node): {
+    node: Node;
+    posBeforeNode: number;
+};

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

@@ -1,5 +1,5 @@
 /** Define the main block types **/
-import { InlineContent } from "./inlineContentTypes";
+import { InlineContent, PartialInlineContent } from "./inlineContentTypes";
 export type BlockTemplate<Type extends string, Props extends Record<string, string>> = {
     id: string;
     type: Type;
@@ -7,23 +7,24 @@ export type BlockTemplate<Type extends string, Props extends Record<string, stri
     content: InlineContent[];
     children: Block[];
 };
-export type GlobalProps = {
+export type DefaultBlockProps = {
     backgroundColor: string;
     textColor: string;
     textAlignment: "left" | "center" | "right" | "justify";
 };
-export type NumberedListItemBlock = BlockTemplate<"numberedListItem", GlobalProps>;
-export type BulletListItemBlock = BlockTemplate<"bulletListItem", GlobalProps>;
-export type HeadingBlock = BlockTemplate<"heading", GlobalProps & {
+export type NumberedListItemBlock = BlockTemplate<"numberedListItem", DefaultBlockProps>;
+export type BulletListItemBlock = BlockTemplate<"bulletListItem", DefaultBlockProps>;
+export type HeadingBlock = BlockTemplate<"heading", DefaultBlockProps & {
     level: "1" | "2" | "3";
 }>;
-export type ParagraphBlock = BlockTemplate<"paragraph", GlobalProps>;
+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"];
+    type?: B["type"];
     props?: Partial<B["props"]>;
-    content?: string | B["content"];
+    content?: string | PartialInlineContent[];
     children?: PartialBlock[];
 } : never;
 export type PartialBlock = PartialBlockTemplate<Block>;
@@ -32,5 +33,5 @@ export type BlockPropsTemplate<Props> = Props extends Block["props"] ? keyof Pro
  * 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 GlobalProps>;
+export declare const globalProps: Array<keyof DefaultBlockProps>;
 export declare const blockProps: Record<Block["type"], Set<string>>;

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/Blocks/api/inlineContentTypes.d.ts

@@ -1,23 +1,29 @@
-export type StyleTemplate<Type extends string, Props extends Record<string, string>> = {
-    type: Type;
-    props: Props;
+export type Styles = {
+    bold?: true;
+    italic?: true;
+    underline?: true;
+    strike?: true;
+    textColor?: string;
+    backgroundColor?: string;
 };
-export type Bold = StyleTemplate<"bold", {}>;
-export type Italic = StyleTemplate<"italic", {}>;
-export type Underline = StyleTemplate<"underline", {}>;
-export type Strikethrough = StyleTemplate<"strike", {}>;
-export type TextColor = StyleTemplate<"textColor", {
-    color: string;
-}>;
-export type BackgroundColor = StyleTemplate<"backgroundColor", {
-    color: string;
-}>;
-export type Link = StyleTemplate<"link", {
-    href: string;
-}>;
-export type Style = Bold | Italic | Underline | Strikethrough | TextColor | BackgroundColor | Link;
+export type ToggledStyles = {
+    [K in keyof Styles]-?: Required<Styles>[K] extends true ? K : never;
+}[keyof Styles];
+export type ColorStyles = {
+    [K in keyof Styles]-?: Required<Styles>[K] extends string ? K : never;
+}[keyof Styles];
 export type StyledText = {
+    type: "text";
     text: string;
-    styles: Style[];
+    styles: Styles;
+};
+export type Link = {
+    type: "link";
+    href: string;
+    content: StyledText[];
+};
+export type PartialLink = Omit<Link, "content"> & {
+    content: string | Link["content"];
 };
-export type InlineContent = StyledText;
+export type InlineContent = StyledText | Link;
+export type PartialInlineContent = StyledText | PartialLink;

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

@@ -24,6 +24,21 @@ export declare class BlockMenuView {
     menuOpen: boolean;
     menuFrozen: boolean;
     constructor({ editor, blockMenuFactory, horizontalPosAnchoredAtRoot, }: BlockMenuViewProps);
+    /**
+     * If the event is outside of the editor contents,
+     * we dispatch a fake event, so that we can still drop the content
+     * when dragging / dropping to the side of the editor
+     */
+    onDrop: (event: DragEvent) => void;
+    /**
+     * If the event is outside of the editor contents,
+     * we dispatch a fake event, so that we can still drop the content
+     * when dragging / dropping to the side of the editor
+     */
+    onDragOver: (event: DragEvent) => void;
+    onKeyDown: (_event: KeyboardEvent) => void;
+    onMouseDown: (event: MouseEvent) => void;
+    onMouseMove: (event: MouseEvent) => void;
     destroy(): void;
     addBlock(): void;
     deleteBlock(): void;

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/types/src/shared/utils.d.ts

@@ -1,2 +1,5 @@
 export declare const isAppleOS: () => boolean;
 export declare function formatKeyboardShortcut(shortcut: string): string;
+export declare class UnreachableCaseError extends Error {
+    constructor(val: never);
+}