KnownKeys<T> breaking change in 4.3.1-rc

[jakearchibald]

Bug Report

🔎 Search Terms

KnownKeys, never, getting known interface keys

🕗 Version & Regression Information

• This changed between versions 4.3.0-beta and 4.3.1-rc

⏯ Playground Link

• 4.3.0-beta playground – types work.
• 4.4.0 playground – types fail. This issue also exists in 4.3.1-rc but that version isn't in the playground.

💻 Code

type KnownKeys<T> = {
  [K in keyof T]: string extends K ? never : number extends K ? never : K
} extends { [_ in keyof T]: infer U } ? U : never;


interface HasStringKeys {
  [s: string]: any;
}

interface ThingWithKeys extends HasStringKeys {
  foo: unknown;
  bar: unknown;
}

const demo: KnownKeys<ThingWithKeys> = 'foo';

🙁 Actual behavior

demo has type never.

🙂 Expected behavior

demo has type 'foo' | 'bar'.

Other info

I'm not sure where I got KnownKeys from, but it appears on https://stackoverflow.com/a/51956054/123395.

This issue impacted https://www.npmjs.com/package/idb, but I've already worked around the issue by using the other method on that StackOverflow post. jakearchibald/idb@e3c76a5

[jakearchibald]

For others that run into this issue, the workaround was to replace KnownKeys with:

type RemoveIndex<T> = {
  [P in keyof T as string extends P
    ? never
    : number extends P
    ? never
    : P]: T[P];
};

type KnownKeys<T> = keyof RemoveIndex<T>;

Edit: I switched to @DanielRosenwasser's version in #44143 (comment), since it's compatible with more TS versions. The workaround above caused compat issues jakearchibald/idb#223

[whzx5byb]

Another workaround:

type KnownKeys<T> = {
  [K in keyof T]: string extends K ? never 
                : number extends K ? never 
                : K
} extends infer R 
  ? R extends{[_ in keyof T]: infer U} 
    ? U 
    : never
  : never
;

[DanielRosenwasser]

Yeah, looks like there's definitely a change here, and I'm not sure exactly what is the root cause.

Here's what I came up with as a workaround.

type KeyToKeyNoIndex<T> = {
    [K in keyof T]: string extends K ? never : number extends K ? never : K;
};
type ValuesOf<T> = T extends { [K in keyof T]: infer U; } ? U : never;
type KnownKeys<T> = ValuesOf<KeyToKeyNoIndex<T>>;

interface ThingWithKeysAndIndexSignature {
    [s: string]: any;
    foo: unknown;
    bar: unknown;
}

const demo1: KnownKeys<ThingWithKeysAndIndexSignature> = 'foo';
const demo2: KnownKeys<ThingWithKeysAndIndexSignature> = 'bar';
const demo3: KnownKeys<ThingWithKeysAndIndexSignature> = 'oopsie';

[DanielRosenwasser]

Possibly related to #44126 - but I don't see how that ties into this one.