How to create a type containing only the common properties from a type union?

Question

I want to map over union of arrays, how can I make it type safely?

I have a solution, but I want to avoid hard-coding the types from the type union. When calculating newArr1, as expected, I get an error: Property 'field2' does not exist on type 'Common<A, B>' Is there a way to get the same error when calculating newArr2?

(link to code)

interface A {
    field1: string
    field2: number
}
interface B {
    field1: string
}

type Common<A, B> = {
    [P in keyof A & keyof B]: A[P] | B[P];
}

function mapArray(arr: A[] | B[]) {

    const newArr1 = (arr as Common<A, B>[]).map(i => i.field2) // error

    // how can I get the same error without hard-coding the types from the type union?
    const newArr2 = (arr as MagicEventuallyFromJcalz<typeof arr>).map(i => i.field2)

    return newArr1
}

Unions kind of act this way already. The problem that unions of functions are hard to call. Do you have some use case better than `mapArray()`? Because I'd just use `arr as (A|B)[]` here without doing type craziness. — jcalz, May 29 '19 at 18:51
Also, wouldn't the second one be something like `(arr as Common[])`? Or do you expect `Common` to somehow be the same as `Common []`? Undistributing "arrayness" seems hard to get for free; it could be hardcoded, but I guess I'd like to see a more full use case — jcalz, May 29 '19 at 18:58
And my first draft of `Common` without arrayness stuff would be `type Common = Pick`. — jcalz, May 29 '19 at 18:59
Why not `mapArray(arr: (A | B)[])`? `mapArray(arr: A[] | B[])` is saysing you either have an array of all A or all B, its the union of array types not of the types of items the array's have so it would be difficult w/o having 2 code paths for each. — Wilhelmina Lohan, May 29 '19 at 19:45

score 0 · Accepted Answer · answered May 29 '19 at 22:39

Thanks jcalz and William Lohan!

A real use case: for 2 different requests from an external api, I get 2 different responses:

an array with users having many details about each user, and
an array with users having a small subset of the details from the previous point

Using the same function which parses either one of the 2 array from above, I want to get the users' ids (id is a common property of users from both arrays), 1) in a type safe manner and 2) without hard-coding the array types in function body. Based on your comments jcalz, I was able to achive that. You deserve the credit for the solution, if you post an answer, I'll mark it as accepted.

The solution I found (link to code):

interface DetailedUser {
    id: number
    many: number
    other: string
    fields: boolean
}
interface CompactUser {
    id: number
}

type Common<T> = Pick<T, keyof T>

type UnpackedFromArray<T> = T extends (infer U)[] ? U : never

function getUserIdsFromApi(usersJsonFromApi: DetailedUser[] | CompactUser[]) {

    // works as expected: in both lines below, a ts error is raised
    // note that the types (DetailedUser[], CompactUser[]) are not hard-coded, but determined from variable usersJsonFromApi

    const userIds1 = (usersJsonFromApi as Common<UnpackedFromArray<typeof usersJsonFromApi>>[]).map(i => i.other)

    const userIds2 = (usersJsonFromApi as Common<typeof usersJsonFromApi[number]>[]).map(i => i.other)

    return userIds1
}

I generally prefer `type UnpackedFromArray> = T[number]` (not that you need to give it a name for such a short thing) to the conditional type `T extends (infer U)[] ? U : never` since the former, a lookup type, is easier for the compiler to reason about. But they both work. — jcalz, May 30 '19 at 00:20

How to create a type containing only the common properties from a type union?

1 Answers1

Linked