ts-gems 2.9.0 → 2.9.2

package/lib/deep-buildable.d.ts

@@ -1,20 +1,20 @@
+import { DeepOmitNever, HighDeepOmitNever } from './deep-omit.js';
 import { IfNoDeepValue } from './helpers.js';
-import { OmitNever } from './omit.js';
 
 /**
  * Combination of Partial and Writable but deeply
  */
-export type DeepBuildable<T> = _DeepBuildable<T>;
+export type DeepBuildable<T> = DeepOmitNever<_DeepBuildable<T>>;
 type _DeepBuildable<T> =
     IfNoDeepValue<T> extends true ? T
-        : OmitNever<{ -readonly [P in keyof T]?: _DeepBuildable<Exclude<T[P], undefined>> }>;
+        : { -readonly [P in keyof T]?: _DeepBuildable<Exclude<T[P], undefined>> };
 
 /**
  * Combination of Partial and Writable but deeply including arrays
  */
-export type HighDeepBuildable<T> = _HighDeepBuildable<T>;
+export type HighDeepBuildable<T> = HighDeepOmitNever<_HighDeepBuildable<T>>;
 type _HighDeepBuildable<T> =
     T extends (infer U)[] ? _HighDeepBuildable<U>[]
         : IfNoDeepValue<T> extends true ? T
             : T extends (infer U)[] ? _HighDeepBuildable<U>[]
-                : OmitNever<{ -readonly [P in keyof T]?: _HighDeepBuildable<Exclude<T[P], undefined>> }>;
+                : { -readonly [P in keyof T]?: _HighDeepBuildable<Exclude<T[P], undefined>> };

package/lib/deep-omit.d.ts

@@ -1,95 +1,94 @@
 import { IfNoDeepValue } from './helpers.js';
 import { OptionalKeys, ReadonlyKeys, RequiredKeys, WritableKeys } from './keys';
-import { OmitNever } from './omit.js';
 
 /**
  * Omit all optional properties in T deeply
  */
-export type DeepOmitOptional<T> = _DeepOmitOptional<Exclude<T, undefined>>;
+export type DeepOmitOptional<T> = DeepOmitNever<_DeepOmitOptional<T>>;
 type _DeepOmitOptional<T, K extends keyof T = Exclude<keyof T, OptionalKeys<T>>> =
     IfNoDeepValue<T> extends true ? T
-        : OmitNever<{ [P in K]-?: DeepOmitOptional<T[P]> }>;
+        : { [P in K]-?: _DeepOmitOptional<Exclude<T[P], undefined>> };
 
 /**
  * Omit all optional properties in T deeply including arrays
  */
-export type HighDeepOmitOptional<T> = _HighDeepOmitOptional<Exclude<T, undefined>>;
+export type HighDeepOmitOptional<T> = HighDeepOmitNever<_HighDeepOmitOptional<T>>;
 type _HighDeepOmitOptional<T, K extends keyof T = Exclude<keyof T, OptionalKeys<T>>> =
-    T extends (infer U)[] ? HighDeepOmitOptional<U>[]
+    T extends (infer U)[] ? _HighDeepOmitOptional<U>[]
         : IfNoDeepValue<T> extends true ? T
-            : OmitNever<{ [P in K]-?: HighDeepOmitOptional<T[P]> }>;
+            : { [P in K]-?: _HighDeepOmitOptional<Exclude<T[P], undefined>> };
 
 
 /**
  * Omit all required properties in T deeply
  */
-export type DeepOmitRequired<T> = _DeepOmitRequired<Exclude<T, undefined>>;
+export type DeepOmitRequired<T> = DeepOmitNever<_DeepOmitRequired<T>>;
 type _DeepOmitRequired<T, J extends keyof T = Exclude<keyof T, RequiredKeys<T>>> =
     IfNoDeepValue<T> extends true ? T
-        : OmitNever<{ [P in J]?: DeepOmitRequired<Exclude<T[P], undefined>> }>;
+        : { [P in J]?: _DeepOmitRequired<Exclude<T[P], undefined>> };
 
 
 /**
  * Omit all required properties in T deeply including arrays
  */
-export type HighDeepOmitRequired<T> = _HighDeepOmitRequired<Exclude<T, undefined>>;
+export type HighDeepOmitRequired<T> = HighDeepOmitNever<_HighDeepOmitRequired<T>>;
 type _HighDeepOmitRequired<T, J extends keyof T = Exclude<keyof T, RequiredKeys<T>>> =
