@prosekit/core 0.8.3 → 0.8.5

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

@@ -0,0 +1,84 @@
+import {
+  Fragment,
+  Slice,
+} from '@prosekit/pm/model'
+import type {
+  Command,
+  Transaction,
+} from '@prosekit/pm/state'
+import { ReplaceAroundStep } from '@prosekit/pm/transform'
+
+import type { CommandCreator } from '../types/extension-command'
+
+/**
+ * @public
+ */
+export interface UnsetBlockTypeOptions {
+  /**
+   * 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 set the type of all textblocks between the given range
+ * to the default type (usually `paragraph`).
+ *
+ * @public
+ */
+export function unsetBlockType(options?: UnsetBlockTypeOptions): Command {
+  return (state, dispatch) => {
+    const from = options?.from ?? state.selection.from
+    const to = options?.to ?? state.selection.to
+    if (from > to) return false
+
+    const tr = state.tr
+    if (unsetTextBlockType(tr, from, to)) {
+      dispatch?.(tr)
+      return true
+    }
+    return false
+  }
+}
+
+function unsetTextBlockType(
+  tr: Transaction,
+  from: number,
+  to: number,
+): boolean {
+  const mapFrom = tr.steps.length
+  tr.doc.nodesBetween(from, to, (node, pos, parent, index): boolean => {
+    if (!parent || !node.isTextblock) return true
+
+    const defaultType = parent.contentMatchAt(index).defaultType
+    if (
+      defaultType
+      && defaultType.isTextblock
+      && node.type !== defaultType
+      && defaultType.validContent(node.content)
+    ) {
+      const mapping = tr.mapping.slice(mapFrom)
+      const start = mapping.map(pos, 1)
+      const end = mapping.map(pos + node.nodeSize, 1)
+      const step = new ReplaceAroundStep(
+        start,
+        end,
+        start + 1,
+        end - 1,
+        new Slice(Fragment.from(defaultType.create()), 0, 0),
+        1,
+        true,
+      )
+      tr.step(step)
+    }
+    return false
+  })
+  return tr.steps.length > mapFrom
+}
+
+unsetBlockType satisfies CommandCreator

package/src/commands/unset-mark.spec.ts

@@ -0,0 +1,35 @@
+import {
+  describe,
+  expect,
+  it,
+} from 'vitest'
+
+import { setupTest } from '../testing'
+
+describe('unsetMark', () => {
+  it('can unset marks', () => {
+    const { editor, m, n } = setupTest()
+
+    const doc1 = n.doc(
+      n.paragraph(
+        '<a>',
+        '1',
+        m.bold('2'),
+        m.italic('3'),
+        '<b>',
+        m.italic('4'),
+        m.italic('5'),
+      ),
+    )
+
+    const doc2 = n.doc(
+      n.paragraph('<a>', '123', '<b>', m.italic('4'), m.italic('5')),
+    )
+
+    editor.set(doc1)
+    expect(editor.state.doc.toJSON()).toEqual(doc1.toJSON())
+
+    editor.commands.unsetMark()
+    expect(editor.state.doc.toJSON()).toEqual(doc2.toJSON())
+  })
+})

package/src/commands/unset-mark.ts

@@ -0,0 +1,38 @@
+import type { Command } from '@prosekit/pm/state'
+
+import type { CommandCreator } from '../types/extension-command'
+
+/**
+ * @public
+ *
+ * Options for {@link unsetMark}.
+ */
+export interface UnsetMarkOptions {
+  /**
+   * 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 all marks.
+ *
+ * @public
+ */
+export function unsetMark(options?: UnsetMarkOptions): Command {
+  return (state, dispatch) => {
+    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))
+    return true
+  }
+}
+
+unsetMark satisfies CommandCreator

package/src/commands/wrap.ts

@@ -0,0 +1,50 @@
+import type {
+  Attrs,
+  NodeType,
+} from '@prosekit/pm/model'
+import type { Command } from '@prosekit/pm/state'
+import { findWrapping } from '@prosekit/pm/transform'
+
+import { getNodeType } from '../utils/get-node-type'
+
+/**
+ * @public
+ */
+export interface WrapOptions {
+  /**
+   * The node type to wrap the selected textblock with.
+   */
+  type: NodeType | string
+
+  /**
+   * @deprecated Use `nodeSpec` instead.
+   */
+  nodeType?: NodeType
+
+  /**
+   * Optional attributes to apply to the node.
+   */
+  attrs?: Attrs | null
+}
+
+/**
+ * Returns a command that wraps the selected textblock with the given node type.
+ *
+ * @param options
+ *
+ * @public
+ */
+export function wrap(options: WrapOptions): Command {
+  return (state, dispatch) => {
+    const { $from, $to } = state.selection
+    const range = $from.blockRange($to)
+    if (!range) return false
+
+    const nodeType = getNodeType(state.schema, options.nodeType || options.type)
+    const wrapping = findWrapping(range, nodeType, options.attrs)
+    if (!wrapping) return false
+
+    dispatch?.(state.tr.wrap(range, wrapping))
+    return true
+  }
+}

