@tiptap/core 2.0.0-beta.2 → 2.0.0-beta.200

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "@tiptap/core",
   "description": "headless rich text editor",
-  "version": "2.0.0-beta.2",
+  "version": "2.0.0-beta.200",
   "homepage": "https://tiptap.dev",
   "keywords": [
     "tiptap",
     "headless",
     "wysiwyg",
-    "text editor"
+    "text editor",
+    "prosemirror"
   ],
   "license": "MIT",
   "funding": {
@@ -17,29 +18,24 @@
   "main": "dist/tiptap-core.cjs.js",
   "umd": "dist/tiptap-core.umd.js",
   "module": "dist/tiptap-core.esm.js",
-  "unpkg": "dist/tiptap-core.bundle.umd.min.js",
   "types": "dist/packages/core/src/index.d.ts",
   "files": [
     "src",
     "dist"
   ],
   "dependencies": {
-    "@types/prosemirror-commands": "^1.0.4",
-    "@types/prosemirror-inputrules": "^1.0.4",
-    "@types/prosemirror-keymap": "^1.0.4",
-    "@types/prosemirror-model": "^1.11.3",
-    "@types/prosemirror-schema-list": "^1.0.3",
-    "@types/prosemirror-state": "^1.2.6",
-    "@types/prosemirror-transform": "^1.1.2",
-    "@types/prosemirror-view": "^1.17.1",
-    "prosemirror-commands": "^1.1.7",
-    "prosemirror-inputrules": "^1.1.3",
-    "prosemirror-keymap": "^1.1.3",
-    "prosemirror-model": "^1.13.3",
-    "prosemirror-schema-list": "^1.1.4",
-    "prosemirror-state": "^1.3.4",
-    "prosemirror-transform": "^1.2.12",
-    "prosemirror-view": "^1.17.8"
+    "prosemirror-commands": "^1.3.1",
+    "prosemirror-keymap": "^1.2.0",
+    "prosemirror-model": "^1.18.1",
+    "prosemirror-schema-list": "^1.2.2",
+    "prosemirror-state": "^1.4.1",
+    "prosemirror-transform": "^1.7.0",
+    "prosemirror-view": "^1.28.2"
   },
-  "gitHead": "bf357dd7cb3da87d494dd8843e90505bba9214ca"
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ueberdosis/tiptap",
+    "directory": "packages/core"
+  },
+  "sideEffects": false
 }

package/src/CommandManager.ts

@@ -1,37 +1,53 @@
 import { EditorState, Transaction } from 'prosemirror-state'
+
 import { Editor } from './Editor'
+import { createChainableState } from './helpers/createChainableState'
 import {
-  SingleCommands,
-  ChainedCommands,
+  AnyCommands,
   CanCommands,
-  RawCommands,
+  ChainedCommands,
   CommandProps,
+  SingleCommands,
 } from './types'
 
-export default class CommandManager {
+export class CommandManager {
 
   editor: Editor
 
-  commands: RawCommands
+  rawCommands: AnyCommands
+
+  customState?: EditorState
 
-  constructor(editor: Editor, commands: RawCommands) {
-    this.editor = editor
-    this.commands = commands
+  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 method = (...args: any[]) => {
           const callback = command(...args)(props)
 
-          if (!tr.getMeta('preventDispatch')) {
+          if (!tr.getMeta('preventDispatch') && !this.hasCustomState) {
             view.dispatch(tr)
           }
 
@@ -39,27 +55,40 @@ export default class CommandManager {
         }
 
         return [name, method]
-      })) as SingleCommands
+      })) 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)
       }
 
-      return () => callbacks.every(callback => callback === true)
+      return callbacks.every(callback => callback === true)
     }
 
     const chain = {
-      ...Object.fromEntries(Object.entries(commands).map(([name, command]) => {
-        const chainedCommand = (...args: any[]) => {
+      ...Object.fromEntries(Object.entries(rawCommands).map(([name, command]) => {
+        const chainedCommand = (...args: never[]) => {
           const props = this.buildProps(tr, shouldDispatch)
           const callback = command(...args)(props)
 
@@ -77,16 +106,15 @@ export default class CommandManager {
   }
 
   public createCan(startTr?: Transaction): CanCommands {
-    const { commands, editor } = this
-    const { state } = editor
-    const dispatch = undefined
+    const { rawCommands, state } = this
+    const dispatch = false
     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: any[]) => command(...args)({ ...props, dispatch })]
-      })) as SingleCommands
+        return [name, (...args: never[]) => command(...args)({ ...props, dispatch: undefined })]
+      })) as unknown as SingleCommands
 
     return {
       ...formattedCommands,
@@ -95,8 +123,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)
@@ -106,7 +134,10 @@ export default class CommandManager {
       tr,
       editor,
       view,
-      state: this.chainableState(tr, state),
+      state: createChainableState({
+        state,
+        transaction: tr,
+      }),
       dispatch: shouldDispatch
         ? () => undefined
         : undefined,
@@ -114,46 +145,14 @@ export default class CommandManager {
       can: () => this.createCan(tr),
       get commands() {
         return Object.fromEntries(Object
-          .entries(commands)
+          .entries(rawCommands)
           .map(([name, command]) => {
-            return [name, (...args: any[]) => command(...args)(props)]
-          })) as SingleCommands
+            return [name, (...args: never[]) => command(...args)(props)]
+          })) as unknown as SingleCommands
       },
     }
 
     return props
   }
 
-  public chainableState(tr: Transaction, state: EditorState): EditorState {
-    let { selection } = tr
-    let { doc } = tr
-    let { storedMarks } = tr
-
-    return {
-      ...state,
-      schema: state.schema,
-      plugins: state.plugins,
-      apply: state.apply.bind(state),
-      applyTransaction: state.applyTransaction.bind(state),
-      reconfigure: state.reconfigure.bind(state),
-      toJSON: state.toJSON.bind(state),
-      get storedMarks() {
-        return storedMarks
-      },
-      get selection() {
-        return selection
-      },
-      get doc() {
-        return doc
-      },
-      get tr() {
-        selection = tr.selection
-        doc = tr.doc
-        storedMarks = tr.storedMarks
-
-        return tr
-      },
-    }
-  }
-
 }