@blocknote/core 0.17.1 → 0.19.0

package/src/i18n/locales/nl.ts

@@ -44,6 +44,12 @@ export const nl: Dictionary = {
       aliases: ["p", "paragraaf"],
       group: "Basisblokken",
     },
+    code_block: {
+      title: "Codeblok",
+      subtext: "Codeblok met syntax highlighting",
+      aliases: ["code", "pre"],
+      group: "Basisblokken",
+    },
     table: {
       title: "Tabel",
       subtext: "Gebruikt voor tabellen",

package/src/i18n/locales/pl.ts

@@ -44,6 +44,12 @@ export const pl: Dictionary = {
       aliases: ["p", "akapit"],
       group: "Podstawowe bloki",
     },
+    code_block: {
+      title: "Blok kodu",
+      subtext: "Blok kodu z podświetleniem składni",
+      aliases: ["kod", "pre"],
+      group: "Podstawowe bloki",
+    },
     table: {
       title: "Tabela",
       subtext: "Używana do tworzenia tabel",

package/src/i18n/locales/pt.ts

@@ -24,13 +24,13 @@ export const pt: Dictionary = {
       title: "Lista Numerada",
       subtext: "Usado para exibir uma lista numerada",
       aliases: ["ol", "li", "lista", "listanumerada", "lista numerada"],
-      group: "Blocos Básicos",
+      group: "Blocos básicos",
     },
     bullet_list: {
       title: "Lista com Marcadores",
       subtext: "Usado para exibir uma lista não ordenada",
       aliases: ["ul", "li", "lista", "listamarcadores", "lista com marcadores"],
-      group: "Blocos Básicos",
+      group: "Blocos básicos",
     },
     check_list: {
       title: "Lista de verificação",
@@ -43,13 +43,19 @@ export const pt: Dictionary = {
         "lista marcada",
         "caixa de seleção",
       ],
-      group: "Blocos Básicos",
+      group: "Blocos básicos",
     },
     paragraph: {
       title: "Parágrafo",
       subtext: "Usado para o corpo do seu documento",
       aliases: ["p", "paragrafo"],
-      group: "Blocos Básicos",
+      group: "Blocos básicos",
+    },
+    code_block: {
+      title: "Bloco de Código",
+      subtext: "Usado para exibir código com destaque de sintaxe",
+      aliases: ["codigo", "pre"],
+      group: "Blocos básicos",
     },
     table: {
       title: "Tabela",

package/src/i18n/locales/ru.ts

@@ -69,6 +69,12 @@ export const ru: Dictionary = {
       aliases: ["p", "paragraph", "параграф"],
       group: "Базовые блоки",
     },
+    code_block: {
+      title: "Блок кода",
+      subtext: "Блок кода с подсветкой синтаксиса",
+      aliases: ["code", "pre", "блок кода"],
+      group: "Базовые блоки",
+    },
     table: {
       title: "Таблица",
       subtext: "Используется для таблиц",

package/src/i18n/locales/vi.ts

@@ -51,6 +51,12 @@ export const vi: Dictionary = {
       aliases: ["p", "doanvan"],
       group: "Khối cơ bản",
     },
+    code_block: {
+      title: "Mã",
+      subtext: "Sử dụng để hiển thị mã với cú pháp",
+      aliases: ["code", "pre"],
+      group: "Khối cơ bản",
+    },
     table: {
       title: "Bảng",
       subtext: "Sử dụng để tạo bảng",

package/src/i18n/locales/zh.ts

@@ -69,6 +69,12 @@ export const zh: Dictionary = {
       aliases: ["p", "paragraph", "text", "正文"],
       group: "基础",
     },
+    code_block: {
+      title: "代码块",
+      subtext: "用于显示带有语法高亮的代码块",
+      aliases: ["code", "pre", "代码", "预格式"],
+      group: "基础",
+    },
     table: {
       title: "表格",
       subtext: "使用表格",

package/src/index.ts

@@ -2,13 +2,19 @@ import * as locales from "./i18n/locales/index.js";
 export * from "./api/exporters/html/externalHTMLExporter.js";
 export * from "./api/exporters/html/internalHTMLSerializer.js";
 export * from "./api/getBlockInfoFromPos.js";
+export * from "./api/nodeUtil.js";
 export * from "./api/testUtil/index.js";
 export * from "./blocks/AudioBlockContent/AudioBlockContent.js";
+export * from "./blocks/CodeBlockContent/CodeBlockContent.js";
 export * from "./blocks/FileBlockContent/FileBlockContent.js";
 export * from "./blocks/FileBlockContent/fileBlockHelpers.js";
 export * from "./blocks/FileBlockContent/uploadToTmpFilesDotOrg_DEV_ONLY.js";
 export * from "./blocks/ImageBlockContent/ImageBlockContent.js";
 export { parseImageElement } from "./blocks/ImageBlockContent/imageBlockHelpers.js";
+export {
+  EMPTY_CELL_HEIGHT,
+  EMPTY_CELL_WIDTH,
+} from "./blocks/TableBlockContent/TableExtension.js";
 export * from "./blocks/VideoBlockContent/VideoBlockContent.js";
 export * from "./blocks/defaultBlockHelpers.js";
 export * from "./blocks/defaultBlockTypeGuards.js";
@@ -17,7 +23,9 @@ export * from "./blocks/defaultProps.js";
 export * from "./editor/BlockNoteEditor.js";
 export * from "./editor/BlockNoteExtensions.js";
 export * from "./editor/BlockNoteSchema.js";
+export * from "./editor/defaultColors.js";
 export * from "./editor/selectionTypes.js";
+export * from "./exporter/index.js";
 export * from "./extensions-shared/UiElementPosition.js";
 export * from "./extensions/FilePanel/FilePanelPlugin.js";
 export * from "./extensions/FormattingToolbar/FormattingToolbarPlugin.js";
@@ -32,6 +40,7 @@ export * from "./extensions/TableHandles/TableHandlesPlugin.js";
 export * from "./i18n/dictionary.js";
 export * from "./schema/index.js";
 export * from "./util/browser.js";
+export * from "./util/combineByGroup.js";
 export * from "./util/esmDependencies.js";
 export * from "./util/string.js";
 export * from "./util/typescript.js";

package/src/pm-nodes/BlockContainer.ts

@@ -21,7 +21,7 @@ export const BlockContainer = Node.create<{
   editor: BlockNoteEditor<any, any, any>;
 }>({
   name: "blockContainer",
-  group: "blockContainer",
+  group: "blockGroupChild bnBlock",
   // A block always contains content, and optionally a blockGroup which contains nested blocks
   content: "blockContent blockGroup?",
   // Ensures content-specific keyboard handlers trigger first.

package/src/pm-nodes/BlockGroup.ts

@@ -6,8 +6,8 @@ export const BlockGroup = Node.create<{
   domAttributes?: BlockNoteDOMAttributes;
 }>({
   name: "blockGroup",
-  group: "blockGroup",
-  content: "blockContainer+",
+  group: "childContainer",
+  content: "blockGroupChild+",
 
   parseHTML() {
     return [

package/src/pm-nodes/README.md

@@ -2,41 +2,140 @@
 
 Defines the prosemirror nodes and base node structure. See below:
 
+# Block structure
+
+In the BlockNote API, recall that blocks look like this:
+
+```typescript
+{
+    id: string;
+    type: string;
+    children: Block[];
+    content: InlineContent[] | undefined;
+    props: Record<string, any>;
+}
+```
+
+`children` describes child blocks that have their own `id` and also map to a `Block` type. Most of the cases these are nested blocks, but they can also be blocks within a `column` or `columnList`.
+
+`content` is the block's Inline Content. Inline content doesn't have any `id`, it's "loose" content within the node.
+
+This is a bit different from the Prosemirror structure we use internally. This document describes the Prosemirror schema architecture.
 
 # Node structure
 
-We use a Prosemirror document structure where every element is a `block` with 1 `content` element and one optional group of children (`blockgroup`).
+## BlockGroup
+
+```typescript
+name: "blockGroup",
+group: "childContainer",
+content: "blockGroupChild+"
+```
+
+A `blockGroup` is a container node that can contain multiple Blocks. It is used as:
+
+- The root node of the Prosemirror document
+- When a block has nested children, they are wrapped in a `blockGroup`
+
+## BlockContainer
+
+```typescript
+name: "blockContainer",
+group: "blockGroupChild bnBlock",
+// A block always contains content, and optionally a blockGroup which contains nested blocks
+content: "blockContent blockGroup?",
+```
+
+A `blockContainer` is a container node that always contains a `blockContent` node, and optionally a `blockGroup` node (for nested children). It is used as the wrapper for most blocks. This structure makes it possible to nest blocks within blocks.
+
+### BlockContent (group)
+
+Example:
 
-- A `block` can only appear in a `blockgroup` (which is also the type of the root node)
-- Every `block` element can have attributes (e.g.: is it a heading or a list item)
-- Every `block` element can contain a `blockgroup` as second child. In this case the `blockgroup` is considered nested (indented in the UX)
+```typescript
+name: "paragraph", // name corresponds to the block type in the BlockNote API
+content: "inline*", // can also be no content (for image blocks)
+group: "blockContent",
+```
+
+Blocks that are part of the `blockContent` group define the appearance / behaviour of the main element of the block (i.e.: headings, paragraphs, list items, etc.).
+These are only used for "regular" blocks that are represented as `blockContainer` nodes.
+
+## Multi-column
+
+The `multi-column` package makes it possible to order blocks side by side in
+columns. It adds the `columnList` and `column` nodes to the schema.
+
+### ColumnList
+
+```typescript
+name: "columnList",
+group: "childContainer bnBlock blockGroupChild",
+// A block always contains content, and optionally a blockGroup which contains nested blocks
+content: "column column+", // min two columns
+```
+
+The column list contains 2 or more columns.
 
-This architecture is different from the "default" Prosemirror / Tiptap implementation which would use more semantic HTML node types (`p`, `li`, etc.). We have designed this block structure instead to more easily:
+### Column
 
-- support indentation of any node (without complex wrapping logic)
-- supporting animations (nodes stay the same type, only attrs are changed)
+```typescript
+name: "column",
+group: "bnBlock childContainer",
+// A block always contains content, and optionally a blockGroup which contains nested blocks
+content: "blockContainer+",
+```
+
+The column contains 1 or more block containers.
+
+# Groups
+
+We use Prosemirror "groups" to help organize this schema. Here is a list of the different groups:
 
-## Example
+- `blockContent`: described above (contain the content for blocks that are represented as `BlockContainer` nodes)
+- `blockGroupChild`: anything that is allowed inside a `blockGroup`. In practice, `blockContainer` and `columnList`
+- `childContainer`: think of this as the container node that can hold nodes corresponding to `block.children` in the BlockNote API. So for regular blocks, this is the `BlockGroup`, but for columns, both `columnList` and `column` are considered to be `childContainer` nodes.
+- `bnBlock`: think of this as the node that directly maps to a `Block` in the BlockNote API. For example, this node will store the `id`. Both `blockContainer`, `column` and `columnList` are part of this group.
+
+_Note that the last two groups, `bnBlock` and `childContainer`, are not used anywhere in the schema. They are however helpful while programming. For example, we can check whether a node is a `bnBlock`, and then we know it corresponds to a BlockNote Block. Or, we can check whether a node is a `childContainer`, and then we know it's a container of a BlockNote Block's `children`. See `getBlockInfoFromPos` for an example of how this is used._
+
+## Example document
 
 ```xml
-<blockgroup>
-    <block>
-        <content>Parent element 1</content>
-        <blockgroup>
-            <block>
-                <content>Nested / child / indented item</content>
-            </block>
-        </blockgroup>
-    </block>
-    <block>
-        <content>Parent element 2</content>
-        <blockgroup>
-            <block>...</block>
-            <block>...</block>
-        </blockgroup>
-    </block>
-    <block>
-        <content>Element 3 without children</content>
-    </block>
-</blockgroup>
+<blockGroup>
+    <blockContaine id="0">
+        <blockContent>Parent element 1</blockContent>
+        <blockGroup>
+            <blockContainer id="1">
+                <blockContent>Nested / child / indented item</blockContent>
+            </blockContainer>
+        </blockGroup>
+    </blockContainer>
+    <blockContainer id="2">
+        <blockContent>Parent element 2</blockContent>
+        <blockGroup>
+            <blockContainer id="3">...</blockContainer>
+            <blockContainer id="4">...</blockContainer>
+        </blockGroup>
+    </blockContainer>
+    <blockContainer id="5">
+        <blockContent>Element 3 without children</blockContent>
+    </blockContainer>
+    <columnList id="6">
+        <column id="7">
+            <blockContainer id="8">
+                <blockContent>Column 1</blockContent>
+            </blockContainer>
+        </column>
+        <column id="9">
+            <blockContainer id="10">
+                <blockContent>Column 2</blockContent>
+            </blockContainer>
+        </column>
+    </columnList>
+</blockGroup>
 ```
+
+## Tables
+
+Tables are implemented a special type of blockContent node. The rows and columns are stored in the `content` fields, not in the `children`. This is because children of tables (rows / columns / cells) are not considered to be blocks (they don't have an id, for example).

package/src/schema/blocks/createSpec.ts

@@ -137,7 +137,10 @@ export function createBlockSpec<
   T extends CustomBlockConfig,
   I extends InlineContentSchema,
   S extends StyleSchema
->(blockConfig: T, blockImplementation: CustomBlockImplementation<T, I, S>) {
+>(
+  blockConfig: T,
+  blockImplementation: CustomBlockImplementation<NoInfer<T>, I, S>
+) {
   const node = createStronglyTypedTiptapNode({
     name: blockConfig.type as T["type"],
     content: (blockConfig.content === "inline"

package/src/schema/blocks/internal.ts

@@ -201,12 +201,22 @@ export function wrapInBlockStructure<
 // Helper type to keep track of the `name` and `content` properties after calling Node.create.
 type StronglyTypedTipTapNode<
   Name extends string,
-  Content extends "inline*" | "tableRow+" | ""
+  Content extends
+    | "inline*"
+    | "tableRow+"
+    | "blockContainer+"
+    | "column column+"
+    | ""
 > = Node & { name: Name; config: { content: Content } };
 
 export function createStronglyTypedTiptapNode<
   Name extends string,
-  Content extends "inline*" | "tableRow+" | ""
+  Content extends
+    | "inline*"
+    | "tableRow+"
+    | "blockContainer+"
+    | "column column+"
+    | ""
 >(config: NodeConfig & { name: Name; content: Content }) {
   return Node.create(config) as StronglyTypedTipTapNode<Name, Content>; // force re-typing (should be safe as it's type-checked from the config)
 }

package/src/schema/blocks/types.ts

@@ -104,7 +104,7 @@ export type BlockSpec<
   S extends StyleSchema
 > = {
   config: T;
-  implementation: TiptapBlockImplementation<T, B, I, S>;
+  implementation: TiptapBlockImplementation<NoInfer<T>, B, I, S>;
 };
 
 // Utility type. For a given object block schema, ensures that the key of each
@@ -149,6 +149,7 @@ export type TableContent<
   S extends StyleSchema = StyleSchema
 > = {
   type: "tableContent";
+  columnWidths: (number | undefined)[];
   rows: {
     cells: InlineContent<I, S>[][];
   }[];
@@ -224,6 +225,7 @@ export type PartialTableContent<
   S extends StyleSchema = StyleSchema
 > = {
   type: "tableContent";
+  columnWidths?: (number | undefined)[];
   rows: {
     cells: PartialInlineContent<I, S>[];
   }[];

package/src/util/combineByGroup.ts

@@ -0,0 +1,25 @@
+/**
+ * Combines items by group. This can be used to combine multiple slash menu item arrays,
+ * while making sure that items from the same group are adjacent to each other.
+ */
+export function combineByGroup<T extends { group?: string }>(
+  items: T[],
+  ...additionalItemsArray: {
+    group?: string;
+  }[][]
+) {
+  const combinedItems = [...items];
+  for (const additionalItems of additionalItemsArray) {
+    for (const additionalItem of additionalItems) {
+      const lastItemWithSameGroup = combinedItems.findLastIndex(
+        (item) => item.group === additionalItem.group
+      );
+      if (lastItemWithSameGroup === -1) {
+        combinedItems.push(additionalItem as T);
+      } else {
+        combinedItems.splice(lastItemWithSameGroup + 1, 0, additionalItem as T);
+      }
+    }
+  }
+  return combinedItems;
+}

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

@@ -1,6 +1,26 @@
-import { Node, ResolvedPos } from "prosemirror-model";
+import { Node } from "prosemirror-model";
 import { EditorState } from "prosemirror-state";
-export declare const getPrevBlockPos: (doc: Node, $nextBlockPos: ResolvedPos) => ResolvedPos;
+import { BlockInfo } from "../../../getBlockInfoFromPos.js";
+/**
+ * Returns the block info from the parent block
+ * or undefined if we're at the root
+ */
+export declare const getParentBlockInfo: (doc: Node, beforePos: number) => BlockInfo | undefined;
+/**
+ * Returns the block info from the sibling block before (above) the given block,
+ * or undefined if the given block is the first sibling.
+ */
+export declare const getPrevBlockInfo: (doc: Node, beforePos: number) => BlockInfo | undefined;
+/**
+ * If a block has children like this:
+ * A
+ * - B
+ * - C
+ * -- D
+ *
+ * Then the bottom nested block returned is D.
+ */
+export declare const getBottomNestedBlockInfo: (doc: Node, blockInfo: BlockInfo) => BlockInfo;
 export declare const mergeBlocksCommand: (posBetweenBlocks: number) => ({ state, dispatch, }: {
     state: EditorState;
     dispatch: ((args?: any) => any) | undefined;

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

@@ -0,0 +1,5 @@
+import { BlockNoteEditor } from "../../../../editor/BlockNoteEditor.js";
+export declare function nestBlock(editor: BlockNoteEditor<any, any, any>): boolean;
+export declare function unnestBlock(editor: BlockNoteEditor<any, any, any>): void;
+export declare function canNestBlock(editor: BlockNoteEditor<any, any, any>): boolean;
+export declare function canUnnestBlock(editor: BlockNoteEditor<any, any, any>): boolean;

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

@@ -76,6 +76,28 @@ export declare function setupTestEnv(): () => BlockNoteEditor<import("../../inde
             };
         }, any, import("../../index.js").InlineContentSchema, import("../../index.js").StyleSchema>;
     };
+    codeBlock: {
+        config: {
+            type: "codeBlock";
+            content: "inline";
+            propSchema: {
+                language: {
+                    default: string;
+                    values: string[];
+                };
+            };
+        };
+        implementation: import("../../index.js").TiptapBlockImplementation<{
+            type: "codeBlock";
+            content: "inline";
+            propSchema: {
+                language: {
+                    default: string;
+                    values: string[];
+                };
+            };
+        }, any, import("../../index.js").InlineContentSchema, import("../../index.js").StyleSchema>;
+    };
     bulletListItem: {
         config: {
             type: "bulletListItem";
@@ -195,10 +217,6 @@ export declare function setupTestEnv(): () => BlockNoteEditor<import("../../inde
                 textColor: {
                     default: "default";
                 };
-                textAlignment: {
-                    default: "left";
-                    values: readonly ["left", "center", "right", "justify"];
-                };
             };
         };
         implementation: import("../../index.js").TiptapBlockImplementation<{
@@ -211,10 +229,6 @@ export declare function setupTestEnv(): () => BlockNoteEditor<import("../../inde
                 textColor: {
                     default: "default";
                 };
-                textAlignment: {
-                    default: "left";
-                    values: readonly ["left", "center", "right", "justify"];
-                };
             };
         }, any, import("../../index.js").InlineContentSchema, import("../../index.js").StyleSchema>;
     };

package/types/src/api/clipboard/fromClipboard/acceptedMIMETypes.d.ts

@@ -1 +1 @@
-export declare const acceptedMIMETypes: readonly ["blocknote/html", "Files", "text/html", "text/plain"];
+export declare const acceptedMIMETypes: readonly ["vscode-editor-data", "blocknote/html", "Files", "text/html", "text/plain"];

package/types/src/api/clipboard/fromClipboard/handleVSCodePaste.d.ts

@@ -0,0 +1,3 @@
+import { BlockNoteEditor } from "../../../editor/BlockNoteEditor.js";
+import { BlockSchema, InlineContentSchema, StyleSchema } from "../../../schema/index.js";
+export declare function handleVSCodePaste<BSchema extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema>(event: ClipboardEvent, editor: BlockNoteEditor<BSchema, I, S>): Promise<boolean>;

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

@@ -2,10 +2,9 @@ import { DOMSerializer } from "prosemirror-model";
 import { PartialBlock } from "../../../../blocks/defaultBlocks.js";
 import type { BlockNoteEditor } from "../../../../editor/BlockNoteEditor.js";
 import { BlockSchema, InlineContentSchema, StyleSchema } from "../../../../schema/index.js";
-export declare function serializeInlineContentInternalHTML<BSchema extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema>(editor: BlockNoteEditor<any, I, S>, blockContent: PartialBlock<BSchema, I, S>["content"], serializer: DOMSerializer, _toExternalHTML: boolean, // TODO, externalHTML for IC
-options?: {
+export declare function serializeInlineContentInternalHTML<BSchema extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema>(editor: BlockNoteEditor<any, I, S>, blockContent: PartialBlock<BSchema, I, S>["content"], serializer: DOMSerializer, options?: {
     document?: Document;
 }): HTMLElement | DocumentFragment;
-export declare const serializeBlocksInternalHTML: <BSchema extends Record<string, import("../../../../schema/index.js").BlockConfig>, I extends InlineContentSchema, S extends StyleSchema>(editor: BlockNoteEditor<BSchema, I, S>, blocks: PartialBlock<BSchema, I, S>[], serializer: DOMSerializer, toExternalHTML: boolean, options?: {
+export declare const serializeBlocksInternalHTML: <BSchema extends Record<string, import("../../../../schema/index.js").BlockConfig>, I extends InlineContentSchema, S extends StyleSchema>(editor: BlockNoteEditor<BSchema, I, S>, blocks: PartialBlock<BSchema, I, S>[], serializer: DOMSerializer, options?: {
     document?: Document;
 }) => HTMLElement;

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

@@ -6,10 +6,36 @@ type SingleBlockInfo = {
     afterPos: number;
 };
 export type BlockInfo = {
-    blockContainer: SingleBlockInfo;
+    /**
+     * The outer node that represents a BlockNote block. This is the node that has the ID.
+     * Most of the time, this will be a blockContainer node, but it could also be a Column or ColumnList
+     */
+    bnBlock: SingleBlockInfo;
+    /**
+     * The type of BlockNote block that this node represents.
+     * When dealing with a blockContainer, this is retrieved from the blockContent node, otherwise it's retrieved from the bnBlock node.
+     */
+    blockNoteType: string;
+} & ({
+    /**
+     * The Prosemirror node that holds block.children. For non-blockContainer, this node will be the same as bnBlock.
+     */
+    childContainer: SingleBlockInfo;
+    isBlockContainer: false;
+} | {
+    /**
+     * The Prosemirror node that holds block.children. For blockContainers, this is the blockGroup node, if it exists.
+     */
+    childContainer?: SingleBlockInfo;
+    /**
+     * The Prosemirror node that wraps block.content and has most of the props
+     */
     blockContent: SingleBlockInfo;
-    blockGroup?: SingleBlockInfo;
-};
+    /**
+     * Whether bnBlock is a blockContainer node
+     */
+    isBlockContainer: true;
+});
 /**
  * Retrieves the position just before the nearest blockContainer node in a
  * ProseMirror doc, relative to a position. If the position is within a
@@ -37,7 +63,7 @@ export declare function getNearestBlockContainerPos(doc: Node, pos: number): {
  * @param blockContainerBeforePosOffset the position just before the
  * `blockContainer` node in the document.
  */
-export declare function getBlockInfoWithManualOffset(node: Node, blockContainerBeforePosOffset: number): BlockInfo;
+export declare function getBlockInfoWithManualOffset(node: Node, bnBlockBeforePosOffset: number): BlockInfo;
 /**
  * Gets information regarding the ProseMirror nodes that make up a block in a
  * BlockNote document. This includes the main `blockContainer` node, the
@@ -66,5 +92,29 @@ export declare function getBlockInfoFromResolvedPos(resolvedPos: ResolvedPos): B
  * selection.
  * @param state The ProseMirror editor state.
  */
-export declare function getBlockInfoFromSelection(state: EditorState): BlockInfo;
+export declare function getBlockInfoFromSelection(state: EditorState): {
+    /**
+     * The outer node that represents a BlockNote block. This is the node that has the ID.
+     * Most of the time, this will be a blockContainer node, but it could also be a Column or ColumnList
+     */
+    bnBlock: SingleBlockInfo;
+    /**
+     * The type of BlockNote block that this node represents.
+     * When dealing with a blockContainer, this is retrieved from the blockContent node, otherwise it's retrieved from the bnBlock node.
+     */
+    blockNoteType: string;
+} & {
+    /**
+     * The Prosemirror node that holds block.children. For blockContainers, this is the blockGroup node, if it exists.
+     */
+    childContainer?: SingleBlockInfo | undefined;
+    /**
+     * The Prosemirror node that wraps block.content and has most of the props
+     */
+    blockContent: SingleBlockInfo;
+    /**
+     * Whether bnBlock is a blockContainer node
+     */
+    isBlockContainer: true;
+};
 export {};

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

@@ -10,6 +10,6 @@ export declare function inlineContentToNodes<I extends InlineContentSchema, S ex
  */
 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.
+ * Converts a BlockNote block to a Prosemirror node.
  */
 export declare function blockToNode(block: PartialBlock<any, any, any>, schema: Schema, styleSchema: StyleSchema): Node;

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

@@ -11,6 +11,8 @@ export declare function contentNodeToTableContent<I extends InlineContentSchema,
 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.
+ * Convert a Prosemirror node to a BlockNote block.
+ *
+ * TODO: test changes
  */
 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>;