@blocknote/core 0.3.0 → 0.4.2

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

@@ -0,0 +1,93 @@
+import { Editor as TiptapEditor } from "@tiptap/core";
+import { Node } from "prosemirror-model";
+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 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 topLevelBlocks(): Block[];
+    /**
+     * 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;
+    /**
+     * 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 contents change.
+     * @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.
+     * @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
+     * 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

@@ -0,0 +1,6 @@
+import { Editor } from "@tiptap/core";
+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.d.ts

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

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

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

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

@@ -0,0 +1,6 @@
+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/formatConversions/simplifyBlocksRehypePlugin.d.ts

@@ -0,0 +1,16 @@
+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/api/nodeConversions/nodeConversions.d.ts

@@ -0,0 +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;
+/**
+ * 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

@@ -0,0 +1,37 @@
+/** Define the main block types **/
+import { InlineContent, PartialInlineContent } from "./inlineContentTypes";
+export type BlockTemplate<Type extends string, Props extends Record<string, string>> = {
+    id: string;
+    type: Type;
+    props: Props;
+    content: InlineContent[];
+    children: Block[];
+};
+export type DefaultBlockProps = {
+    backgroundColor: string;
+    textColor: string;
+    textAlignment: "left" | "center" | "right" | "justify";
+};
+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", 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"];
+    props?: Partial<B["props"]>;
+    content?: string | PartialInlineContent[];
+    children?: PartialBlock[];
+} : never;
+export type PartialBlock = PartialBlockTemplate<Block>;
+export type BlockPropsTemplate<Props> = Props extends Block["props"] ? keyof Props : never;
+/**
+ * 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 DefaultBlockProps>;
+export declare const blockProps: Record<Block["type"], Set<string>>;

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

@@ -0,0 +1,4 @@
+import { Block } from "./blockTypes";
+export type TextCursorPosition = {
+    block: Block;
+};

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

@@ -0,0 +1,29 @@
+export type Styles = {
+    bold?: true;
+    italic?: true;
+    underline?: true;
+    strike?: true;
+    textColor?: string;
+    backgroundColor?: string;
+};
+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: Styles;
+};
+export type Link = {
+    type: "link";
+    href: string;
+    content: StyledText[];
+};
+export type PartialLink = Omit<Link, "content"> & {
+    content: string | Link["content"];
+};
+export type InlineContent = StyledText | Link;
+export type PartialInlineContent = StyledText | PartialLink;

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

@@ -1,5 +1,5 @@
 import { Node } from "@tiptap/core";
-import { BlockUpdate } from "../apiTypes";
+import { PartialBlock } from "../api/blockTypes";
 export interface IBlock {
     HTMLAttributes: Record<string, any>;
 }
@@ -10,8 +10,8 @@ declare module "@tiptap/core" {
             BNDeleteBlock: (posInBlock: number) => ReturnType;
             BNMergeBlocks: (posBetweenBlocks: number) => ReturnType;
             BNSplitBlock: (posInBlock: number, keepType: boolean) => ReturnType;
-            BNUpdateBlock: (posInBlock: number, blockUpdate: BlockUpdate) => ReturnType;
-            BNCreateOrUpdateBlock: (posInBlock: number, blockUpdate: BlockUpdate) => ReturnType;
+            BNUpdateBlock: (posInBlock: number, block: PartialBlock) => ReturnType;
+            BNCreateOrUpdateBlock: (posInBlock: number, block: PartialBlock) => ReturnType;
         };
     }
 }

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/FormattingToolbar/FormattingToolbarFactoryTypes.d.ts

@@ -1,5 +1,5 @@
 import { EditorElement, ElementFactory } from "../../shared/EditorElement";
-import { Block, BlockUpdate } from "../Blocks/apiTypes";
+import { Block, PartialBlock } from "../Blocks/api/blockTypes";
 export type FormattingToolbarStaticParams = {
     toggleBold: () => void;
     toggleItalic: () => void;
@@ -11,7 +11,7 @@ export type FormattingToolbarStaticParams = {
     setTextAlignment: (textAlignment: "left" | "center" | "right" | "justify") => void;
     increaseBlockIndent: () => void;
     decreaseBlockIndent: () => void;
-    updateBlock: (blockUpdate: BlockUpdate) => void;
+    updateBlock: (updatedBlock: PartialBlock) => void;
 };
 export type FormattingToolbarDynamicParams = {
     boldIsActive: boolean;

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

@@ -3,9 +3,7 @@ import { PluginKey } from "prosemirror-state";
 import { SuggestionsMenuFactory } from "../../shared/plugins/suggestion/SuggestionsMenuFactoryTypes";
 import { SlashMenuItem } from "./SlashMenuItem";
 export type SlashMenuOptions = {
-    commands: {
-        [key: string]: SlashMenuItem;
-    };
+    commands: SlashMenuItem[] | undefined;
     slashMenuFactory: SuggestionsMenuFactory<any> | undefined;
 };
 export declare const SlashMenuPluginKey: PluginKey<any>;

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

@@ -9,6 +9,9 @@ export declare class SlashMenuItem implements SuggestionItem {
     readonly name: string;
     readonly execute: (editor: Editor, range: Range) => void;
     readonly aliases: string[];
+    readonly group: string;
+    readonly hint?: string | undefined;
+    readonly shortcut?: string | undefined;
     /**
      * Constructs a new slash-command.
      *
@@ -16,6 +19,6 @@ export declare class SlashMenuItem implements SuggestionItem {
      * @param execute The callback for creating a new node
      * @param aliases Aliases for this command
      */
