@prosekit/core 0.9.0 → 0.10.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@prosekit/core",
   "type": "module",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "private": false,
   "description": "Core features for ProseKit",
   "author": {
@@ -40,19 +40,18 @@
     "src"
   ],
   "dependencies": {
-    "@ocavue/utils": "^1.2.0",
+    "@ocavue/utils": "^1.4.0",
     "clsx": "^2.1.1",
     "orderedmap": "^2.1.1",
     "prosemirror-splittable": "^0.1.1",
-    "type-fest": "^5.3.1",
+    "type-fest": "^5.4.3",
     "@prosekit/pm": "^0.1.15"
   },
   "devDependencies": {
-    "@types/diffable-html": "^5.0.2",
-    "diffable-html": "^6.0.1",
-    "tsdown": "^0.17.0",
+    "diffable-html-snapshot": "^0.2.0",
+    "tsdown": "^0.20.1",
     "typescript": "~5.9.3",
-    "vitest": "^4.0.15",
+    "vitest": "^4.0.18",
     "vitest-browser-commands": "^0.2.0",
     "@prosekit/config-vitest": "0.0.0",
     "@prosekit/config-tsdown": "0.0.0"

package/src/commands/add-mark.ts

@@ -1,7 +1,4 @@
-import type {
-  Attrs,
-  MarkType,
-} from '@prosekit/pm/model'
+import type { Attrs, MarkType } from '@prosekit/pm/model'
 import type { Command } from '@prosekit/pm/state'
 
 import type { CommandCreator } from '../types/extension-command'

package/src/commands/expand-mark.ts

@@ -1,12 +1,5 @@
-import type {
-  Mark,
-  MarkType,
-  ResolvedPos,
-} from '@prosekit/pm/model'
-import {
-  TextSelection,
-  type Command,
-} from '@prosekit/pm/state'
+import type { Mark, MarkType, ResolvedPos } from '@prosekit/pm/model'
+import { TextSelection, type Command } from '@prosekit/pm/state'
 
 import { getMarkType } from '../utils/get-mark-type'
 

package/src/commands/insert-default-block.spec.ts

@@ -1,8 +1,4 @@
-import {
-  describe,
-  expect,
-  it,
-} from 'vitest'
+import { describe, expect, it } from 'vitest'
 
 import { setupTest } from '../testing'
 import { inputText } from '../testing/keyboard'

package/src/commands/insert-default-block.ts

@@ -1,7 +1,4 @@
-import {
-  TextSelection,
-  type Command,
-} from '@prosekit/pm/state'
+import { TextSelection, type Command } from '@prosekit/pm/state'
 
 import { defaultBlockAt } from '../utils/default-block-at'
 

package/src/commands/insert-node.ts

@@ -1,10 +1,6 @@
-import type {
-  Attrs,
-  NodeType,
-  ProseMirrorNode,
-} from '@prosekit/pm/model'
+import { Fragment, Slice, type Attrs, type NodeType, type ProseMirrorNode } from '@prosekit/pm/model'
 import type { Command } from '@prosekit/pm/state'
-import { insertPoint } from '@prosekit/pm/transform'
+import { dropPoint } from '@prosekit/pm/transform'
 
 import { assert } from '../utils/assert'
 import { getNodeType } from '../utils/get-node-type'
@@ -52,10 +48,10 @@ function insertNode(options: InsertNodeOptions): Command {
 
     assert(node, 'You must provide either a node or a type')
 
-    const insertPos = insertPoint(
+    const insertPos = dropPoint(
       state.doc,
       options.pos ?? state.selection.anchor,
-      node.type,
+      new Slice(Fragment.from([node]), 0, 0),
     )
     if (insertPos == null) return false
 

package/src/commands/remove-mark.ts

@@ -1,7 +1,4 @@
-import type {
-  Attrs,
-  MarkType,
-} from '@prosekit/pm/model'
+import type { Attrs, MarkType } from '@prosekit/pm/model'
 import type { Command } from '@prosekit/pm/state'
 
 import type { CommandCreator } from '../types/extension-command'

package/src/commands/remove-node.ts

@@ -14,8 +14,8 @@ export interface RemoveNodeOptions {
   type: string | NodeType
 
   /**
-   * The document position to start searching node. By default it will be the
-   * anchor position of current selection.
+   * The document position to start searching for the node. By default, it will
+   * use the anchor position of current selection.
    */
   pos?: number
 }

package/src/commands/select-block.spec.ts

@@ -1,8 +1,4 @@
-import {
-  describe,
-  expect,
-  it,
-} from 'vitest'
+import { describe, expect, it } from 'vitest'
 
 import { setupTest } from '../testing'
 
@@ -67,7 +63,9 @@ describe('selectBlock', () => {
     ))
     expect(getSelectionString()).toMatchInlineSnapshot(`"<paragraph, blockquote(paragraph("Item 1"), blockquote(paragraph("Sub")))>"`)
     editor.exec(selectBlock())
-    expect(getSelectionString()).toMatchInlineSnapshot(`"<paragraph("Hello"), blockquote(paragraph("Item 1"), blockquote(paragraph("Sub item 1.1")))>"`)
+    expect(getSelectionString()).toMatchInlineSnapshot(
+      `"<paragraph("Hello"), blockquote(paragraph("Item 1"), blockquote(paragraph("Sub item 1.1")))>"`,
+    )
   })
 })
 

