@blocknote/core 0.15.11 → 0.17.0

package/src/api/nodeConversions/{nodeConversions.ts → nodeToBlock.ts}

@@ -1,6 +1,6 @@
-import { Mark, Node, Schema } from "@tiptap/pm/model";
+import { Mark, Node } from "@tiptap/pm/model";
 
-import UniqueID from "../../extensions/UniqueID/UniqueID";
+import UniqueID from "../../extensions/UniqueID/UniqueID.js";
 import type {
   BlockSchema,
   CustomInlineContentConfig,
@@ -8,266 +8,23 @@ import type {
   InlineContent,
   InlineContentFromConfig,
   InlineContentSchema,
-  PartialCustomInlineContentFromConfig,
-  PartialInlineContent,
-  PartialLink,
-  PartialTableContent,
   StyleSchema,
-  StyledText,
   Styles,
   TableContent,
-} from "../../schema";
-import { getBlockInfo } from "../getBlockInfoFromPos";
+} from "../../schema/index.js";
+import { getBlockInfoWithManualOffset } from "../getBlockInfoFromPos.js";
 
-import type { Block, PartialBlock } from "../../blocks/defaultBlocks";
+import type { Block } from "../../blocks/defaultBlocks.js";
 import {
   isLinkInlineContent,
-  isPartialLinkInlineContent,
   isStyledTextInlineContent,
-} from "../../schema/inlineContent/types";
-import { UnreachableCaseError } from "../../util/typescript";
-
-/**
- * Convert a StyledText inline element to a
- * prosemirror text node with the appropriate marks
- */
-function styledTextToNodes<T extends StyleSchema>(
-  styledText: StyledText<T>,
-  schema: Schema,
-  styleSchema: T
-): Node[] {
-  const marks: Mark[] = [];
-
-  for (const [style, value] of Object.entries(styledText.styles)) {
-    const config = styleSchema[style];
-    if (!config) {
-      throw new Error(`style ${style} not found in styleSchema`);
-    }
-
-    if (config.propSchema === "boolean") {
-      marks.push(schema.mark(style));
-    } else if (config.propSchema === "string") {
-      marks.push(schema.mark(style, { stringValue: value }));
-    } else {
-      throw new UnreachableCaseError(config.propSchema);
-    }
-  }
-
-  return (
-    styledText.text
-      // Splits text & line breaks.
-      .split(/(\n)/g)
-      // If the content ends with a line break, an empty string is added to the
-      // end, which this removes.
-      .filter((text) => text.length > 0)
-      // Converts text & line breaks to nodes.
-      .map((text) => {
-        if (text === "\n") {
-          return schema.nodes["hardBreak"].create();
-        } else {
-          return schema.text(text, marks);
-        }
-      })
-  );
-}
-
-/**
- * Converts a Link inline content element to
- * prosemirror text nodes with the appropriate marks
- */
-function linkToNodes(
-  link: PartialLink<StyleSchema>,
-  schema: Schema,
-  styleSchema: StyleSchema
-): Node[] {
-  const linkMark = schema.marks.link.create({
-    href: link.href,
-  });
-
-  return styledTextArrayToNodes(link.content, schema, styleSchema).map(
-    (node) => {
-      if (node.type.name === "text") {
-        return node.mark([...node.marks, linkMark]);
-      }
-
-      if (node.type.name === "hardBreak") {
-        return node;
-      }
-      throw new Error("unexpected node type");
-    }
-  );
-}
-
-/**
- * Converts an array of StyledText inline content elements to
- * prosemirror text nodes with the appropriate marks
- */
-function styledTextArrayToNodes<S extends StyleSchema>(
-  content: string | StyledText<S>[],
-  schema: Schema,
-  styleSchema: S
-): Node[] {
-  const nodes: Node[] = [];
-
-  if (typeof content === "string") {
-    nodes.push(
-      ...styledTextToNodes(
-        { type: "text", text: content, styles: {} },
-        schema,
-        styleSchema
-      )
-    );
-    return nodes;
-  }
-
-  for (const styledText of content) {
-    nodes.push(...styledTextToNodes(styledText, schema, styleSchema));
-  }
-  return nodes;
-}
-
-/**
- * converts an array of inline content elements to prosemirror nodes
- */
-export function inlineContentToNodes<
-  I extends InlineContentSchema,
-  S extends StyleSchema
->(
-  blockContent: PartialInlineContent<I, S>,
-  schema: Schema,
-  styleSchema: S
-): Node[] {
-  const nodes: Node[] = [];
-
-  for (const content of blockContent) {
-    if (typeof content === "string") {
-      nodes.push(...styledTextArrayToNodes(content, schema, styleSchema));
-    } else if (isPartialLinkInlineContent(content)) {
-      nodes.push(...linkToNodes(content, schema, styleSchema));
-    } else if (isStyledTextInlineContent(content)) {
-      nodes.push(...styledTextArrayToNodes([content], schema, styleSchema));
-    } else {
-      nodes.push(
-        blockOrInlineContentToContentNode(content, schema, styleSchema)
-      );
-    }
-  }
-  return nodes;
-}
-
-/**
- * converts an array of inline content elements to prosemirror nodes
- */
-export function tableContentToNodes<
-  I extends InlineContentSchema,
-  S extends StyleSchema
->(
-  tableContent: PartialTableContent<I, S>,
-  schema: Schema,
-  styleSchema: StyleSchema
-): Node[] {
-  const rowNodes: Node[] = [];
-
-  for (const row of tableContent.rows) {
-    const columnNodes: Node[] = [];
-    for (const cell of row.cells) {
-      let pNode: Node;
-      if (!cell) {
-        pNode = schema.nodes["tableParagraph"].create({});
-      } else if (typeof cell === "string") {
-        pNode = schema.nodes["tableParagraph"].create({}, schema.text(cell));
-      } else {
-        const textNodes = inlineContentToNodes(cell, schema, styleSchema);
-        pNode = schema.nodes["tableParagraph"].create({}, textNodes);
-      }
-
-      const cellNode = schema.nodes["tableCell"].create({}, pNode);
-      columnNodes.push(cellNode);
-    }
-    const rowNode = schema.nodes["tableRow"].create({}, columnNodes);
-    rowNodes.push(rowNode);
-  }
-  return rowNodes;
-}
-
-function blockOrInlineContentToContentNode(
-  block:
-    | PartialBlock<any, any, any>
-    | PartialCustomInlineContentFromConfig<any, any>,
-  schema: Schema,
-  styleSchema: StyleSchema
-) {
-  let contentNode: Node;
-  let type = block.type;
-
-  // TODO: needed? came from previous code
-  if (type === undefined) {
-    type = "paragraph";
-  }
-
-  if (!schema.nodes[type]) {
-    throw new Error(`node type ${type} not found in schema`);
-  }
-
-  if (!block.content) {
-    contentNode = schema.nodes[type].create(block.props);
-  } else if (typeof block.content === "string") {
-    const nodes = inlineContentToNodes([block.content], schema, styleSchema);
-    contentNode = schema.nodes[type].create(block.props, nodes);
-  } else if (Array.isArray(block.content)) {
-    const nodes = inlineContentToNodes(block.content, schema, styleSchema);
-    contentNode = schema.nodes[type].create(block.props, nodes);
-  } else if (block.content.type === "tableContent") {
-    const nodes = tableContentToNodes(block.content, schema, styleSchema);
-    contentNode = schema.nodes[type].create(block.props, nodes);
-  } else {
-    throw new UnreachableCaseError(block.content.type);
-  }
-  return contentNode;
-}
-/**
- * Converts a BlockNote block to a TipTap node.
- */
-export function blockToNode(
-  block: PartialBlock<any, any, any>,
-  schema: Schema,
-  styleSchema: StyleSchema
-) {
-  let id = block.id;
-
-  if (id === undefined) {
-    id = UniqueID.options.generateID();
-  }
-
-  const contentNode = blockOrInlineContentToContentNode(
-    block,
-    schema,
-    styleSchema
-  );
-
-  const children: Node[] = [];
-
-  if (block.children) {
-    for (const child of block.children) {
-      children.push(blockToNode(child, schema, styleSchema));
-    }
-  }
-
-  const groupNode = schema.nodes["blockGroup"].create({}, children);
-
-  return schema.nodes["blockContainer"].create(
-    {
-      id: id,
-      ...block.props,
-    },
-    children.length > 0 ? [contentNode, groupNode] : contentNode
-  );
-}
+} from "../../schema/inlineContent/types.js";
+import { UnreachableCaseError } from "../../util/typescript.js";
 
 /**
  * Converts an internal (prosemirror) table node contentto a BlockNote Tablecontent
  */
