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

package/package.json

@@ -1,45 +1,59 @@
 {
   "name": "@tiptap/core",
   "description": "headless rich text editor",
-  "version": "2.0.0-beta.21",
+  "version": "2.0.0-beta.210",
   "homepage": "https://tiptap.dev",
   "keywords": [
     "tiptap",
     "headless",
     "wysiwyg",
-    "text editor"
+    "text editor",
+    "prosemirror"
   ],
   "license": "MIT",
   "funding": {
     "type": "github",
     "url": "https://github.com/sponsors/ueberdosis"
   },
-  "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",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
+  "types": "dist/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.13.0",
-    "@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.14.0",
-    "prosemirror-schema-list": "^1.1.4",
-    "prosemirror-state": "^1.3.4",
-    "prosemirror-transform": "^1.3.2",
-    "prosemirror-view": "^1.18.2"
+  "peerDependencies": {
+    "@tiptap/pm": "^2.0.0-beta.209"
+  },
+  "devDependencies": {
+    "@tiptap/pm": "^2.0.0-beta.210"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ueberdosis/tiptap",
+    "directory": "packages/core"
+  },
+  "sideEffects": false,
+  "scripts": {
+    "build": "tsup"
   },
-  "gitHead": "113d50b814c8860465c8bb16ae2bee3097689016"
+  "tsup": {
+    "entry": [
+      "src/index.ts"
+    ],
+    "dts": true,
+    "splitting": true,
+    "format": [
+      "esm",
+      "cjs"
+    ]
+  }
 }

package/src/CommandManager.ts

@@ -1,37 +1,44 @@
-import { EditorState, Transaction } from 'prosemirror-state'
+import { EditorState, Transaction } from '@tiptap/pm/state'
+
 import { Editor } from './Editor'
+import { createChainableState } from './helpers/createChainableState'
 import {
-  SingleCommands,
-  ChainedCommands,
-  CanCommands,
-  RawCommands,
-  CommandProps,
+  AnyCommands, CanCommands, ChainedCommands, CommandProps, SingleCommands,
 } from './types'
 
-export default class CommandManager {
-
+export class CommandManager {
   editor: Editor
 
-  commands: RawCommands
+  rawCommands: AnyCommands
+
+  customState?: EditorState
+
+  constructor(props: { editor: Editor; state?: EditorState }) {
+    this.editor = props.editor
+    this.rawCommands = this.editor.extensionManager.commands
+    this.customState = props.state
+  }
+
+  get hasCustomState(): boolean {
+    return !!this.customState
+  }
 
-  constructor(editor: Editor, commands: RawCommands) {
-    this.editor = editor
-    this.commands = commands
+  get state(): EditorState {
+    return this.customState || this.editor.state
   }
 
-  public createCommands(): SingleCommands {
-    const { commands, editor } = this
-    const { state, view } = editor
+  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)
-      .map(([name, command]) => {
-        const method = (...args: any) => {
+    return Object.fromEntries(
+      Object.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)
           }
 
@@ -39,37 +46,53 @@ 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[]) => {
-          const props = this.buildProps(tr, shouldDispatch)
-          const callback = command(...args)(props)
+      ...Object.fromEntries(
+        Object.entries(rawCommands).map(([name, command]) => {
+          const chainedCommand = (...args: never[]) => {
+            const props = this.buildProps(tr, shouldDispatch)
+            const callback = command(...args)(props)
 
-          callbacks.push(callback)
+            callbacks.push(callback)
 
-          return chain
-        }
+            return chain
+          }
 
-        return [name, chainedCommand]
-      })),
+          return [name, chainedCommand]
+        }),
+      ),
       run,
     } as unknown as ChainedCommands
 
@@ -77,16 +100,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)
-      .map(([name, command]) => {
-        return [name, (...args: any[]) => command(...args)({ ...props, dispatch })]
-      })) as SingleCommands
+    const formattedCommands = Object.fromEntries(
+      Object.entries(rawCommands).map(([name, command]) => {
+        return [name, (...args: never[]) => command(...args)({ ...props, dispatch: undefined })]
+      }),
+    ) as unknown as SingleCommands
 
     return {
       ...formattedCommands,
@@ -95,8 +117,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,54 +128,22 @@ export default class CommandManager {
       tr,
       editor,
       view,
-      state: this.chainableState(tr, state),
-      dispatch: shouldDispatch
-        ? () => undefined
-        : undefined,
+      state: createChainableState({
+        state,
+        transaction: tr,
+      }),
+      dispatch: shouldDispatch ? () => undefined : undefined,
       chain: () => this.createChain(tr),
       can: () => this.createCan(tr),
       get commands() {
-        return Object.fromEntries(Object
-          .entries(commands)
-          .map(([name, command]) => {
-            return [name, (...args: any[]) => command(...args)(props)]
-          })) as SingleCommands
+        return Object.fromEntries(
+          Object.entries(rawCommands).map(([name, command]) => {
+            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
-      },
-    }
-  }
-
 }