ts-gems 2.7.0 → 2.7.1

package/lib/deep-nullish.d.ts

@@ -7,7 +7,7 @@ import { IsDeepExcluded } from './helpers.js';
 export type DeepNullish<T> = _DeepNullish<DeepRequired<T>>;
 type _DeepNullish<T> =
     IsDeepExcluded<T> extends true ? T
-        : { [P in keyof T]: _DeepNullish<Exclude<T[P], undefined>> | null | undefined };
+        : { [P in keyof T]?: _DeepNullish<Exclude<T[P], undefined>> | null };
 
 
 /**
@@ -17,5 +17,5 @@ export type HighDeepNullish<T> = _HighDeepNullish<HighDeepRequired<T>>;
 type _HighDeepNullish<T> =
     T extends (infer U)[] ? _HighDeepNullish<U>[]
         : IsDeepExcluded<T> extends true ? T
-            : { [P in keyof T]: _HighDeepNullish<Exclude<T[P], undefined>> | null | undefined };
+            : { [P in keyof T]?: _HighDeepNullish<Exclude<T[P], undefined>> | null };
 

package/lib/deep-omit.d.ts

@@ -4,73 +4,73 @@ import { OptionalKeys, ReadonlyKeys, RequiredKeys, WritableKeys } from './keys';
 /**
  * Omit all optional properties in T deeply
  */
-export type DeepOmitOptional<T> = _DeepOmitOptional<T>;
+export type DeepOmitOptional<T> = _DeepOmitOptional<Exclude<T, undefined>>;
 type _DeepOmitOptional<T, K extends keyof T = Exclude<keyof T, OptionalKeys<T>>> =
     IsDeepExcluded<T> extends true ? T
-        : { [P in K]: _DeepOmitOptional<Exclude<T[P], undefined>> };
+        : { [P in K]-?: DeepOmitOptional<T[P]> };
 
 /**
  * Omit all optional properties in T deeply including arrays
  */
-export type HighDeepOmitOptional<T> = _HighDeepOmitOptional<T>;
+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>[]
+    T extends (infer U)[] ? HighDeepOmitOptional<U>[]
         : IsDeepExcluded<T> extends true ? T
-            : { [P in K]: _HighDeepOmitOptional<Exclude<T[P], undefined>> };
+            : { [P in K]-?: HighDeepOmitOptional<T[P]> };
 
 
 /**
  * Omit all required properties in T deeply
  */
-export type DeepOmitRequired<T> = _DeepOmitRequired<T>;
+export type DeepOmitRequired<T> = _DeepOmitRequired<Exclude<T, undefined>>;
 type _DeepOmitRequired<T, J extends keyof T = Exclude<keyof T, RequiredKeys<T>>> =
     IsDeepExcluded<T> extends true ? T