package/src/commands/select-block.ts

@@ -1,7 +1,4 @@
-import {
-  TextSelection,
-  type Command,
-} from '@prosekit/pm/state'
+import { TextSelection, type Command } from '@prosekit/pm/state'
 
 import { isTextSelection } from '../utils/type-assertion'
 

package/src/commands/set-block-type.ts

@@ -1,7 +1,4 @@
-import type {
-  Attrs,
-  NodeType,
-} from '@prosekit/pm/model'
+import type { Attrs, NodeType } from '@prosekit/pm/model'
 import type { Command } from '@prosekit/pm/state'
 
 import { getCustomSelection } from '../utils/get-custom-selection'

package/src/commands/set-node-attrs-between.spec.ts

@@ -0,0 +1,221 @@
+import { describe, expect, it } from 'vitest'
+
+import { setupTest } from '../testing'
+
+import { setNodeAttrsBetween } from './set-node-attrs-between'
+
+describe('setNodeAttrsBetween', () => {
+  it('should set attributes on multiple nodes in selection range', () => {
+    const { editor, n } = setupTest()
+
+    editor.set(
+      n.doc(
+        n.codeBlock('<a>first block'),
+        n.codeBlock('second block<b>'),
+        n.codeBlock('third block'),
+      ),
+    )
+
+    const command = setNodeAttrsBetween({
+      type: 'codeBlock',
+      attrs: { language: 'rust' },
+    })
+
+    expect(editor.exec(command)).toBe(true)
+
+    expect(editor.state.doc.child(0).attrs.language).toBe('rust')
+    expect(editor.state.doc.child(1).attrs.language).toBe('rust')
+    expect(editor.state.doc.child(2).attrs.language).toBe('')
+  })
+
+  it('should set attributes with explicit from/to positions', () => {
+    const { editor, n } = setupTest()
+
+    editor.set(
+      n.doc(
+        /*0*/
+        n.codeBlock(/*1*/ 'A' /*2*/),
+        /*3*/
+        n.codeBlock(/*4*/ 'B' /*5*/),
+        /*6*/
+        n.codeBlock(/*7*/ 'C' /*8*/),
+        /*9*/
+      ),
+    )
+
+    const command = setNodeAttrsBetween({
+      type: 'codeBlock',
+      attrs: { language: 'go' },
+      from: 5,
+      to: 7,
+    })
+
+    expect(editor.exec(command)).toBe(true)
+
+    expect(editor.state.doc.child(0).attrs.language).toBe('')
+    expect(editor.state.doc.child(1).attrs.language).toBe('go')
+    expect(editor.state.doc.child(2).attrs.language).toBe('go')
+  })
+
+  it('should return false when no matching nodes in range', () => {
+    const { editor, n } = setupTest()
+
+    editor.set(
+      n.doc(
+        n.paragraph('<a>first paragraph'),
+        n.paragraph('second paragraph<b>'),
+      ),
+    )
+
+    const command = setNodeAttrsBetween({
+      type: 'codeBlock',
+      attrs: { language: 'typescript' },
+    })
+
+    expect(editor.exec(command)).toBe(false)
+  })
+
+  it('should return false when from > to', () => {
+    const { editor, n } = setupTest()
+
+    editor.set(n.doc(n.codeBlock('code')))
+
+    const command = setNodeAttrsBetween({
+      type: 'codeBlock',
+      attrs: { language: 'typescript' },
+      from: 10,
+      to: 5,
+    })
+
+    expect(editor.exec(command)).toBe(false)
+  })
+
+  it('should handle empty selection (from === to)', () => {
+    const { editor, n } = setupTest()
+
+    editor.set(n.doc(n.codeBlock('<a>code')))
+
+    const command = setNodeAttrsBetween({
+      type: 'codeBlock',
+      attrs: { language: 'typescript' },
+    })
+
+    expect(editor.exec(command)).toBe(true)
+    expect(editor.state.doc.firstChild?.attrs.language).toBe('typescript')
+  })
+
+  it('should handle partial node overlap', () => {
+    const { editor, n } = setupTest()
+
+    editor.set(
+      n.doc(
+        n.codeBlock('first bl<a>ock'),
+        n.codeBlock('second block'),
+        n.codeBlock('third bl<b>ock'),
+      ),
+    )
+
+    const command = setNodeAttrsBetween({
+      type: 'codeBlock',
+      attrs: { language: 'ruby' },
+    })
+
+    expect(editor.exec(command)).toBe(true)
+
+    expect(editor.state.doc.child(0).attrs.language).toBe('ruby')
+    expect(editor.state.doc.child(1).attrs.language).toBe('ruby')
+    expect(editor.state.doc.child(2).attrs.language).toBe('ruby')
+  })
+
+  it('should update only matching node types in mixed content', () => {
+    const { editor, n } = setupTest()
+
+    editor.set(
+      n.doc(
+        n.paragraph('<a>paragraph 1'),
+        n.codeBlock('code block 1'),
+        n.paragraph('paragraph 2'),
+        n.codeBlock('code block 2'),
+        n.paragraph('paragraph 3<b>'),
+      ),
+    )
+
+    const command = setNodeAttrsBetween({
+      type: 'codeBlock',
+      attrs: { language: 'java' },
+    })
+
+    expect(editor.exec(command)).toBe(true)
+
+    expect(editor.state.doc.child(1).attrs.language).toBe('java')
+    expect(editor.state.doc.child(3).attrs.language).toBe('java')
+  })
+
+  it('should handle nested nodes', () => {
+    const { editor, n } = setupTest()
+
+    const doc1 = n.doc(
+      n.blockquote(
+        { variant: 'variant-0' },
+        n.paragraph('paragraph-0'),
+      ),
+      n.blockquote(
+        { variant: 'variant-1' },
+        n.paragraph('paragraph-1'),
+        n.blockquote(
+          { variant: 'variant-1.1' },
+          n.paragraph('paragraph-1.1<a>'),
+        ),
+      ),
+      n.blockquote(
+        { variant: 'variant-2' },
+        n.paragraph('paragraph-2'),
+      ),
+      n.blockquote(
+        { variant: 'variant-3' },
+        n.paragraph('paragraph-3<b>'),
+        n.blockquote(
+          { variant: 'variant-3.1' },
+          n.paragraph('paragraph-3.1'),
+        ),
+      ),
+    )
+
+    const doc2 = n.doc(
+      n.blockquote(
+        { variant: 'variant-0' },
+        n.paragraph('paragraph-0'),
+      ),
+      n.blockquote(
+        { variant: 'variant-X' },
+        n.paragraph('paragraph-1'),
+        n.blockquote(
+          { variant: 'variant-X' },
+          n.paragraph('paragraph-1.1'),
+        ),
+      ),
+      n.blockquote(
+        { variant: 'variant-X' },
+        n.paragraph('paragraph-2'),
+      ),
+      n.blockquote(
+        { variant: 'variant-X' },
+        n.paragraph('paragraph-3'),
+        n.blockquote(
+          { variant: 'variant-3.1' },
+          n.paragraph('paragraph-3.1'),
+        ),
+      ),
+    )
+
+    editor.set(doc1)
+
+    const command = setNodeAttrsBetween({
+      type: 'blockquote',
+      attrs: { variant: 'variant-X' },
+    })
+
+    expect(editor.exec(command)).toBe(true)
+    expect(editor.getDocJSON()).toEqual(doc2.toJSON())
+  })
+})

