@prosekit/core 0.8.3 → 0.8.5

package/src/test/test-editor.ts

@@ -0,0 +1,113 @@
+import type { ProseMirrorNode } from '@prosekit/pm/model'
+import {
+  NodeSelection,
+  TextSelection,
+  type Selection,
+} from '@prosekit/pm/state'
+
+import {
+  createMarkActions,
+  createNodeActions,
+} from '../editor/action'
+import {
+  Editor,
+  EditorInstance,
+  setupEditorExtension,
+  type EditorOptions,
+} from '../editor/editor'
+import type { Extension } from '../types/extension'
+import type {
+  NodeJSON,
+  SelectionJSON,
+} from '../types/model'
+import { isProseMirrorNode } from '../utils/type-assertion'
+
+import {
+  applyMarkForTest,
+  createNodeForTest,
+  type TaggedProseMirrorNode,
+} from './test-builder'
+
+function maybeResolve(doc: ProseMirrorNode, pos?: number) {
+  if (pos != null) {
+    return doc.resolve(pos)
+  }
+  return undefined
+}
+
+function getSelection(doc: TaggedProseMirrorNode): Selection {
+  const tags = doc.tags
+  const $a = maybeResolve(doc, tags?.a)
+  const $b = maybeResolve(doc, tags?.b)
+
+  if ($a) {
+    if ($a.parent.inlineContent) {
+      return new TextSelection($a, $b)
+    } else {
+      return new NodeSelection($a)
+    }
+  }
+  return TextSelection.atStart(doc)
+}
+
+class TestEditorInstance extends EditorInstance {
+  constructor(extension: Extension) {
+    super(extension)
+    this.nodes = createNodeActions(this.schema, this.getState, createNodeForTest)
+    this.marks = createMarkActions(this.schema, this.getState, applyMarkForTest)
+  }
+
+  override setContent(
+    content: ProseMirrorNode | NodeJSON | string | HTMLElement,
+    selection?: SelectionJSON | Selection | 'start' | 'end',
+  ): void {
+    return super.setContent(
+      content,
+      isProseMirrorNode(content) && !selection
+        ? getSelection(content)
+        : selection,
+    )
+  }
+}
+
+/**
+ * An editor for testing purposes.
+ * @public
+ */
+export class TestEditor<E extends Extension = Extension> extends Editor<E> {
+  constructor(instance: EditorInstance) {
+    super(instance)
+  }
+
+  /**
+   * Set the editor state to the given document. You can use special tokens
+   * `<a>` and `<b>` to set the anchor and head positions of the selection.
+   *
+   * @example
+   *
+   * ```ts
+   * const editor = createTestEditor({ extension })
+   * const n = editor.nodes
+   * const doc = n.doc(n.paragraph('<a>Hello<b> world!'))
+   * editor.set(doc) // "Hello" is selected.
+   * ```
+   */
+  set(doc: ProseMirrorNode): void {
+    return this.setContent(doc)
+  }
+
+  dispatchEvent(event: Event): void {
+    this.view.dispatchEvent(event)
+  }
+}
+
+/**
+ * @public
+ */
+export function createTestEditor<E extends Extension>(
+  options: EditorOptions<E>,
+): TestEditor<E> {
+  const extension = setupEditorExtension(options)
+  const instance = new TestEditorInstance(extension)
+  return new TestEditor(instance)
+}

package/src/testing/index.ts

