@tiptap/core 3.22.0 → 3.22.2

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tiptap/core",
   "description": "headless rich text editor",
-  "version": "3.22.0",
+  "version": "3.22.2",
   "homepage": "https://tiptap.dev",
   "keywords": [
     "tiptap",
@@ -52,10 +52,10 @@
     "jsx-dev-runtime"
   ],
   "devDependencies": {
-    "@tiptap/pm": "^3.22.0"
+    "@tiptap/pm": "^3.22.2"
   },
   "peerDependencies": {
-    "@tiptap/pm": "^3.22.0"
+    "@tiptap/pm": "^3.22.2"
   },
   "repository": {
     "type": "git",

package/src/NodeView.ts

@@ -173,6 +173,7 @@ export class NodeView<
     }
 
     const isDragEvent = event.type.startsWith('drag')
+    const isDragOverEnterEvent = event.type === 'dragover' || event.type === 'dragenter'
     const isDropEvent = event.type === 'drop'
     const isInput = ['INPUT', 'BUTTON', 'SELECT', 'TEXTAREA'].includes(target.tagName) || target.isContentEditable
 
@@ -237,7 +238,15 @@ export class NodeView<
     }
 
     // these events are handled by prosemirror
-    if (isDragging || isDropEvent || isCopyEvent || isPasteEvent || isCutEvent || (isClickEvent && isSelectable)) {
+    if (
+      isDragging ||
+      isDragOverEnterEvent ||
+      isDropEvent ||
+      isCopyEvent ||
+      isPasteEvent ||
+      isCutEvent ||
+      (isClickEvent && isSelectable)
+    ) {
       return false
     }
 

package/src/commands/toggleList.ts

@@ -1,5 +1,6 @@
 import type { NodeType } from '@tiptap/pm/model'
 import type { Transaction } from '@tiptap/pm/state'
+import { TextSelection } from '@tiptap/pm/state'
 import { canJoin } from '@tiptap/pm/transform'
 
 import { findParentNode } from '../helpers/findParentNode.js'
@@ -78,6 +79,21 @@ declare module '@tiptap/core' {
   }
 }
 
