ts-gems 3.9.0 → 3.11.0

package/lib/dto.d.ts

@@ -1,6 +1,6 @@
 import { IfNoDeepValue } from './helpers.js';
-import { DeepNullish } from './nullish.js';
-import { DeepPartial } from './partial.js';
+import { DeeperNullish } from './nullish.js';
+import { DeeperPartial } from './partial.js';
 import { IfNever } from './type-check.js';
 
 /**
@@ -9,17 +9,17 @@ import { IfNever } from './type-check.js';
  */
 export type DTO<T> = {
   [K in keyof T as IfNever<
-    Exclude<T[K], undefined | Function>,
+    Exclude<NonNullable<T[K]> | Function>,
     never,
     K
-  >]: Exclude<T[K], undefined | null> extends (infer U)[] // Deep process arrays
+  >]: NonNullable<T[K]> extends (infer U)[] // Deep process arrays
     ? DTO<U>[]
     : // Do not deep process No-Deep values
-      IfNoDeepValue<Exclude<T[K], undefined | null>> extends true
-      ? Exclude<T[K], undefined | null>
+      IfNoDeepValue<NonNullable<T[K]>> extends true
+      ? NonNullable<T[K]>
       : // Deep process objects
-        DTO<Exclude<T[K], undefined | null>>;
+        DTO<NonNullable<T[K]>>;
 };
 
-export type PartialDTO<T> = DeepPartial<DTO<T>>;
-export type PatchDTO<T> = DeepNullish<DTO<T>>;
+export type PartialDTO<T> = DeeperPartial<DTO<T>>;
+export type PatchDTO<T> = DeeperNullish<DTO<T>>;

package/lib/mutable.d.ts

@@ -33,7 +33,7 @@ export type DeepMutable<T> = {
   >]: IfNoDeepValue<Exclude<T[K], undefined>> extends true // Do not deep process No-Deep values
     ? T[K]
     : // Deep process objects
-      DeepMutable<Exclude<T[K], undefined>>;
+      DeepMutable<NonNullable<T[K]>>;
 };
 
 /**
@@ -47,10 +47,10 @@ export type DeeperMutable<T> = {
   >]: Exclude<T[K], undefined> extends (infer U)[] // Deep process arrays
     ? DeeperMutable<U>[]
     : // Do not deep process No-Deep values
-      IfNoDeepValue<Exclude<T[K], undefined>> extends true
+      IfNoDeepValue<NonNullable<T[K]>> extends true
       ? T[K]
       : // Deep process objects
-        DeeperMutable<Exclude<T[K], undefined>>;
+        DeeperMutable<NonNullable<T[K]>>;
 };
 
 /**

package/lib/non-nullable.d.ts

@@ -37,10 +37,10 @@ export type DeeperUnNullish<T> = {
     Exclude<T[K], undefined>,
     never,
     IfNull<Exclude<T[K], undefined>, never, K>
-  >]: NonNullable<Exclude<T[K], undefined>> extends (infer U)[]
+  >]: NonNullable<NonNullable<T[K]>> extends (infer U)[]
     ? DeeperUnNullish<U>[]
     : // Do not deep process No-Deep values
-      IfNoDeepValue<Exclude<T[K], undefined>> extends true
+      IfNoDeepValue<NonNullable<T[K]>> extends true
       ? NonNullable<T[K]>
       : // Deep process objects
         DeeperUnNullish<NonNullable<T[K]>>;

package/lib/nullish.d.ts

@@ -18,7 +18,7 @@ export type DeepNullish<T> = {
   > extends true
     ? T[K] | null
     : // Deep process objects
-      DeepNullish<Exclude<T[K], undefined>> | null;
+      DeepNullish<NonNullable<T[K]>> | null;
 };
 
 /**
@@ -32,8 +32,8 @@ export type DeeperNullish<T> = {
   > extends (infer U)[]
     ? DeeperNullish<U>[] | null
     : // Do not deep process No-Deep values
-      IfNoDeepValue<Exclude<T[K], undefined>> extends true
+      IfNoDeepValue<NonNullable<T[K]>> extends true
       ? T[K] | null
       : // Deep process objects
-        DeeperNullish<Exclude<T[K], undefined>> | null;
+        DeeperNullish<NonNullable<T[K]>> | null;
 };

package/lib/omit-never.d.ts

@@ -30,26 +30,25 @@ export type OmitNever<T> = {
 export type DeepOmitNever<T> = {
   [K in keyof T as IfNever<Exclude<T[K], undefined>, never, K>]: IfNoDeepValue<
     // Do not deep process No-Deep values
-    Exclude<T[K], undefined>
+    NonNullable<T[K]>
   > extends true
     ? T[K]
     : // Deep process objects
-      DeepOmitNever<Exclude<T[K], undefined>>;
+      DeepOmitNever<NonNullable<T[K]>>;
 };
 
 /**
  * Omit all "never" and "undefined" properties in T deeply including arrays
  */
 export type DeeperOmitNever<T> = {
-  [K in keyof T as IfNever<Exclude<T[K], undefined>, never, K>]: Exclude<
+  [K in keyof T as IfNever<Exclude<T[K], undefined>, never, K>]: NonNullable<
     // Deep process arrays
-    T[K],
-    undefined
+    T[K]
   > extends (infer U)[]
     ? DeeperOmitNever<U>[]
     : // Do not deep process No-Deep values
-      IfNoDeepValue<Exclude<T[K], undefined>> extends true
+      IfNoDeepValue<NonNullable<T[K]>> extends true
       ? T[K]
       : // Deep process objects
-        DeeperOmitNever<Exclude<T[K], undefined>>;
+        DeeperOmitNever<NonNullable<T[K]>>;
 };

