@tiptap/core 2.0.0-beta.2 → 2.0.0-beta.200

package/src/commands/splitListItem.ts

@@ -1,22 +1,23 @@
 import {
-  NodeType,
-  Node as ProseMirrorNode,
   Fragment,
+  Node as ProseMirrorNode,
+  NodeType,
   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'
+import { canSplit } from 'prosemirror-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,
     }
   }
 }
@@ -57,14 +58,26 @@ export const splitListItem: RawCommands['splitListItem'] = typeOrName => ({
 
     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,16 +85,30 @@ 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

package/src/commands/toggleList.ts

@@ -1,16 +1,71 @@
 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 { Transaction } from 'prosemirror-state'
+import { canJoin } from 'prosemirror-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) => ReturnType,
     }
   }
 }
@@ -18,7 +73,7 @@ declare module '@tiptap/core' {
 export const toggleList: RawCommands['toggleList'] = (listTypeOrName, itemTypeOrName) => ({
   editor, tr, state, dispatch, chain, commands, can,
 }) => {
-  const { extensions } = editor.options
+  const { extensions } = editor.extensionManager
   const listType = getNodeType(listTypeOrName, state.schema)
   const itemType = getNodeType(itemTypeOrName, state.schema)
   const { selection } = state
@@ -43,21 +98,31 @@ export const toggleList: RawCommands['toggleList'] = (listTypeOrName, itemTypeOr
       && 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()
     }
   }
 
-  const canWrapInList = can().wrapInList(listType)
+  return chain()
+    // try to convert node to default node if needed
+    .command(() => {
+      const canWrapInList = can().wrapInList(listType)
 
-  // try to convert node to paragraph if needed
-  if (!canWrapInList) {
-    return chain()
-      .clearNodes()
-      .wrapInList(listType)
-      .run()
-  }
+      if (canWrapInList) {
+        return true
+      }
 
-  return commands.wrapInList(listType)
+      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 { 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,16 @@
 import { NodeType } from 'prosemirror-model'
-import { AnyObject, Command, RawCommands } from '../types'
-import isNodeActive from '../helpers/isNodeActive'
-import getNodeType from '../helpers/getNodeType'
+
+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,
     }
   }
 }

package/src/commands/toggleWrap.ts

@@ -1,27 +1,27 @@
-import { wrapIn, lift } from 'prosemirror-commands'
 import { NodeType } from 'prosemirror-model'
-import { AnyObject, Command, RawCommands } from '../types'
-import isNodeActive from '../helpers/isNodeActive'
-import getNodeType from '../helpers/getNodeType'
+
+import { getNodeType } from '../helpers/getNodeType'
+import { isNodeActive } from '../helpers/isNodeActive'
+import { RawCommands } from '../types'
 
 declare module '@tiptap/core' {
-  interface Commands {
+  interface Commands<ReturnType> {
     toggleWrap: {
       /**
        * Wraps nodes in another node, or removes an existing wrap.
        */
-      toggleWrap: (typeOrName: string | NodeType, attributes?: AnyObject) => Command,
+      toggleWrap: (typeOrName: string | NodeType, attributes?: Record<string, any>) => ReturnType,
     }
   }
 }
 
-export const toggleWrap: RawCommands['toggleWrap'] = (typeOrName, attributes = {}) => ({ state, dispatch }) => {
+export const toggleWrap: RawCommands['toggleWrap'] = (typeOrName, attributes = {}) => ({ state, commands }) => {
   const type = getNodeType(typeOrName, state.schema)
   const isActive = isNodeActive(state, type, attributes)
 
   if (isActive) {
-    return lift(state, dispatch)
+    return commands.lift(type)
   }
 
-  return wrapIn(type, attributes)(state, dispatch)
+  return commands.wrapIn(type, attributes)
 }

package/src/commands/undoInputRule.ts

@@ -1,17 +1,46 @@
-import { undoInputRule as originalUndoInputRule } from 'prosemirror-inputrules'
-import { Command, RawCommands } from '../types'
+import { RawCommands } from '../types'
 
 declare module '@tiptap/core' {
-  interface Commands {
+  interface Commands<ReturnType> {
     undoInputRule: {
       /**
        * Undo an input rule.
        */
-      undoInputRule: () => Command,
+      undoInputRule: () => ReturnType,
     }
   }
 }
 
 export const undoInputRule: RawCommands['undoInputRule'] = () => ({ state, dispatch }) => {
-  return originalUndoInputRule(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)
+        }
+      }
+
+      return true
+    }
+  }
+
+  return false
 }

