@tiptap/core 3.0.0 → 3.0.1

package/src/commands/insertContentAt.ts

@@ -1,8 +1,9 @@
-import { Fragment, Node as ProseMirrorNode, ParseOptions } from '@tiptap/pm/model'
+import type { Node as ProseMirrorNode, ParseOptions } from '@tiptap/pm/model'
+import { Fragment } from '@tiptap/pm/model'
 
 import { createNodeFromContent } from '../helpers/createNodeFromContent.js'
 import { selectionToInsertionEnd } from '../helpers/selectionToInsertionEnd.js'
-import { Content, Range, RawCommands } from '../types.js'
+import type { Content, Range, RawCommands } from '../types.js'
 
 declare module '@tiptap/core' {
   interface Commands<ReturnType> {
@@ -20,7 +21,7 @@ declare module '@tiptap/core' {
         /**
          * The ProseMirror content to insert.
          */
-        value: Content,
+        value: Content | ProseMirrorNode | Fragment,
 
         /**
          * Optional options
@@ -60,95 +61,149 @@ 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: {},
-      updateSelection: true,
-      applyInputRules: false,
-      applyPasteRules: false,
-      ...options,
-    }
+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
+      let content: Fragment | ProseMirrorNode
+      const { selection } = editor.state
+
+      const emitContentError = (error: Error) => {
+        editor.emit('contentError', {
+          editor,
+          error,
+          disableCollaboration: () => {
+            if (
+              'collaboration' in editor.storage &&
+              typeof editor.storage.collaboration === 'object' &&
+              editor.storage.collaboration
+            ) {
+              ;(editor.storage.collaboration as any).isDisabled = true
+            }
+          },
+        })
+      }
 
-    try {
-      content = createNodeFromContent(value, editor.schema, {
-        parseOptions: {
-          preserveWhitespace: 'full',
-          ...options.parseOptions,
-        },
-        errorOnInvalidContent: options.errorOnInvalidContent ?? editor.options.enableContentCheck,
-      })
-    } catch (e) {
-      return false
-    }
+      const parseOptions: ParseOptions = {
+        preserveWhitespace: 'full',
+        ...options.parseOptions,
+      }
+
+      // If `emitContentError` is enabled, we want to check the content for errors
+      // but ignore them (do not remove the invalid content from the document)
+      if (!options.errorOnInvalidContent && !editor.options.enableContentCheck && editor.options.emitContentError) {
+        try {
+          createNodeFromContent(value, editor.schema, {
+            parseOptions,
+            errorOnInvalidContent: true,
+          })
+        } catch (e) {
+          emitContentError(e as Error)
+        }
+      }
 
-    let { from, to } = typeof position === 'number' ? { from: position, to: position } : { from: position.from, to: position.to }
+      try {
+        content = createNodeFromContent(value, editor.schema, {
+          parseOptions,
+          errorOnInvalidContent: options.errorOnInvalidContent ?? editor.options.enableContentCheck,
+        })
+      } catch (e) {
+        emitContentError(e as Error)
+        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 (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 hasContent = selection.$from.node().content.size > 0
 
-      tr.replaceWith(from, to, newContent)
-    }
+        if (fromSelectionAtStart && isTextSelection && hasContent) {
+          from = Math.max(0, from - 1)
+        }
 
-    // set cursor at end of inserted content
-    if (options.updateSelection) {
-      selectionToInsertionEnd(tr, tr.steps.length - 1, -1)
-    }
+        tr.replaceWith(from, to, newContent)
+      }
 
-    if (options.applyInputRules) {
-      tr.setMeta('applyInputRules', { from, text: newContent })
-    }
+      // set cursor at end of inserted content
+      if (options.updateSelection) {
+        selectionToInsertionEnd(tr, tr.steps.length - 1, -1)
+      }
 
-    if (options.applyPasteRules) {
-      tr.setMeta('applyPasteRules', { from, text: newContent })
+      if (options.applyInputRules) {
+        tr.setMeta('applyInputRules', { from, text: newContent })
+      }
+
+      if (options.applyPasteRules) {
+        tr.setMeta('applyPasteRules', { from, text: newContent })
+      }
     }
-  }
 
-  return true
-}
+    return true
+  }

package/src/commands/join.ts

@@ -5,7 +5,7 @@ import {
   joinUp as originalJoinUp,
 } from '@tiptap/pm/commands'
 
-import { RawCommands } from '../types.js'
+import type { RawCommands } from '../types.js'
 
 declare module '@tiptap/core' {
   interface Commands<ReturnType> {
@@ -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)
+  }

package/src/commands/joinItemBackward.ts

@@ -1,6 +1,6 @@
 import { joinPoint } from '@tiptap/pm/transform'
 
-import { RawCommands } from '../types.js'
+import type { RawCommands } from '../types.js'
 
 declare module '@tiptap/core' {
   interface Commands<ReturnType> {
@@ -14,26 +14,24 @@ declare module '@tiptap/core' {
   }
 }
 
-export const joinItemBackward: RawCommands['joinItemBackward'] = () => ({
-  state,
-  dispatch,
-  tr,
-}) => {
-  try {
-    const point = joinPoint(state.doc, state.selection.$from.pos, -1)
+export const joinItemBackward: RawCommands['joinItemBackward'] =
+  () =>
+  ({ state, dispatch, tr }) => {
+    try {
+      const point = joinPoint(state.doc, state.selection.$from.pos, -1)
 
-    if (point === null || point === undefined) {
-      return false
-    }
+      if (point === null || point === undefined) {
+        return false
+      }
 
-    tr.join(point, 2)
+      tr.join(point, 2)
 
-    if (dispatch) {
-      dispatch(tr)
-    }
+      if (dispatch) {
+        dispatch(tr)
+      }
 
-    return true
-  } catch (e) {
-    return false
+      return true
+    } catch {
+      return false
+    }
   }
-}

package/src/commands/joinItemForward.ts

@@ -1,6 +1,6 @@
 import { joinPoint } from '@tiptap/pm/transform'
 
-import { RawCommands } from '../types.js'
+import type { RawCommands } from '../types.js'
 
 declare module '@tiptap/core' {
   interface Commands<ReturnType> {
@@ -14,26 +14,24 @@ declare module '@tiptap/core' {
   }
 }
 
-export const joinItemForward: RawCommands['joinItemForward'] = () => ({
-  state,
-  dispatch,
-  tr,
-}) => {
-  try {
-    const point = joinPoint(state.doc, state.selection.$from.pos, +1)
+export const joinItemForward: RawCommands['joinItemForward'] =
+  () =>
+  ({ state, dispatch, tr }) => {
+    try {
+      const point = joinPoint(state.doc, state.selection.$from.pos, +1)
 
-    if (point === null || point === undefined) {
-      return false
-    }
+      if (point === null || point === undefined) {
+        return false
+      }
 
-    tr.join(point, 2)
+      tr.join(point, 2)
 
-    if (dispatch) {
-      dispatch(tr)
-    }
+      if (dispatch) {
+        dispatch(tr)
+      }
 
-    return true
-  } catch (e) {
-    return false
+      return true
+    } catch {
+      return false
+    }
   }
-}

package/src/commands/joinTextblockBackward.ts

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

package/src/commands/joinTextblockForward.ts

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

package/src/commands/keyboardShortcut.ts

@@ -1,4 +1,4 @@
-import { RawCommands } from '../types.js'
+import type { RawCommands } from '../types.js'
 import { isiOS } from '../utilities/isiOS.js'
 import { isMacOS } from '../utilities/isMacOS.js'
 
@@ -64,42 +64,37 @@ declare module '@tiptap/core' {
        * @param name The name of the keyboard shortcut.
        * @example editor.commands.keyboardShortcut('Mod-b')
        */
-      keyboardShortcut: (name: string) => ReturnType,
+      keyboardShortcut: (name: string) => ReturnType
     }
   }
 }
 
