@tiptap/core 2.0.0-beta.98 → 2.0.0-rc.1

package/src/helpers/getSchemaByResolvedExtensions.ts

@@ -1,134 +1,188 @@
-import { NodeSpec, MarkSpec, Schema } from 'prosemirror-model'
+import { MarkSpec, NodeSpec, Schema } from '@tiptap/pm/model'
+
+import { MarkConfig, NodeConfig } from '..'
 import { AnyConfig, Extensions } from '../types'
-import { NodeConfig, MarkConfig } from '..'
-import splitExtensions from './splitExtensions'
-import getAttributesFromExtensions from './getAttributesFromExtensions'
-import getRenderedAttributes from './getRenderedAttributes'
-import isEmptyObject from '../utilities/isEmptyObject'
-import injectExtensionAttributesToParseRule from './injectExtensionAttributesToParseRule'
-import callOrReturn from '../utilities/callOrReturn'
-import getExtensionField from './getExtensionField'
+import { callOrReturn } from '../utilities/callOrReturn'
+import { isEmptyObject } from '../utilities/isEmptyObject'
+import { getAttributesFromExtensions } from './getAttributesFromExtensions'
+import { getExtensionField } from './getExtensionField'
+import { getRenderedAttributes } from './getRenderedAttributes'
+import { injectExtensionAttributesToParseRule } from './injectExtensionAttributesToParseRule'
+import { splitExtensions } from './splitExtensions'
 
 function cleanUpSchemaItem<T>(data: T) {
-  return Object.fromEntries(Object.entries(data).filter(([key, value]) => {
-    if (key === 'attrs' && isEmptyObject(value)) {
-      return false
-    }
+  return Object.fromEntries(
+    Object.entries(data).filter(([key, value]) => {
+      if (key === 'attrs' && isEmptyObject(value)) {
+        return false
+      }
 
-    return value !== null && value !== undefined
-  })) as T
+      return value !== null && value !== undefined
+    }),
+  ) as T
 }
 
