@blocknote/core 0.9.6 → 0.10.0

package/types/src/editor/BlockNoteEditor.d.ts

@@ -0,0 +1,299 @@
+import { EditorOptions } from "@tiptap/core";
+import { Node } from "prosemirror-model";
+import { Editor as TiptapEditor } from "@tiptap/core/dist/packages/core/src/Editor";
+import * as Y from "yjs";
+import { DefaultBlockSchema, DefaultInlineContentSchema, DefaultStyleSchema, defaultBlockSpecs, defaultInlineContentSpecs, defaultStyleSpecs } from "../blocks/defaultBlocks";
+import { FormattingToolbarProsemirrorPlugin } from "../extensions/FormattingToolbar/FormattingToolbarPlugin";
+import { HyperlinkToolbarProsemirrorPlugin } from "../extensions/HyperlinkToolbar/HyperlinkToolbarPlugin";
+import { ImageToolbarProsemirrorPlugin } from "../extensions/ImageToolbar/ImageToolbarPlugin";
+import { SideMenuProsemirrorPlugin } from "../extensions/SideMenu/SideMenuPlugin";
+import { BaseSlashMenuItem } from "../extensions/SlashMenu/BaseSlashMenuItem";
+import { SlashMenuProsemirrorPlugin } from "../extensions/SlashMenu/SlashMenuPlugin";
+import { TableHandlesProsemirrorPlugin } from "../extensions/TableHandles/TableHandlesPlugin";
+import { Block, BlockIdentifier, BlockNoteDOMAttributes, BlockSchema, BlockSchemaFromSpecs, BlockSchemaWithBlock, BlockSpecs, InlineContentSchema, InlineContentSchemaFromSpecs, InlineContentSpecs, PartialBlock, StyleSchema, StyleSchemaFromSpecs, StyleSpecs, Styles } from "../schema";
+import { TextCursorPosition } from "./cursorPositionTypes";
+import { Selection } from "./selectionTypes";
+import "prosemirror-tables/style/tables.css";
+import "./Block.css";
+import "./editor.css";
+export type BlockNoteEditorOptions<BSpecs extends BlockSpecs, ISpecs extends InlineContentSpecs, SSpecs extends StyleSpecs> = {
+    enableBlockNoteExtensions: boolean;
+    /**
+     *
+     * (couldn't fix any type, see https://github.com/TypeCellOS/BlockNote/pull/191#discussion_r1210708771)
+     *
+     * @default defaultSlashMenuItems from `./extensions/SlashMenu`
+     */
+    slashMenuItems: BaseSlashMenuItem<any, any, any>[];
+    /**
+     * The HTML element that should be used as the parent element for the editor.
+     *
+     * @default: undefined, the editor is not attached to the DOM
+     */
+    parentElement: HTMLElement;
+    /**
+     * An object containing attributes that should be added to HTML elements of the editor.
+     *
+     * @example { editor: { class: "my-editor-class" } }
+     */
+    domAttributes: Partial<BlockNoteDOMAttributes>;
+    /**
+     *  A callback function that runs when the editor is ready to be used.
+     */
+    onEditorReady: (editor: BlockNoteEditor<BlockSchemaFromSpecs<BSpecs>, InlineContentSchemaFromSpecs<ISpecs>, StyleSchemaFromSpecs<SSpecs>>) => void;
+    /**
+     * A callback function that runs whenever the editor's contents change.
+     */
+    onEditorContentChange: (editor: BlockNoteEditor<BlockSchemaFromSpecs<BSpecs>, InlineContentSchemaFromSpecs<ISpecs>, StyleSchemaFromSpecs<SSpecs>>) => void;
+    /**
+     * A callback function that runs whenever the text cursor position changes.
+     */
+    onTextCursorPositionChange: (editor: BlockNoteEditor<BlockSchemaFromSpecs<BSpecs>, InlineContentSchemaFromSpecs<ISpecs>, StyleSchemaFromSpecs<SSpecs>>) => void;
+    /**
+     * Locks the editor from being editable by the user if set to `false`.
+     */
+    editable: boolean;
+    /**
+     * The content that should be in the editor when it's created, represented as an array of partial block objects.
+     */
+    initialContent: PartialBlock<BlockSchemaFromSpecs<BSpecs>, InlineContentSchemaFromSpecs<ISpecs>, StyleSchemaFromSpecs<SSpecs>>[];
+    /**
+     * Use default BlockNote font and reset the styles of <p> <li> <h1> elements etc., that are used in BlockNote.
+     *
+     * @default true
+     */
+    defaultStyles: boolean;
+    /**
+     * A list of block types that should be available in the editor.
+     */
+    blockSpecs: BSpecs;
+    styleSpecs: SSpecs;
+    inlineContentSpecs: ISpecs;
+    /**
+     * A custom function to handle file uploads.
+     * @param file The file that should be uploaded.
+     * @returns The URL of the uploaded file.
+     */
+    uploadFile: (file: File) => Promise<string>;
+    /**
+     * When enabled, allows for collaboration between multiple users.
+     */
+    collaboration: {
+        /**
+         * The Yjs XML fragment that's used for collaboration.
+         */
+        fragment: Y.XmlFragment;
+        /**
+         * The user info for the current user that's shown to other collaborators.
+         */
+        user: {
+            name: string;
+            color: string;
+        };
+        /**
+         * A Yjs provider (used for awareness / cursor information)
+         */
+        provider: any;
+        /**
+         * Optional function to customize how cursors of users are rendered
+         */
+        renderCursor?: (user: any) => HTMLElement;
+    };
+    _tiptapOptions: Partial<EditorOptions>;
+};
+export declare class BlockNoteEditor<BSchema extends BlockSchema = DefaultBlockSchema, ISchema extends InlineContentSchema = DefaultInlineContentSchema, SSchema extends StyleSchema = DefaultStyleSchema> {
+    private readonly options;
+    readonly _tiptapEditor: TiptapEditor & {
+        contentComponent: any;
+    };
+    blockCache: WeakMap<Node, Block<any, any, any>>;
+    readonly blockSchema: BSchema;
+    readonly inlineContentSchema: ISchema;
+    readonly styleSchema: SSchema;
+    readonly blockImplementations: BlockSpecs;
+    readonly inlineContentImplementations: InlineContentSpecs;
+    readonly styleImplementations: StyleSpecs;
+    ready: boolean;
+    readonly sideMenu: SideMenuProsemirrorPlugin<BSchema, ISchema, SSchema>;
+    readonly formattingToolbar: FormattingToolbarProsemirrorPlugin;
+    readonly slashMenu: SlashMenuProsemirrorPlugin<BSchema, ISchema, SSchema, any>;
+    readonly hyperlinkToolbar: HyperlinkToolbarProsemirrorPlugin<BSchema, ISchema, SSchema>;
+    readonly imageToolbar: ImageToolbarProsemirrorPlugin<BSchema, ISchema, SSchema>;
+    readonly tableHandles: TableHandlesProsemirrorPlugin<BSchema extends BlockSchemaWithBlock<"table", DefaultBlockSchema["table"]> ? BSchema : any, ISchema, SSchema> | undefined;
+    readonly uploadFile: ((file: File) => Promise<string>) | undefined;
+    static create<BSpecs extends BlockSpecs = typeof defaultBlockSpecs, ISpecs extends InlineContentSpecs = typeof defaultInlineContentSpecs, SSpecs extends StyleSpecs = typeof defaultStyleSpecs>(options?: Partial<BlockNoteEditorOptions<BSpecs, ISpecs, SSpecs>>): BlockNoteEditor<BlockSchemaFromSpecs<BSpecs>, InlineContentSchemaFromSpecs<ISpecs>, StyleSchemaFromSpecs<SSpecs>>;
+    private constructor();
+    get prosemirrorView(): import("prosemirror-view").EditorView;
+    get domElement(): HTMLDivElement;
+    isFocused(): boolean;
+    focus(): void;
+    /**
+     * Gets a snapshot of all top-level (non-nested) blocks in the editor.
+     * @returns A snapshot of all top-level (non-nested) blocks in the editor.
+     */
+    get topLevelBlocks(): Block<BSchema, ISchema, SSchema>[];
+    /**
+     * Gets a snapshot of an existing block from the editor.
+     * @param blockIdentifier 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(blockIdentifier: BlockIdentifier): Block<BSchema, ISchema, SSchema> | undefined;
+    /**
+     * Traverses all blocks in the editor depth-first, and executes a callback for each.
+     * @param callback The callback to execute for each block. Returning `false` stops the traversal.
+     * @param reverse Whether the blocks should be traversed in reverse order.
+     */
+    forEachBlock(callback: (block: Block<BSchema, ISchema, SSchema>) => boolean, reverse?: boolean): void;
+    /**
+     * Executes a callback whenever the editor's contents change.
+     * @param callback The callback to execute.
+     */
+    onEditorContentChange(callback: () => void): void;
+    /**
+     * Executes a callback whenever the editor's selection changes.
+     * @param callback The callback to execute.
+     */
+    onEditorSelectionChange(callback: () => void): void;
+    /**
+     * Gets a snapshot of the current text cursor position.
+     * @returns A snapshot of the current text cursor position.
+     */
+    getTextCursorPosition(): TextCursorPosition<BSchema, ISchema, SSchema>;
+    /**
+     * Sets the text cursor position to the start or end of an existing block. Throws an error if the target block could
+     * not be found.
+     * @param targetBlock The identifier of an existing block that the text cursor should be moved to.
+     * @param placement Whether the text cursor should be placed at the start or end of the block.
+     */
+    setTextCursorPosition(targetBlock: BlockIdentifier, placement?: "start" | "end"): void;
+    /**
+     * Gets a snapshot of the current selection.
+     */
+    getSelection(): Selection<BSchema, ISchema, SSchema> | undefined;
+    /**
+     * Checks if the editor is currently editable, or if it's locked.
+     * @returns True if the editor is editable, false otherwise.
+     */
+    get isEditable(): boolean;
+    /**
+     * Makes the editor editable or locks it, depending on the argument passed.
+     * @param editable True to make the editor editable, or false to lock it.
+     */
+    set isEditable(editable: boolean);
+    /**
+     * Inserts new blocks into the editor. If a block's `id` is undefined, BlockNote generates one automatically. Throws an
+     * error if the reference block could not be found.
+     * @param blocksToInsert An array of partial blocks that should be inserted.
+     * @param referenceBlock An identifier for an existing block, at which the new blocks should be inserted.
+     * @param placement Whether the blocks should be inserted just before, just after, or nested inside the
+     * `referenceBlock`. Inserts the blocks at the start of the existing block's children if "nested" is used.
+     */
+    insertBlocks(blocksToInsert: PartialBlock<BSchema, ISchema, SSchema>[], referenceBlock: BlockIdentifier, placement?: "before" | "after" | "nested"): void;
+    /**
+     * Updates an existing block in the editor. Since updatedBlock is a PartialBlock object, some fields might not be
+     * defined. These undefined fields are kept as-is from the existing block. Throws an error if the block to update could
+     * not be found.
+     * @param blockToUpdate The block that should be updated.
+     * @param update A partial block which defines how the existing block should be changed.
+     */
+    updateBlock(blockToUpdate: BlockIdentifier, update: PartialBlock<BSchema, ISchema, SSchema>): void;
+    /**
+     * Removes existing blocks from the editor. Throws an error if any of the blocks could not be found.
+     * @param blocksToRemove An array of identifiers for existing blocks that should be removed.
+     */
+    removeBlocks(blocksToRemove: BlockIdentifier[]): void;
+    /**
+     * Replaces existing blocks in the editor with new blocks. If the blocks that should be removed are not adjacent or
+     * are at different nesting levels, `blocksToInsert` will be inserted at the position of the first block in
+     * `blocksToRemove`. Throws an error if any of the blocks to remove could not be found.
+     * @param blocksToRemove An array of blocks that should be replaced.
+     * @param blocksToInsert An array of partial blocks to replace the old ones with.
+     */
+    replaceBlocks(blocksToRemove: BlockIdentifier[], blocksToInsert: PartialBlock<BSchema, ISchema, SSchema>[]): void;
+    /**
+     * Gets the active text styles at the text cursor position or at the end of the current selection if it's active.
+     */
+    getActiveStyles(): Styles<SSchema>;
+    /**
+     * Adds styles to the currently selected content.
+     * @param styles The styles to add.
+     */
+    addStyles(styles: Styles<SSchema>): void;
+    /**
+     * Removes styles from the currently selected content.
+     * @param styles The styles to remove.
+     */
+    removeStyles(styles: Styles<SSchema>): void;
+    /**
+     * Toggles styles on the currently selected content.
+     * @param styles The styles to toggle.
+     */
+    toggleStyles(styles: Styles<SSchema>): void;
+    /**
+     * Gets the currently selected text.
+     */
+    getSelectedText(): string;
+    /**
+     * Gets the URL of the last link in the current selection, or `undefined` if there are no links in the selection.
+     */
+    getSelectedLinkUrl(): string | undefined;
+    /**
+     * Creates a new link to replace the selected content.
+     * @param url The link URL.
+     * @param text The text to display the link with.
+     */
+    createLink(url: string, text?: string): void;
+    /**
+     * Checks if the block containing the text cursor can be nested.
+     */
+    canNestBlock(): boolean;
+    /**
+     * Nests the block containing the text cursor into the block above it.
+     */
+    nestBlock(): void;
+    /**
+     * Checks if the block containing the text cursor is nested.
+     */
+    canUnnestBlock(): boolean;
+    /**
+     * Lifts the block containing the text cursor out of its parent.
+     */
+    unnestBlock(): void;
+    /**
+     * Serializes blocks into an HTML string. To better conform to HTML standards, children of blocks which aren't list
+     * items are un-nested in the output HTML.
+     * @param blocks An array of blocks that should be serialized into HTML.
+     * @returns The blocks, serialized as an HTML string.
+     */
+    blocksToHTMLLossy(blocks?: Block<BSchema, ISchema, SSchema>[]): Promise<string>;
+    /**
+     * Parses blocks from an HTML string. Tries to create `Block` objects out of any HTML block-level elements, and
+     * `InlineNode` objects from any HTML inline elements, though not all element types are recognized. If BlockNote
+     * doesn't recognize an HTML element's tag, it will parse it as a paragraph or plain text.
+     * @param html The HTML string to parse blocks from.
+     * @returns The blocks parsed from the HTML string.
+     */
+    tryParseHTMLToBlocks(html: string): Promise<Block<BSchema, ISchema, SSchema>[]>;
+    /**
+     * Serializes blocks into a Markdown string. The output is simplified as Markdown does not support all features of
+     * BlockNote - children of blocks which aren't list items are un-nested and certain styles are removed.
+     * @param blocks An array of blocks that should be serialized into Markdown.
+     * @returns The blocks, serialized as a Markdown string.
+     */
+    blocksToMarkdownLossy(blocks?: Block<BSchema, ISchema, SSchema>[]): Promise<string>;
+    /**
+     * Creates a list of blocks from a Markdown string. Tries to create `Block` and `InlineNode` objects based on
+     * Markdown syntax, though not all symbols are recognized. If BlockNote doesn't recognize a symbol, it will parse it
+     * as text.
+     * @param markdown The Markdown string to parse blocks from.
+     * @returns The blocks parsed from the Markdown string.
+     */
+    tryParseMarkdownToBlocks(markdown: string): Promise<Block<BSchema, ISchema, SSchema>[]>;
+    /**
+     * Updates the user info for the current user that's shown to other collaborators.
+     */
+    updateCollaborationUserInfo(user: {
+        name: string;
+        color: string;
+    }): void;
+}

