KeysOfUnion: Fix assignability with keyof

[som-sm]

Fixes #1008

To make keyof T assignable to KeysOfUnion<T>, we can simply add an union with keyof ObjectType to the existing type, as shown below.

type KeysOfUnion<ObjectType> =
 | keyof ObjectType
 | ObjectType extends unknown ? keyof ObjectType : never;

However, I couldn’t find a straightforward way to prevent KeysOfUnion<T> from being assignable to keyof T. So, I reworked the implementation to use UnionToIntersection, which resolves both issues.

---

There's another hack I figured out while experimenting, this also solves both the issues, but it's very hacky:

type KeysOfUnion<ObjectType> =
  | keyof ObjectType // Convinces TS that keyof T is part of KeysOfUnion<T>
  | ObjectType extends unknown ? keyof ObjectType: never
  | Extract<Uppercase<string>, Lowercase<ObjectType & string>>; // Convinces TS that KeysOfUnion<T> is broader than keyof T

// keyof T should be assignable to KeysOfUnion<T>
type Assignability2<T, K extends KeysOfUnion<T>> = unknown;
type Test2<T> = Assignability2<T, keyof T>; // doesn't error now

// KeysOfUnion<T> should not be assignable to keyof T
type Assignability1<T, K extends keyof T> = unknown;
type Test1<T> = Assignability1<T, KeysOfUnion<T>>; // does error now

Playground

[Emiyaaaaa]

Is there a way not hack?

[som-sm]

Could be, but I couldn't figure out anything else.

Do you have any ideas or suggestions?

[sindresorhus]

I think it's fine to do this for now until we come up with a better solution.

[som-sm]

Yeah, I agree!
And this is probably a bug, refer this comment.

[som-sm]

Also, removed intersection with KeysOfUnions as it's not required after this fix, refer db0ce32.

[Emiyaaaaa]

add test:

type Assignability1<T extends UnknownRecord, K extends keyof T> = unknown;
type Test1<T extends UnknownRecord> = Assignability1<T, KeysOfUnion<T>>; // should error

[som-sm]

@Emiyaaaaa The test you suggested doesn’t seem to produce an error:

type Assignability5<T extends UnknownRecord, _K extends keyof T> = unknown;
type Test5<T extends UnknownRecord> = Assignability5<T, KeysOfUnion<T>>; // Doesn't error

However, adding slightly different constraints does produce the expected error:

type Assignability5<T extends Record<string, unknown>, _K extends keyof T> = unknown;
// @ts-expect-error
type Test5<T extends Record<string, unknown>> = Assignability5<T, KeysOfUnion<T>>; // Does error

type Assignability5<T extends object, _K extends keyof T> = unknown;
// @ts-expect-error
type Test5<T extends object> = Assignability5<T, KeysOfUnion<T>>; // Does error

Unsure what's happening here, any ideas?

[Emiyaaaaa]

I don't have idea right now, maybe it's a bug of Typescript I'm not sure. I'll try to look into this interesting issue later

[sindresorhus]

tsd has some flaws with type checking, try assertions using expect-type instead: https://github.com/mmkal/expect-type

[som-sm]

@sindresorhus These tests don't use either tsd or expect-type, they are just simple generics, like this:

type Assignability5<T extends Record<string, unknown>, _K extends keyof T> = unknown;
// @ts-expect-error
type Test5<T extends Record<string, unknown>> = Assignability5<T, KeysOfUnion<T>>; // Does error

[sindresorhus]

Ok, maybe just add your tests, and then add type Assignability5<T extends UnknownRecord, _K extends keyof T> = unknown; type Test5<T extends UnknownRecord> = Assignability5<T, KeysOfUnion<T>>; // Doesn't error commented out with a comment that says that they don't produce error even though they should.

[som-sm]

Yup makes sense, added all the above mentioned cases and some more, refer 2629884.