@prosekit/core 0.8.2 → 0.8.4

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/context'
+
+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)
+})

package/src/types/extension.ts

@@ -0,0 +1,168 @@
+import type { Schema } from '@prosekit/pm/model'
+
+import type {
+  CommandTyping,
+  ToCommandAction,
+  ToCommandCreators,
+} from './extension-command'
+import type {
+  MarkTyping,
+  ToMarkAction,
+} from './extension-mark'
+import type {
+  NodeTyping,
+  ToNodeAction,
+} from './extension-node'
+import type { PickStringLiteral } from './pick-string-literal'
+import type { PickSubType } from './pick-sub-type'
+import type { Priority } from './priority'
+import type { SimplifyDeeper } from './simplify-deeper'
+import type { SimplifyUnion } from './simplify-union'
+
+/**
+ * @internal
+ */
+export interface ExtensionTyping<
+  N extends NodeTyping = never,
+  M extends MarkTyping = never,
+  C extends CommandTyping = never,
+> {
+  Nodes?: N
+  Marks?: M
+  Commands?: C
+}
+
+/**
+ * @public
+ */
+export interface Extension<
+  T extends ExtensionTyping<any, any, any> = ExtensionTyping<any, any, any>,
+> {
+  extension: Extension | Extension[]
+  priority?: Priority
+
+  /**
+   * @public
+   *
+   * The schema that this extension represents.
+   */
+  schema: Schema | null
+
+  /** @internal */
+  _type?: T
+}
+
+/**
+ * @internal
+ */
+export type ExtractTyping<E extends Extension> = E extends Extension<ExtensionTyping<infer N, infer M, infer C>> ? ExtensionTyping<
+    PickSubType<N, NodeTyping>,
+    PickSubType<M, MarkTyping>,
+    PickSubType<C, CommandTyping>
+  >
+  : never
+
+/**
+ * An extension that does not define any nodes, marks, or commands.
+ *
+ * @internal
+ */
+export type PlainExtension = Extension<{
+  Nodes: never
+  Marks: never
+  Commands: never
+}>
+
+/**
+ * @public
+ */
+export type ExtractNodes<E extends Extension> = SimplifyDeeper<
+  SimplifyUnion<ExtractTyping<E>['Nodes']>
+>
+
+/**
+ * @public
+ */
+export type ExtractNodeNames<E extends Extension> = PickStringLiteral<
+  keyof ExtractNodes<E>
+>
+
+/**
+ * @public
+ */
+export type ExtractMarks<E extends Extension> = SimplifyDeeper<
+  SimplifyUnion<ExtractTyping<E>['Marks']>
+>
+
+/**
+ * @public
+ */
+export type ExtractMarkNames<E extends Extension> = PickStringLiteral<
+  keyof ExtractMarks<E>
+>
+
+/**
+ * @internal
+ */
+export type ExtractCommands<E extends Extension> = SimplifyUnion<
+  ExtractTyping<E>['Commands']
+>
+
+/**
+ * @public
+ */
+export type ExtractCommandCreators<E extends Extension> = ToCommandCreators<
+  ExtractCommands<E>
+>
+
+/**
+ * Extracts the {@link CommandAction}s from an extension type.
+ *
+ * @public
+ */
+export type ExtractCommandActions<E extends Extension> = ToCommandAction<
+  ExtractCommands<E>
+>
+
+/**
+ * Extracts the {@link NodeAction}s from an extension type.
+ *
+ * @public
+ */
+export type ExtractNodeActions<E extends Extension> = ToNodeAction<
+  ExtractNodes<E>
+>
+
+/**
+ * Extracts the {@link MarkAction}s from an extension type.
+ *
+ * @public
+ */
+export type ExtractMarkActions<E extends Extension> = ToMarkAction<
+  ExtractMarks<E>
+>
+
+/**
+ * @deprecated Use `ExtractCommandActions` instead.
+ */
+export type ExtractCommandAppliers<E extends Extension> = ExtractCommandActions<E>
+
+/**
+ * @internal
+ */
+export type Union<E extends readonly Extension[]> = Extension<{
+  Nodes: ExtractNodes<E[number]>
+  Marks: ExtractMarks<E[number]>
+  Commands: ExtractCommands<E[number]>
+}>
+
+/**
+ * @deprecated Use `Union` instead.
+ * @internal
+ */
+export type UnionExtension<E extends Extension | readonly Extension[]> = E extends readonly Extension[] ? Extension<{
+    Nodes: ExtractNodes<E[number]>
+    Marks: ExtractMarks<E[number]>
+    Commands: ExtractCommands<E[number]>
+  }>
+  : E