@tiptap/core 2.9.1 → 2.10.1

package/src/commands/setContent.ts

@@ -1,4 +1,4 @@
-import { ParseOptions } from '@tiptap/pm/model'
+import { Fragment, Node as ProseMirrorNode, ParseOptions } from '@tiptap/pm/model'
 
 import { createDocument } from '../helpers/createDocument.js'
 import { Content, RawCommands } from '../types.js'
@@ -17,7 +17,7 @@ declare module '@tiptap/core' {
         /**
          * The new content.
          */
-        content: Content,
+        content: Content | Fragment | ProseMirrorNode,
 
         /**
          * Whether to emit an update event.
@@ -37,10 +37,10 @@ declare module '@tiptap/core' {
           /**
            * Whether to throw an error if the content is invalid.
            */
-           errorOnInvalidContent?: boolean
-        },
-      ) => ReturnType
-    }
+          errorOnInvalidContent?: boolean;
+        }
+      ) => ReturnType;
+    };
   }
 }
 
@@ -66,12 +66,8 @@ export const setContent: RawCommands['setContent'] = (content, emitUpdate = fals
     tr.setMeta('preventUpdate', !emitUpdate)
   }
 
-  return commands.insertContentAt(
-    { from: 0, to: doc.content.size },
-    content,
-    {
-      parseOptions,
-      errorOnInvalidContent: options.errorOnInvalidContent ?? editor.options.enableContentCheck,
-    },
-  )
+  return commands.insertContentAt({ from: 0, to: doc.content.size }, content, {
+    parseOptions,
+    errorOnInvalidContent: options.errorOnInvalidContent ?? editor.options.enableContentCheck,
+  })
 }

package/src/commands/setNode.ts

