fix: Plain content issues

packages/core/src/api/nodeConversions/blockToNode.ts

@@ -64,7 +64,11 @@ function styledTextToNodes<T extends StyleSchema>(
       ? [...schema.nodes[blockType].allowedMarks(marks)]
       : marks;
 
-  const parseHardBreaks = !blockType || !schema.nodes[blockType].spec.code;
+  // Plain content nodes hold raw text — including newlines —
+  // rather than inline content, so they can't contain `hardBreak` nodes. Keep
+  // newlines as text characters for them instead of splitting into hard breaks.
+  const parseHardBreaks =
+    !blockType || !isPlainContentNodeType(schema, schema.nodes[blockType]);
 
   if (!parseHardBreaks) {
     return styledText.text.length > 0

packages/core/src/api/nodeConversions/nodeToBlock.ts

@@ -371,6 +371,9 @@ export function nodeToCustomInlineContent<
       inlineContentSchema,
       styleSchema,
     ) as any; // TODO: is this safe? could we have Links here that are undesired?
+  } else if (icConfig.content === "plain") {
+    // Plain inline content is a single unstyled string.
+    content = node.textContent as any;
   } else {
     content = undefined;
   }

packages/core/src/api/pmUtil.ts

@@ -54,18 +54,26 @@ export function getBlockCache(schema: Schema) {
 }
 
 /**
- * Whether `nodeType` is a BlockNote block whose content type is `"plain"` — i.e.
- * it holds unstyled text and only allows the non-formatting (`"annotation"`)
- * marks. Resolved semantically from the block schema (the source of truth),
- * reachable from `schema.cached.blockNoteEditor`.
+ * Whether `nodeType` is a BlockNote block or inline content whose content type
+ * is `"plain"` — i.e. it holds unstyled text and only allows the non-formatting
+ * (`"annotation"`) marks. Resolved semantically from the block / inline content
+ * schema (the source of truth), reachable from `schema.cached.blockNoteEditor`.
  *
- * Returns `false` for every non-block / structural node type (`doc`,
- * `blockGroup`, `text`, inline content, table sub-nodes), since those aren't
- * keys in the block schema.
+ * Returns `false` for every other node type (`doc`, `blockGroup`, `text`, table
+ * sub-nodes, and non-plain blocks / inline content), since those aren't plain
+ * content keys in either schema.
  */
 export function isPlainContentNodeType(
   schema: Schema,
   nodeType: NodeType,
 ): boolean {
-  return getBlockSchema(schema)[nodeType.name]?.content === "plain";
+  if (getBlockSchema(schema)[nodeType.name]?.content === "plain") {
+    return true;
+  }
+
+  const inlineContentConfig = getInlineContentSchema(schema)[nodeType.name];
+  return (
+    typeof inlineContentConfig === "object" &&
+    inlineContentConfig.content === "plain"
+  );
 }

packages/core/src/schema/index.ts

@@ -4,6 +4,7 @@ export * from "./blocks/types.js";
 export * from "./inlineContent/createSpec.js";
 export * from "./inlineContent/internal.js";
 export * from "./inlineContent/types.js";
+export * from "./markGroups.js";
 export * from "./propTypes.js";
 export * from "./styles/createSpec.js";
 export * from "./styles/internal.js";

packages/core/src/schema/inlineContent/createSpec.test.ts

