@tiptap/core 2.0.0-beta.22 → 2.0.0-beta.220

package/src/commands/setNode.ts

@@ -1,21 +1,45 @@
-import { NodeType } from 'prosemirror-model'
-import { setBlockType } from 'prosemirror-commands'
-import { AnyObject, Command, RawCommands } from '../types'
-import getNodeType from '../helpers/getNodeType'
+import { setBlockType } from '@tiptap/pm/commands'
+import { NodeType } from '@tiptap/pm/model'
+
+import { getNodeType } from '../helpers/getNodeType'
+import { RawCommands } from '../types'
 
 declare module '@tiptap/core' {
-  interface Commands {
+  interface Commands<ReturnType> {
     setNode: {
       /**
        * Replace a given range with a node.
        */
-      setNode: (typeOrName: string | NodeType, attributes?: AnyObject) => Command,
+      setNode: (typeOrName: string | NodeType, attributes?: Record<string, any>) => ReturnType
     }
   }
 }
 
-export const setNode: RawCommands['setNode'] = (typeOrName, attributes = {}) => ({ state, dispatch }) => {
+export const setNode: RawCommands['setNode'] = (typeOrName, attributes = {}) => ({ state, dispatch, chain }) => {
   const type = getNodeType(typeOrName, state.schema)
 
-  return setBlockType(type, attributes)(state, dispatch)
+  // TODO: use a fallback like insertContent?
+  if (!type.isTextblock) {
+    console.warn('[tiptap warn]: Currently "setNode()" only supports text block nodes.')
+
+    return false
+  }
+
+  return (
+    chain()
+    // try to convert node to default node if needed
+      .command(({ commands }) => {
+        const canSetBlock = setBlockType(type, attributes)(state)
+
+        if (canSetBlock) {
+          return true
+        }
+
+        return commands.clearNodes()
+      })
+      .command(({ state: updatedState }) => {
+        return setBlockType(type, attributes)(updatedState, dispatch)
+      })
+      .run()
+  )
 }

package/src/commands/setNodeSelection.ts

@@ -0,0 +1,27 @@
+import { NodeSelection } from '@tiptap/pm/state'
+
+import { RawCommands } from '../types'
+import { minMax } from '../utilities/minMax'
+
+declare module '@tiptap/core' {
+  interface Commands<ReturnType> {
+    setNodeSelection: {
+      /**
+       * Creates a NodeSelection.
+       */
+      setNodeSelection: (position: number) => ReturnType
+    }
+  }
+}
+
+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)
+  }
+
+  return true
+}

package/src/commands/setTextSelection.ts

@@ -0,0 +1,31 @@
+import { TextSelection } from '@tiptap/pm/state'
+
+import { Range, RawCommands } from '../types'
+import { minMax } from '../utilities/minMax'
+
+declare module '@tiptap/core' {
+  interface Commands<ReturnType> {
+    setTextSelection: {
+      /**
+       * Creates a TextSelection.
+       */
+      setTextSelection: (position: number | Range) => ReturnType
+    }
+  }
+}
+
+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)
+  }
+
+  return true
+}

package/src/commands/sinkListItem.ts

