@prosekit/core 0.9.0 → 0.11.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@prosekit/core",
   "type": "module",
-  "version": "0.9.0",
+  "version": "0.11.0",
   "private": false,
   "description": "Core features for ProseKit",
   "author": {
@@ -40,22 +40,22 @@
     "src"
   ],
   "dependencies": {
-    "@ocavue/utils": "^1.2.0",
+    "@ocavue/utils": "^1.6.0",
     "clsx": "^2.1.1",
     "orderedmap": "^2.1.1",
     "prosemirror-splittable": "^0.1.1",
-    "type-fest": "^5.3.1",
+    "type-fest": "^5.5.0",
     "@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.21.4",
     "typescript": "~5.9.3",
-    "vitest": "^4.0.15",
+    "vitest": "^4.1.1",
     "vitest-browser-commands": "^0.2.0",
-    "@prosekit/config-vitest": "0.0.0",
-    "@prosekit/config-tsdown": "0.0.0"
+    "@prosekit/config-tsdown": "0.0.0",
+    "@prosekit/config-ts": "0.0.0",
+    "@prosekit/config-vitest": "0.0.0"
   },
   "publishConfig": {
     "dev": {}

package/src/commands/add-mark.ts

@@ -1,11 +1,8 @@
-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'
-import { getMarkType } from '../utils/get-mark-type'
+import type { CommandCreator } from '../types/extension-command.ts'
+import { getMarkType } from '../utils/get-mark-type.ts'
 
 /**
  * @public

package/src/commands/expand-mark.ts

@@ -1,14 +1,7 @@
-import type {
-  Mark,
-  MarkType,
-  ResolvedPos,
-} from '@prosekit/pm/model'
-import {
-  TextSelection,
-  type Command,
-} from '@prosekit/pm/state'
-
-import { getMarkType } from '../utils/get-mark-type'
+import type { Mark, MarkType, ResolvedPos } from '@prosekit/pm/model'
+import { TextSelection, type Command } from '@prosekit/pm/state'
+
+import { getMarkType } from '../utils/get-mark-type.ts'
 
 /**
  * @public

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

@@ -1,13 +1,9 @@
-import {
-  describe,
-  expect,
-  it,
-} from 'vitest'
+import { describe, expect, it } from 'vitest'
 
-import { setupTest } from '../testing'
-import { inputText } from '../testing/keyboard'
+import { setupTest } from '../testing/index.ts'
+import { inputText } from '../testing/keyboard.ts'
 
-import { insertDefaultBlock } from './insert-default-block'
+import { insertDefaultBlock } from './insert-default-block.ts'
 
 describe('insertDefaultBlock', () => {
   const { editor, n } = setupTest()

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

@@ -1,9 +1,6 @@
-import {
-  TextSelection,
-  type Command,
-} from '@prosekit/pm/state'
+import { TextSelection, type Command } from '@prosekit/pm/state'
 
-import { defaultBlockAt } from '../utils/default-block-at'
+import { defaultBlockAt } from '../utils/default-block-at.ts'
 
 /**
  * @public

package/src/commands/insert-node.ts

@@ -1,14 +1,10 @@
-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'
-import { setSelectionAround } from '../utils/set-selection-around'
+import { assert } from '../utils/assert.ts'
+import { getNodeType } from '../utils/get-node-type.ts'
+import { setSelectionAround } from '../utils/set-selection-around.ts'
 
 /**
  * @public
@@ -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,11 +1,8 @@
-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'
-import { getMarkType } from '../utils/get-mark-type'
+import type { CommandCreator } from '../types/extension-command.ts'
+import { getMarkType } from '../utils/get-mark-type.ts'
 
 /**
  * @public

package/src/commands/remove-node.ts

@@ -1,8 +1,8 @@
 import type { NodeType } from '@prosekit/pm/model'
 import type { Command } from '@prosekit/pm/state'
 
-import type { CommandCreator } from '../types/extension-command'
-import { findParentNodeOfType } from '../utils/find-parent-node-of-type'
+import type { CommandCreator } from '../types/extension-command.ts'
+import { findParentNodeOfType } from '../utils/find-parent-node-of-type.ts'
 
 /**
  * @public
@@ -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,12 +1,8 @@
-import {
-  describe,
-  expect,
-  it,
-} from 'vitest'
+import { describe, expect, it } from 'vitest'
 
-import { setupTest } from '../testing'
+import { setupTest } from '../testing/index.ts'
 
-import { selectBlock } from './select-block'
+import { selectBlock } from './select-block.ts'
 
 describe('selectBlock', () => {
   it('should expand the text selection to cover the start of the paragraph', () => {
@@ -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,9 +1,6 @@
-import {
-  TextSelection,
-  type Command,
-} from '@prosekit/pm/state'
+import { TextSelection, type Command } from '@prosekit/pm/state'
 
-import { isTextSelection } from '../utils/type-assertion'
+import { isTextSelection } from '../utils/type-assertion.ts'
 
 // Based on https://github.com/ProseMirror/prosemirror-commands/blob/1.7.1/src/commands.ts#L507-L521
 function getTextblockEndpoint(selection: TextSelection, side: number): number | undefined {

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

@@ -1,11 +1,8 @@
-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'
-import { getNodeType } from '../utils/get-node-type'
+import { getCustomSelection } from '../utils/get-custom-selection.ts'
+import { getNodeType } from '../utils/get-node-type.ts'
 
 /**
  * @public

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

@@ -0,0 +1,221 @@
+import { describe, expect, it } from 'vitest'
+
+import { setupTest } from '../testing/index.ts'
+
+import { setNodeAttrsBetween } from './set-node-attrs-between.ts'
+
+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.ts'
+
+/**
+ * @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/index.ts'
+
+import { setNodeAttrs } from './set-node-attrs.ts'
+
+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')
+  })
+})