package/src/commands/set-node-attrs-between.ts

@@ -0,0 +1,77 @@
+import type { Attrs, NodeType } from '@prosekit/pm/model'
+import type { Command } from '@prosekit/pm/state'
+
+import { getNodeTypes } from '../utils/get-node-types'
+
+/**
+ * @public
+ */
+export interface SetNodeAttrsBetweenOptions {
+  /**
+   * The type of node to set the attributes of.
+   */
+  type: string | NodeType | string[] | NodeType[]
+
+  /**
+   * The attributes to set.
+   */
+  attrs: Attrs
+
+  /**
+   * The position to start searching for nodes. By default, the selection from position will be used.
+   */
+  from?: number
+
+  /**
+   * The position to end searching for nodes. By default, the selection to position will be used.
+   */
+  to?: number
+}
+
+/**
+ * Returns a command that sets the attributes of all matching nodes between the
+ * `from` and `to` positions.
+ *
+ * @param options
+ *
+ * @public
+ */
+export function setNodeAttrsBetween(options: SetNodeAttrsBetweenOptions): Command {
+  return (state, dispatch) => {
+    const from = options.from ?? state.selection.from
+    const to = options.to ?? state.selection.to
+    if (from > to) {
+      return false
+    }
+
+    const nodeTypes = getNodeTypes(state.schema, options.type)
+    const positions: number[] = []
+    let found = false
+
+    state.doc.nodesBetween(from, to, (node, pos) => {
+      if (nodeTypes.includes(node.type)) {
+        positions.push(pos)
+        found = true
+      }
+      if (!dispatch && found) {
+        // Early return to prevent further iteration
+        return false
+      }
+    })
+
+    if (!found) {
+      return false
+    }
+
+    if (dispatch) {
+      const { tr } = state
+      for (const [key, value] of Object.entries(options.attrs)) {
+        for (const pos of positions) {
+          tr.setNodeAttribute(pos, key, value)
+        }
+      }
+      dispatch(tr)
+    }
+    return true
+  }
+}