-    T extends (infer U)[] ? HighDeepOmitRequired<U>[]
+    T extends (infer U)[] ? _HighDeepOmitRequired<U>[]
         : IfNoDeepValue<T> extends true ? T
-            : OmitNever<{ [P in J]?: HighDeepOmitRequired<Exclude<T[P], undefined>> }>;
+            : { [P in J]?: _HighDeepOmitRequired<Exclude<T[P], undefined>> };
 
 
 /**
  * Omit all readonly properties in T deeply
  */
-export type DeepOmitReadonly<T> = _DeepOmitReadonly<Exclude<T, undefined>>;
+export type DeepOmitReadonly<T> = DeepOmitNever<_DeepOmitReadonly<Exclude<T, undefined>>>;
 type _DeepOmitReadonly<T, J extends keyof T = Exclude<keyof T, ReadonlyKeys<T>>> =
     IfNoDeepValue<T> extends true ? T
-        : OmitNever<{ [P in J]: DeepOmitReadonly<T[P]> }>;
+        : { [P in J]: _DeepOmitReadonly<Exclude<T[P], undefined>> };
 
 
 /**
  * Omit all readonly properties in T deeply including arrays
  */
-export type HighDeepOmitReadonly<T> = _HighDeepOmitReadonly<Exclude<T, undefined>>;
+export type HighDeepOmitReadonly<T> = HighDeepOmitNever<_HighDeepOmitReadonly<T>>;
 type _HighDeepOmitReadonly<T, J extends keyof T = Exclude<keyof T, ReadonlyKeys<T>>> =
-    T extends (infer U)[] ? HighDeepOmitReadonly<U>[]
+    T extends (infer U)[] ? _HighDeepOmitReadonly<U>[]
         : IfNoDeepValue<T> extends true ? T
-            : OmitNever<{ [P in J]: HighDeepOmitReadonly<T[P]> }>;
+            : { [P in J]: _HighDeepOmitReadonly<Exclude<T[P], undefined>> };
 
 
 /**
  * Omit all writable properties in T deeply
  */
-export type DeepOmitWritable<T> = _DeepOmitWritable<Exclude<T, undefined>>
+export type DeepOmitWritable<T> = DeepOmitNever<_DeepOmitWritable<T>>
 type _DeepOmitWritable<T, K extends keyof T = Exclude<keyof T, WritableKeys<T>>> =
     IfNoDeepValue<T> extends true ? T
-        : OmitNever<{ readonly [P in K]: DeepOmitWritable<T[P]> }>
+        : { readonly [P in K]: _DeepOmitWritable<Exclude<T[P], undefined>> }
 
 
 /**
  * Omit all writable properties in T deeply including arrays
  */
-export type HighDeepOmitWritable<T> = _HighDeepOmitWritable<Exclude<T, undefined>>
+export type HighDeepOmitWritable<T> = HighDeepOmitNever<_HighDeepOmitWritable<T>>
 type _HighDeepOmitWritable<T, K extends keyof T = Exclude<keyof T, WritableKeys<T>>> =
-    T extends (infer U)[] ? HighDeepOmitWritable<U>[]
+    T extends (infer U)[] ? _HighDeepOmitWritable<U>[]
         : IfNoDeepValue<T> extends true ? T
-            : OmitNever<{ readonly [P in K]: HighDeepOmitWritable<T[P]> }>
+            : { readonly [P in K]: _HighDeepOmitWritable<Exclude<T[P], undefined>> }
 
 /**
  * Omit all "never" and "undefined" properties in T deeply
  */
-export type DeepOmitNever<T> = _DeepOmitNever<Exclude<T, undefined>>
+export type DeepOmitNever<T> = _DeepOmitNever<T>
 type _DeepOmitNever<T> =
     IfNoDeepValue<T> extends true ? T
-        : { [P in keyof T as (Exclude<T[P], undefined> extends never ? never : P)]: DeepOmitNever<T[P]> }
+        : { [P in keyof T as (Exclude<T[P], undefined> extends never ? never : P)]: _DeepOmitNever<Exclude<T[P], undefined>> }
 
 
 /**
  * Omit all "never" and "undefined" properties in T deeply including arrays
  */
-export type HighDeepOmitNever<T> = _HighDeepOmitNever<Exclude<T, undefined>>
+export type HighDeepOmitNever<T> = _HighDeepOmitNever<T>
 type _HighDeepOmitNever<T> =
