TypeScript looses type when accessing via key

Question

I'm trying to use typed object value as key for another object, but TS seems to loose its type and evaluate it as string.

Is it by design? Are there any way to get targetObj with keys' of type SomeKey?

Link to playground

type SomeKey = "A" | "B"

const Obj = {
    "A": "A"
} as { [k in SomeKey]: SomeKey }

type A = typeof Obj.A

// TargetObj ---> { [x: string]: string } instead of { [k in SomeKey]: SomeKey }
const TargetObj = {
    [Obj.A]: "str"
}

EDIT

As Alexey L. correctly pointed out out the problem lies in difference between {[k in SomeKey]: SomeKey} and {[k in SomeKey]: k}

But can anybody explain how it works?

I think this is the same issue: https://stackoverflow.com/questions/51659420/consider-using-a-mapped-object-type-instead-whats-a-mapped-object-type-and — FunkeyFlo, Dec 24 '19 at 11:16
Can you add more context? This looks like XY problem. You could define `const Obj = { "A": "A" } as const` and it should be fine. If you need you can extract `SomeKey` from this object as well — Aleksey L., Dec 24 '19 at 11:24
If you want the value to be the same as a key, the typing should be: `const Obj = { "A": "A" } as { [Key in SomeKey]: Key }` — Aleksey L., Dec 24 '19 at 12:16
Thanks, this is interesting idea. (doesn't seem to solve problem) I just wonder how it all works under the hood. — walkthroughthecode, Dec 24 '19 at 12:19
I should clarify: works in sandbox, but doesn't work in project. Thanks for your help, Aleksey! — walkthroughthecode, Dec 24 '19 at 12:23

score 0 · Answer 1 · answered Dec 24 '19 at 16:21

In order for TypeScript to recognize your TargetObj as a { [k in SomeKey]: SomeKey } it must satisfy [k in SomeKey]. To do this, you must exhaust all possible values of SomeKey. This can only be done manually as [Obj.A]: "A" on its own cannot satisfy this. Additionally, [Obj.A]: "A", [Obj.B]: "B" won't do it either, as it cannot guarantee that they are the correct values. I tried [Obj.A as A]: "A", ... as well, but it doesn't work because, although it can guarantee the type, cannot guarantee the value.

If all you need is for the value to be the same as the key, this gets a whole lot easier as TypeScript gives you the ability to assert that they are the same.

type SomeKey = "A" | "B";

type ObjType = { [k in SomeKey]: k };

const Obj: ObjType = {
    A: "A",
    B: "B",
};

type A = typeof Obj.A;
type B = typeof Obj.B;

const TargetObj: ObjType = {
    [Obj.A]: "A",
    [Obj.B]: "B",
};

Not sure I understood what you mean. The trick is indeed was in `{ [k in someKey]: k }` instead of `{ [k in SomeKey]: SomeKey }` and it was pointed out earlier. Anyway thanks for answer! — walkthroughthecode, Dec 25 '19 at 09:37

TypeScript looses type when accessing via key

1 Answers1