package/lib/omit-undefined.d.ts

@@ -25,15 +25,13 @@ export type DeepOmitUndefined<T> = {
  * Omit all "never" and "undefined" properties in T deeply including arrays
  */
 export type DeeperOmitUndefined<T> = {
-  [K in keyof T as IfNever<Exclude<T[K], undefined>, never, K>]: Exclude<
-    // Deep process arrays
-    T[K],
-    undefined
-  > extends (infer U)[]
+  [K in keyof T as IfNever<Exclude<T[K], undefined>, never, K>]: NonNullable<
+    T[K]
+  > extends (infer U)[] // Deep process arrays
     ? DeeperOmitUndefined<U>[]
     : // Do not deep process No-Deep values
-      IfNoDeepValue<Exclude<T[K], undefined>> extends true
+      IfNoDeepValue<NonNullable<T[K]>> extends true
       ? T[K]
       : // Deep process objects
-        DeeperOmitUndefined<Exclude<T[K], undefined>>;
+        DeeperOmitUndefined<NonNullable<T[K]>>;
 };

package/lib/omit.d.ts

@@ -18,7 +18,7 @@ export type OmitFunctions<T> = {
     // Omit never keys
     IfNever<Exclude<T[K], undefined>>,
     // Omit functions
-    IfFunction<Exclude<T[K], undefined>>
+    IfFunction<NonNullable<T[K]>>
   > extends true
     ? never
     : K]: T[K];
@@ -45,7 +45,7 @@ export type DeepOmitTypes<T, X> = {
   >]: IfNoDeepValue<Exclude<T[K], undefined>> extends true // Do not deep process No-Deep values
     ? Exclude<T[K], X>
     : // Deep process objects
-      DeepOmitTypes<Exclude<T[K], undefined>, X>;
+      DeepOmitTypes<NonNullable<T[K]>, X>;
 };
 
 /**
@@ -58,8 +58,8 @@ export type DeeperOmitTypes<T, X> = {
     undefined
   > extends (infer U)[]
     ? DeeperOmitTypes<U, X>[]
-    : IfNoDeepValue<Exclude<T[K], undefined>> extends true
+    : IfNoDeepValue<NonNullable<T[K]>> extends true
       ? Exclude<T[K], X>
       : // Deep process objects
-        DeeperOmitTypes<Exclude<T[K], undefined>, X>;
+        DeeperOmitTypes<NonNullable<T[K]>, X>;
 };

package/lib/partial.d.ts

@@ -25,7 +25,7 @@ export type DeepPartial<T> = {
   > extends true
     ? T[K]
     : // Deep process objects
-      DeepPartial<Exclude<T[K], undefined>>;
+      DeepPartial<NonNullable<T[K]>>;
 };
 
 /**
@@ -39,10 +39,10 @@ export type DeeperPartial<T> = {
   > extends (infer U)[]
     ? DeeperPartial<U>[]
     : // Do not deep process No-Deep values
-      IfNoDeepValue<Exclude<T[K], undefined>> extends true
+      IfNoDeepValue<NonNullable<T[K]>> extends true
       ? T[K]
       : // Deep process objects
-        DeeperPartial<Exclude<T[K], undefined>>;
+        DeeperPartial<NonNullable<T[K]>>;
 };
 
 /**

package/lib/pick.d.ts

@@ -31,7 +31,7 @@ export type PickFunctions<T> = {
     // Omit never keys
     IfNever<Exclude<T[K], undefined>>,
     // Omit non functions
-    IfFunction<Exclude<T[K], undefined>, false, true>
+    IfFunction<NonNullable<T[K]>, false, true>
   > extends true
     ? never
     : K]: T[K];

package/lib/readonly.d.ts

@@ -83,10 +83,10 @@ export type DeepPickReadonly<T> = {
     IfEquals<{ [Q in K]: T[K] }, { readonly [Q in K]: T[K] }, false, true>
   > extends true
     ? never
-    : K]: IfNoDeepValue<Exclude<T[K], undefined>> extends true // Do not deep process No-Deep values
+    : K]: IfNoDeepValue<NonNullable<T[K]>> extends true // Do not deep process No-Deep values
     ? T[K]
     : // Deep process objects
-      DeepPickReadonly<Exclude<T[K], undefined>>;
+      DeepPickReadonly<NonNullable<T[K]>>;
 };
 
 /**
@@ -95,15 +95,15 @@ export type DeepPickReadonly<T> = {
 export type DeepOmitReadonly<T> = {
   [K in keyof T as Or<
     // Omit never keys
-    IfNever<Exclude<T[K], undefined>>,
+    IfNever<NonNullable<T[K]>>,
     // Omit required
     IfEquals<{ [Q in K]: T[K] }, { readonly [Q in K]: T[K] }>
   > extends true
     ? never
-    : K]: IfNoDeepValue<Exclude<T[K], undefined>> extends true // Do not deep process No-Deep values
+    : K]: IfNoDeepValue<NonNullable<T[K]>> extends true // Do not deep process No-Deep values
     ? T[K]
     : // Deep process objects
-      DeepOmitReadonly<Exclude<T[K], undefined>>;
+      DeepOmitReadonly<NonNullable<T[K]>>;
 };
 
 /**
@@ -117,13 +117,13 @@ export type DeeperPickReadonly<T> = {
     IfEquals<{ [Q in K]: T[K] }, { readonly [Q in K]: T[K] }, false, true>
   > extends true
     ? never
-    : K]: Exclude<T[K], undefined> extends (infer U)[] // Deep process arrays
+    : K]: NonNullable<T[K]> extends (infer U)[] // Deep process arrays
     ? DeeperPickReadonly<U>[]
     : // Do not deep process No-Deep values
-      IfNoDeepValue<Exclude<T[K], undefined>> extends true
+      IfNoDeepValue<NonNullable<T[K]>> extends true
       ? T[K]
       : // Deep process objects
-        DeeperPickReadonly<Exclude<T[K], undefined>>;
+        DeeperPickReadonly<NonNullable<T[K]>>;
 };
 
 /**
@@ -137,11 +137,11 @@ export type DeeperOmitReadonly<T> = {
     IfEquals<{ [Q in K]: T[K] }, { readonly [Q in K]: T[K] }>
   > extends true
     ? never
-    : K]: Exclude<T[K], undefined> extends (infer U)[] // Deep process arrays
+    : K]: NonNullable<T[K]> extends (infer U)[] // Deep process arrays
     ? DeeperOmitReadonly<U>[]
     : // Do not deep process No-Deep values
-      IfNoDeepValue<Exclude<T[K], undefined>> extends true
+      IfNoDeepValue<NonNullable<T[K]>> extends true
       ? T[K]
       : // Deep process objects
-        DeeperOmitReadonly<Exclude<T[K], undefined>>;
+        DeeperOmitReadonly<NonNullable<T[K]>>;
 };

package/lib/required.d.ts

@@ -30,14 +30,12 @@ export type DeepRequired<T> = {
  * Make all properties in T required deeply including arrays
  */
 export type DeeperRequired<T> = {
-  [K in keyof T as IfNever<Exclude<T[K], undefined>, never, K>]-?: Exclude<
-    // Deep process arrays
-    T[K],
-    undefined
-  > extends (infer U)[]
+  [K in keyof T as IfNever<Exclude<T[K], undefined>, never, K>]-?: NonNullable<
+    T[K]
+  > extends (infer U)[] // Deep process arrays
     ? DeeperRequired<U>[]
     : // Do not deep process No-Deep values
-      IfNoDeepValue<Exclude<T[K], undefined>> extends true
+      IfNoDeepValue<NonNullable<T[K]>> extends true
       ? Exclude<T[K], undefined>
       : // Deep process objects
         DeepRequired<Exclude<T[K], undefined>>;
@@ -88,7 +86,7 @@ export type DeepPickRequired<T> = {
     IfEquals<{ [Q in K]: T[K] }, { [Q in K]?: T[K] }>
   > extends true
     ? never
-    : K]: IfNoDeepValue<Exclude<T[K], undefined>> extends true // Do not deep process No-Deep values
+    : K]: IfNoDeepValue<NonNullable<T[K]>> extends true // Do not deep process No-Deep values
     ? T[K]
     : // Deep process objects
       DeepPickRequired<Exclude<T[K], undefined>>;
