@prosekit/core 0.8.2 → 0.8.4

package/src/types/model.ts

@@ -0,0 +1,54 @@
+/**
+ * A JSON representation of the prosemirror node.
+ *
+ * @public
+ */
+export interface NodeJSON {
+  type: string
+  marks?: Array<{ type: string; attrs?: Record<string, any> }>
+  text?: string
+  content?: NodeJSON[]
+  attrs?: Record<string, any>
+}
+
+/**
+ * A JSON representation of the prosemirror selection.
+ *
+ * @public
+ */
+export interface SelectionJSON {
+  anchor: number
+  head: number
+  type: string
+}
+
+/**
+ * A JSON representation of the prosemirror state.
+ *
+ * @public
+ */
+export interface StateJSON {
+  /**
+   * The main `ProseMirror` doc.
+   */
+  doc: NodeJSON
+
+  /**
+   * The current selection.
+   */
+  selection: SelectionJSON
+}
+
+/**
+ * A JSON representation of the prosemirror step.
+ *
+ * @public
+ */
+export interface StepJSON {
+  /**
+   * The type of the step.
+   */
+  stepType: string
+
+  [x: string]: unknown
+}

package/src/types/object-entries.ts

@@ -0,0 +1,13 @@
+/**
+ * @internal
+ *
+ * @example
+ *
+ * ```
+ * type MyObject = { a: 1; b: 'B' }
+ * type MyEntries = ObjectEntries<MyObject>
+ * //   ^ ["a", 1] | ["b", "B"]
+ */
+export type ObjectEntries<T extends Record<string, any>> = {
+  [K in keyof T]: [K, T[K]]
+}[keyof T]

package/src/types/pick-string-literal.spec.ts

@@ -0,0 +1,10 @@
+import { test } from 'vitest'
+
+import { assertTypeEqual } from './assert-type-equal'
+import type { PickStringLiteral } from './pick-string-literal'
+
+test('PickStringLiteral', () => {
+  assertTypeEqual<PickStringLiteral<'foo'>, 'foo'>(true)
+  assertTypeEqual<PickStringLiteral<'foo' | 'bar'>, 'foo' | 'bar'>(true)
+  assertTypeEqual<PickStringLiteral<string>, never>(true)
+})

package/src/types/pick-string-literal.ts

@@ -0,0 +1,6 @@
+import type { PickSubType } from './pick-sub-type'
+
+/**
+ * @internal
+ */
+export type PickStringLiteral<T> = PickSubType<T, string>

package/src/types/pick-sub-type.spec.ts

@@ -0,0 +1,20 @@
+import { test } from 'vitest'
+
+import { assertTypeEqual } from './assert-type-equal'
+import type { PickSubType } from './pick-sub-type'
+
+test('PickSubType', () => {
+  assertTypeEqual<PickSubType<'abc', string>, 'abc'>(true)
+  assertTypeEqual<PickSubType<'abc' | 'def', string>, 'abc' | 'def'>(true)
+  assertTypeEqual<PickSubType<123, string>, never>(true)
+  assertTypeEqual<PickSubType<string, string>, never>(true)
+
+  assertTypeEqual<PickSubType<{ foo: 1 }, Record<string, number>>, { foo: 1 }>(
+    true,
+  )
+  assertTypeEqual<PickSubType<{ foo: 1 }, Record<string, string>>, never>(true)
+  assertTypeEqual<
+    PickSubType<Record<string, number>, Record<string, string>>,
+    never
+  >(true)
+})

package/src/types/pick-sub-type.ts

@@ -0,0 +1,6 @@
+/**
+ * @internal
+ */
+export type PickSubType<Type, ParentType> = Type extends ParentType ? [ParentType] extends [Type] ? never
+  : Type
+  : never

package/src/types/priority.ts

