@tiptap/core 2.0.0-beta.17 → 2.0.0-beta.170

package/src/helpers/getText.ts

@@ -0,0 +1,18 @@
+import { TextSerializer } from '../types'
+import { Node as ProseMirrorNode } from 'prosemirror-model'
+import { getTextBetween } from './getTextBetween'
+
+export function getText(
+  node: ProseMirrorNode,
+  options?: {
+    blockSeparator?: string,
+    textSerializers?: Record<string, TextSerializer>,
+  },
+) {
+  const range = {
+    from: 0,
+    to: node.content.size,
+  }
+
+  return getTextBetween(node, range, options)
+}

package/src/helpers/getTextBetween.ts

@@ -0,0 +1,45 @@
+import { Range, TextSerializer } from '../types'
+import { Node as ProseMirrorNode } from 'prosemirror-model'
+
+export function getTextBetween(
+  startNode: ProseMirrorNode,
+  range: Range,
+  options?: {
+    blockSeparator?: string,
+    textSerializers?: Record<string, TextSerializer>,
+  },
+): string {
+  const { from, to } = range
+  const {
+    blockSeparator = '\n\n',
+    textSerializers = {},
+  } = options || {}
+  let text = ''
+  let separated = true
+
+  startNode.nodesBetween(from, to, (node, pos, parent, index) => {
+    const textSerializer = textSerializers?.[node.type.name]
+
+    if (textSerializer) {
+      if (node.isBlock && !separated) {
+        text += blockSeparator
+        separated = true
+      }
+
+      text += textSerializer({
+        node,
+        pos,
+        parent,
+        index,
+      })
+    } else if (node.isText) {
+      text += node?.text?.slice(Math.max(from, pos) - pos, to - pos)
+      separated = false
+    } else if (node.isBlock && !separated) {
+      text += blockSeparator
+      separated = true
+    }
+  })
+
+  return text
+}

package/src/helpers/getTextSeralizersFromSchema.ts

@@ -0,0 +1,9 @@
+import { Schema } from 'prosemirror-model'
+import { TextSerializer } from '../types'
+
+export function getTextSeralizersFromSchema(schema: Schema): Record<string, TextSerializer> {
+  return Object.fromEntries(Object
+    .entries(schema.nodes)
+    .filter(([, node]) => node.spec.toText)
+    .map(([name, node]) => [name, node.spec.toText]))
+}

package/src/helpers/injectExtensionAttributesToParseRule.ts

@@ -1,6 +1,7 @@
 import { ParseRule } from 'prosemirror-model'
 import { ExtensionAttribute } from '../types'
-import fromString from '../utilities/fromString'
+import { fromString } from '../utilities/fromString'
+import { isObject } from '../utilities/isObject'
 
 /**
  * This function merges extension attributes into parserule attributes (`attrs` or `getAttrs`).
@@ -8,7 +9,7 @@ import fromString from '../utilities/fromString'
  * @param parseRule ProseMirror ParseRule
  * @param extensionAttributes List of attributes to inject
  */
