SharedUnionFieldsDeep with undefined in Union

[ocadoret]

SharedUnionFieldsDeep doesn't work with Union that have undefined.

For example :

type Cat = {
  type: 'cat';
  name: string;
  catType: string;
};

type Dog = {
  type: 'dog';
  name: string;
  dogType: string;
};

type Pet = SharedUnionFieldsDeep<Cat | Dog>;
// type Pet = {
//   type: "cat" | "dog";
//   name: string;
// }

type OptionalPet = SharedUnionFieldsDeep<Cat | Dog | undefined>;
// type OptionalPet = Cat | Dog | undefined

Here, OptionalPet keeps the full union, but we might expect the following output :

type OptionalPet = SharedUnionFieldsDeep<Cat | Dog | undefined>;
// type Pet = {
//   type: "cat" | "dog";
//   name: string;
// } | undefined

Upvote & Fund

• We're using Polar.sh so you can upvote and help fund this issue.
• The funding will be given to active contributors.
• Thank you in advance for helping prioritize & fund our backlog.

[fregante]

I think it's reasonable to handle invalid types yourself before passing them to a function. I'd think Parameters<SomeFunc | undefined> also fails the same way for example.

[Emiyaaaaa]

I don't think this is a problem, it makes sense to merge public fields only if the original types is consistent, like if they are both an object.

[ocadoret]

I see your point. I thought that it might be a good addition with an option like recurseIntoArrays (maybe allowUndefinedInUnion ?).
Especially with complex and deep types :

type A = {
  a: number;
  b: string;
  c: { d: string; e: number } | { d: string; f: string } | undefined;
}

With this example, it would be quite powerful to have something like this :

type SharedUnionA = SharedUnionFieldsDeep<A, {allowUndefinedInUnion: true}>;
// type SharedUnionA = {
//   a: number;
//   b: string;
//   c: { d: string } | undefined;
// }

Which is correct since as soon as c is defined, then d is string.