Filter object properties by type

[turolla]

TypeScript Version: 3.9.2

Search Terms:
mapped type filter object properties never

Expected behavior:
The type
type FilteredKeys<T, U> = { [P in keyof T]: T[P] extends U ? P : never }[keyof T];
that allows to extract object properties by type should work everywhere.

Actual behavior:
type FilteredKeys<T, U> = { [P in keyof T]: T[P] extends U ? P : never }[keyof T];
only works externally of the declaring type

Related Issues:
#23199

Code

type FilteredKeys<T, U> = { [P in keyof T]: T[P] extends U ? P : never }[keyof T];

type FooItem<T> = T extends number ? { value: T } : undefined;

type FooMap<T> = {
    // [key in keyof T]: FooItem<T[key]>  // <-- This works
    [key in FilteredKeys<T, number>]: FooItem<T[key]>  // <-- This doesn't work
}

class Bar {
    a = 1;
    b = 2;
    c = '';    

    doSomething() {
        const fooMap: FooMap<this> = undefined!; // Omitted...
        const a = fooMap.a.value; // <-- No error expected
        const c = fooMap.c.value; // <-- Error expected
    }
}

const fooMap2: FooMap<Bar> = undefined!; // Omitted...
const a = fooMap2.a.value; // <-- No error expected
const c = fooMap2.c.value; // <-- Error expected

Output

"use strict";
class Bar {
    constructor() {
        this.a = 1;
        this.b = 2;
        this.c = '';
    }
    doSomething() {
        const fooMap = undefined; // Omitted...
        const a = fooMap.a.value; // <-- No error expected
        const c = fooMap.c.value; // <-- Error expected
    }
}
const fooMap2 = undefined; // Omitted...
const a = fooMap2.a.value; // <-- No error expected
const c = fooMap2.c.value; // <-- Error expected

Compiler Options

{
  "compilerOptions": {
    "noImplicitAny": true,
    "strictNullChecks": true,
    "strictFunctionTypes": true,
    "strictPropertyInitialization": true,
    "strictBindCallApply": true,
    "noImplicitThis": true,
    "noImplicitReturns": true,
    "useDefineForClassFields": false,
    "alwaysStrict": true,
    "allowUnreachableCode": false,
    "allowUnusedLabels": false,
    "downlevelIteration": false,
    "noEmitHelpers": false,
    "noLib": false,
    "noStrictGenericChecks": false,
    "noUnusedLocals": false,
    "noUnusedParameters": false,
    "esModuleInterop": true,
    "preserveConstEnums": false,
    "removeComments": false,
    "skipLibCheck": false,
    "checkJs": false,
    "allowJs": false,
    "declaration": true,
    "experimentalDecorators": false,
    "emitDecoratorMetadata": false,
    "target": "ES2017",
    "module": "ESNext"
  }
}

Playground Link: Provided

[RyanCavanaugh]

@weswigham thoughts?

[dumasss163]

you could do this to make it compile:

type FilteredKeys<T, U> = keyof { [P in keyof T]: T[P] extends U ? P : never };

But this still has other problem sometimes, see:
Property Type inference problem when picking property with index key type · Issue #39945 · microsoft/TypeScript

[shauns]

In 4.1 (beta) you can do something like:

type PickByValueType<T, U> = {
  [K in keyof T as T[K] extends U ? K : never]: T[K]
}

[turolla]

Key remapping is a very nice and useful feature.
Unfortunately the issue seems to be still here

https://www.typescriptlang.org/play?ts=4.1.0-dev.20200929#code/C4TwDgpgBAYg9nAksCBbAPAFQHxQLxSZQQAeKAdgCYDOU5ArqgEYQBOUA-FAN5QBuAQwA29CAC5CUAL5QJ9KhABmAS3IRKAbgCwAKF2hIsBAFkBYLLgLddUW1AD09qAG0A1hBBRVUdyDiLCAF0JeCQUDEw3D0DcByd0AFoEwgALZVoAdzhWV2obO2cAaS9yHw9-SQFaSMLA4jIIKloGZjZOKGKJNT42YKMwtCwimLioROTMNNpKOAhqcgByYCgsnN0pXV0AYyEq2gAhAXZrHTsoAXwoAEZtU7smS4AmW7Oty4WF2-zbGYBlOFQEGAaXIAHMABQASh43zOUC2cHI1GWihMZhCaPMwPSlig8koSlU6gAhBpRgB5VDKYAoSgAOgZsNeiOR50uqLgpjAdIEdMEIggZMcYySUAAcnBiKxWNl6pAtrSmXYEUjlm8CByuXStnzhKIhfFRQBRaWy0jyxV3WwbHQ27YslGYx4YzlmdCHVi4-GEtSUUkUqk09QMun21VsjVOnm6gUGkXJCVSmXsc0QBXqMOs9VQTVmR7amP60bjKAm5NytOWoA