@vitest/snapshot 4.1.2 → 4.1.3

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { S as SnapshotStateOptions, a as SnapshotMatchOptions, b as SnapshotResult, R as RawSnapshotInfo } from './rawSnapshot.d-U2kJUxDr.js';
-export { c as SnapshotData, d as SnapshotSerializer, e as SnapshotSummary, f as SnapshotUpdateState, U as UncheckedSnapshot } from './rawSnapshot.d-U2kJUxDr.js';
+import { S as SnapshotStateOptions, a as SnapshotMatchOptions, b as SnapshotResult, R as RawSnapshotInfo } from './rawSnapshot.d-CmdgHNLi.js';
+export { c as SnapshotData, d as SnapshotSerializer, e as SnapshotSummary, f as SnapshotUpdateState, U as UncheckedSnapshot } from './rawSnapshot.d-CmdgHNLi.js';
 import { ParsedStack } from '@vitest/utils';
 import { S as SnapshotEnvironment } from './environment.d-DOJxxZV9.js';
 import { Plugin, Plugins } from '@vitest/pretty-format';
@@ -78,7 +78,11 @@ declare class SnapshotState {
 	getUncheckedCount(): number;
 	getUncheckedKeys(): Array<string>;
 	removeUncheckedKeys(): void;
-	match({ testId, testName, received, key, inlineSnapshot, isInline, error, rawSnapshot }: SnapshotMatchOptions): SnapshotReturnOptions;
+	probeExpectedSnapshot(options: Pick<SnapshotMatchOptions, "testName" | "testId" | "isInline" | "inlineSnapshot">): {
+		data?: string;
+		markAsChecked: () => void;
+	};
+	match({ testId, testName, received, key, inlineSnapshot, isInline, error, rawSnapshot, assertionName }: SnapshotMatchOptions): SnapshotReturnOptions;
 	pack(): Promise<SnapshotResult>;
 }
 
