How to get a subset of `keyof T` whose value, T[K] are callable functions in Typescript

by

You can use the as clause of a mapped type to filter the keys of a type:

type KeyOfType<T, V> = keyof {
    [P in keyof T as T[P] extends V? P: never]: any
}

The as clause of a mapped type allows us to manipulate the name of the key. If the key is mapped to never the key gets removed from the resulting type. You can find more info in this PR

Pre TS 4.1

This version still works in post 4.1, just the other way is easier to read.

You can do this using conditional and mapped types

type KeyOfType<T, U> = {[P in keyof T]: T[P] extends U ? P: never}[keyof T]

Let’s break things down a little bit.

We can start with a mapped type, that has the same properties of the same type as the original T, this a simple standard mapped type:

type KeyOfType<T> = { [P in keyof T]: T[P] } // New Type same as the original

T[P] is a type query and means the type of the key P in type T. We can change this to just P, meaning that the type of the new property is the same as it’s name:

type KeyOfType<T> = { [P in keyof T]: P }
// So
KeyOfType<{ a: number, b: string }> == { a: 'a', b: 'b' }

We can add a type query to this type to again get all the keys of the type. Generally a construct T[keyof T] gets all the property types of a type. Applying this to our mapped type which has the property types the same as the key names we basically get back to keyof T:

type KeyOfType<T> = { [P in keyof T]: P }[keyof T]
// So
KeyOfType<{ a: number, b: string }> ==  'a'|'b'

Now we can add a conditional type to o not always select P. Since A | never == A we can set the type of the property in the mapped type to never if the type of the original property (T[P]) does not meet a certain constraint.

To express the constraint we add an extra generic parameter U and we use a conditional type which has the form T extends U ? TypeIfTrue: TYpeIfFalse. Putting it together we get:

type KeyOfType<T, U> = {[P in keyof T]: T[P] extends U ? P: never}[keyof T]

More Related Contents:

  1. What is “not assignable to parameter of type never” error in TypeScript?
  2. Expected 3 type arguments but got 1 but it should infer 2 types
  3. Import class in definition file (*d.ts)
  4. TypeScript union of string and string literals
  5. What does the `is` keyword do in typescript?
  6. Mapped Types: removing optional modifier
  7. Why can I avoid excess property check in typescript just by passing a reference to an object to a function rather than the object in its literal form?
  8. TypeScript: Accept all Object keys that map to a specific type
  9. Typescript interface default values
  10. How to configure custom global interfaces (.d.ts files) for TypeScript?
  11. What does “keyof typeof” mean in TypeScript?
  12. Typescript Key-Value relation preserving Object.entries type
  13. TypeScript error TS1005: ‘;’ expected (II)
  14. How can an object type with nested subproperties be flattened?
  15. Is there an option to make spreading an object strict?
  16. ‘compile-time’ way to get all property names defined interface
  17. Make overProp function interface with one param
  18. TypeScript: Why can’t I assign a valid field of an object with type { a: “a”, b: “b” }
  19. Absolute paths (baseUrl) gives error: Cannot find module
  20. typescript restrict count of object’s properties
  21. Checking validity of string literal union type at runtime?
  22. TypeScript keyof returning specific type
  23. Why is never assignable to every type?
  24. Is there an alternative to Partial to accept only fields from another type and nothing else?
  25. How to create an Observable from static data similar to http one in Angular?
  26. Setting up tsconfig with spec/test folder
  27. Does TypeScript allow type aliases?
  28. How to pass an instance variable into typescript decorator arguments?
  29. Can I force the TypeScript compiler to use nominal typing?
  30. Optional class members in Typescript

Leave a Comment