Constraints of SetOptional may make you write bad code

[kasperpeulen]

We have some code like this.

type OptionalDefaults<T, Default extends Partial<T>> = SetOptional<T, keyof Default>;

However, SetOptional would complain, as it is defined like this:

export type SetOptional<BaseType, Keys extends keyof BaseType> =

Basically, keyof Default may contain different keys than T. So anyway, I started writing this code to please the SetOptional signature (although it doesn't make any difference in practice):

type OptionalDefaults<T, Default extends Partial<T>> = SetOptional<T, Extract<keyof T, keyof Default>>;

Now I actually found this code to lead to bugs.

interface Props {
  a: string;
  b: string;
  [key: string]: unknown;
}

const defaults = { a: 'bla' };

const props: OptionalDefaults<Props, typeof defaults> = {
  // complains that a is a required key
  b: 'bla',
};

My gut feeling is that the constraint on key of SetOptional is not really worth it.
Or that we need at least also a variant without the constraint.

[papb]

Hello! Actually you have a mistake in your implementation.

Basically, keyof Default may contain different keys than T.

To be more precise: Default may contain more keys than the ones in T.

Therefore, instead of Extract<keyof T, keyof Default>, you should have used Extract<keyof Default, keyof T> (or keyof T & keyof Default).

That said, maybe your OptionalDefaults idea could be even included in type-fest!

Playground

[kasperpeulen]

Oh, that actually makes sense! Thanks for the detailed playground, which makes it all a lot clearer.

So you can always silence the constraint of SetOptional by adding & keyof T:

SetOptional<T, Whatever & keyof T>;

So in that case, adding an unconstraint SetOptional may not be necessary indeed.