@tiptap/core 3.0.0 → 3.0.2-beta.0

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
+    }
 
-  if (dispatch) {
     const atEnd = $to.parentOffset === $to.parent.content.size
 
-    if (selection instanceof TextSelection) {
-      tr.deleteSelection()
-    }
+    const deflt = $from.depth === 0 ? undefined : defaultBlockAt($from.node(-1).contentMatchAt($from.indexAfter(-1)))
 
-    const deflt = $from.depth === 0
-      ? undefined
-      : defaultBlockAt($from.node(-1).contentMatchAt($from.indexAfter(-1)))
-
-    let types = atEnd && deflt
-      ? [
-        {
-          type: deflt,
-          attrs: newAttributes,
-        },
-      ]
-      : undefined
+    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)
-    ) {
+    if (!types && !can && canSplit(tr.doc, tr.mapping.map($from.pos), 1, deflt ? [{ type: deflt }] : undefined)) {
       can = true
       types = deflt
         ? [
-          {
-            type: deflt,
-            attrs: newAttributes,
-          },
-        ]
+            {
+              type: deflt,
+              attrs: newAttributes,
+            },
+          ]
         : undefined
     }
 
-    if (can) {
-      tr.split(tr.mapping.map($from.pos), 1, types)
+    if (dispatch) {
+      if (can) {
+        if (selection instanceof TextSelection) {
+          tr.deleteSelection()
+        }
+
+        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 true
-}

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> {
@@ -14,138 +13,137 @@ declare module '@tiptap/core' {
       /**
        * Splits one list item into two list items.
        * @param typeOrName The type or name of the node.
+       * @param overrideAttrs The attributes to ensure on the new node.
        * @example editor.commands.splitListItem('listItem')
        */
-      splitListItem: (typeOrName: string | NodeType) => ReturnType
+      splitListItem: (typeOrName: string | NodeType, overrideAttrs?: Record<string, any>) => ReturnType
     }
   }
 }
 
-export const splitListItem: RawCommands['splitListItem'] = typeOrName => ({
-  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
+      if (dispatch) {
+        let wrap = Fragment.empty
+        // eslint-disable-next-line
+        const depthBefore = $from.index(-1) ? 1 : $from.index(-2) ? 2 : 3
 
-      // Add a second list item with an empty default start node
-      const newNextTypeAttributes = getSplittedAttributes(
-        extensionAttributes,
-        $from.node().type.name,
-        $from.node().attrs,
-      )
-      const nextType = type.contentMatch.defaultType?.createAndFill(newNextTypeAttributes) || 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))
+        }
 
-      wrap = wrap.append(Fragment.from(type.createAndFill(null, nextType) || undefined))
+        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
 
-      const start = $from.before($from.depth - (depthBefore - 1))
+        wrap = wrap.append(Fragment.from(type.createAndFill(null, nextType) || undefined))
 
-      tr.replace(start, $from.after(-depthAfter), new Slice(wrap, 4 - depthBefore, 0))
+        const start = $from.before($from.depth - (depthBefore - 1))
 
-      let sel = -1
+        tr.replace(start, $from.after(-depthAfter), new Slice(wrap, 4 - depthBefore, 0))
 
-      tr.doc.nodesBetween(start, tr.doc.content.size, (n, pos) => {
-        if (sel > -1) {
-          return false
-        }
+        let sel = -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 (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,
-  )
-  const newNextTypeAttributes = getSplittedAttributes(
-    extensionAttributes,
-    $from.node().type.name,
-    $from.node().attrs,
-  )
-
-  tr.delete($from.pos, $to.pos)
-
-  const types = nextType
-    ? [
-      { type, attrs: newTypeAttributes },
-      { type: nextType, attrs: newNextTypeAttributes },
-    ]
-    : [{ type, attrs: newTypeAttributes }]
-
-  if (!canSplit(tr.doc, $from.pos, 2)) {
-    return false
-  }
+    const newTypeAttributes = {
+      ...getSplittedAttributes(extensionAttributes, grandParent.type.name, grandParent.attrs),
+      ...overrideAttrs,
+    }
+    const newNextTypeAttributes = {
+      ...getSplittedAttributes(extensionAttributes, $from.node().type.name, $from.node().attrs),
+      ...overrideAttrs,
+    }
 
-  if (dispatch) {
-    const { selection, storedMarks } = state
-    const { splittableMarks } = editor.extensionManager
-    const marks = storedMarks || (selection.$to.parentOffset && selection.$from.marks())
+    tr.delete($from.pos, $to.pos)
 
-    tr.split($from.pos, 2, types).scrollIntoView()
+    const types = nextType
+      ? [
+          { type, attrs: newTypeAttributes },
+          { type: nextType, attrs: newNextTypeAttributes },
+        ]
+      : [{ type, attrs: newTypeAttributes }]
 
-    if (!marks || !dispatch) {
-      return true
+    if (!canSplit(tr.doc, $from.pos, 2)) {
+      return false
     }
 
-    const filteredMarks = marks.filter(mark => splittableMarks.includes(mark.type.name))
+    if (dispatch) {
+      const { selection, storedMarks } = state
+      const { splittableMarks } = editor.extensionManager
+      const marks = storedMarks || (selection.$to.parentOffset && selection.$from.marks())
 
-    tr.ensureMarks(filteredMarks)
-  }
+      tr.split($from.pos, 2, types).scrollIntoView()
 
-  return true
-}
+      if (!marks || !dispatch) {
+        return true
+      }
+
+      const filteredMarks = marks.filter(mark => splittableMarks.includes(mark.type.name))
+
+      tr.ensureMarks(filteredMarks)
+    }
+
+    return true
+  }