Evaluate TypeScript method against the interface, for example T['methodName']

Question

Evaluate TypeScript method against the interface, for example T['methodName']

Suppose we have an interface:

class A {
   method(x:number) : string
}

And a function:

const b = (x: string) : number;

Our goal is to test the function against the interface.

Here is one way to achieve this:

type InterfaceKey = {
    method: any
};

function typecheck<T, K extends keyof InterfaceKey >(imp: () => T, d: T[K]) {
 //                                   K cannot be used to index type T ^
    imp();
    return d;
}

typecheck(someclass, 555); // <-- type check _is actually works_ here

// or

function typecheck <T>(imp: () => T, d: any) {
    imp();
    if(!d) {
        let mock: T;
        mock.default = d; // default does not exists on type T 
        return mock;
    }
    return d;
}

It seems that the first approach is the most effective, as it performs a type check in Webstorm (but not in tsc) although it does not compile.

For more information, check out: https://github.com/Microsoft/TypeScript/issues/15768

typescript

Answer 1

Answer №1

Are we headed in the right path?

class anotherClass {
  mymethod(y: number): string { return null!; };
}

const c = (y: number): string => null!;

type KeyInterface = {
  mymethod: any
};

function verifyType<U extends KeyInterface>() {
  return <V extends keyof KeyInterface>(e: U[V]) => {};
}

// should generate error if the signature of anotherClass's `mymethod` doesn't match that of `c`
verifyType<anotherClass>()(c);

Answer 2

Are we headed in the right path?

class anotherClass {
  mymethod(y: number): string { return null!; };
}

const c = (y: number): string => null!;

type KeyInterface = {
  mymethod: any
};

function verifyType<U extends KeyInterface>() {
  return <V extends keyof KeyInterface>(e: U[V]) => {};
}

// should generate error if the signature of anotherClass's `mymethod` doesn't match that of `c`
verifyType<anotherClass>()(c);

Answer 3

Answer №2

//base interface
interface MyInterface {
    method: any 
}

// defining a check interface with specified method
interface CheckData<T extends MyInterface> {
    all(keys: {[P in keyof T]?: T[P]}): Check<T>;

    onlyMethod<Ts extends {[K in keyof Ts]: Ts[K]} & T>(fn: Ts['method']): Check<T>;
}

// check without specified method
interface Check<T> {
    all(keys: {[P in keyof T]?: T[P]}): Check<T>;
}

type CustomCheckData<T extends MyInterface > = CheckData<T>;
type CustomCheck<T> = Check<T>;

// a magic function to uncast type
function uncast(a: any): any{
    return <any>a;
}

// function overloading with generic parameters
function load<K extends MyInterface>(a: K): CustomCheckData<K>;
function load<T>(a: T): CustomCheck<T>;

// type guards for function overloading
function load<T, K extends MyInterface>(a: T|K): CustomCheckData<K> | CustomCheck<T>{
    if ((<K>a).method) return <CustomCheckData<K>>uncast(a);
    return <CustomCheck<T>> uncast(a);
}

// TEST

var C1 = {
    test: a => a + 1,
    method: a => 5
}

var C2 = {
    test: a => a + 1,    
}

let a1 = load(C1);
a1.all({ test: a => 1 });
a1.onlyMethod(55); // type error

let a2 = load(C2);
a2.all({ test: (a,b) => 1 }); // type error
a2.all({ test2: a => 1 });// type error
a2.onlyMethod(55); //no such method

It is evident that the outcome is clear and understandable.

Answer 4

//base interface
interface MyInterface {
    method: any 
}

// defining a check interface with specified method
interface CheckData<T extends MyInterface> {
    all(keys: {[P in keyof T]?: T[P]}): Check<T>;

    onlyMethod<Ts extends {[K in keyof Ts]: Ts[K]} & T>(fn: Ts['method']): Check<T>;
}

// check without specified method
interface Check<T> {
    all(keys: {[P in keyof T]?: T[P]}): Check<T>;
}

type CustomCheckData<T extends MyInterface > = CheckData<T>;
type CustomCheck<T> = Check<T>;

// a magic function to uncast type
function uncast(a: any): any{
    return <any>a;
}

// function overloading with generic parameters
function load<K extends MyInterface>(a: K): CustomCheckData<K>;
function load<T>(a: T): CustomCheck<T>;

// type guards for function overloading
function load<T, K extends MyInterface>(a: T|K): CustomCheckData<K> | CustomCheck<T>{
    if ((<K>a).method) return <CustomCheckData<K>>uncast(a);
    return <CustomCheck<T>> uncast(a);
}

// TEST

var C1 = {
    test: a => a + 1,
    method: a => 5
}

var C2 = {
    test: a => a + 1,    
}

let a1 = load(C1);
a1.all({ test: a => 1 });
a1.onlyMethod(55); // type error

let a2 = load(C2);
a2.all({ test: (a,b) => 1 }); // type error
a2.all({ test2: a => 1 });// type error
a2.onlyMethod(55); //no such method

It is evident that the outcome is clear and understandable.

Evaluate TypeScript method against the interface, for example T['methodName']

Answer №1

Answer №2

Similar questions

What is the best way to retrieve a specific property from an array of objects in Angular 6 using typescript?

Angular location services

What is the reason that Jest is not able to spy on the function?

Angular loop using an HTTP GET request is producing garbled information

typescript Can you explain the significance of square brackets in an interface?

When multiple input fields with an iterative design are using the same onChange() function, the specific event.target.values for each input

Unable to serve static files when using NextJs in conjunction with Storybook

Issue: Formcontrolname attribute is undefined causing TypeError when trying to retrieve 'get' property.Remember to define formcontrolname attribute to

How to verify in HTML with Angular whether a variable is undefined

NestJS integration tests are failing due to an undefined Custom TypeORM Repository

Creating a realistic typewriter effect by incorporating Code Block as the input

Utilizing a constant in setting the slotLabelFormat

Yup will throw an error if both a minimum value is set and the field is also marked

Data fetched using React Query

The For loop causing crashes in the Filter button functionality

Destructuring an array of strings for use as parameters

Filtering database results from an Angular component

Suddenly encountered issue when working with TypeScript Interfaces while integrating Quicktype 'allOf'

Angular's mechanism for detecting changes in a callback function for updates

Extending Enums in Typescript: A Comprehensive Guide