@blocknote/core 0.28.0 → 0.29.0

package/src/api/blockManipulation/selections/selection.ts

@@ -1,8 +1,7 @@
-import { TextSelection } from "prosemirror-state";
+import { TextSelection, type Transaction } from "prosemirror-state";
 import { TableMap } from "prosemirror-tables";
 
 import { Block } from "../../../blocks/defaultBlocks.js";
-import type { BlockNoteEditor } from "../../../editor/BlockNoteEditor";
 import { Selection } from "../../../editor/selectionTypes.js";
 import {
   BlockIdentifier,
@@ -13,26 +12,24 @@ import {
 import { getBlockInfo, getNearestBlockPos } from "../../getBlockInfoFromPos.js";
 import { nodeToBlock } from "../../nodeConversions/nodeToBlock.js";
 import { getNodeById } from "../../nodeUtil.js";
+import { getBlockNoteSchema, getPmSchema } from "../../pmUtil.js";
 
 export function getSelection<
   BSchema extends BlockSchema,
   I extends InlineContentSchema,
   S extends StyleSchema
->(
-  editor: BlockNoteEditor<BSchema, I, S>
-): Selection<BSchema, I, S> | undefined {
-  const state = editor._tiptapEditor.state;
-
+>(tr: Transaction): Selection<BSchema, I, S> | undefined {
+  const pmSchema = getPmSchema(tr);
   // Return undefined if the selection is collapsed or a node is selected.
-  if (state.selection.empty || "node" in state.selection) {
+  if (tr.selection.empty || "node" in tr.selection) {
     return undefined;
   }
 
-  const $startBlockBeforePos = state.doc.resolve(
-    getNearestBlockPos(state.doc, state.selection.from).posBeforeNode
+  const $startBlockBeforePos = tr.doc.resolve(
+    getNearestBlockPos(tr.doc, tr.selection.from).posBeforeNode
   );
-  const $endBlockBeforePos = state.doc.resolve(
-    getNearestBlockPos(state.doc, state.selection.to).posBeforeNode
+  const $endBlockBeforePos = tr.doc.resolve(
+    getNearestBlockPos(tr.doc, tr.selection.to).posBeforeNode
   );
 
   // Converts the node at the given index and depth around `$startBlockBeforePos`
@@ -43,7 +40,7 @@ export function getSelection<
     depth?: number
   ): Block<BSchema, I, S> => {
     const pos = $startBlockBeforePos.posAtIndex(index, depth);
-    const node = state.doc.resolve(pos).nodeAfter;
+    const node = tr.doc.resolve(pos).nodeAfter;
 
     if (!node) {
       throw new Error(
@@ -51,13 +48,7 @@ export function getSelection<
       );
     }
 
-    return nodeToBlock(
-      node,
-      editor.schema.blockSchema,
-      editor.schema.inlineContentSchema,
-      editor.schema.styleSchema,
-      editor.blockCache
-    );
+    return nodeToBlock(node, pmSchema);
   };
 
   const blocks: Block<BSchema, I, S>[] = [];
@@ -98,15 +89,7 @@ export function getSelection<
   // [ id-2, id-3, id-4, id-6, id-7, id-8, id-9 ]
   if ($startBlockBeforePos.depth > sharedDepth) {
     // Adds the block that the selection starts in.
-    blocks.push(
-      nodeToBlock(
-        $startBlockBeforePos.nodeAfter!,
-        editor.schema.blockSchema,
-        editor.schema.inlineContentSchema,
-        editor.schema.styleSchema,
-        editor.blockCache
-      )
-    );
+    blocks.push(nodeToBlock($startBlockBeforePos.nodeAfter!, pmSchema));
 
     // Traverses all depths from the depth of the block in which the selection
     // starts, up to the shared depth.
@@ -137,7 +120,7 @@ export function getSelection<
 
   if (blocks.length === 0) {
     throw new Error(
-      `Error getting selection - selection doesn't span any blocks (${state.selection})`
+      `Error getting selection - selection doesn't span any blocks (${tr.selection})`
     );
   }
 
@@ -146,32 +129,27 @@ export function getSelection<
   };
 }
 
-export function setSelection<
-  BSchema extends BlockSchema,
-  I extends InlineContentSchema,
-  S extends StyleSchema
->(
-  editor: BlockNoteEditor<BSchema, I, S>,
+export function setSelection(
+  tr: Transaction,
   startBlock: BlockIdentifier,
   endBlock: BlockIdentifier
 ) {
   const startBlockId =
     typeof startBlock === "string" ? startBlock : startBlock.id;
   const endBlockId = typeof endBlock === "string" ? endBlock : endBlock.id;
+  const pmSchema = getPmSchema(tr);
+  const schema = getBlockNoteSchema(pmSchema);
 
   if (startBlockId === endBlockId) {
     throw new Error(
       `Attempting to set selection with the same anchor and head blocks (id ${startBlockId})`
     );
   }
-
-  const doc = editor._tiptapEditor.state.doc;
-
-  const anchorPosInfo = getNodeById(startBlockId, doc);
+  const anchorPosInfo = getNodeById(startBlockId, tr.doc);
   if (!anchorPosInfo) {
     throw new Error(`Block with ID ${startBlockId} not found`);
   }
-  const headPosInfo = getNodeById(endBlockId, doc);
+  const headPosInfo = getNodeById(endBlockId, tr.doc);
   if (!headPosInfo) {
     throw new Error(`Block with ID ${endBlockId} not found`);
   }
@@ -180,12 +158,12 @@ export function setSelection<
   const headBlockInfo = getBlockInfo(headPosInfo);
 
   const anchorBlockConfig =
-    editor.schema.blockSchema[
-      anchorBlockInfo.blockNoteType as keyof typeof editor.schema.blockSchema
+    schema.blockSchema[
+      anchorBlockInfo.blockNoteType as keyof typeof schema.blockSchema
     ];
   const headBlockConfig =
-    editor.schema.blockSchema[
-      headBlockInfo.blockNoteType as keyof typeof editor.schema.blockSchema
+    schema.blockSchema[
+      headBlockInfo.blockNoteType as keyof typeof schema.blockSchema
     ];
 
   if (
@@ -226,7 +204,7 @@ export function setSelection<
         headBlockInfo.blockContent.node
       ) +
       1;
-    const lastCellNodeSize = doc.resolve(lastCellPos).nodeAfter!.nodeSize;
+    const lastCellNodeSize = tr.doc.resolve(lastCellPos).nodeAfter!.nodeSize;
     endPos = lastCellPos + lastCellNodeSize - 2;
   } else {
     endPos = headBlockInfo.blockContent.afterPos - 1;
@@ -236,9 +214,5 @@ export function setSelection<
   //  Right now it's missing a few things like a jsonID and styling to show
   //  which nodes are selected. `TextSelection` is ok for now, but has the
   //  restriction that the start/end blocks must have content.
-  editor._tiptapEditor.dispatch(
-    editor._tiptapEditor.state.tr.setSelection(
-      TextSelection.create(editor._tiptapEditor.state.doc, startPos, endPos)
-    )
-  );
+  tr.setSelection(TextSelection.create(tr.doc, startPos, endPos));
 }

package/src/api/blockManipulation/selections/textCursorPosition/textCursorPosition.test.ts

@@ -10,44 +10,65 @@ const getEditor = setupTestEnv();
 
 describe("Test getTextCursorPosition & setTextCursorPosition", () => {
   it("Basic", () => {
-    setTextCursorPosition(getEditor(), "paragraph-1");
+    getEditor().transact((tr) => {
+      setTextCursorPosition(tr, "paragraph-1");
+    });
 
-    expect(getTextCursorPosition(getEditor())).toMatchSnapshot();
+    expect(
+      getEditor().transact((tr) => getTextCursorPosition(tr))
+    ).toMatchSnapshot();
   });
 
   it("First block", () => {
-    setTextCursorPosition(getEditor(), "paragraph-0");
+    getEditor().transact((tr) => {
+      setTextCursorPosition(tr, "paragraph-0");
+    });
 
-    expect(getTextCursorPosition(getEditor())).toMatchSnapshot();
+    expect(
+      getEditor().transact((tr) => getTextCursorPosition(tr))
+    ).toMatchSnapshot();
   });
 
   it("Last block", () => {
-    setTextCursorPosition(getEditor(), "trailing-paragraph");
+    getEditor().transact((tr) => {
+      setTextCursorPosition(tr, "trailing-paragraph");
+    });
 
-    expect(getTextCursorPosition(getEditor())).toMatchSnapshot();
+    expect(
+      getEditor().transact((tr) => getTextCursorPosition(tr))
+    ).toMatchSnapshot();
   });
 
   it("Nested block", () => {
-    setTextCursorPosition(getEditor(), "nested-paragraph-0");
+    getEditor().transact((tr) => {
+      setTextCursorPosition(tr, "nested-paragraph-0");
+    });
 
-    expect(getTextCursorPosition(getEditor())).toMatchSnapshot();
+    expect(
+      getEditor().transact((tr) => getTextCursorPosition(tr))
+    ).toMatchSnapshot();
   });
 
   it("Set to start", () => {
-    setTextCursorPosition(getEditor(), "paragraph-1", "start");
+    getEditor().transact((tr) => {
+      setTextCursorPosition(tr, "paragraph-1", "start");
+    });
 
     expect(
-      getEditor()._tiptapEditor.state.selection.$from.parentOffset === 0
+      getEditor().transact((tr) => tr.selection.$from.parentOffset) === 0
     ).toBeTruthy();
   });
 
   it("Set to end", () => {
-    setTextCursorPosition(getEditor(), "paragraph-1", "end");
+    getEditor().transact((tr) => {
+      setTextCursorPosition(tr, "paragraph-1", "end");
+    });
 
     expect(
-      getEditor()._tiptapEditor.state.selection.$from.parentOffset ===
-        getEditor()._tiptapEditor.state.selection.$from.node().firstChild!
-          .nodeSize
+      getEditor().transact((tr) => tr.selection.$from.parentOffset) ===
+        getEditor().transact(
+          (tr) => tr.selection.$from.node().firstChild!.nodeSize
+        )
     ).toBeTruthy();
   });
 });

package/src/api/blockManipulation/selections/textCursorPosition/textCursorPosition.ts

@@ -1,8 +1,11 @@
-import { Node } from "prosemirror-model";
-
-import type { BlockNoteEditor } from "../../../../editor/BlockNoteEditor.js";
-import { TextCursorPosition } from "../../../../editor/cursorPositionTypes.js";
+import type { Node } from "prosemirror-model";
 import {
+  NodeSelection,
+  TextSelection,
+  type Transaction,
+} from "prosemirror-state";
+import type { TextCursorPosition } from "../../../../editor/cursorPositionTypes.js";
+import type {
   BlockIdentifier,
   BlockSchema,
   InlineContentSchema,
@@ -11,26 +14,26 @@ import {
 import { UnreachableCaseError } from "../../../../util/typescript.js";
 import {
   getBlockInfo,
-  getBlockInfoFromSelection,
+  getBlockInfoFromTransaction,
 } from "../../../getBlockInfoFromPos.js";
 import { nodeToBlock } from "../../../nodeConversions/nodeToBlock.js";
 import { getNodeById } from "../../../nodeUtil.js";
+import { getBlockNoteSchema, getPmSchema } from "../../../pmUtil.js";
 
 export function getTextCursorPosition<
   BSchema extends BlockSchema,
   I extends InlineContentSchema,
   S extends StyleSchema
->(editor: BlockNoteEditor<BSchema, I, S>): TextCursorPosition<BSchema, I, S> {
-  const { bnBlock } = getBlockInfoFromSelection(editor._tiptapEditor.state);
+>(tr: Transaction): TextCursorPosition<BSchema, I, S> {
+  const { bnBlock } = getBlockInfoFromTransaction(tr);
+  const pmSchema = getPmSchema(tr.doc);
 
-  const resolvedPos = editor._tiptapEditor.state.doc.resolve(bnBlock.beforePos);
+  const resolvedPos = tr.doc.resolve(bnBlock.beforePos);
   // Gets previous blockContainer node at the same nesting level, if the current node isn't the first child.
   const prevNode = resolvedPos.nodeBefore;
 
   // Gets next blockContainer node at the same nesting level, if the current node isn't the last child.
-  const nextNode = editor._tiptapEditor.state.doc.resolve(
-    bnBlock.afterPos
-  ).nodeAfter;
+  const nextNode = tr.doc.resolve(bnBlock.afterPos).nodeAfter;
 
   // Gets parent blockContainer node, if the current node is nested.
   let parentNode: Node | undefined = undefined;
@@ -44,58 +47,24 @@ export function getTextCursorPosition<
   }
 
   return {
-    block: nodeToBlock(
-      bnBlock.node,
-      editor.schema.blockSchema,
-      editor.schema.inlineContentSchema,
-      editor.schema.styleSchema,
-      editor.blockCache
-    ),
-    prevBlock:
-      prevNode === null
-        ? undefined
-        : nodeToBlock(
-            prevNode,
-            editor.schema.blockSchema,
-            editor.schema.inlineContentSchema,
-            editor.schema.styleSchema,
-            editor.blockCache
-          ),
-    nextBlock:
-      nextNode === null
-        ? undefined
-        : nodeToBlock(
-            nextNode,
-            editor.schema.blockSchema,
-            editor.schema.inlineContentSchema,
-            editor.schema.styleSchema,
-            editor.blockCache
-          ),
+    block: nodeToBlock(bnBlock.node, pmSchema),
+    prevBlock: prevNode === null ? undefined : nodeToBlock(prevNode, pmSchema),
+    nextBlock: nextNode === null ? undefined : nodeToBlock(nextNode, pmSchema),
     parentBlock:
-      parentNode === undefined
-        ? undefined
-        : nodeToBlock(
-            parentNode,
-            editor.schema.blockSchema,
-            editor.schema.inlineContentSchema,
-            editor.schema.styleSchema,
-            editor.blockCache
-          ),
+      parentNode === undefined ? undefined : nodeToBlock(parentNode, pmSchema),
   };
 }
 
-export function setTextCursorPosition<
-  BSchema extends BlockSchema,
-  I extends InlineContentSchema,
-  S extends StyleSchema
->(
-  editor: BlockNoteEditor<BSchema, I, S>,
+export function setTextCursorPosition(
+  tr: Transaction,
   targetBlock: BlockIdentifier,
   placement: "start" | "end" = "start"
 ) {
   const id = typeof targetBlock === "string" ? targetBlock : targetBlock.id;
+  const pmSchema = getPmSchema(tr.doc);
+  const schema = getBlockNoteSchema(pmSchema);
 
-  const posInfo = getNodeById(id, editor._tiptapEditor.state.doc);
+  const posInfo = getNodeById(id, tr.doc);
   if (!posInfo) {
     throw new Error(`Block with ID ${id} not found`);
   }
@@ -103,23 +72,23 @@ export function setTextCursorPosition<
   const info = getBlockInfo(posInfo);
 
   const contentType: "none" | "inline" | "table" =
-    editor.schema.blockSchema[info.blockNoteType]!.content;
+    schema.blockSchema[info.blockNoteType]!.content;
 
   if (info.isBlockContainer) {
     const blockContent = info.blockContent;
     if (contentType === "none") {
-      editor._tiptapEditor.commands.setNodeSelection(blockContent.beforePos);
+      tr.setSelection(NodeSelection.create(tr.doc, blockContent.beforePos));
       return;
     }
 
     if (contentType === "inline") {
       if (placement === "start") {
-        editor._tiptapEditor.commands.setTextSelection(
-          blockContent.beforePos + 1
+        tr.setSelection(
+          TextSelection.create(tr.doc, blockContent.beforePos + 1)
         );
       } else {
-        editor._tiptapEditor.commands.setTextSelection(
-          blockContent.afterPos - 1
+        tr.setSelection(
+          TextSelection.create(tr.doc, blockContent.afterPos - 1)
         );
       }
     } else if (contentType === "table") {
@@ -127,12 +96,12 @@ export function setTextCursorPosition<
         // Need to offset the position as we have to get through the `tableRow`
         // and `tableCell` nodes to get to the `tableParagraph` node we want to
         // set the selection in.
-        editor._tiptapEditor.commands.setTextSelection(
-          blockContent.beforePos + 4
+        tr.setSelection(
+          TextSelection.create(tr.doc, blockContent.beforePos + 4)
         );
       } else {
-        editor._tiptapEditor.commands.setTextSelection(
-          blockContent.afterPos - 4
+        tr.setSelection(
+          TextSelection.create(tr.doc, blockContent.afterPos - 4)
         );
       }
     } else {
@@ -144,6 +113,6 @@ export function setTextCursorPosition<
         ? info.childContainer.node.firstChild!
         : info.childContainer.node.lastChild!;
 
-    setTextCursorPosition(editor, child.attrs.id, placement);
+    setTextCursorPosition(tr, child.attrs.id, placement);
   }
 }

package/src/api/clipboard/fromClipboard/handleFileInsertion.ts

@@ -160,16 +160,14 @@ export async function handleFileInsertion<
           return;
         }
 
-        const posInfo = getNearestBlockPos(
-          editor._tiptapEditor.state.doc,
-          pos.pos
-        );
-
-        insertedBlockId = insertOrUpdateBlock(
-          editor,
-          editor.getBlock(posInfo.node.attrs.id)!,
-          fileBlock
-        );
+        insertedBlockId = editor.transact((tr) => {
+          const posInfo = getNearestBlockPos(tr.doc, pos.pos);
+          return insertOrUpdateBlock(
+            editor,
+            editor.getBlock(posInfo.node.attrs.id)!,
+            fileBlock
+          );
+        });
       } else {
         return;
       }

package/src/api/clipboard/toClipboard/copyExtension.ts

@@ -94,7 +94,7 @@ function fragmentToExternalHTML<
     );
     externalHTML = externalHTMLExporter.exportInlineContent(ic, {});
   } else {
-    const blocks = fragmentToBlocks(selectedFragment, editor.schema);
+    const blocks = fragmentToBlocks(selectedFragment);
     externalHTML = externalHTMLExporter.exportBlocks(blocks, {});
   }
   return externalHTML;
@@ -120,9 +120,9 @@ export function selectedFragmentToHTML<
     "node" in view.state.selection &&
     (view.state.selection.node as Node).type.spec.group === "blockContent"
   ) {
-    editor.dispatch(
-      editor._tiptapEditor.state.tr.setSelection(
-        new NodeSelection(view.state.doc.resolve(view.state.selection.from - 1))
+    editor.transact((tr) =>
+      tr.setSelection(
+        new NodeSelection(tr.doc.resolve(view.state.selection.from - 1))
       )
     );
   }
@@ -251,10 +251,10 @@ export const createCopyToClipboardExtension = <
                 }
 
                 // Expands the selection to the parent `blockContainer` node.
-                editor.dispatch(
-                  editor._tiptapEditor.state.tr.setSelection(
+                editor.transact((tr) =>
+                  tr.setSelection(
                     new NodeSelection(
-                      view.state.doc.resolve(view.state.selection.from - 1)
+                      tr.doc.resolve(view.state.selection.from - 1)
                     )
                   )
                 );

package/src/api/exporters/html/util/serializeBlocksExternalHTML.ts

@@ -43,23 +43,11 @@ export function serializeInlineContentExternalHTML<
   if (!blockContent) {
     throw new Error("blockContent is required");
   } else if (typeof blockContent === "string") {
-    nodes = inlineContentToNodes(
-      [blockContent],
-      editor.pmSchema,
-      editor.schema.styleSchema
-    );
+    nodes = inlineContentToNodes([blockContent], editor.pmSchema);
   } else if (Array.isArray(blockContent)) {
-    nodes = inlineContentToNodes(
-      blockContent,
-      editor.pmSchema,
-      editor.schema.styleSchema
-    );
+    nodes = inlineContentToNodes(blockContent, editor.pmSchema);
   } else if (blockContent.type === "tableContent") {
-    nodes = tableContentToNodes(
-      blockContent,
-      editor.pmSchema,
-      editor.schema.styleSchema
-    );
+    nodes = tableContentToNodes(blockContent, editor.pmSchema);
   } else {
     throw new UnreachableCaseError(blockContent.type);
   }
@@ -130,7 +118,10 @@ function serializeBlock<
 
   const elementFragment = doc.createDocumentFragment();
   if (ret.dom.classList.contains("bn-block-content")) {
-    const blockContentDataAttributes = [...attrs, ...Array.from(ret.dom.attributes)].filter(
+    const blockContentDataAttributes = [
+      ...attrs,
+      ...Array.from(ret.dom.attributes),
+    ].filter(
       (attr) =>
         attr.name.startsWith("data") &&
         attr.name !== "data-content-type" &&

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

@@ -30,25 +30,11 @@ export function serializeInlineContentInternalHTML<
   if (!blockContent) {
     throw new Error("blockContent is required");
   } else if (typeof blockContent === "string") {
-    nodes = inlineContentToNodes(
-      [blockContent],
-      editor.pmSchema,
-      editor.schema.styleSchema,
-      blockType
-    );
+    nodes = inlineContentToNodes([blockContent], editor.pmSchema, blockType);
   } else if (Array.isArray(blockContent)) {
-    nodes = inlineContentToNodes(
-      blockContent,
-      editor.pmSchema,
-      editor.schema.styleSchema,
-      blockType
-    );
+    nodes = inlineContentToNodes(blockContent, editor.pmSchema, blockType);
   } else if (blockContent.type === "tableContent") {
-    nodes = tableContentToNodes(
-      blockContent,
-      editor.pmSchema,
-      editor.schema.styleSchema
-    );
+    nodes = tableContentToNodes(blockContent, editor.pmSchema);
   } else {
     throw new UnreachableCaseError(blockContent.type);
   }

package/src/api/getBlockInfoFromPos.ts

@@ -1,5 +1,5 @@
 import { Node, ResolvedPos } from "prosemirror-model";
-import { EditorState } from "prosemirror-state";
+import { EditorState, Transaction } from "prosemirror-state";
 
 type SingleBlockInfo = {
   node: Node;
@@ -239,3 +239,15 @@ export function getBlockInfoFromSelection(state: EditorState) {
 
   return getBlockInfo(posInfo);
 }
+
+/**
+ * Gets information regarding the ProseMirror nodes that make up a block. The
+ * block chosen is the one currently containing the current ProseMirror
+ * selection.
+ * @param tr The ProseMirror transaction.
+ */
+export function getBlockInfoFromTransaction(tr: Transaction) {
+  const posInfo = getNearestBlockPos(tr.doc, tr.selection.anchor);
+
+  return getBlockInfo(posInfo);
+}

package/src/api/nodeConversions/blockToNode.ts

@@ -19,6 +19,7 @@ import {
 import { getColspan, isPartialTableCell } from "../../util/table.js";
 import { UnreachableCaseError } from "../../util/typescript.js";
 import { getAbsoluteTableCells } from "../blockManipulation/tables/tables.js";
+import { getStyleSchema } from "../pmUtil.js";
 
 /**
  * Convert a StyledText inline element to a
@@ -139,8 +140,8 @@ export function inlineContentToNodes<
 >(
   blockContent: PartialInlineContent<I, S>,
   schema: Schema,
-  styleSchema: S,
-  blockType?: string
+  blockType?: string,
+  styleSchema: S = getStyleSchema(schema)
 ): Node[] {
   const nodes: Node[] = [];
 
@@ -173,7 +174,7 @@ export function tableContentToNodes<
 >(
   tableContent: PartialTableContent<I, S>,
   schema: Schema,
-  styleSchema: StyleSchema
+  styleSchema: StyleSchema = getStyleSchema(schema)
 ): Node[] {
   const rowNodes: Node[] = [];
   // Header rows and columns are used to determine the type of the cell
@@ -222,7 +223,12 @@ export function tableContentToNodes<
         content = schema.text(cell);
       } else if (isPartialTableCell(cell)) {
         if (cell.content) {
-          content = inlineContentToNodes(cell.content, schema, styleSchema);
+          content = inlineContentToNodes(
+            cell.content,
+            schema,
+            "tableParagraph",
+            styleSchema
+          );
         }
         const colspan = getColspan(cell);
 
@@ -234,7 +240,12 @@ export function tableContentToNodes<
           });
         }
       } else {
-        content = inlineContentToNodes(cell, schema, styleSchema);
+        content = inlineContentToNodes(
+          cell,
+          schema,
+          "tableParagraph",
+          styleSchema
+        );
       }
 
       const cellNode = schema.nodes[
@@ -279,16 +290,16 @@ function blockOrInlineContentToContentNode(
     const nodes = inlineContentToNodes(
       [block.content],
       schema,
-      styleSchema,
-      type
+      type,
+      styleSchema
     );
     contentNode = schema.nodes[type].createChecked(block.props, nodes);
   } else if (Array.isArray(block.content)) {
     const nodes = inlineContentToNodes(
       block.content,
       schema,
-      styleSchema,
-      type
+      type,
+      styleSchema
     );
     contentNode = schema.nodes[type].createChecked(block.props, nodes);
   } else if (block.content.type === "tableContent") {
@@ -306,7 +317,7 @@ function blockOrInlineContentToContentNode(
 export function blockToNode(
   block: PartialBlock<any, any, any>,
   schema: Schema,
-  styleSchema: StyleSchema
+  styleSchema: StyleSchema = getStyleSchema(schema)
 ) {
   let id = block.id;