@prosekit/core 0.8.2 → 0.8.4

package/src/utils/parse.ts

@@ -0,0 +1,321 @@
+import {
+  DOMParser,
+  DOMSerializer,
+  type ParseOptions,
+  type ProseMirrorNode,
+  type Schema,
+} from '@prosekit/pm/model'
+import { EditorState } from '@prosekit/pm/state'
+
+import type { DOMNode } from '../types/dom-node'
+import type {
+  NodeJSON,
+  StateJSON,
+} from '../types/model'
+
+import {
+  getBrowserDocument,
+  getBrowserWindow,
+} from './get-dom-api'
+
+/** @public */
+export interface DOMParserOptions extends ParseOptions {
+  DOMParser?: typeof DOMParser
+}
+
+/** @public */
+export interface DOMSerializerOptions {
+  DOMSerializer?: { fromSchema: typeof DOMSerializer.fromSchema }
+}
+
+/** @public */
+export interface DOMDocumentOptions {
+  /**
+   * The Document object to use for DOM operations. If not provided, defaults to
+   * the current browser's document object. Useful for server-side rendering or
+   * testing environments.
+   */
+  document?: Document
+}
+
+/** @public */
+export interface JSONParserOptions {
+  /**
+   * The editor schema to use.
+   */
+  schema: Schema
+}
+
+/////////////// JSON <=> State ///////////////
+
+/**
+ * Return a JSON object representing this state.
+ *
+ * @public
+ *
+ * @example
+ *
+ * ```ts
+ * const state = editor.state
+ * const json = jsonFromState(state)
+ * ```
+ */
+export function jsonFromState(state: EditorState): StateJSON {
+  return state.toJSON() as StateJSON
+}
+
+/**
+ * Parse a JSON object to a ProseMirror state.
+ *
+ * @public
+ *
+ * @example
+ *
+ * ```ts
+ * const json = { state: { type: 'doc', content: [{ type: 'paragraph' }], selection: { type: 'text', from: 1, to: 1 } } }
+ * const state = stateFromJSON(json, { schema: editor.schema })
+ * ```
+ */
+export function stateFromJSON(
+  json: StateJSON,
+  options: JSONParserOptions,
+): EditorState {
+  return EditorState.fromJSON({ schema: options.schema }, json)
+}
+
+/////////////// JSON <=> Node ///////////////
+
+/**
+ * Return a JSON object representing this node.
+ *
+ * @public
+ *
+ * @example
+ *
+ * ```ts
+ * const node = editor.state.doc
+ * const json = jsonFromNode(node)
+ * ```
+ */
+export function jsonFromNode(node: ProseMirrorNode): NodeJSON {
+  return node.toJSON() as NodeJSON
+}
+
+/**
+ * Parse a JSON object to a ProseMirror node.
+ *
+ * @public
+ *
+ * @example
+ *
+ * ```ts
+ * const json = { type: 'doc', content: [{ type: 'paragraph' }] }
+ * const node = nodeFromJSON(json, { schema: editor.schema })
+ * ```
+ */
+export function nodeFromJSON(
+  json: NodeJSON,
+  options: JSONParserOptions,
+): ProseMirrorNode {
+  return options.schema.nodeFromJSON(json)
+}
+
+/////////////// Node <=> Element ///////////////
+
+/**
+ * Parse a HTML element to a ProseMirror node.
+ *
+ * @public
+ *
+ * @example
+ *
+ * ```ts
+ * const element = document.getElementById('content')
+ * const node = nodeFromElement(element, { schema: editor.schema })
+ * ```
+ */
+export function nodeFromElement(
+  element: DOMNode,
+  options: DOMParserOptions & JSONParserOptions,
+): ProseMirrorNode {
+  const { DOMParser: CustomDOMParser, schema, ...parseOptions } = options
+  return (CustomDOMParser || DOMParser)
+    .fromSchema(schema)
+    .parse(element, parseOptions)
+}
+
+/**
+ * Serialize a ProseMirror node to a HTML element.
+ *
+ * @public
+ *
+ * @example
+ *
+ * ```ts
+ * const node = editor.state.doc
+ * const element = elementFromNode(node)
+ * ```
+ */
+export function elementFromNode(
+  node: ProseMirrorNode,
+  options?: DOMSerializerOptions & DOMDocumentOptions,
+): HTMLElement {
+  const Serializer = options?.DOMSerializer || DOMSerializer
+  const document = getBrowserDocument(options)
+  const schema = node.type.schema
+  const serializer = Serializer.fromSchema(schema)
+
+  if (schema.topNodeType !== node.type) {
+    return serializer.serializeNode(node, { document }) as HTMLElement
+  } else {
+    return serializer.serializeFragment(
+      node.content,
+      { document },
+      document.createElement('div'),
+    ) as HTMLElement
+  }
+}
+
+/////////////// Element <=> HTML ///////////////
+
+/**
+ * Parse a HTML string to a HTML element.
+ *
+ * @internal
+ */
+export function elementFromHTML(
+  html: string,
+  options?: DOMDocumentOptions,
+): HTMLElement {
+  const win = getBrowserWindow(options)
+  const parser = new win.DOMParser()
+  return parser.parseFromString(`<body><div>${html}</div></body>`, 'text/html')
+    .body.firstElementChild as HTMLElement
+}
+
+/**
+ * @internal
+ */
+function htmlFromElement(element: HTMLElement): string {
+  return element.outerHTML
+}
+
+/////////////// Node <=> HTML ///////////////
+
+/**
+ * Parse a HTML string to a ProseMirror node.
+ *
+ * @public
+ *
+ * @example
+ *
+ * ```ts
+ * const html = '<p>Hello, world!</p>'
+ * const node = nodeFromHTML(html, { schema: editor.schema })
+ * ```
+ */
+export function nodeFromHTML(
+  html: string,
+  options: DOMParserOptions & JSONParserOptions & DOMDocumentOptions,
+): ProseMirrorNode {
+  return nodeFromElement(elementFromHTML(html, options), options)
+}
+
+/**
+ * Serialize a ProseMirror node to a HTML string
+ *
+ * @public
+ *
+ * @example
+ *
+ * ```ts
+ * const node = document.getElementById('content')
+ * const html = htmlFromNode(node)
+ * ```
+ */
+export function htmlFromNode(
+  node: ProseMirrorNode,
+  options?: DOMSerializerOptions & DOMDocumentOptions,
+): string {
+  return elementFromNode(node, options).outerHTML
+}
+
+/////////////// JSON <=> Element ///////////////
+
+/**
+ * Serialize a HTML element to a ProseMirror document JSON object.
+ *
+ * @public
+ *
+ * @example
+ *
+ * ```ts
+ * const element = document.getElementById('content')
+ * const json = jsonFromElement(element, { schema: editor.schema })
+ * ```
+ */
+export function jsonFromElement(
+  element: DOMNode,
+  options: DOMParserOptions & JSONParserOptions,
+): NodeJSON {
+  return jsonFromNode(nodeFromElement(element, options))
+}
+
+/**
+ * Parse a ProseMirror document JSON object to a HTML element.
+ *
+ * @public
+ *
+ * @example
+ *
+ * ```ts
+ * const json = { type: 'doc', content: [{ type: 'paragraph' }] }
+ * const element = elementFromJSON(json, { schema: editor.schema })
+ * ```
+ */
+export function elementFromJSON(
+  json: NodeJSON,
+  options: JSONParserOptions & DOMSerializerOptions & DOMDocumentOptions,
+): HTMLElement {
+  return elementFromNode(nodeFromJSON(json, options), options)
+}
+
+/////////////// JSON <=> HTML ///////////////
+
+/**
+ * Parse a HTML string to a ProseMirror document JSON object.
+ *
+ * @public
+ *
+ * @example
+ *
+ * ```ts
+ * const html = '<p>Hello, world!</p>'
+ * const json = jsonFromHTML(html, { schema: editor.schema })
+ * ```
+ */
+export function jsonFromHTML(
+  html: string,
+  options: DOMDocumentOptions & DOMParserOptions & JSONParserOptions,
+): NodeJSON {
+  return jsonFromElement(elementFromHTML(html, options), options)
+}
+
+/**
+ * Parse a ProseMirror document JSON object to a HTML string.
+ *
+ * @public
+ *
+ * @example
+ *
+ * ```ts
+ * const json = { type: 'doc', content: [{ type: 'paragraph' }] }
+ * const html = htmlFromJSON(json, { schema: editor.schema })
+ * ```
+ */
+export function htmlFromJSON(
+  json: NodeJSON,
+  options: JSONParserOptions & DOMSerializerOptions & DOMDocumentOptions,
+): string {
+  return htmlFromElement(elementFromJSON(json, options))
+}

