Map a tuple of objects to an object in typescript types

Question

I have a type that looks like this:

type Config = {
  endpoints: [
    {name: "abc", created: false},
    {name: "xyz", created: true},
  ]
}

I have a function that transforms this type into the following:

type Instance = {
  abc: {name: "abc", created: false},
  xyz: {name: "xyz", created: false},
}

I wrote the following transformation type

type IntersectOf<U extends any> = (U extends unknown ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;

type Transform<T extends Config, K extends (keyof T)[] = (keyof T)[]> = IntersectOf<{
  [key in keyof K]:
    K[key] extends keyof T['endpoints']
    // here it says "name" can't be used as index of `T["endpoints"][K[key]]`
    ? Record<T['endpoints'][K[key]]['name'], T['endpoints'][K[key]]>
    : never;
}[number]>;

type Instance = Transform<Config>;

I also tried adding a number type guard, and the error goes away but Instance becomes unknown. Here is the Transform type with number typeguard:

type Trasnform<T extends Config, K extends (keyof T)[] = (keyof T)[]> = IntersectOf<{
  [key in keyof K]:
    K[key] extends keyof T['endpoints']
    ? K[key] extends number
    ? Record<T['endpoints'][K[key]]['name'], T['endpoints'][K[key]]>
    : never
    : never;
}[number]>;

jcalz · Accepted Answer · 2022-10-30 14:08:35Z

3

My suggestion would be to write a key-remapping mapped type that acts on the union of element types of the endpoints property, like this:

type Transform<T extends { name: string }> =
    { [U in T as U['name']]: U }

And then you pass in, not Config, but the indexed access type Config['endpoints'][number] corresponding to the element types:

type Instance = Transform<Config['endpoints'][number]>;

That produces this:

/* type Instance = {
    abc: {
        name: "abc";
        created: false;
    };
    xyz: {
        name: "xyz";
        created: true;
    };
} */

which is what you were looking for.

Playground link to code

answered Oct 30, 2022 at 14:08

jcalz

339k29 gold badges452 silver badges449 bronze badges

Sign up to request clarification or add additional context in comments.

2 Comments

tokland Over a year ago

Working on the union, nice!

Nauman Umer Over a year ago

thanks a lot, I came across Key Remapping too but I wasn't able to make it work for my use case, Its working fine now

tokland · Accepted Answer · 2022-10-30 14:04:05Z

1

A proposal (playground):

export type IndicesOf<T> = Exclude<keyof T, keyof any[]>;

type Instance = { 
  [Idx in IndicesOf<Config["endpoints"]> 
    as Config["endpoints"][Idx]["name"]]: Config["endpoints"][Idx]
}

answered Oct 30, 2022 at 14:04

tokland

68.2k13 gold badges151 silver badges174 bronze badges

1 Comment

Nauman Umer Over a year ago

thanks a lot, I really liked the IndicesOf approach.

Collectives™ on Stack Overflow

Map a tuple of objects to an object in typescript types

2 Answers 2

2 Comments

1 Comment

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

2 Comments

1 Comment

Your Answer

Sign up or log in

Post as a guest

Related