package/types/src/editor/BlockNoteEditor.test.d.ts

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

package/types/src/editor/BlockNoteExtensions.d.ts

@@ -0,0 +1,24 @@
+import { Extensions } from "@tiptap/core";
+import type { BlockNoteEditor } from "./BlockNoteEditor";
+import * as Y from "yjs";
+import { BlockNoteDOMAttributes, BlockSpecs, InlineContentSchema, InlineContentSpecs, StyleSchema, StyleSpecs } from "../schema";
+/**
+ * Get all the Tiptap extensions BlockNote is configured with by default
+ */
+export declare const getBlockNoteExtensions: <BSchema extends Record<string, import("../schema").BlockConfig>, I extends InlineContentSchema, S extends StyleSchema>(opts: {
+    editor: BlockNoteEditor<BSchema, I, S>;
+    domAttributes: Partial<BlockNoteDOMAttributes>;
+    blockSchema: BSchema;
+    blockSpecs: BlockSpecs;
+    inlineContentSpecs: InlineContentSpecs;
+    styleSpecs: StyleSpecs;
+    collaboration?: {
+        fragment: Y.XmlFragment;
+        user: {
+            name: string;
+            color: string;
+        };
+        provider: any;
+        renderCursor?: ((user: any) => HTMLElement) | undefined;
+    } | undefined;
+}) => Extensions;

