@prosekit/core 0.8.3 → 0.8.5

package/src/utils/deep-equals.spec.ts

@@ -0,0 +1,26 @@
+import OrderedMap from 'orderedmap'
+import {
+  expect,
+  test,
+} from 'vitest'
+
+import { deepEquals } from './deep-equals'
+
+test('arrays with equal values are equal', () => {
+  expect(deepEquals([1, 2], [1, 2])).toBe(true)
+  expect(deepEquals([1, 2], [2, 1])).toBe(false)
+})
+
+test('nested objects', () => {
+  const a = { a: 1, b: { c: 3 } }
+  const b = { a: 1, b: { c: 3 } }
+  const c = { a: 1, b: { c: 4 } }
+  expect(deepEquals(a, b)).toBe(true)
+  expect(deepEquals(a, c)).toBe(false)
+})
+
+test('ordered maps', () => {
+  const map1 = OrderedMap.from({ a: 1, b: 2 })
+  const map2 = OrderedMap.from({ a: 1, b: 2 })
+  expect(deepEquals(map1, map2)).toBe(true)
+})

package/src/utils/deep-equals.ts

@@ -0,0 +1,29 @@
+import OrderedMap from 'orderedmap'
+
+export function deepEquals<T>(a: T, b: T): boolean {
+  if (a === b) {
+    return true
+  }
+
+  if (!a || !b) {
+    return false
+  }
+
+  if (Array.isArray(a) && Array.isArray(b)) {
+    return a.length === b.length && a.every((x, i) => deepEquals(x, b[i]))
+  }
+
+  if (a instanceof OrderedMap && b instanceof OrderedMap) {
+    return a.size === b.size && deepEquals(a.toObject(), b.toObject())
+  }
+
+  if (typeof a === 'object' && typeof b === 'object') {
+    const aKeys = Object.keys(a)
+    const bKeys = Object.keys(b)
+    return (
+      aKeys.length === bKeys.length
+      && aKeys.every((key) => deepEquals(a[key as keyof T], b[key as keyof T]))
+    )
+  }
+  return false
+}

package/src/utils/default-block-at.ts

@@ -0,0 +1,15 @@
+import type {
+  ContentMatch,
+  NodeType,
+} from '@prosekit/pm/model'
+
+/**
+ * @internal
+ */
+export function defaultBlockAt(match: ContentMatch): NodeType | null {
+  for (let i = 0; i < match.edgeCount; i++) {
+    const { type } = match.edge(i)
+    if (type.isTextblock && !type.hasRequiredAttrs()) return type
+  }
+  return null
+}

package/src/utils/editor-content.spec.ts

@@ -0,0 +1,47 @@
+import { AllSelection } from '@prosekit/pm/state'
+import {
+  expect,
+  test,
+} from 'vitest'
+
+import { setupTest } from '../testing'
+
+import { getEditorSelection } from './editor-content'
+
+test('getEditorSelection', () => {
+  const { n } = setupTest()
+  const doc = n.doc(n.paragraph('hello world'))
+  expect(getEditorSelection(doc, 'start').toJSON()).toMatchInlineSnapshot(`
+    {
+      "anchor": 1,
+      "head": 1,
+      "type": "text",
+    }
+  `)
+  expect(getEditorSelection(doc, 'end').toJSON()).toMatchInlineSnapshot(`
+      {
+        "anchor": 12,
+        "head": 12,
+        "type": "text",
+      }
+    `)
+  expect(
+    getEditorSelection(doc, {
+      anchor: 4,
+      head: 8,
+      type: 'text',
+    }).toJSON(),
+  ).toMatchInlineSnapshot(`
+    {
+      "anchor": 4,
+      "head": 8,
+      "type": "text",
+    }
+  `)
+  expect(getEditorSelection(doc, new AllSelection(doc)).toJSON())
+    .toMatchInlineSnapshot(`
+    {
+      "type": "all",
+    }
+  `)
+})

package/src/utils/editor-content.ts

