refactor(nuxt): simplify request computation inside useFetch

[Mini-ghost]

🔗 Linked issue

N/A

❓ Type of change

• 📖 Documentation (updates to the documentation, readme or JSdoc annotations)
• 🐞 Bug fix (a non-breaking change that fixes an issue)
• 👌 Enhancement (improving an existing functionality like performance)
• ✨ New feature (a non-breaking change that adds functionality)
• 🧹 Chore (updates to the build process or auxiliary tools and libraries)
• ⚠️ Breaking change (fix or feature that would cause existing functionality to change)

📚 Description

Currently, the implementation of _request inside useFetch is as follows:

nuxt/packages/nuxt/src/app/composables/fetch.ts

Lines 97 to 103 in ac54da2

	const _request = computed(() => {
	let r = request
	if (typeof r === 'function') {
	r = r()
	}
	return toValue(r)
	})

This code is almost equivalent to toRef(request), should we just use toRef as a cleaner alternative?

I am open to feedback regarding whether this adjustment will yield significant benefits. Should the evaluation indicate that the drawbacks outweigh the benefits, please feel free to close this PR.

📝 Checklist

• I have linked an issue or discussion.
• I have added tests (if possible).
• I have updated the documentation accordingly.

[stackblitz]

Run & review this pull request in StackBlitz Codeflow.

[Mini-ghost]

I'd like to understand if using a getter function as the parameter for request, especially when the calculations are very complex, could actually worsen performance. This is because every time _request is accessed, the getter function would be executed again .

Of course, for users passing in a type of Ref<ReqT> | ReqT, this should not pose a problem.

[danielroe]

Does toRef re-execute the function every time .value is accessed?

[Mini-ghost]

I attempted to write and execute the following code:

const text = toRef(() => {
  console.log('accessed test');
  return 'test';
});

console.log(text.value);
console.log(text.value);
console.log(text.value);

I accessed text.value three times, and it resulted in the following output:

Therefore, using a getter indeed causes multiple executions.

[Mini-ghost]

As an adjustment, perhaps it could be modified like this:

 const _request = computed(() => toValue(request)) 

Or

const _request = typeof request === 'function' ? computed(request ) : toRef(request)  

[danielroe]

I think computed(() => toValue(request)) looks best to me. Thank you for investigating.