package/types/src/editor/cursorPositionTypes.d.ts

@@ -0,0 +1,6 @@
+import { Block, BlockSchema, InlineContentSchema, StyleSchema } from "../schema";
+export type TextCursorPosition<BSchema extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema> = {
+    block: Block<BSchema, I, S>;
+    prevBlock: Block<BSchema, I, S> | undefined;
+    nextBlock: Block<BSchema, I, S> | undefined;
+};

package/types/src/editor/selectionTypes.d.ts

@@ -0,0 +1,4 @@
+import { Block, BlockSchema, InlineContentSchema, StyleSchema } from "../schema";
+export type Selection<BSchema extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema> = {
+    blocks: Block<BSchema, I, S>[];
+};

package/types/src/editor/transformPasted.d.ts

@@ -0,0 +1,12 @@
+import { Slice } from "@tiptap/pm/model";
+import { EditorView } from "@tiptap/pm/view";
+/**
+ * fix for https://github.com/ProseMirror/prosemirror/issues/1430#issuecomment-1822570821
+ *
+ * Without this fix, pasting two paragraphs would cause the second one to be indented in the other
+ * this fix wraps every element in the slice in it's own blockContainer, to prevent Prosemirror from nesting the
+ * elements on paste.
+ *
+ * The exception is when we encounter blockGroups with listitems, because those actually should be nested
+ */
+export declare function transformPasted(slice: Slice, view: EditorView): Slice;

