@prosekit/core 0.8.3 → 0.8.5

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

@@ -0,0 +1,27 @@
+import type {
+  Attrs,
+  MarkType,
+} from '@prosekit/pm/model'
+import type { EditorState } from '@prosekit/pm/state'
+
+import { getMarkType } from './get-mark-type'
+import { includesMark } from './includes-mark'
+import { isMarkAbsent } from './is-mark-absent'
+
+/**
+ * @internal
+ */
+export function isMarkActive(
+  state: EditorState,
+  type: string | MarkType,
+  attrs?: Attrs | null,
+): boolean {
+  const { from, $from, to, empty } = state.selection
+  const markType = getMarkType(state.schema, type)
+  if (empty) {
+    const marks = state.storedMarks || $from.marks()
+    return includesMark(marks, markType, attrs)
+  } else {
+    return !isMarkAbsent(state.doc, from, to, markType, attrs)
+  }
+}

package/src/utils/is-node-active.ts

@@ -0,0 +1,25 @@
+import type {
+  Attrs,
+  NodeType,
+} from '@prosekit/pm/model'
+import type { EditorState } from '@prosekit/pm/state'
+
+import { attrsMatch } from './attrs-match'
+import { getNodeType } from './get-node-type'
+
+export function isNodeActive(
+  state: EditorState,
+  type: string | NodeType,
+  attrs?: Attrs | null,
+): boolean {
+  const $pos = state.selection.$from
+  const nodeType = getNodeType(state.schema, type)
+
+  for (let depth = $pos.depth; depth >= 0; depth--) {
+    const node = $pos.node(depth)
+    if (node.type === nodeType && (!attrs || attrsMatch(node, attrs))) {
+      return true
+    }
+  }
+  return false
+}

package/src/utils/is-subset.spec.ts

@@ -0,0 +1,12 @@
+import {
+  expect,
+  test,
+} from 'vitest'
+
+import { isSubset } from './is-subset'
+
+test('isSubset', () => {
+  expect(isSubset({ a: 1, b: 2 }, { a: 1, b: 2, c: 3 })).toBe(true)
+  expect(isSubset({ a: 1, b: 2, c: 3 }, { a: 1, b: 2 })).toBe(false)
+  expect(isSubset({ a: 1, b: 2, c: 3 }, { a: 1, b: 2, c: 4 })).toBe(false)
+})

package/src/utils/is-subset.ts

@@ -0,0 +1,11 @@
+/**
+ * Check if `subset` is a subset of `superset`.
+ *
+ * @internal
+ */
+export function isSubset(
+  subset: Record<string, unknown>,
+  superset: Record<string, unknown>,
+): boolean {
+  return Object.keys(subset).every((key) => subset[key] === superset[key])
+}

package/src/utils/maybe-run.spec.ts

@@ -0,0 +1,39 @@
+import {
+  expect,
+  test,
+  vi,
+} from 'vitest'
+
+import { maybeRun } from './maybe-run'
+
+test('executes function argument', () => {
+  const fn = vi.fn((x: number) => x + 1)
+  expect(maybeRun(fn, 2)).toBe(3)
+  expect(fn).toHaveBeenCalledWith(2)
+})
+
+test('returns value when not a function', () => {
+  expect(maybeRun(5)).toBe(5)
+  expect(maybeRun(undefined)).toBeUndefined()
+})
+
+test('provides precise inference', () => {
+  const fn: () => number = () => 1
+  const num = 2
+  const input: number | (() => number) = Math.random() > 0.5 ? fn : num
+  const result: number = maybeRun(input)
+  expect(result).toBeTypeOf('number')
+})
+
+test('can prevent unexpected arguments', () => {
+  const fn: (num: number) => number = (num) => num + 1
+
+  // @ts-expect-error: unexpected string argument
+  maybeRun(fn, 'string')
+
+  // @ts-expect-error: unexpected argument count
+  maybeRun(fn)
+
+  // @ts-expect-error: unexpected argument count
+  maybeRun(fn, 1, 2)
+})

package/src/utils/maybe-run.ts

@@ -0,0 +1,11 @@
+/**
+ * @internal
+ */
+export function maybeRun<
+  Value,
+  Args extends unknown[],
+>(value: Value | ((...args: Args) => Value), ...args: Args): Value {
+  return typeof value === 'function'
+    ? (value as (...args: Args) => Value)(...args)
+    : value
+}

