ts-gems 2.7.1 → 2.7.3

package/lib/keys.d.ts

@@ -1,4 +1,7 @@
-import { IfEquals, IfCompatible, IfUndefined, IfAny, IfJson } from './type-check';
+import {
+  IfEquals, IfCompatible, IfUndefined,
+  IfJson, IfNull, IfFunction
+} from './type-check';
 
 /**
  * KeyOf
@@ -17,31 +20,32 @@ export type ValuesOf<T> = T[keyof T];
  * @desc Returns required keys of an object
  */
 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];
+export type _RequiredKeys<T> = ValuesOf<{
+  [K in keyof T]-?: IfUndefined<T[K]> extends true ? never
+      : T extends { [K1 in K]: any } ? K
+          : never
+}>;
 
 /**
  * OptionalKeys
  * @desc Returns optional keys of an object
  */
 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];
+export type _OptionalKeys<T> = ValuesOf<{
+  [K in keyof T]-?: IfUndefined<T[K]> extends true ? never
+      : T extends { [K1 in K]: any } ? never
+          : K
+}>;
 
 
 /**
  * @desc Returns readonly keys of an object
  */
-export type ReadonlyKeys<T> = {
-  [K in keyof T]-?: IfEquals<{ [Q in K]: T[K] }, { -readonly [Q in K]: T[K] }, never, K>
-}[keyof T];
-
+export type ReadonlyKeys<T> = _ReadonlyKeys<T>
+type _ReadonlyKeys<T, J = Required<T>> = ValuesOf<{
+  [K in keyof J]: K extends symbol ? never
+      : IfEquals<{ [Q in K]: J[K] }, { -readonly [Q in K]: J[K] }, never, K>
+}>;
 
 /**
  * @desc Returns JSON friendly keys of an object
@@ -49,10 +53,8 @@ export type ReadonlyKeys<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
 
 }>;
@@ -60,51 +62,52 @@ type _JsonKeys<T, J = Required<T>> = ValuesOf<{
 /**
  * @desc Returns writable keys of an object
  */
-export type WritableKeys<T> = {
-  [K in keyof T]-?: IfEquals<{ [Q in K]: T[K] }, { readonly [Q in K]: T[K] }, never, K>
-}[keyof T];
+export type WritableKeys<T> = _WritableKeys<T>;
+type _WritableKeys<T> = ValuesOf<{
+  [K in keyof T]-?: K extends symbol ? never
+      : IfEquals<{ [Q in K]: T[K] }, { readonly [Q in K]: T[K] }, never, K>
+}>;
 
 
 /**
  * @desc Returns writable json keys of an object
  */
-export type WritableJsonKeys<T> = Extract<{
-  [K in keyof T]-?: IfEquals<{ [Q in K]: T[K] }, { -readonly [Q in K]: T[K] }, K, never>
-}[keyof T], JsonKeys<T>>;
+export type WritableJsonKeys<T> = Extract<WritableKeys<T>, JsonKeys<T>>;
 
 /**
  * @desc Returns Function keys of an object
  */
-export type FunctionKeys<T> = ValuesOf<{
-  [K in keyof T]-?: IfUndefined<T[K]> extends false ?
-      IfAny<T[K]> extends false ?
-          T[K] extends Function ? K
-              : never : never : never;
+export type FunctionKeys<T> = _FunctionKeys<T>;
+type _FunctionKeys<T> = ValuesOf<{
+  [K in keyof T]-?: K extends symbol ? never
+      : IfFunction<T[K]> extends true ? K : 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;
+export type NonFunctionKeys<T> = _NonFunctionKeys<T>;
+type _NonFunctionKeys<T> = ValuesOf<{
+  [K in keyof T]-?: K extends symbol ? never
+      : IfFunction<T[K]> extends true ? never : K;
 }>;
 
 
-
 /**
  * @desc Returns keys that match given type
  */
-export type KeysCompatible<T, U> = ValuesOf<{
-  [K in keyof T]-?: IfCompatible<T[K], U, K, never>;
+export type KeysCompatible<T, U> = _KeysCompatible<T, U>;
+type _KeysCompatible<T, U> = ValuesOf<{
+  [K in keyof T]-?: K extends symbol ? never
+      : IfCompatible<T[K], U, K, never>;
 }>;
 
 /**
  * @desc Returns keys that equals given type
  */
-export type KeysEquals<T, U> = ValuesOf<{
-  [K in keyof T]-?: IfEquals<T[K], U, K, never>;
+export type KeysEquals<T, U> = _KeysEquals<T, U>;
+type _KeysEquals<T, U> = ValuesOf<{
+  [K in keyof T]-?: K extends symbol ? never
+      : IfEquals<T[K], U, K, never>;
 }>;
 

package/lib/type-check.d.ts

@@ -1,4 +1,4 @@
-import {Primitive, Type} from './common';
+import { Primitive, Type } from './common';
 
 type NonObj = Primitive | Function;
 
@@ -113,8 +113,9 @@ export type IfFunction<T, Y = true, N = false> =
     IfNever<T> extends true ? N
         : IfUndefined<T> extends true ? N
             : IfNull<T> extends true ? N
-                : T extends Function ? Y
-                    : N;
+                : T extends Type ? N
+                    : T extends Function ? Y
+                        : N;
 
 export type IfFunctionOrAny<T, Y = true, N = false> =
     IfAny<T> extends true ? Y : IfFunction<T, Y, N>;

package/package.json

@@ -12,7 +12,7 @@
     "lodash",
     "underscore"
   ],
-  "version": "2.7.1",
+  "version": "2.7.3",
   "types": "lib/index.d.ts",
   "main": "lib/index.js",
   "module": "lib/index.js",
@@ -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"
   }
 }