@tiptap/core 2.0.0-beta.21 → 2.0.0-beta.210

package/src/commands/keyboardShortcut.ts

@@ -1,6 +1,6 @@
-import { Command, RawCommands } from '../types'
-
-const mac = typeof navigator !== 'undefined' ? /Mac/.test(navigator.platform) : false
+import { RawCommands } from '../types'
+import { isiOS } from '../utilities/isiOS'
+import { isMacOS } from '../utilities/isMacOS'
 
 function normalizeKeyName(name: string) {
   const parts = name.split(/-(?!$)/)
@@ -27,7 +27,7 @@ function normalizeKeyName(name: string) {
     } else if (/^s(hift)?$/i.test(mod)) {
       shift = true
     } else if (/^mod$/i.test(mod)) {
-      if (mac) {
+      if (isiOS() || isMacOS()) {
         meta = true
       } else {
         ctrl = true
@@ -57,12 +57,12 @@ function normalizeKeyName(name: string) {
 }
 
 declare module '@tiptap/core' {
-  interface Commands {
+  interface Commands<ReturnType> {
     keyboardShortcut: {
       /**
        * Trigger a keyboard shortcut.
        */
-      keyboardShortcut: (name: string) => Command,
+      keyboardShortcut: (name: string) => ReturnType,
     }
   }
 }

package/src/commands/lift.ts

@@ -1,16 +1,17 @@
-import { lift as originalLift } from 'prosemirror-commands'
-import { NodeType } from 'prosemirror-model'
-import { Command, RawCommands, AnyObject } from '../types'
-import isNodeActive from '../helpers/isNodeActive'
-import getNodeType from '../helpers/getNodeType'
+import { lift as originalLift } from '@tiptap/pm/commands'
+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> {
     lift: {
       /**
        * Removes an existing wrap.
        */
-      lift: (typeOrName: string | NodeType, attributes?: AnyObject) => Command,
+      lift: (typeOrName: string | NodeType, attributes?: Record<string, any>) => ReturnType
     }
   }
 }

package/src/commands/liftEmptyBlock.ts

@@ -1,13 +1,14 @@
-import { liftEmptyBlock as originalLiftEmptyBlock } from 'prosemirror-commands'
-import { Command, RawCommands } from '../types'
+import { liftEmptyBlock as originalLiftEmptyBlock } from '@tiptap/pm/commands'
+
+import { RawCommands } from '../types'
 
 declare module '@tiptap/core' {
-  interface Commands {
+  interface Commands<ReturnType> {
     liftEmptyBlock: {
       /**
        * Lift block if empty.
        */
-      liftEmptyBlock: () => Command,
+      liftEmptyBlock: () => ReturnType,
     }
   }
 }

package/src/commands/liftListItem.ts

@@ -1,15 +1,16 @@
-import { liftListItem as originalLiftListItem } 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 { liftListItem as originalLiftListItem } from '@tiptap/pm/schema-list'
+
+import { getNodeType } from '../helpers/getNodeType'
+import { RawCommands } from '../types'
 
 declare module '@tiptap/core' {
-  interface Commands {
+  interface Commands<ReturnType> {
     liftListItem: {
       /**
        * Lift the list item into a wrapping list.
        */
-      liftListItem: (typeOrName: string | NodeType) => Command,
+      liftListItem: (typeOrName: string | NodeType) => ReturnType
     }
   }
 }

package/src/commands/newlineInCode.ts

@@ -1,13 +1,14 @@
-import { newlineInCode as originalNewlineInCode } from 'prosemirror-commands'
-import { Command, RawCommands } from '../types'
+import { newlineInCode as originalNewlineInCode } from '@tiptap/pm/commands'
+
+import { RawCommands } from '../types'
 
 declare module '@tiptap/core' {
-  interface Commands {
+  interface Commands<ReturnType> {
     newlineInCode: {
       /**
        * Add a newline character in code.
        */
-      newlineInCode: () => Command,
+      newlineInCode: () => ReturnType
     }
   }
 }

package/src/commands/resetAttributes.ts

@@ -1,17 +1,21 @@
-import { NodeType, MarkType } from 'prosemirror-model'
-import getNodeType from '../helpers/getNodeType'
-import getMarkType from '../helpers/getMarkType'
-import getSchemaTypeNameByName from '../helpers/getSchemaTypeNameByName'
-import deleteProps from '../utilities/deleteProps'
-import { Command, RawCommands } from '../types'
+import { MarkType, NodeType } from '@tiptap/pm/model'
+
+import { getMarkType } from '../helpers/getMarkType'
+import { getNodeType } from '../helpers/getNodeType'
+import { getSchemaTypeNameByName } from '../helpers/getSchemaTypeNameByName'
+import { RawCommands } from '../types'
+import { deleteProps } from '../utilities/deleteProps'
 
 declare module '@tiptap/core' {
-  interface Commands {
+  interface Commands<ReturnType> {
     resetAttributes: {
       /**
        * Resets some node attributes to the default value.
        */
-      resetAttributes: (typeOrName: string | NodeType | MarkType, attributes: string | string[]) => Command,
+      resetAttributes: (
+        typeOrName: string | NodeType | MarkType,
+        attributes: string | string[],
+      ) => ReturnType
     }
   }
 }
@@ -21,9 +25,7 @@ export const resetAttributes: RawCommands['resetAttributes'] = (typeOrName, attr
   let markType: MarkType | null = null
 
   const schemaType = getSchemaTypeNameByName(
-    typeof typeOrName === 'string'
-      ? typeOrName
-      : typeOrName.name,
+    typeof typeOrName === 'string' ? typeOrName : typeOrName.name,
     state.schema,
   )
 
@@ -49,7 +51,11 @@ export const resetAttributes: RawCommands['resetAttributes'] = (typeOrName, attr
         if (markType && node.marks.length) {
           node.marks.forEach(mark => {
             if (markType === mark.type) {
-              tr.addMark(pos, pos + node.nodeSize, markType.create(deleteProps(mark.attrs, attributes)))
+              tr.addMark(
+                pos,
+                pos + node.nodeSize,
+                markType.create(deleteProps(mark.attrs, attributes)),
+              )
             }
           })
         }

package/src/commands/scrollIntoView.ts

@@ -1,12 +1,12 @@
-import { Command, RawCommands } from '../types'
+import { RawCommands } from '../types'
 
 declare module '@tiptap/core' {
-  interface Commands {
+  interface Commands<ReturnType> {
     scrollIntoView: {
       /**
        * Scroll the selection into view.
        */
-      scrollIntoView: () => Command,
+      scrollIntoView: () => ReturnType,
     }
   }
 }

package/src/commands/selectAll.ts

@@ -1,17 +1,19 @@
-import { selectAll as originalSelectAll } from 'prosemirror-commands'
-import { Command, RawCommands } from '../types'
+import { RawCommands } from '../types'
 
 declare module '@tiptap/core' {
-  interface Commands {
+  interface Commands<ReturnType> {
     selectAll: {
       /**
        * Select the whole document.
        */
-      selectAll: () => Command,
+      selectAll: () => ReturnType,
     }
   }
 }
 
-export const selectAll: RawCommands['selectAll'] = () => ({ state, dispatch }) => {
-  return originalSelectAll(state, dispatch)
+export const selectAll: RawCommands['selectAll'] = () => ({ tr, commands }) => {
+  return commands.setTextSelection({
+    from: 0,
+    to: tr.doc.content.size,
+  })
 }

package/src/commands/selectNodeBackward.ts

@@ -1,13 +1,14 @@
-import { selectNodeBackward as originalSelectNodeBackward } from 'prosemirror-commands'
-import { Command, RawCommands } from '../types'
+import { selectNodeBackward as originalSelectNodeBackward } from '@tiptap/pm/commands'
+
+import { RawCommands } from '../types'
 
 declare module '@tiptap/core' {
-  interface Commands {
+  interface Commands<ReturnType> {
     selectNodeBackward: {
       /**
        * Select a node backward.
        */
-      selectNodeBackward: () => Command,
+      selectNodeBackward: () => ReturnType
     }
   }
 }

package/src/commands/selectNodeForward.ts

@@ -1,13 +1,14 @@
-import { selectNodeForward as originalSelectNodeForward } from 'prosemirror-commands'
-import { Command, RawCommands } from '../types'
+import { selectNodeForward as originalSelectNodeForward } from '@tiptap/pm/commands'
+
+import { RawCommands } from '../types'
 
 declare module '@tiptap/core' {
-  interface Commands {
+  interface Commands<ReturnType> {
     selectNodeForward: {
       /**
        * Select a node forward.
        */
-      selectNodeForward: () => Command,
+      selectNodeForward: () => ReturnType
     }
   }
 }

package/src/commands/selectParentNode.ts

@@ -1,13 +1,14 @@
-import { selectParentNode as originalSelectParentNode } from 'prosemirror-commands'
-import { Command, RawCommands } from '../types'
+import { selectParentNode as originalSelectParentNode } from '@tiptap/pm/commands'
+
+import { RawCommands } from '../types'
 
 declare module '@tiptap/core' {
-  interface Commands {
+  interface Commands<ReturnType> {
     selectParentNode: {
       /**
        * Select the parent node.
        */
-      selectParentNode: () => Command,
+      selectParentNode: () => ReturnType
     }
   }
 }

package/src/commands/selectTextblockEnd.ts

@@ -0,0 +1,20 @@
+// @ts-ignore
+// TODO: add types to @types/prosemirror-commands
+import { selectTextblockEnd as originalSelectTextblockEnd } from '@tiptap/pm/commands'
+
+import { RawCommands } from '../types'
+
+declare module '@tiptap/core' {
+  interface Commands<ReturnType> {
+    selectTextblockEnd: {
+      /**
+       * Moves the cursor to the end of current text block.
+       */
+      selectTextblockEnd: () => ReturnType
+    }
+  }
+}
+
+export const selectTextblockEnd: RawCommands['selectTextblockEnd'] = () => ({ state, dispatch }) => {
+  return originalSelectTextblockEnd(state, dispatch)
+}

package/src/commands/selectTextblockStart.ts

@@ -0,0 +1,20 @@
+// @ts-ignore
+// TODO: add types to @types/prosemirror-commands
+import { selectTextblockStart as originalSelectTextblockStart } from '@tiptap/pm/commands'
+
+import { RawCommands } from '../types'
+
+declare module '@tiptap/core' {
+  interface Commands<ReturnType> {
+    selectTextblockStart: {
+      /**
+       * Moves the cursor to the start of current text block.
+       */
+      selectTextblockStart: () => ReturnType
+    }
+  }
+}
+
+export const selectTextblockStart: RawCommands['selectTextblockStart'] = () => ({ state, dispatch }) => {
+  return originalSelectTextblockStart(state, dispatch)
+}

package/src/commands/setContent.ts

@@ -1,23 +1,19 @@
-import { TextSelection } from 'prosemirror-state'
-import createDocument from '../helpers/createDocument'
-import {
-  AnyObject,
-  Command,
-  RawCommands,
-  Content,
-} from '../types'
+import { ParseOptions } from '@tiptap/pm/model'
+
+import { createDocument } from '../helpers/createDocument'
+import { Content, RawCommands } from '../types'
 
 declare module '@tiptap/core' {
-  interface Commands {
+  interface Commands<ReturnType> {
     setContent: {
       /**
        * Replace the whole document with new content.
        */
       setContent: (
         content: Content,
-        emitUpdate?: Boolean,
-        parseOptions?: AnyObject,
-      ) => Command,
+        emitUpdate?: boolean,
+        parseOptions?: ParseOptions,
+      ) => ReturnType
     }
   }
 }
@@ -25,12 +21,9 @@ declare module '@tiptap/core' {
 export const setContent: RawCommands['setContent'] = (content, emitUpdate = false, parseOptions = {}) => ({ tr, editor, dispatch }) => {
   const { doc } = tr
   const document = createDocument(content, editor.schema, parseOptions)
-  const selection = TextSelection.create(doc, 0, doc.content.size)
 
   if (dispatch) {
-    tr.setSelection(selection)
-      .replaceSelectionWith(document, false)
-      .setMeta('preventUpdate', !emitUpdate)
+    tr.replaceWith(0, doc.content.size, document).setMeta('preventUpdate', !emitUpdate)
   }
 
   return true

package/src/commands/setMark.ts

@@ -1,38 +1,114 @@
-import { MarkType } from 'prosemirror-model'
-import { AnyObject, Command, RawCommands } from '../types'
-import getMarkType from '../helpers/getMarkType'
-import getMarkAttributes from '../helpers/getMarkAttributes'
+import { MarkType, ResolvedPos } from '@tiptap/pm/model'
+import { EditorState, Transaction } from '@tiptap/pm/state'
+
+import { isTextSelection } from '../helpers'
+import { getMarkAttributes } from '../helpers/getMarkAttributes'
+import { getMarkType } from '../helpers/getMarkType'
+import { RawCommands } from '../types'
 
 declare module '@tiptap/core' {
-  interface Commands {
+  interface Commands<ReturnType> {
     setMark: {
       /**
        * Add a mark with new attributes.
        */
-      setMark: (typeOrName: string | MarkType, attributes?: AnyObject) => Command,
+      setMark: (typeOrName: string | MarkType, attributes?: Record<string, any>) => ReturnType
     }
   }
 }
 
+function canSetMark(state: EditorState, tr: Transaction, newMarkType: MarkType) {
+  const { selection } = tr
+  let cursor: ResolvedPos | null = null
+
+  if (isTextSelection(selection)) {
+    cursor = selection.$cursor
+  }
+
+  if (cursor) {
+    const currentMarks = state.storedMarks ?? cursor.marks()
+
+    // There can be no current marks that exclude the new mark
+    return (
+      !!newMarkType.isInSet(currentMarks)
+      || !currentMarks.some(mark => mark.type.excludes(newMarkType))
+    )
+  }
+
+  const { ranges } = selection
+
+  return ranges.some(({ $from, $to }) => {
+    let someNodeSupportsMark = $from.depth === 0
+      ? state.doc.inlineContent && state.doc.type.allowsMarkType(newMarkType)
+      : false
+
+    state.doc.nodesBetween($from.pos, $to.pos, (node, _pos, parent) => {
+      // If we already found a mark that we can enable, return false to bypass the remaining search
+      if (someNodeSupportsMark) {
+        return false
+      }
+
+      if (node.isInline) {
+        const parentAllowsMarkType = !parent || parent.type.allowsMarkType(newMarkType)
+        const currentMarksAllowMarkType = !!newMarkType.isInSet(node.marks)
+          || !node.marks.some(otherMark => otherMark.type.excludes(newMarkType))
+
+        someNodeSupportsMark = parentAllowsMarkType && currentMarksAllowMarkType
+      }
+      return !someNodeSupportsMark
+    })
+
+    return someNodeSupportsMark
+  })
+}
 export const setMark: RawCommands['setMark'] = (typeOrName, attributes = {}) => ({ tr, state, dispatch }) => {
   const { selection } = tr
   const { empty, ranges } = selection
   const type = getMarkType(typeOrName, state.schema)
-  const oldAttributes = getMarkAttributes(state, type)
-  const newAttributes = {
-    ...oldAttributes,
-    ...attributes,
-  }
 
   if (dispatch) {
     if (empty) {
-      tr.addStoredMark(type.create(newAttributes))
+      const oldAttributes = getMarkAttributes(state, type)
+
+      tr.addStoredMark(
+        type.create({
+          ...oldAttributes,
+          ...attributes,
+        }),
+      )
     } else {
       ranges.forEach(range => {
-        tr.addMark(range.$from.pos, range.$to.pos, type.create(newAttributes))
+        const from = range.$from.pos
+        const to = range.$to.pos
+
+        state.doc.nodesBetween(from, to, (node, pos) => {
+          const trimmedFrom = Math.max(pos, from)
+          const trimmedTo = Math.min(pos + node.nodeSize, to)
+          const someHasMark = node.marks.find(mark => mark.type === type)
+
+          // if there is already a mark of this type
+          // we know that we have to merge its attributes
+          // otherwise we add a fresh new mark
+          if (someHasMark) {
+            node.marks.forEach(mark => {
+              if (type === mark.type) {
+                tr.addMark(
+                  trimmedFrom,
+                  trimmedTo,
+                  type.create({
+                    ...mark.attrs,
+                    ...attributes,
+                  }),
+                )
+              }
+            })
+          } else {
+            tr.addMark(trimmedFrom, trimmedTo, type.create(attributes))
+          }
+        })
       })
     }
   }
 
-  return true
+  return canSetMark(state, tr, type)
 }

package/src/commands/setMeta.ts

@@ -0,0 +1,18 @@
+import { RawCommands } from '../types'
+
+declare module '@tiptap/core' {
+  interface Commands<ReturnType> {
+    setMeta: {
+      /**
+       * Store a metadata property in the current transaction.
+       */
+      setMeta: (key: string, value: any) => ReturnType,
+    }
+  }
+}
+
+export const setMeta: RawCommands['setMeta'] = (key, value) => ({ tr }) => {
+  tr.setMeta(key, value)
+
+  return true
+}

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