-    T extends (infer U)[] ? HighDeepOmitNever<U>[]
+    T extends (infer U)[] ? _HighDeepOmitNever<U>[]
         : IfNoDeepValue<T> extends true ? T
-            : { [P in keyof T as (Exclude<T[P], undefined> extends never ? never : P)]: HighDeepOmitNever<T[P]> }
+            : { [P in keyof T as (Exclude<T[P], undefined> extends never ? never : P)]: _HighDeepOmitNever<Exclude<T[P], undefined>> }

package/lib/deep-pick.d.ts

@@ -1,85 +1,85 @@
+import { DeepOmitNever, HighDeepOmitNever } from './deep-omit.js';
 import { IfNoDeepValue } from './helpers.js';
 import { JsonKeys, OptionalKeys, ReadonlyKeys, RequiredKeys, WritableKeys } from './keys';
-import { OmitNever } from './omit.js';
 
 /**
  * Pick all optional properties in T deeply
  */
-export type DeepPickOptional<T> = _DeepPickOptional<Exclude<T, undefined>>;
+export type DeepPickOptional<T> = DeepOmitNever<_DeepPickOptional<T>>;
 type _DeepPickOptional<T, K extends keyof T = OptionalKeys<T>> =
     IfNoDeepValue<T> extends true ? T
-        : OmitNever<{ [P in K]?: DeepPickOptional<T[P]> }>;
+        : { [P in K]?: _DeepPickOptional<Exclude<T[P], undefined>> };
 
 /**
  * Pick all optional properties in T deeply including arrays
  */
-export type HighDeepPickOptional<T> = _HighDeepPickOptional<Exclude<T, undefined>>;
+export type HighDeepPickOptional<T> = HighDeepOmitNever<_HighDeepPickOptional<T>>;
 type _HighDeepPickOptional<T, K extends keyof T = OptionalKeys<T>> =
-    T extends (infer U)[] ? HighDeepPickOptional<U>[]
+    T extends (infer U)[] ? _HighDeepPickOptional<U>[]
         : IfNoDeepValue<T> extends true ? T
-            : OmitNever<{ [P in K]?: HighDeepPickOptional<T[P]> }>;
+            : { [P in K]?: _HighDeepPickOptional<Exclude<T[P], undefined>> };
 
 
 /**
  * Pick all required properties in T deeply
  */
-export type DeepPickRequired<T> = _DeepPickRequired<Exclude<T, undefined>>;
+export type DeepPickRequired<T> = DeepOmitNever<_DeepPickRequired<T>>;
 type _DeepPickRequired<T, J extends keyof T = RequiredKeys<T>> =
     IfNoDeepValue<T> extends true ? T
-        : OmitNever<{ [P in J]-?: DeepPickRequired<T[P]> }>;
+        : { [P in J]-?: _DeepPickRequired<Exclude<T[P], undefined>> };
 
 
 /**
  * Pick all required properties in T deeply including arrays
  */
-export type HighDeepPickRequired<T> = _HighDeepPickRequired<Exclude<T, undefined>>;
+export type HighDeepPickRequired<T> = HighDeepOmitNever<_HighDeepPickRequired<T>>;
 type _HighDeepPickRequired<T, J extends keyof T = RequiredKeys<T>> =
-    T extends (infer U)[] ? HighDeepPickRequired<U>[]
+    T extends (infer U)[] ? _HighDeepPickRequired<U>[]
         : IfNoDeepValue<T> extends true ? T
-            : OmitNever<{ [P in J]-?: HighDeepPickRequired<T[P]> }>;
+            : { [P in J]-?: _HighDeepPickRequired<Exclude<T[P], undefined>> };
 
 
 /**
  * Pick all readonly properties in T deeply
  */
-export type DeepPickReadonly<T> = _DeepPickReadonly<Exclude<T, undefined>>;
+export type DeepPickReadonly<T> = DeepOmitNever<_DeepPickReadonly<T>>;
 type _DeepPickReadonly<T, K extends keyof T = ReadonlyKeys<T>> =
     IfNoDeepValue<T> extends true ? T
-        : OmitNever<{ [P in K]: DeepPickReadonly<T[P]> }>;
+        : { [P in K]: _DeepPickReadonly<Exclude<T[P], undefined>> };
 
 /**
  * Pick all readonly properties in T deeply including arrays
  */
