@vitest/expect 4.1.0-beta.3 → 4.1.0-beta.5

package/dist/index.d.ts

@@ -1,6 +1,5 @@
 import { Test } from '@vitest/runner';
 import { MockInstance } from '@vitest/spy';
-import { Constructable } from '@vitest/utils';
 import { Formatter } from 'tinyrainbow';
 import { StandardSchemaV1 } from '@standard-schema/spec';
 import { diff, printDiffOrStringify } from '@vitest/utils/diff';
@@ -459,6 +458,7 @@ interface JestAssertion<T = any> extends jest.Matchers<void, T>, CustomMatcher {
 	*
 	* @example
 	* expect(mockFunc).toBeCalledTimes(2);
+	* @deprecated Use `toHaveBeenCalledTimes` instead
 	*/
 	toBeCalledTimes: (times: number) => void;
 	/**
@@ -477,6 +477,7 @@ interface JestAssertion<T = any> extends jest.Matchers<void, T>, CustomMatcher {
 	*
 	* @example
 	* expect(mockFunc).toBeCalled();
+	* @deprecated Use `toHaveBeenCalled` instead
 	*/
 	toBeCalled: () => void;
 	/**
@@ -495,6 +496,7 @@ interface JestAssertion<T = any> extends jest.Matchers<void, T>, CustomMatcher {
 	*
 	* @example
 	* expect(mockFunc).toBeCalledWith('arg1', 42);
+	* @deprecated Use `toHaveBeenCalledWith` instead
 	*/
 	toBeCalledWith: <E extends any[]>(...args: E) => void;
 	/**
@@ -507,15 +509,6 @@ interface JestAssertion<T = any> extends jest.Matchers<void, T>, CustomMatcher {
 	*/
 	toHaveBeenNthCalledWith: <E extends any[]>(n: number, ...args: E) => void;
 	/**
-	* Ensure that a mock function is called with specific arguments on an Nth call.
-	*
-	* Alias for `expect.toHaveBeenNthCalledWith`.
-	*
-	* @example
-	* expect(mockFunc).nthCalledWith(2, 'secondArg');
-	*/
-	nthCalledWith: <E extends any[]>(nthCall: number, ...args: E) => void;
-	/**
 	* If you have a mock function, you can use `.toHaveBeenLastCalledWith`
 	* to test what arguments it was last called with.
 	*
@@ -526,16 +519,6 @@ interface JestAssertion<T = any> extends jest.Matchers<void, T>, CustomMatcher {
 	*/
 	toHaveBeenLastCalledWith: <E extends any[]>(...args: E) => void;
 	/**
-	* If you have a mock function, you can use `.lastCalledWith`
-	* to test what arguments it was last called with.
-	*
-	* Alias for `expect.toHaveBeenLastCalledWith`.
-	*
-	* @example
-	* expect(mockFunc).lastCalledWith('lastArg');
-	*/
-	lastCalledWith: <E extends any[]>(...args: E) => void;
-	/**
 	* Used to test that a function throws when it is called.
 	*
 	* Also under the alias `expect.toThrowError`.
@@ -543,8 +526,9 @@ interface JestAssertion<T = any> extends jest.Matchers<void, T>, CustomMatcher {
 	* @example
 	* expect(() => functionWithError()).toThrow('Error message');
 	* expect(() => parseJSON('invalid')).toThrow(SyntaxError);
+	* expect(() => { throw 42 }).toThrow(42);
 	*/
-	toThrow: (expected?: string | Constructable | RegExp | Error) => void;
+	toThrow: (expected?: any) => void;
 	/**
 	* Used to test that a function throws when it is called.
 	*
@@ -553,8 +537,10 @@ interface JestAssertion<T = any> extends jest.Matchers<void, T>, CustomMatcher {
 	* @example
 	* expect(() => functionWithError()).toThrowError('Error message');
 	* expect(() => parseJSON('invalid')).toThrowError(SyntaxError);
+	* expect(() => { throw 42 }).toThrowError(42);
+	* @deprecated Use `toThrow` instead
 	*/
-	toThrowError: (expected?: string | Constructable | RegExp | Error) => void;
+	toThrowError: (expected?: any) => void;
 	/**
 	* Use to test that the mock function successfully returned (i.e., did not throw an error) at least one time
 	*
@@ -562,6 +548,7 @@ interface JestAssertion<T = any> extends jest.Matchers<void, T>, CustomMatcher {
 	*
 	* @example
 	* expect(mockFunc).toReturn();
+	* @deprecated Use `toHaveReturned` instead
 	*/
 	toReturn: () => void;
 	/**
@@ -581,6 +568,7 @@ interface JestAssertion<T = any> extends jest.Matchers<void, T>, CustomMatcher {
 	*
 	* @example
 	* expect(mockFunc).toReturnTimes(3);
+	* @deprecated Use `toHaveReturnedTimes` instead
 	*/
 	toReturnTimes: (times: number) => void;
 	/**
@@ -600,6 +588,7 @@ interface JestAssertion<T = any> extends jest.Matchers<void, T>, CustomMatcher {
 	*
 	* @example
 	* expect(mockFunc).toReturnWith('returnValue');
+	* @deprecated Use `toHaveReturnedWith` instead
 	*/
 	toReturnWith: <E>(value: E) => void;
 	/**
@@ -623,17 +612,6 @@ interface JestAssertion<T = any> extends jest.Matchers<void, T>, CustomMatcher {
 	*/
 	toHaveLastReturnedWith: <E>(value: E) => void;
 	/**
-	* Use to test the specific value that a mock function last returned.
-	* If the last call to the mock function threw an error, then this matcher will fail
-	* no matter what value you provided as the expected return value.
-	*
-	* Alias for `expect.toHaveLastReturnedWith`.
-	*
-	* @example
-	* expect(mockFunc).lastReturnedWith('lastValue');
-	*/
-	lastReturnedWith: <E>(value: E) => void;
-	/**
 	* Use to test the specific value that a mock function returned for the nth call.
 	* If the nth call to the mock function threw an error, then this matcher will fail
 	* no matter what value you provided as the expected return value.
@@ -644,17 +622,6 @@ interface JestAssertion<T = any> extends jest.Matchers<void, T>, CustomMatcher {
 	* expect(mockFunc).toHaveNthReturnedWith(2, 'nthValue');
 	*/
 	toHaveNthReturnedWith: <E>(nthCall: number, value: E) => void;
-	/**
-	* Use to test the specific value that a mock function returned for the nth call.
-	* If the nth call to the mock function threw an error, then this matcher will fail
-	* no matter what value you provided as the expected return value.
-	*
-	* Alias for `expect.toHaveNthReturnedWith`.
-	*
-	* @example
-	* expect(mockFunc).nthReturnedWith(2, 'nthValue');
-	*/
-	nthReturnedWith: <E>(nthCall: number, value: E) => void;
 }
 type VitestAssertion<
 	A,
