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

package/src/helpers/resolveFocusPosition.ts

@@ -4,10 +4,7 @@ import { Selection, TextSelection } from '@tiptap/pm/state'
 import { FocusPosition } from '../types.js'
 import { minMax } from '../utilities/minMax.js'
 
-export function resolveFocusPosition(
-  doc: ProseMirrorNode,
-  position: FocusPosition = null,
-): Selection | null {
+export function resolveFocusPosition(doc: ProseMirrorNode, position: FocusPosition = null): Selection | null {
   if (!position) {
     return null
   }
@@ -27,16 +24,8 @@ export function resolveFocusPosition(
   const maxPos = selectionAtEnd.to
 
   if (position === 'all') {
-    return TextSelection.create(
-      doc,
-      minMax(0, minPos, maxPos),
-      minMax(doc.content.size, minPos, maxPos),
-    )
+    return TextSelection.create(doc, minMax(0, minPos, maxPos), minMax(doc.content.size, minPos, maxPos))
   }
 
-  return TextSelection.create(
-    doc,
-    minMax(position, minPos, maxPos),
-    minMax(position, minPos, maxPos),
-  )
+  return TextSelection.create(doc, minMax(position, minPos, maxPos), minMax(position, minPos, maxPos))
 }

package/src/helpers/rewriteUnknownContent.ts

@@ -0,0 +1,149 @@
+import type { Schema } from '@tiptap/pm/model'
+
+import type { JSONContent } from '../types.js'
+
+type RewriteUnknownContentOptions = {
+  /**
+   * If true, unknown nodes will be treated as paragraphs
+   * @default true
+   */
+  fallbackToParagraph?: boolean
+}
+
+type RewrittenContent = {
+  /**
+   * The original JSON content that was rewritten
+   */
+  original: JSONContent
+  /**
+   * The name of the node or mark that was unsupported
+   */
+  unsupported: string
+}[]
+
+/**
+ * The actual implementation of the rewriteUnknownContent function
+ */
+function rewriteUnknownContentInner({
+  json,
+  validMarks,
+  validNodes,
+  options,
+  rewrittenContent = [],
+}: {
+  json: JSONContent
+  validMarks: Set<string>
+  validNodes: Set<string>
+  options?: RewriteUnknownContentOptions
+  rewrittenContent?: RewrittenContent
+}): {
+  /**
+   * The cleaned JSON content
+   */
+  json: JSONContent | null
+  /**
+   * The array of nodes and marks that were rewritten
+   */
+  rewrittenContent: RewrittenContent
+} {
+  if (json.marks && Array.isArray(json.marks)) {
+    json.marks = json.marks.filter(mark => {
+      const name = typeof mark === 'string' ? mark : mark.type
+
+      if (validMarks.has(name)) {
+        return true
+      }
+
+      rewrittenContent.push({
+        original: JSON.parse(JSON.stringify(mark)),
+        unsupported: name,
+      })
+      // Just ignore any unknown marks
+      return false
+    })
+  }
+
+  if (json.content && Array.isArray(json.content)) {
+    json.content = json.content
+      .map(
+        value =>
+          rewriteUnknownContentInner({
+            json: value,
+            validMarks,
+            validNodes,
+            options,
+            rewrittenContent,
+          }).json,
+      )
+      .filter(a => a !== null && a !== undefined)
+  }
+
+  if (json.type && !validNodes.has(json.type)) {
+    rewrittenContent.push({
+      original: JSON.parse(JSON.stringify(json)),
+      unsupported: json.type,
+    })
+
+    if (json.content && Array.isArray(json.content) && options?.fallbackToParagraph !== false) {
+      // Just treat it like a paragraph and hope for the best
+      json.type = 'paragraph'
+
+      return {
+        json,
+        rewrittenContent,
+      }
+    }
+
+    // or just omit it entirely
+    return {
+      json: null,
+      rewrittenContent,
+    }
+  }
+
+  return { json, rewrittenContent }
+}
+
+/**
+ * Rewrite unknown nodes and marks within JSON content
+ * Allowing for user within the editor
+ */
+export function rewriteUnknownContent(
+  /**
+   * The JSON content to clean of unknown nodes and marks
+   */
+  json: JSONContent,
+  /**
+   * The schema to use for validation
+   */
+  schema: Schema,
+  /**
+   * Options for the cleaning process
+   */
+  options?: RewriteUnknownContentOptions,
+): {
+  /**
+   * The cleaned JSON content
+   */
+  json: JSONContent | null
+  /**
+   * The array of nodes and marks that were rewritten
+   */
+  rewrittenContent: {
+    /**
+     * The original JSON content that was rewritten
+     */
+    original: JSONContent
+    /**
+     * The name of the node or mark that was unsupported
+     */
+    unsupported: string
+  }[]
+} {
+  return rewriteUnknownContentInner({
+    json,
+    validNodes: new Set(Object.keys(schema.nodes)),
+    validMarks: new Set(Object.keys(schema.marks)),
+    options,
+  })
+}

package/src/helpers/sortExtensions.ts

@@ -0,0 +1,26 @@
+import { AnyConfig, Extensions } from '../types.js'
+import { getExtensionField } from './getExtensionField.js'
+
+/**
+ * Sort extensions by priority.
+ * @param extensions An array of Tiptap extensions
+ * @returns A sorted array of Tiptap extensions by priority
+ */
+export function sortExtensions(extensions: Extensions): Extensions {
+  const defaultPriority = 100
+
+  return extensions.sort((a, b) => {
+    const priorityA = getExtensionField<AnyConfig['priority']>(a, 'priority') || defaultPriority
+    const priorityB = getExtensionField<AnyConfig['priority']>(b, 'priority') || defaultPriority
+
+    if (priorityA > priorityB) {
+      return -1
+    }
+
+    if (priorityA < priorityB) {
+      return 1
+    }
+
+    return 0
+  })
+}

package/src/inputRules/markInputRule.ts

@@ -13,11 +13,7 @@ import { callOrReturn } from '../utilities/callOrReturn.js'
 export function markInputRule(config: {
   find: InputRuleFinder
   type: MarkType
-  getAttributes?:
-    | Record<string, any>
-    | ((match: ExtendedRegExpMatchArray) => Record<string, any>)
-    | false
-    | null
+  getAttributes?: Record<string, any> | ((match: ExtendedRegExpMatchArray) => Record<string, any>) | false | null
 }) {
   return new InputRule({
     find: config.find,

package/src/inputRules/nodeInputRule.ts

@@ -24,11 +24,7 @@ export function nodeInputRule(config: {
    * A function that returns the attributes for the node
    * can also be an object of attributes
    */
-  getAttributes?:
-    | Record<string, any>
-    | ((match: ExtendedRegExpMatchArray) => Record<string, any>)
-    | false
-    | null
+  getAttributes?: Record<string, any> | ((match: ExtendedRegExpMatchArray) => Record<string, any>) | false | null
 }) {
   return new InputRule({
     find: config.find,
@@ -60,10 +56,7 @@ export function nodeInputRule(config: {
       } else if (match[0]) {
         const insertionStart = config.type.isInline ? start : start - 1
 
-        tr.insert(insertionStart, config.type.create(attributes)).delete(
-          tr.mapping.map(start),
-          tr.mapping.map(end),
-        )
+        tr.insert(insertionStart, config.type.create(attributes)).delete(tr.mapping.map(start), tr.mapping.map(end))
       }
 
       tr.scrollIntoView()

package/src/inputRules/textInputRule.ts

@@ -5,10 +5,7 @@ import { InputRule, InputRuleFinder } from '../InputRule.js'
  * matched text is typed into it.
  * @see https://tiptap.dev/docs/editor/extensions/custom-extensions/extend-existing#input-rules
  */
-export function textInputRule(config: {
-  find: InputRuleFinder,
-  replace: string,
-}) {
+export function textInputRule(config: { find: InputRuleFinder; replace: string }) {
   return new InputRule({
     find: config.find,
     handler: ({ state, range, match }) => {

package/src/inputRules/textblockTypeInputRule.ts

@@ -14,11 +14,7 @@ import { callOrReturn } from '../utilities/callOrReturn.js'
 export function textblockTypeInputRule(config: {
   find: InputRuleFinder
   type: NodeType
-  getAttributes?:
-    | Record<string, any>
-    | ((match: ExtendedRegExpMatchArray) => Record<string, any>)
-    | false
-    | null
+  getAttributes?: Record<string, any> | ((match: ExtendedRegExpMatchArray) => Record<string, any>) | false | null
 }) {
   return new InputRule({
     find: config.find,
@@ -30,9 +26,7 @@ export function textblockTypeInputRule(config: {
         return null
       }
 
-      state.tr
-        .delete(range.from, range.to)
-        .setBlockType(range.from, range.from, config.type, attributes)
+      state.tr.delete(range.from, range.to).setBlockType(range.from, range.from, config.type, attributes)
     },
   })
 }

package/src/inputRules/wrappingInputRule.ts

@@ -22,24 +22,17 @@ import { callOrReturn } from '../utilities/callOrReturn.js'
  * @see https://tiptap.dev/docs/editor/extensions/custom-extensions/extend-existing#input-rules
  */
 export function wrappingInputRule(config: {
-  find: InputRuleFinder,
-  type: NodeType,
-  keepMarks?: boolean,
-  keepAttributes?: boolean,
+  find: InputRuleFinder
+  type: NodeType
+  keepMarks?: boolean
+  keepAttributes?: boolean
   editor?: Editor
-  getAttributes?:
-  | Record<string, any>
-  | ((match: ExtendedRegExpMatchArray) => Record<string, any>)
-  | false
-  | null
-  ,
-  joinPredicate?: (match: ExtendedRegExpMatchArray, node: ProseMirrorNode) => boolean,
+  getAttributes?: Record<string, any> | ((match: ExtendedRegExpMatchArray) => Record<string, any>) | false | null
+  joinPredicate?: (match: ExtendedRegExpMatchArray, node: ProseMirrorNode) => boolean
 }) {
   return new InputRule({
     find: config.find,
-    handler: ({
-      state, range, match, chain,
-    }) => {
+    handler: ({ state, range, match, chain }) => {
       const attributes = callOrReturn(config.getAttributes, undefined, match) || {}
       const tr = state.tr.delete(range.from, range.to)
       const $start = tr.doc.resolve(range.from)
@@ -65,7 +58,8 @@ export function wrappingInputRule(config: {
       }
       if (config.keepAttributes) {
         /** If the nodeType is `bulletList` or `orderedList` set the `nodeType` as `listItem` */
-        const nodeType = config.type.name === 'bulletList' || config.type.name === 'orderedList' ? 'listItem' : 'taskList'
+        const nodeType =
+          config.type.name === 'bulletList' || config.type.name === 'orderedList' ? 'listItem' : 'taskList'
 
         chain().updateAttributes(nodeType, attributes).run()
       }
@@ -73,10 +67,10 @@ export function wrappingInputRule(config: {
       const before = tr.doc.resolve(range.from - 1).nodeBefore
 
       if (
-        before
-        && before.type === config.type
-        && canJoin(tr.doc, range.from - 1)
-        && (!config.joinPredicate || config.joinPredicate(match, before))
+        before &&
+        before.type === config.type &&
+        canJoin(tr.doc, range.from - 1) &&
+        (!config.joinPredicate || config.joinPredicate(match, before))
       ) {
         tr.join(range.from - 1)
       }

package/src/pasteRules/markPasteRule.ts

@@ -21,9 +21,7 @@ export function markPasteRule(config: {
 }) {
   return new PasteRule({
     find: config.find,
-    handler: ({
-      state, range, match, pasteEvent,
-    }) => {
+    handler: ({ state, range, match, pasteEvent }) => {
       const attributes = callOrReturn(config.getAttributes, undefined, match, pasteEvent)
 
       if (attributes === false || attributes === null) {

package/src/pasteRules/nodePasteRule.ts

@@ -17,17 +17,11 @@ export function nodePasteRule(config: {
     | ((match: ExtendedRegExpMatchArray, event: ClipboardEvent) => Record<string, any>)
     | false
     | null
-  getContent?:
-    | JSONContent[]
-    | ((attrs: Record<string, any>) => JSONContent[])
-    | false
-    | null
+  getContent?: JSONContent[] | ((attrs: Record<string, any>) => JSONContent[]) | false | null
 }) {
   return new PasteRule({
     find: config.find,
-    handler({
-      match, chain, range, pasteEvent,
-    }) {
+    handler({ match, chain, range, pasteEvent }) {
       const attributes = callOrReturn(config.getAttributes, undefined, match, pasteEvent)
       const content = callOrReturn(config.getContent, undefined, attributes)
 

package/src/pasteRules/textPasteRule.ts

@@ -5,10 +5,7 @@ import { PasteRule, PasteRuleFinder } from '../PasteRule.js'
  * matched text is pasted into it.
  * @see https://tiptap.dev/docs/editor/extensions/custom-extensions/extend-existing#paste-rules
  */
-export function textPasteRule(config: {
-  find: PasteRuleFinder,
-  replace: string,
-}) {
+export function textPasteRule(config: { find: PasteRuleFinder; replace: string }) {
   return new PasteRule({
     find: config.find,
     handler: ({ state, range, match }) => {