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

[alvis]

In 4.1, as @shauns mentioned, you can filter out object keys which don't fit the type you want. However, unfortunately, it still can't give you a list of keys which comply with the desired type by the conventional key of trick. i.e. The following doesn't work:

type SelectKeysByValueType<T, U> = {
  [K in keyof T as T[K] extends U ? K : never]: T[K]
}[keyof T] // <~ Type 'keyof T' cannot be used to index type

See also #40833

[ziofat]

Any updates on this issue?

I have a similar issue here:

https://www.typescriptlang.org/play?ts=4.2.3#code/C4TwDgpgBAcg9gOwGIFcEGNgEtEEMA2APACoB8UAvFAN4CwAUFE1ANoDSUWCUA1hCHABmUYlFwBnEewC6UCAA9gEBABNJqDNkRQA-FAQQAbhABOUAFxQ20ywFF56fChUQSMgDRQNmHAlIBuBgBfBgYuJRNBXHRoAGFEQSwAcxoGZn1cAFsIS3FgEy4kwMZmdAJ8ACNonksACgBKSnJDOCwVYvTMrHlLCrg4fAhcbgAfKFqGpqg+gaGEeuKQ+gZHCUkAWWHcJNNCWLlFZTUoeIREpPI6EqZ0RDyTFEw4E1rbs+TLeGQ0HzwiWNIjSu6XSb3EswAdPg4ElXglkhCEFkIAs0iCbndIdDYW9zhCyvhKtVUdcQWCsTC4e8khCuvISeklksGEA

[pascalgn]

As a workaround, I think this could work:

type OriginalType = {
    str: string;
    num: number;
}

type Values<T> = T[keyof T];

type PickKeys<T, U> = Values<{
  [K in keyof T]: T[K] extends U ? K : never;
}>;

type NumberKeys = PickKeys<OriginalType, number>;
type NumberType = Pick<OriginalType, NumberKeys>;

const ok: NumberType = { num: 1 }; // ok
const err: NumberType = { num: 1, str: "" }; // error

With the original example rewritten:

type FooMap<T> = {
    [key in PickKeys<T, number>]: T[key]
}

const ok1: FooMap<OriginalType> = { num: 1 }; // ok
const err2: FooMap<OriginalType> = { num: 1, str: "" }; // error

[aspic-fish]

I have a workaround, just infer type before mapping it.
So rewrite this:

type FooMap<T> = {
    [key in FilteredKeys<T, number>]: FooItem<T[key]> 
}

to this:

type FooMap<T> = T extends infer TT 
  ?  {
    [key in FilteredKeys<T, number>]: FooItem<T[key]>
  }
  : never

turolla case

ziofat case

[turolla]

I have a workaround, just infer type before mapping it. So rewrite this:

type FooMap<T> = {
    [key in FilteredKeys<T, number>]: FooItem<T[key]> 
}

to this:

type FooMap<T> = T extends infer TT 
  ?  {
    [key in FilteredKeys<T, number>]: FooItem<T[key]>
  }
  : never

turolla case

ziofat case

@aspic-fish YOU ARE A GENIUS !!!! Thank you so much!!!

[edvald]

Here's a solution we found to work for us (in this case omitting as opposed to picking), including a recursive option:

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

type OmitByValueType<T, V> = T extends infer _
  ? {
      [key in OmitKeysByValueType<T, V>]: T[key]
    }
  : never

type OmitByValueTypeRecursive<T, V> = T extends object
  ? T extends infer _
    ? {
        [key in OmitKeysByValueType<T, V>]: OmitByValueTypeRecursive<T[key], V>
      }
    : never
  : T

Usage:

interface A {
  someFunctionIDoNotWant: () => void // <- get rid of this
  somePropIDoWant: number
}

interface B {
  prop: string
  prop2: A
}

type AMinusFunctions = OmitByValueType<A, Function>
// -> { somePropIDoWant: true }

type BMinusFunctionsRecursively = OmitByValueTypeRecursive<B, Function>
// -> { prop: string; prop2: {  somePropIDoWant: true } }

cc @Orzelius

[RyanCavanaugh]

A few observations:

• The nonworking form isn't something we can analyze for an arbitrary type parameter like this and get the right answer in the general case
• The working form... works?
• Looks like there are other workarounds too

The real missing feature is #48992 to handle this in a more analyzable form, so I think we can treat this as a duplicate of that one

[typescript-bot]

This issue has been marked as a 'Duplicate' and has seen no recent activity. It has been automatically closed for house-keeping purposes.