@@ -0,0 +1,283 @@
+import '@prosekit/pm/view/style/prosemirror.css'
+
+import type { Attrs } from '@prosekit/pm/model'
+
+import { union } from '../editor/union'
+import { withPriority } from '../editor/with-priority'
+import { defineBaseCommands } from '../extensions/command'
+import { defineHistory } from '../extensions/history'
+import { defineBaseKeymap } from '../extensions/keymap-base'
+import { defineMarkSpec } from '../extensions/mark-spec'
+import { defineNodeSpec } from '../extensions/node-spec'
+import {
+  createTestEditor,
+  type TestEditor,
+} from '../test'
+import type {
+  Extension,
+  ExtractMarkActions,
+  ExtractNodeActions,
+} from '../types/extension'
+import { Priority } from '../types/priority'
+
+type DocExtension = Extension<{ Nodes: { doc: Attrs } }>
+
+/**
+ * @internal
+ */
+export function defineDoc(): DocExtension {
+  return defineNodeSpec({
+    name: 'doc',
+    content: 'block+',
+    topNode: true,
+  })
+}
+
+type ParagraphExtension = Extension<{
+  Nodes: {
+    paragraph: Attrs
+  }
+}>
+
+/**
+ * @internal
+ */
+function defineParagraphSpec(): ParagraphExtension {
+  return defineNodeSpec({
+    name: 'paragraph',
+    content: 'inline*',
+    group: 'block',
+    parseDOM: [{ tag: 'p' }],
+    toDOM() {
+      return ['p', 0]
+    },
+  })
+}
+
+/**
+ * @internal
+ */
+export function defineParagraph(): ParagraphExtension {
+  return withPriority(defineParagraphSpec(), Priority.highest)
+}
+
+type TextExtension = Extension<{
+  Nodes: {
+    text: Attrs
+  }
+}>
+
+/**
+ * @internal
+ */
+export function defineText(): TextExtension {
+  return defineNodeSpec({
+    name: 'text',
+    group: 'inline',
+  })
+}
+
+type BoldExtension = Extension<{
+  Marks: {
+    bold: Attrs
+  }
+}>
+
+/**
+ * @internal
+ */
+function defineBold(): BoldExtension {
+  return defineMarkSpec({
+    name: 'bold',
+    parseDOM: [{ tag: 'strong' }],
+    toDOM() {
+      return ['strong', 0]
+    },
+  })
+}
+
+type ItalicExtension = Extension<{
+  Marks: {
+    italic: Attrs
+  }
+}>
+
+/**
+ * @internal
+ */
+function defineItalic(): ItalicExtension {
+  return defineMarkSpec({
+    name: 'italic',
+    parseDOM: [{ tag: 'em' }],
+    toDOM() {
+      return ['em', 0]
+    },
+  })
+}
+
+interface LinkAttrs {
+  href: string
+  target?: string | null
+  rel?: string | null
+}
+
+type LinkExtension = Extension<{
+  Marks: {
+    link: LinkAttrs
+  }
+}>
+
+/**
+ * @internal
+ */
+function defineLink(): LinkExtension {
+  return defineMarkSpec<'link', LinkAttrs>({
+    name: 'link',
+    inclusive: false,
+    attrs: {
+      href: { validate: 'string' },
+      target: { default: null, validate: 'string|null' },
+      rel: { default: null, validate: 'string|null' },
+    },
+    parseDOM: [
+      {
+        tag: 'a[href]',
+        getAttrs: (dom: HTMLElement) => {
+          return {
+            href: dom.getAttribute('href') || '',
+            target: dom.getAttribute('target') || null,
+            rel: dom.getAttribute('rel') || null,
+          }
+        },
+      },
+    ],
+    toDOM(node) {
+      const { href, target, rel } = node.attrs as LinkAttrs
+      return ['a', { href, target, rel }, 0]
+    },
+  })
+}
+
+type HeadingExtension = Extension<{
+  Nodes: {
+    heading: Attrs
+  }
+}>
+
+/**
+ * @internal
+ */
+function defineHeading(): HeadingExtension {
+  return defineNodeSpec({
+    name: 'heading',
+    content: 'inline*',
+    group: 'block',
+    defining: true,
+    parseDOM: [{ tag: 'h1' }],
+    toDOM() {
+      return ['h1', 0]
+    },
+  })
+}
+
+type CodeBlockExtension = Extension<{
+  Nodes: {
+    codeBlock: { language: string }
+  }
+}>
+
+/**
+ * @internal
+ */
+function defineCodeBlock(): CodeBlockExtension {
+  return defineNodeSpec({
+    name: 'codeBlock',
+    content: 'text*',
+    group: 'block',
+    code: true,
+    defining: true,
+    marks: '',
+    attrs: { language: { default: '', validate: 'string' } },
+    toDOM() {
+      return ['pre', ['code', 0]]
+    },
+  })
+}
+
+type BlockquoteExtension = Extension<{
+  Nodes: {
+    blockquote: Attrs
+  }
+}>
+
+/**
+ * @internal
+ */
+function defineBlockquote(): BlockquoteExtension {
+  return defineNodeSpec({
+    name: 'blockquote',
+    content: 'block+',
+    group: 'block',
+    defining: true,
+    parseDOM: [{ tag: 'blockquote' }],
+    toDOM() {
+      return ['blockquote', 0]
+    },
+  })
+}
+
+/**
+ * @internal
+ */
+export function defineTestExtension() {
+  return union(
+    defineBaseCommands(),
+    defineBaseKeymap(),
+    defineDoc(),
+    defineHistory(),
+    defineParagraph(),
+    defineText(),
+    defineBold(),
+    defineItalic(),
+    defineLink(),
+    defineHeading(),
+    defineCodeBlock(),
+    defineBlockquote(),
+  )
+}
+
+/**
+ * @internal
+ */
+export function setupTestFromExtension<E extends Extension>(
+  extension: E,
+): {
+  editor: TestEditor<E>
+  n: ExtractNodeActions<E>
+  m: ExtractMarkActions<E>
+} {
+  const editor = createTestEditor({ extension })
+
+  const div = document.body.appendChild(document.createElement('div'))
+  div.style.minWidth = '200px'
+  div.style.minHeight = '200px'
+  editor.mount(div)
+  editor.view.dom.focus()
+
+  const n = editor.nodes
+  const m = editor.marks
+  return { editor, n, m }
+}
+
+/**
+ * @internal
+ */
+export function setupTest() {
+  const { editor, m, n } = setupTestFromExtension(defineTestExtension())
+
+  return {
+    editor,
+    m,
+    n: { ...n, p: n.paragraph },
+  }
+}

