@tiptap/core 3.0.0-beta.2 → 3.0.0-beta.21

package/src/Node.ts

@@ -340,8 +340,14 @@ export interface NodeConfig<Options = any, Storage = any>
 export class Node<Options = any, Storage = any> extends Extendable<Options, Storage, NodeConfig<Options, Storage>> {
   type = 'node'
 
-  static create<O = any, S = any>(config: Partial<NodeConfig<O, S>> = {}) {
-    return new Node<O, S>(config)
+  /**
+   * Create a new Node instance
+   * @param config - Node configuration object or a function that returns a configuration object
+   */
+  static create<O = any, S = any>(config: Partial<NodeConfig<O, S>> | (() => Partial<NodeConfig<O, S>>) = {}) {
+    // If the config is a function, execute it to get the configuration object
+    const resolvedConfig = typeof config === 'function' ? config() : config
+    return new Node<O, S>(resolvedConfig)
   }
 
   configure(options?: Partial<Options>) {
@@ -352,7 +358,9 @@ export class Node<Options = any, Storage = any> extends Extendable<Options, Stor
     ExtendedOptions = Options,
     ExtendedStorage = Storage,
     ExtendedConfig = NodeConfig<ExtendedOptions, ExtendedStorage>,
-  >(extendedConfig?: Partial<ExtendedConfig>) {
-    return super.extend(extendedConfig) as Node<ExtendedOptions, ExtendedStorage>
+  >(extendedConfig?: Partial<ExtendedConfig> | (() => Partial<ExtendedConfig>)) {
+    // If the extended config is a function, execute it to get the configuration object
+    const resolvedConfig = typeof extendedConfig === 'function' ? extendedConfig() : extendedConfig
+    return super.extend(resolvedConfig) as Node<ExtendedOptions, ExtendedStorage>
   }
 }

package/src/NodePos.ts

@@ -136,6 +136,12 @@ export class NodePos {
       const isNonTextAtom = node.isAtom && !node.isText
 
       const targetPos = this.pos + offset + (isNonTextAtom ? 0 : 1)
+
+      // Check if targetPos is within valid document range
+      if (targetPos < 0 || targetPos > this.resolvedPos.doc.nodeSize - 2) {
+        return
+      }
+
       const $pos = this.resolvedPos.doc.resolve(targetPos)
 
       if (!isBlock && $pos.depth <= this.depth) {

package/src/PasteRule.ts

@@ -267,7 +267,7 @@ export function pasteRulesPlugin(props: { editor: Editor; rules: PasteRule[] }):
             if (!isDroppedFromProseMirror) {
               const dragFromOtherEditor = tiptapDragFromOtherEditor
 
-              if (dragFromOtherEditor) {
+              if (dragFromOtherEditor?.isEditable) {
                 // setTimeout to avoid the wrong content after drop, timeout arg can't be empty or 0
                 setTimeout(() => {
                   const selection = dragFromOtherEditor.state.selection

package/src/commands/cut.ts

@@ -30,7 +30,7 @@ export const cut: RawCommands['cut'] =
 
     tr.insert(newPos, contentSlice.content)
 
-    tr.setSelection(new TextSelection(tr.doc.resolve(newPos - 1)))
+    tr.setSelection(new TextSelection(tr.doc.resolve(Math.max(newPos - 1, 0))))
 
     return true
   }

package/src/commands/insertContentAt.ts

@@ -76,18 +76,10 @@ export const insertContentAt: RawCommands['insertContentAt'] =
       let content: Fragment | ProseMirrorNode
       const { selection } = editor.state
 
-      try {
-        content = createNodeFromContent(value, editor.schema, {
-          parseOptions: {
-            preserveWhitespace: 'full',
-            ...options.parseOptions,
-          },
-          errorOnInvalidContent: options.errorOnInvalidContent ?? editor.options.enableContentCheck,
-        })
-      } catch (e) {
+      const emitContentError = (error: Error) => {
         editor.emit('contentError', {
           editor,
-          error: e as Error,
+          error,
           disableCollaboration: () => {
             if (
               'collaboration' in editor.storage &&
@@ -98,6 +90,33 @@ export const insertContentAt: RawCommands['insertContentAt'] =
             }
           },
         })
+      }
+
+      const parseOptions: ParseOptions = {
+        preserveWhitespace: 'full',
+        ...options.parseOptions,
+      }
+
+      // If `emitContentError` is enabled, we want to check the content for errors
+      // but ignore them (do not remove the invalid content from the document)
+      if (!options.errorOnInvalidContent && !editor.options.enableContentCheck && editor.options.emitContentError) {
+        try {
+          createNodeFromContent(value, editor.schema, {
+            parseOptions,
+            errorOnInvalidContent: true,
+          })
+        } catch (e) {
+          emitContentError(e as Error)
+        }
+      }
+
+      try {
+        content = createNodeFromContent(value, editor.schema, {
+          parseOptions,
+          errorOnInvalidContent: options.errorOnInvalidContent ?? editor.options.enableContentCheck,
+        })
+      } catch (e) {
+        emitContentError(e as Error)
         return false
       }
 
@@ -163,8 +182,9 @@ export const insertContentAt: RawCommands['insertContentAt'] =
 
         const fromSelectionAtStart = selection.$from.parentOffset === 0
         const isTextSelection = selection.$from.node().isText || selection.$from.node().isTextblock
+        const hasContent = selection.$from.node().content.size > 0
 
-        if (fromSelectionAtStart && isTextSelection) {
+        if (fromSelectionAtStart && isTextSelection && hasContent) {
           from = Math.max(0, from - 1)
         }
 

package/src/types.ts

@@ -354,6 +354,27 @@ export interface EditorOptions {
    * @default false
    */
   enableContentCheck: boolean
+  /**
+   * If `true`, the editor will emit the `contentError` event if invalid content is
+   * encountered but `enableContentCheck` is `false`. This lets you preserve the
+   * invalid editor content while still showing a warning or error message to
+   * the user.
+   *
+   * @default false
+   */
+  emitContentError: boolean
+  /**
+   * Enable a lazy-loaded Prosemirror DevTools integration.
+   *
+   * Requires having the `prosemirror-dev-tools` npm package installed.
+   * @type boolean
+   * @default false
+   * @example
+   * ```js
+   * enableDevTools: true
+   * ```
+   */
+  enableDevTools: boolean
   /**
    * Called before the editor is constructed.
    */

package/src/utilities/canInsertNode.ts

@@ -0,0 +1,30 @@
+import type { NodeType } from '@tiptap/pm/model'
+import { type EditorState, NodeSelection } from '@tiptap/pm/state'
+
+export function canInsertNode(state: EditorState, nodeType: NodeType): boolean {
+  const { selection } = state
+  const { $from } = selection
+
+  // Special handling for NodeSelection
+  if (selection instanceof NodeSelection) {
+    const index = $from.index()
+    const parent = $from.parent
+
+    // Can we replace the selected node with the horizontal rule?
+    return parent.canReplaceWith(index, index + 1, nodeType)
+  }
+
+  // Default: check if we can insert at the current position
+  let depth = $from.depth
+
+  while (depth >= 0) {
+    const index = $from.index(depth)
+    const parent = $from.node(depth)
+    const match = parent.contentMatchAt(index)
+    if (match.matchType(nodeType)) {
+      return true
+    }
+    depth -= 1
+  }
+  return false
+}

package/src/utilities/index.ts

@@ -1,4 +1,5 @@
 export * from './callOrReturn.js'
+export * from './canInsertNode.js'
 export * from './createStyleTag.js'
 export * from './deleteProps.js'
 export * from './elementFromString.js'