@@ -1,15 +1,16 @@
-import { sinkListItem as originalSinkListItem } from 'prosemirror-schema-list'
-import { NodeType } from 'prosemirror-model'
-import { Command, RawCommands } from '../types'
-import getNodeType from '../helpers/getNodeType'
+import { NodeType } from '@tiptap/pm/model'
+import { sinkListItem as originalSinkListItem } from '@tiptap/pm/schema-list'
+
+import { getNodeType } from '../helpers/getNodeType'
+import { RawCommands } from '../types'
 
 declare module '@tiptap/core' {
-  interface Commands {
+  interface Commands<ReturnType> {
     sinkListItem: {
       /**
        * Sink the list item down into an inner list.
        */
-      sinkListItem: (typeOrName: string | NodeType) => Command,
+      sinkListItem: (typeOrName: string | NodeType) => ReturnType
     }
   }
 }

package/src/commands/splitBlock.ts

@@ -1,23 +1,12 @@
-import { canSplit } from 'prosemirror-transform'
-import { ContentMatch, Fragment } from 'prosemirror-model'
-import { EditorState, NodeSelection, TextSelection } from 'prosemirror-state'
-import { Command, RawCommands } from '../types'
-import getSplittedAttributes from '../helpers/getSplittedAttributes'
-
-function defaultBlockAt(match: ContentMatch) {
-  for (let i = 0; i < match.edgeCount; i + 1) {
-    const { type } = match.edge(i)
-
-    if (type.isTextblock && !type.hasRequiredAttrs()) {
-      return type
-    }
-  }
-  return null
-}
+import { EditorState, NodeSelection, TextSelection } from '@tiptap/pm/state'
+import { canSplit } from '@tiptap/pm/transform'
+
+import { defaultBlockAt } from '../helpers/defaultBlockAt'
+import { getSplittedAttributes } from '../helpers/getSplittedAttributes'
+import { RawCommands } from '../types'
 
 function ensureMarks(state: EditorState, splittableMarks?: string[]) {
-  const marks = state.storedMarks
-    || (state.selection.$to.parentOffset && state.selection.$from.marks())
+  const marks = state.storedMarks || (state.selection.$to.parentOffset && state.selection.$from.marks())
 
   if (marks) {
     const filteredMarks = marks.filter(mark => splittableMarks?.includes(mark.type.name))
@@ -27,21 +16,18 @@ function ensureMarks(state: EditorState, splittableMarks?: string[]) {
 }
 
 declare module '@tiptap/core' {
-  interface Commands {
+  interface Commands<ReturnType> {
     splitBlock: {
       /**
        * Forks a new node from an existing node.
        */
-      splitBlock: (options?: { keepMarks?: boolean }) => Command,
+      splitBlock: (options?: { keepMarks?: boolean }) => ReturnType
     }
   }
 }
 
 export const splitBlock: RawCommands['splitBlock'] = ({ keepMarks = true } = {}) => ({
-  tr,
-  state,
-  dispatch,
-  editor,
+  tr, state, dispatch, editor,
 }) => {
   const { selection, doc } = tr
   const { $from, $to } = selection
@@ -84,38 +70,42 @@ export const splitBlock: RawCommands['splitBlock'] = ({ keepMarks = true } = {})
       : defaultBlockAt($from.node(-1).contentMatchAt($from.indexAfter(-1)))
 
     let types = atEnd && deflt
-      ? [{
-        type: deflt,
-        attrs: newAttributes,
-      }]
+      ? [
+        {
+          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
+        && 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 (
-        !atEnd
-        && !$from.parentOffset
-        && $from.parent.type !== deflt
-        && $from.node(-1).canReplace($from.index(-1), $from.indexAfter(-1), Fragment.from(deflt?.create()))
-      ) {
-        tr.setNodeMarkup(tr.mapping.map($from.before()), deflt || undefined)
+      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)
+        }
       }
     }
 

package/src/commands/splitListItem.ts

@@ -1,22 +1,20 @@
 import {
-  NodeType,
-  Node as ProseMirrorNode,
-  Fragment,
-  Slice,
-} from 'prosemirror-model'
-import { canSplit } from 'prosemirror-transform'
-import { TextSelection } from 'prosemirror-state'
-import { Command, RawCommands } from '../types'
-import getNodeType from '../helpers/getNodeType'
-import getSplittedAttributes from '../helpers/getSplittedAttributes'
+  Fragment, Node as ProseMirrorNode, NodeType, Slice,
+} from '@tiptap/pm/model'
+import { TextSelection } from '@tiptap/pm/state'
+import { canSplit } from '@tiptap/pm/transform'
+
+import { getNodeType } from '../helpers/getNodeType'
+import { getSplittedAttributes } from '../helpers/getSplittedAttributes'
+import { RawCommands } from '../types'
 
 declare module '@tiptap/core' {
-  interface Commands {
+  interface Commands<ReturnType> {
     splitListItem: {
       /**
        * Splits one list item into two list items.
        */
-      splitListItem: (typeOrName: string | NodeType) => Command,
+      splitListItem: (typeOrName: string | NodeType) => ReturnType
     }
   }
 }
@@ -29,7 +27,7 @@ export const splitListItem: RawCommands['splitListItem'] = typeOrName => ({
 
   // @ts-ignore
   // eslint-disable-next-line
-  const node: ProseMirrorNode = state.selection.node
+    const node: ProseMirrorNode = state.selection.node
 
   if ((node && node.isBlock) || $from.depth < 2 || !$from.sameParent($to)) {
     return false
@@ -49,22 +47,26 @@ export const splitListItem: RawCommands['splitListItem'] = typeOrName => ({
     // command handle lifting.
     if (
       $from.depth === 2
-      || $from.node(-3).type !== type
-      || $from.index(-2) !== $from.node(-2).childCount - 1
+        || $from.node(-3).type !== type
+        || $from.index(-2) !== $from.node(-2).childCount - 1
     ) {
       return false
     }
 
     if (dispatch) {
       let wrap = Fragment.empty
-      const keepItem = $from.index(-1) > 0
+      // eslint-disable-next-line
+        const depthBefore = $from.index(-1) ? 1 : $from.index(-2) ? 2 : 3
 
       // 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 - (keepItem ? 1 : 2); d >= $from.depth - 3; d -= 1) {
+      for (let d = $from.depth - depthBefore; d >= $from.depth - 3; d -= 1) {
         wrap = Fragment.from($from.node(d).copy(wrap))
       }
 
+      // 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,
@@ -72,24 +74,36 @@ export const splitListItem: RawCommands['splitListItem'] = typeOrName => ({
         $from.node().attrs,
       )
       const nextType = type.contentMatch.defaultType?.createAndFill(newNextTypeAttributes) || undefined
+
       wrap = wrap.append(Fragment.from(type.createAndFill(null, nextType) || undefined))
 
-      tr
-        .replace(
-          $from.before(keepItem ? undefined : -1),
-          $from.after(-3),
-          new Slice(wrap, keepItem ? 3 : 2, 2),
-        )
-        .setSelection(TextSelection.near(tr.doc.resolve($from.pos + (keepItem ? 3 : 2))))
-        .scrollIntoView()
+      const start = $from.before($from.depth - (depthBefore - 1))
+
+      tr.replace(start, $from.after(-depthAfter), new Slice(wrap, 4 - depthBefore, 0))
+
+      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 (sel > -1) {
+        tr.setSelection(TextSelection.near(tr.doc.resolve(sel)))
+      }
+
+      tr.scrollIntoView()
     }
 
     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,
@@ -105,7 +119,10 @@ export const splitListItem: RawCommands['splitListItem'] = typeOrName => ({
   tr.delete($from.pos, $to.pos)
 
   const types = nextType
-    ? [{ type, attrs: newTypeAttributes }, { type: nextType, attrs: newNextTypeAttributes }]
+    ? [
+      { type, attrs: newTypeAttributes },
+      { type: nextType, attrs: newNextTypeAttributes },
+    ]
     : [{ type, attrs: newTypeAttributes }]
 
   if (!canSplit(tr.doc, $from.pos, 2)) {
@@ -113,7 +130,19 @@ export const splitListItem: RawCommands['splitListItem'] = typeOrName => ({
   }
 
   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()
+
+    if (!marks || !dispatch) {
+      return true
+    }
+
+    const filteredMarks = marks.filter(mark => splittableMarks.includes(mark.type.name))
+
+    tr.ensureMarks(filteredMarks)
   }
 
   return true

package/src/commands/toggleList.ts

@@ -1,30 +1,85 @@
-import { NodeType } from 'prosemirror-model'
-import { Command, RawCommands } from '../types'
-import getNodeType from '../helpers/getNodeType'
-import findParentNode from '../helpers/findParentNode'
-import isList from '../helpers/isList'
+import { NodeType } from '@tiptap/pm/model'
+import { Transaction } from '@tiptap/pm/state'
+import { canJoin } from '@tiptap/pm/transform'
+
+import { findParentNode } from '../helpers/findParentNode'
+import { getNodeType } from '../helpers/getNodeType'
+import { isList } from '../helpers/isList'
+import { RawCommands } from '../types'
+
+const joinListBackwards = (tr: Transaction, listType: NodeType): boolean => {
+  const list = findParentNode(node => node.type === listType)(tr.selection)
+
+  if (!list) {
+    return true
+  }
+
+  const before = tr.doc.resolve(Math.max(0, list.pos - 1)).before(list.depth)
+
+  if (before === undefined) {
+    return true
+  }
+
+  const nodeBefore = tr.doc.nodeAt(before)
+  const canJoinBackwards = list.node.type === nodeBefore?.type && canJoin(tr.doc, list.pos)
+
+  if (!canJoinBackwards) {
+    return true
+  }
+
+  tr.join(list.pos)
+
+  return true
+}
+
+const joinListForwards = (tr: Transaction, listType: NodeType): boolean => {
+  const list = findParentNode(node => node.type === listType)(tr.selection)
+
+  if (!list) {
+    return true
+  }
+
+  const after = tr.doc.resolve(list.start).after(list.depth)
+
+  if (after === undefined) {
+    return true
+  }
+
+  const nodeAfter = tr.doc.nodeAt(after)
+  const canJoinForwards = list.node.type === nodeAfter?.type && canJoin(tr.doc, after)
+
+  if (!canJoinForwards) {
+    return true
+  }
+
+  tr.join(after)
+
+  return true
+}
 
 declare module '@tiptap/core' {
-  interface Commands {
+  interface Commands<ReturnType> {
     toggleList: {
       /**
        * Toggle between different list types.
        */
-      toggleList: (listTypeOrName: string | NodeType, itemTypeOrName: string | NodeType) => Command,
+      toggleList: (listTypeOrName: string | NodeType, itemTypeOrName: string | NodeType, keepMarks?: boolean) => ReturnType;
     }
   }
 }
 
-export const toggleList: RawCommands['toggleList'] = (listTypeOrName, itemTypeOrName) => ({
+export const toggleList: RawCommands['toggleList'] = (listTypeOrName, itemTypeOrName, keepMarks) => ({
   editor, tr, state, dispatch, chain, commands, can,
 }) => {
-  const { extensions } = editor.options
+  const { extensions, splittableMarks } = editor.extensionManager
   const listType = getNodeType(listTypeOrName, state.schema)
   const itemType = getNodeType(itemTypeOrName, state.schema)
-  const { selection } = state
+  const { selection, storedMarks } = state
   const { $from, $to } = selection
   const range = $from.blockRange($to)
 
+  const marks = storedMarks || (selection.$to.parentOffset && selection.$from.marks())
+
   if (!range) {
     return false
   }
@@ -40,24 +95,58 @@ export const toggleList: RawCommands['toggleList'] = (listTypeOrName, itemTypeOr
     // change list type
     if (
       isList(parentList.node.type.name, extensions)
-      && listType.validContent(parentList.node.content)
-      && dispatch
+        && listType.validContent(parentList.node.content)
+        && dispatch
     ) {
-      tr.setNodeMarkup(parentList.pos, listType)
+      return chain()
+        .command(() => {
+          tr.setNodeMarkup(parentList.pos, listType)
 
-      return true
+          return true
+        })
+        .command(() => joinListBackwards(tr, listType))
+        .command(() => joinListForwards(tr, listType))
+        .run()
     }
   }
+  if (!keepMarks || !marks || !dispatch) {
 
-  const canWrapInList = can().wrapInList(listType)
-
-  // try to convert node to paragraph if needed
-  if (!canWrapInList) {
     return chain()
-      .clearNodes()
+      // try to convert node to default node if needed
+      .command(() => {
+        const canWrapInList = can().wrapInList(listType)
+
+        if (canWrapInList) {
+          return true
+        }
+
+        return commands.clearNodes()
+      })
       .wrapInList(listType)
+      .command(() => joinListBackwards(tr, listType))
+      .command(() => joinListForwards(tr, listType))
       .run()
   }
 
-  return commands.wrapInList(listType)
+  return (
+    chain()
+    // try to convert node to default node if needed
+      .command(() => {
+        const canWrapInList = can().wrapInList(listType)
+
+        const filteredMarks = marks.filter(mark => splittableMarks.includes(mark.type.name))
+
+        tr.ensureMarks(filteredMarks)
+
+        if (canWrapInList) {
+          return true
+        }
+
+        return commands.clearNodes()
+      })
+      .wrapInList(listType)
+      .command(() => joinListBackwards(tr, listType))
+      .command(() => joinListForwards(tr, listType))
+      .run()
+  )
 }

package/src/commands/toggleMark.ts

@@ -1,25 +1,36 @@
-import { MarkType } from 'prosemirror-model'
-import { AnyObject, Command, RawCommands } from '../types'
-import getMarkType from '../helpers/getMarkType'
-import isMarkActive from '../helpers/isMarkActive'
+import { MarkType } from '@tiptap/pm/model'
+
+import { getMarkType } from '../helpers/getMarkType'
+import { isMarkActive } from '../helpers/isMarkActive'
+import { RawCommands } from '../types'
 
 declare module '@tiptap/core' {
-  interface Commands {
+  interface Commands<ReturnType> {
     toggleMark: {
       /**
        * Toggle a mark on and off.
        */
-      toggleMark: (typeOrName: string | MarkType, attributes?: AnyObject) => Command,
+      toggleMark: (
+        typeOrName: string | MarkType,
+        attributes?: Record<string, any>,
+        options?: {
+          /**
+           * Removes the mark even across the current selection. Defaults to `false`.
+           */
+          extendEmptyMarkRange?: boolean
+        },
+      ) => ReturnType
     }
   }
 }
 
-export const toggleMark: RawCommands['toggleMark'] = (typeOrName, attributes = {}) => ({ state, commands }) => {
+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)
+    return commands.unsetMark(type, { extendEmptyMarkRange })
   }
 
   return commands.setMark(type, attributes)

package/src/commands/toggleNode.ts

@@ -1,15 +1,20 @@
-import { NodeType } from 'prosemirror-model'
-import { AnyObject, Command, RawCommands } from '../types'
-import isNodeActive from '../helpers/isNodeActive'
-import getNodeType from '../helpers/getNodeType'
+import { NodeType } from '@tiptap/pm/model'
+
+import { getNodeType } from '../helpers/getNodeType'
+import { isNodeActive } from '../helpers/isNodeActive'
+import { RawCommands } from '../types'
 
 declare module '@tiptap/core' {
-  interface Commands {
+  interface Commands<ReturnType> {
     toggleNode: {
       /**
        * Toggle a node with another node.
        */
-      toggleNode: (typeOrName: string | NodeType, toggleTypeOrName: string | NodeType, attributes?: AnyObject) => Command,
+      toggleNode: (
+        typeOrName: string | NodeType,
+        toggleTypeOrName: string | NodeType,
+        attributes?: Record<string, any>,
+      ) => ReturnType
     }
   }
 }