Extract function parameters or change function return type in mapped types

[Roaders]

Search Terms

extract function parameters
change function return type

Suggestion

Allow mapped types to change the return type of a function

Use Cases

I am writing a mocking framework. My system under test might be like this:

MyClass{
    myClassFunction(paramOne: string, paramTwo: number): string{}
}

but in my mocking framework I want to do this:

mockedObject
    .withFunction("myClassFunction")
    .withParameters("paramOneValue", 123)
   .wasCalled();

to do the withParameters I need to type a function with the same parameters as defined on my class but with a different return type.

Checklist

My suggestion meets these guidelines:
[ ] This wouldn't be a breaking change in existing TypeScript / JavaScript code
[ ] This wouldn't change the runtime behavior of existing JavaScript code
[ ] This could be implemented without emitting different JS based on the types of the expressions
[ ] This isn't a runtime feature (e.g. new expression-level syntax)

[mhegazy]

Discussed in #23045. we need a few basic concepts to be added to the language before enabling such scenarios. we first need variadic types (tracked by #5453), we need some concept of an open-ended tuple, and we need a way to covert the function param list to tuples and vice versa.

[Roaders]

Thanks for the reply... Seems like it's quite a way off...
I assume when all these pieces come into place well be able to map the parameters.
I.e. convert a list of params to a list of ISomeType

[cyanql]

like this?

type MapResultToPromise<T> = T extends (...args: infer U) => infer R ? (...args: U) => Promise<R> : T;

[Cerberus]

type ArgumentTypes<T> = T extends (... args: infer U ) => infer R ? U: never;
type ReplaceReturnType<T, TNewReturn> = (...a: ArgumentTypes<T>) => TNewReturn;

I found this on stackoverflow. It's very useful.
ref: https://stackoverflow.com/a/50014868/8491995

And I've tried to apply Proxy to object.

type Proxify<T> = { [P in keyof T]: ReplaceReturnType<T[P], Proxify<T>> }

function proxify<T>(o: T): Proxify<T> {
	return new Proxy(o, handler)
}

So then we get a chain-proxy object as you want

[thorn0]

This all is possible now (except probably for some tricky cases). Why is the issue still open?