package/types/src/extensions/BackgroundColor/BackgroundColorExtension.d.ts

@@ -1,9 +1,2 @@
 import { Extension } from "@tiptap/core";
-declare module "@tiptap/core" {
-    interface Commands<ReturnType> {
-        blockBackgroundColor: {
-            setBlockBackgroundColor: (posInBlock: number, color: string) => ReturnType;
-        };
-    }
-}
 export declare const BackgroundColorExtension: Extension<any, any>;

package/types/src/extensions/BackgroundColor/BackgroundColorMark.d.ts

@@ -1,9 +1,7 @@
-import { Mark } from "@tiptap/core";
-declare module "@tiptap/core" {
-    interface Commands<ReturnType> {
-        backgroundColor: {
-            setBackgroundColor: (color: string) => ReturnType;
-        };
-    }
-}
-export declare const BackgroundColorMark: Mark<any, any>;
+export declare const BackgroundColor: {
+    config: {
+        type: string;
+        propSchema: "string";
+    };
+    implementation: import("../../schema").StyleImplementation;
+};

package/types/src/extensions/Blocks/api/blocks/createSpec.d.ts

@@ -0,0 +1,35 @@
+import { ParseRule } from "@tiptap/pm/model";
+import { BlockNoteEditor } from "../../../../BlockNoteEditor";
+import { InlineContentSchema } from "../inlineContent/types";
+import { StyleSchema } from "../styles/types";
+import { BlockConfig, BlockFromConfig, BlockSchemaWithBlock, PartialBlockFromConfig } from "./types";
+export type CustomBlockConfig = BlockConfig & {
+    content: "inline" | "none";
+};
+export type CustomBlockImplementation<T extends CustomBlockConfig, I extends InlineContentSchema, S extends StyleSchema> = {
+    render: (
+    /**
+     * The custom block to render
+     */
+    block: BlockFromConfig<T, I, S>, 
+    /**
+     * The BlockNote editor instance
+     * This is typed generically. If you want an editor with your custom schema, you need to
+     * cast it manually, e.g.: `const e = editor as BlockNoteEditor<typeof mySchema>;`
+     */
+    editor: BlockNoteEditor<BlockSchemaWithBlock<T["type"], T>, I, S>) => {
+        dom: HTMLElement;
+        contentDOM?: HTMLElement;
+        destroy?: () => void;
+    };
+    toExternalHTML?: (block: BlockFromConfig<T, I, S>, editor: BlockNoteEditor<BlockSchemaWithBlock<T["type"], T>, I, S>) => {
+        dom: HTMLElement;
+        contentDOM?: HTMLElement;
+    };
+    parse?: (el: HTMLElement) => PartialBlockFromConfig<T, I, S>["props"] | undefined;
+};
+export declare function getParseRules(config: BlockConfig, customParseFunction: CustomBlockImplementation<any, any, any>["parse"]): ParseRule[];
+export declare function createBlockSpec<T extends CustomBlockConfig, I extends InlineContentSchema, S extends StyleSchema>(blockConfig: T, blockImplementation: CustomBlockImplementation<T, I, S>): {
+    config: T;
+    implementation: import("./types").TiptapBlockImplementation<T, any, InlineContentSchema, StyleSchema>;
+};