@@ -0,0 +1,151 @@
+import { DOMParser as PMDOMParser } from "@tiptap/pm/model";
+import { describe, expect, it } from "vite-plus/test";
+
+import { BlockNoteSchema } from "../../blocks/BlockNoteSchema.js";
+import {
+  defaultBlockSpecs,
+  defaultInlineContentSpecs,
+} from "../../blocks/defaultBlocks.js";
+import { BlockNoteEditor } from "../../editor/BlockNoteEditor.js";
+import { createInlineContentSpec } from "./createSpec.js";
+
+// A minimal "plain" inline content, matched from external HTML by a `parse`
+// function (the `tag: "*"` parse rule).
+const customPlainIC = createInlineContentSpec(
+  {
+    type: "customPlainIC",
+    propSchema: {},
+    content: "plain",
+  },
+  {
+    parse: (el) => (el.classList?.contains("custom-plain-ic") ? {} : undefined),
+    render: () => {
+      const dom = document.createElement("span");
+      const contentDOM = document.createElement("span");
+      dom.append(contentDOM);
+      return { dom, contentDOM };
+    },
+  },
+);
+
+const createEditor = () =>
+  BlockNoteEditor.create({
+    schema: BlockNoteSchema.create({
+      blockSpecs: defaultBlockSpecs,
+      inlineContentSpecs: {
+        ...defaultInlineContentSpecs,
+        customPlainIC,
+      },
+    }),
+  });
+
+describe("plain inline content", () => {
+  it("holds its text as a string in the block model", () => {
+    const editor = createEditor();
+
+    editor.replaceBlocks(editor.document, [
+      {
+        type: "paragraph",
+        content: [
+          {
+            type: "customPlainIC",
+            props: {},
+            content: "hello world",
+          } as any,
+        ],
+      },
+    ]);
+
+    const inlineContent = (editor.document[0] as any).content[0];
+    expect(inlineContent.type).toBe("customPlainIC");
+    expect(inlineContent.content).toBe("hello world");
+
+    editor._tiptapEditor.destroy();
+  });
+
+  it("round-trips a newline in its string content", () => {
+    const editor = createEditor();
+
+    // Plain content holds raw text, so newlines are kept as characters rather
+    // than being split into (disallowed) `hardBreak` nodes.
+    editor.replaceBlocks(editor.document, [
+      {
+        type: "paragraph",
+        content: [
+          {
+            type: "customPlainIC",
+            props: {},
+            content: "first\nsecond",
+          } as any,
+        ],
+      },
+    ]);
+
+    const inlineContent = (editor.document[0] as any).content[0];
+    expect(inlineContent.type).toBe("customPlainIC");
+    expect(inlineContent.content).toBe("first\nsecond");
+
+    editor._tiptapEditor.destroy();
+  });
+
+  it("keeps text and drops formatting marks when parsed", () => {
+    const editor = createEditor();
+
+    const blocks = editor.tryParseHTMLToBlocks(
+      `<p><span class="custom-plain-ic">hello <b>world</b></span></p>`,
+    );
+
+    const inlineContent = (blocks[0] as any).content[0];
+    expect(inlineContent.type).toBe("customPlainIC");
+    expect(inlineContent.content).toBe("hello world");
+
+    editor._tiptapEditor.destroy();
+  });
+
+  it("converts line breaks to newline characters when parsed", () => {
+    const editor = createEditor();
+
+    const blocks = editor.tryParseHTMLToBlocks(
+      `<p><span class="custom-plain-ic">first<br>second</span></p>`,
+    );
+
+    const inlineContent = (blocks[0] as any).content[0];
+    expect(inlineContent.type).toBe("customPlainIC");
+    expect(inlineContent.content).toBe("first\nsecond");
+
+    editor._tiptapEditor.destroy();
+  });
+
+  it("disallows formatting marks but allows annotation marks", () => {
+    const editor = createEditor();
+
+    // Checked at the ProseMirror level because the block model intentionally
+    // represents plain content as a bare string, without marks.
+    const container = document.createElement("div");
+    container.innerHTML = `<p><span class="custom-plain-ic">hello <b>bold</b> <ins data-id="1">inserted</ins></span></p>`;
+    const parsed = PMDOMParser.fromSchema(editor.pmSchema).parse(container, {
+      topNode: editor.pmSchema.nodes["blockGroup"].create(),
+    });
+
+    let plainIC: any;
+    parsed.descendants((node) => {
+      if (node.type.name === "customPlainIC") {
+        plainIC = node;
+        return false;
+      }
+      return true;
+    });
+
+    expect(plainIC).toBeDefined();
+    expect(plainIC.textContent).toBe("hello bold inserted");
+
+    const markNames = new Set<string>();
+    plainIC.forEach((child: any) => {
+      child.marks.forEach((mark: any) => markNames.add(mark.type.name));
+    });
+    expect(markNames.has("insertion")).toBe(true);
+    expect(markNames.has("bold")).toBe(false);
+
+    editor._tiptapEditor.destroy();
+  });
+});

packages/core/src/schema/inlineContent/createSpec.ts

@@ -11,6 +11,7 @@ import { inlineContentToNodes } from "../../api/nodeConversions/blockToNode.js";
 import { nodeToCustomInlineContent } from "../../api/nodeConversions/nodeToBlock.js";
 import type { BlockNoteEditor } from "../../editor/BlockNoteEditor.js";
 import { propsToAttributes } from "../blocks/internal.js";
+import { NON_FORMATTING_MARK_GROUP } from "../markGroups.js";
 import { Props } from "../propTypes.js";
 import { StyleSchema } from "../styles/types.js";
 import {
@@ -148,6 +149,26 @@ function parseInlineContent(el: HTMLElement, schema: Schema) {
   }).content;
 }
 