package/src/utils/merge-objects.spec.ts

@@ -0,0 +1,30 @@
+import {
+  expect,
+  test,
+} from 'vitest'
+
+import { mergeObjects } from './merge-objects'
+
+// basic merge
+test('merge simple objects', () => {
+  const a = { a: 1 }
+  const b = { b: 2 }
+  expect(
+    mergeObjects<{ a: number; b: number }>(a, b),
+  ).toEqual({ a: 1, b: 2 })
+})
+
+// undefined values should be removed and overwritten
+test('skip undefined values and override', () => {
+  const a = { a: 1, b: undefined as number | undefined }
+  const b = { b: 2 }
+  expect(
+    mergeObjects<{ a: number; b: number | undefined }>(a, b),
+  ).toEqual({ a: 1, b: 2 })
+})
+
+// null or undefined arguments should be ignored
+test('ignore null and undefined inputs', () => {
+  const a = { a: 1 }
+  expect(mergeObjects(null, undefined, a)).toEqual({ a: 1 })
+})

package/src/utils/merge-objects.ts

@@ -0,0 +1,11 @@
+import { removeUndefinedValues } from './remove-undefined-values'
+import { isNotNullish } from './type-assertion'
+
+export function mergeObjects<T extends object>(
+  ...objects: Array<Partial<T> | null | undefined>
+): Partial<T> {
+  const filteredObjects = objects
+    .filter(isNotNullish)
+    .map(removeUndefinedValues)
+  return Object.assign({}, ...filteredObjects) as Partial<T>
+}

package/src/utils/merge-specs.ts

@@ -0,0 +1,35 @@
+import type {
+  MarkSpec,
+  NodeSpec,
+} from '@prosekit/pm/model'
+
+import { mergeObjects } from './merge-objects'
+
+function mergeSpecs(a: NodeSpec, b: NodeSpec): NodeSpec
+function mergeSpecs(a: MarkSpec, b: MarkSpec): MarkSpec
+function mergeSpecs(
+  a: NodeSpec | MarkSpec,
+  b: NodeSpec | MarkSpec,
+): NodeSpec | MarkSpec {
+  type T = typeof a
+
+  const attrs: T['attrs'] = {}
+  const attrNames = new Set([
+    ...Object.keys(a.attrs ?? {}),
+    ...Object.keys(b.attrs ?? {}),
+  ])
+  for (const name of attrNames) {
+    const attrSpecA = a.attrs?.[name]
+    const attrSpecB = b.attrs?.[name]
+    const attrSpecMerged = mergeObjects(attrSpecA, attrSpecB)
+    if (attrSpecMerged) {
+      attrs[name] = attrSpecMerged
+    }
+  }
+
+  const parseDOM: T['parseDOM'] = [...(a.parseDOM ?? []), ...(b.parseDOM ?? [])]
+
+  return mergeObjects<T>(a, b, { attrs, parseDOM })
+}
+
+export { mergeSpecs }

package/src/utils/object-equal.spec.ts

@@ -0,0 +1,26 @@
+import {
+  expect,
+  test,
+} from 'vitest'
+
+import { objectEqual } from './object-equal'
+
+test('objects with same keys and values are equal', () => {
+  expect(objectEqual({ a: 1, b: 2 }, { a: 1, b: 2 })).toBe(true)
+})
+
+test('different keys result in inequality', () => {
+  expect(objectEqual({ a: 1, b: 2 }, { a: 1, c: 2 })).toBe(false)
+})
+
+test('nested objects are compared recursively', () => {
+  const obj1 = { a: { c: 3 }, b: 2 }
+  const obj2 = { a: { c: 3 }, b: 2 }
+  expect(objectEqual(obj1, obj2)).toBe(true)
+})
+
+test('nested objects with different values are not equal', () => {
+  const obj1 = { a: { c: 3 }, b: 2 }
+  const obj2 = { a: { c: 4 }, b: 2 }
+  expect(objectEqual(obj1, obj2)).toBe(false)
+})

package/src/utils/object-equal.ts

@@ -0,0 +1,28 @@
+export function objectEqual<T>(a: T, b: T): boolean {
+  if (a === b) {
+    return true
+  }
+  if (typeof a !== 'object' || typeof b !== 'object') {
+    return false
+  }
+  if (a === null || b === null) {
+    return false
+  }
+  if (Array.isArray(a) || Array.isArray(b)) {
+    return false
+  }
+  const aKeys = Object.keys(a) as (keyof T)[]
+  const bKeys = Object.keys(b) as (keyof T)[]
+  if (aKeys.length !== bKeys.length) {
+    return false
+  }
+  for (const key of aKeys) {
+    if (!bKeys.includes(key)) {
+      return false
+    }
+    if (!objectEqual(a[key], b[key])) {
+      return false
+    }
+  }
+  return true
+}

