@blocknote/core 0.9.6 → 0.10.0

package/src/schema/styles/createSpec.ts

@@ -0,0 +1,85 @@
+import { Mark } from "@tiptap/core";
+import { ParseRule } from "@tiptap/pm/model";
+import {
+  addStyleAttributes,
+  createInternalStyleSpec,
+  stylePropsToAttributes,
+} from "./internal";
+import { StyleConfig, StyleSpec } from "./types";
+import {UnreachableCaseError} from "../../util/typescript";
+
+export type CustomStyleImplementation<T extends StyleConfig> = {
+  render: T["propSchema"] extends "boolean"
+    ? () => {
+        dom: HTMLElement;
+        contentDOM?: HTMLElement;
+      }
+    : (value: string) => {
+        dom: HTMLElement;
+        contentDOM?: HTMLElement;
+      };
+};
+
+// TODO: support serialization
+
+export function getStyleParseRules(config: StyleConfig): ParseRule[] {
+  return [
+    {
+      tag: `[data-style-type="${config.type}"]`,
+      contentElement: (element) => {
+        const htmlElement = element as HTMLElement;
+
+        if (htmlElement.matches("[data-editable]")) {
+          return htmlElement;
+        }
+
+        return htmlElement.querySelector("[data-editable]") || htmlElement;
+      },
+    },
+  ];
+}
+
+export function createStyleSpec<T extends StyleConfig>(
+  styleConfig: T,
+  styleImplementation: CustomStyleImplementation<T>
+): StyleSpec<T> {
+  const mark = Mark.create({
+    name: styleConfig.type,
+
+    addAttributes() {
+      return stylePropsToAttributes(styleConfig.propSchema);
+    },
+
+    parseHTML() {
+      return getStyleParseRules(styleConfig);
+    },
+
+    renderHTML({ mark }) {
+      let renderResult: {
+        dom: HTMLElement;
+        contentDOM?: HTMLElement;
+      };
+
+      if (styleConfig.propSchema === "boolean") {
+        // @ts-ignore not sure why this is complaining
+        renderResult = styleImplementation.render();
+      } else if (styleConfig.propSchema === "string") {
+        renderResult = styleImplementation.render(mark.attrs.stringValue);
+      } else {
+        throw new UnreachableCaseError(styleConfig.propSchema);
+      }
+
+      // const renderResult = styleImplementation.render();
+      return addStyleAttributes(
+        renderResult,
+        styleConfig.type,
+        mark.attrs.stringValue,
+        styleConfig.propSchema
+      );
+    },
+  });
+
+  return createInternalStyleSpec(styleConfig, {
+    mark,
+  });
+}

package/src/schema/styles/internal.ts

