@prosekit/core 0.8.3 → 0.8.5

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

package/src/commands/toggle-mark.ts

@@ -0,0 +1,65 @@
+import { toggleMark as baseToggleMark } from '@prosekit/pm/commands'
+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 ToggleMarkOptions {
+  /**
+   * The mark type to toggle.
+   */
+  type: string | MarkType
+
+  /**
+   * The optional attributes to set on the mark.
+   */
+  attrs?: Attrs | null
+
+  /**
+   * Controls whether, when part of the selected range has the mark
+   * already and part doesn't, the mark is removed (`true`) or added
+   * (`false`).
+   *
+   * @default false
+   */
+  removeWhenPresent?: boolean
+
+  /**
+   * Whether the command should act on the content of inline nodes marked as
+   * [atoms](https://prosemirror.net/docs/ref/#model.NodeSpec.atom) that are
+   * completely covered by a selection range.
+   *
+   * @default true
+   */
+  enterInlineAtoms?: boolean
+}
+
+/**
+ * Returns a command that toggles the given mark with the given attributes.
+ *
+ * @param options
+ *
+ * @public
+ */
+export function toggleMark({
+  type,
+  attrs,
+  removeWhenPresent = false,
+  enterInlineAtoms = true,
+}: ToggleMarkOptions): Command {
+  return (state, dispatch, view) => {
+    return baseToggleMark(getMarkType(state.schema, type), attrs, {
+      removeWhenPresent,
+      enterInlineAtoms,
+    })(state, dispatch, view)
+  }
+}
+
+toggleMark satisfies CommandCreator

package/src/commands/toggle-node.ts

@@ -0,0 +1,47 @@
+import { setBlockType } from '@prosekit/pm/commands'
+import type {
+  Attrs,
+  NodeType,
+} from '@prosekit/pm/model'
+import type { Command } from '@prosekit/pm/state'
+
+import { getNodeType } from '../utils/get-node-type'
+import { isNodeActive } from '../utils/is-node-active'
+
+/**
+ * @public
+ */
+export interface ToggleNodeOptions {
+  /**
+   * The type of the node to toggle.
+   */
+  type: string | NodeType
+
+  /**
+   * The attributes of the node to toggle.
+   */
+  attrs?: Attrs | null
+}
+
+/**
+ * Returns a command that set the selected textblocks to the given node type
+ * with the given attributes.
+ *
+ * @param options
+ *
+ * @public
+ */
+export function toggleNode({ type, attrs }: ToggleNodeOptions): Command {
+  return (state, dispatch, view) => {
+    if (isNodeActive(state, type, attrs)) {
+      const defaultType = state.schema.topNodeType.contentMatch.defaultType
+      if (!defaultType) {
+        return false
+      }
+      return setBlockType(defaultType)(state, dispatch, view)
+    } else {
+      const nodeType = getNodeType(state.schema, type)
+      return setBlockType(nodeType, attrs)(state, dispatch, view)
+    }
+  }
+}

package/src/commands/toggle-wrap.spec.ts

@@ -0,0 +1,35 @@
+import {
+  describe,
+  expect,
+  it,
+} from 'vitest'
+
+import { setupTest } from '../testing'
+
+describe('toggle-wrap', () => {
+  it('adds the node wrapping the selection', () => {
+    const { editor, n } = setupTest()
+
+    const doc1 = n.doc(n.paragraph('<a>hello'))
+    const doc2 = n.doc(n.blockquote(n.paragraph('<a>hello')))
+
+    editor.set(doc1)
+    expect(editor.state.doc.toJSON()).toEqual(doc1.toJSON())
+
+    editor.commands.toggleWrap({ type: 'blockquote' })
+    expect(editor.state.doc.toJSON()).toEqual(doc2.toJSON())
+  })
+
+  it('lift the wrapped node', () => {
+    const { editor, n } = setupTest()
+
+    const doc1 = n.doc(n.blockquote(n.paragraph('<a>hello')))
+    const doc2 = n.doc(n.paragraph('<a>hello'))
+
+    editor.set(doc1)
+    expect(editor.state.doc.toJSON()).toEqual(doc1.toJSON())
+
+    editor.commands.toggleWrap({ type: 'paragraph' })
+    expect(editor.state.doc.toJSON()).toEqual(doc2.toJSON())
+  })
+})

package/src/commands/toggle-wrap.ts

@@ -0,0 +1,42 @@
+import { lift } from '@prosekit/pm/commands'
+import type {
+  Attrs,
+  NodeType,
+} from '@prosekit/pm/model'
+import type { Command } from '@prosekit/pm/state'
+
+import { isNodeActive } from '../utils/is-node-active'
+
+import { wrap } from './wrap'
+
+export interface ToggleWrapOptions {
+  /**
+   * The type of the node to toggle.
+   */
+  type: string | NodeType
+
+  /**
+   * The attributes of the node to toggle.
+   */
+  attrs?: Attrs | null
+}
+
+/**
+ * Toggle between wrapping an inactive node with the provided node type, and
+ * lifting it up into its parent.
+ *
+ * @param options
+ *
+ * @public
+ */
+export function toggleWrap(options: ToggleWrapOptions): Command {
+  const { type, attrs } = options
+
+  return (state, dispatch) => {
+    if (isNodeActive(state, type, attrs)) {
+      return lift(state, dispatch)
+    }
+
+    return wrap({ type, attrs })(state, dispatch)
+  }
+}

package/src/commands/unset-block-type.spec.ts

@@ -0,0 +1,49 @@
+import {
+  describe,
+  expect,
+  it,
+} from 'vitest'
+
+import { setupTest } from '../testing'
+
+describe('unsetBlockType', () => {
+  it('can unset a single block', () => {
+    const { editor, n } = setupTest()
+
+    const doc1 = n.doc(n.heading('<a>1'), n.heading('2'))
+    const doc2 = n.doc(n.paragraph('<a>1'), n.heading('2'))
+
+    editor.set(doc1)
+    expect(editor.state.doc.toJSON()).toEqual(doc1.toJSON())
+
+    editor.commands.unsetBlockType()
+    expect(editor.state.doc.toJSON()).toEqual(doc2.toJSON())
+  })
+
+  it('can unset multiple blocks', () => {
+    const { editor, n } = setupTest()
+
+    const doc1 = n.doc(
+      n.heading('0'),
+      n.heading('<a>1'),
+      n.heading('2'),
+      n.heading('<b>3'),
+      n.heading('4'),
+      n.heading('5'),
+    )
+    const doc2 = n.doc(
+      n.heading('0'),
+      n.paragraph('<a>1'),
+      n.paragraph('2'),
+      n.paragraph('<b>3'),
+      n.heading('4'),
+      n.heading('5'),
+    )
+
+    editor.set(doc1)
+    expect(editor.state.doc.toJSON()).toEqual(doc1.toJSON())
+
+    editor.commands.unsetBlockType()
+    expect(editor.state.doc.toJSON()).toEqual(doc2.toJSON())
+  })
+})