package/src/commands/set-node-attrs.spec.ts

@@ -0,0 +1,129 @@
+import { describe, expect, it } from 'vitest'
+
+import { setupTest } from '../testing'
+
+import { setNodeAttrs } from './set-node-attrs'
+
+describe('setNodeAttrs', () => {
+  it('should set attributes on a code block node', () => {
+    const { editor, n } = setupTest()
+
+    editor.set(n.doc(n.codeBlock('const x = 1')))
+
+    // Get the initial language attribute (should be empty string by default)
+    expect(editor.state.doc.firstChild?.attrs.language).toBe('')
+
+    // Set the language attribute
+    const command = setNodeAttrs({
+      type: 'codeBlock',
+      attrs: { language: 'typescript' },
+    })
+
+    expect(editor.exec(command)).toBe(true)
+    expect(editor.state.doc.firstChild?.attrs.language).toBe('typescript')
+  })
+
+  it('should set multiple attributes at once', () => {
+    const { editor, n } = setupTest()
+
+    editor.set(n.doc(n.codeBlock('const x = 1')))
+
+    // Verify initial state
+    expect(editor.state.doc.firstChild?.attrs).toMatchObject({
+      language: '',
+      lineNumbers: false,
+    })
+
+    // Set multiple attributes at once
+    const command = setNodeAttrs({
+      type: 'codeBlock',
+      attrs: { language: 'javascript', lineNumbers: true },
+    })
+
+    editor.exec(command)
+
+    // Verify both attributes were set
+    expect(editor.state.doc.firstChild?.attrs).toMatchObject({
+      language: 'javascript',
+      lineNumbers: true,
+    })
+  })
+
+  it('should return false when node type does not match', () => {
+    const { editor, n } = setupTest()
+
+    editor.set(n.doc(n.paragraph('Hello world')))
+
+    const command = setNodeAttrs({
+      type: 'codeBlock',
+      attrs: { language: 'typescript' },
+    })
+
+    // Should return false because paragraph is not a codeBlock
+    expect(editor.exec(command)).toBe(false)
+  })
+
+  it('should set attributes at a specific position', () => {
+    const { editor, n } = setupTest()
+
+    editor.set(
+      n.doc(
+        /*0*/
+        n.codeBlock(/*1*/ 'A' /*2*/),
+        /*3*/
+        n.codeBlock(/*4*/ 'B' /*5*/),
+        /*6*/
+      ),
+    )
+
+    // Set attribute on the second code block (position after first block)
+    const command = setNodeAttrs({
+      type: 'codeBlock',
+      attrs: { language: 'python' },
+      pos: 3, // Position of second code block
+    })
+
+    editor.exec(command)
+
+    // First block should still have default language
+    expect(editor.state.doc.child(0).attrs.language).toBe('')
+    // Second block should have the new language
+    expect(editor.state.doc.child(1).attrs.language).toBe('python')
+  })
+
+  it('should handle cursor inside a node', () => {
+    const { editor, n } = setupTest()
+
+    editor.set(n.doc(n.codeBlock('const<a> x = 1')))
+
+    const command = setNodeAttrs({
+      type: 'codeBlock',
+      attrs: { language: 'typescript' },
+    })
+
+    editor.exec(command)
+
+    expect(editor.state.doc.firstChild?.attrs.language).toBe('typescript')
+  })
+
+  it('should set attrs on wrapping node containing selection', () => {
+    const { editor, n } = setupTest()
+
+    editor.set(
+      n.doc(
+        n.blockquote(
+          n.paragraph('Hello<a> world<b>'),
+        ),
+      ),
+    )
+
+    const command = setNodeAttrs({
+      type: 'blockquote',
+      attrs: { variant: 'fancy' },
+    })
+
+    // Should find the blockquote wrapping the selection
+    expect(editor.exec(command)).toBe(true)
+    expect(editor.state.doc.firstChild?.attrs.variant).toBe('fancy')
+  })
+})