-export default function getSchemaByResolvedExtensions(extensions: Extensions): Schema {
+export function getSchemaByResolvedExtensions(extensions: Extensions): Schema {
   const allAttributes = getAttributesFromExtensions(extensions)
   const { nodeExtensions, markExtensions } = splitExtensions(extensions)
   const topNode = nodeExtensions.find(extension => getExtensionField(extension, 'topNode'))?.name
 
-  const nodes = Object.fromEntries(nodeExtensions.map(extension => {
-    const extensionAttributes = allAttributes.filter(attribute => attribute.type === extension.name)
-    const context = {
-      name: extension.name,
-      options: extension.options,
-    }
-
-    const extraNodeFields = extensions.reduce((fields, e) => {
-      const extendNodeSchema = getExtensionField<AnyConfig['extendNodeSchema']>(
-        e,
-        'extendNodeSchema',
+  const nodes = Object.fromEntries(
+    nodeExtensions.map(extension => {
+      const extensionAttributes = allAttributes.filter(
+        attribute => attribute.type === extension.name,
+      )
+      const context = {
+        name: extension.name,
+        options: extension.options,
+        storage: extension.storage,
+      }
+
+      const extraNodeFields = extensions.reduce((fields, e) => {
+        const extendNodeSchema = getExtensionField<AnyConfig['extendNodeSchema']>(
+          e,
+          'extendNodeSchema',
+          context,
+        )
+
+        return {
+          ...fields,
+          ...(extendNodeSchema ? extendNodeSchema(extension) : {}),
+        }
+      }, {})
+
+      const schema: NodeSpec = cleanUpSchemaItem({
+        ...extraNodeFields,
+        content: callOrReturn(
+          getExtensionField<NodeConfig['content']>(extension, 'content', context),
+        ),
+        marks: callOrReturn(getExtensionField<NodeConfig['marks']>(extension, 'marks', context)),
+        group: callOrReturn(getExtensionField<NodeConfig['group']>(extension, 'group', context)),
+        inline: callOrReturn(getExtensionField<NodeConfig['inline']>(extension, 'inline', context)),
+        atom: callOrReturn(getExtensionField<NodeConfig['atom']>(extension, 'atom', context)),
+        selectable: callOrReturn(
+          getExtensionField<NodeConfig['selectable']>(extension, 'selectable', context),
+        ),
+        draggable: callOrReturn(
+          getExtensionField<NodeConfig['draggable']>(extension, 'draggable', context),
+        ),
+        code: callOrReturn(getExtensionField<NodeConfig['code']>(extension, 'code', context)),
+        defining: callOrReturn(
+          getExtensionField<NodeConfig['defining']>(extension, 'defining', context),
+        ),
+        isolating: callOrReturn(
+          getExtensionField<NodeConfig['isolating']>(extension, 'isolating', context),
+        ),
+        attrs: Object.fromEntries(
+          extensionAttributes.map(extensionAttribute => {
+            return [extensionAttribute.name, { default: extensionAttribute?.attribute?.default }]
+          }),
+        ),
+      })
+
+      const parseHTML = callOrReturn(
+        getExtensionField<NodeConfig['parseHTML']>(extension, 'parseHTML', context),
+      )
+
+      if (parseHTML) {
+        schema.parseDOM = parseHTML.map(parseRule => injectExtensionAttributesToParseRule(parseRule, extensionAttributes))
+      }
+
+      const renderHTML = getExtensionField<NodeConfig['renderHTML']>(
+        extension,
+        'renderHTML',
         context,
       )
 
-      return {
-        ...fields,
-        ...(extendNodeSchema ? extendNodeSchema(extension) : {}),
+      if (renderHTML) {
+        schema.toDOM = node => renderHTML({
+          node,
+          HTMLAttributes: getRenderedAttributes(node, extensionAttributes),
+        })
       }
-    }, {})
-
-    const schema: NodeSpec = cleanUpSchemaItem({
-      ...extraNodeFields,
-      content: callOrReturn(getExtensionField<NodeConfig['content']>(extension, 'content', context)),
-      marks: callOrReturn(getExtensionField<NodeConfig['marks']>(extension, 'marks', context)),
-      group: callOrReturn(getExtensionField<NodeConfig['group']>(extension, 'group', context)),
-      inline: callOrReturn(getExtensionField<NodeConfig['inline']>(extension, 'inline', context)),
-      atom: callOrReturn(getExtensionField<NodeConfig['atom']>(extension, 'atom', context)),
-      selectable: callOrReturn(getExtensionField<NodeConfig['selectable']>(extension, 'selectable', context)),
-      draggable: callOrReturn(getExtensionField<NodeConfig['draggable']>(extension, 'draggable', context)),
-      code: callOrReturn(getExtensionField<NodeConfig['code']>(extension, 'code', context)),
-      defining: callOrReturn(getExtensionField<NodeConfig['defining']>(extension, 'defining', context)),
-      isolating: callOrReturn(getExtensionField<NodeConfig['isolating']>(extension, 'isolating', context)),
-      attrs: Object.fromEntries(extensionAttributes.map(extensionAttribute => {
-        return [extensionAttribute.name, { default: extensionAttribute?.attribute?.default }]
-      })),
-    })
-
-    const parseHTML = callOrReturn(getExtensionField<NodeConfig['parseHTML']>(extension, 'parseHTML', context))
-
-    if (parseHTML) {
-      schema.parseDOM = parseHTML
-        .map(parseRule => injectExtensionAttributesToParseRule(parseRule, extensionAttributes))
-    }
-
-    const renderHTML = getExtensionField<NodeConfig['renderHTML']>(extension, 'renderHTML', context)
-
-    if (renderHTML) {
-      schema.toDOM = node => renderHTML({
-        node,
-        HTMLAttributes: getRenderedAttributes(node, extensionAttributes),
-      })
-    }
-
-    return [extension.name, schema]
-  }))
-
-  const marks = Object.fromEntries(markExtensions.map(extension => {
-    const extensionAttributes = allAttributes.filter(attribute => attribute.type === extension.name)
-    const context = {
-      name: extension.name,
-      options: extension.options,
-    }
-
-    const extraMarkFields = extensions.reduce((fields, e) => {
-      const extendMarkSchema = getExtensionField<AnyConfig['extendMarkSchema']>(
-        e,
-        'extendMarkSchema',
+
+      const renderText = getExtensionField<NodeConfig['renderText']>(
+        extension,
+        'renderText',
         context,
       )
 
-      return {
-        ...fields,
-        ...(extendMarkSchema ? extendMarkSchema(extension) : {}),
+      if (renderText) {
+        schema.toText = renderText
       }
-    }, {})
-
-    const schema: MarkSpec = cleanUpSchemaItem({
-      ...extraMarkFields,
-      inclusive: callOrReturn(getExtensionField<NodeConfig['inclusive']>(extension, 'inclusive', context)),
-      excludes: callOrReturn(getExtensionField<NodeConfig['excludes']>(extension, 'excludes', context)),
-      group: callOrReturn(getExtensionField<NodeConfig['group']>(extension, 'group', context)),
-      spanning: callOrReturn(getExtensionField<NodeConfig['spanning']>(extension, 'spanning', context)),
-      attrs: Object.fromEntries(extensionAttributes.map(extensionAttribute => {
-        return [extensionAttribute.name, { default: extensionAttribute?.attribute?.default }]
-      })),
-    })
-
-    const parseHTML = callOrReturn(getExtensionField<MarkConfig['parseHTML']>(extension, 'parseHTML', context))
-
-    if (parseHTML) {
-      schema.parseDOM = parseHTML
-        .map(parseRule => injectExtensionAttributesToParseRule(parseRule, extensionAttributes))
-    }
-
-    const renderHTML = getExtensionField<MarkConfig['renderHTML']>(extension, 'renderHTML', context)
-
-    if (renderHTML) {
-      schema.toDOM = mark => renderHTML({
-        mark,
-        HTMLAttributes: getRenderedAttributes(mark, extensionAttributes),
+
+      return [extension.name, schema]
+    }),
+  )
+
+  const marks = Object.fromEntries(
+    markExtensions.map(extension => {
+      const extensionAttributes = allAttributes.filter(
+        attribute => attribute.type === extension.name,
+      )
+      const context = {
+        name: extension.name,
+        options: extension.options,
+        storage: extension.storage,
+      }
+
+      const extraMarkFields = extensions.reduce((fields, e) => {
+        const extendMarkSchema = getExtensionField<AnyConfig['extendMarkSchema']>(
+          e,
+          'extendMarkSchema',
+          context,
+        )
+
+        return {
+          ...fields,
+          ...(extendMarkSchema ? extendMarkSchema(extension) : {}),
+        }
+      }, {})
+
+      const schema: MarkSpec = cleanUpSchemaItem({
+        ...extraMarkFields,
+        inclusive: callOrReturn(
+          getExtensionField<MarkConfig['inclusive']>(extension, 'inclusive', context),
+        ),
+        excludes: callOrReturn(
+          getExtensionField<MarkConfig['excludes']>(extension, 'excludes', context),
+        ),
+        group: callOrReturn(getExtensionField<MarkConfig['group']>(extension, 'group', context)),
+        spanning: callOrReturn(
+          getExtensionField<MarkConfig['spanning']>(extension, 'spanning', context),
+        ),
+        code: callOrReturn(getExtensionField<MarkConfig['code']>(extension, 'code', context)),
+        attrs: Object.fromEntries(
+          extensionAttributes.map(extensionAttribute => {
+            return [extensionAttribute.name, { default: extensionAttribute?.attribute?.default }]
+          }),
+        ),
       })
-    }
 
-    return [extension.name, schema]
-  }))
+      const parseHTML = callOrReturn(
+        getExtensionField<MarkConfig['parseHTML']>(extension, 'parseHTML', context),
+      )
+
+      if (parseHTML) {
+        schema.parseDOM = parseHTML.map(parseRule => injectExtensionAttributesToParseRule(parseRule, extensionAttributes))
+      }
+
+      const renderHTML = getExtensionField<MarkConfig['renderHTML']>(
+        extension,
+        'renderHTML',
+        context,
+      )
+
+      if (renderHTML) {
+        schema.toDOM = mark => renderHTML({
+          mark,
+          HTMLAttributes: getRenderedAttributes(mark, extensionAttributes),
+        })
+      }
+
+      return [extension.name, schema]
+    }),
+  )
 
   return new Schema({
     topNode,

package/src/helpers/getSchemaTypeByName.ts

@@ -1,13 +1,5 @@
-import { MarkType, NodeType, Schema } from 'prosemirror-model'
+import { MarkType, NodeType, Schema } from '@tiptap/pm/model'
 
-export default function getSchemaTypeByName(name: string, schema: Schema): NodeType | MarkType | null {
-  if (schema.nodes[name]) {
-    return schema.nodes[name]
-  }
-
-  if (schema.marks[name]) {
-    return schema.marks[name]
-  }
-
-  return null
+export function getSchemaTypeByName(name: string, schema: Schema): NodeType | MarkType | null {
+  return schema.nodes[name] || schema.marks[name] || null
 }

package/src/helpers/getSchemaTypeNameByName.ts

@@ -1,6 +1,6 @@
-import { Schema } from 'prosemirror-model'
+import { Schema } from '@tiptap/pm/model'
 
-export default function getSchemaTypeNameByName(name: string, schema: Schema): 'node' | 'mark' | null {
+export function getSchemaTypeNameByName(name: string, schema: Schema): 'node' | 'mark' | null {
   if (schema.nodes[name]) {
     return 'node'
   }

package/src/helpers/getSplittedAttributes.ts

@@ -1,6 +1,6 @@
 import { ExtensionAttribute } from '../types'
 
-export default function getSplittedAttributes(
+export function getSplittedAttributes(
   extensionAttributes: ExtensionAttribute[],
   typeName: string,
   attributes: Record<string, any>,

package/src/helpers/getText.ts

@@ -0,0 +1,19 @@
+import { Node as ProseMirrorNode } from '@tiptap/pm/model'
+
+import { TextSerializer } from '../types'
+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,46 @@
+import { Node as ProseMirrorNode } from '@tiptap/pm/model'
+
+import { Range, TextSerializer } from '../types'
+
+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
+      }
+
+      if (parent) {
+        text += textSerializer({
+          node,
+          pos,
+          parent,
+          index,
+          range,
+        })
+      }
+    } else if (node.isText) {
+      text += node?.text?.slice(Math.max(from, pos) - pos, to - pos) // eslint-disable-line
+      separated = false
+    } else if (node.isBlock && !separated) {
+      text += blockSeparator
+      separated = true
+    }
+  })
+
+  return text
+}

package/src/helpers/getTextContentFromNodes.ts

@@ -0,0 +1,26 @@
+import { ResolvedPos } from '@tiptap/pm/model'
+
+export const getTextContentFromNodes = ($from: ResolvedPos, maxMatch = 500) => {
+  let textBefore = ''
+
+  const sliceEndPos = $from.parentOffset
+
+  $from.parent.nodesBetween(
+    Math.max(0, sliceEndPos - maxMatch),
+    sliceEndPos,
+    (node, pos, parent, index) => {
+      const chunk = node.type.spec.toText?.({
+        node,
+        pos,
+        parent,
+        index,
+      })
+        || node.textContent
+        || '%leaf%'
+
+      textBefore += chunk.slice(0, Math.max(0, sliceEndPos - pos))
+    },
+  )
+
+  return textBefore
+}

package/src/helpers/getTextSerializersFromSchema.ts

@@ -0,0 +1,11 @@
+import { Schema } from '@tiptap/pm/model'
+
+import { TextSerializer } from '../types'
+
+export function getTextSerializersFromSchema(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/index.ts

@@ -0,0 +1,47 @@
+export * from './combineTransactionSteps'
+export * from './createChainableState'
+export * from './createDocument'
+export * from './createNodeFromContent'
+export * from './defaultBlockAt'
+export * from './findChildren'
+export * from './findChildrenInRange'
+export * from './findParentNode'
+export * from './findParentNodeClosestToPos'
+export * from './generateHTML'
+export * from './generateJSON'
+export * from './generateText'
+export * from './getAttributes'
+export * from './getAttributesFromExtensions'
+export * from './getChangedRanges'
+export * from './getDebugJSON'
+export * from './getExtensionField'
+export * from './getHTMLFromFragment'
+export * from './getMarkAttributes'
+export * from './getMarkRange'
+export * from './getMarksBetween'
+export * from './getMarkType'
+export * from './getNodeAttributes'
+export * from './getNodeType'
+export * from './getRenderedAttributes'
+export * from './getSchema'
+export * from './getSchemaByResolvedExtensions'
+export * from './getSchemaTypeByName'
+export * from './getSchemaTypeNameByName'
+export * from './getSplittedAttributes'
+export * from './getText'
+export * from './getTextBetween'
+export * from './getTextContentFromNodes'
+export * from './getTextSerializersFromSchema'
+export * from './injectExtensionAttributesToParseRule'
+export * from './isActive'
+export * from './isExtensionRulesEnabled'
+export * from './isList'
+export * from './isMarkActive'
+export * from './isNodeActive'
+export * from './isNodeEmpty'
+export * from './isNodeSelection'
+export * from './isTextSelection'
+export * from './posToDOMRect'
+export * from './resolveFocusPosition'
+export * from './selectionToInsertionEnd'
+export * from './splitExtensions'

package/src/helpers/injectExtensionAttributesToParseRule.ts

@@ -1,6 +1,7 @@
-import { ParseRule } from 'prosemirror-model'
+import { ParseRule } from '@tiptap/pm/model'
+
 import { ExtensionAttribute } from '../types'
-import fromString from '../utilities/fromString'
+import { fromString } from '../utilities/fromString'
 
 /**
  * This function merges extension attributes into parserule attributes (`attrs` or `getAttrs`).
@@ -8,7 +9,10 @@ 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
   }
@@ -16,31 +20,26 @@ export default function injectExtensionAttributesToParseRule(parseRule: ParseRul
   return {
     ...parseRule,
     getAttrs: node => {
-      const oldAttributes = parseRule.getAttrs
-        ? parseRule.getAttrs(node)
-        : parseRule.attrs
+      const oldAttributes = parseRule.getAttrs ? parseRule.getAttrs(node) : parseRule.attrs
 
       if (oldAttributes === false) {
         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 filteredAttributes = Object.fromEntries(Object.entries(attributes)
-            .filter(([, value]) => value !== undefined && value !== null))
-
-          return {
-            ...items,
-            ...filteredAttributes,
-          }
-        }, {})
+      const newAttributes = extensionAttributes.reduce((items, item) => {
+        const value = item.attribute.parseHTML
+          ? item.attribute.parseHTML(node as HTMLElement)
+          : fromString((node as HTMLElement).getAttribute(item.name))
+
+        if (value === null || value === undefined) {
+          return items
+        }
+
+        return {
+          ...items,
+          [item.name]: value,
+        }
+      }, {})
 
       return { ...oldAttributes, ...newAttributes }
     },

package/src/helpers/isActive.ts

@@ -1,9 +1,14 @@
-import { EditorState } from 'prosemirror-state'
-import isNodeActive from './isNodeActive'
-import isMarkActive from './isMarkActive'
-import getSchemaTypeNameByName from './getSchemaTypeNameByName'
+import { EditorState } from '@tiptap/pm/state'
 
-export default function isActive(state: EditorState, name: string | null, attributes: Record<string, any> = {}): boolean {
+import { getSchemaTypeNameByName } from './getSchemaTypeNameByName'
+import { isMarkActive } from './isMarkActive'
+import { isNodeActive } from './isNodeActive'
+
+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,10 +1,10 @@
-import { Extensions } from '../types'
 import { NodeConfig } from '..'
-import splitExtensions from './splitExtensions'
-import callOrReturn from '../utilities/callOrReturn'
-import getExtensionField from '../helpers/getExtensionField'
+import { getExtensionField } from '../helpers/getExtensionField'
+import { Extensions } from '../types'
+import { callOrReturn } from '../utilities/callOrReturn'
+import { splitExtensions } from './splitExtensions'
 
-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.name === name)
 
@@ -15,6 +15,7 @@ export default function isList(name: string, extensions: Extensions): boolean {
   const context = {
     name: extension.name,
     options: extension.options,
+    storage: extension.storage,
   }
   const group = callOrReturn(getExtensionField<NodeConfig['group']>(extension, 'group', context))