Add a new type Required

[monolithed]

It would be nice to have a new type that allows property to be required as opposited to Partial:

interface X {
    x?: string 
}

Required<X>{ }; // Property 'x is missing in type '{}'

[masaeedu]

This will probably depend on #13253 or #12215, whichever ends up getting implemented. You need a mapped type where you subtract undefined and null.

[monolithed]

Asad Saeeduddin (@masaeedu)

type Required<T> = T & {
  [P in keyof T]: T[P];
}

let a: Required<{ x: number }> = { }; // Property 'x is missing in type '{}'

it seems to work well.

[masaeedu]

AA (@monolithed) That snippet doesn't have any optional properties in the type you're passing as a type argument to Required. This corrected snippet doesn't have the expected error:

type Required<T> = T & {
  [P in keyof T]: T[P];
}

let a: Required<{ x?: number }> = { };

[monolithed]

Asad Saeeduddin (@masaeedu), oh, you're right (

[aluanhaddad]

This is what you are looking for I believe. #13224

[monolithed]

This is what you are looking for I believe. #13224

So, why the following operation [P in keyof T]: T[P] is not working as expected?

[PyroVortex]

AA (@monolithed)
The operation is a homomorphic mapping, which have been configured to preserve optional and readonly modifiers. To get the desired behavior, you would need to do:

type RequiredInternal<T, K extends keyof T> = { [P in K]: T[P] }; // Use type parameter to force it not to be considered homomorphic
type Required<T> = T & RequiredInternal<T, keyof T>;

let a: Required<{ x?: number }> = { }; // => Property 'x' is missing in type '{}'

[masaeedu]

PyroVortex No, I tried that yesterday (I think it might have been your comment on another issue). With tsc version 2.2.1, and the following files:

// tsconfig.json
{
    "compilerOptions": {
        "module": "commonjs",
        "target": "es5",
        "strictNullChecks": true,
        "noImplicitAny": false,
        "sourceMap": false
    }
}

// main.ts
type RequiredInternal<T, K extends keyof T> = { [P in K]: T[P] }; // Use type parameter to force it not to be considered homomorphic
type Required<T> = T & RequiredInternal<T, keyof T>;

let a: Required<{ x?: number }> = { }; // No error here
let x: number = a.x;                   // Error here because number | undefined is not assignable to number

The expected error does not appear, and a is typed as having a potentially undefined x property (number | undefined).

[PyroVortex]

Asad Saeeduddin (@masaeedu)
Huh. In the current version in the TypeScript Playground with strictNullChecks enabled, I get an error for the first assignment (missing property), but I do still see the error you are mentioning for the second.

In general, we lack an ability to remove a type from a union using pure type manipulation (we can do it with an actual value).

[masaeedu]

PyroVortex How did you enable strictNullChecks in playground?

[aluanhaddad]

[priithaamer]

PyroVortex Asad Saeeduddin (@masaeedu) I am too trying to create type that maps optional fields to required fields. I get the example above to raise an error with TS 2.1.4 and in the playground (which it seems to be using). From 2.1.5 and up it does not give me an error anymore. Any idea why it is so?

[thehappycoder]

This feature is very handy in react stateful components when you want to specify the default state, and you want to make sure you don't miss any state.

[mikejhill]

I'm still running into issues with this in TS 2.4.1. I've tried breaking the homomorphic relationship, as described in #13723, and I believe this does that because the fields are now required, but instead of removing all traces of optional parameters it keeps the type union with undefined. Is this intentional?

type RequiredInternal<T extends {[key: string]: any}, K extends string> = { [P in K]: T[P]};
type Required<T> = RequiredInternal<T, keyof T>;

// As expected: No compile error
const val1: Required<{x?: number}> = {x: 1};

// As expected: Compile error:
// TS2322: Type '{}' is not assignable to type 'RequiredInternal<{ x?: number | undefined; }, "x">'. Property 'x' is missing in type '{}'.
const val2: Required<{x?: number}> = {};

// Not expected?: No compile error
// Expected something like TS2322: Type '{ x: undefined; }' is not assignable to type 'RequiredInternal<{ x?: number | undefined; }, "x">'. Types of property 'x' are incompatible. Type 'undefined' is not assignable to type 'number'.
const val3: Required<{x?: number}> = {x: undefined};