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

package/src/commands/deleteCurrentNode.ts

@@ -7,36 +7,38 @@ declare module '@tiptap/core' {
        * Delete the node that currently has the selection anchor.
        * @example editor.commands.deleteCurrentNode()
        */
-      deleteCurrentNode: () => ReturnType,
+      deleteCurrentNode: () => ReturnType
     }
   }
 }
 
-export const deleteCurrentNode: RawCommands['deleteCurrentNode'] = () => ({ tr, dispatch }) => {
-  const { selection } = tr
-  const currentNode = selection.$anchor.node()
+export const deleteCurrentNode: RawCommands['deleteCurrentNode'] =
+  () =>
+  ({ tr, dispatch }) => {
+    const { selection } = tr
+    const currentNode = selection.$anchor.node()
 
-  // if there is content inside the current node, break out of this command
-  if (currentNode.content.size > 0) {
-    return false
-  }
+    // if there is content inside the current node, break out of this command
+    if (currentNode.content.size > 0) {
+      return false
+    }
 
-  const $pos = tr.selection.$anchor
+    const $pos = tr.selection.$anchor
 
-  for (let depth = $pos.depth; depth > 0; depth -= 1) {
-    const node = $pos.node(depth)
+    for (let depth = $pos.depth; depth > 0; depth -= 1) {
+      const node = $pos.node(depth)
 
-    if (node.type === currentNode.type) {
-      if (dispatch) {
-        const from = $pos.before(depth)
-        const to = $pos.after(depth)
+      if (node.type === currentNode.type) {
+        if (dispatch) {
+          const from = $pos.before(depth)
+          const to = $pos.after(depth)
 
-        tr.delete(from, to).scrollIntoView()
-      }
+          tr.delete(from, to).scrollIntoView()
+        }
 
-      return true
+        return true
+      }
     }
-  }
 
-  return false
-}
+    return false
+  }

package/src/commands/deleteNode.ts

@@ -11,29 +11,31 @@ declare module '@tiptap/core' {
        * @param typeOrName The type or name of the node.
        * @example editor.commands.deleteNode('paragraph')
        */
-      deleteNode: (typeOrName: string | NodeType) => ReturnType,
+      deleteNode: (typeOrName: string | NodeType) => ReturnType
     }
   }
 }
 
-export const deleteNode: RawCommands['deleteNode'] = typeOrName => ({ tr, state, dispatch }) => {
-  const type = getNodeType(typeOrName, state.schema)
-  const $pos = tr.selection.$anchor
+export const deleteNode: RawCommands['deleteNode'] =
+  typeOrName =>
+  ({ tr, state, dispatch }) => {
+    const type = getNodeType(typeOrName, state.schema)
+    const $pos = tr.selection.$anchor
 
-  for (let depth = $pos.depth; depth > 0; depth -= 1) {
-    const node = $pos.node(depth)
+    for (let depth = $pos.depth; depth > 0; depth -= 1) {
+      const node = $pos.node(depth)
 
-    if (node.type === type) {
-      if (dispatch) {
-        const from = $pos.before(depth)
-        const to = $pos.after(depth)
+      if (node.type === type) {
+        if (dispatch) {
+          const from = $pos.before(depth)
+          const to = $pos.after(depth)
 
-        tr.delete(from, to).scrollIntoView()
-      }
+          tr.delete(from, to).scrollIntoView()
+        }
 
-      return true
+        return true
+      }
     }
-  }
 
-  return false
-}
+    return false
+  }

package/src/commands/deleteRange.ts

@@ -8,17 +8,19 @@ declare module '@tiptap/core' {
        * @param range The range to delete.
        * @example editor.commands.deleteRange({ from: 1, to: 3 })
        */
-      deleteRange: (range: Range) => ReturnType,
+      deleteRange: (range: Range) => ReturnType
     }
   }
 }
 
-export const deleteRange: RawCommands['deleteRange'] = range => ({ tr, dispatch }) => {
-  const { from, to } = range
+export const deleteRange: RawCommands['deleteRange'] =
+  range =>
+  ({ tr, dispatch }) => {
+    const { from, to } = range
 
-  if (dispatch) {
-    tr.delete(from, to)
-  }
+    if (dispatch) {
+      tr.delete(from, to)
+    }
 
-  return true
-}
+    return true
+  }

