@prosekit/core 0.8.3 → 0.8.5

package/src/facets/state.spec.ts

@@ -0,0 +1,53 @@
+import {
+  describe,
+  expect,
+  it,
+} from 'vitest'
+
+import { union } from '../editor/union'
+import { withPriority } from '../editor/with-priority'
+import { defineDefaultState } from '../extensions/default-state'
+import {
+  defineTestExtension,
+  setupTestFromExtension,
+} from '../testing'
+import type { NodeJSON } from '../types/model'
+import { Priority } from '../types/priority'
+
+describe('state', () => {
+  it('uses doc from extension with highest priority', () => {
+    const doc1: NodeJSON = { type: 'doc', content: [{ type: 'paragraph', content: [{ type: 'text', text: 'default priority' }] }] }
+    const doc2: NodeJSON = { type: 'doc', content: [{ type: 'paragraph', content: [{ type: 'text', text: 'highest priority' }] }] }
+    const doc3: NodeJSON = { type: 'doc', content: [{ type: 'paragraph', content: [{ type: 'text', text: 'lowest priority' }] }] }
+
+    const extension1 = defineDefaultState({ defaultDoc: doc1 }) // default priority
+    const extension2 = withPriority(defineDefaultState({ defaultDoc: doc2 }), Priority.highest)
+    const extension3 = withPriority(defineDefaultState({ defaultDoc: doc3 }), Priority.lowest)
+
+    const combinedExtension = union(defineTestExtension(), extension1, extension2, extension3)
+    const { editor } = setupTestFromExtension(combinedExtension)
+
+    const docText = editor.state.doc.textContent
+
+    // The extension with the highest priority should set the doc
+    expect(docText).toEqual('highest priority')
+  })
+
+  it('uses doc from last extension when all have same priority', () => {
+    const doc1 = { type: 'doc', content: [{ type: 'paragraph', content: [{ type: 'text', text: 'first' }] }] }
+    const doc2 = { type: 'doc', content: [{ type: 'paragraph', content: [{ type: 'text', text: 'second' }] }] }
+    const doc3 = { type: 'doc', content: [{ type: 'paragraph', content: [{ type: 'text', text: 'third' }] }] }
+
+    const extension1 = defineDefaultState({ defaultDoc: doc1 })
+    const extension2 = defineDefaultState({ defaultDoc: doc2 })
+    const extension3 = defineDefaultState({ defaultDoc: doc3 })
+
+    const combinedExtension = union(defineTestExtension(), extension1, extension2, extension3)
+    const { editor } = setupTestFromExtension(combinedExtension)
+
+    const docText = editor.state.doc.textContent
+
+    // When all have same priority, later extensions override earlier ones
+    expect(docText).toEqual('third')
+  })
+})

package/src/facets/state.ts

@@ -0,0 +1,85 @@
+import type {
+  Mark,
+  ProseMirrorNode,
+  Schema,
+} from '@prosekit/pm/model'
+import type { EditorStateConfig } from '@prosekit/pm/state'
+import type {
+  Plugin,
+  Selection,
+} from '@prosekit/pm/state'
+
+import { toReversed } from '../utils/array'
+import { assert } from '../utils/assert'
+
+import {
+  defineFacet,
+  type Facet,
+} from './facet'
+import {
+  rootFacet,
+  type RootPayload,
+} from './root'
+
+export type StatePayload = (ctx: { schema: Schema }) => EditorStateConfig
+
+export const stateFacet: Facet<StatePayload, RootPayload> = defineFacet({
+  reduce: () => {
+    // An array of state payloads from lower to higher priority.
+    let callbacks: StatePayload[] = []
+
+    const state: StatePayload = (ctx) => {
+      let doc: ProseMirrorNode | undefined
+      let selection: Selection | undefined
+      let schema: Schema | undefined = ctx.schema
+      const markSet = new Set<Mark>()
+      const pluginSet = new Set<Plugin>()
+
+      // An array of state payloads from higher to lower priority. This matches the
+      // order of plugins required by ProseMirror.
+      const reversedCallbacks = toReversed(callbacks)
+
+      for (const callback of reversedCallbacks) {
+        const config = callback(ctx)
+
+        doc ||= config.doc
+        selection ||= config.selection
+        schema ||= config.schema
+
+        for (const mark of (config.storedMarks ?? [])) {
+          markSet.add(mark)
+        }
+
+        for (const plugin of (config.plugins ?? [])) {
+          // `config.plugins` is an array of plugins from higher to lower priority.
+          pluginSet.add(plugin)
+        }
+      }
+
+      // If both doc and schema are provided, the schema is not needed.
+      if (doc && schema) {
+        schema = undefined
+      }
+
+      assert(
+        doc || schema,
+        "Can't create state without a schema nor a document",
+      )
+
+      return {
+        doc,
+        selection,
+        schema,
+        storedMarks: Array.from(markSet),
+        plugins: Array.from(pluginSet),
+      }
+    }
+
+    return function reducer(inputs) {
+      callbacks = inputs
+      return { state }
+    }
+  },
+  singleton: true,
+  parent: rootFacet,
+})

package/src/facets/union-extension.ts

@@ -0,0 +1,41 @@
+import type {
+  Extension,
+  ExtensionTyping,
+} from '../types/extension'
+import type { Priority } from '../types/priority'
+import { assert } from '../utils/assert'
+
+import { BaseExtension } from './base-extension'
+import {
+  unionFacetNode,
+  type FacetNode,
+} from './facet-node'
+
+export class UnionExtensionImpl<T extends ExtensionTyping = ExtensionTyping> extends BaseExtension<T> implements Extension<T> {
+  /**
+   * @internal
+   */
+  constructor(public extension: BaseExtension[] = []) {
+    super()
+  }
+
+  /**
+   * @internal
+   */
+  createTree(priority: Priority): FacetNode {
+    const pri = this.priority ?? priority
+
+    const extensions = [...this.extension]
+    extensions.sort((a, b) => (a.priority ?? pri) - (b.priority ?? pri))
+
+    const children: FacetNode[] = extensions.map((ext) => ext.getTree(pri))
+
+    assert(children.length > 0)
+
+    let node = children[0]
+    for (let i = 1; i < children.length; i++) {
+      node = unionFacetNode(node, children[i])
+    }
+    return node
+  }
+}

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