package/types/src/extensions/Blocks/api/blocks/internal.d.ts

@@ -0,0 +1,45 @@
+import { Attributes, Editor, Extension, Node, NodeConfig } from "@tiptap/core";
+import { BlockNoteEditor } from "../../../../BlockNoteEditor";
+import { InlineContentSchema } from "../inlineContent/types";
+import { StyleSchema } from "../styles/types";
+import { BlockConfig, BlockSchemaFromSpecs, BlockSchemaWithBlock, BlockSpecs, Props, PropSchema, SpecificBlock, TiptapBlockImplementation } from "./types";
+export declare function camelToDataKebab(str: string): string;
+export declare function propsToAttributes(propSchema: PropSchema): Attributes;
+export declare function getBlockFromPos<BType extends string, Config extends BlockConfig, BSchema extends BlockSchemaWithBlock<BType, Config>, I extends InlineContentSchema, S extends StyleSchema>(getPos: (() => number) | boolean, editor: BlockNoteEditor<BSchema, I, S>, tipTapEditor: Editor, type: BType): SpecificBlock<BSchema, BType, I, S>;
+export declare function wrapInBlockStructure<BType extends string, PSchema extends PropSchema>(element: {
+    dom: HTMLElement;
+    contentDOM?: HTMLElement;
+    destroy?: () => void;
+}, blockType: BType, blockProps: Props<PSchema>, propSchema: PSchema, domAttributes?: Record<string, string>): {
+    dom: HTMLElement;
+    contentDOM?: HTMLElement;
+    destroy?: () => void;
+};
+type StronglyTypedTipTapNode<Name extends string, Content extends "inline*" | "tableRow+" | ""> = Node & {
+    name: Name;
+    config: {
+        content: Content;
+    };
+};
+export declare function createStronglyTypedTiptapNode<Name extends string, Content extends "inline*" | "tableRow+" | "">(config: NodeConfig & {
+    name: Name;
+    content: Content;
+}): StronglyTypedTipTapNode<Name, Content>;
+export declare function createInternalBlockSpec<T extends BlockConfig>(config: T, implementation: TiptapBlockImplementation<T, any, InlineContentSchema, StyleSchema>): {
+    config: T;
+    implementation: TiptapBlockImplementation<T, any, InlineContentSchema, StyleSchema>;
+};
+export declare function createBlockSpecFromStronglyTypedTiptapNode<T extends Node, P extends PropSchema>(node: T, propSchema: P, requiredExtensions?: Array<Extension | Node>): {
+    config: {
+        type: T["name"];
+        content: T["config"]["content"] extends "inline*" ? "inline" : T["config"]["content"] extends "tableRow+" ? "table" : "none";
+        propSchema: P;
+    };
+    implementation: TiptapBlockImplementation<{
+        type: T["name"];
+        content: T["config"]["content"] extends "inline*" ? "inline" : T["config"]["content"] extends "tableRow+" ? "table" : "none";
+        propSchema: P;
+    }, any, InlineContentSchema, StyleSchema>;
+};
+export declare function getBlockSchemaFromSpecs<T extends BlockSpecs>(specs: T): BlockSchemaFromSpecs<T>;
+export {};

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