@@ -0,0 +1,77 @@
+import { isElementLike } from '@ocavue/utils'
+import type {
+  ProseMirrorNode,
+  Schema,
+} from '@prosekit/pm/model'
+import { Selection } from '@prosekit/pm/state'
+
+import type {
+  NodeJSON,
+  SelectionJSON,
+} from '../types/model'
+
+import { assert } from './assert'
+import {
+  jsonFromElement,
+  jsonFromHTML,
+} from './parse'
+import {
+  isProseMirrorNode,
+  isSelection,
+} from './type-assertion'
+
+export function getEditorContentJSON(
+  schema: Schema,
+  content: NodeJSON | string | HTMLElement,
+): NodeJSON {
+  if (typeof content === 'string') {
+    return jsonFromHTML(content, { schema })
+  } else if (isElementLike(content)) {
+    return jsonFromElement(content, { schema })
+  } else {
+    return content
+  }
+}
+
+function getEditorContentNode(
+  schema: Schema,
+  content: NodeJSON | string | HTMLElement | ProseMirrorNode,
+): ProseMirrorNode {
+  if (isProseMirrorNode(content)) {
+    return content
+  }
+  return schema.nodeFromJSON(getEditorContentJSON(schema, content))
+}
+
+export function getEditorContentDoc(
+  schema: Schema,
+  content: NodeJSON | string | HTMLElement | ProseMirrorNode,
+): ProseMirrorNode {
+  const doc = getEditorContentNode(schema, content)
+  assert(
+    doc.type.schema === schema,
+    'Document schema does not match editor schema',
+  )
+  assert(
+    doc.type === schema.topNodeType,
+    `Document type does not match editor top node type. Expected ${schema.topNodeType.name}, got ${doc.type.name}`,
+  )
+  return doc
+}
+
+export function getEditorSelection(
+  doc: ProseMirrorNode,
+  selection: SelectionJSON | Selection | 'start' | 'end',
+): Selection {
+  if (isSelection(selection)) {
+    assert(selection.$head.doc === doc, 'Selection and doc do not match')
+    return selection
+  }
+  if (selection === 'start') {
+    return Selection.atStart(doc)
+  }
+  if (selection === 'end') {
+    return Selection.atEnd(doc)
+  }
+  return Selection.fromJSON(doc, selection)
+}

package/src/utils/env.ts

@@ -0,0 +1,6 @@
+/**
+ * @internal
+ */
+export const isApple: boolean = typeof navigator !== 'undefined'
+  ? /Mac|iP(hone|[ao]d)/.test(navigator.platform)
+  : false

package/src/utils/find-parent-node-of-type.ts

@@ -0,0 +1,29 @@
+import type {
+  NodeType,
+  ResolvedPos,
+} from '@prosekit/pm/model'
+
+import {
+  findParentNode,
+  type FindParentNodeResult,
+} from './find-parent-node'
+import { getNodeType } from './get-node-type'
+
+/**
+ * Finds the closest parent node that matches the given node type.
+ *
+ * @public
+ */
+export function findParentNodeOfType(
+  /**
+   * The type of the node to find.
+   */
+  type: NodeType | string,
+  /**
+   * The position to start searching from.
+   */
+  $pos: ResolvedPos,
+): FindParentNodeResult | undefined {
+  const nodeType = getNodeType($pos.doc.type.schema, type)
+  return findParentNode((node) => node.type === nodeType, $pos)
+}

package/src/utils/find-parent-node.spec.ts

@@ -0,0 +1,68 @@
+import {
+  describe,
+  expect,
+  it,
+} from 'vitest'
+
+import { setupTest } from '../testing'
+
+import { findParentNode } from './find-parent-node'
+
+describe('findParentNode', () => {
+  it('finds parent node with cursor directly inside', () => {
+    const { editor, n } = setupTest()
+    editor.set(n.doc(n.p('foo'), n.p('bar<a>')))
+    const found = findParentNode(
+      (node) => node.type.name === 'paragraph',
+      editor.state.selection.$anchor,
+    )
+    expect(found).toMatchInlineSnapshot(`
+      {
+        "depth": 1,
+        "node": {
+          "content": [
+            {
+              "text": "bar",
+              "type": "text",
+            },
+          ],
+          "type": "paragraph",
+        },
+        "pos": 5,
+        "start": 6,
+      }
+    `)
+  })
+
+  it('can handle the top-level node', () => {
+    const { editor, n } = setupTest()
+    editor.set(n.doc(n.p('foo<a>')))
+
+    expect(
+      findParentNode(
+        (node) => node.type.name === 'doc',
+        editor.state.selection.$anchor,
+      ),
+    ).toMatchInlineSnapshot(`
+      {
+        "depth": 0,
+        "node": {
+          "content": [
+            {
+              "content": [
+                {
+                  "text": "foo",
+                  "type": "text",
+                },
+              ],
+              "type": "paragraph",
+            },
+          ],
+          "type": "doc",
+        },
+        "pos": 0,
+        "start": 0,
+      }
+    `)
+  })
+})

