@blocknote/core 0.5.1 → 0.6.2

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

@@ -2,30 +2,30 @@ import { Editor } from "@tiptap/core";
 import { Plugin } from "prosemirror-state";
 import { BlockSideMenu, BlockSideMenuDynamicParams, BlockSideMenuFactory, BlockSideMenuStaticParams } from "./BlockSideMenuFactoryTypes";
 import { DraggableBlocksOptions } from "./DraggableBlocksExtension";
-export declare function createRect(rect: DOMRect): {
-    left: number;
-    top: number;
-    width: number;
-    height: number;
-    bottom: number;
-    right: number;
-};
+import { BlockNoteEditor } from "../../BlockNoteEditor";
 export type BlockMenuViewProps = {
-    editor: Editor;
+    tiptapEditor: Editor;
+    editor: BlockNoteEditor;
     blockMenuFactory: BlockSideMenuFactory;
     horizontalPosAnchoredAtRoot: boolean;
 };
 export declare class BlockMenuView {
-    editor: Editor;
+    editor: BlockNoteEditor;
+    private ttEditor;
     horizontalPosAnchoredAtRoot: boolean;
     horizontalPosAnchor: number;
     blockMenu: BlockSideMenu;
-    hoveredBlockContent: HTMLElement | undefined;
+    hoveredBlock: HTMLElement | undefined;
+    isDragging: boolean;
     menuOpen: boolean;
     menuFrozen: boolean;
-    constructor({ editor, blockMenuFactory, horizontalPosAnchoredAtRoot, }: BlockMenuViewProps);
+    constructor({ tiptapEditor, editor, blockMenuFactory, horizontalPosAnchoredAtRoot, }: BlockMenuViewProps);
     /**
-     * If the event is outside of the editor contents,
+     * Sets isDragging when dragging text.
+     */
+    onDragStart: () => void;
+    /**
+     * If the event is outside 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
      */
@@ -39,11 +39,9 @@ export declare class BlockMenuView {
     onKeyDown: (_event: KeyboardEvent) => void;
     onMouseDown: (event: MouseEvent) => void;
     onMouseMove: (event: MouseEvent) => void;
+    onScroll: () => void;
     destroy(): void;
     addBlock(): void;
-    deleteBlock(): void;
-    setBlockBackgroundColor(color: string): void;
-    setBlockTextColor(color: string): void;
     getStaticParams(): BlockSideMenuStaticParams;
     getDynamicParams(): BlockSideMenuDynamicParams;
 }

package/types/src/extensions/FormattingToolbar/FormattingToolbarExtension.d.ts

@@ -1,8 +1,10 @@
 import { Extension } from "@tiptap/core";
+import { BlockNoteEditor } from "../..";
 import { FormattingToolbarFactory } from "./FormattingToolbarFactoryTypes";
 /**
  * The menu that is displayed when selecting a piece of text.
  */
 export declare const FormattingToolbarExtension: Extension<{
     formattingToolbarFactory: FormattingToolbarFactory;
+    editor: BlockNoteEditor;
 }, any>;

package/types/src/extensions/FormattingToolbar/FormattingToolbarFactoryTypes.d.ts

@@ -1,32 +1,9 @@
 import { EditorElement, ElementFactory } from "../../shared/EditorElement";
-import { Block, PartialBlock } from "../Blocks/api/blockTypes";
+import { BlockNoteEditor } from "../../BlockNoteEditor";
 export type FormattingToolbarStaticParams = {
-    toggleBold: () => void;
-    toggleItalic: () => void;
-    toggleUnderline: () => void;
-    toggleStrike: () => void;
-    setHyperlink: (url: string, text?: string) => void;
-    setTextColor: (color: string) => void;
-    setBackgroundColor: (color: string) => void;
-    setTextAlignment: (textAlignment: "left" | "center" | "right" | "justify") => void;
-    increaseBlockIndent: () => void;
-    decreaseBlockIndent: () => void;
-    updateBlock: (updatedBlock: PartialBlock) => void;
+    editor: BlockNoteEditor;
 };
 export type FormattingToolbarDynamicParams = {
-    boldIsActive: boolean;
-    italicIsActive: boolean;
-    underlineIsActive: boolean;
-    strikeIsActive: boolean;
-    hyperlinkIsActive: boolean;
-    activeHyperlinkUrl: string;
-    activeHyperlinkText: string;
-    textColor: string;
-    backgroundColor: string;
-    textAlignment: "left" | "center" | "right" | "justify";
-    canIncreaseBlockIndent: boolean;
-    canDecreaseBlockIndent: boolean;
-    block: Block;
     referenceRect: DOMRect;
 };
 export type FormattingToolbar = EditorElement<FormattingToolbarDynamicParams>;

package/types/src/extensions/FormattingToolbar/FormattingToolbarPlugin.d.ts

@@ -1,13 +1,15 @@
 import { Editor } from "@tiptap/core";
 import { EditorState, Plugin, PluginKey } from "prosemirror-state";
 import { EditorView } from "prosemirror-view";
+import { BlockNoteEditor } from "../..";
 import { FormattingToolbar, FormattingToolbarDynamicParams, FormattingToolbarFactory, FormattingToolbarStaticParams } from "./FormattingToolbarFactoryTypes";
 export interface FormattingToolbarPluginProps {
     pluginKey: PluginKey;
-    editor: Editor;
+    tiptapEditor: Editor;
+    editor: BlockNoteEditor;
     formattingToolbarFactory: FormattingToolbarFactory;
     shouldShow?: ((props: {
-        editor: Editor;
+        editor: BlockNoteEditor;
         view: EditorView;
         state: EditorState;
         oldState?: EditorState;
@@ -19,14 +21,16 @@ export type FormattingToolbarViewProps = FormattingToolbarPluginProps & {
     view: EditorView;
 };
 export declare class FormattingToolbarView {
-    editor: Editor;
+    editor: BlockNoteEditor;
+    private ttEditor;
     view: EditorView;
     formattingToolbar: FormattingToolbar;
     preventHide: boolean;
     preventShow: boolean;
     toolbarIsOpen: boolean;
+    prevWasEditable: boolean | null;
     shouldShow: Exclude<FormattingToolbarPluginProps["shouldShow"], null>;
-    constructor({ editor, formattingToolbarFactory, view, shouldShow, }: FormattingToolbarViewProps);
+    constructor({ editor, tiptapEditor, formattingToolbarFactory, view, shouldShow, }: FormattingToolbarViewProps);
     viewMousedownHandler: () => void;
     viewMouseupHandler: () => void;
     dragstartHandler: () => void;
@@ -34,6 +38,7 @@ export declare class FormattingToolbarView {
     blurHandler: ({ event }: {
         event: FocusEvent;
     }) => void;
+    scrollHandler: () => void;
     update(view: EditorView, oldState?: EditorState): void;
     destroy(): void;
     getSelectionBoundingBox(): DOMRect;

package/types/src/index.d.ts

@@ -9,3 +9,4 @@ 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 "./extensions/Blocks/api/inlineContentTypes";

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

@@ -1,93 +0,0 @@
-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/extensions/SlashMenu/SlashMenuItem.d.ts

@@ -1,24 +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 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.
-     *
-     * @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: Editor, range: Range) => void, aliases: string[], group: string, hint?: string | undefined, shortcut?: string | undefined);
-    match(query: string): boolean;
-}

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

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