-export type HighDeepPickReadonly<T> = _HighDeepPickReadonly<Exclude<T, undefined>>;
+export type HighDeepPickReadonly<T> = HighDeepOmitNever<_HighDeepPickReadonly<T>>;
 type _HighDeepPickReadonly<T, K extends keyof T = ReadonlyKeys<T>> =
-    T extends (infer U)[] ? HighDeepPickReadonly<U>[]
+    T extends (infer U)[] ? _HighDeepPickReadonly<U>[]
         : IfNoDeepValue<T> extends true ? T
-            : OmitNever<{ [P in K]: HighDeepPickReadonly<T[P]> }>;
+            : { [P in K]: _HighDeepPickReadonly<Exclude<T[P], undefined>> };
 
 
 /**
  * Pick all writable properties in T deeply
  */
-export type DeepPickWritable<T> = _DeepPickWritable<Exclude<T, undefined>>;
+export type DeepPickWritable<T> = DeepOmitNever<_DeepPickWritable<T>>;
 type _DeepPickWritable<T, K extends keyof T = WritableKeys<T>> =
     IfNoDeepValue<T> extends true ? T
-        : OmitNever<{ [P in K]: DeepPickWritable<T[P]> }>;
+        : { [P in K]: _DeepPickWritable<Exclude<T[P], undefined>> };
 
 /**
  * Pick all writable properties in T deeply including arrays
  */
-export type HighDeepPickWritable<T> = _HighDeepPickWritable<Exclude<T, undefined>>;
+export type HighDeepPickWritable<T> = HighDeepOmitNever<_HighDeepPickWritable<T>>;
 type _HighDeepPickWritable<T, K extends keyof T = WritableKeys<T>> =
-    T extends (infer U)[] ? HighDeepPickWritable<U>[]
+    T extends (infer U)[] ? _HighDeepPickWritable<U>[]
         : IfNoDeepValue<T> extends true ? T
-            : OmitNever<{ [P in K]: HighDeepPickWritable<T[P]> }>;
+            : { [P in K]: _HighDeepPickWritable<Exclude<T[P], undefined>> };
 
 
 /**
  * Pick all JSON friendly properties in T deeply
  */
-export type DeepPickJson<T> = _DeepPickJson<Exclude<T, undefined>>;
+export type DeepPickJson<T> = DeepOmitNever<_DeepPickJson<T>>;
 type _DeepPickJson<T, Keys extends keyof T = JsonKeys<T>> =
-    T extends (infer U)[] ? DeepPickJson<U>[]
+    T extends (infer U)[] ? _DeepPickJson<U>[]
         : IfNoDeepValue<T> extends true ? T
-            : OmitNever<{ [P in Keys]: DeepPickJson<T[P]> }>;
+            : { [P in Keys]: _DeepPickJson<Exclude<T[P], undefined>> };

package/lib/deep-readonly.d.ts

@@ -1,20 +1,20 @@
+import { DeepOmitNever, HighDeepOmitNever } from './deep-omit.js';
 import { IfNoDeepValue } from './helpers.js';
-import { OmitNever } from './omit.js';
 
 /**
  * Make all properties in T readonly deeply
  */
-export type DeepReadonly<T> = _DeepReadonly<T>;
+export type DeepReadonly<T> = DeepOmitNever<_DeepReadonly<T>>;
 type _DeepReadonly<T> =
     IfNoDeepValue<T> extends true ? T
-        : OmitNever<{ readonly [P in keyof T]: _DeepReadonly<T[P]> }>;
+        : { readonly [P in keyof T]: _DeepReadonly<T[P]> };
 
 /**
  * Make all properties in T readonly deeply
  */
-export type HighDeepReadonly<T> = _HighDeepReadonly<T>;
+export type HighDeepReadonly<T> = HighDeepOmitNever<_HighDeepReadonly<T>>;
 type _HighDeepReadonly<T> =
     T extends (infer U)[] ? _HighDeepReadonly<U>[]
         : IfNoDeepValue<T> extends true ? T
-            : OmitNever<{ readonly [P in keyof T]: _HighDeepReadonly<T[P]> }>;
+            : { readonly [P in keyof T]: _HighDeepReadonly<T[P]> };
 

package/lib/deep-remove-nulls.d.ts

@@ -1,20 +1,20 @@
+import { DeepOmitNever, HighDeepOmitNever } from './deep-omit.js';
 import { IfNoDeepValue } from './helpers.js';