@@ -98,6 +102,14 @@ interface AssertOptions {
 	error?: Error;
 	errorMessage?: string;
 	rawSnapshot?: RawSnapshotInfo;
+	assertionName?: string;
+}
+/** Same shape as expect.extend custom matcher result (SyncExpectationResult from @vitest/expect) */
+interface MatchResult {
+	pass: boolean;
+	message: () => string;
+	actual?: unknown;
+	expected?: unknown;
 }
 interface SnapshotClientOptions {
 	isEqual?: (received: unknown, expected: unknown) => boolean;
@@ -111,6 +123,7 @@ declare class SnapshotClient {
 	skipTest(filepath: string, testName: string): void;
 	clearTest(filepath: string, testId: string): void;
 	getSnapshotState(filepath: string): SnapshotState;
+	match(options: AssertOptions): MatchResult;
 	assert(options: AssertOptions): void;
 	assertRaw(options: AssertOptions): Promise<void>;
 	clear(): void;
@@ -129,3 +142,4 @@ declare function addSerializer(plugin: Plugin): void;
 declare function getSerializers(): Plugins;
 
 export { SnapshotClient, SnapshotEnvironment, SnapshotMatchOptions, SnapshotResult, SnapshotState, SnapshotStateOptions, addSerializer, getSerializers, stripSnapshotIndentation };
+export type { MatchResult };

package/dist/index.js

@@ -1,171 +1,8 @@
 import { parseErrorStacktrace } from '@vitest/utils/source-map';
-import { getCallLastIndex, isObject } from '@vitest/utils/helpers';
+import { isObject, getCallLastIndex } from '@vitest/utils/helpers';
 import { positionToOffset, offsetToLineNumber, lineSplitRE } from '@vitest/utils/offset';
 import { plugins, format } from '@vitest/pretty-format';
 
-async function saveInlineSnapshots(environment, snapshots) {
-	const MagicString = (await import('magic-string')).default;
-	const files = new Set(snapshots.map((i) => i.file));
-	await Promise.all(Array.from(files).map(async (file) => {
-		const snaps = snapshots.filter((i) => i.file === file);
-		const code = await environment.readSnapshotFile(file);
-		if (code == null) {
-			throw new Error(`cannot read ${file} when saving inline snapshot`);
-		}
-		const s = new MagicString(code);
-		for (const snap of snaps) {
-			const index = positionToOffset(code, snap.line, snap.column);
-			replaceInlineSnap(code, s, index, snap.snapshot);
-		}
-		const transformed = s.toString();
-		if (transformed !== code) {
-			await environment.saveSnapshotFile(file, transformed);
-		}
-	}));
-}
-const startObjectRegex = /(?:toMatchInlineSnapshot|toThrowErrorMatchingInlineSnapshot)\s*\(\s*(?:\/\*[\s\S]*\*\/\s*|\/\/.*(?:[\n\r\u2028\u2029]\s*|[\t\v\f \xA0\u1680\u2000-\u200A\u202F\u205F\u3000\uFEFF]))*\{/;
-function replaceObjectSnap(code, s, index, newSnap) {
-	let _code = code.slice(index);
-	const startMatch = startObjectRegex.exec(_code);
-	if (!startMatch) {
-		return false;
-	}
-	_code = _code.slice(startMatch.index);
-	let callEnd = getCallLastIndex(_code);
-	if (callEnd === null) {
-		return false;
-	}
-	callEnd += index + startMatch.index;
-	const shapeStart = index + startMatch.index + startMatch[0].length;
-	const shapeEnd = getObjectShapeEndIndex(code, shapeStart);
-	const snap = `, ${prepareSnapString(newSnap, code, index)}`;
-	if (shapeEnd === callEnd) {
-		// toMatchInlineSnapshot({ foo: expect.any(String) })
-		s.appendLeft(callEnd, snap);
-	} else {
-		// toMatchInlineSnapshot({ foo: expect.any(String) }, ``)
-		s.overwrite(shapeEnd, callEnd, snap);
-	}
-	return true;
-}
-function getObjectShapeEndIndex(code, index) {
-	let startBraces = 1;
-	let endBraces = 0;
-	while (startBraces !== endBraces && index < code.length) {
-		const s = code[index++];
-		if (s === "{") {
-			startBraces++;
-		} else if (s === "}") {
-			endBraces++;
-		}
-	}
-	return index;
-}
-function prepareSnapString(snap, source, index) {
-	const lineNumber = offsetToLineNumber(source, index);
-	const line = source.split(lineSplitRE)[lineNumber - 1];
-	const indent = line.match(/^\s*/)[0] || "";
-	const indentNext = indent.includes("	") ? `${indent}\t` : `${indent}  `;
-	const lines = snap.trim().replace(/\\/g, "\\\\").split(/\n/g);
-	const isOneline = lines.length <= 1;
-	const quote = "`";
-	if (isOneline) {
-		return `${quote}${lines.join("\n").replace(/`/g, "\\`").replace(/\$\{/g, "\\${")}${quote}`;
-	}
-	return `${quote}\n${lines.map((i) => i ? indentNext + i : "").join("\n").replace(/`/g, "\\`").replace(/\$\{/g, "\\${")}\n${indent}${quote}`;
-}
-const toMatchInlineName = "toMatchInlineSnapshot";
-const toThrowErrorMatchingInlineName = "toThrowErrorMatchingInlineSnapshot";
-// on webkit, the line number is at the end of the method, not at the start
-function getCodeStartingAtIndex(code, index) {
-	const indexInline = index - toMatchInlineName.length;
-	if (code.slice(indexInline, index) === toMatchInlineName) {
-		return {
-			code: code.slice(indexInline),
-			index: indexInline
-		};
-	}
-	const indexThrowInline = index - toThrowErrorMatchingInlineName.length;
-	if (code.slice(index - indexThrowInline, index) === toThrowErrorMatchingInlineName) {
-		return {
-			code: code.slice(index - indexThrowInline),
-			index: index - indexThrowInline
-		};
-	}
-	return {
-		code: code.slice(index),
-		index
-	};
-}
-const startRegex = /(?:toMatchInlineSnapshot|toThrowErrorMatchingInlineSnapshot)\s*\(\s*(?:\/\*[\s\S]*\*\/\s*|\/\/.*(?:[\n\r\u2028\u2029]\s*|[\t\v\f \xA0\u1680\u2000-\u200A\u202F\u205F\u3000\uFEFF]))*[\w$]*(['"`)])/;
-function replaceInlineSnap(code, s, currentIndex, newSnap) {
-	const { code: codeStartingAtIndex, index } = getCodeStartingAtIndex(code, currentIndex);
-	const startMatch = startRegex.exec(codeStartingAtIndex);
-	const firstKeywordMatch = /toMatchInlineSnapshot|toThrowErrorMatchingInlineSnapshot/.exec(codeStartingAtIndex);
-	if (!startMatch || startMatch.index !== firstKeywordMatch?.index) {
-		return replaceObjectSnap(code, s, index, newSnap);
-	}
-	const quote = startMatch[1];
-	const startIndex = index + startMatch.index + startMatch[0].length;
-	const snapString = prepareSnapString(newSnap, code, index);
-	if (quote === ")") {
-		s.appendRight(startIndex - 1, snapString);
-		return true;
-	}
-	const quoteEndRE = new RegExp(`(?:^|[^\\\\])${quote}`);
-	const endMatch = quoteEndRE.exec(code.slice(startIndex));
-	if (!endMatch) {
-		return false;
-	}
-	const endIndex = startIndex + endMatch.index + endMatch[0].length;
-	s.overwrite(startIndex - 1, endIndex, snapString);
-	return true;
-}
-const INDENTATION_REGEX = /^([^\S\n]*)\S/m;
-function stripSnapshotIndentation(inlineSnapshot) {
-	// Find indentation if exists.
-	const match = inlineSnapshot.match(INDENTATION_REGEX);
-	if (!match || !match[1]) {
-		// No indentation.
-		return inlineSnapshot;
-	}
-	const indentation = match[1];
-	const lines = inlineSnapshot.split(/\n/g);
-	if (lines.length <= 2) {
-		// Must be at least 3 lines.
-		return inlineSnapshot;
-	}
-	if (lines[0].trim() !== "" || lines.at(-1)?.trim() !== "") {
-		// If not blank first and last lines, abort.
-		return inlineSnapshot;
-	}
-	for (let i = 1; i < lines.length - 1; i++) {
-		if (lines[i] !== "") {
-			if (lines[i].indexOf(indentation) !== 0) {
-				// All lines except first and last should either be blank or have the same
-				// indent as the first line (or more). If this isn't the case we don't
-				// want to touch the snapshot at all.
-				return inlineSnapshot;
-			}
-			lines[i] = lines[i].substring(indentation.length);
-		}
-	}
-	// Last line is a special case because it won't have the same indent as others
-	// but may still have been given some indent to line up.
-	lines[lines.length - 1] = "";
-	// Return inline snapshot, now at indent 0.
-	inlineSnapshot = lines.join("\n");
-	return inlineSnapshot;
-}
-
-async function saveRawSnapshots(environment, snapshots) {
-	await Promise.all(snapshots.map(async (snap) => {
-		if (!snap.readonly) {
-			await environment.saveSnapshotFile(snap.file, snap.snapshot);
-		}
-	}));
-}
-
 function getDefaultExportFromCjs(x) {
 	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
 }
@@ -448,6 +285,188 @@ class CounterMap extends DefaultMap {
 		return total;
 	}
 }
+/* @__NO_SIDE_EFFECTS__ */
+function memo(fn) {
+	const cache = new Map();
+	return (arg) => {
+		if (!cache.has(arg)) {
+			cache.set(arg, fn(arg));
+		}
+		return cache.get(arg);
+	};
+}
+
+async function saveInlineSnapshots(environment, snapshots) {
+	const MagicString = (await import('magic-string')).default;
+	const files = new Set(snapshots.map((i) => i.file));
+	await Promise.all(Array.from(files).map(async (file) => {
+		const snaps = snapshots.filter((i) => i.file === file);
+		const code = await environment.readSnapshotFile(file);
+		if (code == null) {
+			throw new Error(`cannot read ${file} when saving inline snapshot`);
+		}
+		const s = new MagicString(code);
+		for (const snap of snaps) {
+			const index = positionToOffset(code, snap.line, snap.column);
+			replaceInlineSnap(code, s, index, snap.snapshot, snap.assertionName);
+		}
+		const transformed = s.toString();
+		if (transformed !== code) {
+			await environment.saveSnapshotFile(file, transformed);
+		}
+	}));
+}
+const defaultStartObjectRegex = /(?:toMatchInlineSnapshot|toThrowErrorMatchingInlineSnapshot)\s*\(\s*(?:\/\*[\s\S]*\*\/\s*|\/\/.*(?:[\n\r\u2028\u2029]\s*|[\t\v\f \xA0\u1680\u2000-\u200A\u202F\u205F\u3000\uFEFF]))*\{/;
+function escapeRegExp(s) {
+	return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+const buildStartObjectRegex = memo((assertionName) => {
+	const replaced = defaultStartObjectRegex.source.replace("toMatchInlineSnapshot|toThrowErrorMatchingInlineSnapshot", escapeRegExp(assertionName));
+	return new RegExp(replaced);
+});
+function replaceObjectSnap(code, s, index, newSnap, assertionName) {
+	let _code = code.slice(index);
+	const regex = assertionName ? buildStartObjectRegex(assertionName) : defaultStartObjectRegex;
+	const startMatch = regex.exec(_code);
+	if (!startMatch) {
+		return false;
+	}
+	_code = _code.slice(startMatch.index);
+	let callEnd = getCallLastIndex(_code);
+	if (callEnd === null) {
+		return false;
+	}
+	callEnd += index + startMatch.index;
+	const shapeStart = index + startMatch.index + startMatch[0].length;
+	const shapeEnd = getObjectShapeEndIndex(code, shapeStart);
+	const snap = `, ${prepareSnapString(newSnap, code, index)}`;
+	if (shapeEnd === callEnd) {
+		// toMatchInlineSnapshot({ foo: expect.any(String) })
+		s.appendLeft(callEnd, snap);
+	} else {
+		// toMatchInlineSnapshot({ foo: expect.any(String) }, ``)
+		s.overwrite(shapeEnd, callEnd, snap);
+	}
+	return true;
+}
+function getObjectShapeEndIndex(code, index) {
+	let startBraces = 1;
+	let endBraces = 0;
+	while (startBraces !== endBraces && index < code.length) {
+		const s = code[index++];
+		if (s === "{") {
+			startBraces++;
+		} else if (s === "}") {
+			endBraces++;
+		}
+	}
+	return index;
+}
+function prepareSnapString(snap, source, index) {
+	const lineNumber = offsetToLineNumber(source, index);
+	const line = source.split(lineSplitRE)[lineNumber - 1];
+	const indent = line.match(/^\s*/)[0] || "";
+	const indentNext = indent.includes("	") ? `${indent}\t` : `${indent}  `;
+	const lines = snap.trim().replace(/\\/g, "\\\\").split(/\n/g);
+	const isOneline = lines.length <= 1;
+	const quote = "`";
+	if (isOneline) {
+		return `${quote}${lines.join("\n").replace(/`/g, "\\`").replace(/\$\{/g, "\\${")}${quote}`;
+	}
+	return `${quote}\n${lines.map((i) => i ? indentNext + i : "").join("\n").replace(/`/g, "\\`").replace(/\$\{/g, "\\${")}\n${indent}${quote}`;
+}
+const defaultMethodNames = ["toMatchInlineSnapshot", "toThrowErrorMatchingInlineSnapshot"];
+// on webkit, the line number is at the end of the method, not at the start
+function getCodeStartingAtIndex(code, index, methodNames) {
+	for (const name of methodNames) {
+		const adjusted = index - name.length;
+		if (adjusted >= 0 && code.slice(adjusted, index) === name) {
+			return {
+				code: code.slice(adjusted),
+				index: adjusted
+			};
+		}
+	}
+	return {
+		code: code.slice(index),
+		index
+	};
+}
+const defaultStartRegex = /(?:toMatchInlineSnapshot|toThrowErrorMatchingInlineSnapshot)\s*\(\s*(?:\/\*[\s\S]*\*\/\s*|\/\/.*(?:[\n\r\u2028\u2029]\s*|[\t\v\f \xA0\u1680\u2000-\u200A\u202F\u205F\u3000\uFEFF]))*[\w$]*(['"`)])/;
+const buildStartRegex = memo((assertionName) => {
+	const replaced = defaultStartRegex.source.replace("toMatchInlineSnapshot|toThrowErrorMatchingInlineSnapshot", escapeRegExp(assertionName));
+	return new RegExp(replaced);
+});
+function replaceInlineSnap(code, s, currentIndex, newSnap, assertionName) {
+	const methodNames = assertionName ? [assertionName] : defaultMethodNames;
+	const { code: codeStartingAtIndex, index } = getCodeStartingAtIndex(code, currentIndex, methodNames);
+	const startRegex = assertionName ? buildStartRegex(assertionName) : defaultStartRegex;
+	const startMatch = startRegex.exec(codeStartingAtIndex);
+	const keywordRegex = assertionName ? new RegExp(escapeRegExp(assertionName)) : /toMatchInlineSnapshot|toThrowErrorMatchingInlineSnapshot/;
+	const firstKeywordMatch = keywordRegex.exec(codeStartingAtIndex);
+	if (!startMatch || startMatch.index !== firstKeywordMatch?.index) {
+		return replaceObjectSnap(code, s, index, newSnap, assertionName);
+	}
+	const quote = startMatch[1];
+	const startIndex = index + startMatch.index + startMatch[0].length;
+	const snapString = prepareSnapString(newSnap, code, index);
+	if (quote === ")") {
+		s.appendRight(startIndex - 1, snapString);
+		return true;
+	}
+	const quoteEndRE = new RegExp(`(?:^|[^\\\\])${quote}`);
+	const endMatch = quoteEndRE.exec(code.slice(startIndex));
+	if (!endMatch) {
+		return false;
+	}
+	const endIndex = startIndex + endMatch.index + endMatch[0].length;
+	s.overwrite(startIndex - 1, endIndex, snapString);
+	return true;
+}
+const INDENTATION_REGEX = /^([^\S\n]*)\S/m;
+function stripSnapshotIndentation(inlineSnapshot) {
+	// Find indentation if exists.
+	const match = inlineSnapshot.match(INDENTATION_REGEX);
+	if (!match || !match[1]) {
+		// No indentation.
+		return inlineSnapshot;
+	}
+	const indentation = match[1];
+	const lines = inlineSnapshot.split(/\n/g);
+	if (lines.length <= 2) {
+		// Must be at least 3 lines.
+		return inlineSnapshot;
+	}
+	if (lines[0].trim() !== "" || lines.at(-1)?.trim() !== "") {
+		// If not blank first and last lines, abort.
+		return inlineSnapshot;
+	}
+	for (let i = 1; i < lines.length - 1; i++) {
+		if (lines[i] !== "") {
+			if (lines[i].indexOf(indentation) !== 0) {
+				// All lines except first and last should either be blank or have the same
+				// indent as the first line (or more). If this isn't the case we don't
+				// want to touch the snapshot at all.
+				return inlineSnapshot;
+			}
+			lines[i] = lines[i].substring(indentation.length);
+		}
+	}
+	// Last line is a special case because it won't have the same indent as others
+	// but may still have been given some indent to line up.
+	lines[lines.length - 1] = "";
+	// Return inline snapshot, now at indent 0.
+	inlineSnapshot = lines.join("\n");
+	return inlineSnapshot;
+}
+
+async function saveRawSnapshots(environment, snapshots) {
+	await Promise.all(snapshots.map(async (snap) => {
+		if (!snap.readonly) {
+			await environment.saveSnapshotFile(snap.file, snap.snapshot);
+		}
+	}));
+}
 
 function isSameStackPosition(x, y) {
 	return x.file === y.file && x.column === y.column && x.line === y.line;
@@ -572,6 +591,12 @@ class SnapshotState {
 				return stacks[i + Number(match[1])] ?? null;
 			}
 		}
+		// custom matcher registered via expect.extend() — the wrapper function
+		// in jest-extend.ts is named __VITEST_EXTEND_ASSERTION__
+		const customMatcherIndex = stacks.findIndex((i) => i.method.includes("__VITEST_EXTEND_ASSERTION__"));
+		if (customMatcherIndex !== -1) {
+			return stacks[customMatcherIndex + 3] ?? null;
+		}
 		// inline snapshot function is called __INLINE_SNAPSHOT__
 		// in integrations/snapshot/chai.ts
 		const stackIndex = stacks.findIndex((i) => i.method.includes("__INLINE_SNAPSHOT__"));
@@ -581,9 +606,10 @@ class SnapshotState {
 		this._dirty = true;
 		if (options.stack) {
 			this._inlineSnapshots.push({
+				...options.stack,
 				snapshot: receivedSerialized,
 				testId: options.testId,
-				...options.stack
+				assertionName: options.assertionName
 			});
 		} else if (options.rawSnapshot) {
 			this._rawSnapshots.push({
@@ -637,7 +663,19 @@ class SnapshotState {
 			this._uncheckedKeys.clear();
 		}
 	}
-	match({ testId, testName, received, key, inlineSnapshot, isInline, error, rawSnapshot }) {
+	probeExpectedSnapshot(options) {
+		const count = this._counters.get(options.testName) + 1;
+		const key = testNameToKey(options.testName, count);
+		return {
+			data: options?.isInline ? options.inlineSnapshot : this._snapshotData[key],
+			markAsChecked: () => {
+				this._counters.increment(options.testName);
+				this._testIdToKeys.get(options.testId).push(key);
+				this._uncheckedKeys.delete(key);
+			}
+		};
+	}
+	match({ testId, testName, received, key, inlineSnapshot, isInline, error, rawSnapshot, assertionName }) {
 		// this also increments counter for inline snapshots. maybe we shouldn't?
 		this._counters.increment(testName);
 		const count = this._counters.get(testName);
@@ -725,7 +763,8 @@ class SnapshotState {
 					this._addSnapshot(key, receivedSerialized, {
 						stack,
 						testId,
-						rawSnapshot
+						rawSnapshot,
+						assertionName
 					});
 				} else {
 					this.matched.increment(testId);
@@ -734,7 +773,8 @@ class SnapshotState {
 				this._addSnapshot(key, receivedSerialized, {
 					stack,
 					testId,
-					rawSnapshot
+					rawSnapshot,
+					assertionName
 				});
 				this.added.increment(testId);
 			}
@@ -844,31 +884,44 @@ class SnapshotClient {
 		}
 		return state;
 	}
-	assert(options) {
-		const { filepath, name, testId = name, message, isInline = false, properties, inlineSnapshot, error, errorMessage, rawSnapshot } = options;
+	match(options) {
+		const { filepath, name, testId = name, message, isInline = false, properties, inlineSnapshot, error, errorMessage, rawSnapshot, assertionName } = options;
 		let { received } = options;
 		if (!filepath) {
 			throw new Error("Snapshot cannot be used outside of test");
 		}
 		const snapshotState = this.getSnapshotState(filepath);
+		const testName = [name, ...message ? [message] : []].join(" > ");
+		// Probe first so we can mark as checked even on early return
+		const expectedSnapshot = snapshotState.probeExpectedSnapshot({
+			testName,
+			testId,
+			isInline,
+			inlineSnapshot
+		});
 		if (typeof properties === "object") {
 			if (typeof received !== "object" || !received) {
+				expectedSnapshot.markAsChecked();
 				throw new Error("Received value must be an object when the matcher has properties");
 			}
+			let propertiesPass;
 			try {
-				const pass = this.options.isEqual?.(received, properties) ?? false;
-				// const pass = equals(received, properties, [iterableEquality, subsetEquality])
-				if (!pass) {
-					throw createMismatchError("Snapshot properties mismatched", snapshotState.expand, received, properties);
-				} else {
-					received = deepMergeSnapshot(received, properties);
-				}
+				propertiesPass = this.options.isEqual?.(received, properties) ?? false;
 			} catch (err) {
-				err.message = errorMessage || "Snapshot mismatched";
+				expectedSnapshot.markAsChecked();
 				throw err;
 			}
+			if (!propertiesPass) {
+				expectedSnapshot.markAsChecked();
+				return {
+					pass: false,
+					message: () => errorMessage || "Snapshot properties mismatched",
+					actual: received,
+					expected: properties
+				};
+			}
+			received = deepMergeSnapshot(received, properties);
 		}
-		const testName = [name, ...message ? [message] : []].join(" > ");
 		const { actual, expected, key, pass } = snapshotState.match({
 			testId,
 			testName,
@@ -876,10 +929,21 @@ class SnapshotClient {
 			isInline,
 			error,
 			inlineSnapshot,
-			rawSnapshot
+			rawSnapshot,
+			assertionName
 		});
-		if (!pass) {
-			throw createMismatchError(`Snapshot \`${key || "unknown"}\` mismatched`, snapshotState.expand, rawSnapshot ? actual : actual?.trim(), rawSnapshot ? expected : expected?.trim());
+		return {
+			pass,
+			message: () => `Snapshot \`${key || "unknown"}\` mismatched`,
+			actual: rawSnapshot ? actual : actual?.trim(),
+			expected: rawSnapshot ? expected : expected?.trim()
+		};
+	}
+	assert(options) {
+		const result = this.match(options);
+		if (!result.pass) {
+			const snapshotState = this.getSnapshotState(options.filepath);
+			throw createMismatchError(result.message(), snapshotState.expand, result.actual, result.expected);
 		}
 	}
 	async assertRaw(options) {

package/dist/manager.d.ts

@@ -1,4 +1,4 @@
-import { S as SnapshotStateOptions, e as SnapshotSummary, b as SnapshotResult } from './rawSnapshot.d-U2kJUxDr.js';
+import { S as SnapshotStateOptions, e as SnapshotSummary, b as SnapshotResult } from './rawSnapshot.d-CmdgHNLi.js';
 import '@vitest/pretty-format';
 import './environment.d-DOJxxZV9.js';
 import '@vitest/utils';

package/dist/{rawSnapshot.d-U2kJUxDr.d.ts → rawSnapshot.d-CmdgHNLi.d.ts}

@@ -20,6 +20,7 @@ interface SnapshotMatchOptions {
 	isInline: boolean;
 	error?: Error;
 	rawSnapshot?: RawSnapshotInfo;
+	assertionName?: string;
 }
 interface SnapshotResult {
 	filepath: string;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vitest/snapshot",
   "type": "module",
-  "version": "4.1.2",
+  "version": "4.1.3",
   "description": "Vitest snapshot manager",
   "license": "MIT",
   "funding": "https://opencollective.com/vitest",
@@ -45,8 +45,8 @@
   "dependencies": {
     "magic-string": "^0.30.21",
     "pathe": "^2.0.3",
-    "@vitest/pretty-format": "4.1.2",
-    "@vitest/utils": "4.1.2"
+    "@vitest/utils": "4.1.3",
+    "@vitest/pretty-format": "4.1.3"
   },
   "devDependencies": {
     "@types/natural-compare": "^1.4.3",