-function contentNodeToTableContent<
+export function contentNodeToTableContent<
   I extends InlineContentSchema,
   S extends StyleSchema
 >(contentNode: Node, inlineContentSchema: I, styleSchema: S) {
@@ -566,9 +323,10 @@ export function nodeToBlock<
     return cachedBlock;
   }
 
-  const blockInfo = getBlockInfo(node);
+  const { blockContainer, blockContent, blockGroup } =
+    getBlockInfoWithManualOffset(node, 0);
 
-  let id = blockInfo.id;
+  let id = blockContainer.node.attrs.id;
 
   // Only used for blocks converted from other formats.
   if (id === null) {
@@ -578,13 +336,13 @@ export function nodeToBlock<
   const props: any = {};
   for (const [attr, value] of Object.entries({
     ...node.attrs,
-    ...blockInfo.contentNode.attrs,
+    ...blockContent.node.attrs,
   })) {
-    const blockSpec = blockSchema[blockInfo.contentType.name];
+    const blockSpec = blockSchema[blockContent.node.type.name];
 
     if (!blockSpec) {
       throw Error(
-        "Block is of an unrecognized type: " + blockInfo.contentType.name
+        "Block is of an unrecognized type: " + blockContent.node.type.name
       );
     }
 
@@ -595,32 +353,32 @@ export function nodeToBlock<
     }
   }
 
