@tiptap/core 3.0.0 → 3.0.2

package/src/commands/resetAttributes.ts

@@ -1,9 +1,9 @@
-import { MarkType, NodeType } from '@tiptap/pm/model'
+import type { MarkType, NodeType } from '@tiptap/pm/model'
 
 import { getMarkType } from '../helpers/getMarkType.js'
 import { getNodeType } from '../helpers/getNodeType.js'
 import { getSchemaTypeNameByName } from '../helpers/getSchemaTypeNameByName.js'
-import { RawCommands } from '../types.js'
+import type { RawCommands } from '../types.js'
 import { deleteProps } from '../utilities/deleteProps.js'
 
 declare module '@tiptap/core' {
@@ -15,56 +15,51 @@ declare module '@tiptap/core' {
        * @param attributes The attributes of the node to reset.
        * @example editor.commands.resetAttributes('heading', 'level')
        */
-      resetAttributes: (
-        typeOrName: string | NodeType | MarkType,
-        attributes: string | string[],
-      ) => ReturnType
+      resetAttributes: (typeOrName: string | NodeType | MarkType, attributes: string | string[]) => ReturnType
     }
   }
 }
 
-export const resetAttributes: RawCommands['resetAttributes'] = (typeOrName, attributes) => ({ tr, state, dispatch }) => {
-  let nodeType: NodeType | null = null
-  let markType: MarkType | null = null
+export const resetAttributes: RawCommands['resetAttributes'] =
+  (typeOrName, attributes) =>
+  ({ tr, state, dispatch }) => {
+    let nodeType: NodeType | null = null
+    let markType: MarkType | null = null
 
-  const schemaType = getSchemaTypeNameByName(
-    typeof typeOrName === 'string' ? typeOrName : typeOrName.name,
-    state.schema,
-  )
+    const schemaType = getSchemaTypeNameByName(
+      typeof typeOrName === 'string' ? typeOrName : typeOrName.name,
+      state.schema,
+    )
 
-  if (!schemaType) {
-    return false
-  }
+    if (!schemaType) {
+      return false
+    }
 
-  if (schemaType === 'node') {
-    nodeType = getNodeType(typeOrName as NodeType, state.schema)
-  }
+    if (schemaType === 'node') {
+      nodeType = getNodeType(typeOrName as NodeType, state.schema)
+    }
 
-  if (schemaType === 'mark') {
-    markType = getMarkType(typeOrName as MarkType, state.schema)
-  }
+    if (schemaType === 'mark') {
+      markType = getMarkType(typeOrName as MarkType, state.schema)
+    }
 
-  if (dispatch) {
-    tr.selection.ranges.forEach(range => {
-      state.doc.nodesBetween(range.$from.pos, range.$to.pos, (node, pos) => {
-        if (nodeType && nodeType === node.type) {
-          tr.setNodeMarkup(pos, undefined, deleteProps(node.attrs, attributes))
-        }
+    if (dispatch) {
+      tr.selection.ranges.forEach(range => {
+        state.doc.nodesBetween(range.$from.pos, range.$to.pos, (node, pos) => {
+          if (nodeType && nodeType === node.type) {
+            tr.setNodeMarkup(pos, undefined, deleteProps(node.attrs, attributes))
+          }
 
-        if (markType && node.marks.length) {
-          node.marks.forEach(mark => {
-            if (markType === mark.type) {
-              tr.addMark(
-                pos,
-                pos + node.nodeSize,
-                markType.create(deleteProps(mark.attrs, attributes)),
-              )
-            }
-          })
-        }
+          if (markType && node.marks.length) {
+            node.marks.forEach(mark => {
+              if (markType === mark.type) {
+                tr.addMark(pos, pos + node.nodeSize, markType.create(deleteProps(mark.attrs, attributes)))
+              }
+            })
+          }
+        })
       })
-    })
-  }
+    }
 
-  return true
-}
+    return true
+  }

package/src/commands/scrollIntoView.ts

@@ -1,4 +1,4 @@
-import { RawCommands } from '../types.js'
+import type { RawCommands } from '../types.js'
 
 declare module '@tiptap/core' {
   interface Commands<ReturnType> {
@@ -7,15 +7,17 @@ declare module '@tiptap/core' {
        * Scroll the selection into view.
        * @example editor.commands.scrollIntoView()
        */
-      scrollIntoView: () => ReturnType,
+      scrollIntoView: () => ReturnType
     }
   }
 }
 
-export const scrollIntoView: RawCommands['scrollIntoView'] = () => ({ tr, dispatch }) => {
-  if (dispatch) {
-    tr.scrollIntoView()
-  }
+export const scrollIntoView: RawCommands['scrollIntoView'] =
+  () =>
+  ({ tr, dispatch }) => {
+    if (dispatch) {
+      tr.scrollIntoView()
+    }
 
-  return true
-}
+    return true
+  }

package/src/commands/selectAll.ts

@@ -1,4 +1,6 @@
-import { RawCommands } from '../types.js'
+import { AllSelection } from '@tiptap/pm/state'
+
+import type { RawCommands } from '../types.js'
 
 declare module '@tiptap/core' {
   interface Commands<ReturnType> {
@@ -7,14 +9,19 @@ declare module '@tiptap/core' {
        * Select the whole document.
        * @example editor.commands.selectAll()
        */
-      selectAll: () => ReturnType,
+      selectAll: () => ReturnType
     }
   }
 }
 
-export const selectAll: RawCommands['selectAll'] = () => ({ tr, commands }) => {
-  return commands.setTextSelection({
-    from: 0,
-    to: tr.doc.content.size,
-  })
-}
+export const selectAll: RawCommands['selectAll'] =
+  () =>
+  ({ tr, dispatch }) => {
+    if (dispatch) {
+      const selection = new AllSelection(tr.doc)
+
+      tr.setSelection(selection)
+    }
+
+    return true
+  }

package/src/commands/selectNodeBackward.ts

@@ -1,6 +1,6 @@
 import { selectNodeBackward as originalSelectNodeBackward } from '@tiptap/pm/commands'
 
-import { RawCommands } from '../types.js'
+import type { RawCommands } from '../types.js'
 
 declare module '@tiptap/core' {
   interface Commands<ReturnType> {
@@ -14,6 +14,8 @@ declare module '@tiptap/core' {
   }
 }
 
-export const selectNodeBackward: RawCommands['selectNodeBackward'] = () => ({ state, dispatch }) => {
-  return originalSelectNodeBackward(state, dispatch)
-}
+export const selectNodeBackward: RawCommands['selectNodeBackward'] =
+  () =>
+  ({ state, dispatch }) => {
+    return originalSelectNodeBackward(state, dispatch)
+  }

package/src/commands/selectNodeForward.ts

@@ -1,6 +1,6 @@
 import { selectNodeForward as originalSelectNodeForward } from '@tiptap/pm/commands'
 
-import { RawCommands } from '../types.js'
+import type { RawCommands } from '../types.js'
 
 declare module '@tiptap/core' {
   interface Commands<ReturnType> {
@@ -14,6 +14,8 @@ declare module '@tiptap/core' {
   }
 }
 
-export const selectNodeForward: RawCommands['selectNodeForward'] = () => ({ state, dispatch }) => {
-  return originalSelectNodeForward(state, dispatch)
-}
+export const selectNodeForward: RawCommands['selectNodeForward'] =
+  () =>
+  ({ state, dispatch }) => {
+    return originalSelectNodeForward(state, dispatch)
+  }

package/src/commands/selectParentNode.ts

@@ -1,6 +1,6 @@
 import { selectParentNode as originalSelectParentNode } from '@tiptap/pm/commands'
 
-import { RawCommands } from '../types.js'
+import type { RawCommands } from '../types.js'
 
 declare module '@tiptap/core' {
   interface Commands<ReturnType> {
@@ -14,6 +14,8 @@ declare module '@tiptap/core' {
   }
 }
 
-export const selectParentNode: RawCommands['selectParentNode'] = () => ({ state, dispatch }) => {
-  return originalSelectParentNode(state, dispatch)
-}
+export const selectParentNode: RawCommands['selectParentNode'] =
+  () =>
+  ({ state, dispatch }) => {
+    return originalSelectParentNode(state, dispatch)
+  }

package/src/commands/selectTextblockEnd.ts

@@ -2,7 +2,7 @@
 // TODO: add types to @types/prosemirror-commands
 import { selectTextblockEnd as originalSelectTextblockEnd } from '@tiptap/pm/commands'
 
-import { RawCommands } from '../types.js'
+import type { RawCommands } from '../types.js'
 
 declare module '@tiptap/core' {
   interface Commands<ReturnType> {
@@ -16,6 +16,8 @@ declare module '@tiptap/core' {
   }
 }
 
-export const selectTextblockEnd: RawCommands['selectTextblockEnd'] = () => ({ state, dispatch }) => {
-  return originalSelectTextblockEnd(state, dispatch)
-}
+export const selectTextblockEnd: RawCommands['selectTextblockEnd'] =
+  () =>
+  ({ state, dispatch }) => {
+    return originalSelectTextblockEnd(state, dispatch)
+  }

package/src/commands/selectTextblockStart.ts

@@ -2,7 +2,7 @@
 // TODO: add types to @types/prosemirror-commands
 import { selectTextblockStart as originalSelectTextblockStart } from '@tiptap/pm/commands'
 
-import { RawCommands } from '../types.js'
+import type { RawCommands } from '../types.js'
 
 declare module '@tiptap/core' {
   interface Commands<ReturnType> {
@@ -16,6 +16,8 @@ declare module '@tiptap/core' {
   }
 }
 
-export const selectTextblockStart: RawCommands['selectTextblockStart'] = () => ({ state, dispatch }) => {
-  return originalSelectTextblockStart(state, dispatch)
-}
+export const selectTextblockStart: RawCommands['selectTextblockStart'] =
+  () =>
+  ({ state, dispatch }) => {
+    return originalSelectTextblockStart(state, dispatch)
+  }

package/src/commands/setContent.ts

@@ -1,7 +1,7 @@
-import { ParseOptions } from '@tiptap/pm/model'
+import type { Fragment, Node as ProseMirrorNode, ParseOptions } from '@tiptap/pm/model'
 
 import { createDocument } from '../helpers/createDocument.js'
-import { Content, RawCommands } from '../types.js'
+import type { Content, RawCommands } from '../types.js'
 
 declare module '@tiptap/core' {
   interface Commands<ReturnType> {
@@ -17,61 +17,58 @@ declare module '@tiptap/core' {
         /**
          * The new content.
          */
-        content: Content,
+        content: Content | Fragment | ProseMirrorNode,
 
-        /**
-         * Whether to emit an update event.
-         * @default false
-         */
-        emitUpdate?: boolean,
-
-        /**
-         * Options for parsing the content.
-         * @default {}
-         */
-        parseOptions?: ParseOptions,
         /**
          * Options for `setContent`.
          */
         options?: {
+          /**
+           * Options for parsing the content.
+           * @default {}
+           */
+          parseOptions?: ParseOptions
+
           /**
            * Whether to throw an error if the content is invalid.
            */
-           errorOnInvalidContent?: boolean
+          errorOnInvalidContent?: boolean
+
+          /**
+           * Whether to emit an update event.
+           * @default true
+           */
+          emitUpdate?: boolean
         },
       ) => ReturnType
     }
   }
 }
 
-export const setContent: RawCommands['setContent'] = (content, emitUpdate = false, parseOptions = {}, options = {}) => ({
-  editor, tr, dispatch, commands,
-}) => {
-  const { doc } = tr
+export const setContent: RawCommands['setContent'] =
+  (content, { errorOnInvalidContent, emitUpdate = true, parseOptions = {} } = {}) =>
+  ({ editor, tr, dispatch, commands }) => {
+    const { doc } = tr
 
-  // This is to keep backward compatibility with the previous behavior
-  // TODO remove this in the next major version
-  if (parseOptions.preserveWhitespace !== 'full') {
-    const document = createDocument(content, editor.schema, parseOptions, {
-      errorOnInvalidContent: options.errorOnInvalidContent ?? editor.options.enableContentCheck,
-    })
+    // This is to keep backward compatibility with the previous behavior
+    // TODO remove this in the next major version
+    if (parseOptions.preserveWhitespace !== 'full') {
+      const document = createDocument(content, editor.schema, parseOptions, {
+        errorOnInvalidContent: errorOnInvalidContent ?? editor.options.enableContentCheck,
+      })
 
-    if (dispatch) {
-      tr.replaceWith(0, doc.content.size, document).setMeta('preventUpdate', !emitUpdate)
+      if (dispatch) {
+        tr.replaceWith(0, doc.content.size, document).setMeta('preventUpdate', !emitUpdate)
+      }
+      return true
     }
-    return true
-  }
 
-  if (dispatch) {
-    tr.setMeta('preventUpdate', !emitUpdate)
-  }
+    if (dispatch) {
+      tr.setMeta('preventUpdate', !emitUpdate)
+    }
 
-  return commands.insertContentAt(
-    { from: 0, to: doc.content.size },
-    content,
-    {
+    return commands.insertContentAt({ from: 0, to: doc.content.size }, content, {
       parseOptions,
-      errorOnInvalidContent: options.errorOnInvalidContent ?? editor.options.enableContentCheck,
-    },
-  )
-}
+      errorOnInvalidContent: errorOnInvalidContent ?? editor.options.enableContentCheck,
+    })
+  }

package/src/commands/setMark.ts

@@ -1,10 +1,10 @@
-import { MarkType, ResolvedPos } from '@tiptap/pm/model'
-import { EditorState, Transaction } from '@tiptap/pm/state'
+import type { MarkType, ResolvedPos } from '@tiptap/pm/model'
+import type { EditorState, Transaction } from '@tiptap/pm/state'
 
 import { getMarkAttributes } from '../helpers/getMarkAttributes.js'
 import { getMarkType } from '../helpers/getMarkType.js'
 import { isTextSelection } from '../helpers/index.js'
-import { RawCommands } from '../types.js'
+import type { RawCommands } from '../types.js'
 
 declare module '@tiptap/core' {
   interface Commands<ReturnType> {
@@ -31,18 +31,14 @@ function canSetMark(state: EditorState, tr: Transaction, newMarkType: MarkType)
     const currentMarks = state.storedMarks ?? cursor.marks()
 
     // There can be no current marks that exclude the new mark
-    return (
-      !!newMarkType.isInSet(currentMarks)
-      || !currentMarks.some(mark => mark.type.excludes(newMarkType))
-    )
+    return !!newMarkType.isInSet(currentMarks) || !currentMarks.some(mark => mark.type.excludes(newMarkType))
   }
 
   const { ranges } = selection
 
   return ranges.some(({ $from, $to }) => {
-    let someNodeSupportsMark = $from.depth === 0
-      ? state.doc.inlineContent && state.doc.type.allowsMarkType(newMarkType)
-      : false
+    let someNodeSupportsMark =
+      $from.depth === 0 ? state.doc.inlineContent && state.doc.type.allowsMarkType(newMarkType) : false
 
     state.doc.nodesBetween($from.pos, $to.pos, (node, _pos, parent) => {
       // If we already found a mark that we can enable, return false to bypass the remaining search
@@ -52,8 +48,8 @@ function canSetMark(state: EditorState, tr: Transaction, newMarkType: MarkType)
 
       if (node.isInline) {
         const parentAllowsMarkType = !parent || parent.type.allowsMarkType(newMarkType)
-        const currentMarksAllowMarkType = !!newMarkType.isInSet(node.marks)
-          || !node.marks.some(otherMark => otherMark.type.excludes(newMarkType))
+        const currentMarksAllowMarkType =
+          !!newMarkType.isInSet(node.marks) || !node.marks.some(otherMark => otherMark.type.excludes(newMarkType))
 
         someNodeSupportsMark = parentAllowsMarkType && currentMarksAllowMarkType
       }
@@ -63,54 +59,56 @@ function canSetMark(state: EditorState, tr: Transaction, newMarkType: MarkType)
     return someNodeSupportsMark
   })
 }
-export const setMark: RawCommands['setMark'] = (typeOrName, attributes = {}) => ({ tr, state, dispatch }) => {
-  const { selection } = tr
-  const { empty, ranges } = selection
-  const type = getMarkType(typeOrName, state.schema)
-
-  if (dispatch) {
-    if (empty) {
-      const oldAttributes = getMarkAttributes(state, type)
-
-      tr.addStoredMark(
-        type.create({
-          ...oldAttributes,
-          ...attributes,
-        }),
-      )
-    } else {
-      ranges.forEach(range => {
-        const from = range.$from.pos
-        const to = range.$to.pos
-
-        state.doc.nodesBetween(from, to, (node, pos) => {
-          const trimmedFrom = Math.max(pos, from)
-          const trimmedTo = Math.min(pos + node.nodeSize, to)
-          const someHasMark = node.marks.find(mark => mark.type === type)
-
-          // if there is already a mark of this type
-          // we know that we have to merge its attributes
-          // otherwise we add a fresh new mark
-          if (someHasMark) {
-            node.marks.forEach(mark => {
-              if (type === mark.type) {
-                tr.addMark(
-                  trimmedFrom,
-                  trimmedTo,
-                  type.create({
-                    ...mark.attrs,
-                    ...attributes,
-                  }),
-                )
-              }
-            })
-          } else {
-            tr.addMark(trimmedFrom, trimmedTo, type.create(attributes))
-          }
+export const setMark: RawCommands['setMark'] =
+  (typeOrName, attributes = {}) =>
+  ({ tr, state, dispatch }) => {
+    const { selection } = tr
+    const { empty, ranges } = selection
+    const type = getMarkType(typeOrName, state.schema)
+
+    if (dispatch) {
+      if (empty) {
+        const oldAttributes = getMarkAttributes(state, type)
+
+        tr.addStoredMark(
+          type.create({
+            ...oldAttributes,
+            ...attributes,
+          }),
+        )
+      } else {
+        ranges.forEach(range => {
+          const from = range.$from.pos
+          const to = range.$to.pos
+
+          state.doc.nodesBetween(from, to, (node, pos) => {
+            const trimmedFrom = Math.max(pos, from)
+            const trimmedTo = Math.min(pos + node.nodeSize, to)
+            const someHasMark = node.marks.find(mark => mark.type === type)
+
+            // if there is already a mark of this type
+            // we know that we have to merge its attributes
+            // otherwise we add a fresh new mark
+            if (someHasMark) {
+              node.marks.forEach(mark => {
+                if (type === mark.type) {
+                  tr.addMark(
+                    trimmedFrom,
+                    trimmedTo,
+                    type.create({
+                      ...mark.attrs,
+                      ...attributes,
+                    }),
+                  )
+                }
+              })
+            } else {
+              tr.addMark(trimmedFrom, trimmedTo, type.create(attributes))
+            }
+          })
         })
-      })
+      }
     }
-  }
 
-  return canSetMark(state, tr, type)
-}
+    return canSetMark(state, tr, type)
+  }

package/src/commands/setMeta.ts

@@ -1,4 +1,6 @@
-import { RawCommands } from '../types.js'
+import type { Plugin, PluginKey } from '@tiptap/pm/state'
+
+import type { RawCommands } from '../types.js'
 
 declare module '@tiptap/core' {
   interface Commands<ReturnType> {
@@ -9,13 +11,15 @@ declare module '@tiptap/core' {
        * @param value The value to store.
        * @example editor.commands.setMeta('foo', 'bar')
        */
-      setMeta: (key: string, value: any) => ReturnType,
+      setMeta: (key: string | Plugin | PluginKey, value: any) => ReturnType
     }
   }
 }
 
-export const setMeta: RawCommands['setMeta'] = (key, value) => ({ tr }) => {
-  tr.setMeta(key, value)
+export const setMeta: RawCommands['setMeta'] =
+  (key, value) =>
+  ({ tr }) => {
+    tr.setMeta(key, value)
 
-  return true
-}
+    return true
+  }

package/src/commands/setNode.ts

@@ -1,8 +1,8 @@
 import { setBlockType } from '@tiptap/pm/commands'
-import { NodeType } from '@tiptap/pm/model'
+import type { NodeType } from '@tiptap/pm/model'
 
 import { getNodeType } from '../helpers/getNodeType.js'
-import { RawCommands } from '../types.js'
+import type { RawCommands } from '../types.js'
 
 declare module '@tiptap/core' {
   interface Commands<ReturnType> {
@@ -18,31 +18,40 @@ declare module '@tiptap/core' {
   }
 }
 
-export const setNode: RawCommands['setNode'] = (typeOrName, attributes = {}) => ({ state, dispatch, chain }) => {
-  const type = getNodeType(typeOrName, state.schema)
+export const setNode: RawCommands['setNode'] =
+  (typeOrName, attributes = {}) =>
+  ({ state, dispatch, chain }) => {
+    const type = getNodeType(typeOrName, state.schema)
 
-  // TODO: use a fallback like insertContent?
-  if (!type.isTextblock) {
-    console.warn('[tiptap warn]: Currently "setNode()" only supports text block nodes.')
+    let attributesToCopy: Record<string, any> | undefined
 
-    return false
-  }
+    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
+    }
 
-  return (
-    chain()
-    // try to convert node to default node if needed
-      .command(({ commands }) => {
-        const canSetBlock = setBlockType(type, attributes)(state)
-
-        if (canSetBlock) {
-          return true
-        }
-
-        return commands.clearNodes()
-      })
-      .command(({ state: updatedState }) => {
-        return setBlockType(type, attributes)(updatedState, dispatch)
-      })
-      .run()
-  )
-}
+    // TODO: use a fallback like insertContent?
+    if (!type.isTextblock) {
+      console.warn('[tiptap warn]: Currently "setNode()" only supports text block nodes.')
+
+      return false
+    }
+
+    return (
+      chain()
+        // try to convert node to default node if needed
+        .command(({ commands }) => {
+          const canSetBlock = setBlockType(type, { ...attributesToCopy, ...attributes })(state)
+
+          if (canSetBlock) {
+            return true
+          }
+
+          return commands.clearNodes()
+        })
+        .command(({ state: updatedState }) => {
+          return setBlockType(type, { ...attributesToCopy, ...attributes })(updatedState, dispatch)
+        })
+        .run()
+    )
+  }