@tiptap/core 2.0.0-beta.99 → 2.0.0-rc.2

package/src/helpers/getDebugJSON.ts

@@ -1,50 +1,54 @@
-import { Node as ProseMirrorNode } from 'prosemirror-model'
+import { Node as ProseMirrorNode } from '@tiptap/pm/model'
+
 import { JSONContent } from '../types'
 
 interface DebugJSONContent extends JSONContent {
-  from: number,
-  to: number,
+  from: number
+  to: number
 }
 
-/**
- * Returns a node tree with node positions.
- */
-export default function getDebugJSON(node: ProseMirrorNode, startOffset = 0) {
-  const nodes: DebugJSONContent[] = []
-
-  node.forEach((n, offset) => {
-    const from = startOffset + offset
-    const to = from + n.nodeSize
-    const marks = n.marks.map(mark => ({
+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,
-      attrs: { ...mark.attrs },
-    }))
-    const attrs = { ...n.attrs }
-    const content = getDebugJSON(n, from + 1)
-    const output: DebugJSONContent = {
-      type: n.type.name,
-      from,
-      to,
     }
 
-    if (Object.keys(attrs).length) {
-      output.attrs = attrs
+    if (Object.keys(mark.attrs).length) {
+      output.attrs = { ...mark.attrs }
     }
 
-    if (marks.length) {
-      output.marks = marks
-    }
-
-    if (content.length) {
-      output.content = content
-    }
-
-    if (n.text) {
-      output.text = n.text
-    }
-
-    nodes.push(output)
+    return output
   })
-
-  return nodes
+  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

@@ -1,9 +1,9 @@
-import { AnyExtension, RemoveThis } from '../types'
+import { AnyExtension, MaybeThisParameterType, RemoveThis } from '../types'
 
-export default function getExtensionField<T = any>(
+export function getExtensionField<T = any>(
   extension: AnyExtension,
   field: string,
-  context: Record<string, any> = {},
+  context?: Omit<MaybeThisParameterType<T>, 'parent'>,
 ): RemoveThis<T> {
 
   if (extension.config[field] === undefined && extension.parent) {

package/src/helpers/getHTMLFromFragment.ts

@@ -1,13 +1,12 @@
-import { Node, DOMSerializer, Schema } from 'prosemirror-model'
+import { DOMSerializer, Fragment, Schema } from '@tiptap/pm/model'
 
-export default function getHTMLFromFragment(doc: Node, schema: Schema): string {
-  const fragment = DOMSerializer
-    .fromSchema(schema)
-    .serializeFragment(doc.content)
+export function getHTMLFromFragment(fragment: Fragment, schema: Schema): string {
+  const documentFragment = DOMSerializer.fromSchema(schema).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,25 +1,33 @@
-import { EditorState } from 'prosemirror-state'
-import { Mark, MarkType } from 'prosemirror-model'
-import getMarkType from './getMarkType'
+import { Mark, MarkType } from '@tiptap/pm/model'
+import { EditorState } from '@tiptap/pm/state'
 
-export default function getMarkAttributes(state: EditorState, typeOrName: string | MarkType): Record<string, any> {
+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,6 +1,7 @@
-import { Mark as ProseMirrorMark, MarkType, ResolvedPos } from 'prosemirror-model'
-import objectIncludes from '../utilities/objectIncludes'
+import { Mark as ProseMirrorMark, MarkType, ResolvedPos } from '@tiptap/pm/model'
+
 import { Range } from '../types'
+import { objectIncludes } from '../utilities/objectIncludes'
 
 function findMarkInSet(
   marks: ProseMirrorMark[],
@@ -20,7 +21,7 @@ function isMarkInSet(
   return !!findMarkInSet(marks, type, attributes)
 }
 
-export default function getMarkRange(
+export function getMarkRange(
   $pos: ResolvedPos,
   type: MarkType,
   attributes: Record<string, any> = {},
@@ -29,24 +30,28 @@ export default function getMarkRange(
     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 mark = findMarkInSet(start.node.marks, type, attributes)
+  const mark = findMarkInSet([...start.node.marks], type, attributes)
 
   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
 
-  findMarkInSet(start.node.marks, type, attributes)
+  findMarkInSet([...start.node.marks], type, attributes)
 
   while (startIndex > 0 && mark.isInSet($pos.parent.child(startIndex - 1).marks)) {
     startIndex -= 1
@@ -55,7 +60,7 @@ export default function getMarkRange(
 
   while (
     endIndex < $pos.parent.childCount
-    && isMarkInSet($pos.parent.child(endIndex).marks, type, attributes)
+    && isMarkInSet([...$pos.parent.child(endIndex).marks], type, attributes)
   ) {
     endPos += $pos.parent.child(endIndex).nodeSize
     endIndex += 1

package/src/helpers/getMarkType.ts

@@ -1,9 +1,11 @@
-import { MarkType, Schema } from 'prosemirror-model'
+import { MarkType, Schema } from '@tiptap/pm/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?`)
+      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,40 @@
-import { EditorState } from 'prosemirror-state'
+import { Node as ProseMirrorNode } from '@tiptap/pm/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,23 +1,25 @@
-import { EditorState } from 'prosemirror-state'
-import { Node, NodeType } from 'prosemirror-model'
-import getNodeType from './getNodeType'
+import { Node, NodeType } from '@tiptap/pm/model'
+import { EditorState } from '@tiptap/pm/state'
 
-export default function getNodeAttributes(state: EditorState, typeOrName: string | NodeType): Record<string, any> {
+import { getNodeType } from './getNodeType'
+
+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)
+  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,9 +1,11 @@
-import { NodeType, Schema } from 'prosemirror-model'
+import { NodeType, Schema } from '@tiptap/pm/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?`)
+      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,12 @@
-import { Node, Mark } from 'prosemirror-model'
+import { Mark, Node } from '@tiptap/pm/model'
+
 import { ExtensionAttribute } from '../types'
-import mergeAttributes from '../utilities/mergeAttributes'
+import { mergeAttributes } from '../utilities/mergeAttributes'
 
-export default function getRenderedAttributes(nodeOrMark: Node | Mark, extensionAttributes: ExtensionAttribute[]): Record<string, any> {
+export function getRenderedAttributes(
+  nodeOrMark: Node | Mark,
+  extensionAttributes: ExtensionAttribute[],
+): Record<string, any> {
   return extensionAttributes
     .filter(item => item.attribute.rendered)
     .map(item => {
@@ -14,7 +18,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), {})
 }

package/src/helpers/getSchema.ts

@@ -1,9 +1,10 @@
-import { Schema } from 'prosemirror-model'
-import getSchemaByResolvedExtensions from './getSchemaByResolvedExtensions'
-import ExtensionManager from '../ExtensionManager'
+import { Schema } from '@tiptap/pm/model'
+
+import { ExtensionManager } from '../ExtensionManager'
 import { Extensions } from '../types'
+import { getSchemaByResolvedExtensions } from './getSchemaByResolvedExtensions'
 
-export default function getSchema(extensions: Extensions): Schema {
+export function getSchema(extensions: Extensions): Schema {
   const resolvedExtensions = ExtensionManager.resolve(extensions)
 
   return getSchemaByResolvedExtensions(resolvedExtensions)