ts-gems 2.7.2 → 2.7.3

package/lib/keys.d.ts

@@ -1,4 +1,7 @@
-import { IfEquals, IfCompatible, IfUndefined, IfAny, IfJson, IfNull } 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> = {
+export type _RequiredKeys<T> = ValuesOf<{
   [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> = _OptionalKeys<T>
-export type _OptionalKeys<T> = {
+export type _OptionalKeys<T> = ValuesOf<{
   [K in keyof T]-?: IfUndefined<T[K]> extends true ? never
       : T extends { [K1 in K]: any } ? never
           : K
-}[keyof T];
+}>;
 
 
 /**
  * @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
@@ -58,50 +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

@@ -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.2",
+  "version": "2.7.3",
   "types": "lib/index.d.ts",
   "main": "lib/index.js",
   "module": "lib/index.js",