Extract function parameters or change function return type in mapped types

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)

[Keyves]

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