@@ -925,6 +892,7 @@ declare const JestExtend: ChaiPlugin;
 declare function equals(a: unknown, b: unknown, customTesters?: Array<Tester>, strictCheck?: boolean): boolean;
 declare function isAsymmetric(obj: any): obj is AsymmetricMatcher<any>;
 declare function hasAsymmetric(obj: any, seen?: Set<any>): boolean;
+declare function isError(value: unknown): value is Error;
 declare function isA(typeName: string, value: unknown): boolean;
 declare function fnNameFor(func: Function): string;
 declare function hasProperty(obj: object | null, property: string): boolean;
@@ -950,5 +918,9 @@ declare function isStandardSchema(obj: any): obj is StandardSchemaV1;
 declare function getState<State extends MatcherState = MatcherState>(expect: ExpectStatic): State;
 declare function setState<State extends MatcherState = MatcherState>(state: Partial<State>, expect: ExpectStatic): void;
 
-export { ASYMMETRIC_MATCHERS_OBJECT, Any, Anything, ArrayContaining, AsymmetricMatcher, ChaiStyleAssertions, GLOBAL_EXPECT, JEST_MATCHERS_OBJECT, JestAsymmetricMatchers, JestChaiExpect, JestExtend, MATCHERS_OBJECT, ObjectContaining, SchemaMatching, StringContaining, StringMatching, addCustomEqualityTesters, arrayBufferEquality, customMatchers, equals, fnNameFor, generateToBeMessage, getObjectKeys, getObjectSubset, getState, hasAsymmetric, hasProperty, isA, isAsymmetric, isImmutableUnorderedKeyed, isImmutableUnorderedSet, isStandardSchema, iterableEquality, pluralize, setState, sparseArrayEquality, subsetEquality, typeEquality };
+declare function createAssertionMessage(util: Chai.ChaiUtils, assertion: Assertion, hasArgs: boolean): string;
+declare function recordAsyncExpect(_test: any, promise: Promise<any>, assertion: string, error: Error, isSoft?: boolean): Promise<any>;
+declare function wrapAssertion(utils: Chai.ChaiUtils, name: string, fn: (this: Chai.AssertionStatic & Assertion, ...args: any[]) => void | PromiseLike<void>): (this: Chai.AssertionStatic & Assertion, ...args: any[]) => void | PromiseLike<void>;
+
+export { ASYMMETRIC_MATCHERS_OBJECT, Any, Anything, ArrayContaining, AsymmetricMatcher, ChaiStyleAssertions, GLOBAL_EXPECT, JEST_MATCHERS_OBJECT, JestAsymmetricMatchers, JestChaiExpect, JestExtend, MATCHERS_OBJECT, ObjectContaining, SchemaMatching, StringContaining, StringMatching, addCustomEqualityTesters, arrayBufferEquality, createAssertionMessage, customMatchers, equals, fnNameFor, generateToBeMessage, getObjectKeys, getObjectSubset, getState, hasAsymmetric, hasProperty, isA, isAsymmetric, isError, isImmutableUnorderedKeyed, isImmutableUnorderedSet, isStandardSchema, iterableEquality, pluralize, recordAsyncExpect, setState, sparseArrayEquality, subsetEquality, typeEquality, wrapAssertion };
 export type { Assertion, AsymmetricMatcherInterface, AsymmetricMatchersContaining, AsyncExpectationResult, ChaiMockAssertion, ChaiPlugin, DeeplyAllowMatchers, ExpectStatic, ExpectationResult, JestAssertion, MatcherHintOptions, MatcherState, Matchers, MatchersObject, PromisifyAssertion, RawMatcherFn, SyncExpectationResult, Tester, TesterContext };

