How to make a type from the values of an union/intersection object type?

Question

I’m having a hard type figuring out how to define a type as the union of all possible values from a predefined object type.

Assume we have an autogenerated type Person that looks like this:

type Person = {
  favouriteColor: string
  age: number
  female: boolean
}

How does one use the Person type to create a union type equal to string | number | boolean?

In my use case, the type Person is autogenerated. I’m using Ramda’s map function on an object, to apply a function to each of the object’s values:

import { map } from 'ramda'

classroom.people.forEach(person =>
  // Ramda’s `map` is applied to a `block` object here:
  map<Person, Person>(property => {
    // The type definitions for Ramda are not sufficiently strong to infer the type
    // of `property`, so it needs to be manually annotated.
    return someFunction(property)
  }, person)
)

The behavior I’m looking for is essentially equivalent to keyof — but as far as I know there is no valueof in TypeScript. What would an equivalent implementation look like?

Thank you very much!

---

Edit: ordinarily, the solution would be as suggested by @kaya3: type ValueOf<T> = T[keyof T]. However, upon closer inspection, my situation seems to be troubled by the following:

type PersonCommonFields = {
  age: number,
  name: string
}
type PersonFragment =
  | { favouriteColor: string }
  | { female: boolean }
  | { eyeColor: Color }
  | { born: Date }
type Person = PersonCommonFields & PersonFragment

In this case, ValueOf<Person> as defined above returns number | string, i.e. only the values from PersonCommonFields, ignoring PersonFragment. The expected result for this example would be number | string | boolean | Color | Date.

Would there be an alternative approach to tackle this situation?

Many (many!) thanks in advance!

Answer 1

I noticed that if you change the | to & in PersonFragment that it works (in other words, create a single type instead of a union type). It seems like you want these fields to be optional, could you use Partial with the single type (same behavior as just making each field optional)?

type PersonCommonFields = {
  age: number,
  name: string
}
type PersonFragment = Partial<{
  favouriteColor: string,
  female: boolean,
  eyeColor: Color,
  born: Date
}>
type Person = PersonCommonFields & PersonFragment;

type PersonTypes = Person[keyof Person]; // number | string | boolean | Color | Date

Edit:

@kaya3 noted in the comments that the current behavior is that at least one of the fields in PersonFragment should be set. If this is not a requirement, the above should work.

Let's say the requirement is actually that only 1 field exists, and not more? You can use the custom type XOR¹ to enforce this, and the resulting object will allow you to access the keys.

// Note: Define these in your global typings file so they can be reused
type Without<T, U> = { [P in Exclude<keyof T, keyof U>]?: never };
type XOR<T, U> = T | U extends object ? (Without<T, U> & U) | (Without<U, T> & T) : T | U;

type PersonFragment = XOR<
  { favouriteColor: string },
  XOR<{ female: boolean }, XOR<{ eyeColor: Color }, { born: Date }>>
>;

¹: https://stackoverflow.com/a/53229857/522877

Answer 2

The ValueOf<T> = T[keyof T] type doesn't work how you want for union types, because keyof doesn't distribute over unions. For example, the type keyof ({foo: 1} | {bar: 2}) is never instead of 'foo' | 'bar'.

Instead, we can use a distributive conditional type, which does distribute over unions (as its name implies).

type ValueOfUnion<T> = T extends infer U ? U[keyof U] : never

type Test = ValueOfUnion<Person>
// Test = string | number | boolean | Color | Date

Playground Link

Answer 3

Inspired by @Wex’s answer I found a workaround, which isn’t perfect but sufficient for now.

graphql-codegen generates the following types:

type PersonCommonFields = {
  age: number,
  name: string
}
type A = { favoriteColor: string }
type B = { female: boolean }
type C = { eyeColor: Color }
type D = { born: Date }
type PersonFragment = A | B | C | D

From this I created type Person = PersonCommonFields & PersonFragment which is used in the code. Ideally, only this last type (Person) would be used to come up with a solution, because it doesn’t need to be kept up-to-date with PersonFragment as it evolves and includes more types in its union (E, F, G etc.) over time, as the GraphQL schema evolves.

But by rearranging a bit, we can get to this:

type PersonFields =
  | Person[keyof PersonCommonFields]
  | A[keyof A]
  | B[keyof B]
  | C[keyof C]
  | D[keyof D]

which creates the desired type number | string | favoriteColor | boolean | Color | Date.