How can I remove a wider type from a union type without removing its subtypes in TypeScript?

by

Current solution (Typescript 4.1+)

2021 Edit: The 2.8 implementation of KnownKeys<T> is broken since Typescript 4.3.1-rc, but a new, more semantic implementation using key remapping is available since 4.1:

type RemoveIndex<T> = {
  [ K in keyof T as string extends K ? never : number extends K ? never : K ] : T[K]
};

It can then be used as follows:

type KnownKeys<T> = keyof RemoveIndex<T>;

interface test {
  req: string
  opt?: string
  [k: string]: any
}

type demo = KnownKeys<test>; // "req" | "opt" // Absolutely glorious!

Below is the preserved solution for pre-4.1 Typescript versions:

I got a solution from @ferdaber in this GitHub thread.

Edit: Turns out it was, to little fanfare, published in 1986 by @ajafff

The solution requires TypeScript 2.8’s Conditional Types and goes as follows:

type KnownKeys<T> = {
  [K in keyof T]: string extends K ? never : number extends K ? never : K
} extends { [_ in keyof T]: infer U } ? U : never;

Below is my attempt at an explaination:

The solution is based on the fact that string extends string (just as 'a' extends string) but string doesn’t extend 'a', and similarly for numbers.
Basically, we must think of extends as “goes into”

First it creates a mapped type, where for every key of T, the value is:

  • if string extends key (key is string, not a subtype) => never
  • if number extends key (key is number, not a subtype) => never
  • else, the actual string key

Then, it does essentially valueof to get a union of all the values:

type ValuesOf<T> = T extends { [_ in keyof T]: infer U } ? U : never

Or, more exactly:

interface test {
  req: string
  opt?: string
  [k: string]: any
}
type FirstHalf<T> = {
  [K in keyof T]: string extends K ? never : number extends K ? never : K
}

type ValuesOf<T> = T extends { [_ in keyof T]: infer U } ? U : never
// or equivalently, since T here, and T in FirstHalf have the same keys,
// we can use T from FirstHalf instead:
type SecondHalf<First, T> = First extends { [_ in keyof T]: infer U } ? U : never;

type a = FirstHalf<test>
//Output:
type a = {
    [x: string]: never;
    req: "req";
    opt?: "opt" | undefined;
}
type a2 = ValuesOf<a> //  "req" | "opt" // Success!
type a2b = SecondHalf<a, test> //  "req" | "opt" // Success!

// Substituting, to create a single type definition, we get @ferdaber's solution:
type KnownKeys<T> = {
  [K in keyof T]: string extends K ? never : number extends K ? never : K
} extends { [_ in keyof T]: infer U } ? U : never;
// type b = KnownKeys<test> //  "req" | "opt" // Absolutely glorious!

Explaination in GitHub thread in case someone makes an objection over there

More Related Contents:

  1. TypeScript conditional types – filter out readonly properties / pick only required properties
  2. When I refresh my website I get a 404. This is with Angular2 and firebase
  3. Expected 3 type arguments but got 1 but it should infer 2 types
  4. Import class in definition file (*d.ts)
  5. Typescript return type depending on parameter
  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. How to selectively assign from one Partial to another in typescript
  12. How to unwrap the type of a Promise?
  13. Experimental decorators warning in TypeScript compilation
  14. A TypeScript GUID class? [closed]
  15. How to define an opaque type in TypeScript?
  16. What is the Record type?
  17. Mapping tuple-typed value to different tuple-typed value without casts
  18. Make overProp function interface with one param
  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. Why is never assignable to every type?
  23. Is there an alternative to Partial to accept only fields from another type and nothing else?
  24. TypeScript sorting an array
  25. Angular 2 ngModel in child component updates parent component property
  26. How to extend the ‘Window’ typescript interface
  27. Generic and typeof T in the parameters
  28. How to make “handler” lookup for “dispatcher” style function be typed correctly
  29. How to place a dynamic component in a container
  30. Modules vs. Namespaces: What is the correct way to organize a large typescript project?

Leave a Comment