package/src/utils/find-parent-node.ts

@@ -0,0 +1,55 @@
+import type {
+  ProseMirrorNode,
+  ResolvedPos,
+} from '@prosekit/pm/model'
+
+/**
+ * @public
+ */
+export interface FindParentNodeResult {
+  /**
+   * The closest parent node that satisfies the predicate.
+   */
+  node: ProseMirrorNode
+
+  /**
+   * The position directly before the node.
+   */
+  pos: number
+
+  /**
+   * The position at the start of the node.
+   */
+  start: number
+
+  /**
+   * The depth of the node.
+   */
+  depth: number
+}
+
+/**
+ * Find the closest parent node that satisfies the predicate.
+ *
+ * @public
+ */
+export function findParentNode(
+  /**
+   * The predicate to test the parent node.
+   */
+  predicate: (node: ProseMirrorNode) => boolean,
+  /**
+   * The position to start searching from.
+   */
+  $pos: ResolvedPos,
+): FindParentNodeResult | undefined {
+  for (let depth = $pos.depth; depth >= 0; depth -= 1) {
+    const node = $pos.node(depth)
+
+    if (predicate(node)) {
+      const pos = depth === 0 ? 0 : $pos.before(depth)
+      const start = $pos.start(depth)
+      return { node, pos, start, depth }
+    }
+  }
+}

package/src/utils/get-custom-selection.ts

@@ -0,0 +1,19 @@
+import {
+  TextSelection,
+  type EditorState,
+  type Selection,
+} from '@prosekit/pm/state'
+
+export function getCustomSelection(
+  state: EditorState,
+  from?: number | null,
+  to?: number | null,
+): Selection {
+  const pos = from ?? to
+  if (pos != null) {
+    const $from = state.doc.resolve(from ?? pos)
+    const $to = state.doc.resolve(to ?? pos)
+    return TextSelection.between($from, $to)
+  }
+  return state.selection
+}

package/src/utils/get-dom-api.ts

@@ -0,0 +1,56 @@
+import { DOMDocumentNotFoundError } from '../error'
+
+function findGlobalBrowserDocument() {
+  if (typeof document !== 'undefined') {
+    return document
+  }
+
+  if (typeof globalThis !== 'undefined' && globalThis.document) {
+    return globalThis.document
+  }
+}
+
+function findGlobalBrowserWindow() {
+  if (typeof window !== 'undefined') {
+    return window
+  }
+
+  if (typeof globalThis !== 'undefined' && globalThis.window) {
+    return globalThis.window
+  }
+}
+
+function findBrowserDocument(options?: { document?: Document }): Document | undefined {
+  return (
+    options?.document
+      ?? findGlobalBrowserDocument()
+      ?? findGlobalBrowserWindow()?.document
+  )
+}
+
+function findBrowserWindow(options?: {
+  document?: Document
+}): (Window & typeof globalThis) | undefined {
+  return (
+    options?.document?.defaultView
+      ?? findGlobalBrowserWindow()
+      ?? findBrowserDocument(options)?.defaultView
+      ?? undefined
+  )
+}
+
+export function getBrowserDocument(options?: {
+  document?: Document
+}): Document {
+  const doc = findBrowserDocument(options)
+  if (doc) return doc
+  throw new DOMDocumentNotFoundError()
+}
+
+export function getBrowserWindow(options?: {
+  document?: Document
+}): Window & typeof globalThis {
+  const win = findBrowserWindow(options)
+  if (win) return win
+  throw new DOMDocumentNotFoundError()
+}

