@tiptap/core 2.11.7 → 3.0.0-beta.0

package/src/commands/setContent.ts

@@ -1,7 +1,7 @@
-import { Fragment, Node as ProseMirrorNode, 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> {
@@ -19,55 +19,56 @@ declare module '@tiptap/core' {
          */
         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;
-        }
-      ) => ReturnType;
-    };
+          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)
+      }
+      return true
+    }
 
     if (dispatch) {
-      tr.replaceWith(0, doc.content.size, document).setMeta('preventUpdate', !emitUpdate)
+      tr.setMeta('preventUpdate', !emitUpdate)
     }
-    return true
-  }
 
-  if (dispatch) {
-    tr.setMeta('preventUpdate', !emitUpdate)
+    return commands.insertContentAt({ from: 0, to: doc.content.size }, content, {
+      parseOptions,
+      errorOnInvalidContent: errorOnInvalidContent ?? editor.options.enableContentCheck,
+    })
   }
-
-  return commands.insertContentAt({ from: 0, to: doc.content.size }, content, {
-    parseOptions,
-    errorOnInvalidContent: options.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,6 +1,6 @@
 import type { Plugin, PluginKey } from '@tiptap/pm/state'
 
-import { RawCommands } from '../types.js'
+import type { RawCommands } from '../types.js'
 
 declare module '@tiptap/core' {
   interface Commands<ReturnType> {
@@ -11,13 +11,15 @@ declare module '@tiptap/core' {
        * @param value The value to store.
        * @example editor.commands.setMeta('foo', 'bar')
        */
-      setMeta: (key: string | Plugin | PluginKey, 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,38 +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)
 
-  let attributesToCopy: Record<string, any> | undefined
+    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
-  }
+    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.')
+    // TODO: use a fallback like insertContent?
+    if (!type.isTextblock) {
+      console.warn('[tiptap warn]: Currently "setNode()" only supports text block nodes.')
 
-    return false
-  }
+      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()
-  )
-}
+    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()
+    )
+  }

package/src/commands/setNodeSelection.ts

@@ -1,6 +1,6 @@
 import { NodeSelection } from '@tiptap/pm/state'
 
-import { RawCommands } from '../types.js'
+import type { RawCommands } from '../types.js'
 import { minMax } from '../utilities/minMax.js'
 
 declare module '@tiptap/core' {
@@ -16,14 +16,16 @@ declare module '@tiptap/core' {
   }
 }
 
-export const setNodeSelection: RawCommands['setNodeSelection'] = position => ({ tr, dispatch }) => {
-  if (dispatch) {
-    const { doc } = tr
-    const from = minMax(position, 0, doc.content.size)
-    const selection = NodeSelection.create(doc, from)
+export const setNodeSelection: RawCommands['setNodeSelection'] =
+  position =>
+  ({ tr, dispatch }) => {
+    if (dispatch) {
+      const { doc } = tr
+      const from = minMax(position, 0, doc.content.size)
+      const selection = NodeSelection.create(doc, from)
 
-    tr.setSelection(selection)
-  }
+      tr.setSelection(selection)
+    }
 
-  return true
-}
+    return true
+  }

package/src/commands/setTextSelection.ts

@@ -1,6 +1,6 @@
 import { TextSelection } from '@tiptap/pm/state'
 
-import { Range, RawCommands } from '../types.js'
+import type { Range, RawCommands } from '../types.js'
 import { minMax } from '../utilities/minMax.js'
 
 declare module '@tiptap/core' {
@@ -16,18 +16,20 @@ declare module '@tiptap/core' {
   }
 }
 
-export const setTextSelection: RawCommands['setTextSelection'] = position => ({ tr, dispatch }) => {
-  if (dispatch) {
-    const { doc } = tr
-    const { from, to } = typeof position === 'number' ? { from: position, to: position } : position
-    const minPos = TextSelection.atStart(doc).from
-    const maxPos = TextSelection.atEnd(doc).to
-    const resolvedFrom = minMax(from, minPos, maxPos)
-    const resolvedEnd = minMax(to, minPos, maxPos)
-    const selection = TextSelection.create(doc, resolvedFrom, resolvedEnd)
+export const setTextSelection: RawCommands['setTextSelection'] =
+  position =>
+  ({ tr, dispatch }) => {
+    if (dispatch) {
+      const { doc } = tr
+      const { from, to } = typeof position === 'number' ? { from: position, to: position } : position
+      const minPos = TextSelection.atStart(doc).from
+      const maxPos = TextSelection.atEnd(doc).to
+      const resolvedFrom = minMax(from, minPos, maxPos)
+      const resolvedEnd = minMax(to, minPos, maxPos)
+      const selection = TextSelection.create(doc, resolvedFrom, resolvedEnd)
 
-    tr.setSelection(selection)
-  }
+      tr.setSelection(selection)
+    }
 
-  return true
-}
+    return true
+  }

package/src/commands/sinkListItem.ts

@@ -1,8 +1,8 @@
-import { NodeType } from '@tiptap/pm/model'
+import type { NodeType } from '@tiptap/pm/model'
 import { sinkListItem as originalSinkListItem } 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 sinkListItem: RawCommands['sinkListItem'] = typeOrName => ({ state, dispatch }) => {
-  const type = getNodeType(typeOrName, state.schema)
+export const sinkListItem: RawCommands['sinkListItem'] =
+  typeOrName =>
+  ({ state, dispatch }) => {
+    const type = getNodeType(typeOrName, state.schema)
 
-  return originalSinkListItem(type)(state, dispatch)
-}
+    return originalSinkListItem(type)(state, dispatch)
+  }

package/src/commands/splitBlock.ts