-export const keyboardShortcut: RawCommands['keyboardShortcut'] = name => ({
-  editor,
-  view,
-  tr,
-  dispatch,
-}) => {
-  const keys = normalizeKeyName(name).split(/-(?!$)/)
-  const key = keys.find(item => !['Alt', 'Ctrl', 'Meta', 'Shift'].includes(item))
-  const event = new KeyboardEvent('keydown', {
-    key: key === 'Space'
-      ? ' '
-      : key,
-    altKey: keys.includes('Alt'),
-    ctrlKey: keys.includes('Ctrl'),
-    metaKey: keys.includes('Meta'),
-    shiftKey: keys.includes('Shift'),
-    bubbles: true,
-    cancelable: true,
-  })
-
-  const capturedTransaction = editor.captureTransaction(() => {
-    view.someProp('handleKeyDown', f => f(view, event))
-  })
-
-  capturedTransaction?.steps.forEach(step => {
-    const newStep = step.map(tr.mapping)
-
-    if (newStep && dispatch) {
-      tr.maybeStep(newStep)
-    }
-  })
+export const keyboardShortcut: RawCommands['keyboardShortcut'] =
+  name =>
+  ({ editor, view, tr, dispatch }) => {
+    const keys = normalizeKeyName(name).split(/-(?!$)/)
+    const key = keys.find(item => !['Alt', 'Ctrl', 'Meta', 'Shift'].includes(item))
+    const event = new KeyboardEvent('keydown', {
+      key: key === 'Space' ? ' ' : key,
+      altKey: keys.includes('Alt'),
+      ctrlKey: keys.includes('Ctrl'),
+      metaKey: keys.includes('Meta'),
+      shiftKey: keys.includes('Shift'),
+      bubbles: true,
+      cancelable: true,
+    })
+
+    const capturedTransaction = editor.captureTransaction(() => {
+      view.someProp('handleKeyDown', f => f(view, event))
+    })
+
+    capturedTransaction?.steps.forEach(step => {
+      const newStep = step.map(tr.mapping)
+
+      if (newStep && dispatch) {
+        tr.maybeStep(newStep)
+      }
+    })
 
-  return true
-}
+    return true
+  }

