@tiptap/core 3.0.0-next.3 → 3.0.0-next.4

package/src/helpers/getAttributesFromExtensions.ts

@@ -1,11 +1,5 @@
 import type { MarkConfig, NodeConfig } from '../index.js'
-import {
-  AnyConfig,
-  Attribute,
-  Attributes,
-  ExtensionAttribute,
-  Extensions,
-} from '../types.js'
+import { AnyConfig, Attribute, Attributes, ExtensionAttribute, Extensions } from '../types.js'
 import { getExtensionField } from './getExtensionField.js'
 import { splitExtensions } from './splitExtensions.js'
 
@@ -17,8 +11,9 @@ export function getAttributesFromExtensions(extensions: Extensions): ExtensionAt
   const extensionAttributes: ExtensionAttribute[] = []
   const { nodeExtensions, markExtensions } = splitExtensions(extensions)
   const nodeAndMarkExtensions = [...nodeExtensions, ...markExtensions]
-  const defaultAttribute: Required<Attribute> = {
+  const defaultAttribute: Required<Omit<Attribute, 'validate'>> & Pick<Attribute, 'validate'> = {
     default: null,
+    validate: undefined,
     rendered: true,
     renderHTML: null,
     parseHTML: null,
@@ -48,18 +43,16 @@ export function getAttributesFromExtensions(extensions: Extensions): ExtensionAt
 
     globalAttributes.forEach(globalAttribute => {
       globalAttribute.types.forEach(type => {
-        Object
-          .entries(globalAttribute.attributes)
-          .forEach(([name, attribute]) => {
-            extensionAttributes.push({
-              type,
-              name,
-              attribute: {
-                ...defaultAttribute,
-                ...attribute,
-              },
-            })
+        Object.entries(globalAttribute.attributes).forEach(([name, attribute]) => {
+          extensionAttributes.push({
+            type,
+            name,
+            attribute: {
+              ...defaultAttribute,
+              ...attribute,
+            },
           })
+        })
       })
     })
   })
@@ -84,28 +77,26 @@ export function getAttributesFromExtensions(extensions: Extensions): ExtensionAt
     // TODO: remove `as Attributes`
     const attributes = addAttributes() as Attributes
 
-    Object
-      .entries(attributes)
-      .forEach(([name, attribute]) => {
-        const mergedAttr = {
-          ...defaultAttribute,
-          ...attribute,
-        }
+    Object.entries(attributes).forEach(([name, attribute]) => {
+      const mergedAttr = {
+        ...defaultAttribute,
+        ...attribute,
+      }
 
-        if (typeof mergedAttr?.default === 'function') {
-          mergedAttr.default = mergedAttr.default()
-        }
+      if (typeof mergedAttr?.default === 'function') {
+        mergedAttr.default = mergedAttr.default()
+      }
 
-        if (mergedAttr?.isRequired && mergedAttr?.default === undefined) {
-          delete mergedAttr.default
-        }
+      if (mergedAttr?.isRequired && mergedAttr?.default === undefined) {
+        delete mergedAttr.default
+      }
 
-        extensionAttributes.push({
-          type: extension.name,
-          name,
-          attribute: mergedAttr,
-        })
+      extensionAttributes.push({
+        type: extension.name,
+        name,
+        attribute: mergedAttr,
       })
+    })
   })
 
   return extensionAttributes

package/src/helpers/getChangedRanges.ts

@@ -4,8 +4,8 @@ import { Range } from '../types.js'
 import { removeDuplicates } from '../utilities/removeDuplicates.js'
 
 export type ChangedRange = {
-  oldRange: Range,
-  newRange: Range,
+  oldRange: Range
+  newRange: Range
 }
 
 /**
@@ -18,15 +18,17 @@ function simplifyChangedRanges(changes: ChangedRange[]): ChangedRange[] {
   return uniqueChanges.length === 1
     ? uniqueChanges
     : uniqueChanges.filter((change, index) => {
-      const rest = uniqueChanges.filter((_, i) => i !== index)
+        const rest = uniqueChanges.filter((_, i) => i !== index)
 
-      return !rest.some(otherChange => {
-        return change.oldRange.from >= otherChange.oldRange.from
-          && change.oldRange.to <= otherChange.oldRange.to
-          && change.newRange.from >= otherChange.newRange.from
-          && change.newRange.to <= otherChange.newRange.to
+        return !rest.some(otherChange => {
+          return (
+            change.oldRange.from >= otherChange.oldRange.from &&
+            change.oldRange.to <= otherChange.oldRange.to &&
+            change.newRange.from >= otherChange.newRange.from &&
+            change.newRange.to <= otherChange.newRange.to
+          )
+        })
       })
-    })
 }
 
 /**
@@ -45,8 +47,8 @@ export function getChangedRanges(transform: Transform): ChangedRange[] {
     // @ts-ignore
     if (!stepMap.ranges.length) {
       const { from, to } = steps[index] as Step & {
-        from?: number,
-        to?: number,
+        from?: number
+        to?: number
       }
 
       if (from === undefined || to === undefined) {

package/src/helpers/getExtensionField.ts

@@ -12,7 +12,6 @@ export function getExtensionField<T = any>(
   field: string,
   context?: Omit<MaybeThisParameterType<T>, 'parent'>,
 ): RemoveThis<T> {
-
   if (extension.config[field] === undefined && extension.parent) {
     return getExtensionField(extension.parent, field, context)
   }
@@ -20,9 +19,7 @@ export function getExtensionField<T = any>(
   if (typeof extension.config[field] === 'function') {
     const value = extension.config[field].bind({
       ...context,
-      parent: extension.parent
-        ? getExtensionField(extension.parent, field, context)
-        : null,
+      parent: extension.parent ? getExtensionField(extension.parent, field, context) : null,
     })
 
     return value

package/src/helpers/getMarkAttributes.ts

@@ -3,10 +3,7 @@ import { EditorState } from '@tiptap/pm/state'
 
 import { getMarkType } from './getMarkType.js'
 
-export function getMarkAttributes(
-  state: EditorState,
-  typeOrName: string | MarkType,
-): Record<string, any> {
+export function getMarkAttributes(state: EditorState, typeOrName: string | MarkType): Record<string, any> {
   const type = getMarkType(typeOrName, state.schema)
   const { from, to, empty } = state.selection
   const marks: Mark[] = []

package/src/helpers/getMarkRange.ts

@@ -10,8 +10,8 @@ function findMarkInSet(
 ): ProseMirrorMark | undefined {
   return marks.find(item => {
     return (
-      item.type === type
-      && objectIncludes(
+      item.type === type &&
+      objectIncludes(
         // Only check equality for the attributes that are provided
         Object.fromEntries(Object.keys(attributes).map(k => [k, item.attrs[k]])),
         attributes,
@@ -20,11 +20,7 @@ function findMarkInSet(
   })
 }
 
-function isMarkInSet(
-  marks: ProseMirrorMark[],
-  type: MarkType,
-  attributes: Record<string, any> = {},
-): boolean {
+function isMarkInSet(marks: ProseMirrorMark[], type: MarkType, attributes: Record<string, any> = {}): boolean {
   return !!findMarkInSet(marks, type, attributes)
 }
 
@@ -77,18 +73,12 @@ export function getMarkRange(
   let endIndex = startIndex + 1
   let endPos = startPos + start.node.nodeSize
 
-  while (
-    startIndex > 0
-    && isMarkInSet([...$pos.parent.child(startIndex - 1).marks], type, attributes)
-  ) {
+  while (startIndex > 0 && isMarkInSet([...$pos.parent.child(startIndex - 1).marks], type, attributes)) {
     startIndex -= 1
     startPos -= $pos.parent.child(startIndex).nodeSize
   }
 
-  while (
-    endIndex < $pos.parent.childCount
-    && isMarkInSet([...$pos.parent.child(endIndex).marks], type, attributes)
-  ) {
+  while (endIndex < $pos.parent.childCount && isMarkInSet([...$pos.parent.child(endIndex).marks], type, attributes)) {
     endPos += $pos.parent.child(endIndex).nodeSize
     endIndex += 1
   }

package/src/helpers/getMarkType.ts

@@ -3,9 +3,7 @@ import { MarkType, Schema } from '@tiptap/pm/model'
 export function getMarkType(nameOrType: string | MarkType, schema: Schema): MarkType {
   if (typeof nameOrType === 'string') {
     if (!schema.marks[nameOrType]) {
-      throw Error(
-        `There is no mark type named '${nameOrType}'. Maybe you forgot to add the extension?`,
-      )
+      throw Error(`There is no mark type named '${nameOrType}'. Maybe you forgot to add the extension?`)
     }
 
     return schema.marks[nameOrType]

package/src/helpers/getNodeAttributes.ts

@@ -3,10 +3,7 @@ import { EditorState } from '@tiptap/pm/state'
 
 import { getNodeType } from './getNodeType.js'
 
-export function getNodeAttributes(
-  state: EditorState,
-  typeOrName: string | NodeType,
-): Record<string, any> {
+export function getNodeAttributes(state: EditorState, typeOrName: string | NodeType): Record<string, any> {
   const type = getNodeType(typeOrName, state.schema)
   const { from, to } = state.selection
   const nodes: Node[] = []

package/src/helpers/getNodeType.ts

@@ -3,9 +3,7 @@ import { NodeType, Schema } from '@tiptap/pm/model'
 export function getNodeType(nameOrType: string | NodeType, schema: Schema): NodeType {
   if (typeof nameOrType === 'string') {
     if (!schema.nodes[nameOrType]) {
-      throw Error(
-        `There is no node type named '${nameOrType}'. Maybe you forgot to add the extension?`,
-      )
+      throw Error(`There is no node type named '${nameOrType}'. Maybe you forgot to add the extension?`)
     }
 
     return schema.nodes[nameOrType]

package/src/helpers/getRenderedAttributes.ts

@@ -8,9 +8,7 @@ export function getRenderedAttributes(
   extensionAttributes: ExtensionAttribute[],
 ): Record<string, any> {
   return extensionAttributes
-    .filter(
-      attribute => attribute.type === nodeOrMark.type.name,
-    )
+    .filter(attribute => attribute.type === nodeOrMark.type.name)
     .filter(item => item.attribute.rendered)
     .map(item => {
       if (!item.attribute.renderHTML) {

package/src/helpers/getSchema.ts

@@ -1,12 +1,12 @@
 import { Schema } from '@tiptap/pm/model'
 
 import { Editor } from '../Editor.js'
-import { ExtensionManager } from '../ExtensionManager.js'
 import { Extensions } from '../types.js'
 import { getSchemaByResolvedExtensions } from './getSchemaByResolvedExtensions.js'
+import { resolveExtensions } from './resolveExtensions.js'
 
 export function getSchema(extensions: Extensions, editor?: Editor): Schema {
-  const resolvedExtensions = ExtensionManager.resolve(extensions)
+  const resolvedExtensions = resolveExtensions(extensions)
 
   return getSchemaByResolvedExtensions(resolvedExtensions, editor)
 }

package/src/helpers/getSchemaByResolvedExtensions.ts

@@ -1,6 +1,4 @@
-import {
-  MarkSpec, NodeSpec, Schema, TagParseRule,
-} from '@tiptap/pm/model'
+import { MarkSpec, NodeSpec, Schema, TagParseRule } from '@tiptap/pm/model'
 
 import type { Editor, MarkConfig, NodeConfig } from '../index.js'
 import { AnyConfig, Extensions } from '../types.js'
@@ -16,7 +14,7 @@ function cleanUpSchemaItem<T>(data: T) {
   return Object.fromEntries(
     // @ts-ignore
     Object.entries(data).filter(([key, value]) => {
-      if (key === 'attrs' && isEmptyObject(value as {} | undefined)) {
+      if (key === 'attrs' && isEmptyObject(value as object | undefined)) {
         return false
       }
 
@@ -38,9 +36,7 @@ export function getSchemaByResolvedExtensions(extensions: Extensions, editor?: E
 
   const nodes = Object.fromEntries(
     nodeExtensions.map(extension => {
-      const extensionAttributes = allAttributes.filter(
-        attribute => attribute.type === extension.name,
-      )
+      const extensionAttributes = allAttributes.filter(attribute => attribute.type === extension.name)
       const context = {
         name: extension.name,
         options: extension.options,
@@ -49,11 +45,7 @@ export function getSchemaByResolvedExtensions(extensions: Extensions, editor?: E
       }
 
       const extraNodeFields = extensions.reduce((fields, e) => {
-        const extendNodeSchema = getExtensionField<AnyConfig['extendNodeSchema']>(
-          e,
-          'extendNodeSchema',
-          context,
-        )
+        const extendNodeSchema = getExtensionField<AnyConfig['extendNodeSchema']>(e, 'extendNodeSchema', context)
 
         return {
           ...fields,
@@ -63,61 +55,49 @@ export function getSchemaByResolvedExtensions(extensions: Extensions, editor?: E
 
       const schema: NodeSpec = cleanUpSchemaItem({
         ...extraNodeFields,
-        content: callOrReturn(
-          getExtensionField<NodeConfig['content']>(extension, 'content', context),
-        ),
+        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),
-        ),
+        selectable: callOrReturn(getExtensionField<NodeConfig['selectable']>(extension, 'selectable', context)),
+        draggable: callOrReturn(getExtensionField<NodeConfig['draggable']>(extension, 'draggable', context)),
         code: callOrReturn(getExtensionField<NodeConfig['code']>(extension, 'code', context)),
         whitespace: callOrReturn(getExtensionField<NodeConfig['whitespace']>(extension, 'whitespace', context)),
-        linebreakReplacement: callOrReturn(getExtensionField<NodeConfig['linebreakReplacement']>(extension, 'linebreakReplacement', context)),
-        defining: callOrReturn(
-          getExtensionField<NodeConfig['defining']>(extension, 'defining', context),
-        ),
-        isolating: callOrReturn(
-          getExtensionField<NodeConfig['isolating']>(extension, 'isolating', context),
+        linebreakReplacement: callOrReturn(
+          getExtensionField<NodeConfig['linebreakReplacement']>(extension, 'linebreakReplacement', 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 }]
+            return [
+              extensionAttribute.name,
+              { default: extensionAttribute?.attribute?.default, validate: extensionAttribute?.attribute?.validate },
+            ]
           }),
         ),
       })
 
-      const parseHTML = callOrReturn(
-        getExtensionField<NodeConfig['parseHTML']>(extension, 'parseHTML', context),
-      )
+      const parseHTML = callOrReturn(getExtensionField<NodeConfig['parseHTML']>(extension, 'parseHTML', context))
 
       if (parseHTML) {
-        schema.parseDOM = parseHTML.map(parseRule => injectExtensionAttributesToParseRule(parseRule, extensionAttributes)) as TagParseRule[]
+        schema.parseDOM = parseHTML.map(parseRule =>
+          injectExtensionAttributesToParseRule(parseRule, extensionAttributes),
+        ) as TagParseRule[]
       }
 
-      const renderHTML = getExtensionField<NodeConfig['renderHTML']>(
-        extension,
-        'renderHTML',
-        context,
-      )
+      const renderHTML = getExtensionField<NodeConfig['renderHTML']>(extension, 'renderHTML', context)
 
       if (renderHTML) {
-        schema.toDOM = node => renderHTML({
-          node,
-          HTMLAttributes: getRenderedAttributes(node, extensionAttributes),
-        })
+        schema.toDOM = node =>
+          renderHTML({
+            node,
+            HTMLAttributes: getRenderedAttributes(node, extensionAttributes),
+          })
       }
 
-      const renderText = getExtensionField<NodeConfig['renderText']>(
-        extension,
-        'renderText',
-        context,
-      )
+      const renderText = getExtensionField<NodeConfig['renderText']>(extension, 'renderText', context)
 
       if (renderText) {
         schema.toText = renderText
@@ -129,9 +109,7 @@ export function getSchemaByResolvedExtensions(extensions: Extensions, editor?: E
 
   const marks = Object.fromEntries(
     markExtensions.map(extension => {
-      const extensionAttributes = allAttributes.filter(
-        attribute => attribute.type === extension.name,
-      )
+      const extensionAttributes = allAttributes.filter(attribute => attribute.type === extension.name)
       const context = {
         name: extension.name,
         options: extension.options,
@@ -140,11 +118,7 @@ export function getSchemaByResolvedExtensions(extensions: Extensions, editor?: E
       }
 
       const extraMarkFields = extensions.reduce((fields, e) => {
-        const extendMarkSchema = getExtensionField<AnyConfig['extendMarkSchema']>(
-          e,
-          'extendMarkSchema',
-          context,
-        )
+        const extendMarkSchema = getExtensionField<AnyConfig['extendMarkSchema']>(e, 'extendMarkSchema', context)
 
         return {
           ...fields,
@@ -154,43 +128,37 @@ export function getSchemaByResolvedExtensions(extensions: Extensions, editor?: E
 
       const schema: MarkSpec = cleanUpSchemaItem({
         ...extraMarkFields,
-        inclusive: callOrReturn(
-          getExtensionField<MarkConfig['inclusive']>(extension, 'inclusive', context),
-        ),
-        excludes: callOrReturn(
-          getExtensionField<MarkConfig['excludes']>(extension, 'excludes', context),
-        ),
+        inclusive: callOrReturn(getExtensionField<MarkConfig['inclusive']>(extension, 'inclusive', context)),
+        excludes: callOrReturn(getExtensionField<MarkConfig['excludes']>(extension, 'excludes', context)),
         group: callOrReturn(getExtensionField<MarkConfig['group']>(extension, 'group', context)),
-        spanning: callOrReturn(
-          getExtensionField<MarkConfig['spanning']>(extension, 'spanning', context),
-        ),
+        spanning: callOrReturn(getExtensionField<MarkConfig['spanning']>(extension, 'spanning', context)),
         code: callOrReturn(getExtensionField<MarkConfig['code']>(extension, 'code', context)),
         attrs: Object.fromEntries(
           extensionAttributes.map(extensionAttribute => {
-            return [extensionAttribute.name, { default: extensionAttribute?.attribute?.default }]
+            return [
+              extensionAttribute.name,
+              { default: extensionAttribute?.attribute?.default, validate: extensionAttribute?.attribute?.validate },
+            ]
           }),
         ),
       })
 
-      const parseHTML = callOrReturn(
-        getExtensionField<MarkConfig['parseHTML']>(extension, 'parseHTML', context),
-      )
+      const parseHTML = callOrReturn(getExtensionField<MarkConfig['parseHTML']>(extension, 'parseHTML', context))
 
       if (parseHTML) {
-        schema.parseDOM = parseHTML.map(parseRule => injectExtensionAttributesToParseRule(parseRule, extensionAttributes))
+        schema.parseDOM = parseHTML.map(parseRule =>
+          injectExtensionAttributesToParseRule(parseRule, extensionAttributes),
+        )
       }
 
-      const renderHTML = getExtensionField<MarkConfig['renderHTML']>(
-        extension,
-        'renderHTML',
-        context,
-      )
+      const renderHTML = getExtensionField<MarkConfig['renderHTML']>(extension, 'renderHTML', context)
 
       if (renderHTML) {
-        schema.toDOM = mark => renderHTML({
-          mark,
-          HTMLAttributes: getRenderedAttributes(mark, extensionAttributes),
-        })
+        schema.toDOM = mark =>
+          renderHTML({
+            mark,
+            HTMLAttributes: getRenderedAttributes(mark, extensionAttributes),
+          })
       }
 
       return [extension.name, schema]

package/src/helpers/getSplittedAttributes.ts

@@ -12,9 +12,8 @@ export function getSplittedAttributes(
   typeName: string,
   attributes: Record<string, any>,
 ): Record<string, any> {
-  return Object.fromEntries(Object
-    .entries(attributes)
-    .filter(([name]) => {
+  return Object.fromEntries(
+    Object.entries(attributes).filter(([name]) => {
       const extensionAttribute = extensionAttributes.find(item => {
         return item.type === typeName && item.name === name
       })
@@ -24,5 +23,6 @@ export function getSplittedAttributes(
       }
 
       return extensionAttribute.attribute.keepOnSplit
-    }))
+    }),
+  )
 }

package/src/helpers/getTextContentFromNodes.ts

@@ -11,22 +11,19 @@ export const getTextContentFromNodes = ($from: ResolvedPos, maxMatch = 500) => {
 
   const sliceEndPos = $from.parentOffset
 
-  $from.parent.nodesBetween(
-    Math.max(0, sliceEndPos - maxMatch),
-    sliceEndPos,
-    (node, pos, parent, index) => {
-      const chunk = node.type.spec.toText?.({
+  $from.parent.nodesBetween(Math.max(0, sliceEndPos - maxMatch), sliceEndPos, (node, pos, parent, index) => {
+    const chunk =
+      node.type.spec.toText?.({
         node,
         pos,
         parent,
         index,
-      })
-        || node.textContent
-        || '%leaf%'
+      }) ||
+      node.textContent ||
+      '%leaf%'
 
-      textBefore += node.isAtom && !node.isText ? chunk : chunk.slice(0, Math.max(0, sliceEndPos - pos))
-    },
-  )
+    textBefore += node.isAtom && !node.isText ? chunk : chunk.slice(0, Math.max(0, sliceEndPos - pos))
+  })
 
   return textBefore
 }

package/src/helpers/index.ts

@@ -7,6 +7,7 @@ export * from './findChildren.js'
 export * from './findChildrenInRange.js'
 export * from './findParentNode.js'
 export * from './findParentNodeClosestToPos.js'
+export * from './flattenExtensions.js'
 export * from './generateHTML.js'
 export * from './generateJSON.js'
 export * from './generateText.js'
@@ -45,6 +46,9 @@ export * from './isNodeEmpty.js'
 export * from './isNodeSelection.js'
 export * from './isTextSelection.js'
 export * from './posToDOMRect.js'
+export * from './resolveExtensions.js'
 export * from './resolveFocusPosition.js'
+export * from './rewriteUnknownContent.js'
 export * from './selectionToInsertionEnd.js'
+export * from './sortExtensions.js'
 export * from './splitExtensions.js'

package/src/helpers/injectExtensionAttributesToParseRule.ts

@@ -29,7 +29,7 @@ export function injectExtensionAttributesToParseRule(
       const newAttributes = extensionAttributes.reduce((items, item) => {
         const value = item.attribute.parseHTML
           ? item.attribute.parseHTML(node)
-          : fromString((node).getAttribute(item.name))
+          : fromString(node.getAttribute(item.name))
 
         if (value === null || value === undefined) {
           return items

package/src/helpers/isActive.ts

@@ -4,11 +4,7 @@ import { getSchemaTypeNameByName } from './getSchemaTypeNameByName.js'
 import { isMarkActive } from './isMarkActive.js'
 import { isNodeActive } from './isNodeActive.js'
 
-export function isActive(
-  state: EditorState,
-  name: string | null,
-  attributes: Record<string, any> = {},
-): boolean {
+export function isActive(state: EditorState, name: string | null, attributes: Record<string, any> = {}): boolean {
   if (!name) {
     return isNodeActive(state, null, attributes) || isMarkActive(state, null, attributes)
   }

package/src/helpers/isExtensionRulesEnabled.ts

@@ -3,9 +3,7 @@ import { AnyExtension, EnableRules } from '../types.js'
 export function isExtensionRulesEnabled(extension: AnyExtension, enabled: EnableRules): boolean {
   if (Array.isArray(enabled)) {
     return enabled.some(enabledExtension => {
-      const name = typeof enabledExtension === 'string'
-        ? enabledExtension
-        : enabledExtension.name
+      const name = typeof enabledExtension === 'string' ? enabledExtension : enabledExtension.name
 
       return name === extension.name
     })

package/src/helpers/isNodeEmpty.ts

@@ -12,11 +12,11 @@ export function isNodeEmpty(
     /**
      * When true (default), it will also check if all children are empty.
      */
-    checkChildren?: boolean;
+    checkChildren?: boolean
     /**
      * When true, it will ignore whitespace when checking for emptiness.
      */
-    ignoreWhitespace?: boolean;
+    ignoreWhitespace?: boolean
   } = {},
 ): boolean {
   if (ignoreWhitespace) {

package/src/helpers/resolveExtensions.ts

@@ -0,0 +1,25 @@
+import { Extensions } from '../types.js'
+import { findDuplicates } from '../utilities/findDuplicates.js'
+import { flattenExtensions } from './flattenExtensions.js'
+import { sortExtensions } from './sortExtensions.js'
+
+/**
+ * Returns a flattened and sorted extension list while
+ * also checking for duplicated extensions and warns the user.
+ * @param extensions An array of Tiptap extensions
+ * @returns An flattened and sorted array of Tiptap extensions
+ */
+export function resolveExtensions(extensions: Extensions): Extensions {
+  const resolvedExtensions = sortExtensions(flattenExtensions(extensions))
+  const duplicatedNames = findDuplicates(resolvedExtensions.map(extension => extension.name))
+
+  if (duplicatedNames.length) {
+    console.warn(
+      `[tiptap warn]: Duplicate extension names found: [${duplicatedNames
+        .map(item => `'${item}'`)
+        .join(', ')}]. This can lead to issues.`,
+    )
+  }
+
+  return resolvedExtensions
+}