@prosekit/core 0.8.3 → 0.8.4

package/src/commands/add-mark.ts

@@ -0,0 +1,53 @@
+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'
+
+/**
+ * @public
+ */
+export interface AddMarkOptions {
+  /**
+   * The type of the mark to add.
+   */
+  type: string | MarkType
+
+  /**
+   * The attributes of the mark to add.
+   */
+  attrs?: Attrs | null
+
+  /**
+   * The start position of the document. By default it will be the start position of current selection.
+   */
+  from?: number
+
+  /**
+   * The end position of the document. By default it will be the end position of current selection.
+   */
+  to?: number
+}
+
+/**
+ * Returns a command that adds the given mark with the given attributes.
+ *
+ * @public
+ */
+export function addMark(options: AddMarkOptions): Command {
+  return (state, dispatch) => {
+    const mark = getMarkType(state.schema, options.type).create(options.attrs)
+    const from = options.from ?? state.selection.from
+    const to = options.to ?? state.selection.to
+    if (from > to) {
+      return false
+    }
+    dispatch?.(state.tr.addMark(from, to, mark))
+    return true
+  }
+}
+
+addMark satisfies CommandCreator

package/src/commands/expand-mark.ts

@@ -0,0 +1,96 @@
+import type {
+  Mark,
+  MarkType,
+  ResolvedPos,
+} from '@prosekit/pm/model'
+import {
+  TextSelection,
+  type Command,
+} from '@prosekit/pm/state'
+
+import { getMarkType } from '../utils/get-mark-type'
+
+/**
+ * @public
+ */
+export interface ExpandMarkOptions {
+  /**
+   * The type of the mark to expand.
+   */
+  type: string | MarkType
+}
+
+/**
+ * Expands the selection to include the entire mark at the current position.
+ *
+ * @public
+ */
+export function expandMark(options: ExpandMarkOptions): Command {
+  return (state, dispatch) => {
+    const markType = getMarkType(state.schema, options.type)
+    const predicate = (mark: Mark) => mark.type === markType
+
+    const from = expandMarkBefore(state.selection.$from, predicate)
+    const to = expandMarkAfter(state.selection.$to, predicate)
+
+    if (from === state.selection.from && to === state.selection.to) {
+      return false
+    }
+
+    if (dispatch) {
+      dispatch(state.tr.setSelection(TextSelection.create(state.doc, from, to)))
+    }
+    return true
+  }
+}
+
+function expandMarkBefore(
+  $pos: ResolvedPos,
+  predicate: (mark: Mark) => boolean,
+): number {
+  const { parent } = $pos
+
+  if (!$pos.marks().some(predicate)) {
+    return $pos.pos
+  }
+
+  const index = $pos.index()
+  let boundaryIndex = index
+
+  for (let i = index; i >= 0; i--) {
+    const node = parent.child(i)
+    if (node.marks.some(predicate)) {
+      boundaryIndex = i
+    } else {
+      break
+    }
+  }
+
+  return $pos.posAtIndex(boundaryIndex)
+}
+
+function expandMarkAfter(
+  $pos: ResolvedPos,
+  predicate: (mark: Mark) => boolean,
+): number {
+  const { parent } = $pos
+
+  if (!$pos.marks().some(predicate)) {
+    return $pos.pos
+  }
+
+  const index = Math.max(0, $pos.indexAfter() - 1)
+  const childCount = parent.childCount
+  let boundaryIndex = index
+
+  for (let i = index; i < childCount; i++) {
+    const node = parent.child(i)
+    if (node.marks.some(predicate)) {
+      boundaryIndex = i
+    } else {
+      break
+    }
+  }
+
+  return $pos.posAtIndex(boundaryIndex) + parent.child(boundaryIndex).nodeSize
+}

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

