TypeScript "forgets" enum in mapped type key

[ddurschlag]

Bug Report

Enum values can be used on both sides of a mapped type (key/value). For values, things work great! For keys, the enum is "forgotten" and replaced with its integral value. This can cause problem for further type logic.

🔎 Search Terms

Enum, Mapped Type

🕗 Version & Regression Information

Replicated in playground in 3.3.3333, 4.9.4, and nightly.

• This is the behavior in every version I tried, and I reviewed the FAQ for entries about enums and mapped types
• I was unable to test this on prior versions because playground only goes back to 3.3.3333

⏯ Playground Link

https://tinyurl.com/mwee547u

💻 Code

enum MyEnum {
    MyEnumValue
};

type EnumOnBothMapSides = {[MyEnum.MyEnumValue]: MyEnum.MyEnumValue};
/*
EnumOnBothMapSides inferred as:

type EnumOnBothMapSides = {
    0: MyEnum.MyEnumValue;
}

Notice that the enum-ness has been lost in the key
*/
type EnumValueType = typeof MyEnum[MyEnum.MyEnumValue];
/*
EnumValueType inferred as:

type EnumValueType = string

It would be nice if this were "MyEnumValue", but that's more of a feature request than a bug.
Nonetheless, we now know that indexing into MyEnum with MyEnumValue produces a string.
Let's specify that:
*/
type MyEnumIndex = {[MyEnum.MyEnumValue]: string};
/*
MyEnumIndex inferred as:

type MyEnumIndex = {
    0: string;
}

This replicates the "forgetfulenss" seen above.
*/
const myEnumIndex: MyEnumIndex = MyEnum;
/*
Error:

Property '[MyEnum.MyEnumValue]' is missing in type 'typeof MyEnum' but required in type 'MyEnumIndex'.(2741)
Earlier, however, TypeScript was quite explicit that "typeof MyEnum[MyEnum.MyEnumValue]" is a string.
*/

🙁 Actual behavior

myEnumIndex doesn't typecheck.

🙂 Expected behavior

myEnumIndex typechecks, as its type describes a demonstrable behavior of the enum type. This should be, in effect, a widening/covariant conversion which TS is generally ok with.

[RyanCavanaugh]

What you're doing is equivalent (as shown in the tooltip) to writing

const f: { 0: string } = MyEnum;

which is no different, from TypeScript's perspective, from writing

const g: { 32: string } = MyEnum;

because enums have a numeric index signature, rather than a series of declared numeric properties. The latter is undesirable because if you wrote that, keyof typeof MyEnum would include "0" or 0, which no one wants.

[ddurschlag]

Is there some way to see the type of the enum's runtime object? This is fundamentally what I was after, but I couldn't figure out what it was (hence { 0: string } instead of { [key: number]: string }). The question of keyof typeof MyEnum is also interesting. Object.keys(MyEnum) produces ["0", "MyEnumValue"], while type X = keyof typeof MyEnum; infers to type X = "MyEnumValue". I believe this behavior may be different for string enums, as well.

Perhaps this is an issue of documentation rather than behavior.

[RyanCavanaugh]

I don't know what you mean by "see". You can construct what the reverse map would look like, which you did.

keyof tells you about the known declared properties of a type, not what Object.keys would return.

[ddurschlag]

By "see" I meant "get the IDE to tell me." Mousing over the declaration of an enum tells you it's an enum, not that it's a { [key: number]: string }. As to keyof, it certainly is dev-time, not run-time, but generally the goal is for the two to line up. In some cases that's not possible, but this seems like one where it would be. Perhaps that's also in the "feature request" category. Thanks for the explanation.