package/src/editor/action.spec.ts

@@ -0,0 +1,143 @@
+import {
+  describe,
+  expect,
+  it,
+} from 'vitest'
+
+import { setupTest } from '../testing'
+import { jsonFromNode } from '../utils/parse'
+
+import type { NodeChild } from './action'
+
+describe('NodeAction', () => {
+  const { editor, n } = setupTest()
+
+  it('can apply node', () => {
+    expect(n.heading('foo').toJSON()).toEqual({
+      type: 'heading',
+      content: [{ text: 'foo', type: 'text' }],
+    })
+  })
+
+  it('can apply node with attrs', () => {
+    expect(n.codeBlock({ language: 'javascript' }, 'foo').toJSON()).toEqual({
+      type: 'codeBlock',
+      attrs: { language: 'javascript' },
+      content: [{ text: 'foo', type: 'text' }],
+    })
+  })
+
+  it('can check node activity', () => {
+    editor.set(n.doc(n.heading('<a>foo<b>')))
+    expect(editor.nodes.heading.isActive()).toBe(true)
+    expect(editor.nodes.paragraph.isActive()).toBe(false)
+  })
+})
+
+describe('MarkAction', () => {
+  const { editor, m, n } = setupTest()
+
+  it('can apply mark', () => {
+    expect(n.p(m.bold('foo')).toJSON()).toEqual({
+      type: 'paragraph',
+      content: [{ marks: [{ type: 'bold' }], text: 'foo', type: 'text' }],
+    })
+  })
+
+  it('can apply mark with attrs', () => {
+    expect(
+      n.p(m.link({ href: 'https://example.com', target: '_blank', rel: 'noopener' }, 'foo')).toJSON(),
+    ).toEqual({
+      type: 'paragraph',
+      content: [
+        {
+          marks: [{ type: 'link', attrs: { href: 'https://example.com', target: '_blank', rel: 'noopener' } }],
+          text: 'foo',
+          type: 'text',
+        },
+      ],
+    })
+  })
+
+  it('can apply multiple marks', () => {
+    const json = jsonFromNode(n.p(m.bold(m.italic('foo'))))
+    const marks = json.content?.[0].marks?.map((mark) => mark.type)
+    expect(marks?.sort()).toEqual(['bold', 'italic'])
+  })
+
+  it('can apply the same mark multiple times', () => {
+    const href1 = 'https://example.com/1'
+    const href2 = 'https://example.com/2'
+    const link1 = (node: NodeChild) => m.link({ href: href1 }, node)
+    const link2 = (node: NodeChild) => m.link({ href: href2, target: '_blank', rel: 'noopener' }, node)
+
+    expect(n.p(link1('foo')).toJSON()).toEqual({
+      type: 'paragraph',
+      content: [
+        {
+          type: 'text',
+          text: 'foo',
+          marks: [{ attrs: { href: href1, target: null, rel: null }, type: 'link' }],
+        },
+      ],
+    })
+
+    expect(n.p(link2(link1('foo'))).toJSON()).toEqual({
+      type: 'paragraph',
+      content: [
+        {
+          type: 'text',
+          text: 'foo',
+          marks: [{ attrs: { href: href2, target: '_blank', rel: 'noopener' }, type: 'link' }],
+        },
+      ],
+    })
+
+    expect(n.p(link2(link2(link2('foo')))).toJSON()).toEqual({
+      type: 'paragraph',
+      content: [
+        {
+          type: 'text',
+          text: 'foo',
+          marks: [{ attrs: { href: href2, target: '_blank', rel: 'noopener' }, type: 'link' }],
+        },
+      ],
+    })
+  })
+
+  it('can check mark activity', () => {
+    editor.set(n.doc(n.p('<a>foo<b>')))
+    expect(editor.marks.bold.isActive()).toBe(false)
+    expect(editor.marks.italic.isActive()).toBe(false)
+
+    editor.set(n.doc(n.p('<a>', m.bold('foo'), '<b>')))
+    expect(editor.marks.bold.isActive()).toBe(true)
+    expect(editor.marks.italic.isActive()).toBe(false)
+  })
+
+  it('can check mark activity for cross-paragraph selection', () => {
+    editor.set(n.doc(n.p('<a>', m.bold('foo')), n.p(m.bold('foo'), '<b>')))
+
+    expect(editor.marks.bold.isActive()).toBe(true)
+    expect(editor.marks.italic.isActive()).toBe(false)
+  })
+
+  it('should not set isActive to true when only part of the text is marked', () => {
+    editor.set(n.doc(n.p('<a>', 'foo', m.bold('bar'), 'baz', '<b>')))
+    expect(editor.marks.bold.isActive()).toBe(false)
+
+    editor.set(n.doc(n.p('<a>', m.bold('foo'), 'bar', '<b>')))
+    expect(editor.marks.bold.isActive()).toBe(false)
+
+    editor.set(n.doc(n.p('<a>', 'foo', m.bold('bar'), '<b>')))
+    expect(editor.marks.bold.isActive()).toBe(false)
+
+    editor.set(n.doc(n.p('<a>', m.bold('foo', 'bar'), '<b>')))
+    expect(editor.marks.bold.isActive()).toBe(true)
+  })
+
+  it('should not set isActive to true when multiple empty paragraphs are selected', () => {
+    editor.set(n.doc(n.p('<a>'), n.p(''), n.p('<b>')))
+    expect(editor.marks.bold.isActive()).toBe(false)
+  })
+})