package/src/testing/keyboard.ts

@@ -0,0 +1,5 @@
+import { userEvent } from 'vitest/browser'
+
+export async function inputText(input: string): Promise<void> {
+  return await userEvent.keyboard(input)
+}

package/src/types/any-function.ts

@@ -0,0 +1,4 @@
+/**
+ * @internal
+ */
+export type AnyFunction = (...args: any[]) => any

package/src/types/assert-type-equal.ts

@@ -0,0 +1,8 @@
+import type { IsEqual } from 'type-fest'
+
+/**
+ * Utility function assert that two types are equal in tests.
+ */
+export function assertTypeEqual<T, U>(_val: IsEqual<T, U>): void {
+  // noop
+}

package/src/types/attrs.ts

@@ -0,0 +1,32 @@
+import type { Attrs } from '@prosekit/pm/model'
+
+/**
+ * An object holding the attributes of a node.
+
+ * @public
+ */
+export type AnyAttrs = Attrs
+
+/**
+ * @public
+ */
+export type AttrSpec<AttrType = any> = {
+  /**
+   * The default value for this attribute, to use when no explicit value is
+   * provided. Attributes that have no default must be provided whenever a node
+   * or mark of a type that has them is created.
+   */
+  default?: AttrType
+
+  /**
+   * A function or type name used to validate values of this attribute. This
+   * will be used when deserializing the attribute from JSON, and when running
+   * [`Node.check`](https://prosemirror.net/docs/ref/#model.Node.check). When a
+   * function, it should raise an exception if the value isn't of the expected
+   * type or shape. When a string, it should be a `|`-separated string of
+   * primitive types (`"number"`, `"string"`, `"boolean"`, `"null"`, and
+   * `"undefined"`), and the library will raise an error when the value is not
+   * one of those types.
+   */
+  validate?: string | ((value: unknown) => void)
+}

package/src/types/base-node-view-options.ts

@@ -0,0 +1,33 @@
+import type { ProseMirrorNode } from '@prosekit/pm/model'
+import type { NodeView } from '@prosekit/pm/view'
+
+// This should be synced with the type `CoreNodeViewUserOptions` from `@prosemirror-adapter/core`
+
+/**
+ * Some basic props for custom node views.
+ *
+ * @deprecated - This is no longer needed. Use `CoreNodeViewUserOptions` from `@prosemirror-adapter/core` instead.
+ *
+ * @hidden
+ */
+export interface BaseNodeViewOptions {
+  /**
+   * The wrapping DOM element for the node view. Defaults to `div` for block nodes and `span` for inline nodes.
+   */
+  as?: string | HTMLElement | ((node: ProseMirrorNode) => HTMLElement)
+
+  /**
+   * The wrapping DOM element for the node view's content. Defaults to `div` for block nodes and `span` for inline nodes.
+   */
+  contentAs?: string | HTMLElement | ((node: ProseMirrorNode) => HTMLElement)
+
+  update?: NodeView['update']
+  ignoreMutation?: NodeView['ignoreMutation']
+  selectNode?: NodeView['selectNode']
+  deselectNode?: NodeView['deselectNode']
+  setSelection?: NodeView['setSelection']
+  stopEvent?: NodeView['stopEvent']
+  destroy?: NodeView['destroy']
+
+  onUpdate?: () => void
+}