package/src/utils/get-id.spec.ts

@@ -0,0 +1,14 @@
+import {
+  expect,
+  test,
+} from 'vitest'
+
+import { getId } from './get-id'
+
+test('generates sequential ids', () => {
+  const first = getId()
+  const second = getId()
+  const firstNum = Number(first.split(':')[1])
+  const secondNum = Number(second.split(':')[1])
+  expect(secondNum).toBe((firstNum + 1) % Number.MAX_SAFE_INTEGER)
+})

package/src/utils/get-id.ts

@@ -0,0 +1,13 @@
+let id = 0
+
+/**
+ * Returns a unique id in the current process that can be used in various places.
+ *
+ * @internal
+ *
+ * @deprecated Import `getId` from `@ocavue/utils` package instead. Remove it in a future version.
+ */
+export function getId(): string {
+  id = (id + 1) % Number.MAX_SAFE_INTEGER
+  return `id:${id}`
+}

package/src/utils/get-mark-type.ts

@@ -0,0 +1,20 @@
+import type {
+  MarkType,
+  Schema,
+} from '@prosekit/pm/model'
+
+import { ProseKitError } from '../error'
+
+/**
+ * @internal
+ */
+export function getMarkType(schema: Schema, type: string | MarkType): MarkType {
+  if (typeof type === 'string') {
+    const markType = schema.marks[type]
+    if (!markType) {
+      throw new ProseKitError(`Cannot find mark type "${type}"`)
+    }
+    return markType
+  }
+  return type
+}

package/src/utils/get-node-type.ts

@@ -0,0 +1,20 @@
+import type {
+  NodeType,
+  Schema,
+} from '@prosekit/pm/model'
+
+import { ProseKitError } from '../error'
+
+/**
+ * @internal
+ */
+export function getNodeType(schema: Schema, type: string | NodeType): NodeType {
+  if (typeof type === 'string') {
+    const nodeType = schema.nodes[type]
+    if (!nodeType) {
+      throw new ProseKitError(`Cannot find ProseMirror node type "${type}"`)
+    }
+    return nodeType
+  }
+  return type
+}

package/src/utils/get-node-types.ts

@@ -0,0 +1,19 @@
+import type {
+  NodeType,
+  Schema,
+} from '@prosekit/pm/model'
+
+import { getNodeType } from './get-node-type'
+
+/**
+ * @internal
+ */
+export function getNodeTypes(
+  schema: Schema,
+  types: string | NodeType | string[] | NodeType[],
+): NodeType[] {
+  if (Array.isArray(types)) {
+    return types.map((type) => getNodeType(schema, type))
+  }
+  return [getNodeType(schema, types)]
+}

package/src/utils/includes-mark.ts

@@ -0,0 +1,18 @@
+import type {
+  Attrs,
+  Mark,
+  MarkType,
+} from '@prosekit/pm/model'
+
+import { isSubset } from './is-subset'
+
+export function includesMark(
+  marks: readonly Mark[],
+  markType: MarkType,
+  attrs?: Attrs | null,
+): boolean {
+  attrs = attrs || {}
+  return marks.some((mark) => {
+    return mark.type === markType && isSubset(attrs, mark.attrs)
+  })
+}

package/src/utils/is-at-block-start.ts

@@ -0,0 +1,26 @@
+import type { ResolvedPos } from '@prosekit/pm/model'
+import type {
+  EditorState,
+  TextSelection,
+} from '@prosekit/pm/state'
+import type { EditorView } from '@prosekit/pm/view'
+
+/**
+ * Whether the selection is an empty text selection at the start of a block.
+ *
+ * @internal
+ */
+export function isAtBlockStart(
+  state: EditorState,
+  view?: EditorView,
+): ResolvedPos | null {
+  // Copy from https://github.com/ProseMirror/prosemirror-commands/blob/1.5.2/src/commands.ts#L15
+  const { $cursor } = state.selection as TextSelection
+  if (
+    !$cursor
+    || (view ? !view.endOfTextblock('backward', state) : $cursor.parentOffset > 0)
+  ) {
+    return null
+  }
+  return $cursor
+}

package/src/utils/is-in-code-block.ts