-import { OmitNever } from './omit.js';
 
 /**
  * Remove null from properties deeply
  */
-export type DeepRemoveNulls<T> = _DeepRemoveNulls<T>;
+export type DeepRemoveNulls<T> = DeepOmitNever<_DeepRemoveNulls<T>>;
 type _DeepRemoveNulls<T> =
     IfNoDeepValue<T> extends true ? T
-        : OmitNever<{ [P in keyof T]: _DeepRemoveNulls<Exclude<T[P], null>> }>;
+        : { [P in keyof T]: _DeepRemoveNulls<Exclude<T[P], null>> };
 
 
 /**
  * Remove null from properties deeply including arrays
  */
-export type HighDeepRemoveNulls<T> = _HighDeepRemoveNulls<T>;
+export type HighDeepRemoveNulls<T> = HighDeepOmitNever<_HighDeepRemoveNulls<T>>;
 type _HighDeepRemoveNulls<T> =
     T extends (infer U)[] ? _HighDeepRemoveNulls<U>[]
         : IfNoDeepValue<T> extends true ? T
-            : OmitNever<{ [P in keyof T]: _HighDeepRemoveNulls<Exclude<T[P], null>> }>;
+            : { [P in keyof T]: _HighDeepRemoveNulls<Exclude<T[P], null>> };

package/lib/deep-required.d.ts

@@ -1,20 +1,20 @@
+import { DeepOmitNever, HighDeepOmitNever } from './deep-omit.js';
 import { IfNoDeepValue } from './helpers.js';
-import { OmitNever } from './omit.js';
 
 /**
  * Make all properties in T required deeply
  */
-export type DeepRequired<T> = _DeepRequired<T>;
+export type DeepRequired<T> = DeepOmitNever<_DeepRequired<T>>;
 type _DeepRequired<T> =
     IfNoDeepValue<T> extends true ? T
-        : OmitNever<{ [P in keyof T]-?: _DeepRequired<Exclude<T[P], undefined>> }>;
+        : { [P in keyof T]-?: _DeepRequired<Exclude<T[P], undefined>> };
 
 
 /**
  * Make all properties in T required deeply including arrays
  */
-export type HighDeepRequired<T> = _HighDeepRequired<T>;
+export type HighDeepRequired<T> = HighDeepOmitNever<_HighDeepRequired<T>>;
 type _HighDeepRequired<T> =
     T extends (infer U)[] ? _HighDeepRequired<U>[]
         : IfNoDeepValue<T> extends true ? T
-            : OmitNever<{ [P in keyof T]-?: _HighDeepRequired<Exclude<T[P], undefined>> }>;
+            : { [P in keyof T]-?: _HighDeepRequired<Exclude<T[P], undefined>> };

package/lib/deep-writable.d.ts

@@ -1,20 +1,20 @@
+import { DeepOmitNever, HighDeepOmitNever } from './deep-omit.js';
 import { IfNoDeepValue } from './helpers.js';
-import { OmitNever } from './omit.js';
 
 /**
  * Make all properties in T writable deeply
  */
-export type DeepWritable<T> = _DeepWritable<T>;
+export type DeepWritable<T> = DeepOmitNever<_DeepWritable<T>>;
 type _DeepWritable<T> =
     IfNoDeepValue<T> extends true ? T
-        : OmitNever<{ -readonly [P in keyof T]: _DeepWritable<T[P]> }>;
+        : { -readonly [P in keyof T]: _DeepWritable<T[P]> };
 
 
 /**
  * Make all properties in T writable deeply including arrays
  */
-export type HighDeepWritable<T> = _HighDeepWritable<T>;
+export type HighDeepWritable<T> = HighDeepOmitNever<_HighDeepWritable<T>>;
 type _HighDeepWritable<T> =
     T extends (infer U)[] ? _HighDeepWritable<U>[]
         : IfNoDeepValue<T> extends true ? T
-            : OmitNever<{ -readonly [P in keyof T]: _HighDeepWritable<T[P]> }>;
+            : { -readonly [P in keyof T]: _HighDeepWritable<T[P]> };

package/package.json

@@ -12,7 +12,7 @@
     "lodash",
     "underscore"
   ],
-  "version": "2.9.0",
+  "version": "2.9.2",
   "types": "lib/index.d.ts",
   "main": "lib/index.js",
   "module": "lib/index.js",