@tiptap/core 2.0.0-beta.20 → 2.0.0-beta.201

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "@tiptap/core",
   "description": "headless rich text editor",
-  "version": "2.0.0-beta.20",
+  "version": "2.0.0-beta.201",
   "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.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"
+    "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": "7b1d8d103c9d74263fd5c8a6dc146ac5ec4077f5"
+  "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
-      },
-    }
-  }
-
 }

package/src/Editor.ts

@@ -1,28 +1,36 @@
+import { MarkType, NodeType, Schema } from 'prosemirror-model'
 import {
-  EditorState, Plugin, PluginKey, Transaction,
+  EditorState,
+  Plugin,
+  PluginKey,
+  Transaction,
 } from 'prosemirror-state'
 import { EditorView } from 'prosemirror-view'
-import { Schema } from 'prosemirror-model'
-import getNodeAttributes from './helpers/getNodeAttributes'
-import getMarkAttributes from './helpers/getMarkAttributes'
-import isActive from './helpers/isActive'
-import removeElement from './utilities/removeElement'
-import createDocument from './helpers/createDocument'
-import getHTMLFromFragment from './helpers/getHTMLFromFragment'
-import isNodeEmpty from './helpers/isNodeEmpty'
-import createStyleTag from './utilities/createStyleTag'
-import CommandManager from './CommandManager'
-import ExtensionManager from './ExtensionManager'
-import EventEmitter from './EventEmitter'
+
+import { CommandManager } from './CommandManager'
+import { EventEmitter } from './EventEmitter'
+import { ExtensionManager } from './ExtensionManager'
+import * as extensions from './extensions'
+import { createDocument } from './helpers/createDocument'
+import { getAttributes } from './helpers/getAttributes'
+import { getHTMLFromFragment } from './helpers/getHTMLFromFragment'
+import { getText } from './helpers/getText'
+import { getTextSerializersFromSchema } from './helpers/getTextSerializersFromSchema'
+import { isActive } from './helpers/isActive'
+import { isNodeEmpty } from './helpers/isNodeEmpty'
+import { resolveFocusPosition } from './helpers/resolveFocusPosition'
+import { style } from './style'
 import {
-  EditorOptions,
   CanCommands,
   ChainedCommands,
+  EditorEvents,
+  EditorOptions,
+  JSONContent,
   SingleCommands,
-  AnyObject,
+  TextSerializer,
 } from './types'
-import * as extensions from './extensions'
-import style from './style'
+import { createStyleTag } from './utilities/createStyleTag'
+import { isFunction } from './utilities/isFunction'
 
 export { extensions }
 
@@ -30,7 +38,7 @@ export interface HTMLElement {
   editor?: Editor
 }
 