@@ -0,0 +1,96 @@
+import { Attributes, Mark } from "@tiptap/core";
+import {
+  StyleConfig,
+  StyleImplementation,
+  StylePropSchema,
+  StyleSchemaFromSpecs,
+  StyleSpec,
+  StyleSpecs,
+} from "./types";
+
+export function stylePropsToAttributes(
+  propSchema: StylePropSchema
+): Attributes {
+  if (propSchema === "boolean") {
+    return {};
+  }
+  return {
+    stringValue: {
+      default: undefined,
+      keepOnSplit: true,
+      parseHTML: (element) => element.getAttribute("data-value"),
+      renderHTML: (attributes) =>
+        attributes.stringValue !== undefined
+          ? {
+              "data-value": attributes.stringValue,
+            }
+          : {},
+    },
+  };
+}
+
+// Function that adds necessary classes and attributes to the `dom` element
+// returned from a custom style's 'render' function, to ensure no data is lost
+// on internal copy & paste.
+export function addStyleAttributes<
+  SType extends string,
+  PSchema extends StylePropSchema
+>(
+  element: {
+    dom: HTMLElement;
+    contentDOM?: HTMLElement;
+  },
+  styleType: SType,
+  styleValue: PSchema extends "boolean" ? undefined : string,
+  propSchema: PSchema
+): {
+  dom: HTMLElement;
+  contentDOM?: HTMLElement;
+} {
+  // Sets content type attribute
+  element.dom.setAttribute("data-style-type", styleType);
+  // Adds style value as an HTML attribute in kebab-case with "data-" prefix, if
+  // the style takes a string value.
+  if (propSchema === "string") {
+    element.dom.setAttribute("data-value", styleValue as string);
+  }
+
+  if (element.contentDOM !== undefined) {
+    element.contentDOM.setAttribute("data-editable", "");
+  }
+
+  return element;
+}
+
+// This helper function helps to instantiate a stylespec with a
+// config and implementation that conform to the type of Config
+export function createInternalStyleSpec<T extends StyleConfig>(
+  config: T,
+  implementation: StyleImplementation
+) {
+  return {
+    config,
+    implementation,
+  } satisfies StyleSpec<T>;
+}
+
+export function createStyleSpecFromTipTapMark<
+  T extends Mark,
+  P extends StylePropSchema
+>(mark: T, propSchema: P) {
+  return createInternalStyleSpec(
+    {
+      type: mark.name as T["name"],
+      propSchema,
+    },
+    {
+      mark,
+    }
+  );
+}
+
+export function getStyleSchemaFromSpecs<T extends StyleSpecs>(specs: T) {
+  return Object.fromEntries(
+    Object.entries(specs).map(([key, value]) => [key, value.config])
+  ) as StyleSchemaFromSpecs<T>;
+}

package/src/schema/styles/types.ts

@@ -0,0 +1,42 @@
+import { Mark } from "@tiptap/core";
+
+export type StylePropSchema = "boolean" | "string"; // TODO: use PropSchema as name? Use objects as type similar to blocks?
+
+// StyleConfig contains the "schema" info about a Style type
+// i.e. what props it supports, what content it supports, etc.
+export type StyleConfig = {
+  type: string;
+  readonly propSchema: StylePropSchema;
+  // content: "inline" | "none" | "table";
+};
+
+// StyleImplementation contains the "implementation" info about a Style element.
+// Currently, the implementation is always a TipTap Mark
+export type StyleImplementation = {
+  mark: Mark;
+};
+
+// Container for both the config and implementation of a Style,
+// and the type of `implementation` is based on that of the config
+export type StyleSpec<T extends StyleConfig> = {
+  config: T;
+  implementation: StyleImplementation;
+};
+
+// A Schema contains all the types (Configs) supported in an editor
+// The keys are the "type" of Styles supported
+export type StyleSchema = Record<string, StyleConfig>;
+
+export type StyleSpecs = Record<string, StyleSpec<StyleConfig>>;
+
+export type StyleSchemaFromSpecs<T extends StyleSpecs> = {
+  [K in keyof T]: T[K]["config"];
+};
+
+export type Styles<T extends StyleSchema> = {
+  [K in keyof T]?: T[K]["propSchema"] extends "boolean"
+    ? boolean
+    : T[K]["propSchema"] extends "string"
+    ? string
+    : never;
+};

package/src/util/README.md

@@ -0,0 +1,3 @@
+### @blocknote/core/src/@util
+
+Contains generic utility files with helper functions / classes.

package/src/{shared/utils.ts → util/browser.ts}

@@ -1,7 +1,8 @@
 export const isAppleOS = () =>
