@tiptap/core 2.0.0-beta.18 → 2.0.0-beta.182

package/src/helpers/getAttributes.ts

@@ -0,0 +1,28 @@
+import { MarkType, NodeType } from 'prosemirror-model'
+import { EditorState } from 'prosemirror-state'
+
+import { getMarkAttributes } from './getMarkAttributes'
+import { getNodeAttributes } from './getNodeAttributes'
+import { getSchemaTypeNameByName } from './getSchemaTypeNameByName'
+
+export function getAttributes(
+  state: EditorState,
+  typeOrName: string | NodeType | MarkType,
+): Record<string, any> {
+  const schemaType = getSchemaTypeNameByName(
+    typeof typeOrName === 'string'
+      ? typeOrName
+      : typeOrName.name,
+    state.schema,
+  )
+
+  if (schemaType === 'node') {
+    return getNodeAttributes(state, typeOrName as NodeType)
+  }
+
+  if (schemaType === 'mark') {
+    return getMarkAttributes(state, typeOrName as MarkType)
+  }
+
+  return {}
+}

package/src/helpers/getAttributesFromExtensions.ts

@@ -1,17 +1,20 @@
-import splitExtensions from './splitExtensions'
+import { MarkConfig, NodeConfig } from '..'
 import {
-  Extensions,
-  GlobalAttributes,
-  Attributes,
+  AnyConfig,
   Attribute,
+  Attributes,
   ExtensionAttribute,
+  Extensions,
+  GlobalAttributes,
 } from '../types'
+import { getExtensionField } from './getExtensionField'
+import { splitExtensions } from './splitExtensions'
 
 /**
  * Get a list of all extension attributes defined in `addAttribute` and `addGlobalAttribute`.
  * @param extensions List of extensions
  */