@@ -0,0 +1,102 @@
+import {
+  describe,
+  expect,
+  it,
+} from 'vitest'
+
+import { setupTest } from '../testing'
+import { inputText } from '../testing/keyboard'
+
+import { insertDefaultBlock } from './insert-default-block'
+
+describe('insertDefaultBlock', () => {
+  const { editor, n } = setupTest()
+  const doc = n.doc(
+    /*0*/
+    n.p(/*1*/ 'ab' /*3*/),
+    /*4*/
+    n.p(/*5*/ 'cd' /*7*/),
+    /*8*/
+  )
+
+  it('can insert a default block before the first text block', async () => {
+    editor.set(doc)
+    editor.exec(insertDefaultBlock({ pos: 0 }))
+    expect(editor.state.doc.toJSON()).toEqual(
+      n.doc(n.p(), n.p('ab'), n.p('cd')).toJSON(),
+    )
+    await inputText('x')
+    expect(editor.state.doc.toJSON()).toEqual(
+      n.doc(n.p('x'), n.p('ab'), n.p('cd')).toJSON(),
+    )
+  })
+
+  it('can insert a default block between two text blocks', async () => {
+    editor.set(doc)
+    editor.exec(insertDefaultBlock({ pos: 4 }))
+    expect(editor.state.doc.toJSON()).toEqual(
+      n.doc(n.p('ab'), n.p(), n.p('cd')).toJSON(),
+    )
+    await inputText('x')
+    expect(editor.state.doc.toJSON()).toEqual(
+      n.doc(n.p('ab'), n.p('x'), n.p('cd')).toJSON(),
+    )
+  })
+
+  it('can insert a default block after the last text block', async () => {
+    editor.set(doc)
+    editor.exec(insertDefaultBlock({ pos: 8 }))
+    expect(editor.state.doc.toJSON()).toEqual(
+      n.doc(n.p('ab'), n.p('cd'), n.p()).toJSON(),
+    )
+    await inputText('x')
+    expect(editor.state.doc.toJSON()).toEqual(
+      n.doc(n.p('ab'), n.p('cd'), n.p('x')).toJSON(),
+    )
+  })
+
+  it('can insert a default block after current text block', async () => {
+    for (const pos of [1, 2, 3]) {
+      editor.set(doc)
+      editor.exec(insertDefaultBlock({ pos }))
+      expect(editor.state.doc.toJSON()).toEqual(
+        n.doc(n.p('ab'), n.p(), n.p('cd')).toJSON(),
+      )
+      await inputText('x')
+      expect(editor.state.doc.toJSON()).toEqual(
+        n.doc(n.p('ab'), n.p('x'), n.p('cd')).toJSON(),
+      )
+    }
+
+    for (const pos of [5, 6, 7]) {
+      editor.set(doc)
+      editor.exec(insertDefaultBlock({ pos }))
+      expect(editor.state.doc.toJSON()).toEqual(
+        n.doc(n.p('ab'), n.p('cd'), n.p()).toJSON(),
+      )
+      await inputText('x')
+      expect(editor.state.doc.toJSON()).toEqual(
+        n.doc(n.p('ab'), n.p('cd'), n.p('x')).toJSON(),
+      )
+    }
+  })
+
+  it('can insert a default block after current selection', async () => {
+    const doc = n.doc(
+      /*0*/
+      n.p(/*1*/ 'a<a>b' /*3*/),
+      /*4*/
+      n.p(/*5*/ 'cd' /*7*/),
+      /*8*/
+    )
+    editor.set(doc)
+    editor.exec(insertDefaultBlock())
+    expect(editor.state.doc.toJSON()).toEqual(
+      n.doc(n.p('ab'), n.p(), n.p('cd')).toJSON(),
+    )
+    await inputText('x')
+    expect(editor.state.doc.toJSON()).toEqual(
+      n.doc(n.p('ab'), n.p('x'), n.p('cd')).toJSON(),
+    )
+  })
+})

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