@@ -1,9 +1,10 @@
-import { EditorState, NodeSelection, TextSelection } from '@tiptap/pm/state'
+import type { EditorState } from '@tiptap/pm/state'
+import { NodeSelection, TextSelection } from '@tiptap/pm/state'
 import { canSplit } from '@tiptap/pm/transform'
 
 import { defaultBlockAt } from '../helpers/defaultBlockAt.js'
 import { getSplittedAttributes } from '../helpers/getSplittedAttributes.js'
-import { RawCommands } from '../types.js'
+import type { RawCommands } from '../types.js'
 
 function ensureMarks(state: EditorState, splittableMarks?: string[]) {
   const marks = state.storedMarks || (state.selection.$to.parentOffset && state.selection.$from.marks())
@@ -29,95 +30,86 @@ declare module '@tiptap/core' {
   }
 }
 
-export const splitBlock: RawCommands['splitBlock'] = ({ keepMarks = true } = {}) => ({
-  tr, state, dispatch, editor,
-}) => {
-  const { selection, doc } = tr
-  const { $from, $to } = selection
-  const extensionAttributes = editor.extensionManager.attributes
-  const newAttributes = getSplittedAttributes(
-    extensionAttributes,
-    $from.node().type.name,
-    $from.node().attrs,
-  )
-
-  if (selection instanceof NodeSelection && selection.node.isBlock) {
-    if (!$from.parentOffset || !canSplit(doc, $from.pos)) {
-      return false
-    }
+export const splitBlock: RawCommands['splitBlock'] =
+  ({ keepMarks = true } = {}) =>
+  ({ tr, state, dispatch, editor }) => {
+    const { selection, doc } = tr
+    const { $from, $to } = selection
+    const extensionAttributes = editor.extensionManager.attributes
+    const newAttributes = getSplittedAttributes(extensionAttributes, $from.node().type.name, $from.node().attrs)
+
+    if (selection instanceof NodeSelection && selection.node.isBlock) {
+      if (!$from.parentOffset || !canSplit(doc, $from.pos)) {
+        return false
+      }
 
-    if (dispatch) {
-      if (keepMarks) {
-        ensureMarks(state, editor.extensionManager.splittableMarks)
+      if (dispatch) {
+        if (keepMarks) {
+          ensureMarks(state, editor.extensionManager.splittableMarks)
+        }
+
+        tr.split($from.pos).scrollIntoView()
       }
 
-      tr.split($from.pos).scrollIntoView()
+      return true
     }
 
-    return true
-  }
-
-  if (!$from.parent.isBlock) {
-    return false
-  }
+    if (!$from.parent.isBlock) {
+      return false
+    }
 
-  const atEnd = $to.parentOffset === $to.parent.content.size
-
-  const deflt = $from.depth === 0
-    ? undefined
-    : defaultBlockAt($from.node(-1).contentMatchAt($from.indexAfter(-1)))
-
-  let types = atEnd && deflt
-    ? [
-      {
-        type: deflt,
-        attrs: newAttributes,
-      },
-    ]
-    : undefined
-
-  let can = canSplit(tr.doc, tr.mapping.map($from.pos), 1, types)
-
-  if (
-    !types
-      && !can
-      && canSplit(tr.doc, tr.mapping.map($from.pos), 1, deflt ? [{ type: deflt }] : undefined)
-  ) {
-    can = true
-    types = deflt
-      ? [
-        {
-          type: deflt,
-          attrs: newAttributes,
-        },
-      ]
-      : undefined
-  }
+    const atEnd = $to.parentOffset === $to.parent.content.size
+
+    const deflt = $from.depth === 0 ? undefined : defaultBlockAt($from.node(-1).contentMatchAt($from.indexAfter(-1)))
+
+    let types =
+      atEnd && deflt
+        ? [
+            {
+              type: deflt,
+              attrs: newAttributes,
+            },
+          ]
+        : undefined
+
+    let can = canSplit(tr.doc, tr.mapping.map($from.pos), 1, types)
+
+    if (!types && !can && canSplit(tr.doc, tr.mapping.map($from.pos), 1, deflt ? [{ type: deflt }] : undefined)) {
+      can = true
+      types = deflt
+        ? [
+            {
+              type: deflt,
+              attrs: newAttributes,
+            },
+          ]
+        : undefined
+    }
 
-  if (dispatch) {
-    if (can) {
-      if (selection instanceof TextSelection) {
-        tr.deleteSelection()
-      }
+    if (dispatch) {
+      if (can) {
+        if (selection instanceof TextSelection) {
+          tr.deleteSelection()
+        }
 
-      tr.split(tr.mapping.map($from.pos), 1, types)
+        tr.split(tr.mapping.map($from.pos), 1, types)
 
-      if (deflt && !atEnd && !$from.parentOffset && $from.parent.type !== deflt) {
-        const first = tr.mapping.map($from.before())
-        const $first = tr.doc.resolve(first)
+        if (deflt && !atEnd && !$from.parentOffset && $from.parent.type !== deflt) {
+          const first = tr.mapping.map($from.before())
+          const $first = tr.doc.resolve(first)
 
-        if ($from.node(-1).canReplaceWith($first.index(), $first.index() + 1, deflt)) {
-          tr.setNodeMarkup(tr.mapping.map($from.before()), deflt)
+          if ($from.node(-1).canReplaceWith($first.index(), $first.index() + 1, deflt)) {
+            tr.setNodeMarkup(tr.mapping.map($from.before()), deflt)
+          }
         }
       }
-    }
 
-    if (keepMarks) {
-      ensureMarks(state, editor.extensionManager.splittableMarks)
+      if (keepMarks) {
+        ensureMarks(state, editor.extensionManager.splittableMarks)
+      }
+
+      tr.scrollIntoView()
     }
 
-    tr.scrollIntoView()
+    return can
   }
-
-  return can
-}