vitest-prosemirror 0.3.2 → 0.4.0

package/dist/vitest-prosemirror.d.ts

@@ -1,44 +1,42 @@
 import 'vitest';
+import { EditorState } from 'prosemirror-state';
 import { Node as Node_2 } from 'prosemirror-model';
 import { Plugin as Plugin_2 } from 'prosemirror-state';
-import { Schema } from 'prosemirror-model';
 import { Selection as Selection_2 } from 'prosemirror-state';
 
 export declare interface CustomMatchers<R = unknown> {
     toEqualProseMirrorNode(expected: Node_2): R;
 }
 
-export declare interface KeyboardModifiers {
-    altKey?: boolean;
-    ctrlKey?: boolean;
-    metaKey?: boolean;
-    shiftKey?: boolean;
-}
-
 export declare interface Options {
+    autoCleanup: boolean;
     plugins: Array<Plugin_2>;
 }
 
 export declare class ProseMirrorTester {
     get doc(): Node_2;
-    get schema(): Schema;
+    get html(): string;
+    get state(): EditorState;
+    get text(): string;
+    private destroyed;
+    private readonly element;
     private readonly view;
     constructor(documentRoot: Node_2, options?: Partial<Options>);
-    insertText(text: string, modifiers?: KeyboardModifiers): void;
+    destroy(): void;
+    insertText(text: string): void;
     selectText(selection: TesterSelection): void;
+    private assertAlive;
 }
 
 export declare type TesterSelection = "all" | "end" | "start" | {
-    from: number;
-    to: number;
+    anchor: number;
+    head: number;
 } | Selection_2 | number;
 
 export { }
 
 
 declare module "vitest" {
-    interface Assertion<T = any> extends CustomMatchers<T> {
-    }
-    interface AsymmetricMatchersContaining extends CustomMatchers {
+    interface Matchers<R extends Promise<void> | void = Promise<void> | void, T = unknown> extends CustomMatchers<R> {
     }
 }

package/dist/vitest-prosemirror.js

@@ -1,45 +1,8 @@
-import { expect } from "vitest";
-import stringifyObject from "stringify-object";
+import { afterEach, expect } from "vitest";
 import { AllSelection, EditorState, Selection, TextSelection } from "prosemirror-state";
 import { EditorView } from "prosemirror-view";
-//#region src/stringifyProseMirrorNode.ts
-function getMarks(marks, origContent) {
-	let content = `'${origContent}'`;
-	for (const mark of [...marks].reverse()) {
-		const hasAttrs = Object.keys(mark.attrs).length > 0;
-		const items = [content];
-		if (hasAttrs) items.unshift(stringifyObject(mark.attrs, {
-			indent: "  ",
-			inlineCharacterLimit: 1e3
-		}));
-		content = `${mark.type.name}(${items.join(", ")})`;
-	}
-	return content;
-}
-var renamedTypes = {
-	hardBreak: "br",
-	heading: "h",
-	horizontalRule: "hr",
-	paragraph: "p"
-};
-function stringifyProseMirrorNode(node, indentation = "") {
-	if (node.type.name === "text") return `${indentation}${getMarks(node.marks, node.text ?? "")}`;
-	const type = renamedTypes[node.type.name] ?? node.type.name;
-	const content = [];
-	const nextIndentation = `${indentation}  `;
-	if (Object.keys(node.attrs).length > 0) content.push(`${nextIndentation}${stringifyObject(node.attrs, {
-		indent: "  ",
-		inlineCharacterLimit: 1e3
-	})},`);
-	node.content.forEach((item) => {
-		content.push(`${stringifyProseMirrorNode(item, nextIndentation)},`);
-	});
-	if (content.length === 0) return `${indentation}${type}()`;
-	if (content.length === 1 && node.content.firstChild?.type.name === "text") return `${indentation}${type}(${stringifyProseMirrorNode(node.content.firstChild, "")})`;
-	return `${indentation}${type}(\n${content.join("\n")}\n${indentation})`;
-}
-//#endregion
-//#region src/utils/mockRangeRects.ts
+import stringifyObject from "stringify-object";
+//#region src/mockRangeRects.ts
 var mockRangeRects = () => {
 	const zeroRect = () => new DOMRect(0, 0, 0, 0);
 	const emptyRectList = () => [];
@@ -48,7 +11,7 @@ var mockRangeRects = () => {
 	if (typeof rangePrototype.getClientRects !== "function") Range.prototype.getClientRects = emptyRectList;
 };
 //#endregion
-//#region src/utils/MutationObserverMock.ts
+//#region src/MutationObserverMock.ts
 var MutationObserverMock = class MutationObserverMock {
 	static activeObservers = /* @__PURE__ */ new Map();
 	callback;
@@ -84,18 +47,19 @@ var MutationObserverMock = class MutationObserverMock {
 	}
 };
 //#endregion
-//#region src/utils/selection.ts
+//#region src/selection.ts
 var resolveSelection = (doc, selection) => {
 	if (selection === "all") return new AllSelection(doc);
 	if (typeof selection === "object" && "$anchor" in selection && "$head" in selection) return selection;
-	if (typeof selection === "object" && "from" in selection && "to" in selection) return TextSelection.between(doc.resolve(selection.from), doc.resolve(selection.to));
+	if (typeof selection === "object" && "anchor" in selection && "head" in selection) return TextSelection.between(doc.resolve(selection.anchor), doc.resolve(selection.head));
+	if (typeof selection === "object" && "from" in selection && "to" in selection) throw new Error("selectText no longer accepts { from, to } — use { anchor, head } instead. The values map directly: { from: a, to: b } becomes { anchor: a, head: b }.");
 	let pos = 0;
 	if (selection === "end") pos = doc.nodeSize - 2;
 	else if (selection !== "start") pos = selection;
 	return TextSelection.near(doc.resolve(pos));
 };
 //#endregion
-//#region src/utils/dom.ts
+//#region src/typing/dom.ts
 var characterDataAt = (node, offset) => {
 	if (node instanceof CharacterData) return {
 		offset,
@@ -108,8 +72,58 @@ var characterDataAt = (node, offset) => {
 	};
 	return null;
 };
+function deleteText(view, direction) {
+	const { selection } = view.state;
+	const from = selection.empty && direction === -1 ? selection.from - 1 : selection.from;
+	const to = selection.empty && direction === 1 ? selection.to + 1 : selection.to;
+	const fromDOM = view.domAtPos(from, -1);
+	const target = characterDataAt(fromDOM.node, fromDOM.offset)?.target;
+	if (target === void 0) throw new Error("Cannot simulate deleting a range that is not inside a single text node");
+	const nodeStart = view.posAtDOM(target, 0);
+	const fromOffset = from - nodeStart;
+	const toOffset = to - nodeStart;
+	if (fromOffset < 0 || toOffset > target.data.length) throw new Error("Cannot simulate deleting a range that is not inside a single text node");
+	const oldValue = target.data;
+	target.data = target.data.slice(0, fromOffset) + target.data.slice(toOffset);
+	MutationObserverMock.createMutation(view.dom, [{
+		oldValue,
+		target,
+		type: "characterData"
+	}]);
+}
+function moveCaret(view, direction) {
+	const { selection } = view.state;
+	let pos = direction === -1 ? selection.from : selection.to;
+	if (selection.empty) pos += direction;
+	view.dispatch(view.state.tr.setSelection(Selection.near(view.state.doc.resolve(pos), direction)));
+}
+function typeCharacter(view, character) {
+	const { node, offset: domOffset } = view.domAtPos(view.state.selection.from, -1);
+	const point = characterDataAt(node, domOffset);
+	if (point !== null) {
+		const { offset, target } = point;
+		const oldValue = target.data;
+		target.data = target.data.slice(0, offset) + character + target.data.slice(offset);
+		MutationObserverMock.createMutation(view.dom, [{
+			oldValue,
+			target,
+			type: "characterData"
+		}]);
+		return;
+	}
+	const textNode = new Text(character);
+	const nextSibling = node.childNodes.item(domOffset);
+	node.insertBefore(textNode, nextSibling);
+	MutationObserverMock.createMutation(view.dom, [{
+		addedNodes: [textNode],
+		nextSibling,
+		previousSibling: textNode.previousSibling,
+		target: node,
+		type: "childList"
+	}]);
+}
 //#endregion
-//#region src/utils/keyboardInput.ts
+//#region src/typing/keyboardInput.ts
 function tokenizeKeyboardInput(input) {
 	const output = [];
 	let currentGroupOpener = null;
@@ -140,7 +154,24 @@ function matchingBrace(opener) {
 	return opener === "{" ? "}" : "]";
 }
 //#endregion
-//#region src/utils/keyIdentity.ts
+//#region src/typing/keyChord.ts
+function parseKeyChord(token) {
+	const parts = token.split(/-(?!$)/u);
+	const key = parts[parts.length - 1] === "Space" ? " " : parts[parts.length - 1];
+	const modifiers = {};
+	for (const modifier of parts.slice(0, -1)) if (/^(cmd|meta|m)$/iu.test(modifier)) modifiers.metaKey = true;
+	else if (/^a(lt)?$/iu.test(modifier)) modifiers.altKey = true;
+	else if (/^(c|ctrl|control)$/iu.test(modifier)) modifiers.ctrlKey = true;
+	else if (/^s(hift)?$/iu.test(modifier)) modifiers.shiftKey = true;
+	else if (/^mod$/iu.test(modifier)) modifiers.ctrlKey = true;
+	else throw new Error(`Unrecognized modifier name: ${modifier}`);
+	return {
+		key,
+		modifiers
+	};
+}
+//#endregion
+//#region src/typing/keyIdentity.ts
 var namedKeys = new Map(Object.entries({
 	Alt: 18,
 	ArrowDown: 40,
@@ -457,7 +488,7 @@ function keyIdentity(key) {
 	};
 }
 //#endregion
-//#region src/utils/typing.ts
+//#region src/typing/typing.ts
 var ignoredKeys = /* @__PURE__ */ new Set([
 	"Alt",
 	"CapsLock",
@@ -466,15 +497,14 @@ var ignoredKeys = /* @__PURE__ */ new Set([
 	"Shift",
 	"Tab"
 ]);
-var backward = -1;
-var forward = 1;
 var hasModifiers = (modifiers) => modifiers !== void 0 && Object.values(modifiers).includes(true);
 var suppressesCharacter = (modifiers) => modifiers?.altKey === true || modifiers?.ctrlKey === true || modifiers?.metaKey === true;
 var isLetter = (key) => /^[a-z]$/iu.test(key);
-function insertText(view, text, modifiers) {
-	for (const key of tokenizeKeyboardInput(text)) {
-		const character = isLetter(key) && modifiers?.shiftKey === true ? key.toUpperCase() : key;
-		const shiftKey = isLetter(character) ? character === character.toUpperCase() : modifiers?.shiftKey ?? false;
+function insertText(view, text) {
+	for (const token of tokenizeKeyboardInput(text)) {
+		const { key, modifiers } = parseKeyChord(token);
+		const character = isLetter(key) && modifiers.shiftKey === true ? key.toUpperCase() : key;
+		const shiftKey = isLetter(character) ? character === character.toUpperCase() : modifiers.shiftKey ?? false;
 		const identity = keyIdentity(character);
 		const eventInit = {
 			bubbles: true,
@@ -506,37 +536,18 @@ function insertText(view, text, modifiers) {
 		view.dispatchEvent(new KeyboardEvent("keyup", eventInit));
 	}
 }
-function deleteText(view, direction) {
-	const { selection } = view.state;
-	const from = selection.empty && direction === backward ? selection.from - 1 : selection.from;
-	const to = selection.empty && direction === forward ? selection.to + 1 : selection.to;
-	const fromDOM = view.domAtPos(from, backward);
-	const target = characterDataAt(fromDOM.node, fromDOM.offset)?.target;
-	if (target === void 0) throw new Error("Cannot simulate deleting a range that is not inside a single text node");
-	const nodeStart = view.posAtDOM(target, 0);
-	const fromOffset = from - nodeStart;
-	const toOffset = to - nodeStart;
-	if (fromOffset < 0 || toOffset > target.data.length) throw new Error("Cannot simulate deleting a range that is not inside a single text node");
-	const oldValue = target.data;
-	target.data = target.data.slice(0, fromOffset) + target.data.slice(toOffset);
-	MutationObserverMock.createMutation(view.dom, [{
-		oldValue,
-		target,
-		type: "characterData"
-	}]);
-}
 function keyAction(key, modifiers) {
 	if (ignoredKeys.has(key)) return { type: "ignore" };
 	if (key === "Backspace") return {
-		direction: backward,
+		direction: -1,
 		type: "delete"
 	};
 	if (key === "Delete") return {
-		direction: forward,
+		direction: 1,
 		type: "delete"
 	};
 	if ((key === "ArrowLeft" || key === "ArrowRight") && !hasModifiers(modifiers)) return {
-		direction: key === "ArrowLeft" ? backward : forward,
+		direction: key === "ArrowLeft" ? -1 : 1,
 		type: "moveCaret"
 	};
 	if (key.length === 1) {
@@ -548,74 +559,129 @@ function keyAction(key, modifiers) {
 	}
 	throw new Error(`Cannot simulate the "${key}" key`);
 }
-function moveCaret(view, direction) {
-	const { selection } = view.state;
-	let pos = direction === backward ? selection.from : selection.to;
-	if (selection.empty) pos += direction;
-	view.dispatch(view.state.tr.setSelection(Selection.near(view.state.doc.resolve(pos), direction)));
-}
-function typeCharacter(view, character) {
-	const { node, offset: domOffset } = view.domAtPos(view.state.selection.from, backward);
-	const point = characterDataAt(node, domOffset);
-	if (point !== null) {
-		const { offset, target } = point;
-		const oldValue = target.data;
-		target.data = target.data.slice(0, offset) + character + target.data.slice(offset);
-		MutationObserverMock.createMutation(view.dom, [{
-			oldValue,
-			target,
-			type: "characterData"
-		}]);
-		return;
-	}
-	const textNode = new Text(character);
-	const nextSibling = node.childNodes.item(domOffset);
-	node.insertBefore(textNode, nextSibling);
-	MutationObserverMock.createMutation(view.dom, [{
-		addedNodes: [textNode],
-		nextSibling,
-		previousSibling: textNode.previousSibling,
-		target: node,
-		type: "childList"
-	}]);
-}
 //#endregion
 //#region src/ProseMirrorTester.ts
+var originalMutationObserver = global.MutationObserver;
+var liveTesters = /* @__PURE__ */ new Set();
+var autoCleanupTesters = /* @__PURE__ */ new Set();
+var cleanupTesters = () => {
+	for (const tester of [...autoCleanupTesters]) tester.destroy();
+};
 var ProseMirrorTester = class {
 	get doc() {
+		this.assertAlive();
 		return this.view.state.doc;
 	}
-	get schema() {
-		return this.view.state.schema;
+	get html() {
+		this.assertAlive();
+		return this.view.dom.innerHTML;
+	}
+	get state() {
+		this.assertAlive();
+		return this.view.state;
+	}
+	get text() {
+		this.assertAlive();
+		return this.view.dom.textContent;
 	}
+	destroyed = false;
+	element;
 	view;
 	constructor(documentRoot, options = {}) {
 		if (typeof document === "undefined") throw new Error("TODO");
-		const element = document.createElement("div");
-		document.body.append(element);
+		this.element = document.createElement("div");
+		document.body.append(this.element);
 		const state = EditorState.create({
 			doc: documentRoot,
 			plugins: options.plugins ?? []
 		});
 		global.MutationObserver = MutationObserverMock;
 		mockRangeRects();
-		this.view = new EditorView(element, { state });
+		this.view = new EditorView(this.element, { state });
+		liveTesters.add(this);
+		if (options.autoCleanup ?? true) autoCleanupTesters.add(this);
 	}
-	insertText(text, modifiers) {
-		insertText(this.view, text, modifiers);
+	destroy() {
+		if (this.destroyed) return;
+		this.destroyed = true;
+		this.view.destroy();
+		this.element.remove();
+		document.getSelection()?.removeAllRanges();
+		autoCleanupTesters.delete(this);
+		liveTesters.delete(this);
+		if (liveTesters.size === 0) global.MutationObserver = originalMutationObserver;
+	}
+	insertText(text) {
+		this.assertAlive();
+		insertText(this.view, text);
 	}
 	selectText(selection) {
+		this.assertAlive();
 		this.view.dispatch(this.view.state.tr.setSelection(resolveSelection(this.doc, selection)));
 	}
+	assertAlive() {
+		if (this.destroyed) throw new Error("This ProseMirrorTester has been destroyed. Testers are destroyed automatically after each test; pass { autoCleanup: false } to keep one alive (e.g. across a beforeAll).");
+	}
 };
 //#endregion
+//#region src/stringifyProseMirrorNode.ts
+function stringifyProseMirrorNode(node, indentation = "") {
+	if (node.type.spec.toDebugString !== void 0) return `${indentation}${wrapMarks(node.marks, node.type.spec.toDebugString(node))}`;
+	if (node.type.name === "text") return `${indentation}${wrapMarks(node.marks, escapeText(node.textContent))}`;
+	const type = node.type.name;
+	const content = [];
+	const nextIndentation = `${indentation}  `;
+	if (Object.keys(node.attrs).length > 0) content.push(`${nextIndentation}${stringifyObject(node.attrs, {
+		indent: "  ",
+		inlineCharacterLimit: 1e3
+	})},`);
+	node.content.forEach((item) => {
+		content.push(`${stringifyProseMirrorNode(item, nextIndentation)},`);
+	});
+	let body;
+	if (content.length === 0) body = `${type}()`;
+	else if (content.length === 1 && node.content.firstChild?.type.name === "text") body = `${type}(${stringifyProseMirrorNode(node.content.firstChild, "")})`;
+	else body = `${type}(\n${content.join("\n")}\n${indentation})`;
+	return `${indentation}${wrapMarks(node.marks, body)}`;
+}
+function escapeText(text) {
+	return `'${text.replace(/[\p{Cc}'\\]/gu, (char) => {
+		switch (char) {
+			case "\f": return "\\f";
+			case "\n": return "\\n";
+			case "\r": return "\\r";
+			case "	": return "\\t";
+			case "\b": return "\\b";
+			case "'": return "\\'";
+			case "\\": return "\\\\";
+			default: return `\\u${char.charCodeAt(0).toString(16).padStart(4, "0")}`;
+		}
+	})}'`;
+}
+function wrapMarks(marks, origContent) {
+	let content = origContent;
+	for (const mark of [...marks].reverse()) {
+		const hasAttrs = Object.keys(mark.attrs).length > 0;
+		const items = [content];
+		if (hasAttrs) items.unshift(stringifyObject(mark.attrs, {
+			indent: "  ",
+			inlineCharacterLimit: 1e3
+		}));
+		content = `${mark.type.name}(${items.join(", ")})`;
+	}
+	return content;
+}
+//#endregion
 //#region src/index.ts
+afterEach(cleanupTesters);
 expect.extend({ toEqualProseMirrorNode(received, expected) {
 	const receivedDoc = `\n${stringifyProseMirrorNode(received)}\n`;
 	const expectedDoc = `\n${stringifyProseMirrorNode(expected)}\n`;
-	const pass = this.equals(receivedDoc, expectedDoc);
+	const sameSchema = received.type.schema === expected.type.schema;
+	const pass = sameSchema && this.equals(receivedDoc, expectedDoc);
 	return {
 		message: pass ? () => `${this.utils.matcherHint(".not.toEqualProsemirrorNode")}\n\nExpected value of document to not equal:\n  ${this.utils.printExpected(expectedDoc)}\nActual:\n  ${this.utils.printReceived(receivedDoc)}` : () => {
+			if (!sameSchema && this.equals(receivedDoc, expectedDoc)) return `${this.utils.matcherHint(".toEqualProsemirrorNode")}\n\nThe documents stringify identically but come from different schemas:\n${this.utils.printReceived(receivedDoc)}`;
 			const diffString = this.utils.diff(expectedDoc, receivedDoc);
 			return `${this.utils.matcherHint(".toEqualProsemirrorNode")}\n\nExpected value of document to equal:\n${this.utils.printExpected(expectedDoc)}\nActual:\n${this.utils.printReceived(receivedDoc)}${diffString === void 0 ? "" : `\n\nDifference:\n\n${diffString}`}`;
 		},

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vitest-prosemirror",
-  "version": "0.3.2",
+  "version": "0.4.0",
   "description": "A plugin for Vitest that enables you to write tests using the ProseMirror editor",
   "keywords": [
     "vitest",
@@ -61,7 +61,7 @@
     "@microsoft/api-extractor": "^7.58.7",
     "@types/node": "^26.0.0",
     "@types/stringify-object": "^4.0.5",
-    "@vitest/coverage-v8": "^4.0.4",
+    "@vitest/coverage-v8": "^5.0.0",
     "@vitest/eslint-plugin": "^1.3.26",
     "es-check": "^9.6.4",
     "eslint": "^10.0.2",
@@ -82,11 +82,11 @@
     "typescript-eslint": "^8.58.0",
     "unplugin-dts": "^1.0.1",
     "vite": "^8.0.0",
-    "vitest": "^4.0.4",
+    "vitest": "^5.0.0",
     "w3c-keyname": "^2.2.8"
   },
   "peerDependencies": {
-    "vitest": "^2.1.9 || ^3.0.7 || ^4.0.4"
+    "vitest": "^2.1.9 || ^3.0.7 || ^4.0.4 || ^5.0.0"
   },
   "peerDependenciesMeta": {
     "vitest": {