@blocknote/core 0.9.5 → 0.10.0

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

@@ -1,9 +1,9 @@
 import { Node } from "@tiptap/core";
 export declare const BlockGroup: Node<{
     domAttributes?: Partial<{
+        editor: Record<string, string>;
         blockContainer: Record<string, string>;
         blockGroup: Record<string, string>;
-        editor: Record<string, string>;
         blockContent: Record<string, string>;
         inlineContent: Record<string, string>;
     }> | undefined;

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

@@ -1,10 +1,12 @@
 import { EditorState, Plugin, PluginKey } from "prosemirror-state";
 import { EditorView } from "prosemirror-view";
-import { BaseUiElementCallbacks, BaseUiElementState, BlockNoteEditor, BlockSchema } from "../..";
-import { EventEmitter } from "../../shared/EventEmitter";
+import type { BlockNoteEditor } from "../../editor/BlockNoteEditor";
+import { BaseUiElementCallbacks, BaseUiElementState } from "../../extensions-shared/BaseUiElementTypes";
+import { BlockSchema, InlineContentSchema, StyleSchema } from "../../schema";
+import { EventEmitter } from "../../util/EventEmitter";
 export type FormattingToolbarCallbacks = BaseUiElementCallbacks;
 export type FormattingToolbarState = BaseUiElementState;
-export declare class FormattingToolbarView<BSchema extends BlockSchema> {
+export declare class FormattingToolbarView {
     private readonly editor;
     private readonly pmView;
     private formattingToolbarState?;
@@ -18,7 +20,7 @@ export declare class FormattingToolbarView<BSchema extends BlockSchema> {
         from: number;
         to: number;
     }) => boolean;
-    constructor(editor: BlockNoteEditor<BSchema>, pmView: EditorView, updateFormattingToolbar: (formattingToolbarState: FormattingToolbarState) => void);
+    constructor(editor: BlockNoteEditor<BlockSchema, InlineContentSchema, StyleSchema>, pmView: EditorView, updateFormattingToolbar: (formattingToolbarState: FormattingToolbarState) => void);
     viewMousedownHandler: () => void;
     viewMouseupHandler: () => void;
     dragstartHandler: () => void;
@@ -30,9 +32,9 @@ export declare class FormattingToolbarView<BSchema extends BlockSchema> {
     getSelectionBoundingBox(): DOMRect;
 }
 export declare const formattingToolbarPluginKey: PluginKey<any>;
-export declare class FormattingToolbarProsemirrorPlugin<BSchema extends BlockSchema> extends EventEmitter<any> {
+export declare class FormattingToolbarProsemirrorPlugin extends EventEmitter<any> {
     private view;
     readonly plugin: Plugin;
-    constructor(editor: BlockNoteEditor<BSchema>);
+    constructor(editor: BlockNoteEditor<any, any, any>);
     onUpdate(callback: (state: FormattingToolbarState) => void): () => void;
 }

package/types/src/extensions/HyperlinkToolbar/HyperlinkToolbarPlugin.d.ts

@@ -1,17 +1,17 @@
 import { Plugin, PluginKey } from "prosemirror-state";
-import { BlockNoteEditor } from "../../BlockNoteEditor";
-import { BaseUiElementState } from "../../shared/BaseUiElementTypes";
-import { EventEmitter } from "../../shared/EventEmitter";
-import { BlockSchema } from "../Blocks/api/blockTypes";
+import type { BlockNoteEditor } from "../../editor/BlockNoteEditor";
+import { BaseUiElementState } from "../../extensions-shared/BaseUiElementTypes";
+import { BlockSchema, InlineContentSchema, StyleSchema } from "../../schema";
+import { EventEmitter } from "../../util/EventEmitter";
 export type HyperlinkToolbarState = BaseUiElementState & {
     url: string;
     text: string;
 };
 export declare const hyperlinkToolbarPluginKey: PluginKey<any>;
-export declare class HyperlinkToolbarProsemirrorPlugin<BSchema extends BlockSchema> extends EventEmitter<any> {
+export declare class HyperlinkToolbarProsemirrorPlugin<BSchema extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema> extends EventEmitter<any> {
     private view;
     readonly plugin: Plugin;
-    constructor(editor: BlockNoteEditor<BSchema>);
+    constructor(editor: BlockNoteEditor<BSchema, I, S>);
     onUpdate(callback: (state: HyperlinkToolbarState) => void): () => void;
     /**
      * Edit the currently hovered hyperlink.

package/types/src/extensions/ImageToolbar/ImageToolbarPlugin.d.ts

@@ -1,25 +1,20 @@
 import { EditorState, Plugin, PluginKey } from "prosemirror-state";
 import { EditorView } from "prosemirror-view";
-import { BaseUiElementCallbacks, BaseUiElementState, BlockNoteEditor, BlockSchema, BlockSpec, SpecificBlock } from "../..";
-import { EventEmitter } from "../../shared/EventEmitter";
+import { EventEmitter } from "../../util/EventEmitter";
+import type { BlockNoteEditor } from "../../editor/BlockNoteEditor";
+import { BlockSchema, InlineContentSchema, SpecificBlock, StyleSchema } from "../../schema";
+import { BaseUiElementCallbacks, BaseUiElementState } from "../../extensions-shared/BaseUiElementTypes";
 export type ImageToolbarCallbacks = BaseUiElementCallbacks;
-export type ImageToolbarState = BaseUiElementState & {
-    block: SpecificBlock<BlockSchema & {
-        image: BlockSpec<"image", {
-            src: {
-                default: string;
-            };
-        }, false>;
-    }, "image">;
+export type ImageToolbarState<B extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema = StyleSchema> = BaseUiElementState & {
+    block: SpecificBlock<B, "image", I, S>;
 };
-export declare class ImageToolbarView {
+export declare class ImageToolbarView<BSchema extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema> {
     private readonly pluginKey;
     private readonly pmView;
     private imageToolbarState?;
     updateImageToolbar: () => void;
     prevWasEditable: boolean | null;
-    shouldShow: (state: EditorState) => boolean;
-    constructor(pluginKey: PluginKey, pmView: EditorView, updateImageToolbar: (imageToolbarState: ImageToolbarState) => void);
+    constructor(pluginKey: PluginKey, pmView: EditorView, updateImageToolbar: (imageToolbarState: ImageToolbarState<BSchema, I, S>) => void);
     mouseDownHandler: () => void;
     dragstartHandler: () => void;
     blurHandler: (event: FocusEvent) => void;
@@ -28,9 +23,9 @@ export declare class ImageToolbarView {
     destroy(): void;
 }
 export declare const imageToolbarPluginKey: PluginKey<any>;
-export declare class ImageToolbarProsemirrorPlugin<BSchema extends BlockSchema> extends EventEmitter<any> {
+export declare class ImageToolbarProsemirrorPlugin<BSchema extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema> extends EventEmitter<any> {
     private view;
     readonly plugin: Plugin;
-    constructor(_editor: BlockNoteEditor<BSchema>);
-    onUpdate(callback: (state: ImageToolbarState) => void): () => void;
+    constructor(_editor: BlockNoteEditor<BSchema, I, S>);
+    onUpdate(callback: (state: ImageToolbarState<BSchema, I, S>) => void): () => void;
 }

package/types/src/extensions/NonEditableBlocks/NonEditableBlockPlugin.d.ts

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

package/types/src/extensions/PreviousBlockType/PreviousBlockTypePlugin.d.ts

@@ -0,0 +1,14 @@
+import { Plugin } from "prosemirror-state";
+/**
+ * This plugin tracks transformation of Block node attributes, so we can support CSS transitions.
+ *
+ * Problem it solves: ProseMirror recreates the DOM when transactions happen. So when a transaction changes a Node attribute,
+ * it results in a completely new DOM element. This means CSS transitions don't work.
+ *
+ * Solution: When attributes change on a node, this plugin sets a data-* attribute with the "previous" value. This way we can still use CSS transitions. (See block.module.css)
+ */
+export declare const PreviousBlockTypePlugin: () => Plugin<{
+    prevTransactionOldBlockAttrs: any;
+    currentTransactionOldBlockAttrs: any;
+    updatedBlocks: Set<string>;
+}>;

package/types/src/extensions/SideMenu/SideMenuPlugin.d.ts

@@ -1,14 +1,21 @@
 import { PluginView } from "@tiptap/pm/state";
 import { Plugin, PluginKey } from "prosemirror-state";
 import { EditorView } from "prosemirror-view";
-import { BlockNoteEditor } from "../../BlockNoteEditor";
-import { BaseUiElementState } from "../../shared/BaseUiElementTypes";
-import { EventEmitter } from "../../shared/EventEmitter";
-import { Block, BlockSchema } from "../Blocks/api/blockTypes";
-export type SideMenuState<BSchema extends BlockSchema> = BaseUiElementState & {
-    block: Block<BSchema>;
+import type { BlockNoteEditor } from "../../editor/BlockNoteEditor";
+import { BaseUiElementState } from "../../extensions-shared/BaseUiElementTypes";
+import { Block, BlockSchema, InlineContentSchema, StyleSchema } from "../../schema";
+import { EventEmitter } from "../../util/EventEmitter";
+export type SideMenuState<BSchema extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema> = BaseUiElementState & {
+    block: Block<BSchema, I, S>;
 };
-export declare class SideMenuView<BSchema extends BlockSchema> implements PluginView {
+export declare function getDraggableBlockFromCoords(coords: {
+    left: number;
+    top: number;
+}, view: EditorView): {
+    node: HTMLElement;
+    id: string;
+} | undefined;
+export declare class SideMenuView<BSchema extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema> implements PluginView {
     private readonly editor;
     private readonly pmView;
     private readonly updateSideMenu;
@@ -18,7 +25,7 @@ export declare class SideMenuView<BSchema extends BlockSchema> implements Plugin
     private hoveredBlock;
     isDragging: boolean;
     menuFrozen: boolean;
-    constructor(editor: BlockNoteEditor<BSchema>, pmView: EditorView, updateSideMenu: (sideMenuState: SideMenuState<BSchema>) => void);
+    constructor(editor: BlockNoteEditor<BSchema, I, S>, pmView: EditorView, updateSideMenu: (sideMenuState: SideMenuState<BSchema, I, S>) => void);
     /**
      * Sets isDragging when dragging text.
      */
@@ -36,18 +43,19 @@ export declare class SideMenuView<BSchema extends BlockSchema> implements Plugin
      */
     onDragOver: (event: DragEvent) => void;
     onKeyDown: (_event: KeyboardEvent) => void;
+    onMouseDown: (_event: MouseEvent) => void;
     onMouseMove: (event: MouseEvent) => void;
     onScroll: () => void;
     destroy(): void;
     addBlock(): void;
 }
 export declare const sideMenuPluginKey: PluginKey<any>;
-export declare class SideMenuProsemirrorPlugin<BSchema extends BlockSchema> extends EventEmitter<any> {
+export declare class SideMenuProsemirrorPlugin<BSchema extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema> extends EventEmitter<any> {
     private readonly editor;
     private sideMenuView;
     readonly plugin: Plugin;
-    constructor(editor: BlockNoteEditor<BSchema>);
-    onUpdate(callback: (state: SideMenuState<BSchema>) => void): () => void;
+    constructor(editor: BlockNoteEditor<BSchema, I, S>);
+    onUpdate(callback: (state: SideMenuState<BSchema, I, S>) => void): () => void;
     /**
      * If the block is empty, opens the slash menu. If the block has content,
      * creates a new block below and opens the slash menu in it.

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

@@ -1,8 +1,7 @@
-import { SuggestionItem } from "../../shared/plugins/suggestion/SuggestionItem";
-import { BlockNoteEditor } from "../../BlockNoteEditor";
-import { BlockSchema } from "../Blocks/api/blockTypes";
-import { DefaultBlockSchema } from "../Blocks/api/defaultBlocks";
-export type BaseSlashMenuItem<BSchema extends BlockSchema = DefaultBlockSchema> = SuggestionItem & {
-    execute: (editor: BlockNoteEditor<BSchema>) => void;
+import type { BlockNoteEditor } from "../../editor/BlockNoteEditor";
+import { SuggestionItem } from "../../extensions-shared/suggestion/SuggestionItem";
+import { BlockSchema, InlineContentSchema, StyleSchema } from "../../schema";
+export type BaseSlashMenuItem<BSchema extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema> = SuggestionItem & {
+    execute: (editor: BlockNoteEditor<BSchema, I, S>) => void;
     aliases?: string[];
 };

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

@@ -1,13 +1,13 @@
 import { Plugin, PluginKey } from "prosemirror-state";
-import { BlockNoteEditor } from "../../BlockNoteEditor";
-import { EventEmitter } from "../../shared/EventEmitter";
-import { SuggestionsMenuState } from "../../shared/plugins/suggestion/SuggestionPlugin";
-import { BlockSchema } from "../Blocks/api/blockTypes";
+import type { BlockNoteEditor } from "../../editor/BlockNoteEditor";
+import { SuggestionsMenuState } from "../../extensions-shared/suggestion/SuggestionPlugin";
+import { BlockSchema, InlineContentSchema, StyleSchema } from "../../schema";
+import { EventEmitter } from "../../util/EventEmitter";
 import { BaseSlashMenuItem } from "./BaseSlashMenuItem";
 export declare const slashMenuPluginKey: PluginKey<any>;
-export declare class SlashMenuProsemirrorPlugin<BSchema extends BlockSchema, SlashMenuItem extends BaseSlashMenuItem<BSchema>> extends EventEmitter<any> {
+export declare class SlashMenuProsemirrorPlugin<BSchema extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema, SlashMenuItem extends BaseSlashMenuItem<BSchema, I, S>> extends EventEmitter<any> {
     readonly plugin: Plugin;
     readonly itemCallback: (item: SlashMenuItem) => void;
-    constructor(editor: BlockNoteEditor<BSchema>, items: SlashMenuItem[]);
+    constructor(editor: BlockNoteEditor<BSchema, I, S>, items: SlashMenuItem[]);
     onUpdate(callback: (state: SuggestionsMenuState<SlashMenuItem>) => void): () => void;
 }

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

@@ -1,2 +1,3 @@
+import { InlineContentSchema, StyleSchema } from "../../schema";
 import { BaseSlashMenuItem } from "./BaseSlashMenuItem";
-export declare const getDefaultSlashMenuItems: <BSchema extends Record<string, import("../Blocks/api/blockTypes").BlockSpec<string, import("../Blocks/api/blockTypes").PropSchema, boolean>>>(schema?: BSchema) => BaseSlashMenuItem<BSchema>[];
+export declare const getDefaultSlashMenuItems: <BSchema extends Record<string, import("../../schema").BlockConfig>, I extends InlineContentSchema, S extends StyleSchema>(schema?: BSchema) => BaseSlashMenuItem<BSchema, I, S>[];

package/types/src/extensions/TableHandles/TableHandlesPlugin.d.ts

@@ -0,0 +1,74 @@
+import { Plugin, PluginKey, PluginView } from "prosemirror-state";
+import { EditorView } from "prosemirror-view";
+import { EventEmitter } from "../../util/EventEmitter";
+import { DefaultBlockSchema } from "../../blocks/defaultBlocks";
+import type { BlockNoteEditor } from "../../editor/BlockNoteEditor";
+import { BlockFromConfigNoChildren, BlockSchemaWithBlock, InlineContentSchema, StyleSchema } from "../../schema";
+export type TableHandlesState<I extends InlineContentSchema, S extends StyleSchema> = {
+    show: boolean;
+    referencePosCell: DOMRect;
+    referencePosTable: DOMRect;
+    block: BlockFromConfigNoChildren<DefaultBlockSchema["table"], I, S>;
+    colIndex: number;
+    rowIndex: number;
+    draggingState: {
+        draggedCellOrientation: "row" | "col";
+        originalIndex: number;
+        mousePos: number;
+    } | undefined;
+};
+export declare class TableHandlesView<BSchema extends BlockSchemaWithBlock<"table", DefaultBlockSchema["table"]>, I extends InlineContentSchema, S extends StyleSchema> implements PluginView {
+    private readonly editor;
+    private readonly pmView;
+    state?: TableHandlesState<I, S>;
+    updateState: () => void;
+    tableId: string | undefined;
+    tablePos: number | undefined;
+    menuFrozen: boolean;
+    prevWasEditable: boolean | null;
+    constructor(editor: BlockNoteEditor<BSchema, I, S>, pmView: EditorView, updateState: (state: TableHandlesState<I, S>) => void);
+    mouseMoveHandler: (event: MouseEvent) => false | undefined;
+    dragOverHandler: (event: DragEvent) => void;
+    dropHandler: (event: DragEvent) => void;
+    scrollHandler: () => void;
+    destroy(): void;
+}
+export declare const tableHandlesPluginKey: PluginKey<any>;
+export declare class TableHandlesProsemirrorPlugin<BSchema extends BlockSchemaWithBlock<"table", DefaultBlockSchema["table"]>, I extends InlineContentSchema, S extends StyleSchema> extends EventEmitter<any> {
+    private readonly editor;
+    private view;
+    readonly plugin: Plugin;
+    constructor(editor: BlockNoteEditor<BSchema, I, S>);
+    onUpdate(callback: (state: TableHandlesState<I, S>) => void): () => void;
+    /**
+     * Callback that should be set on the `dragStart` event for whichever element
+     * is used as the column drag handle.
+     */
+    colDragStart: (event: {
+        dataTransfer: DataTransfer | null;
+        clientX: number;
+    }) => void;
+    /**
+     * Callback that should be set on the `dragStart` event for whichever element
+     * is used as the row drag handle.
+     */
+    rowDragStart: (event: {
+        dataTransfer: DataTransfer | null;
+        clientY: number;
+    }) => void;
+    /**
+     * Callback that should be set on the `dragEnd` event for both the element
+     * used as the row drag handle, and the one used as the column drag handle.
+     */
+    dragEnd: () => void;
+    /**
+     * Freezes the drag handles. When frozen, they will stay attached to the same
+     * cell regardless of which cell is hovered by the mouse cursor.
+     */
+    freezeHandles: () => boolean;
+    /**
+     * Unfreezes the drag handles. When frozen, they will stay attached to the
+     * same cell regardless of which cell is hovered by the mouse cursor.
+     */
+    unfreezeHandles: () => boolean;
+}

package/types/src/extensions/TextAlignment/TextAlignmentExtension.d.ts

@@ -1,9 +1,2 @@
 import { Extension } from "@tiptap/core";
-declare module "@tiptap/core" {
-    interface Commands<ReturnType> {
-        textAlignment: {
-            setTextAlignment: (textAlignment: "left" | "center" | "right" | "justify") => ReturnType;
-        };
-    }
-}
 export declare const TextAlignmentExtension: Extension<any, any>;

package/types/src/extensions/TextColor/TextColorExtension.d.ts

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

package/types/src/extensions/TextColor/TextColorMark.d.ts

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

package/types/src/extensions/UniqueID/UniqueID.d.ts

@@ -1,3 +1,3 @@
 import { Extension } from "@tiptap/core";
 declare const UniqueID: Extension<any, any>;
-export { UniqueID, UniqueID as default };
+export { UniqueID as default, UniqueID };

package/types/src/extensions-shared/BaseUiElementTypes.d.ts

@@ -0,0 +1,7 @@
+export type BaseUiElementCallbacks = {
+    destroy: () => void;
+};
+export type BaseUiElementState = {
+    show: boolean;
+    referencePos: DOMRect;
+};

package/types/src/extensions-shared/suggestion/SuggestionItem.d.ts

@@ -0,0 +1,3 @@
+export type SuggestionItem = {
+    name: string;
+};

package/types/src/extensions-shared/suggestion/SuggestionPlugin.d.ts

@@ -0,0 +1,36 @@
+import { Plugin, PluginKey } from "prosemirror-state";
+import type { BlockNoteEditor } from "../../editor/BlockNoteEditor";
+import { InlineContentSchema, StyleSchema } from "../../schema";
+import { BaseUiElementState } from "../BaseUiElementTypes";
+import { SuggestionItem } from "./SuggestionItem";
+export type SuggestionsMenuState<T extends SuggestionItem> = BaseUiElementState & {
+    filteredItems: T[];
+    keyboardHoveredItemIndex: number;
+};
+type SuggestionPluginState<T extends SuggestionItem> = {
+    active: boolean;
+    triggerCharacter: string | undefined;
+    queryStartPos: number | undefined;
+    items: T[];
+    keyboardHoveredItemIndex: number | undefined;
+    notFoundCount: number | undefined;
+    decorationId: string | undefined;
+};
+/**
+ * A ProseMirror plugin for suggestions, designed to make '/'-commands possible as well as mentions.
+ *
+ * This is basically a simplified version of TipTap's [Suggestions](https://github.com/ueberdosis/tiptap/tree/db92a9b313c5993b723c85cd30256f1d4a0b65e1/packages/suggestion) plugin.
+ *
+ * This version is adapted from the aforementioned version in the following ways:
+ * - This version supports generic items instead of only strings (to allow for more advanced filtering for example)
+ * - This version hides some unnecessary complexity from the user of the plugin.
+ * - This version handles key events differently
+ */
+export declare const setupSuggestionsMenu: <T extends SuggestionItem, BSchema extends Record<string, import("../../schema").BlockConfig>, I extends InlineContentSchema, S extends StyleSchema>(editor: BlockNoteEditor<BSchema, I, S>, updateSuggestionsMenu: (suggestionsMenuState: SuggestionsMenuState<T>) => void, pluginKey: PluginKey, defaultTriggerCharacter: string, items?: (query: string) => T[], onSelectItem?: (props: {
+    item: T;
+    editor: BlockNoteEditor<BSchema, I, S>;
+}) => void) => {
+    plugin: Plugin<SuggestionPluginState<T>>;
+    itemCallback: (item: T) => void;
+};
+export {};

package/types/src/index.d.ts

@@ -1,14 +1,15 @@
-export * from "./BlockNoteEditor";
-export * from "./BlockNoteExtensions";
-export * from "./extensions/Blocks/api/block";
-export * from "./extensions/Blocks/api/blockTypes";
-export * from "./extensions/Blocks/api/defaultProps";
-export * from "./extensions/Blocks/api/defaultBlocks";
-export * from "./extensions/Blocks/api/inlineContentTypes";
-export * from "./extensions/Blocks/api/selectionTypes";
-export * from "./extensions/Blocks/api/serialization";
-export * as blockStyles from "./extensions/Blocks/nodes/Block.module.css";
-export * from "./extensions/Blocks/nodes/BlockContent/ImageBlockContent/uploadToTmpFilesDotOrg_DEV_ONLY";
+export * from "./api/exporters/html/externalHTMLExporter";
+export * from "./api/exporters/html/internalHTMLSerializer";
+export * from "./api/testUtil";
+export * from "./blocks/ImageBlockContent/uploadToTmpFilesDotOrg_DEV_ONLY";
+export * from "./blocks/defaultBlocks";
+export * from "./blocks/defaultProps";
+export * from "./editor/BlockNoteEditor";
+export * from "./editor/BlockNoteExtensions";
+export * from "./editor/selectionTypes";
+export * from "./extensions-shared/BaseUiElementTypes";
+export type { SuggestionItem } from "./extensions-shared/suggestion/SuggestionItem";
+export * from "./extensions-shared/suggestion/SuggestionPlugin";
 export * from "./extensions/FormattingToolbar/FormattingToolbarPlugin";
 export * from "./extensions/HyperlinkToolbar/HyperlinkToolbarPlugin";
 export * from "./extensions/ImageToolbar/ImageToolbarPlugin";
@@ -16,7 +17,11 @@ export * from "./extensions/SideMenu/SideMenuPlugin";
 export * from "./extensions/SlashMenu/BaseSlashMenuItem";
 export * from "./extensions/SlashMenu/SlashMenuPlugin";
 export { getDefaultSlashMenuItems } from "./extensions/SlashMenu/defaultSlashMenuItems";
-export * from "./shared/BaseUiElementTypes";
-export type { SuggestionItem } from "./shared/plugins/suggestion/SuggestionItem";
-export * from "./shared/plugins/suggestion/SuggestionPlugin";
-export * from "./shared/utils";
+export * from "./extensions/TableHandles/TableHandlesPlugin";
+export * from "./schema";
+export * from "./util/browser";
+export * from "./util/string";
+export * from "./api/nodeConversions/nodeConversions";
+export * from "./api/testUtil/partialBlockTestUtil";
+export * from "./extensions/UniqueID/UniqueID";
+export { UnreachableCaseError } from "./util/typescript";

package/types/src/pm-nodes/BlockContainer.d.ts

@@ -0,0 +1,28 @@
+import { Node } from "@tiptap/core";
+import type { BlockNoteEditor } from "../editor/BlockNoteEditor";
+import { BlockSchema, InlineContentSchema, PartialBlock, StyleSchema } from "../schema";
+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;
+            BNUpdateBlock: <BSchema extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema>(posInBlock: number, block: PartialBlock<BSchema, I, S>) => ReturnType;
+            BNCreateOrUpdateBlock: <BSchema extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema>(posInBlock: number, block: PartialBlock<BSchema, I, S>) => ReturnType;
+        };
+    }
+}
+/**
+ * The main "Block node" documents consist of
+ */
+export declare const BlockContainer: Node<{
+    domAttributes?: Partial<{
+        blockContainer: Record<string, string>;
+        blockGroup: Record<string, string>;
+        editor: Record<string, string>;
+        blockContent: Record<string, string>;
+        inlineContent: Record<string, string>;
+    }> | undefined;
+    editor: BlockNoteEditor<BlockSchema, InlineContentSchema, StyleSchema>;
+}, any>;

package/types/src/pm-nodes/BlockGroup.d.ts

@@ -0,0 +1,10 @@
+import { Node } from "@tiptap/core";
+export declare const BlockGroup: Node<{
+    domAttributes?: Partial<{
+        blockContainer: Record<string, string>;
+        blockGroup: Record<string, string>;
+        editor: Record<string, string>;
+        blockContent: Record<string, string>;
+        inlineContent: Record<string, string>;
+    }> | undefined;
+}, any>;

package/types/src/pm-nodes/Doc.d.ts

@@ -0,0 +1,2 @@
+import { Node } from "@tiptap/core";
+export declare const Doc: Node<any, any>;

package/types/src/pm-nodes/index.d.ts

@@ -0,0 +1,3 @@
+export { BlockContainer } from "./BlockContainer";
+export { BlockGroup } from "./BlockGroup";
+export { Doc } from "./Doc";

package/types/src/schema/blocks/createSpec.d.ts

@@ -0,0 +1,35 @@
+import { ParseRule } from "@tiptap/pm/model";
+import type { BlockNoteEditor } from "../../editor/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/schema/blocks/internal.d.ts

@@ -0,0 +1,45 @@
+import { Attributes, Editor, Extension, Node, NodeConfig } from "@tiptap/core";
+import type { BlockNoteEditor } from "../../editor/BlockNoteEditor";
+import { InlineContentSchema } from "../inlineContent/types";
+import { PropSchema, Props } from "../propTypes";
+import { StyleSchema } from "../styles/types";
+import { BlockConfig, BlockSchemaFromSpecs, BlockSchemaWithBlock, BlockSpecs, SpecificBlock, TiptapBlockImplementation } from "./types";
+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 {};