Types from both keys and values of object in Typescript

Question

I have two sets of string values that I want to map from one to the other as a constant object. I want to generate two types from that mapping: one for keys and one for values.

const KeyToVal = {
    MyKey1: 'myValue1',
    MyKey2: 'myValue2',
};

The keys are easy enough:

type Keys = keyof typeof KeyToVal;

I'm having trouble getting a compile-time type for the values. I thought maybe one of these would work:

type Values = typeof KeyToVal[Keys];
type Values<K> = K extends Keys ? (typeof KeyToVal)[K] : never;
type Prefix<
    K extends Keys = Keys, 
    U extends { [name: string]: K } = { [name: string]: K }
> = {[V in keyof U]: V}[K];

All of these just made Values to be string. I also tried adapting the two answers to How to infer typed mapValues using lookups in typescript?, but either I got my adaptations wrong, or the answers didn't fit my scenario in the first place.

artem · Accepted Answer · 2019-07-18T05:46:56.997

The compiler will widen string literal type to string, unless some specific conditions are met as explained in github issues and PR, or const assertion is used for literal value. Const assertions appeared in TypeScript 3.4:

const KeyToVal = {
    MyKey1: 'myValue1',
    MyKey2: 'myValue2',
} as const;

type Keys = keyof typeof KeyToVal;
type Values = typeof KeyToVal[Keys]; //  "myValue1" | "myValue2"

Prior to 3.4, there was a workaround to get the same effect. To make the compiler infer literal types, you had to pass your object through a function with appropriately crafted generic type parameters, this one seems to do the trick for this case:

function t<V extends string, T extends {[key in string]: V}>(o: T): T {return o}

The whole purpose of this function is to capture and preserve types to enable type inference, it's entirely useless otherwise, but with it you can have

const KeyToVal = t({
    MyKey1: 'myValue1',
    MyKey2: 'myValue2',
});

type Keys = keyof typeof KeyToVal;
type Values = typeof KeyToVal[Keys]; //  "myValue1" | "myValue2"

Perfect. I had scanned a couple questions that proposed that, but didn't think the compiler would run the function, so I skipped over the solution. *facepalm* — dx_over_dt, Dec 07 '18 at 02:28
Here is a useful type alias for above: `export type ObjectValues> = T[keyof T];` Then use it like this: `type Values = ObjectValues` — ado387, Aug 23 '23 at 07:32

score 62 · Answer 2 · edited Nov 09 '21 at 17:30

62

Actually, you should change the KeyToVal to the below declaration:

const KeyToVal = {
    MyKey1: 'myValue1',
    MyKey2: 'myValue2',
} as const; // <----- add the <as const> here

Then create the keys types:

type Keys = keyof typeof KeyToVal;

Now you can create the types of the values:

type ValuesTypes = typeof KeyToVal[Keys];

edited Nov 09 '21 at 17:30

Dharman

30,962
25
85
135

answered Nov 09 '21 at 16:51

AmerllicA

29,059
15
130
154

score 16 · Answer 3 · answered Dec 07 '18 at 02:08

You are trying to infer the type from the object (which can have any number of keys/values). You can try to describe the type (or maybe better an interface) first and then infer Kyes and Values like so:

type KeyToObjMap = {
  some: "other",
  more: "somemore",
};

type Keys = keyof KeyToObjMap;

type Values = KeyToObjMap[Keys];

let one: Values = "some";
let two: Values = "other";
let three: Keys = "some";
let four: Values = "somemore";
let five: Keys = "fun";

And you will have a correct highlight in IDE.

That *almost* works. Now I need runtime access to `KeyToObjMap`. — dx_over_dt, Dec 07 '18 at 02:12

score 5 · Answer 4 · answered Jun 27 '22 at 14:03

Not quite the same, but if you have an array of objects instead of a single object then you can pull out the values of a known property to create a type by doing something like this:

const keyToValArray = [
  { value: 'myValue1', label: 'myLabel1' },
  { value: 'myValue2', label: 'myLabel2' }
] as const;
type Keys = typeof keyToValArray[number]['value']; // 'myValue1' | 'myValue2'

score 0 · Answer 5 · answered Sep 21 '20 at 08:44

I know that it may not be related, but for my usecase, I reached this question because I wanted to create a type based on an object or array. So I just thought it may be useful for someone with the same usecase reaching this question to use enums: You can simply define an enum like this:

enum Arrow {
  Up,
  Down,
  Left,
  Right
}

You can read more about them here and here.

You can now use this enum as a type:

type Props = {
  arrow: Arrow
}

const Component = (props: Props) => {
  switch(props.arrow) {
    case Arrow.Up:
      // go-up
    case Arrow.Down:
      // go-down
    ...
  }

}

and you can use it in your components:

  <Component arrow={Arrow.top} />

Types from both keys and values of object in Typescript

5 Answers5

Linked