Bugfix/code block in parentheses

packages/core/src/BlockNoteEditor.ts

@@ -202,16 +202,17 @@ export class BlockNoteEditor<BSchema extends BlockSchema = DefaultBlockSchema> {
 
     this.schema = newOptions.blockSchema;
 
-    const initialContent =
+
+    const defaultInitialContent = [
+    {
+      type: "paragraph",
+      id: UniqueID.options.generateID(),
+    },
+  ];
+
+  let initialContent =
       newOptions.initialContent ||
-      (options.collaboration
-        ? undefined
-        : [
-            {
-              type: "paragraph",
-              id: UniqueID.options.generateID(),
-            },
-          ]);
+      (options.collaboration ? undefined : defaultInitialContent);
 
     const tiptapOptions: EditorOptions = {
       ...blockNoteTipTapOptions,
@@ -225,8 +226,43 @@ export class BlockNoteEditor<BSchema extends BlockSchema = DefaultBlockSchema> {
           // when using collaboration
           return;
         }
-        // we have to set the initial content here, because now we can use the editor schema
-        // which has been created at this point
+        if (typeof initialContent === "string") {
+          console.error(
+            "Invalid initialContent: Expected an array of PartialBlock, but received a string.",
+            "If this string is a JSON of the initial content, please ensure to parse it before passing it as initialContent.",
+            "If a string was passed intentionally, please convert it to the appropriate format."
+          );
+          initialContent = defaultInitialContent;
+        } else if (!Array.isArray(initialContent)) {
+          // Check if the processedInitialContent is an array of PartialBlock
+          console.error(
+            "Invalid initialContent: Expected an array of PartialBlock, received",
+            initialContent
+          );
+          initialContent = defaultInitialContent;
+        } else {
+          for (const block of initialContent) {
+            if (typeof block !== "object" || block === null) {
+              console.error(
+                "Invalid block in initialContent: Expected an object of type PartialBlock, received",
+                block
+              );
+              initialContent = defaultInitialContent;
+              break;
+            } else if (
+              !block.hasOwnProperty("type") ||
+              !block.hasOwnProperty("id")
+            ) {
+              console.error(
+                "Invalid block in initialContent: Block is missing required properties 'type' and 'id'",
+                block
+              );
+              initialContent = defaultInitialContent;
+              break;
+            }
+          }
+        }
+
         const schema = editor.editor.schema;
         const ic = initialContent.map((block) => blockToNode(block, schema));
 
@@ -238,6 +274,7 @@ export class BlockNoteEditor<BSchema extends BlockSchema = DefaultBlockSchema> {
         // override the initialcontent
         editor.editor.options.content = root.toJSON();
       },
+
       onUpdate: () => {
         // This seems to be necessary due to a bug in TipTap:
         // https://github.com/ueberdosis/tiptap/issues/2583

packages/core/src/BlockNoteExtensions.ts

@@ -3,7 +3,9 @@ import { Extensions, extensions } from "@tiptap/core";
 import { BlockNoteEditor } from "./BlockNoteEditor";
 
 import { Bold } from "@tiptap/extension-bold";
-import { Code } from "@tiptap/extension-code";
+// import { Code } from "@tiptap/extension-code";
+import { CustomCodeExtension } from "./extensions/CustomCode/CustomCodeExtension";
+
 import Collaboration from "@tiptap/extension-collaboration";
 import CollaborationCursor from "@tiptap/extension-collaboration-cursor";
 import { Dropcursor } from "@tiptap/extension-dropcursor";
@@ -79,7 +81,8 @@ export const getBlockNoteExtensions = <BSchema extends BlockSchema>(opts: {
 
     // marks:
     Bold,
-    Code,
+    // Code,
+    CustomCodeExtension,
     Italic,
     Strike,
     Underline,

packages/core/src/extensions/CustomCode/CustomCodeExtension.ts

@@ -0,0 +1,119 @@
+import {
+  Mark,
+  markInputRule,
+  markPasteRule,
+  mergeAttributes,
+} from "@tiptap/core";
+
+export interface CodeOptions {
+  HTMLAttributes: Record<string, any>;
+}
+
+declare module "@tiptap/core" {
+  interface Commands<ReturnType> {
+    code: {
+      /**
+       * Set a code mark
+       */
+      setCode: () => ReturnType;
+      /**
+       * Toggle inline code
+       */
+      toggleCode: () => ReturnType;
+      /**
+       * Unset a code mark
+       */
+      unsetCode: () => ReturnType;
+    };
+  }
+}
+
+/**
+ * Regular expressions to match inline code blocks enclosed in backticks.
+ * Original one from @tiptap/extension-code was:
+ *
+ *  inputRegex = /(?:^|\s)((?:`)((?:[^`]+))(?:`))$/
+ *  pasteRegex = /(?:^|\s)((?:`)((?:[^`]+))(?:`))/g
+ *
+ *  The edited regex below fixes this issue: https://github.com/TypeCellOS/BlockNote/issues/338
+ *  It matches:
+ *     - An opening backtick, followed by
+ *     - Any text that doesn't include a backtick (captured for marking), followed by
+ *     - A closing backtick.
+ *  This ensures that any text between backticks is formatted as code,
+ *  regardless of the surrounding characters (exception being another backtick).
+ */
+export const inputRegex = /(?<!`)`([^`]+)`(?!`)/;
+export const pasteRegex = /(?<!`)`([^`]+)`(?!`)/g;
+
+export const CustomCodeExtension = Mark.create<CodeOptions>({
+  name: "code",
+
+  addOptions() {
+    return {
+      HTMLAttributes: {},
+    };
+  },
+
+  excludes: "_",
+
+  code: true,
+
+  exitable: true,
+
+  parseHTML() {
+    return [{ tag: "code" }];
+  },
+
+  renderHTML({ HTMLAttributes }) {
+    return [
+      "code",
+      mergeAttributes(this.options.HTMLAttributes, HTMLAttributes),
+      0,
+    ];
+  },
+
+  addCommands() {
+    return {
+      setCode:
+        () =>
+        ({ commands }) => {
+          return commands.setMark(this.name);
+        },
+      toggleCode:
+        () =>
+        ({ commands }) => {
+          return commands.toggleMark(this.name);
+        },
+      unsetCode:
+        () =>
+        ({ commands }) => {
+          return commands.unsetMark(this.name);
+        },
+    };
+  },
+
+  addKeyboardShortcuts() {
+    return {
+      "Mod-e": () => this.editor.commands.toggleCode(),
+    };
+  },
+
+  addInputRules() {
+    return [
+      markInputRule({
+        find: inputRegex,
+        type: this.type,
+      }),
+    ];
+  },
+
+  addPasteRules() {
+    return [
+      markPasteRule({
+        find: pasteRegex,
+        type: this.type,
+      }),
+    ];
+  },
+});