package/src/commands/deleteSelection.ts

@@ -14,6 +14,8 @@ declare module '@tiptap/core' {
   }
 }
 
-export const deleteSelection: RawCommands['deleteSelection'] = () => ({ state, dispatch }) => {
-  return originalDeleteSelection(state, dispatch)
-}
+export const deleteSelection: RawCommands['deleteSelection'] =
+  () =>
+  ({ state, dispatch }) => {
+    return originalDeleteSelection(state, dispatch)
+  }

package/src/commands/enter.ts

@@ -7,11 +7,13 @@ declare module '@tiptap/core' {
        * Trigger enter.
        * @example editor.commands.enter()
        */
-      enter: () => ReturnType,
+      enter: () => ReturnType
     }
   }
 }
 
-export const enter: RawCommands['enter'] = () => ({ commands }) => {
-  return commands.keyboardShortcut('Enter')
-}
+export const enter: RawCommands['enter'] =
+  () =>
+  ({ commands }) => {
+    return commands.keyboardShortcut('Enter')
+  }

package/src/commands/exitCode.ts

@@ -14,6 +14,8 @@ declare module '@tiptap/core' {
   }
 }
 
-export const exitCode: RawCommands['exitCode'] = () => ({ state, dispatch }) => {
-  return originalExitCode(state, dispatch)
-}
+export const exitCode: RawCommands['exitCode'] =
+  () =>
+  ({ state, dispatch }) => {
+    return originalExitCode(state, dispatch)
+  }

package/src/commands/extendMarkRange.ts

@@ -30,20 +30,22 @@ declare module '@tiptap/core' {
   }
 }
 
-export const extendMarkRange: RawCommands['extendMarkRange'] = (typeOrName, attributes = {}) => ({ tr, state, dispatch }) => {
-  const type = getMarkType(typeOrName, state.schema)
-  const { doc, selection } = tr
-  const { $from, from, to } = selection
+export const extendMarkRange: RawCommands['extendMarkRange'] =
+  (typeOrName, attributes = {}) =>
+  ({ tr, state, dispatch }) => {
+    const type = getMarkType(typeOrName, state.schema)
+    const { doc, selection } = tr
+    const { $from, from, to } = selection
 
-  if (dispatch) {
-    const range = getMarkRange($from, type, attributes)
+    if (dispatch) {
+      const range = getMarkRange($from, type, attributes)
 
-    if (range && range.from <= from && range.to >= to) {
-      const newSelection = TextSelection.create(doc, range.from, range.to)
+      if (range && range.from <= from && range.to >= to) {
+        const newSelection = TextSelection.create(doc, range.from, range.to)
 
-      tr.setSelection(newSelection)
+        tr.setSelection(newSelection)
+      }
     }
-  }
 
-  return true
-}
+    return true
+  }

package/src/commands/first.ts

@@ -8,15 +8,13 @@ declare module '@tiptap/core' {
        * @param commands The commands to run.
        * @example editor.commands.first([command1, command2])
        */
-      first: (commands: Command[] | ((props: CommandProps) => Command[])) => ReturnType,
+      first: (commands: Command[] | ((props: CommandProps) => Command[])) => ReturnType
     }
   }
 }
 
 export const first: RawCommands['first'] = commands => props => {
-  const items = typeof commands === 'function'
-    ? commands(props)
-    : commands
+  const items = typeof commands === 'function' ? commands(props) : commands
 
   for (let i = 0; i < items.length; i += 1) {
     if (items[i](props)) {

package/src/commands/focus.ts

@@ -23,68 +23,65 @@ declare module '@tiptap/core' {
          * @default { scrollIntoView: true }
          */
         options?: {
-          scrollIntoView?: boolean,
+          scrollIntoView?: boolean
         },
-      ) => ReturnType,
+      ) => ReturnType
     }
   }
 }
 
