Strangly behaviour that merged types

[SettingDust]

1. DeepMerged is my own type merge

/**
 * type a = unknown
 */
type a = DeepMergeHKT<Array<{ a: 1 } | { a: 'c', b: 0 }>, DeepMergeMergeFunctionsDefaultURIs, DeepMergeBuiltInMetaData>
/**
 * type b = { a: 1 | "c"; b: 0; }
 */
type b = DeepMerged<{ a: 1 } | { a: 'c', b: 0 }>

export declare type DeepMerged<T, Ignored = never> = [T] extends [UnknownArrayOrTuple]
  ? {
      [K in KeysOfUnion<T>]: DeepMerged<T[K], Ignored>
    }
  : [T] extends [Ignored | DefaultIgnore]
  ? T
  : [T] extends [object]
  ? {
      [K in KeysOfUnion<T>]: DeepMerged<GetValue<T, K>, Ignored>
    }
  : T

2. The function signature not works when input is spreaded iterable
   Support not only array but iterable for types. Such as the generic accept a union instead of array

[RebeccaStevens]

Sorry for the late reply.

I'm not sure I quite follow you. Could you give me a more full example? What's is your expected output type?

[SettingDust]

As the first shows. The { a: 1 } | { a: 'c', b: 0 } should be { a: 1 | "c"; b: 0; } but unknown

[RebeccaStevens]

Ahh, I think I know what you're referring to now.

So currently DeepMergeHKT needs a tuple in order to work out the output type. This tuple represents the order in which the parameters are passed in.

DeepMergeHKT<[{ a: 1 }, { a: "c"; b: 0 }], DeepMergeMergeFunctionsDefaultURIs, DeepMergeBuiltInMetaData> will evaluate to {a: "c"; b: 0;}, but if you swap the order of the elements, you'll get {a: 1; b: 0;}.

When an array is passed, it make sense that { a: 1 | "c"; b: 0; } should be the output type rather than unknown. I'll look into whether or not this would be an easy change to make to the current implementation.