package/src/utils/output-spec.test.ts

@@ -0,0 +1,95 @@
+import type { DOMOutputSpec } from '@prosekit/pm/model'
+import {
+  describe,
+  expect,
+  it,
+} from 'vitest'
+
+import { insertOutputSpecAttrs } from './output-spec'
+
+describe('insertOutputSpecAttrs', () => {
+  it('should insert attrs into an array without attributes', () => {
+    const spec: DOMOutputSpec = ['input']
+    const result = insertOutputSpecAttrs(spec, [
+      ['data-foo', 'foo'],
+      ['checked', ''],
+      ['style', 'background-color: red'],
+      ['style', 'color: blue'],
+    ])
+    expect(result).toMatchInlineSnapshot(`
+      [
+        "input",
+        {
+          "checked": "",
+          "data-foo": "foo",
+          "style": "color: blue; background-color: red",
+        },
+      ]
+    `)
+  })
+
+  it('should insert attrs into an array with attributes', () => {
+    const spec: DOMOutputSpec = ['input', { type: 'checkbox' }]
+    const result = insertOutputSpecAttrs(spec, [
+      ['data-foo', 'foo'],
+      ['checked', ''],
+      ['style', 'background-color: red'],
+      ['style', 'color: blue'],
+    ])
+    expect(result).toMatchInlineSnapshot(`
+      [
+        "input",
+        {
+          "checked": "",
+          "data-foo": "foo",
+          "style": "color: blue; background-color: red",
+          "type": "checkbox",
+        },
+      ]
+    `)
+  })
+
+  it('should insert attrs into an element', () => {
+    const element = document.createElement('input')
+    element.type = 'checkbox'
+
+    const spec: DOMOutputSpec = element
+    const result = insertOutputSpecAttrs(spec, [
+      ['data-foo', 'foo'],
+      ['checked', ''],
+      ['style', 'background-color: red'],
+      ['style', 'color: blue'],
+    ])
+    expect(result).toMatchInlineSnapshot(`
+      <input
+        checked=""
+        data-foo="foo"
+        style="color: blue; background-color: red"
+        type="checkbox"
+      />
+    `)
+  })
+
+  it('should insert attrs into an object ', () => {
+    const element = document.createElement('input')
+    element.type = 'checkbox'
+
+    const spec: DOMOutputSpec = { dom: element }
+    const result = insertOutputSpecAttrs(spec, [
+      ['data-foo', 'foo'],
+      ['checked', ''],
+      ['style', 'background-color: red'],
+      ['style', 'color: blue'],
+    ])
+    expect(result).toMatchInlineSnapshot(`
+      {
+        "dom": <input
+          checked=""
+          data-foo="foo"
+          style="color: blue; background-color: red"
+          type="checkbox"
+        />,
+      }
+    `)
+  })
+})

package/src/utils/output-spec.ts

