@vitest/snapshot 4.1.3 → 4.1.5

package/dist/index.d.ts

@@ -1,90 +1,8 @@
-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 { S as SnapshotState, a as SnapshotStateOptions, b as SnapshotResult, R as RawSnapshotInfo, D as DomainSnapshotAdapter } from './rawSnapshot.d-D_X3-62x.js';
+export { c as DomainMatchResult, d as SnapshotData, e as SnapshotMatchOptions, f as SnapshotSerializer, g as SnapshotSummary, h as SnapshotUpdateState, U as UncheckedSnapshot } from './rawSnapshot.d-D_X3-62x.js';
 import { Plugin, Plugins } from '@vitest/pretty-format';
-
-/**
-* Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
-*
-* This source code is licensed under the MIT license found in the
-* LICENSE file in the root directory of this source tree.
-*/
-
-declare class DefaultMap<
-	K,
-	V
-> extends Map<K, V> {
-	private defaultFn;
-	constructor(defaultFn: (key: K) => V, entries?: Iterable<readonly [K, V]>);
-	get(key: K): V;
-}
-declare class CounterMap<K> extends DefaultMap<K, number> {
-	constructor();
-	_total: number | undefined;
-	valueOf(): number;
-	increment(key: K): void;
-	total(): number;
-}
-
-interface SnapshotReturnOptions {
-	actual: string;
-	count: number;
-	expected?: string;
-	key: string;
-	pass: boolean;
-}
-interface SaveStatus {
-	deleted: boolean;
-	saved: boolean;
-}
-declare class SnapshotState {
-	testFilePath: string;
-	snapshotPath: string;
-	private _counters;
-	private _dirty;
-	private _updateSnapshot;
-	private _snapshotData;
-	private _initialData;
-	private _inlineSnapshots;
-	private _inlineSnapshotStacks;
-	private _testIdToKeys;
-	private _rawSnapshots;
-	private _uncheckedKeys;
-	private _snapshotFormat;
-	private _environment;
-	private _fileExists;
-	expand: boolean;
-	private _added;
-	private _matched;
-	private _unmatched;
-	private _updated;
-	get added(): CounterMap<string>;
-	set added(value: number);
-	get matched(): CounterMap<string>;
-	set matched(value: number);
-	get unmatched(): CounterMap<string>;
-	set unmatched(value: number);
-	get updated(): CounterMap<string>;
-	set updated(value: number);
-	private constructor();
-	static create(testFilePath: string, options: SnapshotStateOptions): Promise<SnapshotState>;
-	get environment(): SnapshotEnvironment;
-	markSnapshotsAsCheckedForTest(testName: string): void;
-	clearTest(testId: string): void;
-	protected _inferInlineSnapshotStack(stacks: ParsedStack[]): ParsedStack | null;
-	private _addSnapshot;
-	save(): Promise<SaveStatus>;
-	getUncheckedCount(): number;
-	getUncheckedKeys(): Array<string>;
-	removeUncheckedKeys(): void;
-	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>;
-}
+export { S as SnapshotEnvironment } from './environment.d-DOJxxZV9.js';
+import '@vitest/utils';
 
 interface AssertOptions {
 	received: unknown;
@@ -104,6 +22,15 @@ interface AssertOptions {
 	rawSnapshot?: RawSnapshotInfo;
 	assertionName?: string;
 }
+interface AssertDomainOptions extends Omit<AssertOptions, "received"> {
+	received: unknown;
+	adapter: DomainSnapshotAdapter<any, any>;
+}
+interface AssertDomainPollOptions extends Omit<AssertDomainOptions, "received"> {
+	poll: () => Promise<unknown> | unknown;
+	timeout?: number;
+	interval?: number;
+}
 /** Same shape as expect.extend custom matcher result (SyncExpectationResult from @vitest/expect) */
 interface MatchResult {
 	pass: boolean;
@@ -125,6 +52,8 @@ declare class SnapshotClient {
 	getSnapshotState(filepath: string): SnapshotState;
 	match(options: AssertOptions): MatchResult;
 	assert(options: AssertOptions): void;
+	matchDomain(options: AssertDomainOptions): MatchResult;
+	pollMatchDomain(options: AssertDomainPollOptions): Promise<MatchResult>;
 	assertRaw(options: AssertOptions): Promise<void>;
 	clear(): void;
 }
@@ -141,5 +70,5 @@ declare function stripSnapshotIndentation(inlineSnapshot: string): string;
 declare function addSerializer(plugin: Plugin): void;
 declare function getSerializers(): Plugins;
 
-export { SnapshotClient, SnapshotEnvironment, SnapshotMatchOptions, SnapshotResult, SnapshotState, SnapshotStateOptions, addSerializer, getSerializers, stripSnapshotIndentation };
+export { DomainSnapshotAdapter, SnapshotClient, SnapshotResult, SnapshotState, SnapshotStateOptions, addSerializer, getSerializers, stripSnapshotIndentation };
 export type { MatchResult };

package/dist/index.js

@@ -533,6 +533,7 @@ class SnapshotState {
 		this._snapshotFormat = {
 			printBasicPrototype: false,
 			escapeString: false,
+			maxOutputLength: 2 ** 27,
 			...options.snapshotFormat
 		};
 		this._environment = options.snapshotEnvironment;
@@ -542,6 +543,9 @@ class SnapshotState {
 		const content = await options.snapshotEnvironment.readSnapshotFile(snapshotPath);
 		return new SnapshotState(testFilePath, snapshotPath, content, options);
 	}
+	get snapshotUpdateState() {
+		return this._updateSnapshot;
+	}
 	get environment() {
 		return this._environment;
 	}
@@ -583,6 +587,11 @@ class SnapshotState {
 		if (promiseIndex !== -1) {
 			return stacks[promiseIndex + 3];
 		}
+		// support poll + inline snapshot
+		const pollChainIndex = stacks.findIndex((i) => i.method.match(/__VITEST_POLL_CHAIN__/));
+		if (pollChainIndex !== -1) {
+			return stacks[pollChainIndex + 1];
+		}
 		// inline snapshot function can be named __INLINE_SNAPSHOT_OFFSET_<n>__
 		// to specify a custom stack offset
 		for (let i = 0; i < stacks.length; i++) {
@@ -620,6 +629,114 @@ class SnapshotState {
 			this._snapshotData[key] = receivedSerialized;
 		}
 	}
+	_resolveKey(testId, testName, key) {
+		this._counters.increment(testName);
+		const count = this._counters.get(testName);
+		if (!key) {
+			key = testNameToKey(testName, count);
+		}
+		this._testIdToKeys.get(testId).push(key);
+		return {
+			key,
+			count
+		};
+	}
+	_resolveInlineStack(options) {
+		const { testId, snapshot, assertionName, error } = options;
+		const stacks = parseErrorStacktrace(error, { ignoreStackEntries: [] });
+		const _stack = this._inferInlineSnapshotStack(stacks);
+		if (!_stack) {
+			const message = stacks.map((s) => `  ${s.file}:${s.line}:${s.column}${s.method ? ` (${s.method})` : ""}`).join("\n");
+			throw new Error(`@vitest/snapshot: Couldn't infer stack frame for inline snapshot.\n${message}`);
+		}
+		const stack = this.environment.processStackTrace?.(_stack) || _stack;
+		// removing 1 column, because source map points to the wrong
+		// location for js files, but `column-1` points to the same in both js/ts
+		// https://github.com/vitejs/vite/issues/8657
+		stack.column--;
+		// reject multiple inline snapshots at the same location if snapshot is different
+		const snapshotsWithSameStack = this._inlineSnapshotStacks.filter((s) => isSameStackPosition(s, stack));
+		if (snapshotsWithSameStack.length > 0) {
+			// ensure only one snapshot will be written at the same location
+			this._inlineSnapshots = this._inlineSnapshots.filter((s) => !isSameStackPosition(s, stack));
+			const differentSnapshot = snapshotsWithSameStack.find((s) => s.snapshot !== snapshot);
+			if (differentSnapshot) {
+				throw Object.assign(new Error(`${assertionName} with different snapshots cannot be called at the same location`), {
+					actual: snapshot,
+					expected: differentSnapshot.snapshot
+				});
+			}
+		}
+		this._inlineSnapshotStacks.push({
+			...stack,
+			testId,
+			snapshot
+		});
+		return stack;
+	}
+	_reconcile(opts) {
+		// These are the conditions on when to write snapshots:
+		//  * There's no snapshot file in a non-CI environment.
+		//  * There is a snapshot file and we decided to update the snapshot.
+		//  * There is a snapshot file, but it doesn't have this snapshot.
+		// These are the conditions on when not to write snapshots:
+		//  * The update flag is set to 'none'.
+		//  * There's no snapshot file or a file without this snapshot on a CI environment.
+		if (opts.hasSnapshot && this._updateSnapshot === "all" || (!opts.hasSnapshot || !opts.snapshotIsPersisted) && (this._updateSnapshot === "new" || this._updateSnapshot === "all")) {
+			if (this._updateSnapshot === "all") {
+				if (!opts.pass) {
+					if (opts.hasSnapshot) {
+						this.updated.increment(opts.testId);
+					} else {
+						this.added.increment(opts.testId);
+					}
+					this._addSnapshot(opts.key, opts.addValue, {
+						stack: opts.stack,
+						testId: opts.testId,
+						rawSnapshot: opts.rawSnapshot,
+						assertionName: opts.assertionName
+					});
+				} else {
+					this.matched.increment(opts.testId);
+				}
+			} else {
+				this._addSnapshot(opts.key, opts.addValue, {
+					stack: opts.stack,
+					testId: opts.testId,
+					rawSnapshot: opts.rawSnapshot,
+					assertionName: opts.assertionName
+				});
+				this.added.increment(opts.testId);
+			}
+			return {
+				actual: "",
+				count: opts.count,
+				expected: "",
+				key: opts.key,
+				pass: true
+			};
+		} else {
+			if (!opts.pass) {
+				this.unmatched.increment(opts.testId);
+				return {
+					actual: opts.actualDisplay,
+					count: opts.count,
+					expected: opts.expectedDisplay,
+					key: opts.key,
+					pass: false
+				};
+			} else {
+				this.matched.increment(opts.testId);
+				return {
+					actual: "",
+					count: opts.count,
+					expected: "",
+					key: opts.key,
+					pass: true
+				};
+			}
+		}
+	}
 	async save() {
 		const hasExternalSnapshots = Object.keys(this._snapshotData).length;
 		const hasInlineSnapshots = this._inlineSnapshots.length;
@@ -667,6 +784,8 @@ class SnapshotState {
 		const count = this._counters.get(options.testName) + 1;
 		const key = testNameToKey(options.testName, count);
 		return {
+			key,
+			count,
 			data: options?.isInline ? options.inlineSnapshot : this._snapshotData[key],
 			markAsChecked: () => {
 				this._counters.increment(options.testName);
@@ -676,13 +795,9 @@ class SnapshotState {
 		};
 	}
 	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);
-		if (!key) {
-			key = testNameToKey(testName, count);
-		}
-		this._testIdToKeys.get(testId).push(key);
+		const resolved = this._resolveKey(testId, testName, key);
+		key = resolved.key;
+		const count = resolved.count;
 		// Do not mark the snapshot as "checked" if the snapshot is inline and
 		// there's an external snapshot. This way the external snapshot can be
 		// removed with `--updateSnapshot`.
@@ -705,107 +820,57 @@ class SnapshotState {
 		const hasSnapshot = expected !== undefined;
 		const snapshotIsPersisted = isInline || this._fileExists || rawSnapshot && rawSnapshot.content != null;
 		if (pass && !isInline && !rawSnapshot) {
-			// Executing a snapshot file as JavaScript and writing the strings back
-			// when other snapshots have changed loses the proper escaping for some
-			// characters. Since we check every snapshot in every test, use the newly
-			// generated formatted string.
-			// Note that this is only relevant when a snapshot is added and the dirty
-			// flag is set.
+			// When the file is re-saved (because other snapshots changed), the JS
+			// round-trip can lose proper escaping. Refresh in-memory data with the
+			// freshly serialized string so the file is written correctly.
+			// _reconcile does not write _snapshotData on pass, so this is the only
+			// place it gets refreshed. Domain snapshots skip this because the stored
+			// value may contain match patterns that differ from the received output.
 			this._snapshotData[key] = receivedSerialized;
 		}
-		// find call site of toMatchInlineSnapshot
-		let stack;
-		if (isInline) {
-			const stacks = parseErrorStacktrace(error || new Error("snapshot"), { ignoreStackEntries: [] });
-			const _stack = this._inferInlineSnapshotStack(stacks);
-			if (!_stack) {
-				throw new Error(`@vitest/snapshot: Couldn't infer stack frame for inline snapshot.\n${JSON.stringify(stacks)}`);
-			}
-			stack = this.environment.processStackTrace?.(_stack) || _stack;
-			// removing 1 column, because source map points to the wrong
-			// location for js files, but `column-1` points to the same in both js/ts
-			// https://github.com/vitejs/vite/issues/8657
-			stack.column--;
-			// reject multiple inline snapshots at the same location if snapshot is different
-			const snapshotsWithSameStack = this._inlineSnapshotStacks.filter((s) => isSameStackPosition(s, stack));
-			if (snapshotsWithSameStack.length > 0) {
-				// ensure only one snapshot will be written at the same location
-				this._inlineSnapshots = this._inlineSnapshots.filter((s) => !isSameStackPosition(s, stack));
-				const differentSnapshot = snapshotsWithSameStack.find((s) => s.snapshot !== receivedSerialized);
-				if (differentSnapshot) {
-					throw Object.assign(new Error("toMatchInlineSnapshot with different snapshots cannot be called at the same location"), {
-						actual: receivedSerialized,
-						expected: differentSnapshot.snapshot
-					});
-				}
-			}
-			this._inlineSnapshotStacks.push({
-				...stack,
-				testId,
-				snapshot: receivedSerialized
-			});
-		}
-		// These are the conditions on when to write snapshots:
-		//  * There's no snapshot file in a non-CI environment.
-		//  * There is a snapshot file and we decided to update the snapshot.
-		//  * There is a snapshot file, but it doesn't have this snapshot.
-		// These are the conditions on when not to write snapshots:
-		//  * The update flag is set to 'none'.
-		//  * There's no snapshot file or a file without this snapshot on a CI environment.
-		if (hasSnapshot && this._updateSnapshot === "all" || (!hasSnapshot || !snapshotIsPersisted) && (this._updateSnapshot === "new" || this._updateSnapshot === "all")) {
-			if (this._updateSnapshot === "all") {
-				if (!pass) {
-					if (hasSnapshot) {
-						this.updated.increment(testId);
-					} else {
-						this.added.increment(testId);
-					}
-					this._addSnapshot(key, receivedSerialized, {
-						stack,
-						testId,
-						rawSnapshot,
-						assertionName
-					});
-				} else {
-					this.matched.increment(testId);
-				}
-			} else {
-				this._addSnapshot(key, receivedSerialized, {
-					stack,
-					testId,
-					rawSnapshot,
-					assertionName
-				});
-				this.added.increment(testId);
-			}
-			return {
-				actual: "",
-				count,
-				expected: "",
-				key,
-				pass: true
-			};
-		} else {
-			if (!pass) {
-				this.unmatched.increment(testId);
-				return {
-					actual: rawSnapshot ? receivedSerialized : removeExtraLineBreaks(receivedSerialized),
-					count,
-					expected: expectedTrimmed !== undefined ? rawSnapshot ? expectedTrimmed : removeExtraLineBreaks(expectedTrimmed) : undefined,
-					key,
-					pass: false
-				};
-			} else {
-				this.matched.increment(testId);
-				return {
-					actual: "",
-					count,
-					expected: "",
-					key,
-					pass: true
-				};
-			}
-		}
+		const stack = isInline ? this._resolveInlineStack({
+			testId,
+			snapshot: receivedSerialized,
+			assertionName: assertionName || "toMatchInlineSnapshot",
+			error: error || new Error("snapshot")
+		}) : undefined;
+		return this._reconcile({
+			testId,
+			key,
+			count,
+			pass,
+			hasSnapshot,
+			snapshotIsPersisted: !!snapshotIsPersisted,
+			addValue: receivedSerialized,
+			actualDisplay: rawSnapshot ? receivedSerialized : removeExtraLineBreaks(receivedSerialized),
+			expectedDisplay: expectedTrimmed !== undefined ? rawSnapshot ? expectedTrimmed : removeExtraLineBreaks(expectedTrimmed) : undefined,
+			stack,
+			rawSnapshot,
+			assertionName
+		});
+	}
+	processDomainSnapshot({ testId, received, expectedSnapshot, matchResult, isInline, error, assertionName }) {
+		const stack = isInline ? this._resolveInlineStack({
+			testId,
+			snapshot: received,
+			assertionName,
+			error: error || new Error("STACK_TRACE_ERROR")
+		}) : undefined;
+		const actualResolved = matchResult?.resolved ?? received;
+		const expectedResolved = matchResult?.expected ?? expectedSnapshot.data;
+		return this._reconcile({
+			testId,
+			key: expectedSnapshot.key,
+			count: expectedSnapshot.count,
+			pass: matchResult?.pass ?? false,
+			hasSnapshot: !!expectedSnapshot.data,
+			snapshotIsPersisted: isInline ? true : this._fileExists,
+			addValue: actualResolved,
+			actualDisplay: removeExtraLineBreaks(actualResolved),
+			expectedDisplay: expectedResolved !== undefined ? removeExtraLineBreaks(expectedResolved) : undefined,
+			stack,
+			assertionName
+		});
 	}
 	async pack() {
 		const snapshot = {
@@ -946,6 +1011,93 @@ class SnapshotClient {
 			throw createMismatchError(result.message(), snapshotState.expand, result.actual, result.expected);
 		}
 	}
+	matchDomain(options) {
+		const { received, filepath, name, testId = name, message, adapter, isInline = false, inlineSnapshot, error } = options;
+		if (!filepath) {
+			throw new Error("Snapshot cannot be used outside of test");
+		}
+		const captured = adapter.capture(received);
+		const rendered = adapter.render(captured);
+		const snapshotState = this.getSnapshotState(filepath);
+		const testName = [name, ...message ? [message] : []].join(" > ");
+		const expectedSnapshot = snapshotState.probeExpectedSnapshot({
+			testName,
+			testId,
+			isInline,
+			inlineSnapshot
+		});
+		expectedSnapshot.markAsChecked();
+		const matchResult = expectedSnapshot.data ? adapter.match(captured, adapter.parseExpected(expectedSnapshot.data)) : undefined;
+		const { actual, expected, key, pass } = snapshotState.processDomainSnapshot({
+			testId,
+			received: rendered,
+			expectedSnapshot,
+			matchResult,
+			isInline,
+			error,
+			assertionName: options.assertionName
+		});
+		return {
+			pass,
+			message: () => `Snapshot \`${key}\` mismatched`,
+			actual: actual?.trim(),
+			expected: expected?.trim()
+		};
+	}
+	async pollMatchDomain(options) {
+		const { poll, filepath, name, testId = name, message, adapter, isInline = false, inlineSnapshot, error, timeout = 1e3, interval = 50 } = options;
+		if (!filepath) {
+			throw new Error("Snapshot cannot be used outside of test");
+		}
+		const snapshotState = this.getSnapshotState(filepath);
+		const testName = [name, ...message ? [message] : []].join(" > ");
+		const expectedSnapshot = snapshotState.probeExpectedSnapshot({
+			testName,
+			testId,
+			isInline,
+			inlineSnapshot
+		});
+		const reference = expectedSnapshot.data && snapshotState.snapshotUpdateState !== "all" ? adapter.parseExpected(expectedSnapshot.data) : undefined;
+		const timedOut = timeout > 0 ? new Promise((r) => setTimeout(r, timeout)) : undefined;
+		const stableResult = await getStableSnapshot({
+			adapter,
+			poll,
+			interval,
+			timedOut,
+			match: reference ? (captured) => adapter.match(captured, reference).pass : undefined
+		});
+		expectedSnapshot.markAsChecked();
+		if (!stableResult?.rendered) {
+			// the original caller `expect.poll` later manipulates error via `throwWithCause`,
+			// so here we can directly throw `lastPollError` if exists.
+			if (stableResult?.lastPollError) {
+				throw stableResult.lastPollError;
+			}
+			return {
+				pass: false,
+				message: () => `poll() did not produce a stable snapshot within the timeout`
+			};
+		}
+		// TODO: should `all` mode ignore parse error?
+		// Sielently hiding the error and creating snaphsot full scratch isn't good either.
+		// Users can fix or purge the broken snapshot manually and that decision affects how domain snapshot gets updated.
+		const matchResult = expectedSnapshot.data ? adapter.match(stableResult.captured, adapter.parseExpected(expectedSnapshot.data)) : undefined;
+		const { actual, expected, key, pass } = snapshotState.processDomainSnapshot({
+			testId,
+			received: stableResult.rendered,
+			expectedSnapshot,
+			matchResult,
+			isInline,
+			error,
+			assertionName: options.assertionName
+		});
+		return {
+			pass,
+			message: () => `Snapshot \`${key}\` mismatched`,
+			actual: actual?.trim(),
+			expected: expected?.trim()
+		};
+	}
 	async assertRaw(options) {
 		if (!options.rawSnapshot) {
 			throw new Error("Raw snapshot is required");
@@ -968,5 +1120,69 @@ class SnapshotClient {
 		this.snapshotStateMap.clear();
 	}
 }
+/**
+* Polls repeatedly until the value reaches a stable state.
+*
+* Compares consecutive rendered outputs from the current session —
+* when two consecutive polls produce the same rendered string,
+* the value is considered stable.
+*
+* Every `await` (poll call, interval delay) races against `timedOut`
+* so that hanging polls and delays are interrupted.
+*/
+async function getStableSnapshot({ adapter, poll, interval, timedOut, match }) {
+	let lastRendered;
+	let lastPollError;
+	let lastStable;
+	while (true) {
+		try {
+			const pollResult = await raceWith(Promise.resolve(poll()), timedOut);
+			if (!pollResult.ok) {
+				break;
+			}
+			const captured = adapter.capture(pollResult.value);
+			const rendered = adapter.render(captured);
+			if (lastRendered !== undefined && rendered === lastRendered) {
+				lastStable = {
+					captured,
+					rendered
+				};
+				if (!match || match(captured)) {
+					break;
+				}
+			} else {
+				lastRendered = rendered;
+				lastStable = undefined;
+			}
+		} catch (pollError) {
+			// poll() threw — reset stability baseline and retry
+			lastRendered = undefined;
+			lastStable = undefined;
+			lastPollError = pollError;
+		}
+		const delayed = await raceWith(new Promise((r) => setTimeout(r, interval)), timedOut);
+		if (!delayed.ok) {
+			break;
+		}
+	}
+	return {
+		...lastStable,
+		lastPollError
+	};
+}
+/** Type-safe `Promise.race` — tells you which promise won. */
+function raceWith(promise, other) {
+	const left = promise.then((value) => ({
+		ok: true,
+		value
+	}));
+	if (!other) {
+		return left;
+	}
+	return Promise.race([left, other.then((value) => ({
+		ok: false,
+		value
+	}))]);
+}
 
 export { SnapshotClient, SnapshotState, addSerializer, getSerializers, stripSnapshotIndentation };

package/dist/manager.d.ts

@@ -1,7 +1,7 @@
-import { S as SnapshotStateOptions, e as SnapshotSummary, b as SnapshotResult } from './rawSnapshot.d-CmdgHNLi.js';
+import { a as SnapshotStateOptions, g as SnapshotSummary, b as SnapshotResult } from './rawSnapshot.d-D_X3-62x.js';
 import '@vitest/pretty-format';
-import './environment.d-DOJxxZV9.js';
 import '@vitest/utils';
+import './environment.d-DOJxxZV9.js';
 
 declare class SnapshotManager {
 	options: Omit<SnapshotStateOptions, "snapshotEnvironment">;

package/dist/rawSnapshot.d-D_X3-62x.d.ts

@@ -0,0 +1,205 @@
+import { OptionsReceived, Plugin } from '@vitest/pretty-format';
+import { ParsedStack } from '@vitest/utils';
+import { S as SnapshotEnvironment } from './environment.d-DOJxxZV9.js';
+
+interface DomainMatchResult {
+	pass: boolean;
+	message?: string;
+	/**
+	* The captured value viewed through the template's lens.
+	*
+	* Where the template uses patterns (e.g. regexes) or omits details,
+	* the resolved string adopts those patterns. Where the template doesn't
+	* match, the resolved string uses literal captured values instead.
+	*
+	* Used for two purposes:
+	* - **Diff display** (actual side): compared against `expected`
+	*   so the diff highlights only genuine mismatches, not pattern-vs-literal noise.
+	* - **Snapshot update** (`--update`): written as the new snapshot content,
+	*   preserving user-edited patterns from matched regions while incorporating
+	*   actual values for mismatched regions.
+	*
+	* When omitted, falls back to `render(capture(received))` (the raw rendered value).
+	*/
+	resolved?: string;
+	/**
+	* The stored template re-rendered as a string, representing what the user
+	* originally wrote or last saved.
+	*
+	* Used as the expected side in diff display.
+	*
+	* When omitted, falls back to the raw snapshot string from the snap file
+	* or inline snapshot.
+	*/
+	expected?: string;
+}
+interface DomainSnapshotAdapter<
+	Captured = unknown,
+	Expected = unknown
+> {
+	name: string;
+	capture: (received: unknown) => Captured;
+	render: (captured: Captured) => string;
+	parseExpected: (input: string) => Expected;
+	match: (captured: Captured, expected: Expected) => DomainMatchResult;
+}
+
+/**
+* Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+
+declare class DefaultMap<
+	K,
+	V
+> extends Map<K, V> {
+	private defaultFn;
+	constructor(defaultFn: (key: K) => V, entries?: Iterable<readonly [K, V]>);
+	get(key: K): V;
+}
+declare class CounterMap<K> extends DefaultMap<K, number> {
+	constructor();
+	_total: number | undefined;
+	valueOf(): number;
+	increment(key: K): void;
+	total(): number;
+}
+
+interface SnapshotReturnOptions {
+	actual: string;
+	count: number;
+	expected?: string;
+	key: string;
+	pass: boolean;
+}
+interface SaveStatus {
+	deleted: boolean;
+	saved: boolean;
+}
+interface ExpectedSnapshot {
+	key: string;
+	count: number;
+	data?: string;
+	markAsChecked: () => void;
+}
+declare class SnapshotState {
+	testFilePath: string;
+	snapshotPath: string;
+	private _counters;
+	private _dirty;
+	private _updateSnapshot;
+	private _snapshotData;
+	private _initialData;
+	private _inlineSnapshots;
+	private _inlineSnapshotStacks;
+	private _testIdToKeys;
+	private _rawSnapshots;
+	private _uncheckedKeys;
+	private _snapshotFormat;
+	private _environment;
+	private _fileExists;
+	expand: boolean;
+	private _added;
+	private _matched;
+	private _unmatched;
+	private _updated;
+	get added(): CounterMap<string>;
+	set added(value: number);
+	get matched(): CounterMap<string>;
+	set matched(value: number);
+	get unmatched(): CounterMap<string>;
+	set unmatched(value: number);
+	get updated(): CounterMap<string>;
+	set updated(value: number);
+	private constructor();
+	static create(testFilePath: string, options: SnapshotStateOptions): Promise<SnapshotState>;
+	get snapshotUpdateState(): SnapshotUpdateState;
+	get environment(): SnapshotEnvironment;
+	markSnapshotsAsCheckedForTest(testName: string): void;
+	clearTest(testId: string): void;
+	protected _inferInlineSnapshotStack(stacks: ParsedStack[]): ParsedStack | null;
+	private _addSnapshot;
+	private _resolveKey;
+	private _resolveInlineStack;
+	private _reconcile;
+	save(): Promise<SaveStatus>;
+	getUncheckedCount(): number;
+	getUncheckedKeys(): Array<string>;
+	removeUncheckedKeys(): void;
+	probeExpectedSnapshot(options: Pick<SnapshotMatchOptions, "testName" | "testId" | "isInline" | "inlineSnapshot">): ExpectedSnapshot;
+	match({ testId, testName, received, key, inlineSnapshot, isInline, error, rawSnapshot, assertionName }: SnapshotMatchOptions): SnapshotReturnOptions;
+	processDomainSnapshot({ testId, received, expectedSnapshot, matchResult, isInline, error, assertionName }: ProcessDomainSnapshotOptions): SnapshotReturnOptions;
+	pack(): Promise<SnapshotResult>;
+}
+
+type SnapshotData = Record<string, string>;
+type SnapshotUpdateState = "all" | "new" | "none";
+type SnapshotSerializer = Plugin;
+interface SnapshotStateOptions {
+	updateSnapshot: SnapshotUpdateState;
+	snapshotEnvironment: SnapshotEnvironment;
+	expand?: boolean;
+	snapshotFormat?: OptionsReceived;
+	resolveSnapshotPath?: (path: string, extension: string, context?: any) => string;
+}
+interface SnapshotMatchOptions {
+	testId: string;
+	testName: string;
+	received: unknown;
+	key?: string;
+	inlineSnapshot?: string;
+	isInline: boolean;
+	error?: Error;
+	rawSnapshot?: RawSnapshotInfo;
+	assertionName?: string;
+}
+interface ProcessDomainSnapshotOptions {
+	testId: string;
+	received: string;
+	expectedSnapshot: ExpectedSnapshot;
+	matchResult?: DomainMatchResult;
+	isInline?: boolean;
+	assertionName?: string;
+	error?: Error;
+}
+interface SnapshotResult {
+	filepath: string;
+	added: number;
+	fileDeleted: boolean;
+	matched: number;
+	unchecked: number;
+	uncheckedKeys: Array<string>;
+	unmatched: number;
+	updated: number;
+}
+interface UncheckedSnapshot {
+	filePath: string;
+	keys: Array<string>;
+}
+interface SnapshotSummary {
+	added: number;
+	didUpdate: boolean;
+	failure: boolean;
+	filesAdded: number;
+	filesRemoved: number;
+	filesRemovedList: Array<string>;
+	filesUnmatched: number;
+	filesUpdated: number;
+	matched: number;
+	total: number;
+	unchecked: number;
+	uncheckedKeysByFile: Array<UncheckedSnapshot>;
+	unmatched: number;
+	updated: number;
+}
+
+interface RawSnapshotInfo {
+	file: string;
+	readonly?: boolean;
+	content?: string;
+}
+
+export { SnapshotState as S };
+export type { DomainSnapshotAdapter as D, RawSnapshotInfo as R, UncheckedSnapshot as U, SnapshotStateOptions as a, SnapshotResult as b, DomainMatchResult as c, SnapshotData as d, SnapshotMatchOptions as e, SnapshotSerializer as f, SnapshotSummary as g, SnapshotUpdateState as h };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vitest/snapshot",
   "type": "module",
-  "version": "4.1.3",
+  "version": "4.1.5",
   "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/utils": "4.1.3",
-    "@vitest/pretty-format": "4.1.3"
+    "@vitest/pretty-format": "4.1.5",
+    "@vitest/utils": "4.1.5"
   },
   "devDependencies": {
     "@types/natural-compare": "^1.4.3",

package/dist/rawSnapshot.d-CmdgHNLi.d.ts

@@ -1,62 +0,0 @@
-import { OptionsReceived, Plugin } from '@vitest/pretty-format';
-import { S as SnapshotEnvironment } from './environment.d-DOJxxZV9.js';
-
-type SnapshotData = Record<string, string>;
-type SnapshotUpdateState = "all" | "new" | "none";
-type SnapshotSerializer = Plugin;
-interface SnapshotStateOptions {
-	updateSnapshot: SnapshotUpdateState;
-	snapshotEnvironment: SnapshotEnvironment;
-	expand?: boolean;
-	snapshotFormat?: OptionsReceived;
-	resolveSnapshotPath?: (path: string, extension: string, context?: any) => string;
-}
-interface SnapshotMatchOptions {
-	testId: string;
-	testName: string;
-	received: unknown;
-	key?: string;
-	inlineSnapshot?: string;
-	isInline: boolean;
-	error?: Error;
-	rawSnapshot?: RawSnapshotInfo;
-	assertionName?: string;
-}
-interface SnapshotResult {
-	filepath: string;
-	added: number;
-	fileDeleted: boolean;
-	matched: number;
-	unchecked: number;
-	uncheckedKeys: Array<string>;
-	unmatched: number;
-	updated: number;
-}
-interface UncheckedSnapshot {
-	filePath: string;
-	keys: Array<string>;
-}
-interface SnapshotSummary {
-	added: number;
-	didUpdate: boolean;
-	failure: boolean;
-	filesAdded: number;
-	filesRemoved: number;
-	filesRemovedList: Array<string>;
-	filesUnmatched: number;
-	filesUpdated: number;
-	matched: number;
-	total: number;
-	unchecked: number;
-	uncheckedKeysByFile: Array<UncheckedSnapshot>;
-	unmatched: number;
-	updated: number;
-}
-
-interface RawSnapshotInfo {
-	file: string;
-	readonly?: boolean;
-	content?: string;
-}
-
-export type { RawSnapshotInfo as R, SnapshotStateOptions as S, UncheckedSnapshot as U, SnapshotMatchOptions as a, SnapshotResult as b, SnapshotData as c, SnapshotSerializer as d, SnapshotSummary as e, SnapshotUpdateState as f };