ts-gems 2.7.0 → 2.7.2

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

@@ -1,4 +1,4 @@
-import { IfEquals, IfCompatible, IfUndefined, IfAny, IfJson } from './type-check';
+import { IfEquals, IfCompatible, IfUndefined, IfAny, IfJson, IfNull } from './type-check';
 
 /**
  * KeyOf
@@ -16,20 +16,22 @@ export type ValuesOf<T> = T[keyof T];
  * RequiredKeys
  * @desc Returns required keys of an object
  */
-export type RequiredKeys<T> = {
-  [K in keyof T]-?: IfUndefined<T[K]> extends true
-      ? never
-      : T extends { [K1 in K]: any } ? K : never
+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
 }[keyof T];
 
 /**
  * OptionalKeys
  * @desc Returns optional keys of an object
  */
-export type OptionalKeys<T> = {
-  [K in keyof T]-?: IfUndefined<T[K]> extends true
-      ? never
-      : T extends { [K1 in K]: any } ? never : K
+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
 }[keyof T];
 
 
@@ -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
@@ -52,10 +49,8 @@ export type NonFunctionKeys<T> = Exclude<keyof T, FunctionKeys<T>>;
 export type JsonKeys<T> = _JsonKeys<T>;
 type _JsonKeys<T, J = Required<T>> = ValuesOf<{
   [K in keyof J]: K extends symbol ? never
-      : IfUndefined<J[K]> extends true
-          ? never
-          : IfJson<J[K]> extends true
-              ? K
+      : IfNull<J[K]> extends true ? K
+          : IfJson<Exclude<J[K], undefined>> extends true ? K
               : never
 
 }>;
@@ -63,7 +58,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];
 
 
 /**
@@ -78,11 +75,22 @@ export type WritableJsonKeys<T> = Extract<{
  */
 export type FunctionKeys<T> = ValuesOf<{
   [K in keyof T]-?: IfUndefined<T[K]> extends false ?
-      IfAny<T[K]> extends false ?
-          T[K] extends Function ? K
+      IfAny<T[K]> extends false
+          ? T[K] extends Function ? K
               : 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

@@ -1,4 +1,4 @@
-import {Primitive, Type} from './common';
+import { Primitive, Type } from './common';
 
 type NonObj = Primitive | Function;
 
@@ -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.2",
   "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",
@@ -32,10 +32,10 @@
     "lib/"
   ],
   "devDependencies": {
-    "@types/jest": "^29.5.4",
-    "eslint": "^8.49.0",
+    "@types/jest": "^29.5.11",
+    "eslint": "^8.55.0",
     "jest": "^29.7.0",
     "ts-jest": "^29.1.1",
-    "typescript": "^5.2.2"
+    "typescript": "^5.3.3"
   }
 }