+function createInnerSelectionForWholeDocList(tr: Transaction) {
+  const doc = tr.doc
+  const list = doc.firstChild
+
+  if (!list) {
+    return null
+  }
+
+  // Place the selection inside the list node so that ProseMirror's
+  // liftListItem command can operate. AllSelection sits at the doc root.
+  const from = 1
+  const to = list.nodeSize - 1
+
+  return TextSelection.create(doc, from, to)
+}
 export const toggleList: RawCommands['toggleList'] =
   (listTypeOrName, itemTypeOrName, keepMarks, attributes = {}) =>
   ({ editor, tr, state, dispatch, chain, commands, can }) => {
@@ -96,17 +112,65 @@ export const toggleList: RawCommands['toggleList'] =
 
     const parentList = findParentNode(node => isList(node.type.name, extensions))(selection)
 
-    if (range.depth >= 1 && parentList && range.depth - parentList.depth <= 1) {
+    // When the user presses Ctrl/Cmd+A, ProseMirror creates an `AllSelection`
+    // covering the entire document (0..doc.content.size). In that case
+    // `findParentNode` cannot detect the surrounding list because the
+    // selection sits at the document root. If the document consists of a
+    // single top-level list node, treat that list as the active list so the
+    // toggle logic can correctly lift or change it.
+    const isAllSelection = selection.from === 0 && selection.to === state.doc.content.size
+    const topLevelNodes = state.doc.content.content
+    const soleTopLevelNode = topLevelNodes.length === 1 ? topLevelNodes[0] : null
+    const allSelectionList =
+      isAllSelection && soleTopLevelNode && isList(soleTopLevelNode.type.name, extensions)
+        ? {
+            node: soleTopLevelNode,
+            pos: 0,
+            depth: 0,
+          }
+        : null
+
+    const currentList = parentList ?? allSelectionList
+
+    const isInsideExistingList = !!parentList && range.depth >= 1 && range.depth - parentList.depth <= 1
+
+    const hasWholeDocSelectedList = !!allSelectionList
+    if ((isInsideExistingList || hasWholeDocSelectedList) && currentList) {
       // remove list
-      if (parentList.node.type === listType) {
+      if (currentList.node.type === listType) {
+        if (isAllSelection && hasWholeDocSelectedList) {
+          return chain()
+            .command(({ tr: trx, dispatch: disp }) => {
+              // Ctrl/Cmd+A creates an AllSelection at the document root.
+              // When the whole document is a single top-level list, normalize the
+              // selection into that list before lifting, since liftListItem expects
+              // a selection inside a list item.
+              const nextSelection = createInnerSelectionForWholeDocList(trx)
+
+              if (!nextSelection) {
+                return false
+              }
+
+              trx.setSelection(nextSelection)
+
+              if (disp) {
+                disp(trx)
+              }
+
+              return true
+            })
+            .liftListItem(itemType)
+            .run()
+        }
+
         return commands.liftListItem(itemType)
       }
 
       // change list type
-      if (isList(parentList.node.type.name, extensions) && listType.validContent(parentList.node.content) && dispatch) {
+      if (isList(currentList.node.type.name, extensions) && listType.validContent(currentList.node.content)) {
         return chain()
           .command(() => {
-            tr.setNodeMarkup(parentList.pos, listType)
+            tr.setNodeMarkup(currentList.pos, listType)
 
             return true
           })
@@ -115,17 +179,16 @@ export const toggleList: RawCommands['toggleList'] =
           .run()
       }
     }
+
     if (!keepMarks || !marks || !dispatch) {
       return (
         chain()
           // try to convert node to default node if needed
           .command(() => {
             const canWrapInList = can().wrapInList(listType, attributes)
-
             if (canWrapInList) {
               return true
             }
-
             return commands.clearNodes()
           })
           .wrapInList(listType, attributes)
@@ -148,7 +211,6 @@ export const toggleList: RawCommands['toggleList'] =
           if (canWrapInList) {
             return true
           }
-
           return commands.clearNodes()
         })
         .wrapInList(listType, attributes)

package/src/pasteRules/markPasteRule.ts

@@ -64,7 +64,16 @@ export function markPasteRule(config: {
 
         tr.addMark(range.from + startSpaces, markEnd, config.type.create(attributes || {}))
 
-        tr.removeStoredMark(config.type)
+        // Only remove the stored mark if the match is not at the end of the
+        // pasted text. When a mark extends to the end of the content, removing
+        // it overrides the mark's `inclusive` behavior and incorrectly places
+        // the cursor outside the mark.
+        const isMatchAtEndOfText =
+          match.index !== undefined && match.input !== undefined && match.index + match[0].length >= match.input.length
+
+        if (!isMatchAtEndOfText) {
+          tr.removeStoredMark(config.type)
+        }
       }
     },
   })

package/src/utilities/index.ts

@@ -23,5 +23,6 @@ export * as markdown from './markdown/index.js'
 export * from './mergeAttributes.js'
 export * from './mergeDeep.js'
 export * from './minMax.js'
+export * from './nodeViewPositionRegistry.js'
 export * from './objectIncludes.js'
 export * from './removeDuplicates.js'

package/src/utilities/nodeViewPositionRegistry.ts

@@ -0,0 +1,70 @@
+import type { Editor } from '../Editor.js'
+
+/**
+ * Per-editor registry for centralized NodeView position-change checks.
+ * A single editor.on('update') listener + rAF is shared across all NodeViews
+ * for a given editor, keeping overhead bounded regardless of NodeView count.
+ *
+ * This is consumed by React, Vue 3, and Vue 2 NodeView renderers.
+ */
+interface PositionUpdateRegistry {
+  callbacks: Set<() => void>
+  rafId: number | null
+  handler: () => void
+}
+
+const positionUpdateRegistries = new WeakMap<Editor, PositionUpdateRegistry>()
+
+/**
+ * Register a callback to be called (via a shared rAF) after every editor
+ * update transaction. If this is the first registration for the given editor,
+ * a new registry entry and a single `editor.on('update')` listener are created.
+ */
+export function schedulePositionCheck(editor: Editor, callback: () => void): void {
+  let registry = positionUpdateRegistries.get(editor)
+
+  if (!registry) {
+    const newRegistry: PositionUpdateRegistry = {
+      callbacks: new Set(),
+      rafId: null,
+      handler: () => {
+        if (newRegistry.rafId !== null) {
+          cancelAnimationFrame(newRegistry.rafId)
+        }
+        newRegistry.rafId = requestAnimationFrame(() => {
+          newRegistry.rafId = null
+          newRegistry.callbacks.forEach(cb => cb())
+        })
+      },
+    }
+
+    positionUpdateRegistries.set(editor, newRegistry)
+    editor.on('update', newRegistry.handler)
+    registry = newRegistry
+  }
+
+  registry.callbacks.add(callback)
+}
+
+/**
+ * Unregister a previously registered callback. When the last callback for an
+ * editor is removed, the shared listener and any pending rAF are also cleaned up.
+ */
+export function cancelPositionCheck(editor: Editor, callback: () => void): void {
+  const registry = positionUpdateRegistries.get(editor)
+
+  if (!registry) {
+    return
+  }
+
+  registry.callbacks.delete(callback)
+
+  if (registry.callbacks.size === 0) {
+    if (registry.rafId !== null) {
+      cancelAnimationFrame(registry.rafId)
+    }
+
+    editor.off('update', registry.handler)
+    positionUpdateRegistries.delete(editor)
+  }
+}