-  /Mac/.test(navigator.platform) ||
-  (/AppleWebKit/.test(navigator.userAgent) &&
-    /Mobile\/\w+/.test(navigator.userAgent));
+    typeof navigator !== "undefined" &&
+    (/Mac/.test(navigator.platform) ||
+        (/AppleWebKit/.test(navigator.userAgent) &&
+            /Mobile\/\w+/.test(navigator.userAgent)));
 
 export function formatKeyboardShortcut(shortcut: string) {
   if (isAppleOS()) {
@@ -15,8 +16,3 @@ export function mergeCSSClasses(...classes: string[]) {
   return classes.filter((c) => c).join(" ");
 }
 
-export class UnreachableCaseError extends Error {
-  constructor(val: never) {
-    super(`Unreachable case: ${val}`);
-  }
-}

package/src/util/string.ts

@@ -0,0 +1,3 @@
+export function camelToDataKebab(str: string): string {
+  return "data-" + str.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+}

package/src/util/typescript.ts

@@ -0,0 +1,5 @@
+export class UnreachableCaseError extends Error {
+    constructor(val: never) {
+        super(`Unreachable case: ${val}`);
+    }
+}

package/types/src/BlockNoteEditor.d.ts

@@ -2,18 +2,22 @@ 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 { Block, BlockIdentifier, BlockNoteDOMAttributes, BlockSchema, PartialBlock } from "./extensions/Blocks/api/blockTypes";
-import { TextCursorPosition } from "./extensions/Blocks/api/cursorPositionTypes";
-import { DefaultBlockSchema } from "./extensions/Blocks/api/defaultBlocks";
-import { Styles } from "./extensions/Blocks/api/inlineContentTypes";
+import { Block, BlockIdentifier, BlockNoteDOMAttributes, BlockSchema, BlockSchemaFromSpecs, BlockSchemaWithBlock, BlockSpecs, PartialBlock } from "./extensions/Blocks/api/blocks/types";
+import { DefaultBlockSchema, DefaultInlineContentSchema, DefaultStyleSchema, defaultBlockSpecs, defaultInlineContentSpecs, defaultStyleSpecs } from "./extensions/Blocks/api/defaultBlocks";
 import { Selection } from "./extensions/Blocks/api/selectionTypes";
+import { StyleSchema, StyleSchemaFromSpecs, StyleSpecs, Styles } from "./extensions/Blocks/api/styles/types";
+import "prosemirror-tables/style/tables.css";
+import "./editor.css";
+import { TextCursorPosition } from "./extensions/Blocks/api/cursorPositionTypes";
+import { InlineContentSchema, InlineContentSchemaFromSpecs, InlineContentSpecs } from "./extensions/Blocks/api/inlineContent/types";
 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";
-export type BlockNoteEditorOptions<BSchema extends BlockSchema> = {
+import { TableHandlesProsemirrorPlugin } from "./extensions/TableHandles/TableHandlesPlugin";
+export type BlockNoteEditorOptions<BSpecs extends BlockSpecs, ISpecs extends InlineContentSpecs, SSpecs extends StyleSpecs> = {
     enableBlockNoteExtensions: boolean;
     /**
      *
@@ -21,7 +25,7 @@ export type BlockNoteEditorOptions<BSchema extends BlockSchema> = {
      *
      * @default defaultSlashMenuItems from `./extensions/SlashMenu`
      */
-    slashMenuItems: BaseSlashMenuItem<any>[];
+    slashMenuItems: BaseSlashMenuItem<BlockSchemaFromSpecs<BSpecs>, InlineContentSchemaFromSpecs<ISpecs>, StyleSchemaFromSpecs<SSpecs>>[];
     /**
      * The HTML element that should be used as the parent element for the editor.
      *
@@ -37,15 +41,15 @@ export type BlockNoteEditorOptions<BSchema extends BlockSchema> = {
     /**
      *  A callback function that runs when the editor is ready to be used.
      */
-    onEditorReady: (editor: BlockNoteEditor<BSchema>) => void;
+    onEditorReady: (editor: BlockNoteEditor<BlockSchemaFromSpecs<BSpecs>, InlineContentSchemaFromSpecs<ISpecs>, StyleSchemaFromSpecs<SSpecs>>) => void;
     /**
      * A callback function that runs whenever the editor's contents change.
      */
-    onEditorContentChange: (editor: BlockNoteEditor<BSchema>) => void;
+    onEditorContentChange: (editor: BlockNoteEditor<BlockSchemaFromSpecs<BSpecs>, InlineContentSchemaFromSpecs<ISpecs>, StyleSchemaFromSpecs<SSpecs>>) => void;
     /**
      * A callback function that runs whenever the text cursor position changes.
      */
-    onTextCursorPositionChange: (editor: BlockNoteEditor<BSchema>) => void;
+    onTextCursorPositionChange: (editor: BlockNoteEditor<BlockSchemaFromSpecs<BSpecs>, InlineContentSchemaFromSpecs<ISpecs>, StyleSchemaFromSpecs<SSpecs>>) => void;
     /**
      * Locks the editor from being editable by the user if set to `false`.
      */
@@ -53,7 +57,7 @@ export type BlockNoteEditorOptions<BSchema extends BlockSchema> = {
     /**
      * The content that should be in the editor when it's created, represented as an array of partial block objects.
      */
-    initialContent: PartialBlock<BSchema>[];
+    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.
      *
@@ -63,7 +67,9 @@ export type BlockNoteEditorOptions<BSchema extends BlockSchema> = {
     /**
      * A list of block types that should be available in the editor.
      */
-    blockSchema: BSchema;
+    blockSpecs: BSpecs;
+    styleSpecs: SSpecs;
+    inlineContentSpecs: ISpecs;
     /**
      * A custom function to handle file uploads.
      * @param file The file that should be uploaded.
@@ -96,21 +102,28 @@ export type BlockNoteEditorOptions<BSchema extends BlockSchema> = {
     };
     _tiptapOptions: Partial<EditorOptions>;
 };
-export declare class BlockNoteEditor<BSchema extends BlockSchema = DefaultBlockSchema> {
+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<BSchema>>;
-    readonly schema: BSchema;
+    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>;
-    readonly formattingToolbar: FormattingToolbarProsemirrorPlugin<BSchema>;
-    readonly slashMenu: SlashMenuProsemirrorPlugin<BSchema, any>;
-    readonly hyperlinkToolbar: HyperlinkToolbarProsemirrorPlugin<BSchema>;
-    readonly imageToolbar: ImageToolbarProsemirrorPlugin<BSchema>;
+    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;
-    constructor(options?: Partial<BlockNoteEditorOptions<BSchema>>);
+    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;
@@ -119,19 +132,19 @@ export declare class BlockNoteEditor<BSchema extends BlockSchema = DefaultBlockS
      * 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>[];
+    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> | undefined;
+    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>) => boolean, reverse?: boolean): void;
+    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.
@@ -146,7 +159,7 @@ export declare class BlockNoteEditor<BSchema extends BlockSchema = DefaultBlockS
      * Gets a snapshot of the current text cursor position.
      * @returns A snapshot of the current text cursor position.
      */
-    getTextCursorPosition(): TextCursorPosition<BSchema>;
+    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.
@@ -157,7 +170,7 @@ export declare class BlockNoteEditor<BSchema extends BlockSchema = DefaultBlockS
     /**
      * Gets a snapshot of the current selection.
      */
-    getSelection(): Selection<BSchema> | undefined;
+    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.
@@ -176,7 +189,7 @@ export declare class BlockNoteEditor<BSchema extends BlockSchema = DefaultBlockS
      * @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>[], referenceBlock: BlockIdentifier, placement?: "before" | "after" | "nested"): void;
+    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
@@ -184,7 +197,7 @@ export declare class BlockNoteEditor<BSchema extends BlockSchema = DefaultBlockS
      * @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>): void;
+    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.
@@ -197,26 +210,26 @@ export declare class BlockNoteEditor<BSchema extends BlockSchema = DefaultBlockS
      * @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>[]): void;
+    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;
+    getActiveStyles(): Styles<SSchema>;
     /**
      * Adds styles to the currently selected content.
      * @param styles The styles to add.
      */
-    addStyles(styles: Styles): void;
+    addStyles(styles: Styles<SSchema>): void;
     /**
      * Removes styles from the currently selected content.
      * @param styles The styles to remove.
      */
-    removeStyles(styles: Styles): void;
+    removeStyles(styles: Styles<SSchema>): void;
     /**
      * Toggles styles on the currently selected content.
      * @param styles The styles to toggle.
      */
-    toggleStyles(styles: Styles): void;
+    toggleStyles(styles: Styles<SSchema>): void;
     /**
      * Gets the currently selected text.
      */
@@ -253,7 +266,7 @@ export declare class BlockNoteEditor<BSchema extends BlockSchema = DefaultBlockS
      * @param blocks An array of blocks that should be serialized into HTML.
      * @returns The blocks, serialized as an HTML string.
      */
-    blocksToHTML(blocks: Block<BSchema>[]): Promise<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
@@ -261,14 +274,14 @@ export declare class BlockNoteEditor<BSchema extends BlockSchema = DefaultBlockS
      * @param html The HTML string to parse blocks from.
      * @returns The blocks parsed from the HTML string.
      */
-    HTMLToBlocks(html: string): Promise<Block<BSchema>[]>;
+    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.
      */
-    blocksToMarkdown(blocks: Block<BSchema>[]): Promise<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
@@ -276,7 +289,7 @@ export declare class BlockNoteEditor<BSchema extends BlockSchema = DefaultBlockS
      * @param markdown The Markdown string to parse blocks from.
      * @returns The blocks parsed from the Markdown string.
      */
-    markdownToBlocks(markdown: string): Promise<Block<BSchema>[]>;
+    tryParseMarkdownToBlocks(markdown: string): Promise<Block<BSchema, ISchema, SSchema>[]>;
     /**
      * Updates the user info for the current user that's shown to other collaborators.
      */

package/types/src/BlockNoteExtensions.d.ts

@@ -1,14 +1,19 @@
 import { Extensions } from "@tiptap/core";
 import { BlockNoteEditor } from "./BlockNoteEditor";
 import * as Y from "yjs";
-import { BlockNoteDOMAttributes } from "./extensions/Blocks/api/blockTypes";
+import { BlockNoteDOMAttributes, BlockSpecs } from "./extensions/Blocks/api/blocks/types";
+import { InlineContentSchema, InlineContentSpecs } from "./extensions/Blocks/api/inlineContent/types";
+import { StyleSchema, StyleSpecs } from "./extensions/Blocks/api/styles/types";
 /**
  * Get all the Tiptap extensions BlockNote is configured with by default
  */
-export declare const getBlockNoteExtensions: <BSchema extends Record<string, import("./extensions/Blocks/api/blockTypes").BlockSpec<string, import("./extensions/Blocks/api/blockTypes").PropSchema, boolean>>>(opts: {
-    editor: BlockNoteEditor<BSchema>;
+export declare const getBlockNoteExtensions: <BSchema extends Record<string, import("./extensions/Blocks/api/blocks/types").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: {

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

@@ -1,6 +1,7 @@
 import { Editor } from "@tiptap/core";
-import { BlockIdentifier, BlockSchema, PartialBlock } from "../../extensions/Blocks/api/blockTypes";
-export declare function insertBlocks<BSchema extends BlockSchema>(blocksToInsert: PartialBlock<BSchema>[], referenceBlock: BlockIdentifier, placement: "before" | "after" | "nested" | undefined, editor: Editor): void;
-export declare function updateBlock<BSchema extends BlockSchema>(blockToUpdate: BlockIdentifier, update: PartialBlock<BSchema>, editor: Editor): void;
+import type { BlockNoteEditor } from "../../editor/BlockNoteEditor";
+import { BlockIdentifier, BlockSchema, InlineContentSchema, PartialBlock, StyleSchema } from "../../schema";
+export declare function insertBlocks<BSchema extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema>(blocksToInsert: PartialBlock<BSchema, I, S>[], referenceBlock: BlockIdentifier, placement: "before" | "after" | "nested" | undefined, editor: BlockNoteEditor<BSchema, I, S>): void;
+export declare function updateBlock<BSchema extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema>(blockToUpdate: BlockIdentifier, update: PartialBlock<BSchema, I, S>, editor: Editor): void;
 export declare function removeBlocks(blocksToRemove: BlockIdentifier[], editor: Editor): void;
-export declare function replaceBlocks<BSchema extends BlockSchema>(blocksToRemove: BlockIdentifier[], blocksToInsert: PartialBlock<BSchema>[], editor: Editor): void;
+export declare function replaceBlocks<BSchema extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema>(blocksToRemove: BlockIdentifier[], blocksToInsert: PartialBlock<BSchema, I, S>[], editor: BlockNoteEditor<BSchema, I, S>): void;

package/types/src/api/exporters/copyExtension.d.ts

@@ -0,0 +1,6 @@
+import { Extension } from "@tiptap/core";
+import type { BlockNoteEditor } from "../../editor/BlockNoteEditor";
+import { InlineContentSchema, StyleSchema } from "../../schema";
+export declare const createCopyToClipboardExtension: <BSchema extends Record<string, import("../../schema").BlockConfig>, I extends InlineContentSchema, S extends StyleSchema>(editor: BlockNoteEditor<BSchema, I, S>) => Extension<{
+    editor: BlockNoteEditor<BSchema, I, S>;
+}, undefined>;

package/types/src/api/exporters/html/externalHTMLExporter.d.ts

@@ -0,0 +1,8 @@
+import { Fragment, Schema } from "prosemirror-model";
+import type { BlockNoteEditor } from "../../../editor/BlockNoteEditor";
+import { BlockSchema, InlineContentSchema, PartialBlock, StyleSchema } from "../../../schema";
+export interface ExternalHTMLExporter<BSchema extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema> {
+    exportBlocks: (blocks: PartialBlock<BSchema, I, S>[]) => string;
+    exportProseMirrorFragment: (fragment: Fragment) => string;
+}
+export declare const createExternalHTMLExporter: <BSchema extends Record<string, import("../../../schema").BlockConfig>, I extends InlineContentSchema, S extends StyleSchema>(schema: Schema, editor: BlockNoteEditor<BSchema, I, S>) => ExternalHTMLExporter<BSchema, I, S>;

package/types/src/api/exporters/html/internalHTMLSerializer.d.ts

@@ -0,0 +1,8 @@
+import { Fragment, Schema } from "prosemirror-model";
+import type { BlockNoteEditor } from "../../../editor/BlockNoteEditor";
+import { BlockSchema, InlineContentSchema, PartialBlock, StyleSchema } from "../../../schema";
+export interface InternalHTMLSerializer<BSchema extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema> {
+    serializeProseMirrorFragment: (fragment: Fragment) => string;
+    serializeBlocks: (blocks: PartialBlock<BSchema, I, S>[]) => string;
+}
+export declare const createInternalHTMLSerializer: <BSchema extends Record<string, import("../../../schema").BlockConfig>, I extends InlineContentSchema, S extends StyleSchema>(schema: Schema, editor: BlockNoteEditor<BSchema, I, S>) => InternalHTMLSerializer<BSchema, I, S>;

package/types/src/api/exporters/html/util/sharedHTMLConversion.d.ts

@@ -0,0 +1,7 @@
+import { DOMSerializer, Fragment, Node } from "prosemirror-model";
+import type { BlockNoteEditor } from "../../../../editor/BlockNoteEditor";
+import { InlineContentSchema, StyleSchema } from "../../../../schema";
+export declare const serializeNodeInner: <BSchema extends Record<string, import("../../../../schema").BlockConfig>, I extends InlineContentSchema, S extends StyleSchema>(node: Node, options: {
+    document?: Document;
+}, serializer: DOMSerializer, editor: BlockNoteEditor<BSchema, I, S>, toExternalHTML: boolean) => HTMLElement;
+export declare const serializeProseMirrorFragment: (fragment: Fragment, serializer: DOMSerializer) => string;

package/types/src/api/exporters/markdown/markdownExporter.d.ts

@@ -0,0 +1,5 @@
+import { Schema } from "prosemirror-model";
+import type { BlockNoteEditor } from "../../../editor/BlockNoteEditor";
+import { Block, BlockSchema, InlineContentSchema, StyleSchema } from "../../../schema";
+export declare function cleanHTMLToMarkdown(cleanHTMLString: string): string;
+export declare function blocksToMarkdown<BSchema extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema>(blocks: Block<BSchema, I, S>[], schema: Schema, editor: BlockNoteEditor<BSchema, I, S>): string;

package/types/src/api/exporters/markdown/markdownExporter.test.d.ts

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

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

@@ -0,0 +1,27 @@
+import { Node, NodeType } from "prosemirror-model";
+export type BlockInfoWithoutPositions = {
+    id: string;
+    node: Node;
+    contentNode: Node;
+    contentType: NodeType;
+    numChildBlocks: number;
+};
+export type BlockInfo = BlockInfoWithoutPositions & {
+    startPos: number;
+    endPos: number;
+    depth: number;
+};
+/**
+ * Helper function for `getBlockInfoFromPos`, returns information regarding
+ * provided blockContainer node.
+ * @param blockContainer The blockContainer node to retrieve info for.
+ */
+export declare function getBlockInfo(blockContainer: Node): BlockInfoWithoutPositions;
+/**
+ * Retrieves information regarding the nearest blockContainer node in a
+ * ProseMirror doc, relative to a position.
+ * @param doc The ProseMirror doc.
+ * @param pos An integer position.
+ * @returns A BlockInfo object for the nearest blockContainer node.
+ */
+export declare function getBlockInfoFromPos(doc: Node, pos: number): BlockInfo;

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

@@ -1,15 +1,23 @@
-import { Node, Schema } from "prosemirror-model";
-import { Block, BlockSchema, PartialBlock } from "../../extensions/Blocks/api/blockTypes";
-import { PartialInlineContent } from "../../extensions/Blocks/api/inlineContentTypes";
+import { Node, Schema } from "@tiptap/pm/model";
+import type { Block, BlockSchema, InlineContent, InlineContentSchema, PartialBlock, PartialInlineContent, PartialTableContent, StyleSchema } from "../../schema";
 /**
  * converts an array of inline content elements to prosemirror nodes
  */
-export declare function inlineContentToNodes(blockContent: PartialInlineContent[], schema: Schema): Node[];
+export declare function inlineContentToNodes<I extends InlineContentSchema, S extends StyleSchema>(blockContent: PartialInlineContent<I, S>, schema: Schema, styleSchema: S): Node[];
+/**
+ * converts an array of inline content elements to prosemirror nodes
+ */
+export declare function tableContentToNodes<I extends InlineContentSchema, S extends StyleSchema>(tableContent: PartialTableContent<I, S>, schema: Schema, styleSchema: StyleSchema): Node[];
 /**
  * Converts a BlockNote block to a TipTap node.
  */
-export declare function blockToNode<BSchema extends BlockSchema>(block: PartialBlock<BSchema>, schema: Schema): Node;
+export declare function blockToNode(block: PartialBlock<any, any, any>, schema: Schema, styleSchema: StyleSchema): Node;
+/**
+ * Converts an internal (prosemirror) content node to a BlockNote InlineContent array.
+ */
+export declare function contentNodeToInlineContent<I extends InlineContentSchema, S extends StyleSchema>(contentNode: Node, inlineContentSchema: I, styleSchema: S): InlineContent<I, S>[];
+export declare function nodeToCustomInlineContent<I extends InlineContentSchema, S extends StyleSchema>(node: Node, inlineContentSchema: I, styleSchema: S): InlineContent<I, S>;
 /**
  * Convert a TipTap node to a BlockNote block.
  */
-export declare function nodeToBlock<BSchema extends BlockSchema>(node: Node, blockSchema: BSchema, blockCache?: WeakMap<Node, Block<BSchema>>): Block<BSchema>;
+export declare function nodeToBlock<BSchema extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema>(node: Node, blockSchema: BSchema, inlineContentSchema: I, styleSchema: S, blockCache?: WeakMap<Node, Block<BSchema, I, S>>): Block<BSchema, I, S>;