NonNullable isn't narrowing down object values' types for optional properties

TypeScript Version: 3.2.0-dev.20181106

Search Terms: NonNullable object NonNullable object values

Code

Run the following code via tsc --no-emit --strict test.ts:

interface P {
  color?: 'red' | 'green';
}

type RequiredP = {
  [K in keyof P]: NonNullable<P[K]>;
}

declare const p: RequiredP;
const color: 'red' | 'green' = p.color;

Expected behavior:

The resulting type should not allow undefined for the value at a property color.

Actual behavior:

undefined is still allowed. Using the NonNullable type doesn’t seem to have any effect.

Playground Link: Note: you need to enable strictNullChecks manually! https://www.typescriptlang.org/play/#src=interface P { color%3F%3A ‘red’ | ‘green’%3B } type RequiredP %3D { [K in keyof P]%3A NonNullable<P[K]>%3B } declare const p%3A RequiredP%3B const color%3A ‘red’ | ‘green’ %3D p.color%3B

Related Issues:

[hiyelbaz]

Here is the generic version:

type DeepNonNullable<T> = {
        [P in keyof T]-?: NonNullable<T[P]>;
}

[dragomirtitian]

@mgol Let me know if I misunderstood the problem, but I think this issue is just about the fact that your RequiredP is a homomorphic mapped type. This means that the optionality of the field is preserved in RequiredP If you use -? (added by this PR) you can remove the optional modifier explicitly and all will work as expected as far as I can tell:

interface P {
  color?: 'red' | 'green';
}

type RequiredP = {
  [K in keyof P]-?: NonNullable<P[K]>;
}

declare const p: RequiredP;
const color: 'red' | 'green' = p.color; // no error, previously an error because p.color still contained undefined

play

Note: Mapped types are only homomorphic if they map over keyof T where T is any type or if they map over K where K is a type parameter extending keyof T. This is why your workarounds worked because they broke the pattern for homomorphic mapped types.