ts-gems 2.7.4 → 2.7.6

package/lib/deep-buildable.d.ts

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

package/lib/deep-omit.d.ts

@@ -1,5 +1,6 @@
 import { IfNoDeepValue } from './helpers.js';
 import { OptionalKeys, ReadonlyKeys, RequiredKeys, WritableKeys } from './keys';
+import { OmitNever } from './omit.js';
 
 /**
  * Omit all optional properties in T deeply
@@ -7,7 +8,7 @@ import { OptionalKeys, ReadonlyKeys, RequiredKeys, WritableKeys } from './keys';
 export type DeepOmitOptional<T> = _DeepOmitOptional<Exclude<T, undefined>>;
 type _DeepOmitOptional<T, K extends keyof T = Exclude<keyof T, OptionalKeys<T>>> =
     IfNoDeepValue<T> extends true ? T
-        : { [P in K]-?: DeepOmitOptional<T[P]> };
+        : OmitNever<{ [P in K]-?: DeepOmitOptional<T[P]> }>;
 
 /**
  * Omit all optional properties in T deeply including arrays
@@ -16,7 +17,7 @@ export type HighDeepOmitOptional<T> = _HighDeepOmitOptional<Exclude<T, undefined
 type _HighDeepOmitOptional<T, K extends keyof T = Exclude<keyof T, OptionalKeys<T>>> =
     T extends (infer U)[] ? HighDeepOmitOptional<U>[]
         : IfNoDeepValue<T> extends true ? T
-            : { [P in K]-?: HighDeepOmitOptional<T[P]> };
+            : OmitNever<{ [P in K]-?: HighDeepOmitOptional<T[P]> }>;
 
 
 /**
@@ -25,7 +26,7 @@ type _HighDeepOmitOptional<T, K extends keyof T = Exclude<keyof T, OptionalKeys<
 export type DeepOmitRequired<T> = _DeepOmitRequired<Exclude<T, undefined>>;
 type _DeepOmitRequired<T, J extends keyof T = Exclude<keyof T, RequiredKeys<T>>> =
     IfNoDeepValue<T> extends true ? T
-        : { [P in J]?: DeepOmitRequired<Exclude<T[P], undefined>> };
+        : OmitNever<{ [P in J]?: DeepOmitRequired<Exclude<T[P], undefined>> }>;
 
 
 /**
@@ -35,7 +36,7 @@ export type HighDeepOmitRequired<T> = _HighDeepOmitRequired<Exclude<T, undefined
 type _HighDeepOmitRequired<T, J extends keyof T = Exclude<keyof T, RequiredKeys<T>>> =
     T extends (infer U)[] ? HighDeepOmitRequired<U>[]
         : IfNoDeepValue<T> extends true ? T
-            : { [P in J]?: HighDeepOmitRequired<Exclude<T[P], undefined>> };
+            : OmitNever<{ [P in J]?: HighDeepOmitRequired<Exclude<T[P], undefined>> }>;
 
 
 /**
@@ -44,7 +45,7 @@ type _HighDeepOmitRequired<T, J extends keyof T = Exclude<keyof T, RequiredKeys<
 export type DeepOmitReadonly<T> = _DeepOmitReadonly<Exclude<T, undefined>>;
 type _DeepOmitReadonly<T, J extends keyof T = Exclude<keyof T, ReadonlyKeys<T>>> =
     IfNoDeepValue<T> extends true ? T
-        : { [P in J]: DeepOmitReadonly<T[P]> };
+        : OmitNever<{ [P in J]: DeepOmitReadonly<T[P]> }>;
 
 
 /**
@@ -54,7 +55,7 @@ export type HighDeepOmitReadonly<T> = _HighDeepOmitReadonly<Exclude<T, undefined
 type _HighDeepOmitReadonly<T, J extends keyof T = Exclude<keyof T, ReadonlyKeys<T>>> =
     T extends (infer U)[] ? HighDeepOmitReadonly<U>[]
         : IfNoDeepValue<T> extends true ? T
-            : { [P in J]: HighDeepOmitReadonly<T[P]> };
+            : OmitNever<{ [P in J]: HighDeepOmitReadonly<T[P]> }>;
 
 
 /**
@@ -63,7 +64,7 @@ type _HighDeepOmitReadonly<T, J extends keyof T = Exclude<keyof T, ReadonlyKeys<
 export type DeepOmitWritable<T> = _DeepOmitWritable<Exclude<T, undefined>>
 type _DeepOmitWritable<T, K extends keyof T = Exclude<keyof T, WritableKeys<T>>> =
     IfNoDeepValue<T> extends true ? T
-        : { readonly [P in K]: DeepOmitWritable<T[P]> }
+        : OmitNever<{ readonly [P in K]: DeepOmitWritable<T[P]> }>
 
 
 /**
@@ -73,4 +74,4 @@ export type HighDeepOmitWritable<T> = _HighDeepOmitWritable<Exclude<T, undefined
 type _HighDeepOmitWritable<T, K extends keyof T = Exclude<keyof T, WritableKeys<T>>> =
     T extends (infer U)[] ? HighDeepOmitWritable<U>[]
         : IfNoDeepValue<T> extends true ? T
-            : { readonly [P in K]: HighDeepOmitWritable<T[P]> }
+            : OmitNever<{ readonly [P in K]: HighDeepOmitWritable<T[P]> }>

package/lib/deep-pick.d.ts

@@ -1,5 +1,6 @@
 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
@@ -7,7 +8,7 @@ import { JsonKeys, OptionalKeys, ReadonlyKeys, RequiredKeys, WritableKeys } from
 export type DeepPickOptional<T> = _DeepPickOptional<Exclude<T, undefined>>;
 type _DeepPickOptional<T, K extends keyof T = OptionalKeys<T>> =
     IfNoDeepValue<T> extends true ? T
-        : { [P in K]?: DeepPickOptional<T[P]> };
+        : OmitNever<{ [P in K]?: DeepPickOptional<T[P]> }>;
 
 /**
  * Pick all optional properties in T deeply including arrays
@@ -16,7 +17,7 @@ export type HighDeepPickOptional<T> = _HighDeepPickOptional<Exclude<T, undefined
 type _HighDeepPickOptional<T, K extends keyof T = OptionalKeys<T>> =
     T extends (infer U)[] ? HighDeepPickOptional<U>[]
         : IfNoDeepValue<T> extends true ? T
-            : { [P in K]?: HighDeepPickOptional<T[P]> };
+            : OmitNever<{ [P in K]?: HighDeepPickOptional<T[P]> }>;
 
 
 /**
@@ -25,7 +26,7 @@ type _HighDeepPickOptional<T, K extends keyof T = OptionalKeys<T>> =
 export type DeepPickRequired<T> = _DeepPickRequired<Exclude<T, undefined>>;
 type _DeepPickRequired<T, J extends keyof T = RequiredKeys<T>> =
     IfNoDeepValue<T> extends true ? T
-        : { [P in J]-?: DeepPickRequired<T[P]> };
+        : OmitNever<{ [P in J]-?: DeepPickRequired<T[P]> }>;
 
 
 /**
@@ -35,7 +36,7 @@ export type HighDeepPickRequired<T> = _HighDeepPickRequired<Exclude<T, undefined
 type _HighDeepPickRequired<T, J extends keyof T = RequiredKeys<T>> =
     T extends (infer U)[] ? HighDeepPickRequired<U>[]
         : IfNoDeepValue<T> extends true ? T
-            : { [P in J]-?: HighDeepPickRequired<T[P]> };
+            : OmitNever<{ [P in J]-?: HighDeepPickRequired<T[P]> }>;
 
 
 /**
@@ -44,7 +45,7 @@ type _HighDeepPickRequired<T, J extends keyof T = RequiredKeys<T>> =
 export type DeepPickReadonly<T> = _DeepPickReadonly<Exclude<T, undefined>>;
 type _DeepPickReadonly<T, K extends keyof T = ReadonlyKeys<T>> =
     IfNoDeepValue<T> extends true ? T
-        : { [P in K]: DeepPickReadonly<T[P]> };
+        : OmitNever<{ [P in K]: DeepPickReadonly<T[P]> }>;
 
 /**
  * Pick all readonly properties in T deeply including arrays
@@ -53,7 +54,7 @@ export type HighDeepPickReadonly<T> = _HighDeepPickReadonly<Exclude<T, undefined
 type _HighDeepPickReadonly<T, K extends keyof T = ReadonlyKeys<T>> =
     T extends (infer U)[] ? HighDeepPickReadonly<U>[]
         : IfNoDeepValue<T> extends true ? T
-            : { [P in K]: HighDeepPickReadonly<T[P]> };
+            : OmitNever<{ [P in K]: HighDeepPickReadonly<T[P]> }>;
 
 
 /**
@@ -62,7 +63,7 @@ type _HighDeepPickReadonly<T, K extends keyof T = ReadonlyKeys<T>> =
 export type DeepPickWritable<T> = _DeepPickWritable<Exclude<T, undefined>>;
 type _DeepPickWritable<T, K extends keyof T = WritableKeys<T>> =
     IfNoDeepValue<T> extends true ? T
-        : { [P in K]: DeepPickWritable<T[P]> };
+        : OmitNever<{ [P in K]: DeepPickWritable<T[P]> }>;
 
 /**
  * Pick all writable properties in T deeply including arrays
@@ -71,7 +72,7 @@ export type HighDeepPickWritable<T> = _HighDeepPickWritable<Exclude<T, undefined
 type _HighDeepPickWritable<T, K extends keyof T = WritableKeys<T>> =
     T extends (infer U)[] ? HighDeepPickWritable<U>[]
         : IfNoDeepValue<T> extends true ? T
-            : { [P in K]: HighDeepPickWritable<T[P]> };
+            : OmitNever<{ [P in K]: HighDeepPickWritable<T[P]> }>;
 
 
 /**
@@ -81,4 +82,4 @@ export type DeepPickJson<T> = _DeepPickJson<Exclude<T, undefined>>;
 type _DeepPickJson<T, Keys extends keyof T = JsonKeys<T>> =
     T extends (infer U)[] ? DeepPickJson<U>[]
         : IfNoDeepValue<T> extends true ? T
-            : { [P in Keys]: DeepPickJson<T[P]> };
+            : OmitNever<{ [P in Keys]: DeepPickJson<T[P]> }>;

package/lib/deep-readonly.d.ts

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

package/lib/deep-required.d.ts

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

package/lib/deep-writable.d.ts

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

package/lib/helpers.d.ts

@@ -8,12 +8,13 @@ export type IfNoDeepValue<T> = _IfNoDeepValue<T>
 type _IfNoDeepValue<T> =
     T extends Builtin ? true
         : IfTuple<T> extends true ? true
-            : IfClass<T> extends true ? true
-                : T extends Map<any, any> ? true
-                    : T extends ReadonlyMap<any, any> ? true
-                        : T extends WeakMap<any, any> ? true
-                            : T extends Set<any> ? true
-                                : T extends ReadonlySet<any> ? true
-                                    : T extends WeakSet<any> ? true
-                                        : T extends any[] ? true
-                                            : false;
+            : T extends Function ? true
+                : IfClass<T> extends true ? true
+                    : T extends Map<any, any> ? true
+                        : T extends ReadonlyMap<any, any> ? true
+                            : T extends WeakMap<any, any> ? true
+                                : T extends Set<any> ? true
+                                    : T extends ReadonlySet<any> ? true
+                                        : T extends WeakSet<any> ? true
+                                            : T extends any[] ? true
+                                                : false;

package/lib/index.d.ts

@@ -10,5 +10,6 @@ export * from "./deep-pick";
 export * from "./deep-readonly";
 export * from "./deep-required";
 export * from "./deep-writable";
+export * from "./helpers";
 export * from "./pick";
 export * from "./omit";

package/lib/keys.d.ts

@@ -110,3 +110,9 @@ type _KeysEquals<T, U> = ValuesOf<{
       : IfEquals<T[K], U, K, never>;
 }>;
 
+/**
+ * @desc Returns keys that property value type is not "never"
+ */
+export type NonNeverKeys<T> = ValuesOf<{
+  [K in keyof T]: K
+}>;

