@prosekit/core 0.9.0 → 0.11.0

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

@@ -1,9 +1,6 @@
-import {
-  expect,
-  test,
-} from 'vitest'
+import { expect, test } from 'vitest'
 
-import { groupEntries } from './array-grouping'
+import { groupEntries } from './array-grouping.ts'
 
 test('groupEntries', () => {
   expect(

package/src/utils/assert.ts

@@ -1,4 +1,4 @@
-import { ProseKitError } from '../error'
+import { ProseKitError } from '../error.ts'
 
 /**
  * @internal

package/src/utils/attrs-match.ts

@@ -1,8 +1,4 @@
-import type {
-  Attrs,
-  Mark,
-  ProseMirrorNode,
-} from '@prosekit/pm/model'
+import type { Attrs, Mark, ProseMirrorNode } from '@prosekit/pm/model'
 
 export function attrsMatch(
   nodeOrMark: ProseMirrorNode | Mark,

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

@@ -1,12 +1,6 @@
-import { once } from '@ocavue/utils'
+import { supportsRegexLookbehind } 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
-  }
-})
+export const canUseRegexLookbehind: () => boolean = supportsRegexLookbehind

package/src/utils/clsx.spec.ts

@@ -1,9 +1,6 @@
-import {
-  expect,
-  test,
-} from 'vitest'
+import { expect, test } from 'vitest'
 
-import { clsx } from './clsx'
+import { clsx } from './clsx.ts'
 
 test('joins class names', () => {
   expect(clsx('foo', 'bar')).toBe('foo bar')

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

@@ -1,10 +1,6 @@
-import {
-  expect,
-  test,
-  vi,
-} from 'vitest'
+import { expect, test, vi } from 'vitest'
 
-import { combineEventHandlers } from './combine-event-handlers'
+import { combineEventHandlers } from './combine-event-handlers.ts'
 
 test('runs handlers in reverse order and stops on true', () => {
   const handler1 = vi.fn(() => false)

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

@@ -1,7 +1,4 @@
-import type {
-  ContentMatch,
-  NodeType,
-} from '@prosekit/pm/model'
+import type { ContentMatch, NodeType } from '@prosekit/pm/model'
 
 /**
  * @internal

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

@@ -1,12 +1,9 @@
 import { AllSelection } from '@prosekit/pm/state'
-import {
-  expect,
-  test,
-} from 'vitest'
+import { expect, test } from 'vitest'
 
-import { setupTest } from '../testing'
+import { setupTest } from '../testing/index.ts'
 
-import { getEditorSelection } from './editor-content'
+import { getEditorSelection } from './editor-content.ts'
 
 test('getEditorSelection', () => {
   const { n } = setupTest()

package/src/utils/editor-content.ts

@@ -1,24 +1,12 @@
 import { isElementLike } from '@ocavue/utils'
-import type {
-  ProseMirrorNode,
-  Schema,
-} from '@prosekit/pm/model'
+import type { ProseMirrorNode, Schema } from '@prosekit/pm/model'
 import { Selection } from '@prosekit/pm/state'
 
-import type {
-  NodeJSON,
-  SelectionJSON,
-} from '../types/model'
+import type { NodeJSON, SelectionJSON } from '../types/model.ts'
 
-import { assert } from './assert'
-import {
-  jsonFromElement,
-  jsonFromHTML,
-} from './parse'
-import {
-  isProseMirrorNode,
-  isSelection,
-} from './type-assertion'
+import { assert } from './assert.ts'
+import { jsonFromElement, jsonFromHTML } from './parse.ts'
+import { isProseMirrorNode, isSelection } from './type-assertion.ts'
 
 export function getEditorContentJSON(
   schema: Schema,

package/src/utils/find-node.ts

@@ -0,0 +1,65 @@
+import type { ProseMirrorNode } from '@prosekit/pm/model'
+
+/**
+ * Finds the first node that satisfies the predicate from the given document.
+ *
+ * @internal
+ */
+export function findNode(
+  doc: ProseMirrorNode,
+  predicate: (node: ProseMirrorNode) => boolean,
+): FindNodeResult | undefined {
+  let found: FindNodeResult | undefined
+  doc.descendants((node, pos, parent, index) => {
+    if (found) {
+      return false
+    }
+    if (predicate(node)) {
+      found = { node, pos, parent, index }
+      return false
+    }
+  })
+  return found
+}
+
+/**
+ * Finds all nodes that satisfy the predicate from the given document.
+ *
+ * @internal
+ */
+export function findNodes(
+  doc: ProseMirrorNode,
+  predicate: (node: ProseMirrorNode) => boolean,
+): FindNodeResult[] {
+  const results: FindNodeResult[] = []
+  doc.descendants((node, pos, parent, index) => {
+    if (predicate(node)) {
+      results.push({ node, pos, parent, index })
+    }
+  })
+  return results
+}
+
+/**
+ * The result of the {@link findNode} function.
+ *
+ * @internal
+ */
+export interface FindNodeResult {
+  /**
+   * The node that satisfies the predicate.
+   */
+  node: ProseMirrorNode
+  /**
+   * The position of the node.
+   */
+  pos: number
+  /**
+   * The parent of the node.
+   */
+  parent: ProseMirrorNode | null
+  /**
+   * The index of the node in the parent.
+   */
+  index: number
+}

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

@@ -1,13 +1,7 @@
-import type {
-  NodeType,
-  ResolvedPos,
-} from '@prosekit/pm/model'
+import type { NodeType, ResolvedPos } from '@prosekit/pm/model'
 
-import {
-  findParentNode,
-  type FindParentNodeResult,
-} from './find-parent-node'
-import { getNodeType } from './get-node-type'
+import { findParentNode, type FindParentNodeResult } from './find-parent-node.ts'
+import { getNodeTypes } from './get-node-types.ts'
 
 /**
  * Finds the closest parent node that matches the given node type.
@@ -18,12 +12,12 @@ export function findParentNodeOfType(
   /**
    * The type of the node to find.
    */
-  type: NodeType | string,
+  type: string | NodeType | string[] | NodeType[],
   /**
    * 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)
+  const nodeTypes = getNodeTypes($pos.doc.type.schema, type)
+  return findParentNode((node) => nodeTypes.includes(node.type), $pos)
 }

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

@@ -1,12 +1,8 @@
-import {
-  describe,
-  expect,
-  it,
-} from 'vitest'
+import { describe, expect, it } from 'vitest'
 
-import { setupTest } from '../testing'
+import { setupTest } from '../testing/index.ts'
 
-import { findParentNode } from './find-parent-node'
+import { findParentNode } from './find-parent-node.ts'
 
 describe('findParentNode', () => {
   it('finds parent node with cursor directly inside', () => {

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

@@ -1,7 +1,4 @@
-import type {
-  ProseMirrorNode,
-  ResolvedPos,
-} from '@prosekit/pm/model'
+import type { ProseMirrorNode, ResolvedPos } from '@prosekit/pm/model'
 
 /**
  * @public

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

@@ -1,8 +1,4 @@
-import {
-  TextSelection,
-  type EditorState,
-  type Selection,
-} from '@prosekit/pm/state'
+import { TextSelection, type EditorState, type Selection } from '@prosekit/pm/state'
 
 export function getCustomSelection(
   state: EditorState,

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

@@ -1,4 +1,4 @@
-import { DOMDocumentNotFoundError } from '../error'
+import { DOMDocumentNotFoundError } from '../error.ts'
 
 function findGlobalBrowserDocument() {
   if (typeof document !== 'undefined') {

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

@@ -1,9 +1,6 @@
-import type {
-  MarkType,
-  Schema,
-} from '@prosekit/pm/model'
+import type { MarkType, Schema } from '@prosekit/pm/model'
 
-import { ProseKitError } from '../error'
+import { ProseKitError } from '../error.ts'
 
 /**
  * @internal

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

@@ -1,9 +1,6 @@
-import type {
-  NodeType,
-  Schema,
-} from '@prosekit/pm/model'
+import type { NodeType, Schema } from '@prosekit/pm/model'
 
-import { ProseKitError } from '../error'
+import { ProseKitError } from '../error.ts'
 
 /**
  * @internal

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

@@ -1,9 +1,6 @@
-import type {
-  NodeType,
-  Schema,
-} from '@prosekit/pm/model'
+import type { NodeType, Schema } from '@prosekit/pm/model'
 
-import { getNodeType } from './get-node-type'
+import { getNodeType } from './get-node-type.ts'
 
 /**
  * @internal

package/src/utils/includes-mark.ts

@@ -1,10 +1,6 @@
-import type {
-  Attrs,
-  Mark,
-  MarkType,
-} from '@prosekit/pm/model'
+import type { Attrs, Mark, MarkType } from '@prosekit/pm/model'
 
-import { isSubset } from './is-subset'
+import { isSubset } from './is-subset.ts'
 
 export function includesMark(
   marks: readonly Mark[],

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

@@ -1,8 +1,5 @@
 import type { ResolvedPos } from '@prosekit/pm/model'
-import type {
-  EditorState,
-  TextSelection,
-} from '@prosekit/pm/state'
+import type { EditorState, TextSelection } from '@prosekit/pm/state'
 import type { EditorView } from '@prosekit/pm/view'
 
 /**

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

@@ -1,11 +1,8 @@
-import {
-  expect,
-  test,
-} from 'vitest'
+import { expect, test } from 'vitest'
 
-import { setupTest } from '../testing'
+import { setupTest } from '../testing/index.ts'
 
-import { isMarkAbsent } from './is-mark-absent'
+import { isMarkAbsent } from './is-mark-absent.ts'
 
 test('isMarkAbsent', () => {
   const { editor, m, n } = setupTest()

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

@@ -1,10 +1,6 @@
-import type {
-  Attrs,
-  MarkType,
-  ProseMirrorNode,
-} from '@prosekit/pm/model'
+import type { Attrs, MarkType, ProseMirrorNode } from '@prosekit/pm/model'
 
-import { includesMark } from './includes-mark'
+import { includesMark } from './includes-mark.ts'
 
 /**
  * Returns true if the given mark is missing in some part of the range.

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

@@ -1,12 +1,9 @@
-import type {
-  Attrs,
-  MarkType,
-} from '@prosekit/pm/model'
+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'
+import { getMarkType } from './get-mark-type.ts'
+import { includesMark } from './includes-mark.ts'
+import { isMarkAbsent } from './is-mark-absent.ts'
 
 /**
  * @internal

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

@@ -0,0 +1,109 @@
+import { NodeSelection } from '@prosekit/pm/state'
+import { describe, expect, it } from 'vitest'
+
+import { setupTest } from '../testing/index.ts'
+
+import { isNodeActive } from './is-node-active.ts'
+
+describe('isNodeActive', () => {
+  it('should return true when cursor is in a node of the specified type', () => {
+    const { editor, n } = setupTest()
+    editor.set(n.doc(n.p('Hello <a>world')))
+
+    expect(isNodeActive(editor.state, 'paragraph')).toBe(true)
+  })
+
+  it('should return false when cursor is not in a node of the specified type', () => {
+    const { editor, n } = setupTest()
+    editor.set(n.doc(n.p('Hello <a>world')))
+
+    expect(isNodeActive(editor.state, 'codeBlock')).toBe(false)
+  })
+
+  it('should return true when cursor is in a nested node of the specified type', () => {
+    const { editor, n } = setupTest()
+    editor.set(n.doc(n.blockquote(n.p('Hello <a>world'))))
+
+    expect(isNodeActive(editor.state, 'blockquote')).toBe(true)
+  })
+
+  it('should return true when cursor is in a node with matching attributes', () => {
+    const { editor, n } = setupTest()
+    editor.set(n.doc(n.codeBlock({ language: 'typescript' }, '<a>code')))
+
+    expect(isNodeActive(editor.state, 'codeBlock', { language: 'typescript' })).toBe(true)
+  })
+
+  it('should return false when cursor is in a node with non-matching attributes', () => {
+    const { editor, n } = setupTest()
+    editor.set(n.doc(n.codeBlock({ language: 'typescript' }, '<a>code')))
+
+    expect(isNodeActive(editor.state, 'codeBlock', { language: 'javascript' })).toBe(false)
+  })
+
+  it('should return true when using NodeSelection with matching type', () => {
+    const { editor, n } = setupTest()
+    editor.set(n.doc(n.p('Hello world')))
+
+    const $pos = editor.state.doc.resolve(0)
+    const state = editor.state.apply(
+      editor.state.tr.setSelection(NodeSelection.create(editor.state.doc, $pos.pos)),
+    )
+
+    expect(isNodeActive(state, 'paragraph')).toBe(true)
+  })
+
+  it('should return true when using NodeSelection with matching type and attributes', () => {
+    const { editor, n } = setupTest()
+    editor.set(n.doc(n.codeBlock({ language: 'python' }, 'code')))
+
+    const $pos = editor.state.doc.resolve(0)
+    const state = editor.state.apply(
+      editor.state.tr.setSelection(NodeSelection.create(editor.state.doc, $pos.pos)),
+    )
+
+    expect(isNodeActive(state, 'codeBlock', { language: 'python' })).toBe(true)
+  })
+
+  it('should return false when using NodeSelection with non-matching attributes', () => {
+    const { editor, n } = setupTest()
+    editor.set(n.doc(n.codeBlock({ language: 'python' }, 'code')))
+
+    const $pos = editor.state.doc.resolve(0)
+    const state = editor.state.apply(
+      editor.state.tr.setSelection(NodeSelection.create(editor.state.doc, $pos.pos)),
+    )
+
+    expect(isNodeActive(state, 'codeBlock', { language: 'javascript' })).toBe(false)
+  })
+
+  it('should work with NodeType instead of string', () => {
+    const { editor, n } = setupTest()
+    editor.set(n.doc(n.p('Hello <a>world')))
+
+    expect(isNodeActive(editor.state, editor.state.schema.nodes.paragraph)).toBe(true)
+  })
+
+  it('should return true when node is at any depth in the hierarchy', () => {
+    const { editor, n } = setupTest()
+    editor.set(n.doc(n.blockquote(n.p('Hello <a>world'))))
+
+    expect(isNodeActive(editor.state, 'paragraph')).toBe(true)
+    expect(isNodeActive(editor.state, 'blockquote')).toBe(true)
+    expect(isNodeActive(editor.state, 'doc')).toBe(true)
+  })
+
+  it('should return true when attributes is null', () => {
+    const { editor, n } = setupTest()
+    editor.set(n.doc(n.codeBlock({ language: 'typescript' }, '<a>code')))
+
+    expect(isNodeActive(editor.state, 'codeBlock', null)).toBe(true)
+  })
+
+  it('should match partial attributes', () => {
+    const { editor, n } = setupTest()
+    editor.set(n.doc(n.codeBlock({ language: 'typescript', lineNumbers: true }, '<a>code')))
+
+    expect(isNodeActive(editor.state, 'codeBlock', { language: 'typescript' })).toBe(true)
+  })
+})

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

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

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

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

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

@@ -1,10 +1,6 @@
-import {
-  expect,
-  test,
-  vi,
-} from 'vitest'
+import { expect, test, vi } from 'vitest'
 
-import { maybeRun } from './maybe-run'
+import { maybeRun } from './maybe-run.ts'
 
 test('executes function argument', () => {
   const fn = vi.fn((x: number) => x + 1)

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

@@ -1,9 +1,6 @@
-import {
-  expect,
-  test,
-} from 'vitest'
+import { expect, test } from 'vitest'
 
-import { mergeObjects } from './merge-objects'
+import { mergeObjects } from './merge-objects.ts'
 
 // basic merge
 test('merge simple objects', () => {

package/src/utils/merge-objects.ts

@@ -1,5 +1,6 @@
-import { removeUndefinedValues } from './remove-undefined-values'
-import { isNotNullish } from './type-assertion'
+import { isNotNullish } from '@ocavue/utils'
+
+import { removeUndefinedValues } from './remove-undefined-values.ts'
 
 export function mergeObjects<T extends object>(
   ...objects: Array<Partial<T> | null | undefined>

package/src/utils/merge-specs.ts

@@ -1,9 +1,6 @@
-import type {
-  MarkSpec,
-  NodeSpec,
-} from '@prosekit/pm/model'
+import type { MarkSpec, NodeSpec } from '@prosekit/pm/model'
 
-import { mergeObjects } from './merge-objects'
+import { mergeObjects } from './merge-objects.ts'
 
 function mergeSpecs(a: NodeSpec, b: NodeSpec): NodeSpec
 function mergeSpecs(a: MarkSpec, b: MarkSpec): MarkSpec

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

@@ -1,9 +1,6 @@
-import {
-  expect,
-  test,
-} from 'vitest'
+import { expect, test } from 'vitest'
 
-import { objectEqual } from './object-equal'
+import { objectEqual } from './object-equal.ts'
 
 test('objects with same keys and values are equal', () => {
   expect(objectEqual({ a: 1, b: 2 }, { a: 1, b: 2 })).toBe(true)

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

@@ -1,11 +1,7 @@
 import type { DOMOutputSpec } from '@prosekit/pm/model'
-import {
-  describe,
-  expect,
-  it,
-} from 'vitest'
+import { describe, expect, it } from 'vitest'
 
-import { insertOutputSpecAttrs } from './output-spec'
+import { insertOutputSpecAttrs } from './output-spec.ts'
 
 describe('insertOutputSpecAttrs', () => {
   it('should insert attrs into an array without attributes', () => {

package/src/utils/output-spec.ts

@@ -1,13 +1,5 @@
-import { isElementLike } from '@ocavue/utils'
-import type {
-  DOMOutputSpec,
-  Mark,
-  ParseRule,
-  ProseMirrorNode,
-  TagParseRule,
-} from '@prosekit/pm/model'
-
-import { isNotNullish } from './type-assertion'
+import { isElementLike, isNotNullish } from '@ocavue/utils'
+import type { DOMOutputSpec, Mark, ParseRule, ProseMirrorNode, TagParseRule } from '@prosekit/pm/model'
 
 interface AttrOptions {
   attr: string