-        : { [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<T>;
+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>[]
+    T extends (infer U)[] ? HighDeepOmitRequired<U>[]
         : IsDeepExcluded<T> extends true ? T
-            : { [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<T>;
+export type DeepOmitReadonly<T> = _DeepOmitReadonly<Exclude<T, undefined>>;
 type _DeepOmitReadonly<T, J extends keyof T = Exclude<keyof T, ReadonlyKeys<T>>> =
     IsDeepExcluded<T> extends true ? T
-        : { [P in J]: _DeepOmitReadonly<Exclude<T[P], undefined>> };
+        : { [P in J]: DeepOmitReadonly<T[P]> };
 
 
 /**
  * Omit all readonly properties in T deeply including arrays
  */
-export type HighDeepOmitReadonly<T> = _HighDeepOmitReadonly<T>;
+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>[]
+    T extends (infer U)[] ? HighDeepOmitReadonly<U>[]
         : IsDeepExcluded<T> extends true ? T
-            : { [P in J]: _HighDeepOmitReadonly<Exclude<T[P], undefined>> };
+            : { [P in J]: HighDeepOmitReadonly<T[P]> };
 
 
 /**
  * Omit all writable properties in T deeply
  */
-export type DeepOmitWritable<T> = _DeepOmitWritable<T>
+export type DeepOmitWritable<T> = _DeepOmitWritable<Exclude<T, undefined>>
 type _DeepOmitWritable<T, K extends keyof T = Exclude<keyof T, WritableKeys<T>>> =
     IsDeepExcluded<T> extends true ? T
-        : { [P in K]: _DeepOmitWritable<Exclude<T[P], undefined>> }
+        : { readonly [P in K]: DeepOmitWritable<T[P]> }
 
 
 /**
  * Omit all writable properties in T deeply including arrays
  */
-export type HighDeepOmitWritable<T> = _HighDeepOmitWritable<T>
+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>[]
+    T extends (infer U)[] ? HighDeepOmitWritable<U>[]
         : IsDeepExcluded<T> extends true ? T
-            : { [P in K]: _HighDeepOmitWritable<Exclude<T[P], undefined>> }
+            : { readonly [P in K]: HighDeepOmitWritable<T[P]> }

package/lib/deep-pick.d.ts

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

package/lib/deep-readonly.d.ts

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

package/lib/deep-writable.d.ts

@@ -6,7 +6,7 @@ import { IsDeepExcluded } from './helpers.js';
 export type DeepWritable<T> = _DeepWritable<T>;
 type _DeepWritable<T> =
     IsDeepExcluded<T> extends true ? T
-        : { -readonly [P in keyof T]: _DeepWritable<Exclude<T[P], undefined>> };
+        : { -readonly [P in keyof T]: _DeepWritable<T[P]> };
 
 
 /**
@@ -16,4 +16,4 @@ export type HighDeepWritable<T> = _HighDeepWritable<T>;
 type _HighDeepWritable<T> =
     T extends (infer U)[] ? _HighDeepWritable<U>[]
         : IsDeepExcluded<T> extends true ? T
-            : { -readonly [P in keyof T]: _HighDeepWritable<Exclude<T[P], undefined>> };
+            : { -readonly [P in keyof T]: _HighDeepWritable<T[P]> };

package/lib/keys.d.ts

@@ -16,7 +16,8 @@ export type ValuesOf<T> = T[keyof T];
  * RequiredKeys
  * @desc Returns required keys of an object
  */
-export type RequiredKeys<T> = {
+export type RequiredKeys<T> = _RequiredKeys<T>
+export type _RequiredKeys<T> = {
   [K in keyof T]-?: IfUndefined<T[K]> extends true
       ? never
       : T extends { [K1 in K]: any } ? K : never
@@ -26,7 +27,8 @@ export type RequiredKeys<T> = {
  * OptionalKeys
  * @desc Returns optional keys of an object
  */
-export type OptionalKeys<T> = {
+export type OptionalKeys<T> = _OptionalKeys<T>
+export type _OptionalKeys<T> = {
   [K in keyof T]-?: IfUndefined<T[K]> extends true
       ? never
       : T extends { [K1 in K]: any } ? never : K
@@ -40,11 +42,6 @@ export type ReadonlyKeys<T> = {
   [K in keyof T]-?: IfEquals<{ [Q in K]: T[K] }, { -readonly [Q in K]: T[K] }, never, K>
 }[keyof T];
 
-/**
- * @desc Returns non function keys of an object
- */
-export type NonFunctionKeys<T> = Exclude<keyof T, FunctionKeys<T>>;
-
 
 /**
  * @desc Returns JSON friendly keys of an object
@@ -63,7 +60,9 @@ type _JsonKeys<T, J = Required<T>> = ValuesOf<{
 /**
  * @desc Returns writable keys of an object
  */
-export type WritableKeys<T> = Exclude<keyof T, ReadonlyKeys<T>>;
+export type WritableKeys<T> = {
+  [K in keyof T]-?: IfEquals<{ [Q in K]: T[K] }, { readonly [Q in K]: T[K] }, never, K>
+}[keyof T];
 
 
 /**
@@ -83,6 +82,18 @@ export type FunctionKeys<T> = ValuesOf<{
               : never : never : never;
 }>;
 
+/**
+ * @desc Returns non function keys of an object
+ */
+export type NonFunctionKeys<T> =  ValuesOf<{
+  [K in keyof T]-?: IfUndefined<T[K]> extends false ?
+      IfAny<T[K]> extends false ?
+          T[K] extends Function ? never
+              : K : K : K;
+}>;
+
+
+
 /**
  * @desc Returns keys that match given type
  */

package/lib/type-check.d.ts

@@ -20,6 +20,11 @@ export type IfNever<T, Y = true, N = false> =
 export type IfUndefined<T, Y = true, N = false> =
     IfEquals<T, undefined, Y, N>;
 
+// export type IfUndefined<T, Y = true, N = false> =
+//     IfEquals<T, undefined, Y, N> extends Y ? Y
+//         : undefined extends T ? Y : N;
+
+
 /**
  * Returns Y if typeof T is "unknown", N otherwise
  */

package/package.json

@@ -12,7 +12,7 @@
     "lodash",
     "underscore"
   ],
-  "version": "2.7.0",
+  "version": "2.7.1",
   "types": "lib/index.d.ts",
   "main": "lib/index.js",
   "module": "lib/index.js",
@@ -23,8 +23,8 @@
     "compile": "tsc -b tsconfig.json",
     "lint": "eslint --no-error-on-unmatched-pattern",
     "test:common": "jest --clearCache && jest --config=./jest.config.js",
-    "test:strict-null": "jest --clearCache && jest --config=./jest.strict-null.config.js",
-    "test": "npm run test:common && npm run test:strict-null"
+    "test:nostrict": "jest --clearCache && jest --config=./jest.nostrict.config.js",
+    "test": "npm run test:common && npm run test:nostrict"
   },
   "files": [
     "LICENSE",