@@ -0,0 +1,130 @@
+import { isElementLike } from '@ocavue/utils'
+import type {
+  DOMOutputSpec,
+  Mark,
+  ProseMirrorNode,
+  TagParseRule,
+} from '@prosekit/pm/model'
+
+import { isNotNullish } from './type-assertion'
+
+interface AttrOptions {
+  attr: string
+  toDOM?: (value: unknown) => [key: string, value: string] | null | undefined
+  parseDOM?: (node: HTMLElement) => unknown
+}
+
+export function wrapOutputSpecAttrs<
+  T extends ProseMirrorNode | Mark,
+  Args extends readonly unknown[],
+>(
+  toDOM: (node: T, ...args: Args) => DOMOutputSpec,
+  options: AttrOptions[],
+): (node: T, ...args: Args) => DOMOutputSpec {
+  return (node, ...args) => {
+    const dom = toDOM(node, ...args)
+    const pairs = options
+      .map((option) => option.toDOM?.(node.attrs[option.attr]))
+      .filter(isNotNullish)
+    return insertOutputSpecAttrs(dom, pairs)
+  }
+}
+
+export function wrapTagParseRuleAttrs(
+  rule: TagParseRule,
+  options: AttrOptions[],
+): TagParseRule {
+  const existingGetAttrs = rule.getAttrs
+  const existingAttrs = rule.attrs
+
+  return {
+    ...rule,
+    getAttrs: (dom) => {
+      const baseAttrs = existingGetAttrs?.(dom) ?? existingAttrs ?? {}
+
+      if (baseAttrs === false || !dom || !isElementLike(dom)) {
+        return baseAttrs ?? null
+      }
+
+      const insertedAttrs: Record<string, unknown> = {}
+
+      for (const option of options) {
+        if (option.parseDOM) {
+          insertedAttrs[option.attr] = option.parseDOM(dom)
+        }
+      }
+
+      return { ...baseAttrs, ...insertedAttrs }
+    },
+  }
+}
+
+export function insertOutputSpecAttrs(
+  dom: DOMOutputSpec,
+  attrs: Array<[key: string, value: string]>,
+): DOMOutputSpec {
+  if (!dom) {
+    return dom
+  }
+
+  if (Array.isArray(dom)) {
+    const rest = dom.slice(1) as Array<unknown>
+    let oldAttrs: Record<string, unknown>
+
+    if (rest.length > 0 && (rest[0] == null || typeof rest[0] === 'object')) {
+      oldAttrs = rest.shift() as Record<string, unknown>
+    } else {
+      oldAttrs = {}
+    }
+
+    const newAttrs = setObjectAttributes(oldAttrs, attrs)
+    return [dom[0], newAttrs, ...rest]
+  }
+
+  if (isElementLike(dom)) {
+    return setElementAttributes(dom, attrs)
+  }
+
+  if (typeof dom === 'object' && 'dom' in dom && isElementLike(dom.dom)) {
+    return { ...dom, dom: setElementAttributes(dom.dom, attrs) }
+  }
+
+  return dom
+}
+
+function setObjectAttributes(
+  obj: Record<string, unknown>,
+  attrs: Array<[key: string, value: string]>,
+): Record<string, unknown> {
+  obj = { ...obj }
+  for (const [key, value] of attrs) {
+    const oldValue = obj[key]
+    const newValue = key === 'style'
+      ? joinStyles(value, typeof oldValue === 'string' ? oldValue : '')
+      : value
+    obj[key] = newValue
+  }
+  return obj
+}
+
+function setElementAttributes(
+  element: Element,
+  attrs: Array<[key: string, value: string]>,
+): Element {
+  element = element.cloneNode(true) as Element
+  for (const [key, value] of attrs) {
+    const oldValue = element.getAttribute(key)
+    const newValue = key === 'style'
+      ? joinStyles(value, typeof oldValue === 'string' ? oldValue : '')
+      : value
+    element.setAttribute(key, newValue)
+  }
+  return element
+}
+
+function joinStyles(...styles: string[]) {
+  return styles
+    .map((style) => style.trim().replace(/;$/, ''))
+    .filter(Boolean)
+    .join('; ')
+}

package/src/utils/parse.spec.ts

@@ -0,0 +1,46 @@
+import {
+  describe,
+  expect,
+  test,
+} from 'vitest'
+
+import { createEditor } from '../editor/editor'
+import { defineTestExtension } from '../testing'
+
+import {
+  elementFromHTML,
+  htmlFromNode,
+  nodeFromElement,
+  nodeFromHTML,
+} from './parse'
+
+describe('parse', () => {
+  const extension = defineTestExtension()
+  const editor = createEditor({ extension })
+  const schema = editor.schema
+  const n = editor.nodes
+
+  const element = document.createElement('div')
+  element.innerHTML = '<p>hello</p>'
+
+  const node = n.doc(n.paragraph(schema.text('hello')))
+
+  const html = '<p>hello</p>'
+
+  test('nodeFromElement', () => {
+    expect(node.eq(nodeFromElement(element, { schema }))).toBe(true)
+  })
+
+  test('nodeFromHTML', () => {
+    expect(nodeFromHTML(html, { schema }).eq(node)).toBe(true)
+  })
+
+  test('elementFromHTML', () => {
+    expect(elementFromHTML(html).innerHTML).toBe(html)
+  })
+
+  test('htmlFromNode', () => {
+    expect(htmlFromNode(node)).toBe('<div><p>hello</p></div>')
+    expect(htmlFromNode(node.child(0))).toBe('<p>hello</p>')
+  })
+})