@@ -21,6 +21,13 @@ declare module '@tiptap/core' {
 export const setNode: RawCommands['setNode'] = (typeOrName, attributes = {}) => ({ state, dispatch, chain }) => {
   const type = getNodeType(typeOrName, state.schema)
 
+  let attributesToCopy: Record<string, any> | undefined
+
+  if (state.selection.$anchor.sameParent(state.selection.$head)) {
+    // only copy attributes if the selection is pointing to a node of the same type
+    attributesToCopy = state.selection.$anchor.parent.attrs
+  }
+
   // TODO: use a fallback like insertContent?
   if (!type.isTextblock) {
     console.warn('[tiptap warn]: Currently "setNode()" only supports text block nodes.')
@@ -32,7 +39,7 @@ export const setNode: RawCommands['setNode'] = (typeOrName, attributes = {}) =>
     chain()
     // try to convert node to default node if needed
       .command(({ commands }) => {
-        const canSetBlock = setBlockType(type, attributes)(state)
+        const canSetBlock = setBlockType(type, { ...attributesToCopy, ...attributes })(state)
 
         if (canSetBlock) {
           return true
@@ -41,7 +48,7 @@ export const setNode: RawCommands['setNode'] = (typeOrName, attributes = {}) =>
         return commands.clearNodes()
       })
       .command(({ state: updatedState }) => {
-        return setBlockType(type, attributes)(updatedState, dispatch)
+        return setBlockType(type, { ...attributesToCopy, ...attributes })(updatedState, dispatch)
       })
       .run()
   )

package/src/commands/updateAttributes.ts

@@ -1,4 +1,7 @@
-import { MarkType, NodeType } from '@tiptap/pm/model'
+import {
+  Mark, MarkType, Node, NodeType,
+} from '@tiptap/pm/model'
+import { SelectionRange } from '@tiptap/pm/state'
 
 import { getMarkType } from '../helpers/getMarkType.js'
 import { getNodeType } from '../helpers/getNodeType.js'
@@ -30,6 +33,7 @@ declare module '@tiptap/core' {
 }
 
 export const updateAttributes: RawCommands['updateAttributes'] = (typeOrName, attributes = {}) => ({ tr, state, dispatch }) => {
+
   let nodeType: NodeType | null = null
   let markType: MarkType | null = null
 
@@ -51,24 +55,80 @@ export const updateAttributes: RawCommands['updateAttributes'] = (typeOrName, at
   }
 
   if (dispatch) {
-    tr.selection.ranges.forEach(range => {
+    tr.selection.ranges.forEach((range: SelectionRange) => {
+
       const from = range.$from.pos
       const to = range.$to.pos
 
-      state.doc.nodesBetween(from, to, (node, pos) => {
-        if (nodeType && nodeType === node.type) {
-          tr.setNodeMarkup(pos, undefined, {
-            ...node.attrs,
+      let lastPos: number | undefined
+      let lastNode: Node | undefined
+      let trimmedFrom: number
+      let trimmedTo: number
+
+      if (tr.selection.empty) {
+        state.doc.nodesBetween(from, to, (node: Node, pos: number) => {
+
+          if (nodeType && nodeType === node.type) {
+            trimmedFrom = Math.max(pos, from)
+            trimmedTo = Math.min(pos + node.nodeSize, to)
+            lastPos = pos
+            lastNode = node
+          }
+        })
+      } else {
+        state.doc.nodesBetween(from, to, (node: Node, pos: number) => {
+
+          if (pos < from && nodeType && nodeType === node.type) {
+            trimmedFrom = Math.max(pos, from)
+            trimmedTo = Math.min(pos + node.nodeSize, to)
+            lastPos = pos
+            lastNode = node
+          }
+
+          if (pos >= from && pos <= to) {
+
+            if (nodeType && nodeType === node.type) {
+              tr.setNodeMarkup(pos, undefined, {
+                ...node.attrs,
+                ...attributes,
+              })
+            }
+
+            if (markType && node.marks.length) {
+              node.marks.forEach((mark: Mark) => {
+
+                if (markType === mark.type) {
+                  const trimmedFrom2 = Math.max(pos, from)
+                  const trimmedTo2 = Math.min(pos + node.nodeSize, to)
+
+                  tr.addMark(
+                    trimmedFrom2,
+                    trimmedTo2,
+                    markType.create({
+                      ...mark.attrs,
+                      ...attributes,
+                    }),
+                  )
+                }
+              })
+            }
+          }
+        })
+      }
+
+      if (lastNode) {
+
+        if (lastPos !== undefined) {
+          tr.setNodeMarkup(lastPos, undefined, {
+            ...lastNode.attrs,
             ...attributes,
           })
         }
 
-        if (markType && node.marks.length) {
-          node.marks.forEach(mark => {
-            if (markType === mark.type) {
-              const trimmedFrom = Math.max(pos, from)
-              const trimmedTo = Math.min(pos + node.nodeSize, to)
+        if (markType && lastNode.marks.length) {
+          lastNode.marks.forEach((mark: Mark) => {
 
+            if (markType === mark.type) {
               tr.addMark(
                 trimmedFrom,
                 trimmedTo,
@@ -80,7 +140,7 @@ export const updateAttributes: RawCommands['updateAttributes'] = (typeOrName, at
             }
           })
         }
-      })
+      }
     })
   }
 

package/src/helpers/createDocument.ts

@@ -1,4 +1,6 @@
-import { Node as ProseMirrorNode, ParseOptions, Schema } from '@tiptap/pm/model'
+import {
+  Fragment, Node as ProseMirrorNode, ParseOptions, Schema,
+} from '@tiptap/pm/model'
 
 import { Content } from '../types.js'
 import { createNodeFromContent } from './createNodeFromContent.js'
@@ -11,7 +13,7 @@ import { createNodeFromContent } from './createNodeFromContent.js'
  * @returns The created Prosemirror document node
  */
 export function createDocument(
-  content: Content,
+  content: Content | ProseMirrorNode | Fragment,
   schema: Schema,
   parseOptions: ParseOptions = {},
   options: { errorOnInvalidContent?: boolean } = {},

package/src/helpers/createNodeFromContent.ts

@@ -23,10 +23,13 @@ export type CreateNodeFromContentOptions = {
  * @returns The created Prosemirror node or fragment
  */
 export function createNodeFromContent(
-  content: Content,
+  content: Content | ProseMirrorNode | Fragment,
   schema: Schema,
   options?: CreateNodeFromContentOptions,
 ): ProseMirrorNode | Fragment {
+  if (content instanceof ProseMirrorNode || content instanceof Fragment) {
+    return content
+  }
   options = {
     slice: true,
     parseOptions: {},

package/src/helpers/getMarkRange.ts

@@ -9,7 +9,14 @@ function findMarkInSet(
   attributes: Record<string, any> = {},
 ): ProseMirrorMark | undefined {
   return marks.find(item => {
-    return item.type === type && objectIncludes(item.attrs, attributes)
+    return (
+      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,
+      )
+    )
   })
 }
 
@@ -21,10 +28,23 @@ function isMarkInSet(
   return !!findMarkInSet(marks, type, attributes)
 }
 
+/**
+ * Get the range of a mark at a resolved position.
+ */
 export function getMarkRange(
+  /**
+   * The position to get the mark range for.
+   */
   $pos: ResolvedPos,
+  /**
+   * The mark type to get the range for.
+   */
   type: MarkType,
-  attributes: Record<string, any> = {},
+  /**
+   * The attributes to match against.
+   * If not provided, only the first mark at the position will be matched.
+   */
+  attributes?: Record<string, any>,
 ): Range | void {
   if (!$pos || !type) {
     return
@@ -41,6 +61,9 @@ export function getMarkRange(
     return
   }
 
+  // Default to only matching against the first mark's attributes
+  attributes = attributes || start.node.marks[0]?.attrs
+
   // We now know that the cursor is either at the start, middle or end of a text node with the specified mark
   // so we can look it up on the targeted mark
   const mark = findMarkInSet([...start.node.marks], type, attributes)
@@ -54,9 +77,10 @@ export function getMarkRange(
   let endIndex = startIndex + 1
   let endPos = startPos + start.node.nodeSize
 
-  findMarkInSet([...start.node.marks], type, attributes)
-
-  while (startIndex > 0 && mark.isInSet($pos.parent.child(startIndex - 1).marks)) {
+  while (
+    startIndex > 0
+    && isMarkInSet([...$pos.parent.child(startIndex - 1).marks], type, attributes)
+  ) {
     startIndex -= 1
     startPos -= $pos.parent.child(startIndex).nodeSize
   }

package/src/helpers/getSchemaByResolvedExtensions.ts

@@ -78,6 +78,7 @@ export function getSchemaByResolvedExtensions(extensions: Extensions, editor?: E
         ),
         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),
         ),

package/src/inputRules/markInputRule.ts

@@ -8,7 +8,7 @@ import { callOrReturn } from '../utilities/callOrReturn.js'
 /**
  * Build an input rule that adds a mark when the
  * matched text is typed into it.
- * @see https://tiptap.dev/guide/custom-extensions/#input-rules
+ * @see https://tiptap.dev/docs/editor/extensions/custom-extensions/extend-existing#input-rules
  */
 export function markInputRule(config: {
   find: InputRuleFinder

package/src/inputRules/nodeInputRule.ts

@@ -7,7 +7,7 @@ import { callOrReturn } from '../utilities/callOrReturn.js'
 /**
  * Build an input rule that adds a node when the
  * matched text is typed into it.
- * @see https://tiptap.dev/guide/custom-extensions/#input-rules
+ * @see https://tiptap.dev/docs/editor/extensions/custom-extensions/extend-existing#input-rules
  */
 export function nodeInputRule(config: {
   /**

package/src/inputRules/textInputRule.ts

@@ -3,7 +3,7 @@ import { InputRule, InputRuleFinder } from '../InputRule.js'
 /**
  * Build an input rule that replaces text when the
  * matched text is typed into it.
- * @see https://tiptap.dev/guide/custom-extensions/#input-rules
+ * @see https://tiptap.dev/docs/editor/extensions/custom-extensions/extend-existing#input-rules
  */
 export function textInputRule(config: {
   find: InputRuleFinder,

package/src/inputRules/textblockTypeInputRule.ts

@@ -9,7 +9,7 @@ import { callOrReturn } from '../utilities/callOrReturn.js'
  * matched text is typed into it. When using a regular expresion you’ll
  * probably want the regexp to start with `^`, so that the pattern can
  * only occur at the start of a textblock.
- * @see https://tiptap.dev/guide/custom-extensions/#input-rules
+ * @see https://tiptap.dev/docs/editor/extensions/custom-extensions/extend-existing#input-rules
  */
 export function textblockTypeInputRule(config: {
   find: InputRuleFinder

package/src/inputRules/wrappingInputRule.ts

@@ -19,7 +19,7 @@ import { callOrReturn } from '../utilities/callOrReturn.js'
  * two nodes. You can pass a join predicate, which takes a regular
  * expression match and the node before the wrapped node, and can
  * return a boolean to indicate whether a join should happen.
- * @see https://tiptap.dev/guide/custom-extensions/#input-rules
+ * @see https://tiptap.dev/docs/editor/extensions/custom-extensions/extend-existing#input-rules
  */
 export function wrappingInputRule(config: {
   find: InputRuleFinder,

package/src/pasteRules/markPasteRule.ts

@@ -8,7 +8,7 @@ import { callOrReturn } from '../utilities/callOrReturn.js'
 /**
  * Build an paste rule that adds a mark when the
  * matched text is pasted into it.
- * @see https://tiptap.dev/guide/custom-extensions/#paste-rules
+ * @see https://tiptap.dev/docs/editor/extensions/custom-extensions/extend-existing#paste-rules
  */
 export function markPasteRule(config: {
   find: PasteRuleFinder

package/src/pasteRules/nodePasteRule.ts

@@ -7,7 +7,7 @@ import { callOrReturn } from '../utilities/index.js'
 /**
  * Build an paste rule that adds a node when the
  * matched text is pasted into it.
- * @see https://tiptap.dev/guide/custom-extensions/#paste-rules
+ * @see https://tiptap.dev/docs/editor/extensions/custom-extensions/extend-existing#paste-rules
  */
 export function nodePasteRule(config: {
   find: PasteRuleFinder

package/src/pasteRules/textPasteRule.ts

@@ -3,7 +3,7 @@ import { PasteRule, PasteRuleFinder } from '../PasteRule.js'
 /**
  * Build an paste rule that replaces text when the
  * matched text is pasted into it.
- * @see https://tiptap.dev/guide/custom-extensions/#paste-rules
+ * @see https://tiptap.dev/docs/editor/extensions/custom-extensions/extend-existing#paste-rules
  */
 export function textPasteRule(config: {
   find: PasteRuleFinder,