@prosekit/core 0.8.7 → 0.10.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@prosekit/core",
   "type": "module",
-  "version": "0.8.7",
+  "version": "0.10.0",
   "private": false,
   "description": "Core features for ProseKit",
   "author": {
@@ -40,24 +40,21 @@
     "src"
   ],
   "dependencies": {
-    "@ocavue/utils": "^0.8.1",
+    "@ocavue/utils": "^1.4.0",
     "clsx": "^2.1.1",
-    "just-clone": "^6.2.0",
-    "just-map-values": "^3.2.0",
     "orderedmap": "^2.1.1",
     "prosemirror-splittable": "^0.1.1",
-    "type-fest": "^5.2.0",
-    "@prosekit/pm": "^0.1.14"
+    "type-fest": "^5.4.3",
+    "@prosekit/pm": "^0.1.15"
   },
   "devDependencies": {
-    "@types/diffable-html": "^5.0.2",
-    "diffable-html": "^6.0.1",
-    "tsdown": "^0.16.5",
+    "diffable-html-snapshot": "^0.2.0",
+    "tsdown": "^0.20.1",
     "typescript": "~5.9.3",
-    "vitest": "^4.0.10",
+    "vitest": "^4.0.18",
     "vitest-browser-commands": "^0.2.0",
-    "@prosekit/config-tsdown": "0.0.0",
-    "@prosekit/config-vitest": "0.0.0"
+    "@prosekit/config-vitest": "0.0.0",
+    "@prosekit/config-tsdown": "0.0.0"
   },
   "publishConfig": {
     "dev": {}

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-all.ts

@@ -1,7 +1,5 @@
-import {
-  AllSelection,
-  type Command,
-} from '@prosekit/pm/state'
+import { selectAll as selectAllCommand } from '@prosekit/pm/commands'
+import type { Command } from '@prosekit/pm/state'
 
 /**
  * Returns a command that selects the whole document.
@@ -9,8 +7,5 @@ import {
  * @public
  */
 export function selectAll(): Command {
-  return (state, dispatch) => {
-    dispatch?.(state.tr.setSelection(new AllSelection(state.doc)))
-    return true
-  }
+  return selectAllCommand
 }

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

@@ -0,0 +1,81 @@
+import { describe, expect, it } from 'vitest'
+
+import { setupTest } from '../testing'
+
+import { selectBlock } from './select-block'
+
+describe('selectBlock', () => {
+  it('should expand the text selection to cover the start of the paragraph', () => {
+    const { editor, n, getSelectionString } = setup()
+    editor.set(n.doc(n.paragraph('Hello <a>world<b>')))
+    expect(getSelectionString()).toMatchInlineSnapshot(`"<paragraph("world")>"`)
+    editor.exec(selectBlock())
+    expect(getSelectionString()).toMatchInlineSnapshot(`"<paragraph("Hello world")>"`)
+  })
+
+  it('should expand the text selection to cover the end of the paragraph', () => {
+    const { editor, n, getSelectionString } = setup()
+    editor.set(n.doc(n.paragraph('<a>Hello<b> world')))
+    expect(getSelectionString()).toMatchInlineSnapshot(`"<paragraph("Hello")>"`)
+    editor.exec(selectBlock())
+    expect(getSelectionString()).toMatchInlineSnapshot(`"<paragraph("Hello world")>"`)
+  })
+
+  it('should expand the text selection to include other marks', () => {
+    const { editor, n, m, getSelectionString } = setup()
+    editor.set(n.doc(n.paragraph(
+      m.bold('Bold'),
+      ' ',
+      m.italic('Italic<a>'),
+      ' ',
+      m.bold('Bold'),
+    )))
+    expect(getSelectionString()).toMatchInlineSnapshot(`"<>"`)
+    editor.exec(selectBlock())
+    expect(getSelectionString()).toMatchInlineSnapshot(`"<paragraph(bold("Bold"), " ", italic("Italic"), " ", bold("Bold"))>"`)
+  })
+
+  it('should expand the text selection to include multiple blocks', () => {
+    const { editor, n, getSelectionString } = setup()
+    editor.set(n.doc(
+      n.paragraph('Hello<a>'),
+      n.paragraph('World'),
+      n.paragraph('<b>!'),
+    ))
+    expect(getSelectionString()).toMatchInlineSnapshot(`"<paragraph, paragraph("World"), paragraph>"`)
+    editor.exec(selectBlock())
+    expect(getSelectionString()).toMatchInlineSnapshot(`"<paragraph("Hello"), paragraph("World"), paragraph("!")>"`)
+  })
+
+  it('is able to expand the text selection pointing to different depths', () => {
+    const { editor, n, getSelectionString } = setup()
+    editor.set(n.doc(
+      n.paragraph('Hello<a>'),
+      n.blockquote([
+        n.paragraph('Item 1'),
+        n.blockquote([
+          n.paragraph('Sub<b> item 1.1'),
+        ]),
+      ]),
+      n.blockquote([
+        n.paragraph('Item 2'),
+      ]),
+    ))
+    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")))>"`,
+    )
+  })
+})
+
+function setup() {
+  const { editor, n, m } = setupTest()
+
+  const getSelectionString = () => {
+    const fragment = editor.state.selection.content().content
+    return fragment.toString()
+  }
+
+  return { editor, n, m, getSelectionString }
+}

package/src/commands/select-block.ts

@@ -0,0 +1,56 @@
+import { TextSelection, type Command } from '@prosekit/pm/state'
+
+import { isTextSelection } from '../utils/type-assertion'
+
+// 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 {
+  const $pos = side < 0 ? selection.$from : selection.$to
+  let depth = $pos.depth
+  while ($pos.node(depth).isInline) {
+    if (!depth) {
+      return
+    }
+    depth--
+  }
+  if (!$pos.node(depth).isTextblock) {
+    return
+  }
+  return side < 0 ? $pos.start(depth) : $pos.end(depth)
+}
+
+/**
+ * @internal
+ */
+export const selectBlockCommand: Command = (state, dispatch) => {
+  const { selection } = state
+  if (!isTextSelection(selection)) {
+    return false
+  }
+
+  const expectedFrom = getTextblockEndpoint(selection, -1)
+  const expectedTo = getTextblockEndpoint(selection, 1)
+  if (expectedFrom == null || expectedTo == null) {
+    return false
+  }
+
+  if (selection.from <= expectedFrom && selection.to >= expectedTo) {
+    return false
+  }
+
+  if (dispatch) {
+    const newSelection = TextSelection.create(state.doc, expectedFrom, expectedTo)
+    dispatch(state.tr.setSelection(newSelection))
+  }
+  return true
+}
+
+/**
+ * Returns a command to expand the text selection to cover the current block
+ * node. If the text selection spans multiple blocks, it will select all
+ * blocks in the selection.
+ *
+ * @public
+ */
+export function selectBlock(): Command {
+  return selectBlockCommand
+}

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
+  }
+}