package/src/utils/remove-undefined-values.spec.ts

@@ -0,0 +1,15 @@
+import {
+  expect,
+  test,
+} from 'vitest'
+
+import { removeUndefinedValues } from './remove-undefined-values'
+
+test('removeUndefinedValues', () => {
+  const obj1 = { a: 1, b: undefined, c: null }
+  const obj2 = { a: 1, c: null }
+
+  expect(Object.keys(obj1).length).toEqual(3)
+  expect(Object.keys(obj2).length).toEqual(2)
+  expect(removeUndefinedValues(obj1)).toEqual(obj2)
+})

package/src/utils/remove-undefined-values.ts

@@ -0,0 +1,9 @@
+export function removeUndefinedValues<T extends object>(obj: T): T {
+  const result = {} as Record<string, unknown>
+  for (const [key, value] of Object.entries(obj)) {
+    if (value !== undefined) {
+      result[key] = value
+    }
+  }
+  return result as T
+}

package/src/utils/set-selection-around.ts

@@ -0,0 +1,11 @@
+import {
+  TextSelection,
+  type Transaction,
+} from '@prosekit/pm/state'
+
+export function setSelectionAround(tr: Transaction, pos: number): void {
+  const docSize = tr.doc.content.size
+  const $pos = tr.doc.resolve(pos > docSize ? docSize : pos < 0 ? 0 : pos)
+  const selection = TextSelection.between($pos, $pos)
+  tr.setSelection(selection)
+}