-export const focus: RawCommands['focus'] = (position = null, options = {}) => ({
-  editor,
-  view,
-  tr,
-  dispatch,
-}) => {
-  options = {
-    scrollIntoView: true,
-    ...options,
-  }
+export const focus: RawCommands['focus'] =
+  (position = null, options = {}) =>
+  ({ editor, view, tr, dispatch }) => {
+    options = {
+      scrollIntoView: true,
+      ...options,
+    }
 
-  const delayedFocus = () => {
-    (view.dom as HTMLElement).focus()
+    const delayedFocus = () => {
+      ;(view.dom as HTMLElement).focus()
 
-    // For React we have to focus asynchronously. Otherwise wild things happen.
-    // see: https://github.com/ueberdosis/tiptap/issues/1520
-    requestAnimationFrame(() => {
-      if (!editor.isDestroyed) {
-        view.focus()
+      // For React we have to focus asynchronously. Otherwise wild things happen.
+      // see: https://github.com/ueberdosis/tiptap/issues/1520
+      requestAnimationFrame(() => {
+        if (!editor.isDestroyed) {
+          view.focus()
 
-        if (options?.scrollIntoView) {
-          editor.commands.scrollIntoView()
+          if (options?.scrollIntoView) {
+            editor.commands.scrollIntoView()
+          }
         }
-      }
-    })
-  }
+      })
+    }
 
-  if ((view.hasFocus() && position === null) || position === false) {
-    return true
-  }
+    if ((view.hasFocus() && position === null) || position === false) {
+      return true
+    }
 
-  // we don’t try to resolve a NodeSelection or CellSelection
-  if (dispatch && position === null && !isTextSelection(editor.state.selection)) {
-    delayedFocus()
-    return true
-  }
+    // we don’t try to resolve a NodeSelection or CellSelection
+    if (dispatch && position === null && !isTextSelection(editor.state.selection)) {
+      delayedFocus()
+      return true
+    }
 
-  // pass through tr.doc instead of editor.state.doc
-  // since transactions could change the editors state before this command has been run
-  const selection = resolveFocusPosition(tr.doc, position) || editor.state.selection
-  const isSameSelection = editor.state.selection.eq(selection)
+    // pass through tr.doc instead of editor.state.doc
+    // since transactions could change the editors state before this command has been run
+    const selection = resolveFocusPosition(tr.doc, position) || editor.state.selection
+    const isSameSelection = editor.state.selection.eq(selection)
 
-  if (dispatch) {
-    if (!isSameSelection) {
-      tr.setSelection(selection)
-    }
+    if (dispatch) {
+      if (!isSameSelection) {
+        tr.setSelection(selection)
+      }
 
-    // `tr.setSelection` resets the stored marks
-    // so we’ll restore them if the selection is the same as before
-    if (isSameSelection && tr.storedMarks) {
-      tr.setStoredMarks(tr.storedMarks)
+      // `tr.setSelection` resets the stored marks
+      // so we’ll restore them if the selection is the same as before
+      if (isSameSelection && tr.storedMarks) {
+        tr.setStoredMarks(tr.storedMarks)
+      }
+
+      delayedFocus()
     }
 
-    delayedFocus()
+    return true
   }
-
-  return true
-}

package/src/commands/forEach.ts

@@ -11,10 +11,10 @@ declare module '@tiptap/core' {
         fn: (
           item: T,
           props: CommandProps & {
-            index: number,
+            index: number
           },
         ) => boolean,
-      ) => ReturnType,
+      ) => ReturnType
     }
   }
 }

package/src/commands/insertContent.ts

@@ -23,24 +23,22 @@ declare module '@tiptap/core' {
           /**
            * Options for parsing the content.
            */
-          parseOptions?: ParseOptions;
+          parseOptions?: ParseOptions
 
           /**
            * Whether to update the selection after inserting the content.
            */
-          updateSelection?: boolean;
-          applyInputRules?: boolean;
-          applyPasteRules?: boolean;
-        }
-      ) => ReturnType;
-    };
+          updateSelection?: boolean
+          applyInputRules?: boolean
+          applyPasteRules?: boolean
+        },
+      ) => ReturnType
+    }
   }
 }
 
-export const insertContent: RawCommands['insertContent'] = (value, options) => ({ tr, commands }) => {
-  return commands.insertContentAt(
-    { from: tr.selection.from, to: tr.selection.to },
-    value,
-    options,
-  )
-}
+export const insertContent: RawCommands['insertContent'] =
+  (value, options) =>
+  ({ tr, commands }) => {
+    return commands.insertContentAt({ from: tr.selection.from, to: tr.selection.to }, value, options)
+  }

package/src/commands/insertContentAt.ts

@@ -60,122 +60,125 @@ const isFragment = (nodeOrFragment: ProseMirrorNode | Fragment): nodeOrFragment
   return !('type' in nodeOrFragment)
 }
 