-  const blockConfig = blockSchema[blockInfo.contentType.name];
+  const blockConfig = blockSchema[blockContent.node.type.name];
 
   const children: Block<BSchema, I, S>[] = [];
-  for (let i = 0; i < blockInfo.numChildBlocks; i++) {
+  blockGroup?.node.forEach((child) => {
     children.push(
       nodeToBlock(
-        node.lastChild!.child(i),
+        child,
         blockSchema,
         inlineContentSchema,
         styleSchema,
         blockCache
       )
     );
-  }
+  });
 
   let content: Block<any, any, any>["content"];
 
   if (blockConfig.content === "inline") {
     content = contentNodeToInlineContent(
-      blockInfo.contentNode,
+      blockContent.node,
       inlineContentSchema,
       styleSchema
     );
   } else if (blockConfig.content === "table") {
     content = contentNodeToTableContent(
-      blockInfo.contentNode,
+      blockContent.node,
       inlineContentSchema,
       styleSchema
     );

package/src/api/parsers/html/parseHTML.test.ts

@@ -1,21 +1,18 @@
+import * as pmView from "prosemirror-view";
 import { describe, expect, it } from "vitest";
-import { BlockNoteEditor } from "../../..";
-import { nestedListsToBlockNoteStructure } from "./util/nestedLists";
+import { BlockNoteEditor } from "../../../index.js";
+import { nestedListsToBlockNoteStructure } from "./util/nestedLists.js";
 
 async function parseHTMLAndCompareSnapshots(
   html: string,
   snapshotName: string
 ) {
-  // use a dynamic import because we want to access
-  // __parseFromClipboard which is not exposed in types
-  const view: any = await import("prosemirror-view");
-
   const editor = BlockNoteEditor.create();
   const div = document.createElement("div");
   editor.mount(div);
   const blocks = await editor.tryParseHTMLToBlocks(html);
 
-  const snapshotPath = "./__snapshots__/paste/" + snapshotName + ".json";
+  const snapshotPath = "./__snapshots__/" + snapshotName + ".json";
   expect(JSON.stringify(blocks, undefined, 2)).toMatchFileSnapshot(
     snapshotPath
   );
@@ -34,7 +31,7 @@ async function parseHTMLAndCompareSnapshots(
   (window as any).__TEST_OPTIONS.mockID = 0; // reset id counter
   const htmlNode = nestedListsToBlockNoteStructure(html);
 
-  const slice = view.__parseFromClipboard(
+  const slice = (pmView as any).__parseFromClipboard(
     editor.prosemirrorView,
     "",
     htmlNode.innerHTML,

package/src/api/parsers/html/parseHTML.ts

@@ -1,9 +1,13 @@
 import { DOMParser, Schema } from "prosemirror-model";
-import { BlockSchema, InlineContentSchema, StyleSchema } from "../../../schema";
+import {
+  BlockSchema,
+  InlineContentSchema,
+  StyleSchema,
+} from "../../../schema/index.js";
 
-import { Block } from "../../../blocks/defaultBlocks";
-import { nodeToBlock } from "../../nodeConversions/nodeConversions";
-import { nestedListsToBlockNoteStructure } from "./util/nestedLists";
+import { Block } from "../../../blocks/defaultBlocks.js";
+import { nodeToBlock } from "../../nodeConversions/nodeToBlock.js";
+import { nestedListsToBlockNoteStructure } from "./util/nestedLists.js";
 export async function HTMLToBlocks<
   BSchema extends BlockSchema,
   I extends InlineContentSchema,

package/src/api/parsers/html/util/nestedLists.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from "vitest";
-import { initializeESMDependencies } from "../../../../util/esmDependencies";
-import { nestedListsToBlockNoteStructure } from "./nestedLists";
+import { initializeESMDependencies } from "../../../../util/esmDependencies.js";
+import { nestedListsToBlockNoteStructure } from "./nestedLists.js";
 
 async function testHTML(html: string) {
   const deps = await initializeESMDependencies();