@tiptap/core 2.11.7 → 3.0.0-beta.1

package/src/commands/deleteSelection.ts

@@ -1,6 +1,6 @@
 import { deleteSelection as originalDeleteSelection } 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 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

@@ -1,4 +1,4 @@
-import { RawCommands } from '../types.js'
+import type { RawCommands } from '../types.js'
 
 declare module '@tiptap/core' {
   interface Commands<ReturnType> {
@@ -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

@@ -1,6 +1,6 @@
 import { exitCode as originalExitCode } 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 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

@@ -1,9 +1,9 @@
-import { MarkType } from '@tiptap/pm/model'
+import type { MarkType } from '@tiptap/pm/model'
 import { TextSelection } from '@tiptap/pm/state'
 
 import { getMarkRange } from '../helpers/getMarkRange.js'
 import { getMarkType } from '../helpers/getMarkType.js'
-import { RawCommands } from '../types.js'
+import type { RawCommands } from '../types.js'
 
 declare module '@tiptap/core' {
   interface Commands<ReturnType> {
@@ -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

@@ -1,4 +1,4 @@
-import { Command, CommandProps, RawCommands } from '../types.js'
+import type { Command, CommandProps, RawCommands } from '../types.js'
 
 declare module '@tiptap/core' {
   interface Commands<ReturnType> {
@@ -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

@@ -1,6 +1,6 @@
 import { isTextSelection } from '../helpers/isTextSelection.js'
 import { resolveFocusPosition } from '../helpers/resolveFocusPosition.js'
-import { FocusPosition, RawCommands } from '../types.js'
+import type { FocusPosition, RawCommands } from '../types.js'
 import { isAndroid } from '../utilities/isAndroid.js'
 import { isiOS } from '../utilities/isiOS.js'
 
@@ -25,72 +25,69 @@ 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,
-  }
-
-  const delayedFocus = () => {
-    // focus within `requestAnimationFrame` breaks focus on iOS and Android
-    // so we have to call this
-    if (isiOS() || isAndroid()) {
-      (view.dom as HTMLElement).focus()
+export const focus: RawCommands['focus'] =
+  (position = null, options = {}) =>
+  ({ editor, view, tr, dispatch }) => {
+    options = {
+      scrollIntoView: true,
+      ...options,
     }
 
-    // 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()
-        }
+    const delayedFocus = () => {
+      // focus within `requestAnimationFrame` breaks focus on iOS and Android
+      // so we have to call this
+      if (isiOS() || isAndroid()) {
+        ;(view.dom as HTMLElement).focus()
       }
-    })
-  }
 
-  if ((view.hasFocus() && position === null) || position === false) {
-    return true
-  }
+      // 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()
 
-  // we don’t try to resolve a NodeSelection or CellSelection
-  if (dispatch && position === null && !isTextSelection(editor.state.selection)) {
-    delayedFocus()
-    return true
-  }
+          if (options?.scrollIntoView) {
+            editor.commands.scrollIntoView()
+          }
+        }
+      })
+    }
 
-  // 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 ((view.hasFocus() && position === null) || position === false) {
+      return true
+    }
 
-  if (dispatch) {
-    if (!isSameSelection) {
-      tr.setSelection(selection)
+    // we don’t try to resolve a NodeSelection or CellSelection
+    if (dispatch && position === null && !isTextSelection(editor.state.selection)) {
+      delayedFocus()
+      return true
     }
 
-    // `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)
+    // 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)
+      }
+
+      // `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

@@ -1,4 +1,4 @@
-import { CommandProps, RawCommands } from '../types.js'
+import type { CommandProps, RawCommands } from '../types.js'
 
 declare module '@tiptap/core' {
   interface Commands<ReturnType> {
@@ -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

@@ -1,6 +1,6 @@
-import { Fragment, Node as ProseMirrorNode, ParseOptions } from '@tiptap/pm/model'
+import type { Fragment, Node as ProseMirrorNode, ParseOptions } from '@tiptap/pm/model'
 
-import { Content, RawCommands } from '../types.js'
+import type { Content, RawCommands } from '../types.js'
 
 declare module '@tiptap/core' {
   interface Commands<ReturnType> {
@@ -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

@@ -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> {
@@ -60,114 +61,129 @@ 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
+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 (
+              'collaboration' in editor.storage &&
+              typeof editor.storage.collaboration === 'object' &&
+              editor.storage.collaboration
+            ) {
+              ;(editor.storage.collaboration as any).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
 
-      tr.replaceWith(from, to, newContent)
-    }
+        if (fromSelectionAtStart && isTextSelection) {
+          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 {
-    return false
+      return true
+    } catch {
+      return false
+    }
   }
-}