@prosekit/core 0.8.2 → 0.8.4

package/src/index.ts

@@ -0,0 +1,302 @@
+export {
+  addMark,
+  type AddMarkOptions,
+} from './commands/add-mark'
+export {
+  expandMark,
+  type ExpandMarkOptions,
+} from './commands/expand-mark'
+export {
+  insertDefaultBlock,
+  type InsertDefaultBlockOptions,
+} from './commands/insert-default-block'
+export {
+  insertNode,
+  type InsertNodeOptions,
+} from './commands/insert-node'
+export {
+  removeMark,
+  type RemoveMarkOptions,
+} from './commands/remove-mark'
+export {
+  removeNode,
+  type RemoveNodeOptions,
+} from './commands/remove-node'
+export {
+  setBlockType,
+  type SetBlockTypeOptions,
+} from './commands/set-block-type'
+export {
+  setNodeAttrs,
+  type SetNodeAttrsOptions,
+} from './commands/set-node-attrs'
+export {
+  toggleMark,
+  type ToggleMarkOptions,
+} from './commands/toggle-mark'
+export {
+  toggleNode,
+  type ToggleNodeOptions,
+} from './commands/toggle-node'
+export {
+  toggleWrap,
+  type ToggleWrapOptions,
+} from './commands/toggle-wrap'
+export {
+  unsetBlockType,
+  type UnsetBlockTypeOptions,
+} from './commands/unset-block-type'
+export {
+  unsetMark,
+  type UnsetMarkOptions,
+} from './commands/unset-mark'
+export {
+  wrap,
+  type WrapOptions,
+} from './commands/wrap'
+export type {
+  MarkAction,
+  MarkBuilder,
+  NodeAction,
+  NodeBuilder,
+  NodeChild,
+} from './editor/action'
+export {
+  createEditor,
+  Editor,
+  type EditorOptions,
+} from './editor/editor'
+export { union } from './editor/union'
+export { withPriority } from './editor/with-priority'
+export {
+  EditorNotFoundError,
+  ProseKitError,
+} from './error'
+export {
+  defineClipboardSerializer,
+  type ClipboardSerializerOptions,
+} from './extensions/clipboard-serializer'
+export {
+  defineBaseCommands,
+  defineCommands,
+  type BaseCommandsExtension,
+} from './extensions/command'
+export {
+  defineDefaultState,
+  type DefaultStateOptions,
+} from './extensions/default-state'
+export {
+  defineDoc,
+  type DocExtension,
+} from './extensions/doc'
+export {
+  defineDocChangeHandler,
+  type DocChangeHandler,
+} from './extensions/events/doc-change'
+export {
+  defineDOMEventHandler,
+  type DOMEventHandler,
+} from './extensions/events/dom-event'
+export {
+  defineClickHandler,
+  defineClickOnHandler,
+  defineDoubleClickHandler,
+  defineDoubleClickOnHandler,
+  defineDropHandler,
+  defineKeyDownHandler,
+  defineKeyPressHandler,
+  definePasteHandler,
+  defineScrollToSelectionHandler,
+  defineTextInputHandler,
+  defineTripleClickHandler,
+  defineTripleClickOnHandler,
+  editorEventFacet,
+  type ClickHandler,
+  type ClickOnHandler,
+  type DoubleClickHandler,
+  type DoubleClickOnHandler,
+  type DropHandler,
+  type EditorEventPayload,
+  type KeyDownHandler,
+  type KeyPressHandler,
+  type PasteHandler,
+  type ScrollToSelectionHandler,
+  type TextInputHandler,
+  type TripleClickHandler,
+  type TripleClickOnHandler,
+} from './extensions/events/editor-event'
+export {
+  defineFocusChangeHandler,
+  type FocusChangeHandler,
+} from './extensions/events/focus'
+export {
+  defineMountHandler,
+  defineUnmountHandler,
+  defineUpdateHandler,
+  type MountHandler,
+  type UnmountHandler,
+  type UpdateHandler,
+} from './extensions/events/plugin-view'
+export {
+  defineHistory,
+  type HistoryExtension,
+  type HistoryOptions,
+} from './extensions/history'
+export {
+  defineKeymap,
+  keymapFacet,
+  type Keymap,
+  type KeymapPayload,
+} from './extensions/keymap'
+export {
+  defineBaseKeymap,
+  type BaseKeymapExtension,
+} from './extensions/keymap-base'
+export {
+  defineMarkAttr,
+  defineMarkSpec,
+  type MarkAttrOptions,
+  type MarkSpecOptions,
+} from './extensions/mark-spec'
+export {
+  defineMarkView,
+  type MarkViewOptions,
+} from './extensions/mark-view'
+export {
+  defineMarkViewComponent,
+  defineMarkViewFactory,
+  type MarkViewComponentOptions,
+  type MarkViewFactoryOptions,
+} from './extensions/mark-view-effect'
+export {
+  defineNodeAttr,
+  defineNodeSpec,
+  type NodeAttrOptions,
+  type NodeSpecOptions,
+} from './extensions/node-spec'
+export {
+  defineNodeView,
+  type NodeViewOptions,
+} from './extensions/node-view'
+export {
+  defineNodeViewComponent,
+  defineNodeViewFactory,
+  type NodeViewComponentOptions,
+  type NodeViewFactoryOptions,
+} from './extensions/node-view-effect'
+export {
+  defineParagraph,
+  type ParagraphExtension,
+} from './extensions/paragraph'
+export {
+  definePlugin,
+  pluginFacet,
+  type PluginPayload,
+} from './extensions/plugin'
+export {
+  defineText,
+  type TextExtension,
+} from './extensions/text'
+export {
+  defineFacet,
+  type Facet,
+} from './facets/facet'
+export { defineFacetPayload } from './facets/facet-extension'
+export type { AnyFunction } from './types/any-function'
+export type {
+  AnyAttrs,
+  AttrSpec,
+} from './types/attrs'
+export type { BaseNodeViewOptions } from './types/base-node-view-options'
+export type {
+  Extension,
+  ExtensionTyping,
+  ExtractCommandActions,
+  ExtractCommandAppliers,
+  ExtractCommandCreators,
+  ExtractCommands,
+  ExtractMarkActions,
+  ExtractMarks,
+  ExtractNodeActions,
+  ExtractNodes,
+  ExtractTyping,
+  PlainExtension,
+  Union,
+  UnionExtension,
+} from './types/extension'
+export type {
+  CommandAction,
+  CommandTyping,
+} from './types/extension-command'
+export type {
+  MarkTyping,
+  ToMarkAction,
+} from './types/extension-mark'
+export type {
+  NodeTyping,
+  ToNodeAction,
+} from './types/extension-node'
+export type {
+  NodeJSON,
+  SelectionJSON,
+  StateJSON,
+  StepJSON,
+} from './types/model'
+export type { PickSubType } from './types/pick-sub-type'
+export { Priority } from './types/priority'
+export type { SimplifyDeeper } from './types/simplify-deeper'
+export type { SimplifyUnion } from './types/simplify-union'
+export { assert } from './utils/assert'
+export { canUseRegexLookbehind } from './utils/can-use-regex-lookbehind'
+export { clsx } from './utils/clsx'
+export { collectChildren } from './utils/collect-children'
+export {
+  collectNodes,
+  type NodeContent,
+} from './utils/collect-nodes'
+export { containsInlineNode } from './utils/contains-inline-node'
+export { defaultBlockAt } from './utils/default-block-at'
+export { isApple } from './utils/env'
+export {
+  findParentNode,
+  type FindParentNodeResult,
+} from './utils/find-parent-node'
+export { findParentNodeOfType } from './utils/find-parent-node-of-type'
+export { getId as _getId } from './utils/get-id'
+export { getMarkType } from './utils/get-mark-type'
+export { getNodeType } from './utils/get-node-type'
+export { isAtBlockStart } from './utils/is-at-block-start'
+export { isInCodeBlock } from './utils/is-in-code-block'
+export { isMarkAbsent } from './utils/is-mark-absent'
+export { isMarkActive } from './utils/is-mark-active'
+export { maybeRun } from './utils/maybe-run'
+export {
+  elementFromJSON,
+  elementFromNode,
+  htmlFromJSON,
+  htmlFromNode,
+  jsonFromHTML,
+  jsonFromNode,
+  jsonFromState,
+  nodeFromElement,
+  nodeFromHTML,
+  nodeFromJSON,
+  stateFromJSON,
+  type DOMDocumentOptions,
+  type DOMParserOptions,
+  type DOMSerializerOptions,
+  type JSONParserOptions,
+} from './utils/parse'
+export { setSelectionAround } from './utils/set-selection-around'
+export {
+  isAllSelection,
+  isFragment,
+  isMark,
+  isNodeSelection,
+  isProseMirrorNode,
+  isSelection,
+  isSlice,
+  isTextSelection,
+} from './utils/type-assertion'
+export * from './utils/unicode'
+export { withSkipCodeBlock } from './utils/with-skip-code-block'