package/src/commands/unsetAllMarks.ts

@@ -1,30 +1,28 @@
-import { Command, RawCommands } from '../types'
+import { RawCommands } from '../types'
 
 declare module '@tiptap/core' {
-  interface Commands {
+  interface Commands<ReturnType> {
     unsetAllMarks: {
       /**
        * Remove all marks in the current selection.
        */
-      unsetAllMarks: () => Command,
+      unsetAllMarks: () => ReturnType,
     }
   }
 }
 
-export const unsetAllMarks: RawCommands['unsetAllMarks'] = () => ({ tr, state, dispatch }) => {
+export const unsetAllMarks: RawCommands['unsetAllMarks'] = () => ({ tr, dispatch }) => {
   const { selection } = tr
-  const { from, to, empty } = selection
+  const { empty, ranges } = selection
 
   if (empty) {
     return true
   }
 
   if (dispatch) {
-    Object
-      .entries(state.schema.marks)
-      .forEach(([, mark]) => {
-        tr.removeMark(from, to, mark as any)
-      })
+    ranges.forEach(range => {
+      tr.removeMark(range.$from.pos, range.$to.pos)
+    })
   }
 
   return true

package/src/commands/unsetMark.ts

@@ -1,38 +1,56 @@
 import { MarkType } from 'prosemirror-model'
-import { Command, RawCommands } from '../types'
-import getMarkType from '../helpers/getMarkType'
-import getMarkRange from '../helpers/getMarkRange'
+
+import { getMarkRange } from '../helpers/getMarkRange'
+import { getMarkType } from '../helpers/getMarkType'
+import { RawCommands } from '../types'
 
 declare module '@tiptap/core' {
-  interface Commands {
+  interface Commands<ReturnType> {
     unsetMark: {
       /**
        * Remove all marks in the current selection.
        */
-      unsetMark: (typeOrName: string | MarkType) => Command,
+      unsetMark: (
+        typeOrName: string | MarkType,
+        options?: {
+          /**
+           * Removes the mark even across the current selection. Defaults to `false`.
+           */
+          extendEmptyMarkRange?: boolean,
+        },
+      ) => ReturnType,
     }
   }
 }
 
-export const unsetMark: RawCommands['unsetMark'] = typeOrName => ({ tr, state, dispatch }) => {
+export const unsetMark: RawCommands['unsetMark'] = (typeOrName, options = {}) => ({ tr, state, dispatch }) => {
+  const { extendEmptyMarkRange = false } = options
   const { selection } = tr
   const type = getMarkType(typeOrName, state.schema)
-  let { from, to } = selection
-  const { $from, empty } = selection
+  const { $from, empty, ranges } = selection
+
+  if (!dispatch) {
+    return true
+  }
 
-  if (empty) {
-    const range = getMarkRange($from, type)
+  if (empty && extendEmptyMarkRange) {
+    let { from, to } = selection
+    const attrs = $from.marks().find(mark => mark.type === type)?.attrs
+    const range = getMarkRange($from, type, attrs)
 
     if (range) {
       from = range.from
       to = range.to
     }
-  }
 
-  if (dispatch) {
     tr.removeMark(from, to, type)
-    tr.removeStoredMark(type)
+  } else {
+    ranges.forEach(range => {
+      tr.removeMark(range.$from.pos, range.$to.pos, type)
+    })
   }
 
+  tr.removeStoredMark(type)
+
   return true
 }

package/src/commands/updateAttributes.ts

@@ -0,0 +1,73 @@
+import { MarkType, NodeType } from 'prosemirror-model'
+
+import { getMarkType } from '../helpers/getMarkType'
+import { getNodeType } from '../helpers/getNodeType'
+import { getSchemaTypeNameByName } from '../helpers/getSchemaTypeNameByName'
+import { RawCommands } from '../types'
+
+declare module '@tiptap/core' {
+  interface Commands<ReturnType> {
+    updateAttributes: {
+      /**
+       * Update attributes of a node or mark.
+       */
+      updateAttributes: (typeOrName: string | NodeType | MarkType, attributes: Record<string, any>) => ReturnType,
+    }
+  }
+}
+
+export const updateAttributes: RawCommands['updateAttributes'] = (typeOrName, attributes = {}) => ({ tr, state, dispatch }) => {
+  let nodeType: NodeType | null = null
+  let markType: MarkType | null = null
+
+  const schemaType = getSchemaTypeNameByName(
+    typeof typeOrName === 'string'
+      ? typeOrName
+      : typeOrName.name,
+    state.schema,
+  )
+
+  if (!schemaType) {
+    return false
+  }
+
+  if (schemaType === 'node') {
+    nodeType = getNodeType(typeOrName as NodeType, state.schema)
+  }
+
+  if (schemaType === 'mark') {
+    markType = getMarkType(typeOrName as MarkType, state.schema)
+  }
+
+  if (dispatch) {
+    tr.selection.ranges.forEach(range => {
+      const from = range.$from.pos
+      const to = range.$to.pos
+
+      state.doc.nodesBetween(from, to, (node, pos) => {
+        if (nodeType && nodeType === node.type) {
+          tr.setNodeMarkup(pos, undefined, {
+            ...node.attrs,
+            ...attributes,
+          })
+        }
+
+        if (markType && node.marks.length) {
+          node.marks.forEach(mark => {
+            if (markType === mark.type) {
+              const trimmedFrom = Math.max(pos, from)
+              const trimmedTo = Math.min(pos + node.nodeSize, to)
+
+              tr.addMark(trimmedFrom, trimmedTo, markType.create({
+                ...mark.attrs,
+                ...attributes,
+              }))
+            }
+          })
+        }
+      })
+    })
+  }
+
+  return true
+}

package/src/commands/wrapIn.ts

@@ -1,27 +1,22 @@
 import { wrapIn as originalWrapIn } from 'prosemirror-commands'
 import { NodeType } from 'prosemirror-model'
-import { AnyObject, Command, RawCommands } from '../types'
-import isNodeActive from '../helpers/isNodeActive'
-import getNodeType from '../helpers/getNodeType'
+
+import { getNodeType } from '../helpers/getNodeType'
+import { RawCommands } from '../types'
 
 declare module '@tiptap/core' {
-  interface Commands {
+  interface Commands<ReturnType> {
     wrapIn: {
       /**
        * Wraps nodes in another node.
        */
-      wrapIn: (typeOrName: string | NodeType, attributes?: AnyObject) => Command,
+      wrapIn: (typeOrName: string | NodeType, attributes?: Record<string, any>) => ReturnType,
     }
   }
 }
 
 export const wrapIn: RawCommands['wrapIn'] = (typeOrName, attributes = {}) => ({ state, dispatch }) => {
   const type = getNodeType(typeOrName, state.schema)
-  const isActive = isNodeActive(state, type, attributes)
-
-  if (isActive) {
-    return false
-  }
 
   return originalWrapIn(type, attributes)(state, dispatch)
 }

package/src/commands/wrapInList.ts

@@ -1,15 +1,16 @@
-import { wrapInList as originalWrapInList } from 'prosemirror-schema-list'
 import { NodeType } from 'prosemirror-model'
-import { AnyObject, Command, RawCommands } from '../types'
-import getNodeType from '../helpers/getNodeType'
+import { wrapInList as originalWrapInList } from 'prosemirror-schema-list'
+
+import { getNodeType } from '../helpers/getNodeType'
+import { RawCommands } from '../types'
 
 declare module '@tiptap/core' {
-  interface Commands {
+  interface Commands<ReturnType> {
     wrapInList: {
       /**
        * Wrap a node in a list.
        */
-      wrapInList: (typeOrName: string | NodeType, attributes?: AnyObject) => Command,
+      wrapInList: (typeOrName: string | NodeType, attributes?: Record<string, any>) => ReturnType,
     }
   }
 }