fix: parsing priority for custom inline content and styles (#2119)

Author: matthewlipski

packages/core/src/extensions/BackgroundColor/BackgroundColorMark.ts

@@ -81,6 +81,8 @@ export type CustomInlineContentImplementation<
         contentDOM?: HTMLElement;
       }
     | undefined;
+
+  runsBefore?: string[];
 };
 
 export function getInlineContentParseRules<C extends CustomInlineContentConfig>(
@@ -220,6 +222,7 @@ export function createInlineContentSpec<
     node,
     inlineContentConfig.propSchema,
     {
+      ...inlineContentImplementation,
       toExternalHTML: inlineContentImplementation.toExternalHTML,
       render(inlineContent, updateInlineContent, editor) {
         const output = inlineContentImplementation.render(

packages/core/src/extensions/TextColor/TextColorMark.ts

@@ -43,6 +43,7 @@ export type InlineContentImplementation<T extends InlineContentConfig> =
           ignoreMutation?: (mutation: ViewMutationRecord) => boolean;
           destroy?: () => void;
         };
+        runsBefore?: string[];
       };
 
 export type InlineContentSchemaWithInlineContent<

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

@@ -84,8 +84,12 @@ export class CustomBlockNoteSchema<
     const defaultSet = new Set<string>();
     dag.set("default", defaultSet);
 
-    for (const [key, specDef] of Object.entries(this.opts.blockSpecs)) {
-      if (specDef.implementation.runsBefore) {
+    for (const [key, specDef] of Object.entries({
+      ...this.opts.blockSpecs,
+      ...this.opts.inlineContentSpecs,
+      ...this.opts.styleSpecs,
+    })) {
+      if (specDef.implementation?.runsBefore) {
         dag.set(key, new Set(specDef.implementation.runsBefore));
       } else {
         defaultSet.add(key);
@@ -130,19 +134,58 @@ export class CustomBlockNoteSchema<
         : never;
     };
 
+    const inlineContentSpecs = Object.fromEntries(
+      Object.entries(this.opts.inlineContentSpecs).map(
+        ([key, inlineContentSpec]) => {
+          // Case for text and links.
+          if (typeof inlineContentSpec.config !== "object") {
+            return [key, inlineContentSpec];
+          }
+
+          return [
+            key,
+            {
+              ...inlineContentSpec,
+              implementation: {
+                ...inlineContentSpec.implementation,
+                node: inlineContentSpec.implementation?.node.extend({
+                  priority: getPriority(key),
+                }),
+              },
+            },
+          ];
+        },
+      ),
+    ) as InlineContentSpecs;
+
+    const styleSpecs = Object.fromEntries(
+      Object.entries(this.opts.styleSpecs).map(([key, styleSpec]) => [
+        key,
+        {
+          ...styleSpec,
+          implementation: {
+            ...styleSpec.implementation,
+            mark: styleSpec.implementation?.mark.extend({
+              priority: getPriority(key),
+            }),
+          },
+        },
+      ]),
+    ) as StyleSpecs;
+
     return {
       blockSpecs,
       blockSchema: Object.fromEntries(
         Object.entries(blockSpecs).map(([key, blockDef]) => {
           return [key, blockDef.config];
         }),
       ) as any,
-      inlineContentSpecs: removeUndefined(this.opts.inlineContentSpecs),
-      styleSpecs: removeUndefined(this.opts.styleSpecs),
+      inlineContentSpecs: removeUndefined(inlineContentSpecs),
+      styleSpecs: removeUndefined(styleSpecs),
       inlineContentSchema: getInlineContentSchemaFromSpecs(
-        this.opts.inlineContentSpecs,
+        inlineContentSpecs,
       ) as any,
-      styleSchema: getStyleSchemaFromSpecs(this.opts.styleSpecs) as any,
+      styleSchema: getStyleSchemaFromSpecs(styleSpecs) as any,
     };
   }
 

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

@@ -22,6 +22,7 @@ export type CustomStyleImplementation<T extends StyleConfig> = {
   parse?: (
     element: HTMLElement,
   ) => (T["propSchema"] extends "boolean" ? true : string) | undefined;
+  runsBefore?: string[];
 };
 
 export function getStyleParseRules<T extends StyleConfig>(
@@ -46,6 +47,10 @@ export function getStyleParseRules<T extends StyleConfig>(
   if (customParseFunction) {
     rules.push({
       tag: "*",
+      // By default, styles can overlap each other, so the rules should not
+      // completely consume the element they parse (which can have multiple
+      // styles).
+      consuming: false,
       getAttrs(node: string | HTMLElement) {
         if (typeof node === "string") {
           return false;
@@ -107,6 +112,7 @@ export function createStyleSpec<const T extends StyleConfig>(
   });
 
   return createInternalStyleSpec(styleConfig, {
+    ...styleImplementation,
     mark,
     render: (value) => {
       const renderResult = styleImplementation.render(value as any);

packages/core/src/schema/schema.ts

@@ -28,6 +28,7 @@ export type StyleImplementation<T extends StyleConfig> = {
     dom: HTMLElement;
     contentDOM?: HTMLElement;
   };
+  runsBefore?: string[];
 };
 
 // Container for both the config and implementation of a Style,

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

@@ -233,6 +233,7 @@ export function createReactInlineContentSpec<
   return createInternalInlineContentSpec(
     inlineContentConfig as CustomInlineContentConfig,
     {
+      ...inlineContentImplementation,
       node,
       render(inlineContent, updateInlineContent, editor) {
         const Content = inlineContentImplementation.render;

packages/core/src/schema/styles/types.ts

@@ -23,6 +23,7 @@ export type ReactCustomStyleImplementation<T extends StyleConfig> = {
     contentRef: (el: HTMLElement | null) => void;
     editor: BlockNoteEditor<any, any, any>;
   }>;
+  runsBefore?: string[];
 };
 
 // A function to create custom block for API consumers
@@ -116,6 +117,7 @@ export function createReactStyleSpec<T extends StyleConfig>(
   });
 
   return createInternalStyleSpec(styleConfig, {
+    ...styleImplementation,
     mark,
     render(value, editor) {
       const Content = styleImplementation.render;