Ngtjyty

function whatever(object, methodName, args) {

  return object[methodName](...args);

}

Can the above be typed so the the following is enforced:

• 
  methodName is a key of object.


• 
  object[methodName] is callable and its args are ...args.


• The return type of whatever(object, methodName, args) is the return type of object[methodName](...args).

The closest thing I could find is the definition of function.apply, but it isn't quite the same as the above.

I think this does the trick:

function callMethodWithArgs<

  M extends string,

  T extends { [m in M]: (...args: Array<any>) => any },

  F extends T[M]

>(obj: T, methodName: M, args: Parameters<F>) {

  return obj[methodName](...args) as ReturnType<F>;

}

Requires TS 3 though!

This should do it. This checks for the methodName as well as each of the args.

(Note: not perfect, some refinement can be made; e.g., unknown -> any)

type ArgumentsType<T> = T extends (...args: infer A) => any ? A : never;



function whatever<

  T extends object,

  TKey extends keyof T,

  TArgs extends ArgumentsType<T[TKey]>

>(

  object: T,

  methodName: T[TKey] extends ((...args: TArgs) => unknown) ? TKey : never,

  args: TArgs

): T[TKey] extends ((...args: TArgs) => unknown) ? ReturnType<T[TKey]> : never {

  const method = object[methodName];

  if (typeof method !== 'function') {

    throw new Error('not a function');

  }

  return method(...args);

}



interface Test {

  foo: (a: number, b: number) => number;

  bar: string;

}



const test: Test = {

  foo: (a, b) => a + b,

  bar: 'not a function'

};



const result = whatever(test, 'foo', [1, 2]);

How about this?

function whatever(someObject: { [key: string]: Function}, methodName: string, args: any) {

    return someObject[methodName](...args);

}



whatever({ func1: (args) => (console.log(...args)) }, 'func1', [1])

Is the return type always the same of someObject[methodName]?

function whatever<O extends {[key: string]: (...args) => R}, R>(object: O, methodName: keyof O, ...args: any): R {

  return object[methodName](...args);

}

Then you could do this.

The option that is the type-safest one is to use Parameters to get the parameter types of the function (in order for arguments to be type safe), ReturnType to return the result of a function.

You also need to also add a type parameter to capture the actual key passed in so we can get the actual type of the function (T[K](

function whatever<T extends Record<string, (...a: any)=> any>, K extends keyof T> (someObject: T,  methodName: K, ...args: Parameters<T[K]>) : ReturnType<T[K]>{

    return someObject[methodName](...args);

}



whatever({ func1: (args: number) => (console.log(...args)) }, 'func1', [1])

whatever({ func1: (args: number) => (console.log(...args)) }, 'func1', ["1"]) // err

type Dictionary = { [key: string]: any }



type MethodNames<T extends Dictionary> = T extends ReadonlyArray<any>

  ? Exclude<keyof , number>

  : { [P in keyof T]: T[P] extends Function ? P : never }[keyof T]



function apply<T extends Dictionary, P extends MethodNames<T>>(

  obj: T,

  methodName: P,

  args: Parameters<T[P]>

): ReturnType<T[P]> {

  return obj[methodName](...args);

}



// Testing object types:

const obj = { add: (...args: number) => {} }

apply(obj, 'add', [1, 2, 3, 4, 5])



// Testing array types:

apply([1, 2, 3], 'push', [4])



// Testing the return type:

let result: number = apply(new Map<number, number>(), 'get', [1])

Playground link

The Dictionary type allows T[P] to be used.

The Parameters and ReturnType types are baked into TypeScript.

The MethodNames type extracts any keys whose value is assignable to the Function type. Array types require a special case.

Checklist

• Method name is validated? ✅


• Arguments are type-checked? ✅


• Return type is correct? ✅