-export const insertContentAt: RawCommands['insertContentAt'] = (position, value, options) => ({ tr, dispatch, editor }) => {
-  if (dispatch) {
-    options = {
-      parseOptions: editor.options.parseOptions,
-      updateSelection: true,
-      applyInputRules: false,
-      applyPasteRules: false,
-      ...options,
-    }
-
-    let content: Fragment | ProseMirrorNode
-    const { selection } = editor.state
+export const insertContentAt: RawCommands['insertContentAt'] =
+  (position, value, options) =>
+  ({ tr, dispatch, editor }) => {
+    if (dispatch) {
+      options = {
+        parseOptions: editor.options.parseOptions,
+        updateSelection: true,
+        applyInputRules: false,
+        applyPasteRules: false,
+        ...options,
+      }
 
-    try {
-      content = createNodeFromContent(value, editor.schema, {
-        parseOptions: {
-          preserveWhitespace: 'full',
-          ...options.parseOptions,
-        },
-        errorOnInvalidContent: options.errorOnInvalidContent ?? editor.options.enableContentCheck,
-      })
-    } catch (e) {
-      editor.emit('contentError', {
-        editor,
-        error: e as Error,
-        disableCollaboration: () => {
-          if (editor.storage.collaboration) {
-            editor.storage.collaboration.isDisabled = true
-          }
-        },
-      })
-      return false
-    }
+      let content: Fragment | ProseMirrorNode
+      const { selection } = editor.state
 
-    let { from, to } = typeof position === 'number' ? { from: position, to: position } : { from: position.from, to: position.to }
+      try {
+        content = createNodeFromContent(value, editor.schema, {
+          parseOptions: {
+            preserveWhitespace: 'full',
+            ...options.parseOptions,
+          },
+          errorOnInvalidContent: options.errorOnInvalidContent ?? editor.options.enableContentCheck,
+        })
+      } catch (e) {
+        editor.emit('contentError', {
+          editor,
+          error: e as Error,
+          disableCollaboration: () => {
+            if (editor.storage.collaboration) {
+              editor.storage.collaboration.isDisabled = true
+            }
+          },
+        })
+        return false
+      }
 
-    let isOnlyTextContent = true
-    let isOnlyBlockContent = true
-    const nodes = isFragment(content) ? content : [content]
+      let { from, to } =
+        typeof position === 'number' ? { from: position, to: position } : { from: position.from, to: position.to }
 
-    nodes.forEach(node => {
-      // check if added node is valid
-      node.check()
+      let isOnlyTextContent = true
+      let isOnlyBlockContent = true
+      const nodes = isFragment(content) ? content : [content]
 
-      isOnlyTextContent = isOnlyTextContent ? node.isText && node.marks.length === 0 : false
+      nodes.forEach(node => {
+        // check if added node is valid
+        node.check()
 
-      isOnlyBlockContent = isOnlyBlockContent ? node.isBlock : false
-    })
+        isOnlyTextContent = isOnlyTextContent ? node.isText && node.marks.length === 0 : false
 
-    // check if we can replace the wrapping node by
-    // the newly inserted content
-    // example:
-    // replace an empty paragraph by an inserted image
-    // instead of inserting the image below the paragraph
-    if (from === to && isOnlyBlockContent) {
-      const { parent } = tr.doc.resolve(from)
-      const isEmptyTextBlock = parent.isTextblock && !parent.type.spec.code && !parent.childCount
+        isOnlyBlockContent = isOnlyBlockContent ? node.isBlock : false
+      })
 
-      if (isEmptyTextBlock) {
-        from -= 1
-        to += 1
+      // check if we can replace the wrapping node by
+      // the newly inserted content
+      // example:
+      // replace an empty paragraph by an inserted image
+      // instead of inserting the image below the paragraph
+      if (from === to && isOnlyBlockContent) {
+        const { parent } = tr.doc.resolve(from)
+        const isEmptyTextBlock = parent.isTextblock && !parent.type.spec.code && !parent.childCount
+
+        if (isEmptyTextBlock) {
+          from -= 1
+          to += 1
+        }
       }
-    }
-
-    let newContent
-
-    // if there is only plain text we have to use `insertText`
-    // because this will keep the current marks
-    if (isOnlyTextContent) {
-      // if value is string, we can use it directly
-      // otherwise if it is an array, we have to join it
-      if (Array.isArray(value)) {
-        newContent = value.map(v => v.text || '').join('')
-      } else if (value instanceof Fragment) {
-        let text = ''
-
-        value.forEach(node => {
-          if (node.text) {
-            text += node.text
-          }
-        })
 
-        newContent = text
-      } else if (typeof value === 'object' && !!value && !!value.text) {
-        newContent = value.text
+      let newContent
+
+      // if there is only plain text we have to use `insertText`
+      // because this will keep the current marks
+      if (isOnlyTextContent) {
+        // if value is string, we can use it directly
+        // otherwise if it is an array, we have to join it
+        if (Array.isArray(value)) {
+          newContent = value.map(v => v.text || '').join('')
+        } else if (value instanceof Fragment) {
+          let text = ''
+
+          value.forEach(node => {
+            if (node.text) {
+              text += node.text
+            }
+          })
+
+          newContent = text
+        } else if (typeof value === 'object' && !!value && !!value.text) {
+          newContent = value.text
+        } else {
+          newContent = value as string
+        }
+
+        tr.insertText(newContent, from, to)
       } else {
-        newContent = value as string
-      }
+        newContent = content
 
-      tr.insertText(newContent, from, to)
-    } else {
-      newContent = content
+        const fromSelectionAtStart = selection.$from.parentOffset === 0
+        const isTextSelection = selection.$from.node().isText || selection.$from.node().isTextblock
 
-      const fromSelectionAtStart = selection.$from.parentOffset === 0
-      const isTextSelection = selection.$from.node().isText || selection.$from.node().isTextblock
+        if (fromSelectionAtStart && isTextSelection) {
+          from = Math.max(0, from - 1)
+        }
 
-      if (fromSelectionAtStart && isTextSelection) {
-        from = Math.max(0, from - 1)
+        tr.replaceWith(from, to, newContent)
       }
 
-      tr.replaceWith(from, to, newContent)
-    }
+      // set cursor at end of inserted content
+      if (options.updateSelection) {
+        selectionToInsertionEnd(tr, tr.steps.length - 1, -1)
+      }
 
-    // set cursor at end of inserted content
-    if (options.updateSelection) {
-      selectionToInsertionEnd(tr, tr.steps.length - 1, -1)
-    }
+      if (options.applyInputRules) {
+        tr.setMeta('applyInputRules', { from, text: newContent })
+      }
 
-    if (options.applyInputRules) {
-      tr.setMeta('applyInputRules', { from, text: newContent })
+      if (options.applyPasteRules) {
+        tr.setMeta('applyPasteRules', { from, text: newContent })
+      }
     }
 
-    if (options.applyPasteRules) {
-      tr.setMeta('applyPasteRules', { from, text: newContent })
-    }
+    return true
   }
-
-  return true
-}

package/src/commands/join.ts

@@ -44,18 +44,26 @@ declare module '@tiptap/core' {
   }
 }
 
-export const joinUp: RawCommands['joinUp'] = () => ({ state, dispatch }) => {
-  return originalJoinUp(state, dispatch)
-}
+export const joinUp: RawCommands['joinUp'] =
+  () =>
+  ({ state, dispatch }) => {
+    return originalJoinUp(state, dispatch)
+  }
 
-export const joinDown: RawCommands['joinDown'] = () => ({ state, dispatch }) => {
-  return originalJoinDown(state, dispatch)
-}
+export const joinDown: RawCommands['joinDown'] =
+  () =>
+  ({ state, dispatch }) => {
+    return originalJoinDown(state, dispatch)
+  }
 
-export const joinBackward: RawCommands['joinBackward'] = () => ({ state, dispatch }) => {
-  return originalJoinBackward(state, dispatch)
-}
+export const joinBackward: RawCommands['joinBackward'] =
+  () =>
+  ({ state, dispatch }) => {
+    return originalJoinBackward(state, dispatch)
+  }
 
-export const joinForward: RawCommands['joinForward'] = () => ({ state, dispatch }) => {
-  return originalJoinForward(state, dispatch)
-}
+export const joinForward: RawCommands['joinForward'] =
+  () =>
+  ({ state, dispatch }) => {
+    return originalJoinForward(state, dispatch)
+  }