package/src/editor/action.ts

@@ -0,0 +1,248 @@
+import type {
+  Attrs,
+  Mark,
+  MarkType,
+  NodeType,
+  ProseMirrorNode,
+  Schema,
+} from '@prosekit/pm/model'
+import type { EditorState } from '@prosekit/pm/state'
+import mapValues from 'just-map-values'
+
+import { ProseKitError } from '../error'
+import type { AnyAttrs } from '../types/attrs'
+import { assert } from '../utils/assert'
+import { isMarkActive } from '../utils/is-mark-active'
+import { isNodeActive } from '../utils/is-node-active'
+import { isProseMirrorNode } from '../utils/type-assertion'
+
+/**
+ * Available children parameters for {@link NodeAction} and {@link MarkAction}.
+ *
+ * @public
+ */
+export type NodeChild = ProseMirrorNode | string | NodeChild[]
+
+/**
+ * A function for creating a node with optional attributes and any number of
+ * children.
+ *
+ * It also has a `isActive` method for checking if the node is active in the
+ * current editor selection.
+ *
+ * @public
+ */
+export interface NodeAction<Attrs extends AnyAttrs = AnyAttrs> {
+  /**
+   * Creates a node with attributes and any number of children.
+   */
+  (attrs: Attrs | null, ...children: NodeChild[]): ProseMirrorNode
+
+  /**
+   * Creates a node with any number of children.
+   */
+  (...children: NodeChild[]): ProseMirrorNode
+
+  /**
+   * Checks if the node is active in the current editor selection. If the
+   * optional `attrs` parameter is provided, it will check if the node is active
+   * with the given attributes.
+   */
+  isActive: (attrs?: Attrs) => boolean
+}
+
+/**
+ * A function for applying a mark with optional attributes and any number of
+ * children.
+ *
+ * It also has a `isActive` method for checking if the mark is active in the
+ * current editor selection.
+ *
+ * @public
+ */
+export interface MarkAction<Attrs extends AnyAttrs = AnyAttrs> {
+  /**
+   * Applies a mark with attributes and any number of children.
+   */
+  (attrs: Attrs | null, ...children: NodeChild[]): ProseMirrorNode[]
+
+  /**
+   * Applies a mark with any number of children.
+   */
+  (...children: NodeChild[]): ProseMirrorNode[]
+
+  /**
+   * Checks if the mark is active in the current editor selection. If the
+   * optional `attrs` parameter is provided, it will check if the mark is active
+   * with the given attributes.
+   */
+  isActive: (attrs?: Attrs) => boolean
+}
+
+/**
+ * @deprecated Use type {@link NodeAction} instead.
+ */
+export type NodeBuilder = NodeAction
+
+/**
+ * @deprecated Use type {@link MarkAction} instead.
+ */
+export type MarkBuilder = MarkAction
+
+/**
+ * @internal
+ */
+export function createNodeActions(
+  schema: Schema,
+  getState: GetStateFunction,
+  createNode: CreateNodeFunction = defaultCreateNode,
+): Record<string, NodeAction> {
+  return mapValues(schema.nodes, (type) => createNodeAction(type, getState, createNode))
+}
+
+function createNodeAction(
+  type: NodeType,
+  getState: GetStateFunction,
+  createNode: CreateNodeFunction,
+): NodeAction {
+  const action = (
+    ...args: [Attrs | NodeChild | null | undefined, ...NodeChild[]]
+  ) => buildNode(type, args, createNode)
+  action.isActive = (attrs?: Attrs) => {
+    const state = getState()
+    return state ? isNodeActive(state, type, attrs) : false
+  }
+  return action
+}
+
+/**
+ * @internal
+ */
+export function createMarkActions(
+  schema: Schema,
+  getState: GetStateFunction,
+  applyMark: ApplyMarkFunction = defaultApplyMark,
+): Record<string, MarkAction> {
+  return mapValues(schema.marks, (type) => createMarkAction(type, getState, applyMark))
+}
+
+function createMarkAction(
+  type: MarkType,
+  getState: GetStateFunction,
+  applyMark: ApplyMarkFunction,
+): MarkAction {
+  const action = (
+    ...args: [Attrs | NodeChild | null | undefined, ...NodeChild[]]
+  ) => buildMark(type, args, applyMark)
+  action.isActive = (attrs?: Attrs) => {
+    const state = getState()
+    return state ? isMarkActive(state, type, attrs) : false
+  }
+  return action
+}
+
+function buildMark(
+  type: MarkType,
+  args: [Attrs | NodeChild | null | undefined, ...NodeChild[]],
+  applyMark: ApplyMarkFunction,
+): ProseMirrorNode[] {
+  const [attrs, children] = normalizeArgs(args)
+  const mark = type.create(attrs)
+  return applyMark(mark, flattenChildren(type.schema, children))
+}
+
+/**
+ * @internal
+ */
+export type ApplyMarkFunction = (
+  mark: Mark,
+  children: ProseMirrorNode[],
+) => ProseMirrorNode[]
+
+const defaultApplyMark: ApplyMarkFunction = (
+  mark: Mark,
+  children: ProseMirrorNode[],
+): ProseMirrorNode[] => {
+  return children.map((node) => node.mark(mark.addToSet(node.marks)))
+}
+
+function buildNode(
+  type: NodeType,
+  args: [Attrs | NodeChild | null | undefined, ...NodeChild[]],
+  createNode: CreateNodeFunction,
+): ProseMirrorNode {
+  const [attrs, children] = normalizeArgs(args)
+  return createNode(type, attrs, flattenChildren(type.schema, children))
+}
+
+/**
+ * @internal
+ */
+export type CreateNodeFunction = (
+  type: NodeType,
+  attrs: Attrs | null,
+  children: ProseMirrorNode[],
+) => ProseMirrorNode
+
+type GetStateFunction = () => EditorState | null | undefined
+
+const defaultCreateNode: CreateNodeFunction = (
+  type: NodeType,
+  attrs: Attrs | null,
+  children: ProseMirrorNode[],
+) => {
+  const node = type.createAndFill(attrs, children)
+  assert(node, `Failed to create node ${type.name}`)
+  return node
+}
+
+function flattenChildren(
+  schema: Schema,
+  children: NodeChild[],
+): Array<ProseMirrorNode> {
+  const nodes: Array<ProseMirrorNode> = []
+
+  for (const child of children) {
+    if (typeof child === 'string') {
+      if (child) {
+        nodes.push(schema.text(child, null))
+      }
+    } else if (Array.isArray(child)) {
+      nodes.push(...flattenChildren(schema, child))
+    } else if (isProseMirrorNode(child)) {
+      nodes.push(child)
+    } else {
+      throw new ProseKitError(`Invalid node child: ${typeof child}`)
+    }
+  }
+
+  return nodes
+}
+
+function normalizeArgs(
+  args: [Attrs | NodeChild | null | undefined, ...NodeChild[]],
+): [Attrs | null, NodeChild[]] {
+  const [attrs, ...children] = args
+  if (isNodeChild(attrs)) {
+    children.unshift(attrs)
+    return [null, children]
+  } else if (typeof attrs === 'object') {
+    return [attrs, children]
+  } else {
+    return [null, children]
+  }
+}
+
+function isNodeChild(
+  value: Attrs | NodeChild | null | undefined,
+): value is NodeChild {
+  if (!value) {
+    return false
+  }
+
+  return (
+    typeof value === 'string'
+    || Array.isArray(value)
+    || isProseMirrorNode(value)
+  )
+}