package/lib/omit.d.ts

@@ -6,30 +6,60 @@ import {
   WritableKeys
 } from './keys';
 
+/**
+ * OmitNever<T> is a type that omits all properties with a value of type "never".
+ *
+ * @template T - The original type
+ *
+ * @example
+ * type MyType = {
+ *   a: string;
+ *   b: number;
+ *   c?: never;
+ * };
+ *
+ * type Result = OmitNever<MyType>;
+ * // Result is:
+ * // {
+ * //   a: string;
+ * //   b: number;
+ * // }
+ */
+export type OmitNever<T> = {
+  [K in keyof T as (Exclude<T[K], undefined> extends never ? never : K)]: T[K]
+};
+
+/**
+ * Construct a type with the properties of T except for those in type K,
+ * while preserving strict type checking.
+ *
+ * @template T - The original type.
+ * @template K - The keys of the properties to be removed from the original type.
+ */
 export type StrictOmit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
 
 /**
  * Omit all optional properties in T
  */
-export type OmitOptional<T> = Omit<T, OptionalKeys<T>>;
+export type OmitOptional<T> = OmitNever<Omit<T, OptionalKeys<T>>>;
 
 /**
  * Omit all required properties in T
  */
-export type OmitRequired<T> = Omit<T, RequiredKeys<T>>;
+export type OmitRequired<T> = OmitNever<Omit<T, RequiredKeys<T>>>;
 
 /**
  * Omit all readonly properties in T
  */
-export type OmitReadonly<T> = Omit<T, ReadonlyKeys<T>>;
+export type OmitReadonly<T> = OmitNever<Omit<T, ReadonlyKeys<T>>>;
 
 
 /**
  * Omit all writable properties in T
  */
-export type OmitWritable<T> = Omit<T, WritableKeys<T>>;
+export type OmitWritable<T> = OmitNever<Omit<T, WritableKeys<T>>>;
 
 /**
  * Omit all JSON friendly properties in T
  */
-export type OmitJson<T> = Omit<T, JsonKeys<T>>;
+export type OmitJson<T> = OmitNever<Omit<T, JsonKeys<T>>>;

package/package.json

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