How can we leverage mapped types in TypeScript to eliminate properties and promisify methods?

Question

How can we leverage mapped types in TypeScript to eliminate properties and promisify methods?

Below is the provided code snippet:

class A {
    x = 0;
    y = 0;
    visible = false;
    render() {
        return 1;
    }
}

type RemoveProperties<T> = {
    readonly [P in keyof T]: T[P] extends Function ? T[P] : never//;
};

type JustMethodKeys<T> = ({ [P in keyof T]: T[P] extends Function ? P : never })[keyof T];
type JustMethods<T> = Pick<T, JustMethodKeys<T>>

type IsValidArg<T> = T extends object ? keyof T extends never ? false : true : true;

type Promisified<T extends Function> =
    T extends (...args: any[]) => Promise<any> ? T : (
        T extends (a: infer A, b: infer B, c: infer C, d: infer D, e: infer E, f: infer F, g: infer G, h: infer H, i: infer I, j: infer J) => infer R ? (
            IsValidArg<J> extends true ? (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I, j: J) => Promise<R> :
            IsValidArg<I> extends true ? (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I) => Promise<R> :
            IsValidArg<H> extends true ? (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H) => Promise<R> :
            IsValidArg<G> extends true ? (a: A, b: B, c: C, d: D, e: E, f: F, g: G) => Promise<R> :
            IsValidArg<F> extends true ? (a: A, b: B, c: C, d: D, e: E, f: F) => Promise<R> :
            IsValidArg<E> extends true ? (a: A, b: B, c: C, d: D, e: E) => Promise<R> :
            IsValidArg<D> extends true ? (a: A, b: B, c: C, d: D) => Promise<R> :
            IsValidArg<C> extends true ? (a: A, b: B, c: C) => Promise<R> :
            IsValidArg<B> extends true ? (a: A, b: B) => Promise<R> :
            IsValidArg<A> extends true ? (a: A) => Promise<R> :
            () => Promise<R>
        ) : never
    );

var a = new A() as JustMethods<A>  // I want to JustMethod && Promisified
a.visible // error
var b = a.render() // b should be Promise<number>

How can this be implemented? The goal is to remove the 'visible' property and promisify the 'render' method. How can we combine Promisified and JustMethods for this purpose?

typescript typescript-typings mapped-types

Answer 1

Answer №1

To properly implement the desired functionality, it is necessary to utilize a mapped type that specifically targets the methods of the designated type by leveraging JustMethodKeys and applying Promisified to each property.

class A {
    x = 0;
    y = 0;
    visible = false;
    render() {
        return 1;
    }
}

type JustMethodKeys<T> = ({ [P in keyof T]: T[P] extends Function ? P : never })[keyof T];

type IsValidArg<T> = T extends object ? keyof T extends never ? false : true : true;

type Promisified<T extends Function> =
    T extends (...args: any[]) => Promise<any> ? T : (
        T extends (a: infer A, b: infer B, c: infer C, d: infer D, e: infer E, f: infer F, g: infer G, h: infer H, i: infer I, j: infer J) => infer R ? (
            IsValidArg<J> extends true ? (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I, j: J) => Promise<R> :
            IsValidArg<I> extends true ? (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I) => Promise<R> :
            IsValidArg<H> extends true ? (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H) => Promise<R> :
            IsValidArg<G> extends true ? (a: A, b: B, c: C, d: D, e: E, f: F, g: G) => Promise<R> :
            IsValidArg<F> extends true ? (a: A, b: B, c: C, d: D, e: E, f: F) => Promise<R> :
            IsValidArg<E> extends true ? (a: A, b: B, c: C, d: D, e: E) => Promise<R> :
            IsValidArg<D> extends true ? (a: A, b: B, c: C, d: D) => Promise<R> :
            IsValidArg<C> extends true ? (a: A, b: B, c: C) => Promise<R> :
            IsValidArg<B> extends true ? (a: A, b: B) => Promise<R> :
            IsValidArg<A> extends true ? (a: A) => Promise<R> :
            () => Promise<R>
        ) : never
    );

type PromisifyMethods<T> = { 
    // We take just the method key and Promisify them, 
    // We have to use T[P] & Function because the compiler will not realize T[P] will always be a function
    [P in JustMethodKeys<T>] : Promisified<T[P] & Function>
}

//Usage
declare var a : PromisifyMethods<A>  
a.visible // error
var b = a.render() // b is Promise<number>

Edit

Following the initial response, TypeScript has evolved with a more concise solution to the problem at hand. With the introduction of Tuples in rest parameters and spread expressions, there is no longer a need for multiple overloads within Promisified:

type JustMethodKeys<T> = ({ [P in keyof T]: T[P] extends Function ? P : never })[keyof T];


type ArgumentTypes<T> = T extends (... args: infer U ) => any ? U: never;
type Promisified<T> = T extends (...args: any[])=> infer R ? (...a: ArgumentTypes<T>) => Promise<R> : never;

type PromisifyMethods<T> = { 
    // We take just the method key and Promisify them, 
    // We have to use T[P] & Function because the compiler will not realize T[P] will always be a function
    [P in JustMethodKeys<T>] : Promisified<T[P]>
}

//Usage
declare var a : PromisifyMethods<A>  
a.visible // error
var b = a.render("") // b is Promise<number> , render is render: (k: string) => Promise<number>

This updated approach not only simplifies the process but also addresses various issues:

Optional parameters remain optional
Argument names are retained
Works seamlessly with any number of arguments

Answer 2

To properly implement the desired functionality, it is necessary to utilize a mapped type that specifically targets the methods of the designated type by leveraging JustMethodKeys and applying Promisified to each property.

class A {
    x = 0;
    y = 0;
    visible = false;
    render() {
        return 1;
    }
}

