fix(assign): typing Issues and add type-safety tests

src/object/assign.ts

@@ -1,5 +1,20 @@
 import { isPlainObject } from 'radashi'
 
+export type GenericObject = Record<string | symbol | number, any>
+export type MergeDeep<A, B> = {
+  [K in keyof A | keyof B]: K extends keyof B
+    ? K extends keyof A
+      ? A[K] extends GenericObject
+        ? B[K] extends GenericObject
+          ? MergeDeep<A[K], B[K]>
+          : B[K]
+        : B[K]
+      : B[K]
+    : K extends keyof A
+      ? A[K]
+      : never
+}
+
 /**
  * Create a copy of the first object, and then merge the second object
  * into it recursively. Only plain objects are recursively merged.
@@ -14,10 +29,10 @@ import { isPlainObject } from 'radashi'
  * // => { a: 1, b: 2, c: 3, p: { a: 4, b: 5 } }
  * ```
  */
-export function assign<X extends Record<string | symbol | number, any>>(
+export function assign<X extends GenericObject, Y extends GenericObject>(
   initial: X,
-  override: X,
-): X {
+  override: Y,
+): MergeDeep<X, Y> {
   if (!initial || !override) {
     return initial ?? override ?? {}
   }

tests/object/assign.test-d.ts

@@ -0,0 +1,57 @@
+import * as _ from 'radashi'
+import { expectTypeOf } from 'vitest'
+
+describe('assign types', () => {
+  test('should return merged types', () => {
+    const obj = _.assign({ a: 1, b: '2', c: true }, { d: 4, e: '5' })
+    expectTypeOf(obj).toMatchTypeOf<{
+      a: number
+      b: string
+      c: boolean
+      d: number
+      e: string
+    }>()
+  })
+
+  test('should return merged types with nested objects', () => {
+    const initial = {
+      a: {
+        b: 'c',
+      },
+    }
+    const override = {
+      a: {
+        c: 'e',
+      },
+      d: '2',
+    }
+
+    const obj = _.assign(initial, override)
+
+    expectTypeOf(obj).toEqualTypeOf<{
+      a: { b: string; c: string }
+      d: string
+    }>()
+  })
+
+  test('should override types', () => {
+    const initial = {
+      a: 1,
+      b: '2',
+      c: true,
+    }
+    const override = {
+      a: true,
+      b: 2,
+      c: { d: 4 },
+    }
+
+    const obj = _.assign(initial, override)
+
+    expectTypeOf(obj).toEqualTypeOf<{
+      a: boolean
+      b: number
+      c: { d: number }
+    }>()
+  })
+})