package/src/utils/type-assertion.ts

@@ -0,0 +1,91 @@
+import {
+  Fragment,
+  Mark,
+  ProseMirrorNode,
+  Slice,
+} from '@prosekit/pm/model'
+import {
+  AllSelection,
+  NodeSelection,
+  Selection,
+  TextSelection,
+} from '@prosekit/pm/state'
+
+/**
+ * Checks if the given object is a {@link ProseMirrorNode} instance.
+ */
+export function isProseMirrorNode(value: unknown): value is ProseMirrorNode {
+  return value instanceof ProseMirrorNode
+}
+
+/**
+ * Checks if the given object is a {@link Mark} instance.
+ *
+ * @public
+ */
+export function isMark(value: unknown): value is Mark {
+  return value instanceof Mark
+}
+
+/**
+ * Checks if the given object is a {@link Fragment} instance.
+ *
+ * @public
+ */
+export function isFragment(value: unknown): value is Fragment {
+  return value instanceof Fragment
+}
+
+/**
+ * Checks if the given object is a {@link Slice} instance.
+ *
+ * @public
+ */
+export function isSlice(value: unknown): value is Slice {
+  return value instanceof Slice
+}
+
+/**
+ * Checks if the given object is a {@link Selection} instance.
+ *
+ * @public
+ */
+export function isSelection(value: unknown): value is Selection {
+  return value instanceof Selection
+}
+
+/**
+ * Checks if the given object is a {@link TextSelection} instance.
+ *
+ * @public
+ */
+export function isTextSelection(value: Selection): value is TextSelection {
+  return value instanceof TextSelection
+}
+
+/**
+ * Checks if the given object is a {@link NodeSelection} instance.
+ *
+ * @public
+ */
+export function isNodeSelection(value: Selection): value is NodeSelection {
+  return value instanceof NodeSelection
+}
+
+/**
+ * Checks if the given object is a {@link AllSelection} instance.
+ *
+ * @public
+ */
+export function isAllSelection(value: Selection): value is AllSelection {
+  return value instanceof AllSelection
+}
+
+/**
+ * @internal
+ */
+export function isNotNullish<T>(
+  value: T | null | undefined,
+): value is T {
+  return value != null
+}

package/src/utils/unicode.spec.ts

@@ -0,0 +1,10 @@
+import {
+  expect,
+  test,
+} from 'vitest'
+
+import { OBJECT_REPLACEMENT_CHARACTER } from './unicode'
+
+test('constant value', () => {
+  expect(OBJECT_REPLACEMENT_CHARACTER).toBe('\uFFFC')
+})

package/src/utils/unicode.ts

@@ -0,0 +1,4 @@
+/**
+ * @internal
+ */
+export const OBJECT_REPLACEMENT_CHARACTER = '\uFFFC'

package/src/utils/with-skip-code-block.ts

@@ -0,0 +1,15 @@
+import type { Command } from '@prosekit/pm/state'
+
+import { isInCodeBlock } from './is-in-code-block'
+
+/**
+ * @internal
+ */
+export function withSkipCodeBlock(command: Command): Command {
+  return (state, dispatch, view) => {
+    if (isInCodeBlock(state.selection)) {
+      return false
+    }
+    return command(state, dispatch, view)
+  }
+}