@@ -0,0 +1,12 @@
+/**
+ * ProseKit extension priority.
+ *
+ * @public
+ */
+export enum Priority {
+  lowest = 0,
+  low = 1,
+  default = 2,
+  high = 3,
+  highest = 4,
+}

package/src/types/setter.ts

@@ -0,0 +1,4 @@
+/**
+ * @internal
+ */
+export type Setter<T> = (value: T) => void

package/src/types/simplify-deeper.spec.ts

@@ -0,0 +1,40 @@
+import type { Simplify } from 'type-fest'
+import { test } from 'vitest'
+
+import { assertTypeEqual } from './assert-type-equal'
+import type { SimplifyDeeper } from './simplify-deeper'
+
+test('SimplifyDeeper', () => {
+  type T1 = {
+    nodeA: {
+      attr1: string
+    } & {
+      attr2: string
+    }
+  } & {
+    nodeB: {
+      attr3: string
+    } & {
+      attr4: string
+    }
+  }
+  interface T2 {
+    nodeA: {
+      attr1: string
+      attr2: string
+    }
+    nodeB: {
+      attr3: string
+      attr4: string
+    }
+  }
+
+  assertTypeEqual<T1, T1>(true)
+  assertTypeEqual<T1, T2>(false)
+
+  assertTypeEqual<T1, SimplifyDeeper<T1>>(false)
+  assertTypeEqual<T2, SimplifyDeeper<T1>>(true)
+
+  assertTypeEqual<T1, Simplify<T1>>(false)
+  assertTypeEqual<T2, Simplify<T1>>(false)
+})

package/src/types/simplify-deeper.ts

@@ -0,0 +1,6 @@
+import type { Simplify } from 'type-fest'
+
+/**
+ * @internal
+ */
+export type SimplifyDeeper<T> = { [KeyType in keyof T]: Simplify<T[KeyType]> }

package/src/types/simplify-union.spec.ts

@@ -0,0 +1,21 @@
+import { test } from 'vitest'
+
+import { assertTypeEqual } from './assert-type-equal'
+import type { SimplifyUnion } from './simplify-union'
+
+test('SimplifyUnion', () => {
+  type T1 = { a: string } | { b: string }
+
+  interface T2 {
+    a: string
+    b: string
+  }
+
+  type T3 = SimplifyUnion<T1>
+
+  assertTypeEqual<T1, T1>(true)
+  assertTypeEqual<T1, T2>(false)
+
+  assertTypeEqual<T1, T3>(false)
+  assertTypeEqual<T2, T3>(true)
+})

package/src/types/simplify-union.ts

@@ -0,0 +1,11 @@
+import type {
+  Simplify,
+  UnionToIntersection,
+} from 'type-fest'
+
+/**
+ * @internal
+ */
+export type SimplifyUnion<T> = Simplify<
+  UnionToIntersection<T extends undefined ? never : T>
+>

package/src/utils/array-grouping.spec.ts

@@ -0,0 +1,29 @@
+import {
+  expect,
+  test,
+} from 'vitest'
+
+import {
+  groupBy,
+  groupEntries,
+} from './array-grouping'
+
+test('groupEntries', () => {
+  expect(
+    groupEntries([
+      ['a', 1],
+      ['b', 2],
+      ['a', 3],
+    ]),
+  ).toEqual({
+    a: [1, 3],
+    b: [2],
+  })
+})
+
+test('groupBy', () => {
+  expect(groupBy([1, 2, 3, 4, 5], (n) => n % 2)).toEqual({
+    0: [2, 4],
+    1: [1, 3, 5],
+  })
+})

package/src/utils/array-grouping.ts