package/src/commands/set-node-attrs.ts

@@ -1,9 +1,7 @@
-import type {
-  Attrs,
-  NodeType,
-} from '@prosekit/pm/model'
+import type { Attrs, NodeType } from '@prosekit/pm/model'
 import type { Command } from '@prosekit/pm/state'
 
+import { findParentNodeOfType } from '../utils/find-parent-node-of-type'
 import { getNodeTypes } from '../utils/get-node-types'
 
 /**
@@ -12,8 +10,6 @@ import { getNodeTypes } from '../utils/get-node-types'
 export interface SetNodeAttrsOptions {
   /**
    * The type of node to set the attributes of.
-   *
-   * If current node is not of this type, the command will do nothing.
    */
   type: string | NodeType | string[] | NodeType[]
 
@@ -23,43 +19,46 @@ export interface SetNodeAttrsOptions {
   attrs: Attrs
 
   /**
-   * The position of the node. Defaults to the position of the wrapping node
-   * containing the current selection.
+   * The document position of the node to update. If not provided, the command
+   * will find the closest ancestor node that matches the type based on the
+   * anchor position of the selection.
    */
   pos?: number
 }
 
 /**
- * Returns a command that set the attributes of the current node.
+ * Returns a command that sets the attributes of the current node.
+ *
+ * @param options
  *
  * @public
  */
-export function setNodeAttrs(options: SetNodeAttrsOptions): Command {
+export function setNodeAttrs({ type, attrs, pos }: SetNodeAttrsOptions): Command {
   return (state, dispatch) => {
-    const nodeTypes = getNodeTypes(state.schema, options.type)
-    const from = options.pos ?? state.selection.from
-    const to = options.pos ?? state.selection.to
-    const positions: number[] = []
+    let updatePos: number
 
-    state.doc.nodesBetween(from, to, (node, pos) => {
-      if (nodeTypes.includes(node.type)) {
-        positions.push(pos)
+    if (pos == null) {
+      const found = findParentNodeOfType(type, state.selection.$anchor)
+      if (!found) {
+        return false
       }
-      if (!dispatch && positions.length > 0) {
+      updatePos = found.pos
+    } else {
+      const found = state.doc.nodeAt(pos)
+      if (!found) {
         return false
       }
-    })
-
-    if (positions.length === 0) {
-      return false
+      const nodeTypes = getNodeTypes(state.schema, type)
+      if (!nodeTypes.includes(found.type)) {
+        return false
+      }
+      updatePos = pos
     }
 
     if (dispatch) {
       const { tr } = state
-      for (const pos of positions) {
-        for (const [key, value] of Object.entries(options.attrs)) {
-          tr.setNodeAttribute(pos, key, value)
-        }
+      for (const [key, value] of Object.entries(attrs)) {
+        tr.setNodeAttribute(updatePos, key, value)
       }
       dispatch(tr)
     }