@tiptap/core 2.11.6 → 3.0.0-beta.0

package/src/commands/splitListItem.ts

@@ -1,12 +1,11 @@
-import {
-  Fragment, Node as ProseMirrorNode, NodeType, Slice,
-} from '@tiptap/pm/model'
+import type { Node as ProseMirrorNode, NodeType } from '@tiptap/pm/model'
+import { Fragment, Slice } from '@tiptap/pm/model'
 import { TextSelection } from '@tiptap/pm/state'
 import { canSplit } from '@tiptap/pm/transform'
 
 import { getNodeType } from '../helpers/getNodeType.js'
 import { getSplittedAttributes } from '../helpers/getSplittedAttributes.js'
-import { RawCommands } from '../types.js'
+import type { RawCommands } from '../types.js'
 
 declare module '@tiptap/core' {
   interface Commands<ReturnType> {
@@ -22,140 +21,129 @@ declare module '@tiptap/core' {
   }
 }
 
-export const splitListItem: RawCommands['splitListItem'] = (typeOrName, overrideAttrs = {}) => ({
-  tr, state, dispatch, editor,
-}) => {
-  const type = getNodeType(typeOrName, state.schema)
-  const { $from, $to } = state.selection
+export const splitListItem: RawCommands['splitListItem'] =
+  (typeOrName, overrideAttrs = {}) =>
+  ({ tr, state, dispatch, editor }) => {
+    const type = getNodeType(typeOrName, state.schema)
+    const { $from, $to } = state.selection
 
-  // @ts-ignore
-  // eslint-disable-next-line
+    // @ts-ignore
+    // eslint-disable-next-line
     const node: ProseMirrorNode = state.selection.node
 
-  if ((node && node.isBlock) || $from.depth < 2 || !$from.sameParent($to)) {
-    return false
-  }
-
-  const grandParent = $from.node(-1)
+    if ((node && node.isBlock) || $from.depth < 2 || !$from.sameParent($to)) {
+      return false
+    }
 
-  if (grandParent.type !== type) {
-    return false
-  }
+    const grandParent = $from.node(-1)
 
-  const extensionAttributes = editor.extensionManager.attributes
-
-  if ($from.parent.content.size === 0 && $from.node(-1).childCount === $from.indexAfter(-1)) {
-    // In an empty block. If this is a nested list, the wrapping
-    // list item should be split. Otherwise, bail out and let next
-    // command handle lifting.
-    if (
-      $from.depth === 2
-        || $from.node(-3).type !== type
-        || $from.index(-2) !== $from.node(-2).childCount - 1
-    ) {
+    if (grandParent.type !== type) {
       return false
     }
 
-    if (dispatch) {
-      let wrap = Fragment.empty
-      // eslint-disable-next-line
-        const depthBefore = $from.index(-1) ? 1 : $from.index(-2) ? 2 : 3
+    const extensionAttributes = editor.extensionManager.attributes
 
-      // Build a fragment containing empty versions of the structure
-      // from the outer list item to the parent node of the cursor
-      for (let d = $from.depth - depthBefore; d >= $from.depth - 3; d -= 1) {
-        wrap = Fragment.from($from.node(d).copy(wrap))
+    if ($from.parent.content.size === 0 && $from.node(-1).childCount === $from.indexAfter(-1)) {
+      // In an empty block. If this is a nested list, the wrapping
+      // list item should be split. Otherwise, bail out and let next
+      // command handle lifting.
+      if ($from.depth === 2 || $from.node(-3).type !== type || $from.index(-2) !== $from.node(-2).childCount - 1) {
+        return false
       }
 
-      // eslint-disable-next-line
-        const depthAfter = $from.indexAfter(-1) < $from.node(-2).childCount ? 1 : $from.indexAfter(-2) < $from.node(-3).childCount ? 2 : 3
-
-      // Add a second list item with an empty default start node
-      const newNextTypeAttributes = {
-        ...getSplittedAttributes(
-          extensionAttributes,
-          $from.node().type.name,
-          $from.node().attrs,
-        ),
-        ...overrideAttrs,
-      }
-      const nextType = type.contentMatch.defaultType?.createAndFill(newNextTypeAttributes) || undefined
+      if (dispatch) {
+        let wrap = Fragment.empty
+        // eslint-disable-next-line
+        const depthBefore = $from.index(-1) ? 1 : $from.index(-2) ? 2 : 3
 
-      wrap = wrap.append(Fragment.from(type.createAndFill(null, nextType) || undefined))
+        // Build a fragment containing empty versions of the structure
+        // from the outer list item to the parent node of the cursor
+        for (let d = $from.depth - depthBefore; d >= $from.depth - 3; d -= 1) {
+          wrap = Fragment.from($from.node(d).copy(wrap))
+        }
 
-      const start = $from.before($from.depth - (depthBefore - 1))
+        const depthAfter =
+          // eslint-disable-next-line no-nested-ternary
+          $from.indexAfter(-1) < $from.node(-2).childCount
+            ? 1
+            : $from.indexAfter(-2) < $from.node(-3).childCount
+              ? 2
+              : 3
+
+        // Add a second list item with an empty default start node
+        const newNextTypeAttributes = {
+          ...getSplittedAttributes(extensionAttributes, $from.node().type.name, $from.node().attrs),
+          ...overrideAttrs,
+        }
+        const nextType = type.contentMatch.defaultType?.createAndFill(newNextTypeAttributes) || undefined
 
-      tr.replace(start, $from.after(-depthAfter), new Slice(wrap, 4 - depthBefore, 0))
+        wrap = wrap.append(Fragment.from(type.createAndFill(null, nextType) || undefined))
 
-      let sel = -1
+        const start = $from.before($from.depth - (depthBefore - 1))
 
-      tr.doc.nodesBetween(start, tr.doc.content.size, (n, pos) => {
-        if (sel > -1) {
-          return false
-        }
+        tr.replace(start, $from.after(-depthAfter), new Slice(wrap, 4 - depthBefore, 0))
+
+        let sel = -1
 
-        if (n.isTextblock && n.content.size === 0) {
-          sel = pos + 1
+        tr.doc.nodesBetween(start, tr.doc.content.size, (n, pos) => {
+          if (sel > -1) {
+            return false
+          }
+
+          if (n.isTextblock && n.content.size === 0) {
+            sel = pos + 1
+          }
+        })
+
+        if (sel > -1) {
+          tr.setSelection(TextSelection.near(tr.doc.resolve(sel)))
         }
-      })
 
-      if (sel > -1) {
-        tr.setSelection(TextSelection.near(tr.doc.resolve(sel)))
+        tr.scrollIntoView()
       }
 
-      tr.scrollIntoView()
+      return true
     }
 
-    return true
-  }
+    const nextType = $to.pos === $from.end() ? grandParent.contentMatchAt(0).defaultType : null
 
-  const nextType = $to.pos === $from.end() ? grandParent.contentMatchAt(0).defaultType : null
+    const newTypeAttributes = {
+      ...getSplittedAttributes(extensionAttributes, grandParent.type.name, grandParent.attrs),
+      ...overrideAttrs,
+    }
+    const newNextTypeAttributes = {
+      ...getSplittedAttributes(extensionAttributes, $from.node().type.name, $from.node().attrs),
+      ...overrideAttrs,
+    }
 
-  const newTypeAttributes = {
-    ...getSplittedAttributes(
-      extensionAttributes,
-      grandParent.type.name,
-      grandParent.attrs,
-    ),
-    ...overrideAttrs,
-  }
-  const newNextTypeAttributes = {
-    ...getSplittedAttributes(
-      extensionAttributes,
-      $from.node().type.name,
-      $from.node().attrs,
-    ),
-    ...overrideAttrs,
-  }
+    tr.delete($from.pos, $to.pos)
 
-  tr.delete($from.pos, $to.pos)
+    const types = nextType
+      ? [
+          { type, attrs: newTypeAttributes },
+          { type: nextType, attrs: newNextTypeAttributes },
+        ]
+      : [{ type, attrs: newTypeAttributes }]
 
-  const types = nextType
-    ? [
-      { type, attrs: newTypeAttributes },
-      { type: nextType, attrs: newNextTypeAttributes },
-    ]
-    : [{ type, attrs: newTypeAttributes }]
+    if (!canSplit(tr.doc, $from.pos, 2)) {
+      return false
+    }
 
-  if (!canSplit(tr.doc, $from.pos, 2)) {
-    return false
-  }
+    if (dispatch) {
+      const { selection, storedMarks } = state
+      const { splittableMarks } = editor.extensionManager
+      const marks = storedMarks || (selection.$to.parentOffset && selection.$from.marks())
 
-  if (dispatch) {
-    const { selection, storedMarks } = state
-    const { splittableMarks } = editor.extensionManager
-    const marks = storedMarks || (selection.$to.parentOffset && selection.$from.marks())
+      tr.split($from.pos, 2, types).scrollIntoView()
 
-    tr.split($from.pos, 2, types).scrollIntoView()
+      if (!marks || !dispatch) {
+        return true
+      }
 
-    if (!marks || !dispatch) {
-      return true
-    }
+      const filteredMarks = marks.filter(mark => splittableMarks.includes(mark.type.name))
 
-    const filteredMarks = marks.filter(mark => splittableMarks.includes(mark.type.name))
+      tr.ensureMarks(filteredMarks)
+    }
 
-    tr.ensureMarks(filteredMarks)
+    return true
   }
-
-  return true
-}

package/src/commands/toggleList.ts

@@ -1,11 +1,11 @@
-import { NodeType } from '@tiptap/pm/model'
-import { Transaction } from '@tiptap/pm/state'
+import type { NodeType } from '@tiptap/pm/model'
+import type { Transaction } from '@tiptap/pm/state'
 import { canJoin } from '@tiptap/pm/transform'
 
 import { findParentNode } from '../helpers/findParentNode.js'
 import { getNodeType } from '../helpers/getNodeType.js'
 import { isList } from '../helpers/isList.js'
-import { RawCommands } from '../types.js'
+import type { RawCommands } from '../types.js'
 
 const joinListBackwards = (tr: Transaction, listType: NodeType): boolean => {
   const list = findParentNode(node => node.type === listType)(tr.selection)
@@ -68,90 +68,92 @@ declare module '@tiptap/core' {
        * @param attributes Attributes for the new list.
        * @example editor.commands.toggleList('bulletList', 'listItem')
        */
-      toggleList: (listTypeOrName: string | NodeType, itemTypeOrName: string | NodeType, keepMarks?: boolean, attributes?: Record<string, any>) => ReturnType;
+      toggleList: (
+        listTypeOrName: string | NodeType,
+        itemTypeOrName: string | NodeType,
+        keepMarks?: boolean,
+        attributes?: Record<string, any>,
+      ) => ReturnType
     }
   }
 }
 
-export const toggleList: RawCommands['toggleList'] = (listTypeOrName, itemTypeOrName, keepMarks, attributes = {}) => ({
-  editor, tr, state, dispatch, chain, commands, can,
-}) => {
-  const { extensions, splittableMarks } = editor.extensionManager
-  const listType = getNodeType(listTypeOrName, state.schema)
-  const itemType = getNodeType(itemTypeOrName, state.schema)
-  const { selection, storedMarks } = state
-  const { $from, $to } = selection
-  const range = $from.blockRange($to)
+export const toggleList: RawCommands['toggleList'] =
+  (listTypeOrName, itemTypeOrName, keepMarks, attributes = {}) =>
+  ({ editor, tr, state, dispatch, chain, commands, can }) => {
+    const { extensions, splittableMarks } = editor.extensionManager
+    const listType = getNodeType(listTypeOrName, state.schema)
+    const itemType = getNodeType(itemTypeOrName, state.schema)
+    const { selection, storedMarks } = state
+    const { $from, $to } = selection
+    const range = $from.blockRange($to)
 
-  const marks = storedMarks || (selection.$to.parentOffset && selection.$from.marks())
+    const marks = storedMarks || (selection.$to.parentOffset && selection.$from.marks())
 
-  if (!range) {
-    return false
-  }
-
-  const parentList = findParentNode(node => isList(node.type.name, extensions))(selection)
+    if (!range) {
+      return false
+    }
 
-  if (range.depth >= 1 && parentList && range.depth - parentList.depth <= 1) {
-    // remove list
-    if (parentList.node.type === listType) {
-      return commands.liftListItem(itemType)
+    const parentList = findParentNode(node => isList(node.type.name, extensions))(selection)
+
+    if (range.depth >= 1 && parentList && range.depth - parentList.depth <= 1) {
+      // remove list
+      if (parentList.node.type === listType) {
+        return commands.liftListItem(itemType)
+      }
+
+      // change list type
+      if (isList(parentList.node.type.name, extensions) && listType.validContent(parentList.node.content) && dispatch) {
+        return chain()
+          .command(() => {
+            tr.setNodeMarkup(parentList.pos, listType)
+
+            return true
+          })
+          .command(() => joinListBackwards(tr, listType))
+          .command(() => joinListForwards(tr, listType))
+          .run()
+      }
+    }
+    if (!keepMarks || !marks || !dispatch) {
+      return (
+        chain()
+          // try to convert node to default node if needed
+          .command(() => {
+            const canWrapInList = can().wrapInList(listType, attributes)
+
+            if (canWrapInList) {
+              return true
+            }
+
+            return commands.clearNodes()
+          })
+          .wrapInList(listType, attributes)
+          .command(() => joinListBackwards(tr, listType))
+          .command(() => joinListForwards(tr, listType))
+          .run()
+      )
     }
 
-    // change list type
-    if (
-      isList(parentList.node.type.name, extensions)
-        && listType.validContent(parentList.node.content)
-        && dispatch
-    ) {
-      return chain()
+    return (
+      chain()
+        // try to convert node to default node if needed
         .command(() => {
-          tr.setNodeMarkup(parentList.pos, listType)
+          const canWrapInList = can().wrapInList(listType, attributes)
 
-          return true
+          const filteredMarks = marks.filter(mark => splittableMarks.includes(mark.type.name))
+
+          tr.ensureMarks(filteredMarks)
+
+          if (canWrapInList) {
+            return true
+          }
+
+          return commands.clearNodes()
         })
+        .wrapInList(listType, attributes)
         .command(() => joinListBackwards(tr, listType))
         .command(() => joinListForwards(tr, listType))
         .run()
-    }
+    )
   }
-  if (!keepMarks || !marks || !dispatch) {
-
-    return chain()
-      // try to convert node to default node if needed
-      .command(() => {
-        const canWrapInList = can().wrapInList(listType, attributes)
-
-        if (canWrapInList) {
-          return true
-        }
-
-        return commands.clearNodes()
-      })
-      .wrapInList(listType, attributes)
-      .command(() => joinListBackwards(tr, listType))
-      .command(() => joinListForwards(tr, listType))
-      .run()
-  }
-
-  return (
-    chain()
-    // try to convert node to default node if needed
-      .command(() => {
-        const canWrapInList = can().wrapInList(listType, attributes)
-
-        const filteredMarks = marks.filter(mark => splittableMarks.includes(mark.type.name))
-
-        tr.ensureMarks(filteredMarks)
-
-        if (canWrapInList) {
-          return true
-        }
-
-        return commands.clearNodes()
-      })
-      .wrapInList(listType, attributes)
-      .command(() => joinListBackwards(tr, listType))
-      .command(() => joinListForwards(tr, listType))
-      .run()
-  )
-}

package/src/commands/toggleMark.ts

@@ -1,8 +1,8 @@
-import { MarkType } from '@tiptap/pm/model'
+import type { MarkType } from '@tiptap/pm/model'
 
 import { getMarkType } from '../helpers/getMarkType.js'
 import { isMarkActive } from '../helpers/isMarkActive.js'
-import { RawCommands } from '../types.js'
+import type { RawCommands } from '../types.js'
 
 declare module '@tiptap/core' {
   interface Commands<ReturnType> {
@@ -36,14 +36,16 @@ declare module '@tiptap/core' {
   }
 }
 
-export const toggleMark: RawCommands['toggleMark'] = (typeOrName, attributes = {}, options = {}) => ({ state, commands }) => {
-  const { extendEmptyMarkRange = false } = options
-  const type = getMarkType(typeOrName, state.schema)
-  const isActive = isMarkActive(state, type, attributes)
+export const toggleMark: RawCommands['toggleMark'] =
+  (typeOrName, attributes = {}, options = {}) =>
+  ({ state, commands }) => {
+    const { extendEmptyMarkRange = false } = options
+    const type = getMarkType(typeOrName, state.schema)
+    const isActive = isMarkActive(state, type, attributes)
 
-  if (isActive) {
-    return commands.unsetMark(type, { extendEmptyMarkRange })
-  }
+    if (isActive) {
+      return commands.unsetMark(type, { extendEmptyMarkRange })
+    }
 
-  return commands.setMark(type, attributes)
-}
+    return commands.setMark(type, attributes)
+  }

package/src/commands/toggleNode.ts

@@ -1,8 +1,8 @@
-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> {
@@ -23,23 +23,25 @@ declare module '@tiptap/core' {
   }
 }
 
-export const toggleNode: RawCommands['toggleNode'] = (typeOrName, toggleTypeOrName, attributes = {}) => ({ state, commands }) => {
-  const type = getNodeType(typeOrName, state.schema)
-  const toggleType = getNodeType(toggleTypeOrName, state.schema)
-  const isActive = isNodeActive(state, type, attributes)
+export const toggleNode: RawCommands['toggleNode'] =
+  (typeOrName, toggleTypeOrName, attributes = {}) =>
+  ({ state, commands }) => {
+    const type = getNodeType(typeOrName, state.schema)
+    const toggleType = getNodeType(toggleTypeOrName, state.schema)
+    const isActive = isNodeActive(state, type, attributes)
 
-  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
+    }
 
-  if (isActive) {
-    return commands.setNode(toggleType, attributesToCopy)
-  }
+    if (isActive) {
+      return commands.setNode(toggleType, attributesToCopy)
+    }
 
-  // If the node is not active, we want to set the new node type with the given attributes
-  // Copying over the attributes from the current node if the selection is pointing to a node of the same type
-  return commands.setNode(type, { ...attributesToCopy, ...attributes })
-}
+    // If the node is not active, we want to set the new node type with the given attributes
+    // Copying over the attributes from the current node if the selection is pointing to a node of the same type
+    return commands.setNode(type, { ...attributesToCopy, ...attributes })
+  }

package/src/commands/toggleWrap.ts

@@ -1,8 +1,8 @@
-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> {
@@ -18,13 +18,15 @@ declare module '@tiptap/core' {
   }
 }
 
-export const toggleWrap: RawCommands['toggleWrap'] = (typeOrName, attributes = {}) => ({ state, commands }) => {
-  const type = getNodeType(typeOrName, state.schema)
-  const isActive = isNodeActive(state, type, attributes)
+export const toggleWrap: RawCommands['toggleWrap'] =
+  (typeOrName, attributes = {}) =>
+  ({ state, commands }) => {
+    const type = getNodeType(typeOrName, state.schema)
+    const isActive = isNodeActive(state, type, attributes)
 
-  if (isActive) {
-    return commands.lift(type)
-  }
+    if (isActive) {
+      return commands.lift(type)
+    }
 
-  return commands.wrapIn(type, attributes)
-}
+    return commands.wrapIn(type, attributes)
+  }

package/src/commands/undoInputRule.ts

@@ -1,4 +1,4 @@
-import { RawCommands } from '../types.js'
+import type { RawCommands } from '../types.js'
 
 declare module '@tiptap/core' {
   interface Commands<ReturnType> {
@@ -7,41 +7,43 @@ declare module '@tiptap/core' {
        * Undo an input rule.
        * @example editor.commands.undoInputRule()
        */
-      undoInputRule: () => ReturnType,
+      undoInputRule: () => ReturnType
     }
   }
 }
 
-export const undoInputRule: RawCommands['undoInputRule'] = () => ({ state, dispatch }) => {
-  const plugins = state.plugins
-
-  for (let i = 0; i < plugins.length; i += 1) {
-    const plugin = plugins[i]
-    let undoable
-
-    // @ts-ignore
-    // eslint-disable-next-line
-    if (plugin.spec.isInputRules && (undoable = plugin.getState(state))) {
-      if (dispatch) {
-        const tr = state.tr
-        const toUndo = undoable.transform
-
-        for (let j = toUndo.steps.length - 1; j >= 0; j -= 1) {
-          tr.step(toUndo.steps[j].invert(toUndo.docs[j]))
+export const undoInputRule: RawCommands['undoInputRule'] =
+  () =>
+  ({ state, dispatch }) => {
+    const plugins = state.plugins
+
+    for (let i = 0; i < plugins.length; i += 1) {
+      const plugin = plugins[i]
+      let undoable
+
+      // @ts-ignore
+      // eslint-disable-next-line
+      if (plugin.spec.isInputRules && (undoable = plugin.getState(state))) {
+        if (dispatch) {
+          const tr = state.tr
+          const toUndo = undoable.transform
+
+          for (let j = toUndo.steps.length - 1; j >= 0; j -= 1) {
+            tr.step(toUndo.steps[j].invert(toUndo.docs[j]))
+          }
+
+          if (undoable.text) {
+            const marks = tr.doc.resolve(undoable.from).marks()
+
+            tr.replaceWith(undoable.from, undoable.to, state.schema.text(undoable.text, marks))
+          } else {
+            tr.delete(undoable.from, undoable.to)
+          }
         }
 
-        if (undoable.text) {
-          const marks = tr.doc.resolve(undoable.from).marks()
-
-          tr.replaceWith(undoable.from, undoable.to, state.schema.text(undoable.text, marks))
-        } else {
-          tr.delete(undoable.from, undoable.to)
-        }
+        return true
       }
-
-      return true
     }
-  }
 
-  return false
-}
+    return false
+  }