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

package/src/helpers/isNodeActive.ts

@@ -1,49 +1,37 @@
-import { EditorState } from 'prosemirror-state'
-import { NodeType } from 'prosemirror-model'
-import objectIncludes from '../utilities/objectIncludes'
-import getNodeType from './getNodeType'
-import { AnyObject, NodeRange } from '../types'
+import { NodeType } from '@tiptap/pm/model'
+import { EditorState } from '@tiptap/pm/state'
 
-export default function isNodeActive(
+import { NodeRange } from '../types'
+import { objectIncludes } from '../utilities/objectIncludes'
+import { getNodeType } from './getNodeType'
+
+export function isNodeActive(
   state: EditorState,
   typeOrName: NodeType | string | null,
-  attributes: AnyObject = {},
+  attributes: Record<string, any> = {},
 ): boolean {
   const { from, to, empty } = state.selection
-  const type = typeOrName
-    ? getNodeType(typeOrName, state.schema)
-    : null
+  const type = typeOrName ? getNodeType(typeOrName, state.schema) : null
 
-  let nodeRanges: NodeRange[] = []
+  const nodeRanges: NodeRange[] = []
 
   state.doc.nodesBetween(from, to, (node, pos) => {
-    if (!node.isText) {
-      const relativeFrom = Math.max(from, pos)
-      const relativeTo = Math.min(to, pos + node.nodeSize)
-
-      nodeRanges = [...nodeRanges, {
-        node,
-        from: relativeFrom,
-        to: relativeTo,
-      }]
+    if (node.isText) {
+      return
     }
-  })
 
-  if (empty) {
-    return !!nodeRanges
-      .filter(nodeRange => {
-        if (!type) {
-          return true
-        }
-
-        return type.name === nodeRange.node.type.name
-      })
-      .find(nodeRange => objectIncludes(nodeRange.node.attrs, attributes))
-  }
+    const relativeFrom = Math.max(from, pos)
+    const relativeTo = Math.min(to, pos + node.nodeSize)
 
-  const selectionRange = to - from
+    nodeRanges.push({
+      node,
+      from: relativeFrom,
+      to: relativeTo,
+    })
+  })
 
-  const range = nodeRanges
+  const selectionRange = to - from
+  const matchedNodeRanges = nodeRanges
     .filter(nodeRange => {
       if (!type) {
         return true
@@ -51,11 +39,13 @@ export default function isNodeActive(
 
       return type.name === nodeRange.node.type.name
     })
-    .filter(nodeRange => objectIncludes(nodeRange.node.attrs, attributes))
-    .reduce((sum, nodeRange) => {
-      const size = nodeRange.to - nodeRange.from
-      return sum + size
-    }, 0)
+    .filter(nodeRange => objectIncludes(nodeRange.node.attrs, attributes, { strict: false }))
+
+  if (empty) {
+    return !!matchedNodeRanges.length
+  }
+
+  const range = matchedNodeRanges.reduce((sum, nodeRange) => sum + nodeRange.to - nodeRange.from, 0)
 
   return range >= selectionRange
 }

package/src/helpers/isNodeEmpty.ts

@@ -1,6 +1,6 @@
-import { Node as ProseMirrorNode } from 'prosemirror-model'
+import { Node as ProseMirrorNode } from '@tiptap/pm/model'
 
-export default function isNodeEmpty(node: ProseMirrorNode): boolean {
+export function isNodeEmpty(node: ProseMirrorNode): boolean {
   const defaultContent = node.type.createAndFill()?.toJSON()
   const content = node.toJSON()
 

package/src/helpers/isNodeSelection.ts

@@ -1,6 +1,5 @@
-import { NodeSelection } from 'prosemirror-state'
-import isObject from '../utilities/isObject'
+import { NodeSelection } from '@tiptap/pm/state'
 
-export default function isNodeSelection(value: unknown): value is NodeSelection {
-  return isObject(value) && value instanceof NodeSelection
+export function isNodeSelection(value: unknown): value is NodeSelection {
+  return value instanceof NodeSelection
 }

package/src/helpers/isTextSelection.ts

@@ -1,6 +1,5 @@
-import { TextSelection } from 'prosemirror-state'
-import isObject from '../utilities/isObject'
+import { TextSelection } from '@tiptap/pm/state'
 
-export default function isTextSelection(value: unknown): value is TextSelection {
-  return isObject(value) && value instanceof TextSelection
+export function isTextSelection(value: unknown): value is TextSelection {
+  return value instanceof TextSelection
 }

package/src/helpers/posToDOMRect.ts

@@ -0,0 +1,35 @@
+import { EditorView } from '@tiptap/pm/view'
+
+import { minMax } from '../utilities/minMax'
+
+export function posToDOMRect(view: EditorView, from: number, to: number): DOMRect {
+  const minPos = 0
+  const maxPos = view.state.doc.content.size
+  const resolvedFrom = minMax(from, minPos, maxPos)
+  const resolvedEnd = minMax(to, minPos, maxPos)
+  const start = view.coordsAtPos(resolvedFrom)
+  const end = view.coordsAtPos(resolvedEnd, -1)
+  const top = Math.min(start.top, end.top)
+  const bottom = Math.max(start.bottom, end.bottom)
+  const left = Math.min(start.left, end.left)
+  const right = Math.max(start.right, end.right)
+  const width = right - left
+  const height = bottom - top
+  const x = left
+  const y = top
+  const data = {
+    top,
+    bottom,
+    left,
+    right,
+    width,
+    height,
+    x,
+    y,
+  }
+
+  return {
+    ...data,
+    toJSON: () => data,
+  }
+}

package/src/helpers/resolveFocusPosition.ts

@@ -0,0 +1,42 @@
+import { Node as ProseMirrorNode } from '@tiptap/pm/model'
+import { Selection, TextSelection } from '@tiptap/pm/state'
+
+import { FocusPosition } from '../types'
+import { minMax } from '../utilities/minMax'
+
+export function resolveFocusPosition(
+  doc: ProseMirrorNode,
+  position: FocusPosition = null,
+): Selection | null {
+  if (!position) {
+    return null
+  }
+
+  const selectionAtStart = Selection.atStart(doc)
+  const selectionAtEnd = Selection.atEnd(doc)
+
+  if (position === 'start' || position === true) {
+    return selectionAtStart
+  }
+
+  if (position === 'end') {
+    return selectionAtEnd
+  }
+
+  const minPos = selectionAtStart.from
+  const maxPos = selectionAtEnd.to
+
+  if (position === 'all') {
+    return TextSelection.create(
+      doc,
+      minMax(0, minPos, maxPos),
+      minMax(doc.content.size, minPos, maxPos),
+    )
+  }
+
+  return TextSelection.create(
+    doc,
+    minMax(position, minPos, maxPos),
+    minMax(position, minPos, maxPos),
+  )
+}

package/src/helpers/selectionToInsertionEnd.ts

@@ -1,8 +1,8 @@
-import { Selection, Transaction } from 'prosemirror-state'
-import { ReplaceStep, ReplaceAroundStep } from 'prosemirror-transform'
+import { Selection, Transaction } from '@tiptap/pm/state'
+import { ReplaceAroundStep, ReplaceStep } from '@tiptap/pm/transform'
 
 // source: https://github.com/ProseMirror/prosemirror-state/blob/master/src/selection.js#L466
-export default function selectionToInsertionEnd(tr: Transaction, startLen: number, bias: number) {
+export function selectionToInsertionEnd(tr: Transaction, startLen: number, bias: number) {
   const last = tr.steps.length - 1
 
   if (last < startLen) {

package/src/helpers/splitExtensions.ts

@@ -1,9 +1,9 @@
-import { Extensions } from '../types'
 import { Extension } from '../Extension'
-import { Node } from '../Node'
 import { Mark } from '../Mark'
+import { Node } from '../Node'
+import { Extensions } from '../types'
 
-export default function splitExtensions(extensions: Extensions) {
+export function splitExtensions(extensions: Extensions) {
   const baseExtensions = extensions.filter(extension => extension.type === 'extension') as Extension[]
   const nodeExtensions = extensions.filter(extension => extension.type === 'node') as Node[]
   const markExtensions = extensions.filter(extension => extension.type === 'mark') as Mark[]

package/src/index.ts

@@ -1,38 +1,27 @@
+export * from './CommandManager'
 export * from './Editor'
 export * from './Extension'
-export * from './Node'
+export * as extensions from './extensions'
+export * from './helpers'
+export * from './InputRule'
+export * from './inputRules'
 export * from './Mark'
+export * from './Node'
 export * from './NodeView'
+export * from './PasteRule'
+export * from './pasteRules'
+export * from './Tracker'
 export * from './types'
+export * from './utilities'
 
-export { default as nodeInputRule } from './inputRules/nodeInputRule'
-export { default as markInputRule } from './inputRules/markInputRule'
-export { default as markPasteRule } from './pasteRules/markPasteRule'
-
-export { default as callOrReturn } from './utilities/callOrReturn'
-export { default as mergeAttributes } from './utilities/mergeAttributes'
-
-export { default as findChildren } from './helpers/findChildren'
-export { default as findParentNode } from './helpers/findParentNode'
-export { default as findParentNodeClosestToPos } from './helpers/findParentNodeClosestToPos'
-export { default as generateHTML } from './helpers/generateHTML'
-export { default as getSchema } from './helpers/getSchema'
-export { default as getHTMLFromFragment } from './helpers/getHTMLFromFragment'
-export { default as getMarkAttributes } from './helpers/getMarkAttributes'
-export { default as isActive } from './helpers/isActive'
-export { default as isMarkActive } from './helpers/isMarkActive'
-export { default as isNodeActive } from './helpers/isNodeActive'
-export { default as isNodeEmpty } from './helpers/isNodeEmpty'
-export { default as isNodeSelection } from './helpers/isNodeSelection'
-export { default as isTextSelection } from './helpers/isTextSelection'
-
-export interface Commands {}
+// eslint-disable-next-line
+export interface Commands<ReturnType = any> {}
 
 // eslint-disable-next-line
-export interface ExtensionConfig<Options = any> {}
+export interface ExtensionConfig<Options = any, Storage = any> {}
 
 // eslint-disable-next-line
-export interface NodeConfig<Options = any> {}
+export interface NodeConfig<Options = any, Storage = any> {}
 
 // eslint-disable-next-line
-export interface MarkConfig<Options = any> {}
+export interface MarkConfig<Options = any, Storage = any> {}

package/src/inputRules/index.ts

@@ -0,0 +1,5 @@
+export * from './markInputRule'
+export * from './nodeInputRule'
+export * from './textblockTypeInputRule'
+export * from './textInputRule'
+export * from './wrappingInputRule'

package/src/inputRules/markInputRule.ts

@@ -1,50 +1,69 @@
-import { InputRule } from 'prosemirror-inputrules'
-import { MarkType } from 'prosemirror-model'
-import getMarksBetween from '../helpers/getMarksBetween'
-
-export default function (regexp: RegExp, markType: MarkType, getAttributes?: Function): InputRule {
-  return new InputRule(regexp, (state, match, start, end) => {
-    const attributes = getAttributes instanceof Function
-      ? getAttributes(match)
-      : getAttributes
-    const { tr } = state
-    const captureGroup = match[match.length - 1]
-    const fullMatch = match[0]
-    let markEnd = end
-
-    if (captureGroup) {
-      const startSpaces = fullMatch.search(/\S/)
-      const textStart = start + fullMatch.indexOf(captureGroup)
-      const textEnd = textStart + captureGroup.length
-
-      const excludedMarks = getMarksBetween(start, end, state)
-        .filter(item => {
-          // TODO: PR to add excluded to MarkType
-          // @ts-ignore
-          const { excluded } = item.mark.type
-          return excluded.find((type: MarkType) => type.name === markType.name)
-        })
-        .filter(item => item.to > textStart)
-
-      if (excludedMarks.length) {
+import { MarkType } from '@tiptap/pm/model'
+
+import { getMarksBetween } from '../helpers/getMarksBetween'
+import { InputRule, InputRuleFinder } from '../InputRule'
+import { ExtendedRegExpMatchArray } from '../types'
+import { callOrReturn } from '../utilities/callOrReturn'
+
+/**
+ * Build an input rule that adds a mark when the
+ * matched text is typed into it.
+ */
+export function markInputRule(config: {
+  find: InputRuleFinder
+  type: MarkType
+  getAttributes?:
+    | Record<string, any>
+    | ((match: ExtendedRegExpMatchArray) => Record<string, any>)
+    | false
+    | null
+}) {
+  return new InputRule({
+    find: config.find,
+    handler: ({ state, range, match }) => {
+      const attributes = callOrReturn(config.getAttributes, undefined, match)
+
+      if (attributes === false || attributes === null) {
         return null
       }
 
-      if (textEnd < end) {
-        tr.delete(textEnd, end)
-      }
+      const { tr } = state
+      const captureGroup = match[match.length - 1]
+      const fullMatch = match[0]
+      let markEnd = range.to
 
-      if (textStart > start) {
-        tr.delete(start + startSpaces, textStart)
-      }
+      if (captureGroup) {
+        const startSpaces = fullMatch.search(/\S/)
+        const textStart = range.from + fullMatch.indexOf(captureGroup)
+        const textEnd = textStart + captureGroup.length
 
-      markEnd = start + startSpaces + captureGroup.length
+        const excludedMarks = getMarksBetween(range.from, range.to, state.doc)
+          .filter(item => {
+            // @ts-ignore
+            const excluded = item.mark.type.excluded as MarkType[]
 
-      tr.addMark(start + startSpaces, markEnd, markType.create(attributes))
+            return excluded.find(type => type === config.type && type !== item.mark.type)
+          })
+          .filter(item => item.to > textStart)
 
-      tr.removeStoredMark(markType)
-    }
+        if (excludedMarks.length) {
+          return null
+        }
 
-    return tr
+        if (textEnd < range.to) {
+          tr.delete(textEnd, range.to)
+        }
+
+        if (textStart > range.from) {
+          tr.delete(range.from + startSpaces, textStart)
+        }
+
+        markEnd = range.from + startSpaces + captureGroup.length
+
+        tr.addMark(range.from + startSpaces, markEnd, config.type.create(attributes || {}))
+
+        tr.removeStoredMark(config.type)
+      }
+    },
   })
 }

package/src/inputRules/nodeInputRule.ts

@@ -1,17 +1,50 @@
-import { InputRule } from 'prosemirror-inputrules'
-import { NodeType } from 'prosemirror-model'
+import { NodeType } from '@tiptap/pm/model'
 
-export default function (regexp: RegExp, type: NodeType, getAttributes?: (match: any) => any): InputRule {
-  return new InputRule(regexp, (state, match, start, end) => {
-    const attributes = getAttributes instanceof Function
-      ? getAttributes(match)
-      : getAttributes
-    const { tr } = state
+import { InputRule, InputRuleFinder } from '../InputRule'
+import { ExtendedRegExpMatchArray } from '../types'
+import { callOrReturn } from '../utilities/callOrReturn'
 
-    if (match[0]) {
-      tr.replaceWith(start - 1, end, type.create(attributes))
-    }
+/**
+ * Build an input rule that adds a node when the
+ * matched text is typed into it.
+ */
+export function nodeInputRule(config: {
+  find: InputRuleFinder
+  type: NodeType
+  getAttributes?:
+    | Record<string, any>
+    | ((match: ExtendedRegExpMatchArray) => Record<string, any>)
+    | false
+    | null
+}) {
+  return new InputRule({
+    find: config.find,
+    handler: ({ state, range, match }) => {
+      const attributes = callOrReturn(config.getAttributes, undefined, match) || {}
+      const { tr } = state
+      const start = range.from
+      let end = range.to
 
-    return tr
+      if (match[1]) {
+        const offset = match[0].lastIndexOf(match[1])
+        let matchStart = start + offset
+
+        if (matchStart > end) {
+          matchStart = end
+        } else {
+          end = matchStart + match[1].length
+        }
+
+        // insert last typed character
+        const lastChar = match[0][match[0].length - 1]
+
+        tr.insertText(lastChar, start + match[0].length - 1)
+
+        // insert node from input rule
+        tr.replaceWith(matchStart, end, config.type.create(attributes))
+      } else if (match[0]) {
+        tr.replaceWith(start, end, config.type.create(attributes))
+      }
+    },
   })
 }

package/src/inputRules/textInputRule.ts

@@ -0,0 +1,35 @@
+import { InputRule, InputRuleFinder } from '../InputRule'
+
+/**
+ * Build an input rule that replaces text when the
+ * matched text is typed into it.
+ */
+export function textInputRule(config: {
+  find: InputRuleFinder,
+  replace: string,
+}) {
+  return new InputRule({
+    find: config.find,
+    handler: ({ state, range, match }) => {
+      let insert = config.replace
+      let start = range.from
+      const end = range.to
+
+      if (match[1]) {
+        const offset = match[0].lastIndexOf(match[1])
+
+        insert += match[0].slice(offset + match[1].length)
+        start += offset
+
+        const cutOff = start - end
+
+        if (cutOff > 0) {
+          insert = match[0].slice(offset - cutOff, offset) + insert
+          start = end
+        }
+      }
+
+      state.tr.insertText(insert, start, end)
+    },
+  })
+}

package/src/inputRules/textblockTypeInputRule.ts

@@ -0,0 +1,37 @@
+import { NodeType } from '@tiptap/pm/model'
+
+import { InputRule, InputRuleFinder } from '../InputRule'
+import { ExtendedRegExpMatchArray } from '../types'
+import { callOrReturn } from '../utilities/callOrReturn'
+
+/**
+ * Build an input rule that changes the type of a textblock when the
+ * matched text is typed into it. When using a regular expresion you’ll
+ * probably want the regexp to start with `^`, so that the pattern can
+ * only occur at the start of a textblock.
+ */
+export function textblockTypeInputRule(config: {
+  find: InputRuleFinder
+  type: NodeType
+  getAttributes?:
+    | Record<string, any>
+    | ((match: ExtendedRegExpMatchArray) => Record<string, any>)
+    | false
+    | null
+}) {
+  return new InputRule({
+    find: config.find,
+    handler: ({ state, range, match }) => {
+      const $start = state.doc.resolve(range.from)
+      const attributes = callOrReturn(config.getAttributes, undefined, match) || {}
+
+      if (!$start.node(-1).canReplaceWith($start.index(-1), $start.indexAfter(-1), config.type)) {
+        return null
+      }
+
+      state.tr
+        .delete(range.from, range.to)
+        .setBlockType(range.from, range.from, config.type, attributes)
+    },
+  })
+}

package/src/inputRules/wrappingInputRule.ts

@@ -0,0 +1,84 @@
+import { Node as ProseMirrorNode, NodeType } from '@tiptap/pm/model'
+import { canJoin, findWrapping } from '@tiptap/pm/transform'
+
+import { Editor } from '../Editor'
+import { InputRule, InputRuleFinder } from '../InputRule'
+import { ExtendedRegExpMatchArray } from '../types'
+import { callOrReturn } from '../utilities/callOrReturn'
+
+/**
+ * Build an input rule for automatically wrapping a textblock when a
+ * given string is typed. When using a regular expresion you’ll
+ * probably want the regexp to start with `^`, so that the pattern can
+ * only occur at the start of a textblock.
+ *
+ * `type` is the type of node to wrap in.
+ *
+ * By default, if there’s a node with the same type above the newly
+ * wrapped node, the rule will try to join those
+ * two nodes. You can pass a join predicate, which takes a regular
+ * expression match and the node before the wrapped node, and can
+ * return a boolean to indicate whether a join should happen.
+ */
+export function wrappingInputRule(config: {
+  find: InputRuleFinder,
+  type: NodeType,
+  keepMarks?: boolean,
+  keepAttributes?: boolean,
+  editor?: Editor
+  getAttributes?:
+  | Record<string, any>
+  | ((match: ExtendedRegExpMatchArray) => Record<string, any>)
+  | false
+  | null
+  ,
+  joinPredicate?: (match: ExtendedRegExpMatchArray, node: ProseMirrorNode) => boolean,
+}) {
+  return new InputRule({
+    find: config.find,
+    handler: ({
+      state, range, match, chain,
+    }) => {
+      const attributes = callOrReturn(config.getAttributes, undefined, match) || {}
+      const tr = state.tr.delete(range.from, range.to)
+      const $start = tr.doc.resolve(range.from)
+      const blockRange = $start.blockRange()
+      const wrapping = blockRange && findWrapping(blockRange, config.type, attributes)
+
+      if (!wrapping) {
+        return null
+      }
+
+      tr.wrap(blockRange, wrapping)
+
+      if (config.keepMarks && config.editor) {
+        const { selection, storedMarks } = state
+        const { splittableMarks } = config.editor.extensionManager
+        const marks = storedMarks || (selection.$to.parentOffset && selection.$from.marks())
+
+        if (marks) {
+          const filteredMarks = marks.filter(mark => splittableMarks.includes(mark.type.name))
+
+          tr.ensureMarks(filteredMarks)
+        }
+      }
+      if (config.keepAttributes) {
+        /** If the nodeType is `bulletList` or `orderedList` set the `nodeType` as `listItem` */
+        const nodeType = config.type.name === 'bulletList' || config.type.name === 'orderedList' ? 'listItem' : 'taskList'
+
+        chain().updateAttributes(nodeType, attributes).run()
+      }
+
+      const before = tr.doc.resolve(range.from - 1).nodeBefore
+
+      if (
+        before
+        && before.type === config.type
+        && canJoin(tr.doc, range.from - 1)
+        && (!config.joinPredicate || config.joinPredicate(match, before))
+      ) {
+        tr.join(range.from - 1)
+      }
+    },
+  })
+}

package/src/pasteRules/index.ts

@@ -0,0 +1,3 @@
+export * from './markPasteRule'
+export * from './nodePasteRule'
+export * from './textPasteRule'