@@ -0,0 +1,18 @@
+import type { NodeType } from '@prosekit/pm/model'
+import type { Selection } from '@prosekit/pm/state'
+
+function isCodeBlockType(type: NodeType): boolean {
+  return !!(type.spec.code && type.isBlock)
+}
+
+/**
+ * Check if the selection is in a code block.
+ *
+ * @internal
+ */
+export function isInCodeBlock(selection: Selection): boolean {
+  return (
+    isCodeBlockType(selection.$from.parent.type)
+    || isCodeBlockType(selection.$to.parent.type)
+  )
+}

package/src/utils/is-mark-absent.spec.ts

@@ -0,0 +1,53 @@
+import {
+  expect,
+  test,
+} from 'vitest'
+
+import { setupTest } from '../testing'
+
+import { isMarkAbsent } from './is-mark-absent'
+
+test('isMarkAbsent', () => {
+  const { editor, m, n } = setupTest()
+
+  const isBoldAbsent = () => {
+    const markType = editor.schema.marks.bold
+    const { doc, selection } = editor.state
+    return isMarkAbsent(doc, selection.from, selection.to, markType)
+  }
+
+  editor.set(n.doc(n.p('<a>foo<b>')))
+  expect(isBoldAbsent()).toBe(true)
+
+  editor.set(n.doc(n.p('<a>', m.bold('foo'), '<b>')))
+  expect(isBoldAbsent()).toBe(false)
+
+  editor.set(n.doc(n.p('<a>', 'foo', m.bold('bar'), 'baz', '<b>')))
+  expect(isBoldAbsent()).toBe(true)
+
+  editor.set(n.doc(n.p('<a>', m.bold('foo'), 'bar', '<b>')))
+  expect(isBoldAbsent()).toBe(true)
+
+  editor.set(n.doc(n.p('<a>', 'foo', m.bold('bar'), '<b>')))
+  expect(isBoldAbsent()).toBe(true)
+
+  editor.set(n.doc(n.p('<a>'), n.p('foo'), n.p('<b>')))
+  expect(isBoldAbsent()).toBe(true)
+
+  editor.set(n.doc(n.p('<a>'), n.p('foo'), n.p(m.bold('bar')), n.p('<b>')))
+  expect(isBoldAbsent()).toBe(true)
+
+  editor.set(n.doc(n.p('<a>'), n.p(''), n.p(''), n.p('<b>')))
+  expect(isBoldAbsent()).toBe(true)
+
+  editor.set(
+    n.doc(n.p('<a>'), n.p(m.bold('foo')), n.p(m.bold('bar')), n.p('<b>')),
+  )
+  expect(isBoldAbsent()).toBe(false)
+
+  editor.set(n.doc(n.p('<a>'), n.p(m.bold('foo')), n.p(), n.p('<b>')))
+  expect(isBoldAbsent()).toBe(false)
+
+  editor.set(n.doc(n.codeBlock('<a>', 'foo', '<b>')))
+  expect(isBoldAbsent()).toBe(true)
+})

package/src/utils/is-mark-absent.ts

@@ -0,0 +1,42 @@
+import type {
+  Attrs,
+  MarkType,
+  ProseMirrorNode,
+} from '@prosekit/pm/model'
+
+import { includesMark } from './includes-mark'
+
+/**
+ * Returns true if the given mark is missing in some part of the range.
+ * Returns false if the entire range has the given mark.
+ * Returns true if the mark is not allowed in the range.
+ *
+ * @internal
+ */
+export function isMarkAbsent(
+  node: ProseMirrorNode,
+  from: number,
+  to: number,
+  markType: MarkType,
+  attrs?: Attrs | null,
+): boolean {
+  let missing = false
+  let available = false
+
+  node.nodesBetween(from, to, (node, pos, parent) => {
+    if (missing) {
+      return false
+    }
+
+    const allowed = parent?.type.allowsMarkType(markType)
+      && !node.marks.some((m) => m.type !== markType && m.type.excludes(markType))
+
+    if (allowed) {
+      available = true
+      if (!includesMark(node.marks, markType, attrs)) {
+        missing = true
+      }
+    }
+  })
+  return available ? missing : true
+}