@@ -105,7 +103,7 @@ export type DeepOmitRequired<T> = {
     IfEquals<{ [Q in K]: T[K] }, { [Q in K]-?: T[K] }>
   > extends true
     ? never
-    : K]?: IfNoDeepValue<Exclude<T[K], undefined>> extends true // Do not deep process No-Deep values
+    : K]?: IfNoDeepValue<NonNullable<T[K]>> extends true // Do not deep process No-Deep values
     ? T[K]
     : // Deep process objects
       DeepOmitRequired<Exclude<T[K], undefined>>;
@@ -122,10 +120,10 @@ export type DeeperPickRequired<T> = {
     IfEquals<{ [Q in K]: T[K] }, { [Q in K]?: T[K] }>
   > extends true
     ? never
-    : K]: Exclude<T[K], undefined> extends (infer U)[] // Deep process arrays
+    : K]: NonNullable<T[K]> extends (infer U)[] // Deep process arrays
     ? DeeperPickRequired<U>[]
     : // Do not deep process No-Deep values
-      IfNoDeepValue<Exclude<T[K], undefined>> extends true
+      IfNoDeepValue<NonNullable<T[K]>> extends true
       ? T[K]
       : // Deep process objects
         DeeperPickRequired<Exclude<T[K], undefined>>;
@@ -142,10 +140,10 @@ export type DeeperOmitRequired<T> = {
     IfEquals<{ [Q in K]: T[K] }, { [Q in K]-?: T[K] }>
   > extends true
     ? never
-    : K]: Exclude<T[K], undefined> extends (infer U)[] // Deep process arrays
+    : K]: NonNullable<T[K]> extends (infer U)[] // Deep process arrays
     ? DeeperOmitRequired<U>[]
     : // Do not deep process No-Deep values
-      IfNoDeepValue<Exclude<T[K], undefined>> extends true
+      IfNoDeepValue<NonNullable<T[K]>> extends true
       ? T[K]
       : // Deep process objects
         DeeperOmitRequired<Exclude<T[K], undefined>>;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "ts-gems",
   "description": "Valuable typing extensions for TypeScript",
-  "version": "3.9.0",
+  "version": "3.11.0",
   "license": "MIT",
   "module": "./lib/index.mjs",
   "main": "./lib/index.cjs",