fix: add support for priority and nested extension for getSchema

packages/core/src/ExtensionManager.ts

@@ -6,7 +6,7 @@ import { Plugin } from 'prosemirror-state'
 import { Editor } from './Editor'
 import { Extensions, RawCommands, AnyConfig } from './types'
 import getExtensionField from './helpers/getExtensionField'
-import getSchema from './helpers/getSchema'
+import getSchemaByResolvedExtensions from './helpers/getSchemaByResolvedExtensions'
 import getSchemaTypeByName from './helpers/getSchemaTypeByName'
 import getNodeType from './helpers/getNodeType'
 import splitExtensions from './helpers/splitExtensions'
@@ -27,8 +27,8 @@ export default class ExtensionManager {
 
   constructor(extensions: Extensions, editor: Editor) {
     this.editor = editor
-    this.extensions = this.sort(this.flatten(extensions))
+    this.extensions = ExtensionManager.resolve(extensions)
-    this.schema = getSchema(this.extensions)
+    this.schema = getSchemaByResolvedExtensions(this.extensions)
 
     this.extensions.forEach(extension => {
       const context = {
@@ -128,13 +128,16 @@ export default class ExtensionManager {
     })
   }
 
-  private flatten(extensions: Extensions): Extensions {
+  static resolve(extensions: Extensions): Extensions {
+    return ExtensionManager.sort(ExtensionManager.flatten(extensions))
+  }
+
+  static flatten(extensions: Extensions): Extensions {
     return extensions
       .map(extension => {
         const context = {
           name: extension.name,
           options: extension.options,
-          editor: this.editor,
         }
 
         const addExtensions = getExtensionField<AnyConfig['addExtensions']>(
@@ -153,7 +156,7 @@ export default class ExtensionManager {
       .flat(10)
   }
 
-  private sort(extensions: Extensions): Extensions {
+  static sort(extensions: Extensions): Extensions {
     const defaultPriority = 100
 
     return extensions.sort((a, b) => {

packages/core/src/helpers/getSchema.ts

@@ -1,138 +1,10 @@
-import { NodeSpec, MarkSpec, Schema } from 'prosemirror-model'
+import { Schema } from 'prosemirror-model'
-import { AnyConfig, Extensions } from '../types'
+import getSchemaByResolvedExtensions from './getSchemaByResolvedExtensions'
-import { NodeConfig, MarkConfig } from '..'
+import ExtensionManager from '../ExtensionManager'
-import splitExtensions from './splitExtensions'
+import { Extensions } from '../types'
-import getAttributesFromExtensions from './getAttributesFromExtensions'
-import getRenderedAttributes from './getRenderedAttributes'
-import isEmptyObject from '../utilities/isEmptyObject'
-import injectExtensionAttributesToParseRule from './injectExtensionAttributesToParseRule'
-import callOrReturn from '../utilities/callOrReturn'
-import getExtensionField from './getExtensionField'
-
-function cleanUpSchemaItem<T>(data: T) {
-  return Object.fromEntries(Object.entries(data).filter(([key, value]) => {
-    if (key === 'attrs' && isEmptyObject(value)) {
-      return false
-    }
-
-    return value !== null && value !== undefined
-  })) as T
-}
 
 export default function getSchema(extensions: Extensions): Schema {
-  const allAttributes = getAttributesFromExtensions(extensions)
+  const resolvedExtensions = ExtensionManager.resolve(extensions)
-  const { nodeExtensions, markExtensions } = splitExtensions(extensions)
-  const topNode = nodeExtensions.find(extension => getExtensionField(extension, 'topNode'))?.name
 
-  const nodes = Object.fromEntries(nodeExtensions.map(extension => {
+  return getSchemaByResolvedExtensions(resolvedExtensions)
-    const extensionAttributes = allAttributes.filter(attribute => attribute.type === extension.name)
-    const context = {
-      name: extension.name,
-      options: extension.options,
-    }
-
-    const extraNodeFields = extensions.reduce((fields, e) => {
-      const extendNodeSchema = getExtensionField<AnyConfig['extendNodeSchema']>(
-        e,
-        'extendNodeSchema',
-        context,
-      )
-
-      return {
-        ...fields,
-        ...(extendNodeSchema ? extendNodeSchema(extension) : {}),
-      }
-    }, {})
-
-    const schema: NodeSpec = cleanUpSchemaItem({
-      ...extraNodeFields,
-      content: callOrReturn(getExtensionField<NodeConfig['content']>(extension, 'content', context)),
-      marks: callOrReturn(getExtensionField<NodeConfig['marks']>(extension, 'marks', context)),
-      group: callOrReturn(getExtensionField<NodeConfig['group']>(extension, 'group', context)),
-      inline: callOrReturn(getExtensionField<NodeConfig['inline']>(extension, 'inline', context)),
-      atom: callOrReturn(getExtensionField<NodeConfig['atom']>(extension, 'atom', context)),
-      selectable: callOrReturn(getExtensionField<NodeConfig['selectable']>(extension, 'selectable', context)),
-      draggable: callOrReturn(getExtensionField<NodeConfig['draggable']>(extension, 'draggable', context)),
-      code: callOrReturn(getExtensionField<NodeConfig['code']>(extension, 'code', context)),
-      defining: callOrReturn(getExtensionField<NodeConfig['defining']>(extension, 'defining', context)),
-      isolating: callOrReturn(getExtensionField<NodeConfig['isolating']>(extension, 'isolating', context)),
-      attrs: Object.fromEntries(extensionAttributes.map(extensionAttribute => {
-        return [extensionAttribute.name, { default: extensionAttribute?.attribute?.default }]
-      })),
-    })
-
-    const parseHTML = callOrReturn(getExtensionField<NodeConfig['parseHTML']>(extension, 'parseHTML', context))
-
-    if (parseHTML) {
-      schema.parseDOM = parseHTML
-        .map(parseRule => injectExtensionAttributesToParseRule(parseRule, extensionAttributes))
-    }
-
-    const renderHTML = getExtensionField<NodeConfig['renderHTML']>(extension, 'renderHTML', context)
-
-    if (renderHTML) {
-      schema.toDOM = node => renderHTML({
-        node,
-        HTMLAttributes: getRenderedAttributes(node, extensionAttributes),
-      })
-    }
-
-    return [extension.name, schema]
-  }))
-
-  const marks = Object.fromEntries(markExtensions.map(extension => {
-    const extensionAttributes = allAttributes.filter(attribute => attribute.type === extension.name)
-    const context = {
-      name: extension.name,
-      options: extension.options,
-    }
-
-    const extraMarkFields = extensions.reduce((fields, e) => {
-      const extendMarkSchema = getExtensionField<AnyConfig['extendMarkSchema']>(
-        e,
-        'extendMarkSchema',
-        context,
-      )
-
-      return {
-        ...fields,
-        ...(extendMarkSchema ? extendMarkSchema(extension) : {}),
-      }
-    }, {})
-
-    const schema: MarkSpec = cleanUpSchemaItem({
-      ...extraMarkFields,
-      inclusive: callOrReturn(getExtensionField<NodeConfig['inclusive']>(extension, 'inclusive', context)),
-      excludes: callOrReturn(getExtensionField<NodeConfig['excludes']>(extension, 'excludes', context)),
-      group: callOrReturn(getExtensionField<NodeConfig['group']>(extension, 'group', context)),
-      spanning: callOrReturn(getExtensionField<NodeConfig['spanning']>(extension, 'spanning', context)),
-      attrs: Object.fromEntries(extensionAttributes.map(extensionAttribute => {
-        return [extensionAttribute.name, { default: extensionAttribute?.attribute?.default }]
-      })),
-    })
-
-    const parseHTML = callOrReturn(getExtensionField<MarkConfig['parseHTML']>(extension, 'parseHTML', context))
-
-    if (parseHTML) {
-      schema.parseDOM = parseHTML
-        .map(parseRule => injectExtensionAttributesToParseRule(parseRule, extensionAttributes))
-    }
-
-    const renderHTML = getExtensionField<MarkConfig['renderHTML']>(extension, 'renderHTML', context)
-
-    if (renderHTML) {
-      schema.toDOM = mark => renderHTML({
-        mark,
-        HTMLAttributes: getRenderedAttributes(mark, extensionAttributes),
-      })
-    }
-
-    return [extension.name, schema]
-  }))
-
-  return new Schema({
-    topNode,
-    nodes,
-    marks,
-  })
 }

packages/core/src/helpers/getSchemaByResolvedExtensions.ts

@@ -0,0 +1,138 @@
+import { NodeSpec, MarkSpec, Schema } from 'prosemirror-model'
+import { AnyConfig, Extensions } from '../types'
+import { NodeConfig, MarkConfig } from '..'
+import splitExtensions from './splitExtensions'
+import getAttributesFromExtensions from './getAttributesFromExtensions'
+import getRenderedAttributes from './getRenderedAttributes'
+import isEmptyObject from '../utilities/isEmptyObject'
+import injectExtensionAttributesToParseRule from './injectExtensionAttributesToParseRule'
+import callOrReturn from '../utilities/callOrReturn'
+import getExtensionField from './getExtensionField'
+
+function cleanUpSchemaItem<T>(data: T) {
+  return Object.fromEntries(Object.entries(data).filter(([key, value]) => {
+    if (key === 'attrs' && isEmptyObject(value)) {
+      return false
+    }
+
+    return value !== null && value !== undefined
+  })) as T
+}
+
+export default function getSchemaByResolvedExtensions(extensions: Extensions): Schema {
+  const allAttributes = getAttributesFromExtensions(extensions)
+  const { nodeExtensions, markExtensions } = splitExtensions(extensions)
+  const topNode = nodeExtensions.find(extension => getExtensionField(extension, 'topNode'))?.name
+
+  const nodes = Object.fromEntries(nodeExtensions.map(extension => {
+    const extensionAttributes = allAttributes.filter(attribute => attribute.type === extension.name)
+    const context = {
+      name: extension.name,
+      options: extension.options,
+    }
+
+    const extraNodeFields = extensions.reduce((fields, e) => {
+      const extendNodeSchema = getExtensionField<AnyConfig['extendNodeSchema']>(
+        e,
+        'extendNodeSchema',
+        context,
+      )
+
+      return {
+        ...fields,
+        ...(extendNodeSchema ? extendNodeSchema(extension) : {}),
+      }
+    }, {})
+
+    const schema: NodeSpec = cleanUpSchemaItem({
+      ...extraNodeFields,
+      content: callOrReturn(getExtensionField<NodeConfig['content']>(extension, 'content', context)),
+      marks: callOrReturn(getExtensionField<NodeConfig['marks']>(extension, 'marks', context)),
+      group: callOrReturn(getExtensionField<NodeConfig['group']>(extension, 'group', context)),
+      inline: callOrReturn(getExtensionField<NodeConfig['inline']>(extension, 'inline', context)),
+      atom: callOrReturn(getExtensionField<NodeConfig['atom']>(extension, 'atom', context)),
+      selectable: callOrReturn(getExtensionField<NodeConfig['selectable']>(extension, 'selectable', context)),
+      draggable: callOrReturn(getExtensionField<NodeConfig['draggable']>(extension, 'draggable', context)),
+      code: callOrReturn(getExtensionField<NodeConfig['code']>(extension, 'code', context)),
+      defining: callOrReturn(getExtensionField<NodeConfig['defining']>(extension, 'defining', context)),
+      isolating: callOrReturn(getExtensionField<NodeConfig['isolating']>(extension, 'isolating', context)),
+      attrs: Object.fromEntries(extensionAttributes.map(extensionAttribute => {
+        return [extensionAttribute.name, { default: extensionAttribute?.attribute?.default }]
+      })),
+    })
+
+    const parseHTML = callOrReturn(getExtensionField<NodeConfig['parseHTML']>(extension, 'parseHTML', context))
+
+    if (parseHTML) {
+      schema.parseDOM = parseHTML
+        .map(parseRule => injectExtensionAttributesToParseRule(parseRule, extensionAttributes))
+    }
+
+    const renderHTML = getExtensionField<NodeConfig['renderHTML']>(extension, 'renderHTML', context)
+
+    if (renderHTML) {
+      schema.toDOM = node => renderHTML({
+        node,
+        HTMLAttributes: getRenderedAttributes(node, extensionAttributes),
+      })
+    }
+
+    return [extension.name, schema]
+  }))
+
+  const marks = Object.fromEntries(markExtensions.map(extension => {
+    const extensionAttributes = allAttributes.filter(attribute => attribute.type === extension.name)
+    const context = {
+      name: extension.name,
+      options: extension.options,
+    }
+
+    const extraMarkFields = extensions.reduce((fields, e) => {
+      const extendMarkSchema = getExtensionField<AnyConfig['extendMarkSchema']>(
+        e,
+        'extendMarkSchema',
+        context,
+      )
+
+      return {
+        ...fields,
+        ...(extendMarkSchema ? extendMarkSchema(extension) : {}),
+      }
+    }, {})
+
+    const schema: MarkSpec = cleanUpSchemaItem({
+      ...extraMarkFields,
+      inclusive: callOrReturn(getExtensionField<NodeConfig['inclusive']>(extension, 'inclusive', context)),
+      excludes: callOrReturn(getExtensionField<NodeConfig['excludes']>(extension, 'excludes', context)),
+      group: callOrReturn(getExtensionField<NodeConfig['group']>(extension, 'group', context)),
+      spanning: callOrReturn(getExtensionField<NodeConfig['spanning']>(extension, 'spanning', context)),
+      attrs: Object.fromEntries(extensionAttributes.map(extensionAttribute => {
+        return [extensionAttribute.name, { default: extensionAttribute?.attribute?.default }]
+      })),
+    })
+
+    const parseHTML = callOrReturn(getExtensionField<MarkConfig['parseHTML']>(extension, 'parseHTML', context))
+
+    if (parseHTML) {
+      schema.parseDOM = parseHTML
+        .map(parseRule => injectExtensionAttributesToParseRule(parseRule, extensionAttributes))
+    }
+
+    const renderHTML = getExtensionField<MarkConfig['renderHTML']>(extension, 'renderHTML', context)
+
+    if (renderHTML) {
+      schema.toDOM = mark => renderHTML({
+        mark,
+        HTMLAttributes: getRenderedAttributes(mark, extensionAttributes),
+      })
+    }
+
+    return [extension.name, schema]
+  }))
+
+  return new Schema({
+    topNode,
+    nodes,
+    marks,
+  })
+}