feat(type): add DeepPick utility type (#146)

* feat(type): add `DeepPick` utility type

* chore: update `DeepPick` utility type

Author: halvaradop

src/object-types.ts

@@ -540,3 +540,26 @@ export type Get<T, K extends string> = K extends keyof T
     : K extends `${infer Char extends keyof T & string}.${infer Substr}`
       ? Get<T[Char], Substr>
       : never
+
+/**
+ * Picks the properties of an object at any depth based on the provided pattern.
+ *
+ * @example
+ * interface User {
+ *   name: string,
+ *   address: {
+ *     street: string,
+ *     avenue: string
+ *   }
+ * }
+ *
+ * // Expected: { address: { street: string } }
+ * type UserPick = DeepPick<User, "address.street">
+ */
+export type DeepPick<Obj, Pattern> = Pattern extends `${infer Left}.${infer Right}`
+    ? Left extends keyof Obj
+        ? DeepPick<Obj[Left], Right>
+        : unknown
+    : Pattern extends keyof Obj
+      ? Obj[Pattern]
+      : unknown

test/object-types.test.ts

@@ -385,3 +385,44 @@ describe("Get", () => {
         >().toEqualTypeOf<number>()
     })
 })
+
+describe("DeepPick", () => {
+    test("Pick properties from nested objects", () => {
+        type Obj = {
+            foo: string
+            bar: number
+            foobar: {
+                foofoo: number
+                barbar: boolean
+                foo: {
+                    bar: string
+                    foobar: number
+                    barfoo: {
+                        foobar: string
+                        bar: number
+                    }
+                }
+            }
+        }
+
+        expectTypeOf<utilities.DeepPick<Obj, "foo">>().toEqualTypeOf<string>()
+        expectTypeOf<utilities.DeepPick<Obj, "bar">>().toEqualTypeOf<number>()
+        expectTypeOf<utilities.DeepPick<Obj, "foobar">>().toEqualTypeOf<{
+            foofoo: number
+            barbar: boolean
+            foo: {
+                bar: string
+                foobar: number
+                barfoo: {
+                    foobar: string
+                    bar: number
+                }
+            }
+        }>()
+        expectTypeOf<utilities.DeepPick<Obj, "foobar.barbar">>().toEqualTypeOf<boolean>()
+        expectTypeOf<utilities.DeepPick<Obj, "foobar.foo.barfoo">>().toEqualTypeOf<{
+            foobar: string
+            bar: number
+        }>()
+    })
+})