type JustMethodKeys<T> = ({ [P in keyof T]: T[P] extends Function ? P : never })[keyof T];

type IsValidArg<T> = T extends object ? keyof T extends never ? false : true : true;

type Promisified<T extends Function> =
    T extends (...args: any[]) => Promise<any> ? T : (
        T extends (a: infer A, b: infer B, c: infer C, d: infer D, e: infer E, f: infer F, g: infer G, h: infer H, i: infer I, j: infer J) => infer R ? (
            IsValidArg<J> extends true ? (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I, j: J) => Promise<R> :
            IsValidArg<I> extends true ? (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I) => Promise<R> :
            IsValidArg<H> extends true ? (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H) => Promise<R> :
            IsValidArg<G> extends true ? (a: A, b: B, c: C, d: D, e: E, f: F, g: G) => Promise<R> :
            IsValidArg<F> extends true ? (a: A, b: B, c: C, d: D, e: E, f: F) => Promise<R> :
            IsValidArg<E> extends true ? (a: A, b: B, c: C, d: D, e: E) => Promise<R> :
            IsValidArg<D> extends true ? (a: A, b: B, c: C, d: D) => Promise<R> :
            IsValidArg<C> extends true ? (a: A, b: B, c: C) => Promise<R> :
            IsValidArg<B> extends true ? (a: A, b: B) => Promise<R> :
            IsValidArg<A> extends true ? (a: A) => Promise<R> :
            () => Promise<R>
        ) : never
    );

type PromisifyMethods<T> = { 
    // We take just the method key and Promisify them, 
    // We have to use T[P] & Function because the compiler will not realize T[P] will always be a function
    [P in JustMethodKeys<T>] : Promisified<T[P] & Function>
}

//Usage
declare var a : PromisifyMethods<A>  
a.visible // error
var b = a.render() // b is Promise<number>

Edit

Following the initial response, TypeScript has evolved with a more concise solution to the problem at hand. With the introduction of Tuples in rest parameters and spread expressions, there is no longer a need for multiple overloads within Promisified:

type JustMethodKeys<T> = ({ [P in keyof T]: T[P] extends Function ? P : never })[keyof T];


type ArgumentTypes<T> = T extends (... args: infer U ) => any ? U: never;
type Promisified<T> = T extends (...args: any[])=> infer R ? (...a: ArgumentTypes<T>) => Promise<R> : never;

type PromisifyMethods<T> = { 
    // We take just the method key and Promisify them, 
    // We have to use T[P] & Function because the compiler will not realize T[P] will always be a function
    [P in JustMethodKeys<T>] : Promisified<T[P]>
}

//Usage
declare var a : PromisifyMethods<A>  
a.visible // error
var b = a.render("") // b is Promise<number> , render is render: (k: string) => Promise<number>

This updated approach not only simplifies the process but also addresses various issues:

Optional parameters remain optional
Argument names are retained
Works seamlessly with any number of arguments

Answer 3

Answer №2

Here is a different take on the code snippet provided:

type Method = (...args: any) => any;
type KeysOfFunctions<T> = ({ [K in keyof T]: T[K] extends Method ? K : never })[keyof T];
type SelectMethods<T> = Pick<T, KeysOfFunctions<T>>;
type PromisifyFunction<T> = T extends Promise<infer U> ? Promise<U> : Promise<T>;
type PromisifyMethod<T extends Method> = (...args: Parameters<T>) => PromisifyFunction<ReturnType<T>>
type PromisifyAllMethods<T> = { [K in keyof T]: T[K] extends Method ? PromisifyMethod<T[K]> : T[K] };

type OnlyPromisifiedMethods<T> = SelectMethods<PromisifyAllMethods<T>>

Answer 4

Here is a different take on the code snippet provided:

type Method = (...args: any) => any;
type KeysOfFunctions<T> = ({ [K in keyof T]: T[K] extends Method ? K : never })[keyof T];
type SelectMethods<T> = Pick<T, KeysOfFunctions<T>>;
type PromisifyFunction<T> = T extends Promise<infer U> ? Promise<U> : Promise<T>;
type PromisifyMethod<T extends Method> = (...args: Parameters<T>) => PromisifyFunction<ReturnType<T>>
type PromisifyAllMethods<T> = { [K in keyof T]: T[K] extends Method ? PromisifyMethod<T[K]> : T[K] };

type OnlyPromisifiedMethods<T> = SelectMethods<PromisifyAllMethods<T>>

How can we leverage mapped types in TypeScript to eliminate properties and promisify methods?

Answer №1

Answer №2

Similar questions

Saving Data in an Angular Material Table: A How-to Guide

What steps should I take to ensure that this test covers all possible scenarios?

Using TypeScript to Add Items to a Sorted Set in Redis

ng-select search functionality failing to display any matches

Package.json file is not included in Typescript

Tips for sending a timestamp as input to a stored procedure in TypeScript with the mssql module

Replacing `any` in TypeScript when combining interfaces

Bring in all subdirectories dynamically and export them

Prevent the array from altering its values

Configuring ESLint, Prettier, and TypeScript in React Native: A Step-by-Step Guide

What are the conditions for Jasmine's .toHaveBeenCalledWith to match the parameters?

Guide on implementing the Translate service pipe in Angular 2 code

Angular issue: Readonly or disabled input fields not submitting data

What is the best way to apply DateRange filtering in a Kendo Ui Grid?

Unable to display animation without first launching it on Rive web

Steer clear of type assertion in your codebase when utilizing useSelector alongside Redux, Immutable.js, and TypeScript

What is the best method for retrieving an item from localstorage?

In what ways can enhancing the TypeScript type system with additional restrictions help eliminate errors?

Custom Map Typescript Interface

Combine the selected values of two dropdowns and display the result in an input field using Angular