@@ -0,0 +1,25 @@
+import type { ObjectEntries } from '../types/object-entries'
+
+export function groupBy<K extends PropertyKey, T>(
+  items: Iterable<T>,
+  keySelector: (item: T) => K,
+): Partial<Record<K, T[]>> {
+  const result: Partial<Record<K, T[]>> = {}
+  for (const item of items) {
+    const key = keySelector(item)
+    const values = (result[key] ||= [])
+    values.push(item)
+  }
+  return result
+}
+
+export function groupEntries<T extends Record<string, any>>(
+  entries: ObjectEntries<T>[],
+): { [K in keyof T]?: T[K][] } {
+  const result: { [K in keyof T]?: T[K][] } = {}
+  for (const [key, value] of entries) {
+    const values = (result[key] ||= [])
+    values.push(value)
+  }
+  return result
+}

package/src/utils/array.ts

@@ -0,0 +1,21 @@
+export function uniqPush<T>(prev: readonly T[], next: readonly T[]): T[] {
+  const result = [...prev]
+
+  for (const item of next) {
+    if (!result.includes(item)) {
+      result.push(item)
+    }
+  }
+  return result
+}
+
+/**
+ * @internal
+ */
+export function arraySubtract<T>(a: T[], b: T[]): T[] {
+  return a.filter((x) => !b.includes(x))
+}
+
+export function toReversed<T>(arr: T[]): T[] {
+  return arr.toReversed?.() ?? [...arr].reverse()
+}

package/src/utils/assert.ts

@@ -0,0 +1,13 @@
+import { ProseKitError } from '../error'
+
+/**
+ * @internal
+ */
+export function assert(
+  condition: unknown,
+  message = 'Assertion failed',
+): asserts condition {
+  if (!condition) {
+    throw new ProseKitError(message)
+  }
+}

package/src/utils/attrs-match.ts

@@ -0,0 +1,20 @@
+import type {
+  Attrs,
+  Mark,
+  ProseMirrorNode,
+} from '@prosekit/pm/model'
+
+export function attrsMatch(
+  nodeOrMark: ProseMirrorNode | Mark,
+  attrs: Attrs,
+): boolean {
+  const currentAttrs = nodeOrMark.attrs
+
+  for (const [key, value] of Object.entries(attrs)) {
+    if (currentAttrs[key] !== value) {
+      return false
+    }
+  }
+
+  return true
+}

package/src/utils/can-use-regex-lookbehind.ts

@@ -0,0 +1,12 @@
+import { once } from '@ocavue/utils'
+
+/**
+ * Checks if the browser supports [regex lookbehind assertion](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Regular_expressions/Lookbehind_assertion).
+ */
+export const canUseRegexLookbehind: () => boolean = once(() => {
+  try {
+    return 'ab'.replace(new RegExp('(?<=a)b', 'g'), 'c') === 'ac'
+  } catch {
+    return false
+  }
+})

package/src/utils/clsx.spec.ts

@@ -0,0 +1,14 @@
+import {
+  expect,
+  test,
+} from 'vitest'
+
+import { clsx } from './clsx'
+
+test('joins class names', () => {
+  expect(clsx('foo', 'bar')).toBe('foo bar')
+})
+
+test('filters falsy values', () => {
+  expect(clsx('foo', false, null, undefined, 'baz')).toBe('foo baz')
+})

package/src/utils/clsx.ts

@@ -0,0 +1,12 @@
+import clsxLite from 'clsx/lite'
+
+/**
+ * A utility for constructing `className` strings conditionally.
+ *
+ * It is a re-export of [clsx/lite](https://www.npmjs.com/package/clsx) with stricter types.
+ *
+ * @public
+ */
+export const clsx: (
+  ...args: Array<string | boolean | null | undefined>
+) => string = clsxLite

package/src/utils/collect-children.ts

@@ -0,0 +1,21 @@
+import type {
+  Fragment,
+  ProseMirrorNode,
+} from '@prosekit/pm/model'
+
+/**
+ * Collects all children of a node or a fragment, and returns them as an array.
+ *
+ * @deprecated Use `node.children` or `fragment.content` instead.
+ *
+ * @hidden
+ */
+export function collectChildren(
+  parent: ProseMirrorNode | Fragment,
+): ProseMirrorNode[] {
+  const children: ProseMirrorNode[] = []
+  for (let i = 0; i < parent.childCount; i++) {
+    children.push(parent.child(i))
+  }
+  return children
+}

