`assign` usage is confusing and types are broken.

[mctrafik]

It's unexpected that assign isn't a straight mapping to Object.assign and the differences with it and lodash are very stark. Not modifying the original object is unexpected. It functions similar to lodash's object merge, but doesn't support multiple objects.

Lastly, the types are broken. I ran into this with FastifyHelmetOptions for both args and got a typescript error Type is infinite.
The merge of A and B is just A & B in lodash which makes sense. But radashi uses:

type Assign<TInitial extends object, TOverride extends object> = TInitial extends any ? TOverride extends any ? SimplifyMutable<Omit<TInitial, keyof TOverride> & Omit<TOverride, keyof TInitial> & (Pick<TInitial, keyof TInitial & keyof TOverride> extends infer TConflictInitial ? Pick<TOverride, keyof TInitial & keyof TOverride> extends infer TConflictOverride ? {
    [K in RequiredKeys<TConflictOverride>]: AssignDeep<TConflictInitial[K & keyof TConflictInitial], TConflictOverride[K]>;
} & {
    [K in RequiredKeys<TConflictInitial> & OptionalKeys<TConflictOverride>]: AssignDeep<TConflictInitial[K], TConflictOverride[K], true>;
} & {
    [K in OptionalKeys<TConflictInitial> & OptionalKeys<TConflictOverride>]?: AssignDeep<TConflictInitial[K], TConflictOverride[K], true>;
} : unknown : unknown)> : never : never;

which I imagine fails for any recursive type.

[aleclarson]

We have type-level tests for assign here: https://github.com/radashi-org/radashi/blob/main/tests/object/assign.test-d.ts

You can run them with pnpm test-single assign.

Could you add a minimal test case for recursive types that reproduces the issue? Then you could submit a PR and I'll investigate how to solve it.

It's unexpected that assign isn't a straight mapping to Object.assign and the differences with it and lodash are very stark. Not modifying the original object is unexpected. It functions similar to lodash's object merge, but doesn't support multiple objects.

Radashi doesn't have any functions that mutate input arguments. The docs could probably be clearer about that.

Also, matching Lodash 1-for-1 is not a goal of Radashi, so you shouldn't assume your Lodash knowledge will transfer cleanly. That said, we try not to diverge from Lodash if it aligns with our design ethos.

1. Is there a reason you can't use Object.assign when mutability is desirable?
2. I'd be open to making assign take a variable number of arguments, if you want to implement it.