-export default function injectExtensionAttributesToParseRule(parseRule: ParseRule, extensionAttributes: ExtensionAttribute[]): ParseRule {
+export function injectExtensionAttributesToParseRule(parseRule: ParseRule, extensionAttributes: ExtensionAttribute[]): ParseRule {
   if (parseRule.style) {
     return parseRule
   }
@@ -24,23 +25,20 @@ export default function injectExtensionAttributesToParseRule(parseRule: ParseRul
         return false
       }
 
-      const newAttributes = extensionAttributes
-        .filter(item => item.attribute.rendered)
-        .reduce((items, item) => {
-          const attributes = item.attribute.parseHTML
-            ? item.attribute.parseHTML(node as HTMLElement) || {}
-            : {
-              [item.name]: fromString((node as HTMLElement).getAttribute(item.name)),
-            }
+      const newAttributes = extensionAttributes.reduce((items, item) => {
+        const value = item.attribute.parseHTML
+          ? item.attribute.parseHTML(node as HTMLElement)
+          : fromString((node as HTMLElement).getAttribute(item.name))
 
-          const filteredAttributes = Object.fromEntries(Object.entries(attributes)
-            .filter(([, value]) => value !== undefined && value !== null))
+        if (value === null || value === undefined) {
+          return items
+        }
 
-          return {
-            ...items,
-            ...filteredAttributes,
-          }
-        }, {})
+        return {
+          ...items,
+          [item.name]: value,
+        }
+      }, {})
 
       return { ...oldAttributes, ...newAttributes }
     },

package/src/helpers/isActive.ts

@@ -1,10 +1,9 @@
 import { EditorState } from 'prosemirror-state'
-import isNodeActive from './isNodeActive'
-import isMarkActive from './isMarkActive'
-import getSchemaTypeNameByName from './getSchemaTypeNameByName'
-import { AnyObject } from '../types'
+import { isNodeActive } from './isNodeActive'
+import { isMarkActive } from './isMarkActive'
+import { getSchemaTypeNameByName } from './getSchemaTypeNameByName'
 
-export default function isActive(state: EditorState, name: string | null, attributes: AnyObject = {}): boolean {
+export function isActive(state: EditorState, name: string | null, attributes: Record<string, any> = {}): boolean {
   if (!name) {
     return isNodeActive(state, null, attributes) || isMarkActive(state, null, attributes)
   }

package/src/helpers/isExtensionRulesEnabled.ts

@@ -0,0 +1,15 @@
+import { AnyExtension, EnableRules } from '../types'
+
+export function isExtensionRulesEnabled(extension: AnyExtension, enabled: EnableRules): boolean {
+  if (Array.isArray(enabled)) {
+    return enabled.some(enabledExtension => {
+      const name = typeof enabledExtension === 'string'
+        ? enabledExtension
+        : enabledExtension.name
+
+      return name === extension.name
+    })
+  }
+
+  return enabled
+}

package/src/helpers/isList.ts

@@ -1,20 +1,27 @@
 import { Extensions } from '../types'
-import splitExtensions from './splitExtensions'
-import callOrReturn from '../utilities/callOrReturn'
+import { NodeConfig } from '..'
+import { splitExtensions } from './splitExtensions'
+import { callOrReturn } from '../utilities/callOrReturn'
+import { getExtensionField } from '../helpers/getExtensionField'
 
-export default function isList(name: string, extensions: Extensions): boolean {
+export function isList(name: string, extensions: Extensions): boolean {
   const { nodeExtensions } = splitExtensions(extensions)
-  const extension = nodeExtensions.find(item => item.config.name === name)
+  const extension = nodeExtensions.find(item => item.name === name)
 
   if (!extension) {
     return false
   }
 
-  const groups = callOrReturn(extension.config.group, { options: extension.options })
+  const context = {
+    name: extension.name,
+    options: extension.options,
+    storage: extension.storage,
+  }
+  const group = callOrReturn(getExtensionField<NodeConfig['group']>(extension, 'group', context))
 
-  if (typeof groups !== 'string') {
+  if (typeof group !== 'string') {
     return false
   }
 
-  return groups.split(' ').includes('list')
+  return group.split(' ').includes('list')
 }

package/src/helpers/isMarkActive.ts

@@ -1,15 +1,15 @@
 import { EditorState } from 'prosemirror-state'
 import { MarkType } from 'prosemirror-model'
-import objectIncludes from '../utilities/objectIncludes'
-import getMarkType from './getMarkType'
-import { AnyObject, MarkRange } from '../types'
+import { objectIncludes } from '../utilities/objectIncludes'
+import { getMarkType } from './getMarkType'
+import { MarkRange } from '../types'
 
-export default function isMarkActive(
+export function isMarkActive(
   state: EditorState,
   typeOrName: MarkType | string | null,
-  attributes: AnyObject = {},
+  attributes: Record<string, any> = {},
 ): boolean {
-  const { from, to, empty } = state.selection
+  const { empty, ranges } = state.selection
   const type = typeOrName
     ? getMarkType(typeOrName, state.schema)
     : null
@@ -23,33 +23,41 @@ export default function isMarkActive(
 
         return type.name === mark.type.name
       })
-      .find(mark => objectIncludes(mark.attrs, attributes))
+      .find(mark => objectIncludes(mark.attrs, attributes, { strict: false }))
   }
 
   let selectionRange = 0
-  let markRanges: MarkRange[] = []
+  const markRanges: MarkRange[] = []
+
+  ranges.forEach(({ $from, $to }) => {
+    const from = $from.pos
+    const to = $to.pos
+
+    state.doc.nodesBetween(from, to, (node, pos) => {
+      if (!node.isText && !node.marks.length) {
+        return
+      }
 
-  state.doc.nodesBetween(from, to, (node, pos) => {
-    if (node.isText) {
       const relativeFrom = Math.max(from, pos)
       const relativeTo = Math.min(to, pos + node.nodeSize)
       const range = relativeTo - relativeFrom
 
       selectionRange += range
 
-      markRanges = [...markRanges, ...node.marks.map(mark => ({
+      markRanges.push(...node.marks.map(mark => ({
         mark,
         from: relativeFrom,
         to: relativeTo,
-      }))]
-    }
+      })))
+    })
   })
 
   if (selectionRange === 0) {
     return false
   }
 
-  const range = markRanges
+  // calculate range of matched mark
+  const matchedRange = markRanges
     .filter(markRange => {
       if (!type) {
         return true
@@ -57,11 +65,27 @@ export default function isMarkActive(
 
       return type.name === markRange.mark.type.name
     })
-    .filter(markRange => objectIncludes(markRange.mark.attrs, attributes))
-    .reduce((sum, markRange) => {
-      const size = markRange.to - markRange.from
-      return sum + size
-    }, 0)
+    .filter(markRange => objectIncludes(markRange.mark.attrs, attributes, { strict: false }))
+    .reduce((sum, markRange) => sum + markRange.to - markRange.from, 0)
+
+  // calculate range of marks that excludes the searched mark
+  // for example `code` doesn’t allow any other marks
+  const excludedRange = markRanges
+    .filter(markRange => {
+      if (!type) {
+        return true
+      }
+
+      return markRange.mark.type !== type
+        && markRange.mark.type.excludes(type)
+    })
+    .reduce((sum, markRange) => sum + markRange.to - markRange.from, 0)
+
+  // we only include the result of `excludedRange`
+  // if there is a match at all
+  const range = matchedRange > 0
+    ? matchedRange + excludedRange
+    : matchedRange
 
   return range >= selectionRange
 }

package/src/helpers/isNodeActive.ts

@@ -1,49 +1,38 @@
 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 { objectIncludes } from '../utilities/objectIncludes'
+import { getNodeType } from './getNodeType'
+import { NodeRange } from '../types'
 
-export default function isNodeActive(
+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
 
-  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 +40,14 @@ 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'
 
-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,6 @@
 import { NodeSelection } from 'prosemirror-state'
-import isObject from '../utilities/isObject'
+import { isObject } from '../utilities/isObject'
 
-export default function isNodeSelection(value: unknown): value is NodeSelection {
+export function isNodeSelection(value: unknown): value is NodeSelection {
   return isObject(value) && value instanceof NodeSelection
 }

package/src/helpers/isTextSelection.ts

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

package/src/helpers/posToDOMRect.ts

@@ -0,0 +1,34 @@
+import { EditorView } from 'prosemirror-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,34 @@
+import { Node as ProseMirrorNode } from 'prosemirror-model'
+import { Selection, TextSelection } from 'prosemirror-state'
+import { FocusPosition } from '../types'
+import { minMax } from '../utilities/minMax'
+
+export function resolveFocusPosition(
+  doc: ProseMirrorNode,
+  position: FocusPosition = null,
+): Selection | null {
+
+  if (!position) {
+    return null
+  }
+
+  if (position === 'start' || position === true) {
+    return Selection.atStart(doc)
+  }
+
+  if (position === 'end') {
+    return Selection.atEnd(doc)
+  }
+
+  if (position === 'all') {
+    return TextSelection.create(doc, 0, doc.content.size)
+  }
+
+  // Check if `position` is in bounds of the doc if `position` is a number.
+  const minPos = Selection.atStart(doc).from
+  const maxPos = Selection.atEnd(doc).to
+  const resolvedFrom = minMax(position, minPos, maxPos)
+  const resolvedEnd = minMax(position, minPos, maxPos)
+
+  return TextSelection.create(doc, resolvedFrom, resolvedEnd)
+}

package/src/helpers/selectionToInsertionEnd.ts

@@ -2,7 +2,7 @@ import { Selection, Transaction } from 'prosemirror-state'
 import { ReplaceStep, ReplaceAroundStep } from 'prosemirror-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

@@ -3,7 +3,7 @@ import { Extension } from '../Extension'
 import { Node } from '../Node'
 import { Mark } from '../Mark'
 
-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,36 +1,69 @@
+import * as extensions from './extensions'
+
+export { extensions }
 export * from './Editor'
 export * from './Extension'
 export * from './Node'
 export * from './Mark'
 export * from './NodeView'
+export * from './Tracker'
+export * from './InputRule'
+export * from './PasteRule'
+export * from './CommandManager'
 export * from './types'
 
-export { default as nodeInputRule } from './inputRules/nodeInputRule'
-export { default as markInputRule } from './inputRules/markInputRule'
-export { default as markPasteRule } from './pasteRules/markPasteRule'
+export * from './inputRules/nodeInputRule'
+export * from './inputRules/markInputRule'
+export * from './inputRules/textblockTypeInputRule'
+export * from './inputRules/textInputRule'
+export * from './inputRules/wrappingInputRule'
+export * from './pasteRules/markPasteRule'
+export * from './pasteRules/textPasteRule'
 
-export { default as callOrReturn } from './utilities/callOrReturn'
-export { default as mergeAttributes } from './utilities/mergeAttributes'
+export * from './utilities/callOrReturn'
+export * from './utilities/escapeForRegEx'
+export * from './utilities/mergeAttributes'
 
-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 { default as findParentNodeClosestToPos } from './helpers/findParentNodeClosestToPos'
+export * from './helpers/combineTransactionSteps'
+export * from './helpers/defaultBlockAt'
+export * from './helpers/getExtensionField'
+export * from './helpers/findChildren'
+export * from './helpers/findChildrenInRange'
+export * from './helpers/findParentNode'
+export * from './helpers/findParentNodeClosestToPos'
+export * from './helpers/generateHTML'
+export * from './helpers/generateJSON'
+export * from './helpers/generateText'
+export * from './helpers/getChangedRanges'
+export * from './helpers/getSchema'
+export * from './helpers/getHTMLFromFragment'
+export * from './helpers/getDebugJSON'
+export * from './helpers/getAttributes'
+export * from './helpers/getMarkAttributes'
+export * from './helpers/getMarkRange'
+export * from './helpers/getMarkType'
+export * from './helpers/getMarksBetween'
+export * from './helpers/getNodeAttributes'
+export * from './helpers/getNodeType'
+export * from './helpers/getText'
+export * from './helpers/getTextBetween'
+export * from './helpers/isActive'
+export * from './helpers/isList'
+export * from './helpers/isMarkActive'
+export * from './helpers/isNodeActive'
+export * from './helpers/isNodeEmpty'
+export * from './helpers/isNodeSelection'
+export * from './helpers/isTextSelection'
+export * from './helpers/posToDOMRect'
 
-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> {}