package/src/commands/lift.ts

@@ -1,9 +1,9 @@
 import { lift as originalLift } from '@tiptap/pm/commands'
-import { NodeType } from '@tiptap/pm/model'
+import type { NodeType } from '@tiptap/pm/model'
 
 import { getNodeType } from '../helpers/getNodeType.js'
 import { isNodeActive } from '../helpers/isNodeActive.js'
-import { RawCommands } from '../types.js'
+import type { RawCommands } from '../types.js'
 
 declare module '@tiptap/core' {
   interface Commands<ReturnType> {
@@ -20,13 +20,15 @@ declare module '@tiptap/core' {
   }
 }
 
-export const lift: RawCommands['lift'] = (typeOrName, attributes = {}) => ({ state, dispatch }) => {
-  const type = getNodeType(typeOrName, state.schema)
-  const isActive = isNodeActive(state, type, attributes)
+export const lift: RawCommands['lift'] =
+  (typeOrName, attributes = {}) =>
+  ({ state, dispatch }) => {
+    const type = getNodeType(typeOrName, state.schema)
+    const isActive = isNodeActive(state, type, attributes)
 
-  if (!isActive) {
-    return false
-  }
+    if (!isActive) {
+      return false
+    }
 
-  return originalLift(state, dispatch)
-}
+    return originalLift(state, dispatch)
+  }

package/src/commands/liftEmptyBlock.ts

@@ -1,6 +1,6 @@
 import { liftEmptyBlock as originalLiftEmptyBlock } from '@tiptap/pm/commands'
 
-import { RawCommands } from '../types.js'
+import type { RawCommands } from '../types.js'
 
 declare module '@tiptap/core' {
   interface Commands<ReturnType> {
@@ -9,11 +9,13 @@ declare module '@tiptap/core' {
        * If the cursor is in an empty textblock that can be lifted, lift the block.
        * @example editor.commands.liftEmptyBlock()
        */
-      liftEmptyBlock: () => ReturnType,
+      liftEmptyBlock: () => ReturnType
     }
   }
 }
 
-export const liftEmptyBlock: RawCommands['liftEmptyBlock'] = () => ({ state, dispatch }) => {
-  return originalLiftEmptyBlock(state, dispatch)
-}
+export const liftEmptyBlock: RawCommands['liftEmptyBlock'] =
+  () =>
+  ({ state, dispatch }) => {
+    return originalLiftEmptyBlock(state, dispatch)
+  }

package/src/commands/liftListItem.ts

@@ -1,8 +1,8 @@
-import { NodeType } from '@tiptap/pm/model'
+import type { NodeType } from '@tiptap/pm/model'
 import { liftListItem as originalLiftListItem } from '@tiptap/pm/schema-list'
 
 import { getNodeType } from '../helpers/getNodeType.js'
-import { RawCommands } from '../types.js'
+import type { RawCommands } from '../types.js'
 
 declare module '@tiptap/core' {
   interface Commands<ReturnType> {
@@ -17,8 +17,10 @@ declare module '@tiptap/core' {
   }
 }
 
-export const liftListItem: RawCommands['liftListItem'] = typeOrName => ({ state, dispatch }) => {
-  const type = getNodeType(typeOrName, state.schema)
+export const liftListItem: RawCommands['liftListItem'] =
+  typeOrName =>
+  ({ state, dispatch }) => {
+    const type = getNodeType(typeOrName, state.schema)
 
-  return originalLiftListItem(type)(state, dispatch)
-}
+    return originalLiftListItem(type)(state, dispatch)
+  }

package/src/commands/newlineInCode.ts

@@ -1,6 +1,6 @@
 import { newlineInCode as originalNewlineInCode } 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 newlineInCode: RawCommands['newlineInCode'] = () => ({ state, dispatch }) => {
-  return originalNewlineInCode(state, dispatch)
-}
+export const newlineInCode: RawCommands['newlineInCode'] =
+  () =>
+  ({ state, dispatch }) => {
+    return originalNewlineInCode(state, dispatch)
+  }