feat: added DeepPartial<T> mapped type

README.md

@@ -93,6 +93,7 @@ This gives you the power to prioritize our work and support project contributors
 * [`DeepReadonly<T>`](#deepreadonlyt)
 * [`DeepRequired<T>`](#deeprequiredt)
 * [`DeepNonNullable<T>`](#deepnonnullablet)
+* [`DeepPartial<T>`](#deeppartialt)
 
 ## Flow's Utility Types
 
@@ -554,6 +555,36 @@ type RequiredNestedProps = DeepNonNullable<NestedProps>;
 
 ---
 
+### `DeepPartial<T>`
+
+Partial that works for deeply nested structures
+
+**Usage:**
+
+```ts
+import { DeepPartial } from 'utility-types';
+
+type NestedProps = {
+  first: {
+    second: {
+      name: string;
+    };
+  };
+};
+type PartialNestedProps = DeepPartial<NestedProps>;
+// Expect: {
+//   first?: {
+//     second?: {
+//       name?: string;
+//     };
+//   };
+// }
+```
+
+[⇧ back to top](#mapped-types)
+
+---
+
 ## Flow's Utility Types
 
 ### `$Keys<T>`

src/__snapshots__/mapped-types.spec.ts.snap

@@ -24,6 +24,24 @@ exports[`DeepNonNullable testType<DeepNonNullable<NestedProps>['first']['second'
 
 exports[`DeepNonNullable testType<DeepNonNullable<NestedProps>['first']['second']['name']>() 1`] = `"string"`;
 
+exports[`DeepPartial testType<ReturnType<NonNullable<typeof functionProp>>>() 1`] = `"string"`;
+
+exports[`DeepPartial testType<typeof arrayItem.name>() 1`] = `"string | undefined"`;
+
+exports[`DeepPartial testType<typeof arrayProp>() 1`] = `"_DeepPartialArray<{ name: string; }> | undefined"`;
+
+exports[`DeepPartial testType<typeof functionProp>() 1`] = `"((value: number) => string) | undefined"`;
+
+exports[`DeepPartial testType<typeof name>() 1`] = `"string | undefined"`;
+
+exports[`DeepPartial testType<typeof nestedArrayPartial.first>() 1`] = `"_DeepPartialObject<{ second: { name: string; }[]; }> | undefined"`;
+
+exports[`DeepPartial testType<typeof nestedFunctionPartial.first>() 1`] = `"_DeepPartialObject<{ second: (value: number) => string; }> | undefined"`;
+
+exports[`DeepPartial testType<typeof partialNested.first>() 1`] = `"_DeepPartialObject<{ second: { name: string; }; }> | undefined"`;
+
+exports[`DeepPartial testType<typeof second>() 1`] = `"_DeepPartialObject<{ name: string; }> | undefined"`;
+
 exports[`DeepReadonly testType<DeepReadonly<NestedArrayProps>['first']>() 1`] = `"_DeepReadonlyObject<{ second: { name: string; }[]; }>"`;
 
 exports[`DeepReadonly testType<DeepReadonly<NestedArrayProps>['first']['second']>() 1`] = `"_DeepReadonlyArray<{ name: string; }>"`;

src/index.ts

@@ -22,6 +22,7 @@ export {
   DeepReadonly,
   DeepRequired,
   DeepNonNullable,
+  DeepPartial,
   Diff,
   FunctionKeys,
   Intersection,

src/mapped-types.spec.snap.ts

@@ -20,12 +20,15 @@ import {
   DeepReadonly,
   DeepRequired,
   DeepNonNullable,
+  DeepPartial,
   _DeepNonNullableArray,
   _DeepNonNullableObject,
   _DeepReadonlyArray,
   _DeepReadonlyObject,
   _DeepRequiredArray,
   _DeepRequiredObject,
+  _DeepPartialObject,
+  _DeepPartialArray,
 } from './mapped-types';
 
 /**
@@ -279,3 +282,58 @@ it('DeepNonNullable', () => {
     ReturnType<DeepNonNullable<NestedFunctionProps>['first']['second']>
   >();
 });
+
+// @dts-jest:group DeepPartial
+it('DeepPartial', () => {
+  type NestedProps = {
+    first: {
+      second: {
+        name: string;
+      };
+    };
+  };
+  const partialNested: DeepPartial<NestedProps> = {} as any;
+  // @dts-jest:pass:snap -> _DeepPartialObject<{ second: { name: string; }; }> | undefined
+  testType<typeof partialNested.first>();
+
+  const second = partialNested.first!.second;
+  // @dts-jest:pass:snap -> _DeepPartialObject<{ name: string; }> | undefined
+  testType<typeof second>();
+
+  const name = second!.name;
+  // @dts-jest:pass:snap -> string | undefined
+  testType<typeof name>();
+
+  type NestedArrayProps = {
+    first: {
+      second: Array<{ name: string }>;
+    };
+  };
+
+  const nestedArrayPartial: DeepPartial<NestedArrayProps> = {};
+  // @dts-jest:pass:snap -> _DeepPartialObject<{ second: { name: string; }[]; }> | undefined
+  testType<typeof nestedArrayPartial.first>();
+
+  const arrayProp = nestedArrayPartial.first!.second;
+  // @dts-jest:pass:snap -> _DeepPartialArray<{ name: string; }> | undefined
+  testType<typeof arrayProp>();
+
+  const arrayItem = arrayProp![0];
+  // @dts-jest:pass:snap -> string | undefined
+  testType<typeof arrayItem.name>();
+
+  type NestedFunctionProps = {
+    first: {
+      second: (value: number) => string;
+    };
+  };
+  const nestedFunctionPartial: DeepPartial<NestedFunctionProps> = {};
+  // @dts-jest:pass:snap -> _DeepPartialObject<{ second: (value: number) => string; }> | undefined
+  testType<typeof nestedFunctionPartial.first>();
+
+  const functionProp = nestedFunctionPartial.first!.second;
+  // @dts-jest:pass:snap -> ((value: number) => string) | undefined
+  testType<typeof functionProp>();
+  // @dts-jest:pass:snap -> string
+  testType<ReturnType<NonNullable<typeof functionProp>>>();
+});

src/mapped-types.spec.ts

@@ -20,12 +20,15 @@ import {
   DeepReadonly,
   DeepRequired,
   DeepNonNullable,
+  DeepPartial,
   _DeepNonNullableArray,
   _DeepNonNullableObject,
   _DeepReadonlyArray,
   _DeepReadonlyObject,
   _DeepRequiredArray,
   _DeepRequiredObject,
+  _DeepPartialObject,
+  _DeepPartialArray,
 } from './mapped-types';
 
 /**
@@ -279,3 +282,58 @@ it('DeepNonNullable', () => {
     ReturnType<DeepNonNullable<NestedFunctionProps>['first']['second']>
   >();
 });
+
+// @dts-jest:group DeepPartial
+it('DeepPartial', () => {
+  type NestedProps = {
+    first: {
+      second: {
+        name: string;
+      };
+    };
+  };
+  const partialNested: DeepPartial<NestedProps> = {} as any;
+  // @dts-jest:pass:snap
+  testType<typeof partialNested.first>();
+
+  const second = partialNested.first!.second;
+  // @dts-jest:pass:snap
+  testType<typeof second>();
+
+  const name = second!.name;
+  // @dts-jest:pass:snap
+  testType<typeof name>();
+
+  type NestedArrayProps = {
+    first: {
+      second: Array<{ name: string }>;
+    };
+  };
+
+  const nestedArrayPartial: DeepPartial<NestedArrayProps> = {};
+  // @dts-jest:pass:snap
+  testType<typeof nestedArrayPartial.first>();
+
+  const arrayProp = nestedArrayPartial.first!.second;
+  // @dts-jest:pass:snap
+  testType<typeof arrayProp>();
+
+  const arrayItem = arrayProp![0];
+  // @dts-jest:pass:snap
+  testType<typeof arrayItem.name>();
+
+  type NestedFunctionProps = {
+    first: {
+      second: (value: number) => string;
+    };
+  };
+  const nestedFunctionPartial: DeepPartial<NestedFunctionProps> = {};
+  // @dts-jest:pass:snap
+  testType<typeof nestedFunctionPartial.first>();
+
+  const functionProp = nestedFunctionPartial.first!.second;
+  // @dts-jest:pass:snap
+  testType<typeof functionProp>();
+  // @dts-jest:pass:snap
+  testType<ReturnType<NonNullable<typeof functionProp>>>();
+});

src/mapped-types.ts

@@ -204,3 +204,20 @@ export interface _DeepNonNullableArray<T>
 export type _DeepNonNullableObject<T> = {
   [P in keyof T]-?: DeepNonNullable<NonNullable<T[P]>>
 };
+
+/**
+ * DeepPartial
+ * @desc Partial that works for deeply nested structure
+ */
+export type DeepPartial<T> =
+  T extends Function ? T :
+  T extends Array<infer U> ? _DeepPartialArray<U> :
+  T extends object ? _DeepPartialObject<T> :
+  T | undefined;
+/** @private */
+// tslint:disable-next-line:class-name
+export interface _DeepPartialArray<T> extends Array<DeepPartial<T>> { }
+/** @private */
+export type _DeepPartialObject<T> = {
+  [P in keyof T]?: DeepPartial<T[P]>;
+};