package/src/test/index.ts

@@ -0,0 +1,4 @@
+export {
+  createTestEditor,
+  type TestEditor,
+} from './test-editor'

package/src/test/test-builder.ts

@@ -0,0 +1,68 @@
+import type { ProseMirrorNode } from '@prosekit/pm/model'
+
+import type {
+  ApplyMarkFunction,
+  CreateNodeFunction,
+} from '../editor/action'
+import { assert } from '../utils/assert'
+
+type Tags = Record<string, number>
+export type TaggedProseMirrorNode = ProseMirrorNode & { tags?: Tags }
+
+export const createNodeForTest: CreateNodeFunction = (
+  type,
+  attrs,
+  children: TaggedProseMirrorNode[],
+): TaggedProseMirrorNode => {
+  const tags: Tags = {}
+  const isTopNode = type === type.schema.topNodeType
+  let pos = isTopNode ? 0 : 1
+  const normalizedChildren: TaggedProseMirrorNode[] = []
+
+  for (const child of children) {
+    if (child.tags) {
+      for (const [key, value] of Object.entries(child.tags)) {
+        tags[key] = pos + value
+      }
+      normalizedChildren.push(child)
+      pos += child.nodeSize
+    } else if (child.isText) {
+      const text = child.text!
+      const re = /<(a|b)>/g
+      let i = 0
+      let out = ''
+      for (const match of text.matchAll(re)) {
+        out += text.slice(i, match.index)
+        tags[match[1]] = pos + out.length
+        i = match.index + match[0].length
+      }
+      out += text.slice(i)
+      if (out) {
+        normalizedChildren.push(child.type.schema.text(out).mark(child.marks))
+        pos += out.length
+      }
+    } else {
+      normalizedChildren.push(child)
+      pos += child.nodeSize
+    }
+  }
+
+  const node: TaggedProseMirrorNode | null = type.createAndFill(
+    attrs,
+    normalizedChildren,
+  )
+  assert(node, `Failed to create node ${type.name}`)
+  node.tags = tags
+  return node
+}
+
+export const applyMarkForTest: ApplyMarkFunction = (
+  mark,
+  children: TaggedProseMirrorNode[],
+): TaggedProseMirrorNode[] => {
+  return children.map((node) => {
+    const newNode: TaggedProseMirrorNode = node.mark(mark.addToSet(node.marks))
+    newNode.tags = node.tags
+    return newNode
+  })
+}