-export class Editor extends EventEmitter {
+export class Editor extends EventEmitter<EditorEvents> {
 
   private commandManager!: CommandManager
 
@@ -44,12 +52,13 @@ export class Editor extends EventEmitter {
 
   public isFocused = false
 
-  private resizeObserver!: ResizeObserver
+  public extensionStorage: Record<string, any> = {}
 
   public options: EditorOptions = {
     element: document.createElement('div'),
     content: '',
     injectCSS: true,
+    injectNonce: undefined,
     extensions: [],
     autofocus: false,
     editable: true,
@@ -57,14 +66,14 @@ export class Editor extends EventEmitter {
     parseOptions: {},
     enableInputRules: true,
     enablePasteRules: true,
+    enableCoreExtensions: true,
+    onBeforeCreate: () => null,
     onCreate: () => null,
     onUpdate: () => null,
     onSelectionUpdate: () => null,
-    onViewUpdate: () => null,
     onTransaction: () => null,
     onFocus: () => null,
     onBlur: () => null,
-    onResize: () => null,
     onDestroy: () => null,
   }
 
@@ -74,50 +83,54 @@ export class Editor extends EventEmitter {
     this.createExtensionManager()
     this.createCommandManager()
     this.createSchema()
+    this.on('beforeCreate', this.options.onBeforeCreate)
+    this.emit('beforeCreate', { editor: this })
     this.createView()
     this.injectCSS()
     this.on('create', this.options.onCreate)
     this.on('update', this.options.onUpdate)
     this.on('selectionUpdate', this.options.onSelectionUpdate)
-    this.on('viewUpdate', this.options.onViewUpdate)
     this.on('transaction', this.options.onTransaction)
     this.on('focus', this.options.onFocus)
     this.on('blur', this.options.onBlur)
     this.on('destroy', this.options.onDestroy)
 
     window.setTimeout(() => {
+      if (this.isDestroyed) {
+        return
+      }
+
       this.commands.focus(this.options.autofocus)
       this.emit('create', { editor: this })
-
-      if (window.ResizeObserver) {
-        this.resizeObserver = new ResizeObserver(() => {
-          this.emit('resize', { editor: this })
-        })
-        this.resizeObserver.observe(this.view.dom)
-      }
     }, 0)
+  }
 
+  /**
+   * Returns the editor storage.
+   */
+  public get storage(): Record<string, any> {
+    return this.extensionStorage
   }
 
   /**
    * An object of all registered commands.
    */
   public get commands(): SingleCommands {
-    return this.commandManager.createCommands()
+    return this.commandManager.commands
   }
 
   /**
    * Create a command chain to call multiple commands at once.
    */
   public chain(): ChainedCommands {
-    return this.commandManager.createChain()
+    return this.commandManager.chain()
   }
 
   /**
    * Check if a command or a command chain can be executed. Without executing it.
    */
   public can(): CanCommands {
-    return this.commandManager.createCan()
+    return this.commandManager.can()
   }
 
   /**
@@ -125,7 +138,7 @@ export class Editor extends EventEmitter {
    */
   private injectCSS(): void {
     if (this.options.injectCSS && document) {
-      this.css = createStyleTag(style)
+      this.css = createStyleTag(style, this.options.injectNonce)
     }
   }
 
@@ -135,7 +148,20 @@ export class Editor extends EventEmitter {
    * @param options A list of options
    */
   public setOptions(options: Partial<EditorOptions> = {}): void {
-    this.options = { ...this.options, ...options }
+    this.options = {
+      ...this.options,
+      ...options,
+    }
+
+    if (!this.view || !this.state || this.isDestroyed) {
+      return
+    }
+
+    if (this.options.editorProps) {
+      this.view.setProps(this.options.editorProps)
+    }
+
+    this.view.updateState(this.state)
   }
 
   /**
@@ -143,17 +169,19 @@ export class Editor extends EventEmitter {
    */
   public setEditable(editable: boolean): void {
     this.setOptions({ editable })
-
-    if (this.view && this.state && !this.isDestroyed) {
-      this.view.updateState(this.state)
-    }
+    this.emit('update', { editor: this, transaction: this.state.tr })
   }
 
   /**
    * Returns whether the editor is editable.
    */
   public get isEditable(): boolean {
-    return this.view && this.view.editable
+    // since plugins are applied after creating the view
+    // `editable` is always `true` for one tick.
+    // that’s why we also have to check for `options.editable`
+    return this.options.editable
+      && this.view
+      && this.view.editable
   }
 
   /**
@@ -170,8 +198,8 @@ export class Editor extends EventEmitter {
    * @param handlePlugins Control how to merge the plugin into the existing plugins.
    */
   public registerPlugin(plugin: Plugin, handlePlugins?: (newPlugin: Plugin, plugins: Plugin[]) => Plugin[]): void {
-    const plugins = typeof handlePlugins === 'function'
-      ? handlePlugins(plugin, this.state.plugins)
+    const plugins = isFunction(handlePlugins)
+      ? handlePlugins(plugin, [...this.state.plugins])
       : [...this.state.plugins, plugin]
 
     const state = this.state.reconfigure({ plugins })
@@ -182,7 +210,7 @@ export class Editor extends EventEmitter {
   /**
    * Unregister a ProseMirror plugin.
    *
-   * @param name The plugins name
+   * @param nameOrPluginKey The plugins name
    */
   public unregisterPlugin(nameOrPluginKey: string | PluginKey): void {
     if (this.isDestroyed) {
@@ -206,7 +234,9 @@ export class Editor extends EventEmitter {
    * Creates an extension manager.
    */
   private createExtensionManager(): void {
-    const coreExtensions = Object.entries(extensions).map(([, extension]) => extension)
+    const coreExtensions = this.options.enableCoreExtensions
+      ? Object.values(extensions)
+      : []
     const allExtensions = [...coreExtensions, ...this.options.extensions].filter(extension => {
       return ['extension', 'node', 'mark'].includes(extension?.type)
     })
@@ -218,7 +248,9 @@ export class Editor extends EventEmitter {
    * Creates an command manager.
    */
   private createCommandManager(): void {
-    this.commandManager = new CommandManager(this, this.extensionManager.commands)
+    this.commandManager = new CommandManager({
+      editor: this,
+    })
   }
 
   /**
@@ -232,27 +264,22 @@ export class Editor extends EventEmitter {
    * Creates a ProseMirror view.
    */
   private createView(): void {
+    const doc = createDocument(this.options.content, this.schema, this.options.parseOptions)
+    const selection = resolveFocusPosition(doc, this.options.autofocus)
+
     this.view = new EditorView(this.options.element, {
       ...this.options.editorProps,
       dispatchTransaction: this.dispatchTransaction.bind(this),
       state: EditorState.create({
-        doc: createDocument(this.options.content, this.schema, this.options.parseOptions),
+        doc,
+        selection: selection || undefined,
       }),
     })
 
     // `editor.view` is not yet available at this time.
     // Therefore we will add all plugins and node views directly afterwards.
     const newState = this.state.reconfigure({
-      plugins: [
-        new Plugin({
-          view: () => ({
-            update: () => this.emit('viewUpdate', {
-              editor: this,
-            }),
-          }),
-        }),
-        ...this.extensionManager.plugins,
-      ],
+      plugins: this.extensionManager.plugins,
     })
 
     this.view.updateState(newState)
@@ -262,6 +289,7 @@ export class Editor extends EventEmitter {
     // Let’s store the editor instance in the DOM element.
     // So we’ll have access to it for tests.
     const dom = this.view.dom as HTMLElement
+
     dom.editor = this
   }
 
@@ -296,10 +324,6 @@ export class Editor extends EventEmitter {
    * @param transaction An editor state transaction
    */
   private dispatchTransaction(transaction: Transaction): void {
-    if (transaction.docChanged && !this.isEditable) {
-      return
-    }
-
     if (this.isCapturingTransaction) {
       if (!this.capturedTransaction) {
         this.capturedTransaction = transaction
@@ -324,6 +348,7 @@ export class Editor extends EventEmitter {
     if (selectionHasChanged) {
       this.emit('selectionUpdate', {
         editor: this,
+        transaction,
       })
     }
 
@@ -334,6 +359,7 @@ export class Editor extends EventEmitter {
       this.emit('focus', {
         editor: this,
         event: focus.event,
+        transaction,
       })
     }
 
@@ -341,6 +367,7 @@ export class Editor extends EventEmitter {
       this.emit('blur', {
         editor: this,
         event: blur.event,
+        transaction,
       })
     }
 
@@ -355,21 +382,10 @@ export class Editor extends EventEmitter {
   }
 
   /**
-   * Get attributes of the currently selected node.
-   *
-   * @param name Name of the node
+   * Get attributes of the currently selected node or mark.
    */
-  public getNodeAttributes(name: string): AnyObject {
-    return getNodeAttributes(this.state, name)
-  }
-
-  /**
-   * Get attributes of the currently selected mark.
-   *
-   * @param name Name of the mark
-   */
-  public getMarkAttributes(name: string): AnyObject {
-    return getMarkAttributes(this.state, name)
+  public getAttributes(nameOrType: string | NodeType | MarkType): Record<string, any> {
+    return getAttributes(this.state, nameOrType)
   }
 
   /**
@@ -395,7 +411,7 @@ export class Editor extends EventEmitter {
   /**
    * Get the document as JSON.
    */
-  public getJSON(): AnyObject {
+  public getJSON(): JSONContent {
     return this.state.doc.toJSON()
   }
 
@@ -403,7 +419,28 @@ export class Editor extends EventEmitter {
    * Get the document as HTML.
    */
   public getHTML(): string {
-    return getHTMLFromFragment(this.state.doc, this.schema)
+    return getHTMLFromFragment(this.state.doc.content, this.schema)
+  }
+
+  /**
+   * Get the document as text.
+   */
+  public getText(options?: {
+    blockSeparator?: string,
+    textSerializers?: Record<string, TextSerializer>,
+  }): string {
+    const {
+      blockSeparator = '\n\n',
+      textSerializers = {},
+    } = options || {}
+
+    return getText(this.state.doc, {
+      blockSeparator,
+      textSerializers: {
+        ...textSerializers,
+        ...getTextSerializersFromSchema(this.schema),
+      },
+    })
   }
 
   /**
@@ -415,8 +452,12 @@ export class Editor extends EventEmitter {
 
   /**
    * Get the number of characters for the current document.
+   *
+   * @deprecated
    */
   public getCharacterCount(): number {
+    console.warn('[tiptap warn]: "editor.getCharacterCount()" is deprecated. Please use "editor.storage.characterCount.characters()" instead.')
+
     return this.state.doc.content.size - 2
   }
 
@@ -424,8 +465,6 @@ export class Editor extends EventEmitter {
    * Destroy the editor.
    */
   public destroy(): void {
-    this.resizeObserver?.unobserve(this.view.dom)
-
     this.emit('destroy')
 
     if (this.view) {
@@ -433,7 +472,6 @@ export class Editor extends EventEmitter {
     }
 
     this.removeAllListeners()
-    removeElement(this.css)
   }
 
   /**