feat: Allow to use commands within InputRule and PasteRule (#2035)

* add optional state prop to commandmanager

* add commands, chain and can getter to commandmanager

* use custom CommandManager for input rules and paste rules

* export commandmanager

packages/core/src/CommandManager.ts

@@ -1,4 +1,4 @@
-import { Transaction } from 'prosemirror-state'
+import { EditorState, Transaction } from 'prosemirror-state'
 import { Editor } from './Editor'
 import createChainableState from './helpers/createChainableState'
 import {
@@ -13,26 +13,40 @@ export default class CommandManager {
 
   editor: Editor
 
-  commands: AnyCommands
+  rawCommands: AnyCommands
 
-  constructor(editor: Editor, commands: AnyCommands) {
-    this.editor = editor
-    this.commands = commands
+  customState?: EditorState
+
+  constructor(props: {
+    editor: Editor,
+    state?: EditorState,
+  }) {
+    this.editor = props.editor
+    this.rawCommands = this.editor.extensionManager.commands
+    this.customState = props.state
   }
 
-  public createCommands(): SingleCommands {
-    const { commands, editor } = this
-    const { state, view } = editor
+  get hasCustomState(): boolean {
+    return !!this.customState
+  }
+
+  get state(): EditorState {
+    return this.customState || this.editor.state
+  }
+
+  get commands(): SingleCommands {
+    const { rawCommands, editor, state } = this
+    const { view } = editor
     const { tr } = state
     const props = this.buildProps(tr)
 
     return Object.fromEntries(Object
-      .entries(commands)
+      .entries(rawCommands)
       .map(([name, command]) => {
         const method = (...args: any[]) => {
           const callback = command(...args)(props)
 
-          if (!tr.getMeta('preventDispatch')) {
+          if (!tr.getMeta('preventDispatch') && !this.hasCustomState) {
             view.dispatch(tr)
           }
 
@@ -43,15 +57,28 @@ export default class CommandManager {
       })) as unknown as SingleCommands
   }
 
+  get chain(): () => ChainedCommands {
+    return () => this.createChain()
+  }
+
+  get can(): () => CanCommands {
+    return () => this.createCan()
+  }
+
   public createChain(startTr?: Transaction, shouldDispatch = true): ChainedCommands {
-    const { commands, editor } = this
-    const { state, view } = editor
+    const { rawCommands, editor, state } = this
+    const { view } = editor
     const callbacks: boolean[] = []
     const hasStartTransaction = !!startTr
     const tr = startTr || state.tr
 
     const run = () => {
-      if (!hasStartTransaction && shouldDispatch && !tr.getMeta('preventDispatch')) {
+      if (
+        !hasStartTransaction
+        && shouldDispatch
+        && !tr.getMeta('preventDispatch')
+        && !this.hasCustomState
+      ) {
         view.dispatch(tr)
       }
 
@@ -59,7 +86,7 @@ export default class CommandManager {
     }
 
     const chain = {
-      ...Object.fromEntries(Object.entries(commands).map(([name, command]) => {
+      ...Object.fromEntries(Object.entries(rawCommands).map(([name, command]) => {
         const chainedCommand = (...args: never[]) => {
           const props = this.buildProps(tr, shouldDispatch)
           const callback = command(...args)(props)
@@ -78,13 +105,12 @@ export default class CommandManager {
   }
 
   public createCan(startTr?: Transaction): CanCommands {
-    const { commands, editor } = this
-    const { state } = editor
+    const { rawCommands, state } = this
     const dispatch = undefined
     const tr = startTr || state.tr
     const props = this.buildProps(tr, dispatch)
     const formattedCommands = Object.fromEntries(Object
-      .entries(commands)
+      .entries(rawCommands)
       .map(([name, command]) => {
         return [name, (...args: never[]) => command(...args)({ ...props, dispatch })]
       })) as unknown as SingleCommands
@@ -96,8 +122,8 @@ export default class CommandManager {
   }
 
   public buildProps(tr: Transaction, shouldDispatch = true): CommandProps {
-    const { editor, commands } = this
-    const { state, view } = editor
+    const { rawCommands, editor, state } = this
+    const { view } = editor
 
     if (state.storedMarks) {
       tr.setStoredMarks(state.storedMarks)
@@ -118,7 +144,7 @@ export default class CommandManager {
       can: () => this.createCan(tr),
       get commands() {
         return Object.fromEntries(Object
-          .entries(commands)
+          .entries(rawCommands)
           .map(([name, command]) => {
             return [name, (...args: never[]) => command(...args)(props)]
           })) as unknown as SingleCommands