Proposal: `Must`

[LucienLee]

Like Required make all properties in T required.

I want to propose adding Must, which makes all properties in T NonNullable.

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

If it makes sense, I can make a PR.

[sindresorhus]

What's the use-case and how does it differ from Required?

[LucienLee]

Required only make the property not optional, but keeping null. I think that we need a way to strip null too.

See related discussion here

[sindresorhus]

Ah, that makes sense. I think this could be useful. However, I don't think the name is clear enough.

How about NonNullableDeep?

[papb]

Interesting, something that makes the value:

• Required
• Not null
• Not undefined

I would suggest StrictlyRequired, what do you think?

[kainiedziela]

Is this type supossed to nest within object properties? If so, then a Deep suffix is valid, because thats the naming pattern used throughout the project. Since the type would deeply apply NonNullable I think NonNullableDeep is the name that makes the underlying logic obvious.

[papb]

@kainiedziela You're very right, the Deep suffix is very valid! Let me change my suggestion to StrictlyRequiredDeep.

I don't think NonNullableDeep is the best because it seems to imply that the only thing happening is NonNullable being applied recursively. I'd even prefer RequiredAndNonNullableDeep or NonNullableAndRequiredDeep over NonNullableDeep, but StrictlyRequiredDeep seems to fit it well and is shorter.

[LucienLee]

I didn't think that applying NonNullable recursively at initial, but it's a good idea too. So how do you guys think about adding two types:

1. A single level NonNullable types, name as StrictlyRequired or something else
2. A recursively deep one, name as NonNullableDeep or StrictlyRequiredDeep

[papb]

@LucienLee That looks great to me.

[tjx666]

need NonNullableDeep, current version is not recursive.