package/dist/index.js

@@ -244,6 +244,18 @@ function asymmetricMatch(a, b, customTesters) {
 		return b.asymmetricMatch(a, customTesters);
 	}
 }
+// https://github.com/jestjs/jest/blob/905bcbced3d40cdf7aadc4cdf6fb731c4bb3dbe3/packages/expect-utils/src/utils.ts#L509
+function isError(value) {
+	if (typeof Error.isError === "function") {
+		return Error.isError(value);
+	}
+	switch (Object.prototype.toString.call(value)) {
+		case "[object Error]":
+		case "[object Exception]":
+		case "[object DOMException]": return true;
+		default: return value instanceof Error;
+	}
+}
 // Equality function lovingly adapted from isEqual in
 //   [Underscore](http://underscorejs.org)
 function eq(a, b, aStack, bStack, customTesters, hasKey) {
@@ -332,7 +344,7 @@ function eq(a, b, aStack, bStack, customTesters, hasKey) {
 	if (className === "[object Array]" && a.length !== b.length) {
 		return false;
 	}
-	if (a instanceof Error && b instanceof Error) {
+	if (isError(a) && isError(b)) {
 		try {
 			return isErrorEqual(a, b, aStack, bStack, customTesters, hasKey);
 		} finally {
@@ -366,17 +378,17 @@ function isErrorEqual(a, b, aStack, bStack, customTesters, hasKey) {
 	// - [[Prototype]] of objects are compared using the === operator.
 	// - Only enumerable "own" properties are considered.
 	// - Error names, messages, causes, and errors are always compared, even if these are not enumerable properties. errors is also compared.
-	let result = Object.getPrototypeOf(a) === Object.getPrototypeOf(b) && a.name === b.name && a.message === b.message;
+	let result = Object.prototype.toString.call(a) === Object.prototype.toString.call(b) && a.name === b.name && a.message === b.message;
 	// check Error.cause asymmetrically
 	if (typeof b.cause !== "undefined") {
-		result && (result = eq(a.cause, b.cause, aStack, bStack, customTesters, hasKey));
+		result &&= eq(a.cause, b.cause, aStack, bStack, customTesters, hasKey);
 	}
 	// AggregateError.errors
 	if (a instanceof AggregateError && b instanceof AggregateError) {
-		result && (result = eq(a.errors, b.errors, aStack, bStack, customTesters, hasKey));
+		result &&= eq(a.errors, b.errors, aStack, bStack, customTesters, hasKey);
 	}
 	// spread to compare enumerable properties
-	result && (result = eq({ ...a }, { ...b }, aStack, bStack, customTesters, hasKey));
+	result &&= eq({ ...a }, { ...b }, aStack, bStack, customTesters, hasKey);
 	return result;
 }
 function keys(obj, hasKey) {
@@ -570,7 +582,7 @@ function hasPropertyInObject(object, key) {
 	return Object.hasOwn(object, key) || hasPropertyInObject(Object.getPrototypeOf(object), key);
 }
 function isObjectWithKeys(a) {
-	return isObject(a) && !(a instanceof Error) && !Array.isArray(a) && !(a instanceof Date) && !(a instanceof Set) && !(a instanceof Map);
+	return isObject(a) && !isError(a) && !Array.isArray(a) && !(a instanceof Date) && !(a instanceof Set) && !(a instanceof Map);
 }
 function subsetEquality(object, subset, customTesters = []) {
 	const filteredCustomTesters = customTesters.filter((t) => t !== subsetEquality);
@@ -653,10 +665,7 @@ function pluralize(word, count) {
 	return `${count} ${word}${count === 1 ? "" : "s"}`;
 }
 function getObjectKeys(object) {
-	return [...Object.keys(object), ...Object.getOwnPropertySymbols(object).filter((s) => {
-		var _Object$getOwnPropert;
-		return (_Object$getOwnPropert = Object.getOwnPropertyDescriptor(object, s)) === null || _Object$getOwnPropert === void 0 ? void 0 : _Object$getOwnPropert.enumerable;
-	})];
+	return [...Object.keys(object), ...Object.getOwnPropertySymbols(object).filter((s) => Object.getOwnPropertyDescriptor(object, s)?.enumerable)];
 }
 function getObjectSubset(object, subset, customTesters) {
 	let stripped = 0;
@@ -834,10 +843,7 @@ class ObjectContaining extends AsymmetricMatcher {
 		return this.hasProperty(this.getPrototype(obj), property);
 	}
 	getProperties(obj) {
-		return [...Object.keys(obj), ...Object.getOwnPropertySymbols(obj).filter((s) => {
-			var _Object$getOwnPropert;
-			return (_Object$getOwnPropert = Object.getOwnPropertyDescriptor(obj, s)) === null || _Object$getOwnPropert === void 0 ? void 0 : _Object$getOwnPropert.enumerable;
-		})];
+		return [...Object.keys(obj), ...Object.getOwnPropertySymbols(obj).filter((s) => Object.getOwnPropertyDescriptor(obj, s)?.enumerable)];
 	}
 	asymmetricMatch(other, customTesters) {
 		if (typeof this.sample !== "object") {
@@ -1032,9 +1038,8 @@ class SchemaMatching extends AsymmetricMatcher {
 		return "object";
 	}
 	toAsymmetricMatcher() {
-		var _this$result;
 		const { utils } = this.getMatcherContext();
-		const issues = ((_this$result = this.result) === null || _this$result === void 0 ? void 0 : _this$result.issues) || [];
+		const issues = this.result?.issues || [];
 		if (issues.length > 0) {
 			return `${this.toString()} ${utils.stringify(this.result, undefined, { printBasicPrototype: false })}`;
 		}
@@ -1062,13 +1067,14 @@ const JestAsymmetricMatchers = (chai, utils) => {
 };
 
 function createAssertionMessage(util, assertion, hasArgs) {
+	const soft = util.flag(assertion, "soft") ? ".soft" : "";
 	const not = util.flag(assertion, "negate") ? "not." : "";
 	const name = `${util.flag(assertion, "_name")}(${hasArgs ? "expected" : ""})`;
 	const promiseName = util.flag(assertion, "promise");
 	const promise = promiseName ? `.${promiseName}` : "";
-	return `expect(actual)${promise}.${not}${name}`;
+	return `expect${soft}(actual)${promise}.${not}${name}`;
 }
-function recordAsyncExpect(_test, promise, assertion, error) {
+function recordAsyncExpect(_test, promise, assertion, error, isSoft) {
 	const test = _test;
 	// record promise for test, that resolves before test ends
 	if (test && promise instanceof Promise) {
@@ -1086,17 +1092,23 @@ function recordAsyncExpect(_test, promise, assertion, error) {
 		if (!test.promises) {
 			test.promises = [];
 		}
+		// setup `expect.soft` handler here instead of `wrapAssertion`
+		// to avoid double error tracking while keeping non-await promise detection.
+		if (isSoft) {
+			promise = promise.then(noop, (err) => {
+				handleTestError(test, err);
+			});
+		}
 		test.promises.push(promise);
 		let resolved = false;
-		test.onFinished ?? (test.onFinished = []);
+		test.onFinished ??= [];
 		test.onFinished.push(() => {
 			if (!resolved) {
-				var _vitest_worker__;
-				const processor = ((_vitest_worker__ = globalThis.__vitest_worker__) === null || _vitest_worker__ === void 0 ? void 0 : _vitest_worker__.onFilterStackTrace) || ((s) => s || "");
+				const processor = globalThis.__vitest_worker__?.onFilterStackTrace || ((s) => s || "");
 				const stack = processor(error.stack);
 				console.warn([
 					`Promise returned by \`${assertion}\` was not awaited. `,
-					"Vitest currently auto-awaits hanging assertions at the end of the test, but this will cause the test to fail in Vitest 3. ",
+					"Vitest currently auto-awaits hanging assertions at the end of the test, but this will cause the test to fail in the next Vitest major. ",
 					"Please remember to await the assertion.\n",
 					stack
 				].join(""));
@@ -1119,10 +1131,9 @@ function recordAsyncExpect(_test, promise, assertion, error) {
 	return promise;
 }
 function handleTestError(test, err) {
-	var _test$result;
-	test.result || (test.result = { state: "fail" });
+	test.result ||= { state: "fail" };
 	test.result.state = "fail";
-	(_test$result = test.result).errors || (_test$result.errors = []);
+	test.result.errors ||= [];
 	test.result.errors.push(processError(err));
 }
 function wrapAssertion(utils, name, fn) {
@@ -1132,7 +1143,11 @@ function wrapAssertion(utils, name, fn) {
 			utils.flag(this, "_name", name);
 		}
 		if (!utils.flag(this, "soft")) {
-			return fn.apply(this, args);
+			// avoid WebKit's proper tail call to preserve stacktrace offset for inline snapshot
+			// https://webkit.org/blog/6240/ecmascript-6-proper-tail-calls-in-webkit
+			try {
+				return fn.apply(this, args);
+			} finally {}
 		}
 		const test = utils.flag(this, "vitest-test");
 		if (!test) {
@@ -1482,7 +1497,7 @@ const JestChaiExpect = (chai, utils) => {
 			throw new AssertionError(formatCalls(spy, msg, args));
 		}
 	});
-	def(["toHaveBeenNthCalledWith", "nthCalledWith"], function(times, ...args) {
+	def("toHaveBeenNthCalledWith", function(times, ...args) {
 		const spy = getSpy(this);
 		const spyName = spy.getMockName();
 		const nthCall = spy.mock.calls[times - 1];
@@ -1490,7 +1505,7 @@ const JestChaiExpect = (chai, utils) => {
 		const isCalled = times <= callCount;
 		this.assert(nthCall && equalsArgumentArray(nthCall, args), `expected ${ordinalOf(times)} "${spyName}" call to have been called with #{exp}${isCalled ? `` : `, but called only ${callCount} times`}`, `expected ${ordinalOf(times)} "${spyName}" call to not have been called with #{exp}`, args, nthCall, isCalled);
 	});
-	def(["toHaveBeenLastCalledWith", "lastCalledWith"], function(...args) {
+	def("toHaveBeenLastCalledWith", function(...args) {
 		const spy = getSpy(this);
 		const spyName = spy.getMockName();
 		const lastCall = spy.mock.calls.at(-1);
@@ -1561,7 +1576,7 @@ const JestChaiExpect = (chai, utils) => {
 			const name = expected.name || expected.prototype.constructor.name;
 			return this.assert(thrown && thrown instanceof expected, `expected error to be instance of ${name}`, `expected error not to be instance of ${name}`, expected, thrown);
 		}
-		if (expected instanceof Error) {
+		if (isError(expected)) {
 			const equal = equals(thrown, expected, [...customTesters, iterableEquality]);
 			return this.assert(equal, "expected a thrown error to be #{exp}", "expected a thrown error not to be #{exp}", expected, thrown);
 		}
@@ -1569,7 +1584,8 @@ const JestChaiExpect = (chai, utils) => {
 			const matcher = expected;
 			return this.assert(thrown && matcher.asymmetricMatch(thrown), "expected error to match asymmetric matcher", "expected error not to match asymmetric matcher", matcher, thrown);
 		}
-		throw new Error(`"toThrow" expects string, RegExp, function, Error instance or asymmetric matcher, got "${typeof expected}"`);
+		const equal = equals(thrown, expected, [...customTesters, iterableEquality]);
+		return this.assert(equal, "expected a thrown value to equal #{exp}", "expected a thrown value not to equal #{exp}", expected, thrown);
 	});
 	[{
 		name: "toHaveResolved",
@@ -1637,7 +1653,7 @@ const JestChaiExpect = (chai, utils) => {
 		},
 		action: "resolve"
 	}, {
-		name: ["toHaveLastReturnedWith", "lastReturnedWith"],
+		name: "toHaveLastReturnedWith",
 		condition: (spy, value) => {
 			const result = spy.mock.results.at(-1);
 			return Boolean(result && result.type === "return" && equals(result.value, value));
@@ -1649,7 +1665,7 @@ const JestChaiExpect = (chai, utils) => {
 			const results = action === "return" ? spy.mock.results : spy.mock.settledResults;
 			const result = results.at(-1);
 			const spyName = spy.getMockName();
-			this.assert(condition(spy, value), `expected last "${spyName}" call to ${action} #{exp}`, `expected last "${spyName}" call to not ${action} #{exp}`, value, result === null || result === void 0 ? void 0 : result.value);
+			this.assert(condition(spy, value), `expected last "${spyName}" call to ${action} #{exp}`, `expected last "${spyName}" call to not ${action} #{exp}`, value, result?.value);
 		});
 	});
 	[{
@@ -1660,7 +1676,7 @@ const JestChaiExpect = (chai, utils) => {
 		},
 		action: "resolve"
 	}, {
-		name: ["toHaveNthReturnedWith", "nthReturnedWith"],
+		name: "toHaveNthReturnedWith",
 		condition: (spy, index, value) => {
 			const result = spy.mock.results[index - 1];
 			return result && result.type === "return" && equals(result.value, value);
@@ -1673,7 +1689,7 @@ const JestChaiExpect = (chai, utils) => {
 			const results = action === "return" ? spy.mock.results : spy.mock.settledResults;
 			const result = results[nthCall - 1];
 			const ordinalCall = `${ordinalOf(nthCall)} call`;
-			this.assert(condition(spy, nthCall, value), `expected ${ordinalCall} "${spyName}" call to ${action} #{exp}`, `expected ${ordinalCall} "${spyName}" call to not ${action} #{exp}`, value, result === null || result === void 0 ? void 0 : result.value);
+			this.assert(condition(spy, nthCall, value), `expected ${ordinalCall} "${spyName}" call to ${action} #{exp}`, `expected ${ordinalCall} "${spyName}" call to not ${action} #{exp}`, value, result?.value);
 		});
 	});
 	// @ts-expect-error @internal
@@ -1692,7 +1708,7 @@ const JestChaiExpect = (chai, utils) => {
 		if (utils.flag(this, "poll")) {
 			throw new SyntaxError(`expect.poll() is not supported in combination with .resolves`);
 		}
-		if (typeof (obj === null || obj === void 0 ? void 0 : obj.then) !== "function") {
+		if (typeof obj?.then !== "function") {
 			throw new TypeError(`You must provide a Promise to expect() when using .resolves, not '${typeof obj}'.`);
 		}
 		const proxy = new Proxy(this, { get: (target, key, receiver) => {
@@ -1702,14 +1718,18 @@ const JestChaiExpect = (chai, utils) => {
 			}
 			return (...args) => {
 				utils.flag(this, "_name", key);
-				const promise = obj.then((value) => {
+				const promise = Promise.resolve(obj).then((value) => {
 					utils.flag(this, "object", value);
 					return result.call(this, ...args);
 				}, (err) => {
 					const _error = new AssertionError(`promise rejected "${utils.inspect(err)}" instead of resolving`, { showDiff: false });
 					_error.cause = err;
-					_error.stack = error.stack.replace(error.message, _error.message);
 					throw _error;
+				}).catch((err) => {
+					if (isError(err) && error.stack) {
+						err.stack = error.stack.replace(error.message, err.message);
+					}
+					throw err;
 				});
 				return recordAsyncExpect(test, promise, createAssertionMessage(utils, this, !!args.length), error);
 			};
@@ -1726,7 +1746,7 @@ const JestChaiExpect = (chai, utils) => {
 		if (utils.flag(this, "poll")) {
 			throw new SyntaxError(`expect.poll() is not supported in combination with .rejects`);
 		}
-		if (typeof (wrapper === null || wrapper === void 0 ? void 0 : wrapper.then) !== "function") {
+		if (typeof wrapper?.then !== "function") {
 			throw new TypeError(`You must provide a Promise to expect() when using .rejects, not '${typeof wrapper}'.`);
 		}
 		const proxy = new Proxy(this, { get: (target, key, receiver) => {
@@ -1736,17 +1756,21 @@ const JestChaiExpect = (chai, utils) => {
 			}
 			return (...args) => {
 				utils.flag(this, "_name", key);
-				const promise = wrapper.then((value) => {
+				const promise = Promise.resolve(wrapper).then((value) => {
 					const _error = new AssertionError(`promise resolved "${utils.inspect(value)}" instead of rejecting`, {
 						showDiff: true,
 						expected: new Error("rejected promise"),
 						actual: value
 					});
-					_error.stack = error.stack.replace(error.message, _error.message);
 					throw _error;
 				}, (err) => {
 					utils.flag(this, "object", err);
 					return result.call(this, ...args);
+				}).catch((err) => {
+					if (isError(err) && error.stack) {
+						err.stack = error.stack.replace(error.message, err.message);
+					}
+					throw err;
 				});
 				return recordAsyncExpect(test, promise, createAssertionMessage(utils, this, !!args.length), error);
 			};
@@ -1770,7 +1794,7 @@ function ordinalOf(i) {
 }
 function formatCalls(spy, msg, showActualCall) {
 	if (spy.mock.calls.length) {
-		msg += c.gray(`\n\nReceived: \n\n${spy.mock.calls.map((callArg, i) => {
+		msg += c.gray(`\n\nReceived:\n\n${spy.mock.calls.map((callArg, i) => {
 			let methodCall = c.bold(`  ${ordinalOf(i + 1)} ${spy.getMockName()} call:\n\n`);
 			if (showActualCall) {
 				methodCall += diff(showActualCall, callArg, { omitAnnotationLines: true });
@@ -1786,7 +1810,7 @@ function formatCalls(spy, msg, showActualCall) {
 }
 function formatReturns(spy, results, msg, showActualReturn) {
 	if (results.length) {
-		msg += c.gray(`\n\nReceived: \n\n${results.map((callReturn, i) => {
+		msg += c.gray(`\n\nReceived:\n\n${results.map((callReturn, i) => {
 			let methodCall = c.bold(`  ${ordinalOf(i + 1)} ${spy.getMockName()} call return:\n\n`);
 			if (showActualReturn) {
 				methodCall += diff(showActualReturn, callReturn.value, { omitAnnotationLines: true });
@@ -1814,8 +1838,8 @@ function getMatcherState(assertion, expect) {
 		subsetEquality
 	};
 	let task = util.flag(assertion, "vitest-test");
-	const currentTestName = (task === null || task === void 0 ? void 0 : task.fullTestName) ?? "";
-	if ((task === null || task === void 0 ? void 0 : task.type) !== "test") {
+	const currentTestName = task?.fullTestName ?? "";
+	if (task?.type !== "test") {
 		task = undefined;
 	}
 	const matcherState = {
@@ -1917,4 +1941,4 @@ const JestExtend = (chai, utils) => {
 	});
 };
 
-export { ASYMMETRIC_MATCHERS_OBJECT, Any, Anything, ArrayContaining, AsymmetricMatcher, ChaiStyleAssertions, GLOBAL_EXPECT, JEST_MATCHERS_OBJECT, JestAsymmetricMatchers, JestChaiExpect, JestExtend, MATCHERS_OBJECT, ObjectContaining, SchemaMatching, StringContaining, StringMatching, addCustomEqualityTesters, arrayBufferEquality, customMatchers, equals, fnNameFor, generateToBeMessage, getObjectKeys, getObjectSubset, getState, hasAsymmetric, hasProperty, isA, isAsymmetric, isImmutableUnorderedKeyed, isImmutableUnorderedSet, isStandardSchema, iterableEquality, pluralize, setState, sparseArrayEquality, subsetEquality, typeEquality };
+export { ASYMMETRIC_MATCHERS_OBJECT, Any, Anything, ArrayContaining, AsymmetricMatcher, ChaiStyleAssertions, GLOBAL_EXPECT, JEST_MATCHERS_OBJECT, JestAsymmetricMatchers, JestChaiExpect, JestExtend, MATCHERS_OBJECT, ObjectContaining, SchemaMatching, StringContaining, StringMatching, addCustomEqualityTesters, arrayBufferEquality, createAssertionMessage, customMatchers, equals, fnNameFor, generateToBeMessage, getObjectKeys, getObjectSubset, getState, hasAsymmetric, hasProperty, isA, isAsymmetric, isError, isImmutableUnorderedKeyed, isImmutableUnorderedSet, isStandardSchema, iterableEquality, pluralize, recordAsyncExpect, setState, sparseArrayEquality, subsetEquality, typeEquality, wrapAssertion };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vitest/expect",
   "type": "module",
-  "version": "4.1.0-beta.3",
+  "version": "4.1.0-beta.5",
   "description": "Jest's expect matchers as a Chai plugin",
   "license": "MIT",
   "funding": "https://opencollective.com/vitest",
@@ -33,11 +33,11 @@
     "@types/chai": "^5.2.2",
     "chai": "^6.2.2",
     "tinyrainbow": "^3.0.3",
-    "@vitest/spy": "4.1.0-beta.3",
-    "@vitest/utils": "4.1.0-beta.3"
+    "@vitest/spy": "4.1.0-beta.5",
+    "@vitest/utils": "4.1.0-beta.5"
   },
   "devDependencies": {
-    "@vitest/runner": "4.1.0-beta.3"
+    "@vitest/runner": "4.1.0-beta.5"
   },
   "scripts": {
     "build": "premove dist && rollup -c",