package/src/types/dom-node.ts

@@ -0,0 +1 @@
+export type DOMNode = InstanceType<typeof window.Node>

package/src/types/extension-command.ts

@@ -0,0 +1,52 @@
+import type { Command } from '@prosekit/pm/state'
+
+/**
+ * A function to apply a command to the editor. It will return `true` if the command was applied, and `false` otherwise.
+ *
+ * It also has a `canExec` method to check if the command can be applied.
+ *
+ * @public
+ */
+export interface CommandAction<Args extends any[] = any[]> {
+  /**
+   * Execute the current command. Return `true` if the command was successfully
+   * executed, otherwise `false`.
+   */
+  (...args: Args): boolean
+
+  /**
+   * Check if the current command can be executed. Return `true` if the command
+   * can be executed, otherwise `false`.
+   */
+  canExec(...args: Args): boolean
+
+  /**
+   * An alias for `canExec`.
+   *
+   * @deprecated Use `canExec` instead.
+   */
+  canApply(...args: Args): boolean
+}
+
+export type CommandCreator<Args extends any[] = any[]> = (
+  ...arg: Args
+) => Command
+
+/**
+ * @internal
+ */
+export interface CommandTyping {
+  [name: string]: any[]
+}
+
+export interface CommandCreators {
+  [name: string]: CommandCreator
+}
+
+export type ToCommandCreators<T extends CommandTyping> = {
+  [K in keyof T]: CommandCreator<T[K]>
+}
+
+export type ToCommandAction<T extends CommandTyping> = {
+  [K in keyof T]: CommandAction<T[K]>
+}

package/src/types/extension-mark.ts

@@ -0,0 +1,15 @@
+import type { MarkAction } from '../editor/action'
+
+/**
+ * @internal
+ */
+export interface MarkTyping {
+  [name: string]: Record<string, any>
+}
+
+/**
+ * @internal
+ */
+export type ToMarkAction<T extends MarkTyping> = {
+  [K in keyof T]: MarkAction<T[K]>
+}

package/src/types/extension-node.ts

@@ -0,0 +1,15 @@
+import type { NodeAction } from '../editor/action'
+
+/**
+ * @internal
+ */
+export interface NodeTyping {
+  [name: string]: Record<string, any>
+}
+
+/**
+ * @internal
+ */
+export type ToNodeAction<T extends NodeTyping> = {
+  [K in keyof T]: NodeAction<T[K]>
+}

package/src/types/extension.spec.ts

@@ -0,0 +1,56 @@
+import { test } from 'vitest'
+
+import { assertTypeEqual } from './assert-type-equal'
+import type {
+  Extension,
+  Union,
+} from './extension'
+
+test('ExtractTyping', () => {
+  type E1 = Extension<{
+    Nodes: { foo: { attr1: string } }
+  }>
+  type E2 = Extension<{
+    Nodes: { foo: { attr2: number } }
+  }>
+  type E3 = Extension<{
+    Marks: { bar: { attr3: boolean } }
+  }>
+  type E4 = Extension<{
+    Commands: { a: [''] }
+  }>
+  type E5 = Extension<{
+    Nodes: { baz: { attr4: null } }
+
+    Commands: { b: [string, number]; c: [{ c: boolean }] }
+  }>
+  type E6 = Extension<{
+    Nodes: never
+    Marks: never
+    Commands: never
+  }>
+  type E7 = Extension<{
+    Nodes: any
+    Marks: any
+    Commands: any
+  }>
+  type E = [E1, E2, E3, E4, E5, E6, E7]
+
+  type Received = Union<E>
+  type Expected = Extension<{
+    Nodes: {
+      foo: { attr1: string; attr2: number }
+      baz: { attr4: null }
+    }
+    Marks: {
+      bar: { attr3: boolean }
+    }
+    Commands: {
+      a: ['']
+      b: [string, number]
+      c: [{ c: boolean }]
+    }
+  }>
+
+  assertTypeEqual<Received, Expected>(true)
+})