package/src/test/test-editor.spec.ts

@@ -0,0 +1,104 @@
+import {
+  describe,
+  expect,
+  it,
+} from 'vitest'
+
+import { setupTest } from '../testing'
+
+describe('TestEditor', () => {
+  it('should create nodes and marks', () => {
+    const { editor, m, n } = setupTest()
+
+    const doc = n.doc(n.paragraph('Hello ', m.bold('world!')))
+    editor.set(doc)
+    expect(editor.state.doc.toJSON()).toMatchInlineSnapshot(`
+      {
+        "content": [
+          {
+            "content": [
+              {
+                "text": "Hello ",
+                "type": "text",
+              },
+              {
+                "marks": [
+                  {
+                    "type": "bold",
+                  },
+                ],
+                "text": "world!",
+                "type": "text",
+              },
+            ],
+            "type": "paragraph",
+          },
+        ],
+        "type": "doc",
+      }
+    `)
+  })
+
+  it('should set text selection', () => {
+    const { editor, m, n } = setupTest()
+
+    editor.set(n.doc(n.paragraph('Hello ', m.bold('<a>world<b>!'))))
+    expect(editor.state.selection.toJSON()).toMatchInlineSnapshot(`
+      {
+        "anchor": 7,
+        "head": 12,
+        "type": "text",
+      }
+    `)
+    expect(
+      editor.state.selection.content().content.toString(),
+    ).toMatchInlineSnapshot(`"<paragraph(bold("world"))>"`)
+
+    editor.set(n.doc(n.paragraph('Hello ', m.bold('<b>world<a>!'))))
+    expect(editor.state.selection.toJSON()).toMatchInlineSnapshot(`
+      {
+        "anchor": 12,
+        "head": 7,
+        "type": "text",
+      }
+    `)
+    expect(
+      editor.state.selection.content().content.toString(),
+    ).toMatchInlineSnapshot(`"<paragraph(bold("world"))>"`)
+
+    editor.set(n.doc(n.paragraph('Hello ', m.bold('<a>world!'))))
+    expect(editor.state.selection.toJSON()).toMatchInlineSnapshot(`
+      {
+        "anchor": 7,
+        "head": 7,
+        "type": "text",
+      }
+    `)
+  })
+
+  it('should set node selection', () => {
+    const { editor, n } = setupTest()
+
+    editor.set(n.doc('<a>', n.paragraph('foo')))
+    expect(editor.state.selection.toJSON()).toMatchInlineSnapshot(`
+      {
+        "anchor": 0,
+        "type": "node",
+      }
+    `)
+    expect(
+      editor.state.selection.content().content.toString(),
+    ).toMatchInlineSnapshot(`"<paragraph("foo")>"`)
+
+    editor.set(n.doc(n.paragraph('foo'), '<a>', n.paragraph('bar')))
+    expect(editor.state.selection.toJSON()).toMatchInlineSnapshot(`
+      {
+        "anchor": 5,
+        "type": "node",
+      }
+    `)
+    expect(
+      editor.state.selection.content().content.toString(),
+    ).toMatchInlineSnapshot(`"<paragraph("bar")>"`)
+  })
+})

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