@prosekit/core 0.8.3 → 0.8.5

package/src/types/extension.ts

@@ -0,0 +1,168 @@
+import type { Schema } from '@prosekit/pm/model'
+
+import type {
+  CommandTyping,
+  ToCommandAction,
+  ToCommandCreators,
+} from './extension-command'
+import type {
+  MarkTyping,
+  ToMarkAction,
+} from './extension-mark'
+import type {
+  NodeTyping,
+  ToNodeAction,
+} from './extension-node'
+import type { PickStringLiteral } from './pick-string-literal'
+import type { PickSubType } from './pick-sub-type'
+import type { Priority } from './priority'
+import type { SimplifyDeeper } from './simplify-deeper'
+import type { SimplifyUnion } from './simplify-union'
+
+/**
+ * @internal
+ */
+export interface ExtensionTyping<
+  N extends NodeTyping = never,
+  M extends MarkTyping = never,
+  C extends CommandTyping = never,
+> {
+  Nodes?: N
+  Marks?: M
+  Commands?: C
+}
+
+/**
+ * @public
+ */
+export interface Extension<
+  T extends ExtensionTyping<any, any, any> = ExtensionTyping<any, any, any>,
+> {
+  extension: Extension | Extension[]
+  priority?: Priority
+
+  /**
+   * @public
+   *
+   * The schema that this extension represents.
+   */
+  schema: Schema | null
+
+  /** @internal */
+  _type?: T
+}
+
+/**
+ * @internal
+ */
+export type ExtractTyping<E extends Extension> = E extends Extension<ExtensionTyping<infer N, infer M, infer C>> ? ExtensionTyping<
+    PickSubType<N, NodeTyping>,
+    PickSubType<M, MarkTyping>,
+    PickSubType<C, CommandTyping>
+  >
+  : never
+
+/**
+ * An extension that does not define any nodes, marks, or commands.
+ *
+ * @internal
+ */
+export type PlainExtension = Extension<{
+  Nodes: never
+  Marks: never
+  Commands: never
+}>
+
+/**
+ * @public
+ */
+export type ExtractNodes<E extends Extension> = SimplifyDeeper<
+  SimplifyUnion<ExtractTyping<E>['Nodes']>
+>
+
+/**
+ * @public
+ */
+export type ExtractNodeNames<E extends Extension> = PickStringLiteral<
+  keyof ExtractNodes<E>
+>
+
+/**
+ * @public
+ */
+export type ExtractMarks<E extends Extension> = SimplifyDeeper<
+  SimplifyUnion<ExtractTyping<E>['Marks']>
+>
+
+/**
+ * @public
+ */
+export type ExtractMarkNames<E extends Extension> = PickStringLiteral<
+  keyof ExtractMarks<E>
+>
+
+/**
+ * @internal
+ */
+export type ExtractCommands<E extends Extension> = SimplifyUnion<
+  ExtractTyping<E>['Commands']
+>
+
+/**
+ * @public
+ */
+export type ExtractCommandCreators<E extends Extension> = ToCommandCreators<
+  ExtractCommands<E>
+>
+
+/**
+ * Extracts the {@link CommandAction}s from an extension type.
+ *
+ * @public
+ */
+export type ExtractCommandActions<E extends Extension> = ToCommandAction<
+  ExtractCommands<E>
+>
+
+/**
+ * Extracts the {@link NodeAction}s from an extension type.
+ *
+ * @public
+ */
+export type ExtractNodeActions<E extends Extension> = ToNodeAction<
+  ExtractNodes<E>
+>
+
+/**
+ * Extracts the {@link MarkAction}s from an extension type.
+ *
+ * @public
+ */
+export type ExtractMarkActions<E extends Extension> = ToMarkAction<
+  ExtractMarks<E>
+>
+
+/**
+ * @deprecated Use `ExtractCommandActions` instead.
+ */
+export type ExtractCommandAppliers<E extends Extension> = ExtractCommandActions<E>
+
+/**
+ * @internal
+ */
+export type Union<E extends readonly Extension[]> = Extension<{
+  Nodes: ExtractNodes<E[number]>
+  Marks: ExtractMarks<E[number]>
+  Commands: ExtractCommands<E[number]>
+}>
+
+/**
+ * @deprecated Use `Union` instead.
+ * @internal
+ */
+export type UnionExtension<E extends Extension | readonly Extension[]> = E extends readonly Extension[] ? Extension<{
+    Nodes: ExtractNodes<E[number]>
+    Marks: ExtractMarks<E[number]>
+    Commands: ExtractCommands<E[number]>
+  }>
+  : E

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,14 @@
+import clsxLite from 'clsx/lite'
+
+// This type declaration can be removed if https://github.com/lukeed/clsx/pull/110 gets merged and released
+
+/**
+ * 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
+}