-    constructor(name: string, execute: (editor: Editor, range: Range) => void, aliases?: string[]);
+    constructor(name: string, execute: (editor: Editor, range: Range) => void, aliases: string[], group: string, hint?: string | undefined, shortcut?: string | undefined);
     match(query: string): boolean;
 }

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

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

package/types/src/index.d.ts

@@ -1,10 +1,12 @@
 export * from "./BlockNoteEditor";
 export * from "./BlockNoteExtensions";
-export type { Block, BlockUpdate } from "./extensions/Blocks/apiTypes";
-export * from "./extensions/FormattingToolbar/FormattingToolbarFactoryTypes";
+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 * 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/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/src/extensions/Blocks/apiTypes.ts

@@ -1,48 +0,0 @@
-export type BlockSpec<
-  // Type of the block.
-  // Examples might include: "paragraph", "heading", or "bulletListItem".
-  Type extends string,
-  // Changeable props which affect the block's behaviour or appearance.
-  // An example might be: { textAlignment: "left" | "right" | "center" | "justify" } for a paragraph block.
-  Props extends Record<string, string>
-> = {
-  type: Type;
-  props: Props;
-};
-
-export type BlockSpecUpdate<Spec> = Spec extends BlockSpec<
-  infer Type,
-  infer Props
->
-  ? {
-      type: Type;
-      props?: Partial<Props>;
-    }
-  : never;
-
-export type NumberedListItemBlock = BlockSpec<"numberedListItem", {}>;
-
-export type BulletListItemBlock = BlockSpec<"bulletListItem", {}>;
-
-export type HeadingBlock = BlockSpec<
-  "heading",
-  {
-    level: "1" | "2" | "3";
-  }
->;
-
-export type ParagraphBlock = BlockSpec<"paragraph", {}>;
-
-export type Block =
-  | ParagraphBlock
-  | HeadingBlock
-  | BulletListItemBlock
-  | NumberedListItemBlock;
-
-export type BlockUpdate = BlockSpecUpdate<Block>;
-
-/*
-TODO:
- 1) guard read / writes (now we just pass on internal node attrs)
- 2) where to locate this code / types
-*/

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/extensions/Blocks/BlockAttributes.d.ts

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

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

