I have often asked myself about this, since it can lead to the obvious problem:
function someFunction (a, b) {
return a + b
}
If a is a promise you would need to resolve it first:
async function someFunction (a, b) {
a = await a
return a + b
}
Leading to confusing on whether a is resolved or not...
Yes, one should generally avoid passing promises to functions. Prefer waiting for the promise and passing only the result, i.e. do
somethingAsync().then(x => someFunction(x, y))
// or
someFunction(await somethingAsync(), y)
instead of
someFunction(somethingAsync(), y)
As you say, it's very confusing otherwise, especially when not using TypeScript to tell you when you have messed up. And the implementation of someFunction becomes much simpler when it is synchronous and doesn't have to deal with any asynchronous logic, which also makes it more universally useful.
Of course, there are exceptions to every rule, and they would be functions that are explicitly dedicated to handle asynchronous promise logic, like Promise.resolve, Promise.all, Promise.race, .then() etc. Sometimes you write similar helper functions yourself, e.g. for error-handling, and in those cases it might be acceptable to pass a promise. It's still unusual though.