+// Flattens parsed inline content into text nodes only. "plain" inline content
+// holds text only, so non-text inline nodes are flattened: line breaks become
+// newline characters and other nodes (e.g. mentions) are kept as their text.
+function flattenToText(content: Fragment, schema: Schema) {
+  const textNodes: ProsemirrorNode[] = [];
+  content.forEach((child) => {
+    if (child.isText) {
+      textNodes.push(child);
+    } else {
+      const text =
+        child.type === schema.linebreakReplacement ? "\n" : child.textContent;
+      if (text) {
+        textNodes.push(schema.text(text, child.marks));
+      }
+    }
+  });
+
+  return Fragment.fromArray(textNodes);
+}
+
 export function getInlineContentParseRules<C extends CustomInlineContentConfig>(
   config: C,
   customParseFunction?: CustomInlineContentImplementation<C, any>["parse"],
@@ -164,19 +185,32 @@ export function getInlineContentParseRules<C extends CustomInlineContentConfig>(
   // `parse` function (the second rule). `resolveContentElement` locates the
   // element whose children to parse as a fallback when `parseContent` returns
   // `undefined`.
+  // "plain" inline content always needs `getContent` so its parsed content is
+  // flattened to text (`<br>`/line breaks become newline characters), regardless
+  // of whether a custom `parseContent` is provided — mirroring "plain" blocks.
+  // "styled" inline content only needs it to run a custom `parseContent`.
   const getContent =
-    customParseContentFunction && config.content === "styled"
+    config.content === "plain" ||
+    (customParseContentFunction && config.content === "styled")
       ? (resolveContentElement: (el: HTMLElement) => HTMLElement) =>
           (node: HTMLElement, schema: Schema) => {
-            const result = customParseContentFunction({ el: node, schema });
+            const result = customParseContentFunction?.({ el: node, schema });
 
             // `parseContent` may return `undefined` to fall through to the
             // default inline content parsing.
             if (result !== undefined) {
-              return result;
+              return config.content === "plain"
+                ? flattenToText(result, schema)
+                : result;
             }
 
-            return parseInlineContent(resolveContentElement(node), schema);
+            const parsed = parseInlineContent(
+              resolveContentElement(node),
+              schema,
+            );
+            return config.content === "plain"
+              ? flattenToText(parsed, schema)
+              : parsed;
           }
       : undefined;
 
@@ -230,10 +264,23 @@ export function createInlineContentSpec<
     inline: true,
     group: "inline",
     draggable: inlineContentImplementation.meta?.draggable,
-    selectable: inlineContentConfig.content === "styled",
+    selectable: inlineContentConfig.content !== "none",
     atom: inlineContentConfig.content === "none",
     code: inlineContentImplementation.meta?.code,
-    content: inlineContentConfig.content === "styled" ? "inline*" : "",
+    content:
+      inlineContentConfig.content === "styled"
+        ? "inline*"
+        : inlineContentConfig.content === "plain"
+          ? "text*"
+          : "",
+    // "plain" inline content holds unstyled text, so it disallows formatting
+    // marks (mirroring "plain" blocks). It still allows the non-formatting marks
+    // (comments and suggestions/diffs), which annotate content without changing
+    // it and are ignored by the content model.
+    marks:
+      inlineContentConfig.content === "plain"
+        ? NON_FORMATTING_MARK_GROUP
+        : undefined,
 
     addAttributes() {
       return propsToAttributes(inlineContentConfig.propSchema);

packages/core/src/schema/inlineContent/internal.ts

@@ -105,7 +105,12 @@ export function createInlineContentSpecFromTipTapNode<
     {
       type: node.name as T["name"],
       propSchema,
-      content: node.config.content === "inline*" ? "styled" : "none",
+      content:
+        node.config.content === "inline*"
+          ? "styled"
+          : node.config.content === "text*"
+            ? "plain"
+            : "none",
     },
     // Cast needed because `implementation` is typed against the generic
     // `CustomInlineContentConfig`, while `createInternalInlineContentSpec`
@@ -117,7 +122,7 @@ export function createInlineContentSpecFromTipTapNode<
     } as unknown as InlineContentImplementation<{
       type: T["name"];
       propSchema: P;
-      content: "styled" | "none";
+      content: "styled" | "none" | "plain";
     }>,
   );
 }

packages/diagram-block/src/block/createReactDiagramBlockSpec.test.tsx

@@ -156,9 +156,16 @@ describe("Diagram block source popup", () => {
     await flush();
 
     // The selection spans exactly the block's source, not the document.
+    // Newlines are hard break nodes in the ProseMirror doc, so extract them as
+    // "\n" to match the block's source (where `getBlock` renders them as such).
     const selection = editor.prosemirrorState.selection;
     expect(
-      editor.prosemirrorState.doc.textBetween(selection.from, selection.to),
+      editor.prosemirrorState.doc.textBetween(
+        selection.from,
+        selection.to,
+        undefined,
+        (leafNode) => (leafNode.type.name === "hardBreak" ? "\n" : ""),
+      ),
     ).toBe(source());
     expect(isPopupOpen()).toBe(true);
   });