@tiptap/core 2.0.0-beta.209 → 2.0.0-beta.210

package/src/ExtensionManager.ts

@@ -1,7 +1,7 @@
-import { keymap } from 'prosemirror-keymap'
-import { Node as ProsemirrorNode, Schema } from 'prosemirror-model'
-import { Plugin } from 'prosemirror-state'
-import { Decoration, EditorView } from 'prosemirror-view'
+import { keymap } from '@tiptap/pm/keymap'
+import { Node as ProsemirrorNode, Schema } from '@tiptap/pm/model'
+import { Plugin } from '@tiptap/pm/state'
+import { Decoration, EditorView } from '@tiptap/pm/view'
 
 import { Mark, NodeConfig } from '.'
 import { Editor } from './Editor'
@@ -20,7 +20,6 @@ import { callOrReturn } from './utilities/callOrReturn'
 import { findDuplicates } from './utilities/findDuplicates'
 
 export class ExtensionManager {
-
   editor: Editor
 
   schema: Schema
@@ -64,21 +63,13 @@ export class ExtensionManager {
         this.editor.on('beforeCreate', onBeforeCreate)
       }
 
-      const onCreate = getExtensionField<AnyConfig['onCreate']>(
-        extension,
-        'onCreate',
-        context,
-      )
+      const onCreate = getExtensionField<AnyConfig['onCreate']>(extension, 'onCreate', context)
 
       if (onCreate) {
         this.editor.on('create', onCreate)
       }
 
-      const onUpdate = getExtensionField<AnyConfig['onUpdate']>(
-        extension,
-        'onUpdate',
-        context,
-      )
+      const onUpdate = getExtensionField<AnyConfig['onUpdate']>(extension, 'onUpdate', context)
 
       if (onUpdate) {
         this.editor.on('update', onUpdate)
@@ -104,31 +95,19 @@ export class ExtensionManager {
         this.editor.on('transaction', onTransaction)
       }
 
-      const onFocus = getExtensionField<AnyConfig['onFocus']>(
-        extension,
-        'onFocus',
-        context,
-      )
+      const onFocus = getExtensionField<AnyConfig['onFocus']>(extension, 'onFocus', context)
 
       if (onFocus) {
         this.editor.on('focus', onFocus)
       }
 
-      const onBlur = getExtensionField<AnyConfig['onBlur']>(
-        extension,
-        'onBlur',
-        context,
-      )
+      const onBlur = getExtensionField<AnyConfig['onBlur']>(extension, 'onBlur', context)
 
       if (onBlur) {
         this.editor.on('blur', onBlur)
       }
 
-      const onDestroy = getExtensionField<AnyConfig['onDestroy']>(
-        extension,
-        'onDestroy',
-        context,
-      )
+      const onDestroy = getExtensionField<AnyConfig['onDestroy']>(extension, 'onDestroy', context)
 
       if (onDestroy) {
         this.editor.on('destroy', onDestroy)
@@ -141,38 +120,41 @@ export class ExtensionManager {
     const duplicatedNames = findDuplicates(resolvedExtensions.map(extension => extension.name))
 
     if (duplicatedNames.length) {
-      console.warn(`[tiptap warn]: Duplicate extension names found: [${duplicatedNames.map(item => `'${item}'`).join(', ')}]. This can lead to issues.`)
+      console.warn(
+        `[tiptap warn]: Duplicate extension names found: [${duplicatedNames
+          .map(item => `'${item}'`)
+          .join(', ')}]. This can lead to issues.`,
+      )
     }
 
     return resolvedExtensions
   }
 
   static flatten(extensions: Extensions): Extensions {
-    return extensions
-      .map(extension => {
-        const context = {
-          name: extension.name,
-          options: extension.options,
-          storage: extension.storage,
-        }
-
-        const addExtensions = getExtensionField<AnyConfig['addExtensions']>(
-          extension,
-          'addExtensions',
-          context,
-        )
-
-        if (addExtensions) {
-          return [
+    return (
+      extensions
+        .map(extension => {
+          const context = {
+            name: extension.name,
+            options: extension.options,
+            storage: extension.storage,
+          }
+
+          const addExtensions = getExtensionField<AnyConfig['addExtensions']>(
             extension,
-            ...this.flatten(addExtensions()),
-          ]
-        }
+            'addExtensions',
+            context,
+          )
 
-        return extension
-      })
-      // `Infinity` will break TypeScript so we set a number that is probably high enough
-      .flat(10)
+          if (addExtensions) {
+            return [extension, ...this.flatten(addExtensions())]
+          }
+
+          return extension
+        })
+        // `Infinity` will break TypeScript so we set a number that is probably high enough
+        .flat(10)
+    )
   }
 
   static sort(extensions: Extensions): Extensions {
@@ -256,16 +238,14 @@ export class ExtensionManager {
 
         // bind exit handling
         if (extension.type === 'mark' && extension.config.exitable) {
-          defaultBindings.ArrowRight = () => Mark.handleExit({ editor, mark: (extension as Mark) })
+          defaultBindings.ArrowRight = () => Mark.handleExit({ editor, mark: extension as Mark })
         }
 
         if (addKeyboardShortcuts) {
           const bindings = Object.fromEntries(
-            Object
-              .entries(addKeyboardShortcuts())
-              .map(([shortcut, method]) => {
-                return [shortcut, () => method({ editor })]
-              }),
+            Object.entries(addKeyboardShortcuts()).map(([shortcut, method]) => {
+              return [shortcut, () => method({ editor })]
+            }),
           )
 
           defaultBindings = { ...defaultBindings, ...bindings }
@@ -332,46 +312,50 @@ export class ExtensionManager {
     const { editor } = this
     const { nodeExtensions } = splitExtensions(this.extensions)
 
-    return Object.fromEntries(nodeExtensions
-      .filter(extension => !!getExtensionField(extension, 'addNodeView'))
-      .map(extension => {
-        const extensionAttributes = this.attributes.filter(attribute => attribute.type === extension.name)
-        const context = {
-          name: extension.name,
-          options: extension.options,
-          storage: extension.storage,
-          editor,
-          type: getNodeType(extension.name, this.schema),
-        }
-        const addNodeView = getExtensionField<NodeConfig['addNodeView']>(
-          extension,
-          'addNodeView',
-          context,
-        )
-
-        if (!addNodeView) {
-          return []
-        }
-
-        const nodeview = (
-          node: ProsemirrorNode,
-          view: EditorView,
-          getPos: (() => number) | boolean,
-          decorations: Decoration[],
-        ) => {
-          const HTMLAttributes = getRenderedAttributes(node, extensionAttributes)
-
-          return addNodeView()({
+    return Object.fromEntries(
+      nodeExtensions
+        .filter(extension => !!getExtensionField(extension, 'addNodeView'))
+        .map(extension => {
+          const extensionAttributes = this.attributes.filter(
+            attribute => attribute.type === extension.name,
+          )
+          const context = {
+            name: extension.name,
+            options: extension.options,
+            storage: extension.storage,
             editor,
-            node,
-            getPos,
-            decorations,
-            HTMLAttributes,
+            type: getNodeType(extension.name, this.schema),
+          }
+          const addNodeView = getExtensionField<NodeConfig['addNodeView']>(
             extension,
-          })
-        }
+            'addNodeView',
+            context,
+          )
 
-        return [extension.name, nodeview]
-      }))
+          if (!addNodeView) {
+            return []
+          }
+
+          const nodeview = (
+            node: ProsemirrorNode,
+            view: EditorView,
+            getPos: (() => number) | boolean,
+            decorations: Decoration[],
+          ) => {
+            const HTMLAttributes = getRenderedAttributes(node, extensionAttributes)
+
+            return addNodeView()({
+              editor,
+              node,
+              getPos,
+              decorations,
+              HTMLAttributes,
+              extension,
+            })
+          }
+
+          return [extension.name, nodeview]
+        }),
+    )
   }
 }

package/src/InputRule.ts

@@ -1,4 +1,4 @@
-import { EditorState, Plugin, TextSelection } from 'prosemirror-state'
+import { EditorState, Plugin, TextSelection } from '@tiptap/pm/state'
 
 import { CommandManager } from './CommandManager'
 import { Editor } from './Editor'
@@ -14,46 +14,47 @@ import {
 import { isRegExp } from './utilities/isRegExp'
 
 export type InputRuleMatch = {
-  index: number,
-  text: string,
-  replaceWith?: string,
-  match?: RegExpMatchArray,
-  data?: Record<string, any>,
+  index: number
+  text: string
+  replaceWith?: string
+  match?: RegExpMatchArray
+  data?: Record<string, any>
 }
 
-export type InputRuleFinder =
-  | RegExp
-  | ((text: string) => InputRuleMatch | null)
+export type InputRuleFinder = RegExp | ((text: string) => InputRuleMatch | null)
 
 export class InputRule {
   find: InputRuleFinder
 
   handler: (props: {
-    state: EditorState,
-    range: Range,
-    match: ExtendedRegExpMatchArray,
-    commands: SingleCommands,
-    chain: () => ChainedCommands,
-    can: () => CanCommands,
+    state: EditorState
+    range: Range
+    match: ExtendedRegExpMatchArray
+    commands: SingleCommands
+    chain: () => ChainedCommands
+    can: () => CanCommands
   }) => void | null
 
   constructor(config: {
-    find: InputRuleFinder,
+    find: InputRuleFinder
     handler: (props: {
-      state: EditorState,
-      range: Range,
-      match: ExtendedRegExpMatchArray,
-      commands: SingleCommands,
-      chain: () => ChainedCommands,
-      can: () => CanCommands,
-    }) => void | null,
+      state: EditorState
+      range: Range
+      match: ExtendedRegExpMatchArray
+      commands: SingleCommands
+      chain: () => ChainedCommands
+      can: () => CanCommands
+    }) => void | null
   }) {
     this.find = config.find
     this.handler = config.handler
   }
 }
 
-const inputRuleMatcherHandler = (text: string, find: InputRuleFinder): ExtendedRegExpMatchArray | null => {
+const inputRuleMatcherHandler = (
+  text: string,
+  find: InputRuleFinder,
+): ExtendedRegExpMatchArray | null => {
   if (isRegExp(find)) {
     return find.exec(text)
   }
@@ -64,16 +65,17 @@ const inputRuleMatcherHandler = (text: string, find: InputRuleFinder): ExtendedR
     return null
   }
 
-  const result: ExtendedRegExpMatchArray = []
+  const result: ExtendedRegExpMatchArray = [inputRuleMatch.text]
 
-  result.push(inputRuleMatch.text)
   result.index = inputRuleMatch.index
   result.input = text
   result.data = inputRuleMatch.data
 
   if (inputRuleMatch.replaceWith) {
     if (!inputRuleMatch.text.includes(inputRuleMatch.replaceWith)) {
-      console.warn('[tiptap warn]: "inputRuleMatch.replaceWith" must be part of "inputRuleMatch.text".')
+      console.warn(
+        '[tiptap warn]: "inputRuleMatch.replaceWith" must be part of "inputRuleMatch.text".',
+      )
     }
 
     result.push(inputRuleMatch.replaceWith)
@@ -83,20 +85,15 @@ const inputRuleMatcherHandler = (text: string, find: InputRuleFinder): ExtendedR
 }
 
 function run(config: {
-  editor: Editor,
-  from: number,
-  to: number,
-  text: string,
-  rules: InputRule[],
-  plugin: Plugin,
+  editor: Editor
+  from: number
+  to: number
+  text: string
+  rules: InputRule[]
+  plugin: Plugin
 }): boolean {
   const {
-    editor,
-    from,
-    to,
-    text,
-    rules,
-    plugin,
+    editor, from, to, text, rules, plugin,
   } = config
   const { view } = editor
 
@@ -180,7 +177,7 @@ function run(config: {
  * input that matches any of the given rules to trigger the rule’s
  * action.
  */
-export function inputRulesPlugin(props: { editor: Editor, rules: InputRule[] }): Plugin {
+export function inputRulesPlugin(props: { editor: Editor; rules: InputRule[] }): Plugin {
   const { editor, rules } = props
   const plugin = new Plugin({
     state: {
@@ -194,9 +191,7 @@ export function inputRulesPlugin(props: { editor: Editor, rules: InputRule[] }):
           return stored
         }
 
-        return tr.selectionSet || tr.docChanged
-          ? null
-          : prev
+        return tr.selectionSet || tr.docChanged ? null : prev
       },
     },