-export default function getAttributesFromExtensions(extensions: Extensions): ExtensionAttribute[] {
+export function getAttributesFromExtensions(extensions: Extensions): ExtensionAttribute[] {
   const extensionAttributes: ExtensionAttribute[] = []
   const { nodeExtensions, markExtensions } = splitExtensions(extensions)
   const nodeAndMarkExtensions = [...nodeExtensions, ...markExtensions]
@@ -21,18 +24,28 @@ export default function getAttributesFromExtensions(extensions: Extensions): Ext
     renderHTML: null,
     parseHTML: null,
     keepOnSplit: true,
+    isRequired: false,
   }
 
   extensions.forEach(extension => {
     const context = {
+      name: extension.name,
       options: extension.options,
+      storage: extension.storage,
     }
 
-    if (!extension.config.addGlobalAttributes) {
+    const addGlobalAttributes = getExtensionField<AnyConfig['addGlobalAttributes']>(
+      extension,
+      'addGlobalAttributes',
+      context,
+    )
+
+    if (!addGlobalAttributes) {
       return
     }
 
-    const globalAttributes = extension.config.addGlobalAttributes.bind(context)() as GlobalAttributes
+    // TODO: remove `as GlobalAttributes`
+    const globalAttributes = addGlobalAttributes() as GlobalAttributes
 
     globalAttributes.forEach(globalAttribute => {
       globalAttribute.types.forEach(type => {
@@ -54,25 +67,40 @@ export default function getAttributesFromExtensions(extensions: Extensions): Ext
 
   nodeAndMarkExtensions.forEach(extension => {
     const context = {
+      name: extension.name,
       options: extension.options,
+      storage: extension.storage,
     }
 
-    if (!extension.config.addAttributes) {
+    const addAttributes = getExtensionField<NodeConfig['addAttributes'] | MarkConfig['addAttributes']>(
+      extension,
+      'addAttributes',
+      context,
+    )
+
+    if (!addAttributes) {
       return
     }
 
-    const attributes = extension.config.addAttributes.bind(context)() as Attributes
+    // TODO: remove `as Attributes`
+    const attributes = addAttributes() as Attributes
 
     Object
       .entries(attributes)
       .forEach(([name, attribute]) => {
+        const mergedAttr = {
+          ...defaultAttribute,
+          ...attribute,
+        }
+
+        if (attribute.isRequired && attribute.default === undefined) {
+          delete mergedAttr.default
+        }
+
         extensionAttributes.push({
-          type: extension.config.name,
+          type: extension.name,
           name,
-          attribute: {
-            ...defaultAttribute,
-            ...attribute,
-          },
+          attribute: mergedAttr,
         })
       })
   })

package/src/helpers/getChangedRanges.ts

@@ -0,0 +1,83 @@
+import { Step, Transform } from 'prosemirror-transform'
+
+import { Range } from '../types'
+import { removeDuplicates } from '../utilities/removeDuplicates'
+
+export type ChangedRange = {
+  oldRange: Range,
+  newRange: Range,
+}
+
+/**
+ * Removes duplicated ranges and ranges that are
+ * fully captured by other ranges.
+ */
+function simplifyChangedRanges(changes: ChangedRange[]): ChangedRange[] {
+  const uniqueChanges = removeDuplicates(changes)
+
+  return uniqueChanges.length === 1
+    ? uniqueChanges
+    : uniqueChanges.filter((change, index) => {
+      const rest = uniqueChanges.filter((_, i) => i !== index)
+
+      return !rest.some(otherChange => {
+        return change.oldRange.from >= otherChange.oldRange.from
+          && change.oldRange.to <= otherChange.oldRange.to
+          && change.newRange.from >= otherChange.newRange.from
+          && change.newRange.to <= otherChange.newRange.to
+      })
+    })
+}
+
+/**
+ * Returns a list of changed ranges
+ * based on the first and last state of all steps.
+ */
+export function getChangedRanges(transform: Transform): ChangedRange[] {
+  const { mapping, steps } = transform
+  const changes: ChangedRange[] = []
+
+  mapping.maps.forEach((stepMap, index) => {
+    const ranges: Range[] = []
+
+    // This accounts for step changes where no range was actually altered
+    // e.g. when setting a mark, node attribute, etc.
+    // @ts-ignore
+    if (!stepMap.ranges.length) {
+      const { from, to } = steps[index] as Step & {
+        from?: number,
+        to?: number,
+      }
+
+      if (from === undefined || to === undefined) {
+        return
+      }
+
+      ranges.push({ from, to })
+    } else {
+      stepMap.forEach((from, to) => {
+        ranges.push({ from, to })
+      })
+    }
+
+    ranges.forEach(({ from, to }) => {
+      const newStart = mapping.slice(index).map(from, -1)
+      const newEnd = mapping.slice(index).map(to)
+      const oldStart = mapping.invert().map(newStart, -1)
+      const oldEnd = mapping.invert().map(newEnd)
+
+      changes.push({
+        oldRange: {
+          from: oldStart,
+          to: oldEnd,
+        },
+        newRange: {
+          from: newStart,
+          to: newEnd,
+        },
+      })
+    })
+  })
+
+  return simplifyChangedRanges(changes)
+}

package/src/helpers/getDebugJSON.ts

@@ -0,0 +1,54 @@
+import { Node as ProseMirrorNode } from 'prosemirror-model'
+
+import { JSONContent } from '../types'
+
+interface DebugJSONContent extends JSONContent {
+  from: number,
+  to: number,
+}
+
+export function getDebugJSON(node: ProseMirrorNode, startOffset = 0): DebugJSONContent {
+  const isTopNode = node.type === node.type.schema.topNodeType
+  const increment = isTopNode ? 0 : 1
+  const from = startOffset
+  const to = from + node.nodeSize
+  const marks = node.marks.map(mark => {
+    const output: { type: string, attrs?: Record<string, any> } = {
+      type: mark.type.name,
+    }
+
+    if (Object.keys(mark.attrs).length) {
+      output.attrs = { ...mark.attrs }
+    }
+
+    return output
+  })
+  const attrs = { ...node.attrs }
+  const output: DebugJSONContent = {
+    type: node.type.name,
+    from,
+    to,
+  }
+
+  if (Object.keys(attrs).length) {
+    output.attrs = attrs
+  }
+
+  if (marks.length) {
+    output.marks = marks
+  }
+
+  if (node.content.childCount) {
+    output.content = []
+
+    node.forEach((child, offset) => {
+      output.content?.push(getDebugJSON(child, startOffset + offset + increment))
+    })
+  }
+
+  if (node.text) {
+    output.text = node.text
+  }
+
+  return output
+}

package/src/helpers/getExtensionField.ts

@@ -0,0 +1,25 @@
+import { AnyExtension, MaybeThisParameterType, RemoveThis } from '../types'
+
+export function getExtensionField<T = any>(
+  extension: AnyExtension,
+  field: string,
+  context?: Omit<MaybeThisParameterType<T>, 'parent'>,
+): RemoveThis<T> {
+
+  if (extension.config[field] === undefined && extension.parent) {
+    return getExtensionField(extension.parent, field, context)
+  }
+
+  if (typeof extension.config[field] === 'function') {
+    const value = extension.config[field].bind({
+      ...context,
+      parent: extension.parent
+        ? getExtensionField(extension.parent, field, context)
+        : null,
+    })
+
+    return value
+  }
+
+  return extension.config[field]
+}

package/src/helpers/getHTMLFromFragment.ts

@@ -1,13 +1,14 @@
-import { Node, DOMSerializer, Schema } from 'prosemirror-model'
+import { DOMSerializer, Fragment, Schema } from 'prosemirror-model'
 
-export default function getHTMLFromFragment(doc: Node, schema: Schema): string {
-  const fragment = DOMSerializer
+export function getHTMLFromFragment(fragment: Fragment, schema: Schema): string {
+  const documentFragment = DOMSerializer
     .fromSchema(schema)
-    .serializeFragment(doc.content)
+    .serializeFragment(fragment)
 
   const temporaryDocument = document.implementation.createHTMLDocument()
   const container = temporaryDocument.createElement('div')
-  container.appendChild(fragment)
+
+  container.appendChild(documentFragment)
 
   return container.innerHTML
 }

package/src/helpers/getMarkAttributes.ts

@@ -1,26 +1,30 @@
-import { EditorState } from 'prosemirror-state'
 import { Mark, MarkType } from 'prosemirror-model'
-import getMarkType from './getMarkType'
-import { AnyObject } from '../types'
+import { EditorState } from 'prosemirror-state'
 
-export default function getMarkAttributes(state: EditorState, typeOrName: string | MarkType): AnyObject {
+import { getMarkType } from './getMarkType'
+
+export function getMarkAttributes(state: EditorState, typeOrName: string | MarkType): Record<string, any> {
   const type = getMarkType(typeOrName, state.schema)
   const { from, to, empty } = state.selection
-  let marks: Mark[] = []
+  const marks: Mark[] = []
 
   if (empty) {
-    marks = state.selection.$head.marks()
+    if (state.storedMarks) {
+      marks.push(...state.storedMarks)
+    }
+
+    marks.push(...state.selection.$head.marks())
   } else {
     state.doc.nodesBetween(from, to, node => {
-      marks = [...marks, ...node.marks]
+      marks.push(...node.marks)
     })
   }
 
   const mark = marks.find(markItem => markItem.type.name === type.name)
 
-  if (mark) {
-    return { ...mark.attrs }
+  if (!mark) {
+    return {}
   }
 
-  return {}
+  return { ...mark.attrs }
 }

package/src/helpers/getMarkRange.ts

@@ -1,34 +1,67 @@
-import { MarkType, ResolvedPos } from 'prosemirror-model'
+import { Mark as ProseMirrorMark, MarkType, ResolvedPos } from 'prosemirror-model'
+
 import { Range } from '../types'
+import { objectIncludes } from '../utilities/objectIncludes'
+
+function findMarkInSet(
+  marks: ProseMirrorMark[],
+  type: MarkType,
+  attributes: Record<string, any> = {},
+): ProseMirrorMark | undefined {
+  return marks.find(item => {
+    return item.type === type && objectIncludes(item.attrs, attributes)
+  })
+}
+
+function isMarkInSet(
+  marks: ProseMirrorMark[],
+  type: MarkType,
+  attributes: Record<string, any> = {},
+): boolean {
+  return !!findMarkInSet(marks, type, attributes)
+}
 
-export default function getMarkRange($pos: ResolvedPos, type: MarkType): Range | void {
+export function getMarkRange(
+  $pos: ResolvedPos,
+  type: MarkType,
+  attributes: Record<string, any> = {},
+): Range | void {
   if (!$pos || !type) {
     return
   }
 
-  const start = $pos.parent.childAfter($pos.parentOffset)
+  let start = $pos.parent.childAfter($pos.parentOffset)
+
+  if ($pos.parentOffset === start.offset && start.offset !== 0) {
+    start = $pos.parent.childBefore($pos.parentOffset)
+  }
 
   if (!start.node) {
     return
   }
 
-  const link = start.node.marks.find(mark => mark.type === type)
+  const mark = findMarkInSet([...start.node.marks], type, attributes)
 
-  if (!link) {
+  if (!mark) {
     return
   }
 
-  let startIndex = $pos.index()
+  let startIndex = start.index
   let startPos = $pos.start() + start.offset
   let endIndex = startIndex + 1
   let endPos = startPos + start.node.nodeSize
 
-  while (startIndex > 0 && link.isInSet($pos.parent.child(startIndex - 1).marks)) {
+  findMarkInSet([...start.node.marks], type, attributes)
+
+  while (startIndex > 0 && mark.isInSet($pos.parent.child(startIndex - 1).marks)) {
     startIndex -= 1
     startPos -= $pos.parent.child(startIndex).nodeSize
   }
 
-  while (endIndex < $pos.parent.childCount && link.isInSet($pos.parent.child(endIndex).marks)) {
+  while (
+    endIndex < $pos.parent.childCount
+    && isMarkInSet([...$pos.parent.child(endIndex).marks], type, attributes)
+  ) {
     endPos += $pos.parent.child(endIndex).nodeSize
     endIndex += 1
   }

package/src/helpers/getMarkType.ts

@@ -1,7 +1,11 @@
 import { MarkType, Schema } from 'prosemirror-model'
 
-export default function getMarkType(nameOrType: string | MarkType, schema: Schema): MarkType {
+export function getMarkType(nameOrType: string | MarkType, schema: Schema): MarkType {
   if (typeof nameOrType === 'string') {
+    if (!schema.marks[nameOrType]) {
+      throw Error(`There is no mark type named '${nameOrType}'. Maybe you forgot to add the extension?`)
+    }
+
     return schema.marks[nameOrType]
   }
 

package/src/helpers/getMarksBetween.ts

@@ -1,16 +1,38 @@
-import { EditorState } from 'prosemirror-state'
+import { Node as ProseMirrorNode } from 'prosemirror-model'
+
 import { MarkRange } from '../types'
+import { getMarkRange } from './getMarkRange'
+
+export function getMarksBetween(from: number, to: number, doc: ProseMirrorNode): MarkRange[] {
+  const marks: MarkRange[] = []
+
+  // get all inclusive marks on empty selection
+  if (from === to) {
+    doc
+      .resolve(from)
+      .marks()
+      .forEach(mark => {
+        const $pos = doc.resolve(from - 1)
+        const range = getMarkRange($pos, mark.type)
 
-export default function getMarksBetween(from: number, to: number, state: EditorState): MarkRange[] {
-  let marks: MarkRange[] = []
+        if (!range) {
+          return
+        }
 
-  state.doc.nodesBetween(from, to, (node, pos) => {
-    marks = [...marks, ...node.marks.map(mark => ({
-      from: pos,
-      to: pos + node.nodeSize,
-      mark,
-    }))]
-  })
+        marks.push({
+          mark,
+          ...range,
+        })
+      })
+  } else {
+    doc.nodesBetween(from, to, (node, pos) => {
+      marks.push(...node.marks.map(mark => ({
+        from: pos,
+        to: pos + node.nodeSize,
+        mark,
+      })))
+    })
+  }
 
   return marks
 }

package/src/helpers/getNodeAttributes.ts

@@ -1,24 +1,24 @@
-import { EditorState } from 'prosemirror-state'
 import { Node, NodeType } from 'prosemirror-model'
-import getNodeType from './getNodeType'
-import { AnyObject } from '../types'
+import { EditorState } from 'prosemirror-state'
+
+import { getNodeType } from './getNodeType'
 
-export default function getNodeAttributes(state: EditorState, typeOrName: string | NodeType): AnyObject {
+export function getNodeAttributes(state: EditorState, typeOrName: string | NodeType): Record<string, any> {
   const type = getNodeType(typeOrName, state.schema)
   const { from, to } = state.selection
-  let nodes: Node[] = []
+  const nodes: Node[] = []
 
   state.doc.nodesBetween(from, to, node => {
-    nodes = [...nodes, node]
+    nodes.push(node)
   })
 
   const node = nodes
     .reverse()
     .find(nodeItem => nodeItem.type.name === type.name)
 
-  if (node) {
-    return { ...node.attrs }
+  if (!node) {
+    return {}
   }
 
-  return {}
+  return { ...node.attrs }
 }

package/src/helpers/getNodeType.ts

@@ -1,7 +1,11 @@
 import { NodeType, Schema } from 'prosemirror-model'
 
-export default function getNodeType(nameOrType: string | NodeType, schema: Schema): NodeType {
+export function getNodeType(nameOrType: string | NodeType, schema: Schema): NodeType {
   if (typeof nameOrType === 'string') {
+    if (!schema.nodes[nameOrType]) {
+      throw Error(`There is no node type named '${nameOrType}'. Maybe you forgot to add the extension?`)
+    }
+
     return schema.nodes[nameOrType]
   }
 

package/src/helpers/getRenderedAttributes.ts

@@ -1,8 +1,9 @@
-import { Node, Mark } from 'prosemirror-model'
-import { ExtensionAttribute, AnyObject } from '../types'
-import mergeAttributes from '../utilities/mergeAttributes'
+import { Mark, Node } from 'prosemirror-model'
 
-export default function getRenderedAttributes(nodeOrMark: Node | Mark, extensionAttributes: ExtensionAttribute[]): AnyObject {
+import { ExtensionAttribute } from '../types'
+import { mergeAttributes } from '../utilities/mergeAttributes'
+
+export function getRenderedAttributes(nodeOrMark: Node | Mark, extensionAttributes: ExtensionAttribute[]): Record<string, any> {
   return extensionAttributes
     .filter(item => item.attribute.rendered)
     .map(item => {
@@ -14,7 +15,5 @@ export default function getRenderedAttributes(nodeOrMark: Node | Mark, extension
 
       return item.attribute.renderHTML(nodeOrMark.attrs) || {}
     })
-    .reduce((attributes, attribute) => {
-      return mergeAttributes(attributes, attribute)
-    }, {})
+    .reduce((attributes, attribute) => mergeAttributes(attributes, attribute), {})
 }