@@ -1,24 +0,0 @@
-import { Selection } from "prosemirror-state";
-import { Node, ResolvedPos, Slice } from "prosemirror-model";
-import { Mappable } from "prosemirror-transform";
-/**
- * This class represents an editor selection which spans multiple nodes/blocks. It's currently only used to allow users
- * to drag multiple blocks at the same time. Expects the selection anchor and head to be between nodes, i.e. just before
- * the first target node and just after the last, and that anchor and head are at the same nesting level.
- *
- * Partially based on ProseMirror's NodeSelection implementation:
- * (https://github.com/ProseMirror/prosemirror-state/blob/master/src/selection.ts)
- * MultipleNodeSelection differs from NodeSelection in the following ways:
- * 1. Stores which nodes are included in the selection instead of just a single node.
- * 2. Already expects the selection to start just before the first target node and ends just after the last, while a
- * NodeSelection automatically sets both anchor and head to just before the single target node.
- */
-export declare class MultipleNodeSelection extends Selection {
-    nodes: Array<Node>;
-    constructor($anchor: ResolvedPos, $head: ResolvedPos);
-    static create(doc: Node, from: number, to?: number): MultipleNodeSelection;
-    content(): Slice;
-    eq(selection: Selection): boolean;
-    map(doc: Node, mapping: Mappable): Selection;
-    toJSON(): any;
-}

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

@@ -1,16 +0,0 @@
-export type BlockSpec<Type extends string, Props extends Record<string, string>> = {
-    type: Type;
-    props: Props;
-};
-export type BlockSpecUpdate<Spec> = Spec extends BlockSpec<infer Type, infer Props> ? {
-    type: Type;
-    props?: Partial<Props>;
-} : never;
-export type NumberedListItemBlock = BlockSpec<"numberedListItem", {}>;
-export type BulletListItemBlock = BlockSpec<"bulletListItem", {}>;
-export type HeadingBlock = BlockSpec<"heading", {
-    level: "1" | "2" | "3";
-}>;
-export type ParagraphBlock = BlockSpec<"paragraph", {}>;
-export type Block = ParagraphBlock | HeadingBlock | BulletListItemBlock | NumberedListItemBlock;
-export type BlockUpdate = BlockSpecUpdate<Block>;

package/types/src/extensions/Blocks/nodes/Block.d.ts

@@ -1,24 +0,0 @@
-import { Node } from "@tiptap/core";
-import { TextContentType } from "./BlockTypes/TextBlock/TextContent";
-import { HeadingContentType } from "./BlockTypes/HeadingBlock/HeadingContent";
-import { ListItemContentType } from "./BlockTypes/ListItemBlock/ListItemContent";
-export interface IBlock {
-    HTMLAttributes: Record<string, any>;
-}
-export declare type BlockContentType = TextContentType | HeadingContentType | ListItemContentType;
-declare module "@tiptap/core" {
-    interface Commands<ReturnType> {
-        block: {
-            BNCreateBlock: (pos: number) => ReturnType;
-            BNDeleteBlock: (posInBlock: number) => ReturnType;
-            BNMergeBlocks: (posBetweenBlocks: number) => ReturnType;
-            BNSplitBlock: (posInBlock: number, keepType: boolean) => ReturnType;
-            BNSetContentType: (posInBlock: number, type: BlockContentType) => ReturnType;
-            BNCreateBlockOrSetContentType: (posInBlock: number, type: BlockContentType) => ReturnType;
-        };
-    }
-}
-/**
- * The main "Block node" documents consist of
- */
-export declare const Block: Node<IBlock, any>;

package/types/src/extensions/Blocks/nodes/BlockContent/BlockContentTypes.d.ts

@@ -1,4 +0,0 @@
-export declare type Block<Type extends string, Props extends Record<string, string>> = {
-    type: Type;
-    props: Props;
-};

package/types/src/extensions/Blocks/nodes/BlockContent/HeadingBlockContent/HeadingBlockContentTypes.d.ts

@@ -1,4 +0,0 @@
-import { Block } from "../BlockContentTypes";
-export declare type HeadingBlock = Block<"heading", {
-    level: "1" | "2" | "3";
-}>;

package/types/src/extensions/Blocks/nodes/BlockContent/ListItemBlockContent/BulletListItemBlockContent/BulletListItemBlockContentTypes.d.ts