package/src/utils/collect-nodes.ts

@@ -0,0 +1,37 @@
+import {
+  ProseMirrorFragment,
+  ProseMirrorNode,
+} from '@prosekit/pm/model'
+
+import { ProseKitError } from '../error'
+
+/**
+ * @hidden
+ *
+ * @deprecated
+ */
+export type NodeContent = ProseMirrorNode | ProseMirrorFragment | NodeContent[]
+
+/**
+ * Collects all nodes from a given content.
+ *
+ * @deprecated Use `collectChildren` instead.
+ *
+ * @hidden
+ */
+export function collectNodes(content: NodeContent): ProseMirrorNode[] {
+  if (Array.isArray(content)) {
+    return content.flatMap(collectNodes)
+  }
+  if (content instanceof ProseMirrorNode) {
+    return [content]
+  }
+  if (content instanceof ProseMirrorFragment) {
+    const nodes: ProseMirrorNode[] = []
+    for (let i = 0; i < content.childCount; i++) {
+      nodes.push(content.child(i))
+    }
+    return nodes
+  }
+  throw new ProseKitError(`Invalid node content: ${typeof content}`)
+}

package/src/utils/combine-event-handlers.spec.ts

@@ -0,0 +1,27 @@
+import {
+  expect,
+  test,
+  vi,
+} from 'vitest'
+
+import { combineEventHandlers } from './combine-event-handlers'
+
+test('runs handlers in reverse order and stops on true', () => {
+  const handler1 = vi.fn(() => false)
+  const handler2 = vi.fn(() => true)
+  const handler3 = vi.fn(() => false)
+  const [setHandlers, run] = combineEventHandlers<() => boolean>()
+  setHandlers([handler1, handler2, handler3])
+  expect(run()).toBe(true)
+  expect(handler3).toHaveBeenCalled()
+  expect(handler2).toHaveBeenCalled()
+  expect(handler1).not.toHaveBeenCalled()
+})
+
+test('returns false when all handlers return false', () => {
+  const handler1 = vi.fn(() => false)
+  const handler2 = vi.fn(() => false)
+  const [setHandlers, run] = combineEventHandlers<() => boolean>()
+  setHandlers([handler1, handler2])
+  expect(run()).toBe(false)
+})

package/src/utils/combine-event-handlers.ts

@@ -0,0 +1,27 @@
+import { toReversed } from './array'
+
+export function combineEventHandlers<
+  Handler extends (...args: any[]) => boolean | void,
+  Args extends Parameters<Handler> = Parameters<Handler>,
+>(): [
+  setHandlers: (eventHandlers: Handler[]) => void,
+  combinedEventHandler: (...args: Args) => boolean,
+] {
+  let handlers: Handler[] = []
+
+  function setHandlers(eventHandlers: Handler[]): void {
+    // The handlers at the end have a higher priority.
+    handlers = toReversed(eventHandlers)
+  }
+
+  function combinedEventHandler(...args: Args): boolean {
+    for (const handler of handlers) {
+      if (handler(...args)) {
+        return true
+      }
+    }
+    return false
+  }
+
+  return [setHandlers, combinedEventHandler] as const
+}

package/src/utils/contains-inline-node.ts

@@ -0,0 +1,17 @@
+import type { ProseMirrorNode } from '@prosekit/pm/model'
+
+/**
+ * @internal
+ */
+export function containsInlineNode(
+  doc: ProseMirrorNode,
+  from: number,
+  to: number,
+): boolean {
+  let found = false
+  doc.nodesBetween(from, to, (node) => {
+    if (found) return false
+    if (node.isInline) found = true
+  })
+  return found
+}

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