@@ -0,0 +1,49 @@
+import {
+  TextSelection,
+  type Command,
+} from '@prosekit/pm/state'
+
+import { defaultBlockAt } from '../utils/default-block-at'
+
+/**
+ * @public
+ */
+export interface InsertDefaultBlockOptions {
+  /**
+   * The position to insert the node at. By default it will insert after the
+   * current selection.
+   */
+  pos?: number
+}
+
+/**
+ * Returns a command that inserts a default block after current selection or at
+ * the given position.
+ *
+ * @public
+ */
+export function insertDefaultBlock(
+  options?: InsertDefaultBlockOptions,
+): Command {
+  return (state, dispatch) => {
+    const $pos = options?.pos == null
+      ? state.selection.$to
+      : state.doc.resolve(options.pos)
+    const depth = $pos.parent.isTextblock ? $pos.depth - 1 : $pos.depth
+    const parent = $pos.node(depth)
+    const index = $pos.indexAfter(depth)
+    const type = defaultBlockAt(parent.contentMatchAt(index))
+    if (!type) return false
+    if (dispatch) {
+      const pos = $pos.posAtIndex(index, depth)
+      const node = type.createAndFill()
+      if (!node) return false
+      const tr = state.tr.insert(pos, node)
+      const selection = TextSelection.findFrom(tr.doc.resolve(pos), 1)
+      if (!selection) return false
+      tr.setSelection(selection)
+      dispatch(tr.scrollIntoView())
+    }
+    return true
+  }
+}

package/src/commands/insert-node.ts

@@ -0,0 +1,71 @@
+import type {
+  Attrs,
+  NodeType,
+  ProseMirrorNode,
+} from '@prosekit/pm/model'
+import type { Command } from '@prosekit/pm/state'
+import { insertPoint } from '@prosekit/pm/transform'
+
+import { assert } from '../utils/assert'
+import { getNodeType } from '../utils/get-node-type'
+import { setSelectionAround } from '../utils/set-selection-around'
+
+/**
+ * @public
+ */
+export interface InsertNodeOptions {
+  /**
+   * The node to insert. Either this or `type` must be provided.
+   */
+  node?: ProseMirrorNode
+
+  /**
+   * The type of the node to insert. Either this or `node` must be provided.
+   */
+  type?: string | NodeType
+
+  /**
+   * When `type` is provided, the attributes of the node to insert.
+   */
+  attrs?: Attrs
+
+  /**
+   * The position to insert the node at. By default it will be the anchor
+   * position of current selection.
+   */
+  pos?: number
+}
+
+/**
+ * Returns a command that inserts the given node at the current selection or at
+ * the given position.
+ *
+ * @public
+ */
+function insertNode(options: InsertNodeOptions): Command {
+  return (state, dispatch) => {
+    const node = options.node
+      ? options.node
+      : options.type
+      ? getNodeType(state.schema, options.type).createAndFill(options.attrs)
+      : null
+
+    assert(node, 'You must provide either a node or a type')
+
+    const insertPos = insertPoint(
+      state.doc,
+      options.pos ?? state.selection.anchor,
+      node.type,
+    )
+    if (insertPos == null) return false
+
+    if (dispatch) {
+      const tr = state.tr.insert(insertPos, node)
+      setSelectionAround(tr, insertPos + node.nodeSize)
+      dispatch(tr)
+    }
+    return true
+  }
+}
+
+export { insertNode }

package/src/commands/insert-text.ts

@@ -0,0 +1,24 @@
+import type { Command } from '@prosekit/pm/state'
+
+/**
+ * @public
+ */
+export type InsertTextOptions = {
+  text: string
+  from?: number
+  to?: number
+}
+
+/**
+ * Returns a command that inserts the given text.
+ *
+ * @public
+ */
+export function insertText({ text, from, to }: InsertTextOptions): Command {
+  return (state, dispatch) => {
+    if (text) {
+      dispatch?.(state.tr.insertText(text, from, to))
+    }
+    return true
+  }
+}

package/src/commands/remove-mark.ts

@@ -0,0 +1,54 @@
+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'
+
+/**
+ * @public
+ */
+export interface RemoveMarkOptions {
+  /**
+   * The type of the mark to remove.
+   */
+  type: string | MarkType
+
+  /**
+   * If attrs is given, remove precisely the mark with the given attrs. Otherwise, remove all marks of the given type.
+   */
+  attrs?: Attrs | null
+
+  /**
+   * The start position of the document. By default it will be the start position of current selection.
+   */
+  from?: number
+
+  /**
+   * The end position of the document. By default it will be the end position of current selection.
+   */
+  to?: number
+}
+
+/**
+ * Returns a command that removes the given mark.
+ *
+ * @public
+ */
+export function removeMark(options: RemoveMarkOptions): Command {
+  return (state, dispatch) => {
+    const markType = getMarkType(state.schema, options.type)
+    const mark = options.attrs ? markType.create(options.attrs) : markType
+    const from = options.from ?? state.selection.from
+    const to = options.to ?? state.selection.to
+    if (from > to) {
+      return false
+    }
+    dispatch?.(state.tr.removeMark(from, to, mark))
+    return true
+  }
+}
+
+removeMark satisfies CommandCreator

