@blocknote/core 0.4.0 → 0.4.2

package/src/extensions/Blocks/nodes/BlockContainer.ts

@@ -1,7 +1,10 @@
 import { mergeAttributes, Node } from "@tiptap/core";
 import { Fragment, Node as PMNode, Slice } from "prosemirror-model";
 import { TextSelection } from "prosemirror-state";
-import { blockToNode } from "../../../api/nodeConversions/nodeConversions";
+import {
+  blockToNode,
+  inlineContentToNodes,
+} from "../../../api/nodeConversions/nodeConversions";
 import { PartialBlock } from "../api/blockTypes";
 import { getBlockInfoFromPos } from "../helpers/getBlockInfoFromPos";
 import { PreviousBlockTypePlugin } from "../PreviousBlockTypePlugin";
@@ -329,15 +332,7 @@ export const BlockContainer = Node.create<IBlock>({
               } else {
                 // Adds a text node with the provided styles converted into marks to the content, for each InlineContent
                 // object.
-                for (const styledText of block.content) {
-                  const marks = [];
-
-                  for (const style of styledText.styles) {
-                    marks.push(state.schema.mark(style.type, style.props));
-                  }
-
-                  content.push(state.schema.text(styledText.text, marks));
-                }
+                content = inlineContentToNodes(block.content, state.schema);
               }
 
               // Replaces the contents of the blockContent node with the previously created text node(s).
@@ -350,10 +345,16 @@ export const BlockContainer = Node.create<IBlock>({
 
             // Changes the block type and adds the provided props as node attributes. Also preserves all existing node
             // attributes that are compatible with the new type.
-            state.tr.setNodeMarkup(startPos, state.schema.nodes[block.type], {
-              ...contentNode.attrs,
-              ...block.props,
-            });
+            state.tr.setNodeMarkup(
+              startPos,
+              block.type === undefined
+                ? undefined
+                : state.schema.nodes[block.type],
+              {
+                ...contentNode.attrs,
+                ...block.props,
+              }
+            );
           }
 
           return true;

package/src/extensions/DraggableBlocks/DraggableBlocksPlugin.ts

@@ -150,8 +150,10 @@ function setDragImage(view: EditorView, from: number, to = from) {
   }
 
   // dataTransfer.setDragImage(element) only works if element is attached to the DOM.
+  unsetDragImage();
   dragImageElement = parentClone;
-  dragImageElement.className = styles.dragPreview;
+  dragImageElement.className =
+    dragImageElement.className + " " + styles.dragPreview;
   document.body.appendChild(dragImageElement);
 }
 
@@ -245,104 +247,164 @@ export class BlockMenuView {
 
     this.blockMenu = blockMenuFactory(this.getStaticParams());
 
+    document.body.addEventListener("drop", this.onDrop, true);
+    document.body.addEventListener("dragover", this.onDragOver);
+
     // Shows or updates menu position whenever the cursor moves, if the menu isn't frozen.
-    document.body.addEventListener(
-      "mousemove",
-      (event) => {
-        if (this.menuFrozen) {
-          return;
-        }
-
-        // Editor itself may have padding or other styling which affects size/position, so we get the boundingRect of
-        // the first child (i.e. the blockGroup that wraps all blocks in the editor) for a more accurate bounding box.
-        const editorBoundingBox = (
-          this.editor.view.dom.firstChild! as HTMLElement
-        ).getBoundingClientRect();
-
-        this.horizontalPosAnchor = editorBoundingBox.x;
-
-        // Gets block at mouse cursor's vertical position.
-        const coords = {
-          left: editorBoundingBox.left + editorBoundingBox.width / 2, // take middle of editor
-          top: event.clientY,
-        };
-        const block = getDraggableBlockFromCoords(coords, this.editor.view);
-
-        // Closes the menu if the mouse cursor is beyond the editor vertically.
-        if (!block) {
-          if (this.menuOpen) {
-            this.menuOpen = false;
-            this.blockMenu.hide();
-          }
-
-          return;
-        }
-
-        // Doesn't update if the menu is already open and the mouse cursor is still hovering the same block.
-        if (
-          this.menuOpen &&
-          this.hoveredBlockContent?.hasAttribute("data-id") &&
-          this.hoveredBlockContent?.getAttribute("data-id") === block.id
-        ) {
-          return;
-        }
-
-        // Gets the block's content node, which lets to ignore child blocks when determining the block menu's position.
-        const blockContent = block.node.firstChild as HTMLElement;
-        this.hoveredBlockContent = blockContent;
-
-        if (!blockContent) {
-          return;
-        }
-
-        // Shows or updates elements.
-        if (!this.menuOpen) {
-          this.menuOpen = true;
-          this.blockMenu.render(this.getDynamicParams(), true);
-        } else {
-          this.blockMenu.render(this.getDynamicParams(), false);
-        }
-      },
-      true
-    );
+    document.body.addEventListener("mousemove", this.onMouseMove, true);
 
     // Hides and unfreezes the menu whenever the user selects the editor with the mouse or presses a key.
     // TODO: Better integration with suggestions menu and only editor scope?
-    document.body.addEventListener(
-      "mousedown",
-      (event) => {
-        if (this.blockMenu.element?.contains(event.target as HTMLElement)) {
-          return;
-        }
-
-        if (this.menuOpen) {
-          this.menuOpen = false;
-          this.blockMenu.hide();
-        }
+    document.body.addEventListener("mousedown", this.onMouseDown, true);
+    document.body.addEventListener("keydown", this.onKeyDown, true);
+  }
 
-        this.menuFrozen = false;
-      },
-      true
-    );
-    document.body.addEventListener(
-      "keydown",
-      () => {
-        if (this.menuOpen) {
-          this.menuOpen = false;
-          this.blockMenu.hide();
-        }
+  /**
+   * 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) => {
+    if ((event as any).synthetic) {
+      return;
+    }
+    let pos = this.editor.view.posAtCoords({
+      left: event.clientX,
+      top: event.clientY,
+    });
 
-        this.menuFrozen = false;
-      },
-      true
-    );
-  }
+    if (!pos || pos.inside === -1) {
+      const evt = new Event("drop", event) as any;
+      const editorBoundingBox = (
+        this.editor.view.dom.firstChild! as HTMLElement
+      ).getBoundingClientRect();
+      evt.clientX = editorBoundingBox.left + editorBoundingBox.width / 2;
+      evt.clientY = event.clientY;
+      evt.dataTransfer = event.dataTransfer;
+      evt.preventDefault = () => event.preventDefault();
+      evt.synthetic = true; // prevent recursion
+      // console.log("dispatch fake drop");
+      this.editor.view.dom.dispatchEvent(evt);
+    }
+  };
+
+  /**
+   * 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) => {
+    if ((event as any).synthetic) {
+      return;
+    }
+    let pos = this.editor.view.posAtCoords({
+      left: event.clientX,
+      top: event.clientY,
+    });
+
+    if (!pos || pos.inside === -1) {
+      const evt = new Event("dragover", event) as any;
+      const editorBoundingBox = (
+        this.editor.view.dom.firstChild! as HTMLElement
+      ).getBoundingClientRect();
+      evt.clientX = editorBoundingBox.left + editorBoundingBox.width / 2;
+      evt.clientY = event.clientY;
+      evt.dataTransfer = event.dataTransfer;
+      evt.preventDefault = () => event.preventDefault();
+      evt.synthetic = true; // prevent recursion
+      // console.log("dispatch fake dragover");
+      this.editor.view.dom.dispatchEvent(evt);
+    }
+  };
+
+  onKeyDown = (_event: KeyboardEvent) => {
+    if (this.menuOpen) {
+      this.menuOpen = false;
+      this.blockMenu.hide();
+    }
+
+    this.menuFrozen = false;
+  };
+
+  onMouseDown = (event: MouseEvent) => {
+    if (this.blockMenu.element?.contains(event.target as HTMLElement)) {
+      return;
+    }
+
+    if (this.menuOpen) {
+      this.menuOpen = false;
+      this.blockMenu.hide();
+    }
+
+    this.menuFrozen = false;
+  };
+
+  onMouseMove = (event: MouseEvent) => {
+    if (this.menuFrozen) {
+      return;
+    }
+
+    // Editor itself may have padding or other styling which affects size/position, so we get the boundingRect of
+    // the first child (i.e. the blockGroup that wraps all blocks in the editor) for a more accurate bounding box.
+    const editorBoundingBox = (
+      this.editor.view.dom.firstChild! as HTMLElement
+    ).getBoundingClientRect();
+
+    this.horizontalPosAnchor = editorBoundingBox.x;
+
+    // Gets block at mouse cursor's vertical position.
+    const coords = {
+      left: editorBoundingBox.left + editorBoundingBox.width / 2, // take middle of editor
+      top: event.clientY,
+    };
+    const block = getDraggableBlockFromCoords(coords, this.editor.view);
+
+    // Closes the menu if the mouse cursor is beyond the editor vertically.
+    if (!block) {
+      if (this.menuOpen) {
+        this.menuOpen = false;
+        this.blockMenu.hide();
+      }
+
+      return;
+    }
+
+    // Doesn't update if the menu is already open and the mouse cursor is still hovering the same block.
+    if (
+      this.menuOpen &&
+      this.hoveredBlockContent?.hasAttribute("data-id") &&
+      this.hoveredBlockContent?.getAttribute("data-id") === block.id
+    ) {
+      return;
+    }
+
+    // Gets the block's content node, which lets to ignore child blocks when determining the block menu's position.
+    const blockContent = block.node.firstChild as HTMLElement;
+    this.hoveredBlockContent = blockContent;
+
+    if (!blockContent) {
+      return;
+    }
+
+    // Shows or updates elements.
+    if (!this.menuOpen) {
+      this.menuOpen = true;
+      this.blockMenu.render(this.getDynamicParams(), true);
+    } else {
+      this.blockMenu.render(this.getDynamicParams(), false);
+    }
+  };
 
   destroy() {
     if (this.menuOpen) {
       this.menuOpen = false;
       this.blockMenu.hide();
     }
+    document.body.removeEventListener("mousemove", this.onMouseMove);
+    document.body.removeEventListener("dragover", this.onDragOver);
+    document.body.removeEventListener("drop", this.onDrop);
+    document.body.removeEventListener("mousedown", this.onMouseDown);
+    document.body.removeEventListener("keydown", this.onKeyDown);
   }
 
   addBlock() {

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

@@ -9,8 +9,8 @@ export type BlockNoteEditorOptions = {
     slashCommands: SlashCommand[];
     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 {

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/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/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);
+}

package/types/src/EditorElement.d.ts

@@ -1,7 +0,0 @@
-export declare type EditorElement<ElementParams extends Record<string, any>> = {
-    element: HTMLElement | undefined;
-    show: (params: ElementParams) => void;
-    hide: () => void;
-    update: (params: ElementParams) => void;
-};
-export declare type ElementFactory<ElementParams extends Record<string, any>> = (params: ElementParams) => EditorElement<ElementParams>;

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

@@ -1,5 +0,0 @@
-import { Node } from "prosemirror-model";
-import { EditorState } from "prosemirror-state";
-import { Block, Document } from "../extensions/Blocks/apiTypes";
-export declare function BlockFromPMNode(node: Node): Block;
-export declare function DocumentFromPMState(_state: EditorState): Document;

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

@@ -1,6 +0,0 @@
-import { Parent as HASTParent } from "hast";
-/**
- * Rehype plugin which removes <u> tags. Used to remove underlines before converting HTML to markdown, as Markdown
- * doesn't support underlines.
- */
-export declare function removeUnderlines(): (tree: HASTParent) => void;

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

@@ -1,16 +0,0 @@
-import { Parent as HASTParent } from "hast";
-type SimplifyBlocksOptions = {
-    orderedListItemBlockTypes: Set<string>;
-    unorderedListItemBlockTypes: Set<string>;
-};
-/**
- * Rehype plugin which converts the HTML output string rendered by BlockNote into a simplified structure which better
- * follows HTML standards. It does several things:
- * - Removes all block related div elements, leaving only the actual content inside the block.
- * - Lifts nested blocks to a higher level for all block types that don't represent list items.
- * - Wraps blocks which represent list items in corresponding ul/ol HTML elements and restructures them to comply
- * with HTML list structure.
- * @param options Options for specifying which block types represent ordered and unordered list items.
- */
-export declare function simplifyBlocks(options: SimplifyBlocksOptions): (tree: HASTParent) => void;
-export {};

package/types/src/extensions/Blocks/BlockAttributes.d.ts

@@ -1,2 +0,0 @@
-declare const BlockAttributes: Record<string, string>;
-export default BlockAttributes;