@tiptap/core 3.0.0-next.3 → 3.0.0-next.5

package/src/commands/setNode.ts

@@ -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

@@ -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

@@ -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

@@ -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

@@ -29,95 +29,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
-}

package/src/commands/splitListItem.ts

@@ -1,6 +1,4 @@
-import {
-  Fragment, Node as ProseMirrorNode, NodeType, Slice,
-} from '@tiptap/pm/model'
+import { Fragment, Node as ProseMirrorNode, NodeType, Slice } from '@tiptap/pm/model'
 import { TextSelection } from '@tiptap/pm/state'
 import { canSplit } from '@tiptap/pm/transform'
 
@@ -22,140 +20,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
-}