package/src/commands/remove-node.ts

@@ -0,0 +1,43 @@
+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'
+
+/**
+ * @public
+ */
+export interface RemoveNodeOptions {
+  /**
+   * The type of the node to remove.
+   */
+  type: string | NodeType
+
+  /**
+   * The document position to start searching node. By default it will be the
+   * anchor position of current selection.
+   */
+  pos?: number
+}
+
+/**
+ * Returns a command to remove the nearest ancestor node of a specific type from the current position.
+ *
+ * @public
+ */
+export function removeNode(options: RemoveNodeOptions): Command {
+  return (state, dispatch) => {
+    const $pos = typeof options.pos === 'number'
+      ? state.doc.resolve(options.pos)
+      : state.selection.$anchor
+
+    const found = findParentNodeOfType(options.type, $pos)
+    if (!found) return false
+
+    const { pos, node } = found
+    dispatch?.(state.tr.delete(pos, pos + node.nodeSize))
+    return true
+  }
+}
+
+removeNode satisfies CommandCreator

package/src/commands/select-all.ts

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

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

@@ -0,0 +1,64 @@
+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'
+
+/**
+ * @public
+ */
+export interface SetBlockTypeOptions {
+  type: NodeType | string
+  attrs?: Attrs | null
+  from?: number
+  to?: number
+}
+
+/**
+ * Returns a command that tries to set the selected textblocks to the given node
+ * type with the given attributes.
+ *
+ * @public
+ */
+export function setBlockType(options: SetBlockTypeOptions): Command {
+  return (state, dispatch) => {
+    const nodeType = getNodeType(state.schema, options.type)
+    const selection = getCustomSelection(state, options.from, options.to)
+    const attrs = options.attrs
+
+    let applicable = false
+    for (let i = 0; i < selection.ranges.length && !applicable; i++) {
+      const {
+        $from: { pos: from },
+        $to: { pos: to },
+      } = selection.ranges[i]
+      state.doc.nodesBetween(from, to, (node, pos) => {
+        if (applicable) return false
+        if (!node.isTextblock || node.hasMarkup(nodeType, attrs)) return
+        if (node.type == nodeType) {
+          applicable = true
+        } else {
+          const $pos = state.doc.resolve(pos),
+            index = $pos.index()
+          applicable = $pos.parent.canReplaceWith(index, index + 1, nodeType)
+        }
+      })
+    }
+    if (!applicable) return false
+    if (dispatch) {
+      const tr = state.tr
+      for (const range of selection.ranges) {
+        const {
+          $from: { pos: from },
+          $to: { pos: to },
+        } = range
+        tr.setBlockType(from, to, nodeType, attrs)
+      }
+      dispatch(tr.scrollIntoView())
+    }
+    return true
+  }
+}

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

@@ -0,0 +1,68 @@
+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 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[]
+
+  /**
+   * The attributes to set.
+   */
+  attrs: Attrs
+
+  /**
+   * The position of the node. Defaults to the position of the wrapping node
+   * containing the current selection.
+   */
+  pos?: number
+}
+
+/**
+ * Returns a command that set the attributes of the current node.
+ *
+ * @public
+ */
+export function setNodeAttrs(options: 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[] = []
+
+    state.doc.nodesBetween(from, to, (node, pos) => {
+      if (nodeTypes.includes(node.type)) {
+        positions.push(pos)
+      }
+      if (!dispatch && positions.length > 0) {
+        return false
+      }
+    })
+
+    if (positions.length === 0) {
+      return false
+    }
+
+    if (dispatch) {
+      const { tr } = state
+      for (const pos of positions) {
+        for (const [key, value] of Object.entries(options.attrs)) {
+          tr.setNodeAttribute(pos, key, value)
+        }
+      }
+      dispatch(tr)
+    }
+    return true
+  }
+}