@@ -1,2 +0,0 @@
-import { Block } from "../../BlockContentTypes";
-export declare type BulletListItemBlock = Block<"bulletListItem", {}>;

package/types/src/extensions/Blocks/nodes/BlockContent/ListItemBlockContent/NumberedListItemBlockContent/NumberedListItemBlockContentTypes.d.ts

@@ -1,2 +0,0 @@
-import { Block } from "../../BlockContentTypes";
-export declare type NumberedListItemBlock = Block<"numberedListItem", {}>;

package/types/src/extensions/Blocks/nodes/BlockContent/ParagraphBlockContent/ParagraphBlockContentTypes.d.ts

@@ -1,2 +0,0 @@
-import { Block } from "../BlockContentTypes";
-export declare type ParagraphBlock = Block<"paragraph", {}>;

package/types/src/extensions/Blocks/nodes/BlockTypes/HeadingBlock/HeadingContent.d.ts

@@ -1,8 +0,0 @@
-import { Node } from "@tiptap/core";
-export declare type HeadingContentType = {
-    name: "headingContent";
-    attrs?: {
-        headingLevel: string;
-    };
-};
-export declare const HeadingContent: Node<any, any>;

package/types/src/extensions/Blocks/nodes/BlockTypes/ListItemBlock/ListItemContent.d.ts

@@ -1,8 +0,0 @@
-import { Node } from "@tiptap/core";
-export declare type ListItemContentType = {
-    name: "listItemContent";
-    attrs?: {
-        listItemType: string;
-    };
-};
-export declare const ListItemContent: Node<any, any>;

package/types/src/extensions/Blocks/nodes/BlockTypes/ListItemBlock/OrderedListItemIndexPlugin.d.ts

@@ -1,2 +0,0 @@
-import { Plugin } from "prosemirror-state";
-export declare const OrderedListItemIndexPlugin: () => Plugin<any>;

package/types/src/extensions/Blocks/nodes/BlockTypes/TextBlock/TextContent.d.ts

@@ -1,6 +0,0 @@
-import { Node } from "@tiptap/core";
-export declare type TextContentType = {
-    name: "textContent";
-    attrs?: {};
-};
-export declare const TextContent: Node<any, any>;

package/types/src/extensions/BubbleMenu/BubbleMenuExtension.d.ts

@@ -1,8 +0,0 @@
-import { Extension } from "@tiptap/core";
-import { BubbleMenuFactory } from "./BubbleMenuFactoryTypes";
-/**
- * The menu that is displayed when selecting a piece of text.
- */
-export declare const BubbleMenuExtension: Extension<{
-    bubbleMenuFactory: BubbleMenuFactory;
-}, any>;

package/types/src/extensions/BubbleMenu/BubbleMenuFactoryTypes.d.ts

@@ -1,27 +0,0 @@
-import { EditorElement, ElementFactory } from "../../shared/EditorElement";
-export declare type BubbleMenuParams = {
-    boldIsActive: boolean;
-    toggleBold: () => void;
-    italicIsActive: boolean;
-    toggleItalic: () => void;
-    underlineIsActive: boolean;
-    toggleUnderline: () => void;
-    strikeIsActive: boolean;
-    toggleStrike: () => void;
-    hyperlinkIsActive: boolean;
-    activeHyperlinkUrl: string;
-    activeHyperlinkText: string;
-    setHyperlink: (url: string, text?: string) => void;
-    paragraphIsActive: boolean;
-    setParagraph: () => void;
-    headingIsActive: boolean;
-    activeHeadingLevel: string;
-    setHeading: (level: string) => void;
-    setListItem: (type: string) => void;
-    listItemIsActive: boolean;
-    activeListItemType: string;
-    selectionBoundingBox: DOMRect;
-    editorElement: Element;
-};
-export declare type BubbleMenu = EditorElement<BubbleMenuParams>;
-export declare type BubbleMenuFactory = ElementFactory<BubbleMenuParams>;