@@ -0,0 +1,114 @@
+/** Define the main block types **/
+import { Extension, Node } from "@tiptap/core";
+import { BlockNoteEditor } from "../../../../BlockNoteEditor";
+import { InlineContent, InlineContentSchema, PartialInlineContent } from "../inlineContent/types";
+import { StyleSchema } from "../styles/types";
+export type BlockNoteDOMElement = "editor" | "blockContainer" | "blockGroup" | "blockContent" | "inlineContent";
+export type BlockNoteDOMAttributes = Partial<{
+    [DOMElement in BlockNoteDOMElement]: Record<string, string>;
+}>;
+export type PropSpec<PType extends boolean | number | string> = {
+    values?: readonly PType[];
+    default: PType;
+};
+export type PropSchema = Record<string, PropSpec<boolean | number | string>>;
+export type Props<PSchema extends PropSchema> = {
+    [PName in keyof PSchema]: PSchema[PName]["default"] extends boolean ? PSchema[PName]["values"] extends readonly boolean[] ? PSchema[PName]["values"][number] : boolean : PSchema[PName]["default"] extends number ? PSchema[PName]["values"] extends readonly number[] ? PSchema[PName]["values"][number] : number : PSchema[PName]["default"] extends string ? PSchema[PName]["values"] extends readonly string[] ? PSchema[PName]["values"][number] : string : never;
+};
+export type BlockConfig = {
+    type: string;
+    readonly propSchema: PropSchema;
+    content: "inline" | "none" | "table";
+};
+export type TiptapBlockImplementation<T extends BlockConfig, B extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema> = {
+    requiredExtensions?: Array<Extension | Node>;
+    node: Node;
+    toInternalHTML: (block: BlockFromConfigNoChildren<T, I, S> & {
+        children: Block<B, I, S>[];
+    }, editor: BlockNoteEditor<B, I, S>) => {
+        dom: HTMLElement;
+        contentDOM?: HTMLElement;
+    };
+    toExternalHTML: (block: BlockFromConfigNoChildren<T, I, S> & {
+        children: Block<B, I, S>[];
+    }, editor: BlockNoteEditor<B, I, S>) => {
+        dom: HTMLElement;
+        contentDOM?: HTMLElement;
+    };
+};
+export type BlockSpec<T extends BlockConfig, B extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema> = {
+    config: T;
+    implementation: TiptapBlockImplementation<T, B, I, S>;
+};
+type NamesMatch<Blocks extends Record<string, BlockConfig>> = Blocks extends {
+    [Type in keyof Blocks]: Type extends string ? Blocks[Type] extends {
+        type: Type;
+    } ? Blocks[Type] : never : never;
+} ? Blocks : never;
+export type BlockSchema = NamesMatch<Record<string, BlockConfig>>;
+export type BlockSpecs = Record<string, BlockSpec<any, any, InlineContentSchema, StyleSchema>>;
+export type BlockImplementations = Record<string, TiptapBlockImplementation<any, any, any, any>>;
+export type BlockSchemaFromSpecs<T extends BlockSpecs> = {
+    [K in keyof T]: T[K]["config"];
+};
+export type BlockSchemaWithBlock<BType extends string, C extends BlockConfig> = {
+    [k in BType]: C;
+};
+export type TableContent<I extends InlineContentSchema, S extends StyleSchema = StyleSchema> = {
+    type: "tableContent";
+    rows: {
+        cells: InlineContent<I, S>[][];
+    }[];
+};
+export type BlockFromConfigNoChildren<B extends BlockConfig, I extends InlineContentSchema, S extends StyleSchema> = {
+    id: string;
+    type: B["type"];
+    props: Props<B["propSchema"]>;
+    content: B["content"] extends "inline" ? InlineContent<I, S>[] : B["content"] extends "table" ? TableContent<I, S> : B["content"] extends "none" ? undefined : never;
+};
+export type BlockFromConfig<B extends BlockConfig, I extends InlineContentSchema, S extends StyleSchema> = BlockFromConfigNoChildren<B, I, S> & {
+    children: Block<BlockSchema, I, S>[];
+};
+type BlocksWithoutChildren<BSchema extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema> = {
+    [BType in keyof BSchema]: BlockFromConfigNoChildren<BSchema[BType], I, S>;
+};
+export type Block<BSchema extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema> = BlocksWithoutChildren<BSchema, I, S>[keyof BSchema] & {
+    children: Block<BSchema, I, S>[];
+};
+export type SpecificBlock<BSchema extends BlockSchema, BType extends keyof BSchema, I extends InlineContentSchema, S extends StyleSchema> = BlocksWithoutChildren<BSchema, I, S>[BType] & {
+    children: Block<BSchema, I, S>[];
+};
+/** CODE FOR PARTIAL BLOCKS, analogous to above
+ *
+ * Partial blocks are convenience-wrappers to make it easier to
+ *create/update blocks in the editor.
+ *
+ */
+export type PartialTableContent<I extends InlineContentSchema, S extends StyleSchema = StyleSchema> = {
+    type: "tableContent";
+    rows: {
+        cells: PartialInlineContent<I, S>[];
+    }[];
+};
+type PartialBlockFromConfigNoChildren<B extends BlockConfig, I extends InlineContentSchema, S extends StyleSchema> = {
+    id?: string;
+    type?: B["type"];
+    props?: Partial<Props<B["propSchema"]>>;
+    content?: B["content"] extends "inline" ? PartialInlineContent<I, S> : B["content"] extends "table" ? PartialTableContent<I, S> : undefined;
+};
+type PartialBlocksWithoutChildren<BSchema extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema> = {
+    [BType in keyof BSchema]: PartialBlockFromConfigNoChildren<BSchema[BType], I, S>;
+};
+export type PartialBlock<BSchema extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema> = PartialBlocksWithoutChildren<BSchema, I, S>[keyof PartialBlocksWithoutChildren<BSchema, I, S>] & Partial<{
+    children: PartialBlock<BSchema, I, S>[];
+}>;
+export type SpecificPartialBlock<BSchema extends BlockSchema, I extends InlineContentSchema, BType extends keyof BSchema, S extends StyleSchema> = PartialBlocksWithoutChildren<BSchema, I, S>[BType] & {
+    children?: Block<BSchema, I, S>[];
+};
+export type PartialBlockFromConfig<B extends BlockConfig, I extends InlineContentSchema, S extends StyleSchema> = PartialBlockFromConfigNoChildren<B, I, S> & {
+    children?: Block<BlockSchema, I, S>[];
+};
+export type BlockIdentifier = {
+    id: string;
+} | string;
+export {};

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

@@ -1,6 +1,8 @@
-import { Block, BlockSchema } from "./blockTypes";
-export type TextCursorPosition<BSchema extends BlockSchema> = {
-    block: Block<BSchema>;
-    prevBlock: Block<BSchema> | undefined;
-    nextBlock: Block<BSchema> | undefined;
+import { Block, BlockSchema } from "./blocks/types";
+import { InlineContentSchema } from "./inlineContent/types";
+import { StyleSchema } from "./styles/types";
+export type TextCursorPosition<BSchema extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema> = {
+    block: Block<BSchema, I, S>;
+    prevBlock: Block<BSchema, I, S> | undefined;
+    nextBlock: Block<BSchema, I, S> | undefined;
 };