ts-gems 0.0.3 → 1.1.1

package/lib/common.d.ts

@@ -1,19 +1,83 @@
-export type Primitive = string | number | boolean | null | bigint | symbol | undefined;
-export type Builtin = Primitive | Function | Date | Error | RegExp;
-export type NonObj = Primitive | Function;
-export type NonSymbol = Exclude<Builtin, symbol>;
+/**
+ * BasicPrimitive
+ * @desc Type representing [`BasicPrimitive`](https://www.typescriptlang.org/docs/handbook/release-notes/overview.html#smarter-type-alias-preservation) types in TypeScript
+ */
+type BasicPrimitive = number | string | boolean;
 
+
+/**
+ * Primitive
+ * @desc Type representing [`Primitive`](https://developer.mozilla.org/en-US/docs/Glossary/Primitive) types
+ * in TypeScript: `string | number | bigint | boolean |  symbol | null | undefined`
+ */
+export type Primitive = BasicPrimitive | null | bigint | symbol | undefined;
+
+/**
+ * JsonTypes
+ * @desc Type representing JSON types in TypeScript
+ */
+type JsonType = BasicPrimitive | null | object | (BasicPrimitive | object)[]
+
+
+/**
+ * Builtin
+ * @desc Type representing Builtin types in JavaScript
+ */
+export type Builtin = Primitive | Function | String | Number | Date | Error | RegExp |
+    ArrayBuffer | DataView | Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array |
+    Int32Array | Uint32Array | Float32Array | Float64Array;
+
+/**
+ * Maybe
+ * @desc Type representing T | undefined
+ */
 export type Maybe<T> = T | undefined;
-export type Nullable<T> = T | undefined | null;
 
+/**
+ * Nullish
+ * @desc Type representing [nullish values][https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-7.html#nullish-coalescing] in TypeScript: `null | undefined`
+ */
+export type Nullish<T = null> = T | undefined | null;
+
+/**
+ * Falsy
+ * @desc Type representing falsy values in TypeScript: `false | "" | 0 | null | undefined`
+ */
+export type Falsy = false | '' | 0 | null | undefined;
+
+
+export type Awaited<T> = T extends PromiseLike<infer U> ? U : T;
+
+
+export type Thunk<T, Args extends any[] = any[]> = T | ((...args: Args) => T);
+export type AsyncThunk<T, Args extends any[] = any[]> = Thunk<T> | ((...args: Args) => Promise<T>);
+
+
+/**
+ * PropertyType
+ * @desc Returns the type of property at a given key `K`
+ */
+export type PropertyType<T, K extends keyof T> = T[K];
+
+/**
+ * $ElementType
+ * @desc Returns the type of elements inside of array, tuple or object of type `T`, that matches the given index type `K`
+ */
+export type ElementType<T extends { [P in K & any]: any },
+    K extends keyof T | number> = T[K];
+
+
+/**
+ * Class
+ * @desc Represents constructor of type T
+ */
 export interface Type<T = any> {
     new(...args: any[]): T;
 }
 
-export type Awaited<T> = T extends PromiseLike<infer PT> ? PT : T;
-
+/**
+ * Class
+ * @desc Represents Class constructor of type T
+ */
 export type Class<Args extends any[] = any[], Instance = {}, Static = {}> =
     (new(...args: Args) => Instance) & Static;
-
-export type Thunk<T, Args extends any[] = any[]> = T | ((...args: Args) => T);
-export type AsyncThunk<T, Args extends any[] = any[]> = T | ((...args: Args) => T) | ((...args: Args) => Promise<T>);

package/lib/deep-modify.d.ts

@@ -0,0 +1,106 @@
+import {Builtin} from './common';
+import {IfTuple} from './type-check';
+import {OptionalKeys} from './keys';
+
+/**
+ * Partial but deeply
+ */
+export type DeepPartial<T> = _DeepPartial<T>;
+type _DeepPartial<T> =
+    T extends Builtin ? T
+        : T extends Promise<infer U> ? Promise<DeepPartial<U>>
+            : T extends Map<infer K, infer V> ? Map<K, DeepPartial<V>>
+                : T extends ReadonlyMap<infer K, infer V> ? ReadonlyMap<K, DeepPartial<V>>
+                    : T extends WeakMap<infer K, infer V> ? WeakMap<K, DeepPartial<V>>
+                        : T extends Set<infer U> ? Set<DeepPartial<U>>
+                            : T extends ReadonlySet<infer U> ? ReadonlySet<DeepPartial<U>>
+                                : T extends WeakSet<infer U> ? WeakSet<DeepPartial<U>>
+                                    : IfTuple<T> extends true ? { [K in OptionalKeys<T>]?: DeepPartial<T[K]> }
+                                        : T extends (infer U)[] ? DeepPartial<U>[]
+                                            : { [P in keyof T]?: DeepPartial<Exclude<T[P], undefined>> };
+
+/**
+ * Combination of Partial and Writable but deeply
+ */
+export type DeepBuildable<T> = _DeepBuildable<T>;
+type _DeepBuildable<T> =
+    T extends Builtin ? T
+        : T extends Promise<infer U> ? Promise<DeepBuildable<U>>
+            : T extends Map<infer K, infer V> ? Map<K, DeepBuildable<V>>
+                : T extends ReadonlyMap<infer K, infer V> ? ReadonlyMap<K, DeepBuildable<V>>
+                    : T extends WeakMap<infer K, infer V> ? WeakMap<K, DeepBuildable<V>>
+                        : T extends Set<infer U> ? Set<DeepBuildable<U>>
+                            : T extends ReadonlySet<infer U> ? ReadonlySet<DeepBuildable<U>>
+                                : T extends WeakSet<infer U> ? WeakSet<DeepBuildable<U>>
+                                    : IfTuple<T> extends true ? { [K in OptionalKeys<T>]?: DeepBuildable<T[K]> }
+                                        : T extends (infer U)[] ? DeepBuildable<U>[]
+                                            : { -readonly [P in keyof T]?: DeepBuildable<Exclude<T[P], undefined>> };
+
+/**
+ * Make all properties in T required deeply
+ */
+export type DeepRequired<T> = _DeepRequired<T>;
+type _DeepRequired<T> =
+    T extends Builtin ? T
+        : T extends Promise<infer U> ? Promise<DeepRequired<U>>
+            : T extends Map<infer K, infer V> ? Map<K, DeepRequired<V>>
+                : T extends ReadonlyMap<infer K, infer V> ? ReadonlyMap<K, DeepRequired<V>>
+                    : T extends WeakMap<infer K, infer V> ? WeakMap<K, DeepRequired<V>>
+                        : T extends Set<infer U> ? Set<DeepRequired<U>>
+                            : T extends ReadonlySet<infer U> ? ReadonlySet<DeepRequired<U>>
+                                : T extends WeakSet<infer U> ? WeakSet<DeepRequired<U>>
+                                    : IfTuple<T> extends true ? { [K in OptionalKeys<T>]?: DeepRequired<T[K]> }
+                                        : T extends (infer U)[] ? DeepRequired<U>[]
+                                            : { [P in keyof T]-?: DeepRequired<Exclude<T[P], undefined>> };
+
+
+/**
+ * Make all properties in T readonly deeply
+ */
+export type DeepReadonly<T> = _DeepReadonly<T>;
+type _DeepReadonly<T> =
+    T extends Builtin ? T
+        : T extends Promise<infer U> ? Promise<DeepReadonly<U>>
+            : T extends Map<infer K, infer V> ? Map<K, DeepReadonly<V>>
+                : T extends ReadonlyMap<infer K, infer V> ? ReadonlyMap<K, DeepReadonly<V>>
+                    : T extends WeakMap<infer K, infer V> ? WeakMap<K, DeepReadonly<V>>
+                        : T extends Set<infer U> ? Set<DeepReadonly<U>>
+                            : T extends ReadonlySet<infer U> ? ReadonlySet<DeepReadonly<U>>
+                                : T extends WeakSet<infer U> ? WeakSet<DeepReadonly<U>>
+                                    : IfTuple<T> extends true ? { [K in OptionalKeys<T>]?: DeepReadonly<T[K]> }
+                                        : T extends (infer U)[] ? DeepReadonly<U>[]
+                                            : { readonly [P in keyof T]: DeepReadonly<Exclude<T[P], undefined>> };
+
+/**
+ * Make all properties in T writable deeply
+ */
+export type DeepWritable<T> = _DeepWritable<T>;
+type _DeepWritable<T> =
+    T extends Builtin ? T
+        : T extends Promise<infer U> ? Promise<DeepWritable<U>>
+            : T extends Map<infer K, infer V> ? Map<K, DeepWritable<V>>
+                : T extends ReadonlyMap<infer K, infer V> ? ReadonlyMap<K, DeepWritable<V>>
+                    : T extends WeakMap<infer K, infer V> ? WeakMap<K, DeepWritable<V>>
+                        : T extends Set<infer U> ? Set<DeepWritable<U>>
+                            : T extends ReadonlySet<infer U> ? ReadonlySet<DeepWritable<U>>
+                                : T extends WeakSet<infer U> ? WeakSet<DeepWritable<U>>
+                                    : IfTuple<T> extends true ? { [K in OptionalKeys<T>]?: DeepWritable<T[K]> }
+                                        : T extends (infer U)[] ? DeepWritable<U>[]
+                                            : { -readonly [P in keyof T]: DeepWritable<Exclude<T[P], undefined>> };
+
+/**
+ * Make all properties in T nullable deeply
+ */
+export type DeepNullish<T> = _DeepNullish<DeepRequired<T>>;
+type _DeepNullish<T> =
+    T extends Builtin ? T | null | undefined
+        : T extends Promise<infer U> ? Promise<DeepNullish<U>>
+            : T extends Map<infer K, infer V> ? Map<K, DeepNullish<V>>
+                : T extends ReadonlyMap<infer K, infer V> ? ReadonlyMap<K, DeepNullish<V>>
+                    : T extends WeakMap<infer K, infer V> ? WeakMap<K, DeepNullish<V>>
+                        : T extends Set<infer U> ? Set<DeepNullish<U>>
+                            : T extends ReadonlySet<infer U> ? ReadonlySet<DeepNullish<U>>
+                                : T extends WeakSet<infer U> ? WeakSet<DeepNullish<U>>
+                                    : IfTuple<T> extends true ? { [K in OptionalKeys<T>]?: DeepNullish<T[K]> }
+                                        : T extends (infer U)[] ? DeepNullish<U>[] | null | undefined
+                                            : { [P in keyof T]: DeepNullish<T[P]>| null | undefined };

package/lib/deep-omit.d.ts

@@ -0,0 +1,88 @@
+import {Builtin} from './common';
+import {IfTuple} from './type-check';
+import {JsonKeys, OptionalKeys, ReadonlyKeys, RequiredKeys, WritableKeys} from './keys';
+
+/**
+ * Omit all optional properties in T deeply
+ */
+export type DeepOmitOptional<T> = _DeepOmitOptional<T>;
+type _DeepOmitOptional<T, K extends keyof T = Exclude<keyof T, OptionalKeys<T>>> =
+    T extends Builtin ? T
+        : T extends Promise<infer U> ? Promise<DeepOmitOptional<U>>
+            : T extends Map<infer K, infer V> ? Map<K, DeepOmitOptional<V>>
+                : T extends ReadonlyMap<infer K, infer V> ? ReadonlyMap<K, DeepOmitOptional<V>>
+                    : T extends WeakMap<infer K, infer V> ? WeakMap<K, DeepOmitOptional<V>>
+                        : T extends Set<infer U> ? Set<DeepOmitOptional<U>>
+                            : T extends ReadonlySet<infer U> ? ReadonlySet<DeepOmitOptional<U>>
+                                : T extends WeakSet<infer U> ? WeakSet<DeepOmitOptional<U>>
+                                    : IfTuple<T> extends true ? { [K in OptionalKeys<T>]?: DeepOmitOptional<T[K]> }
+                                        : T extends (infer U)[] ? DeepOmitOptional<U>[]
+                                            : { [P in K]: DeepOmitOptional<Exclude<T[P], undefined>> };
+
+/**
+ * Omit all required properties in T deeply
+ */
+export type DeepOmitRequired<T> = _DeepOmitRequired<T>;
+type _DeepOmitRequired<T, J extends keyof T = Exclude<keyof T, RequiredKeys<T>>> =
+    T extends Builtin ? T
+        : T extends Promise<infer U> ? Promise<DeepOmitRequired<U>>
+            : T extends Map<infer K, infer V> ? Map<K, DeepOmitRequired<V>>
+                : T extends ReadonlyMap<infer K, infer V> ? ReadonlyMap<K, DeepOmitRequired<V>>
+                    : T extends WeakMap<infer K, infer V> ? WeakMap<K, DeepOmitRequired<V>>
+                        : T extends Set<infer U> ? Set<DeepOmitRequired<U>>
+                            : T extends ReadonlySet<infer U> ? ReadonlySet<DeepOmitRequired<U>>
+                                : T extends WeakSet<infer U> ? WeakSet<DeepOmitRequired<U>>
+                                    : IfTuple<T> extends true ? { [K in OptionalKeys<T>]?: DeepOmitRequired<T[K]> }
+                                        : T extends (infer U)[] ? DeepOmitRequired<U>[]
+                                            : { [P in J]: DeepOmitRequired<Exclude<T[P], undefined>> };
+
+/**
+ * Omit all readonly properties in T deeply
+ */
+export type DeepOmitReadonly<T> = _DeepOmitReadonly<T>;
+type _DeepOmitReadonly<T, J extends keyof T = Exclude<keyof T, ReadonlyKeys<T>>> =
+    T extends Builtin ? T
+        : T extends Promise<infer U> ? Promise<DeepOmitReadonly<U>>
+            : T extends Map<infer K, infer V> ? Map<K, DeepOmitReadonly<V>>
+                : T extends ReadonlyMap<infer K, infer V> ? ReadonlyMap<K, DeepOmitReadonly<V>>
+                    : T extends WeakMap<infer K, infer V> ? WeakMap<K, DeepOmitReadonly<V>>
+                        : T extends Set<infer U> ? Set<DeepOmitReadonly<U>>
+                            : T extends ReadonlySet<infer U> ? ReadonlySet<DeepOmitReadonly<U>>
+                                : T extends WeakSet<infer U> ? WeakSet<DeepOmitReadonly<U>>
+                                    : IfTuple<T> extends true ? { [K in OptionalKeys<T>]?: DeepOmitReadonly<T[K]> }
+                                        : T extends (infer U)[] ? DeepOmitReadonly<U>[]
+                                            : { [P in J]: DeepOmitReadonly<Exclude<T[P], undefined>> };
+
+/**
+ * Omit all writable properties in T deeply
+ */
+export type DeepOmitWritable<T> = _DeepOmitWritable<T>
+type _DeepOmitWritable<T, K extends keyof T = Exclude<keyof T, WritableKeys<T>>> =
+    T extends Builtin ? T
+        : T extends Promise<infer U> ? Promise<DeepOmitWritable<U>>
+            : T extends Map<infer K, infer V> ? Map<K, DeepOmitWritable<V>>
+                : T extends ReadonlyMap<infer K, infer V> ? ReadonlyMap<K, DeepOmitWritable<V>>
+                    : T extends WeakMap<infer K, infer V> ? WeakMap<K, DeepOmitWritable<V>>
+                        : T extends Set<infer U> ? Set<DeepOmitWritable<U>>
+                            : T extends ReadonlySet<infer U> ? ReadonlySet<DeepOmitWritable<U>>
+                                : T extends WeakSet<infer U> ? WeakSet<DeepOmitWritable<U>>
+                                    : IfTuple<T> extends true ? { [K in OptionalKeys<T>]?: DeepOmitWritable<T[K]> }
+                                        : T extends (infer U)[] ? DeepOmitWritable<U>[]
+                                            : { [P in K]: DeepOmitWritable<Exclude<T[P], undefined>> }
+
+/**
+ * Omit all JSON friendly properties in T deeply
+ */
+export type DeepOmitJson<T> = _DeepOmitJson<T>
+type _DeepOmitJson<T, K extends keyof T = Exclude<keyof T, JsonKeys<T>>> =
+    T extends Builtin ? T
+        : T extends Promise<infer U> ? Promise<DeepOmitJson<U>>
+            : T extends Map<infer K, infer V> ? Map<K, DeepOmitJson<V>>
+                : T extends ReadonlyMap<infer K, infer V> ? ReadonlyMap<K, DeepOmitJson<V>>
+                    : T extends WeakMap<infer K, infer V> ? WeakMap<K, DeepOmitJson<V>>
+                        : T extends Set<infer U> ? Set<DeepOmitJson<U>>
+                            : T extends ReadonlySet<infer U> ? ReadonlySet<DeepOmitJson<U>>
+                                : T extends WeakSet<infer U> ? WeakSet<DeepOmitJson<U>>
+                                    : IfTuple<T> extends true ? { [K in OptionalKeys<T>]?: DeepOmitJson<T[K]> }
+                                        : T extends (infer U)[] ? DeepOmitJson<U>[]
+                                            : { [P in K]: DeepOmitJson<Exclude<T[P], undefined>> };

package/lib/deep-pick.d.ts

@@ -0,0 +1,88 @@
+import {Builtin} from './common';
+import {IfTuple} from './type-check';
+import {JsonKeys, OptionalKeys, ReadonlyKeys, RequiredKeys, WritableKeys} from './keys';
+
+/**
+ * Pick all optional properties in T deeply
+ */
+export type DeepPickOptional<T> = _DeepPickOptional<T>;
+type _DeepPickOptional<T, K extends keyof T = OptionalKeys<T>> =
+    T extends Builtin ? T
+        : T extends Promise<infer U> ? Promise<DeepPickOptional<U>>
+            : T extends Map<infer K, infer V> ? Map<K, DeepPickOptional<V>>
+                : T extends ReadonlyMap<infer K, infer V> ? ReadonlyMap<K, DeepPickOptional<V>>
+                    : T extends WeakMap<infer K, infer V> ? WeakMap<K, DeepPickOptional<V>>
+                        : T extends Set<infer U> ? Set<DeepPickOptional<U>>
+                            : T extends ReadonlySet<infer U> ? ReadonlySet<DeepPickOptional<U>>
+                                : T extends WeakSet<infer U> ? WeakSet<DeepPickOptional<U>>
+                                    : IfTuple<T> extends true ? { [K in OptionalKeys<T>]?: DeepPickOptional<T[K]> }
+                                        : T extends (infer U)[] ? DeepPickOptional<U>[]
+                                            : { [P in K]: DeepPickOptional<Exclude<T[P], undefined>> };
+
+/**
+ * Pick all required properties in T deeply
+ */
+export type DeepPickRequired<T> = _DeepPickRequired<T>;
+type _DeepPickRequired<T, J extends keyof T = RequiredKeys<T>> =
+    T extends Builtin ? T
+        : T extends Promise<infer U> ? Promise<DeepPickRequired<U>>
+            : T extends Map<infer K, infer V> ? Map<K, DeepPickRequired<V>>
+                : T extends ReadonlyMap<infer K, infer V> ? ReadonlyMap<K, DeepPickRequired<V>>
+                    : T extends WeakMap<infer K, infer V> ? WeakMap<K, DeepPickRequired<V>>
+                        : T extends Set<infer U> ? Set<DeepPickRequired<U>>
+                            : T extends ReadonlySet<infer U> ? ReadonlySet<DeepPickRequired<U>>
+                                : T extends WeakSet<infer U> ? WeakSet<DeepPickRequired<U>>
+                                    : IfTuple<T> extends true ? { [K in OptionalKeys<T>]?: DeepPickRequired<T[K]> }
+                                        : T extends (infer U)[] ? DeepPickRequired<U>[]
+                                            : { [P in J]: DeepPickRequired<Exclude<T[P], undefined>> };
+
+/**
+ * Pick all readonly properties in T deeply
+ */
+export type DeepPickReadonly<T> = _DeepPickReadonly<T>;
+type _DeepPickReadonly<T, J extends keyof T = ReadonlyKeys<T>> =
+    T extends Builtin ? T
+        : T extends Promise<infer U> ? Promise<DeepPickReadonly<U>>
+            : T extends Map<infer K, infer V> ? Map<K, DeepPickReadonly<V>>
+                : T extends ReadonlyMap<infer K, infer V> ? ReadonlyMap<K, DeepPickReadonly<V>>
+                    : T extends WeakMap<infer K, infer V> ? WeakMap<K, DeepPickReadonly<V>>
+                        : T extends Set<infer U> ? Set<DeepPickReadonly<U>>
+                            : T extends ReadonlySet<infer U> ? ReadonlySet<DeepPickReadonly<U>>
+                                : T extends WeakSet<infer U> ? WeakSet<DeepPickReadonly<U>>
+                                    : IfTuple<T> extends true ? { [K in OptionalKeys<T>]?: DeepPickReadonly<T[K]> }
+                                        : T extends (infer U)[] ? DeepPickReadonly<U>[]
+                                            : { [P in J]: DeepPickReadonly<Exclude<T[P], undefined>> };
+
+/**
+ * Pick all writable properties in T deeply
+ */
+export type DeepPickWritable<T> = _DeepPickWritable<T>
+type _DeepPickWritable<T, K extends keyof T = WritableKeys<T>> =
+    T extends Builtin ? T
+        : T extends Promise<infer U> ? Promise<DeepPickWritable<U>>
+            : T extends Map<infer K, infer V> ? Map<K, DeepPickWritable<V>>
+                : T extends ReadonlyMap<infer K, infer V> ? ReadonlyMap<K, DeepPickWritable<V>>
+                    : T extends WeakMap<infer K, infer V> ? WeakMap<K, DeepPickWritable<V>>
+                        : T extends Set<infer U> ? Set<DeepPickWritable<U>>
+                            : T extends ReadonlySet<infer U> ? ReadonlySet<DeepPickWritable<U>>
+                                : T extends WeakSet<infer U> ? WeakSet<DeepPickWritable<U>>
+                                    : IfTuple<T> extends true ? { [K in OptionalKeys<T>]?: DeepPickWritable<T[K]> }
+                                        : T extends (infer U)[] ? DeepPickWritable<U>[]
+                                            : { [P in K]: DeepPickWritable<Exclude<T[P], undefined>> }
+
+/**
+ * Pick all JSON friendly properties in T deeply
+ */
+export type DeepPickJson<T> = _DeepPickJson<T>
+type _DeepPickJson<T, K extends keyof T = JsonKeys<T>> =
+    T extends Builtin ? T
+        : T extends Promise<infer U> ? Promise<DeepPickJson<U>>
+            : T extends Map<infer K, infer V> ? Map<K, DeepPickJson<V>>
+                : T extends ReadonlyMap<infer K, infer V> ? ReadonlyMap<K, DeepPickJson<V>>
+                    : T extends WeakMap<infer K, infer V> ? WeakMap<K, DeepPickJson<V>>
+                        : T extends Set<infer U> ? Set<DeepPickJson<U>>
+                            : T extends ReadonlySet<infer U> ? ReadonlySet<DeepPickJson<U>>
+                                : T extends WeakSet<infer U> ? WeakSet<DeepPickJson<U>>
+                                    : IfTuple<T> extends true ? { [K in OptionalKeys<T>]?: DeepPickJson<T[K]> }
+                                        : T extends (infer U)[] ? DeepPickJson<U>[]
+                                            : { [P in K]: DeepPickJson<Exclude<T[P], undefined>> };

package/lib/index.d.ts

@@ -1,6 +1,9 @@
 export * from "./common";
 export * from "./keys";
+export * from "./type-check";
 export * from "./modify";
-export * from "./omit";
+export * from "./deep-pick";
+export * from "./deep-omit";
+export * from "./deep-modify";
 export * from "./pick";
-export * from "./type-check";
+export * from "./omit";

package/lib/keys.ts

@@ -1,48 +1,100 @@
-import {IfEquals, IsUndefined} from './type-check';
+import {IfEquals, IfCompatible, IfUndefined, IfAny, IfJson} from './type-check';
 
 /**
- * Gets optional keys of an object
+ * KeyOf
+ * @desc Returns the union type of all the keys in a type
  */
-export type OptionalKeys<T> = {
-    [K in keyof T]-?: {} extends Pick<T, K> ? K : never;
-}[keyof T];
+export type KeysOf<T> = keyof T;
 
 /**
- * Gets required keys of an object
+ * ValuesOf
+ * @desc Returns the union type of all the values in a type
  */
-export type RequiredKeys<T> = Exclude<keyof T, OptionalKeys<T>>;
+export type ValuesOf<T> = T[keyof T];
 
 /**
- * Gets Function keys of an object
+ * RequiredKeys
+ * @desc Returns required keys of an object
  */
-export type FunctionKeys<T> = {
-    [K in keyof T]-?: IsUndefined<T[K]> extends false ?
-        T[K] extends Function ? K : never : never;
+export type RequiredKeys<T> = {
+    [K in keyof T]-?: IfUndefined<T[K]> extends true
+        ? never
+        : T extends { [K1 in K]: any } ? K : never
 }[keyof T];
 
 /**
- * Gets readonly keys of an object
+ * 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
+}[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];
 
 /**
- * Gets readable keys of an object
+ * @desc Returns non function keys of an object
  */
-export type ReadableKeys<T> = Exclude<keyof T, FunctionKeys<T>>;
+export type NonFunctionKeys<T> = Exclude<keyof T, FunctionKeys<T>>;
+
 
 /**
- * Gets writable keys of an object
+ * @desc Returns JSON friendly keys of an object
  */
-export type WritableKeys<T> = Exclude<{
-    [K in keyof T]-?: IfEquals<{ [Q in K]: T[K] }, { -readonly [Q in K]: T[K] }, K>
-}[keyof T], FunctionKeys<T>>;
+export type JsonKeys<T> = _JsonKeys<T>;
+type _JsonKeys<T, J = Required<T>> = ValuesOf<{
+    [K in keyof J]: IfUndefined<J[K]> extends true
+        ? never
+        : K extends symbol
+            ? never
+            : IfJson<J[K]> extends true
+                ? K
+                : never
+
+}>;
 
 /**
- * Gets keys that matches V of T
+ * @desc Returns writable keys of an object
  */
-type _TypeKeys<T, V> = {
-    [K in keyof T]: IfEquals<T[K], V, K, never>
-}[keyof T];
-export type TypeKeys<T, V> = _TypeKeys<Required<T>, V>;
+export type WritableKeys<T> = Exclude<keyof T, ReadonlyKeys<T>>;
+
+
+/**
+ * @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>>;
+
+/**
+ * @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;
+}>;
+
+/**
+ * @desc Returns keys that match given type
+ */
+export type KeysCompatible<T, U> = ValuesOf<{
+    [K in keyof T]-?: 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>;
+}>;
+

package/lib/modify.d.ts

@@ -1,7 +1,3 @@
-/** Like Partial but recursive */
-import {Builtin} from './common';
-import {IsTuple} from './type-check';
-
 /**
  * Make all properties in T writable
  */
@@ -13,91 +9,3 @@ export type Writable<T> = {
  * Combination of Partial and Writable
  */
 export type Buildable<T> = Partial<Writable<T>>;
-
-/**
- * Combination of DeepPartial and DeepWritable
- */
-export type DeepBuildable<T> = DeepPartial<DeepWritable<T>>;
-
-/**
- * Make all properties in T optional deeply
- */
-export type DeepPartial<T> =
-    T extends Builtin ? T
-        : T extends Map<infer K, infer V> ? Map<K, DeepPartial<V>>
-            : T extends ReadonlyMap<infer K, infer V> ? ReadonlyMap<K, DeepPartial<V>>
-                : T extends WeakMap<infer K, infer V> ? WeakMap<K, DeepPartial<V>>
-                    : T extends Set<infer U> ? Set<DeepPartial<U>>
-                        : T extends ReadonlySet<infer U> ? ReadonlySet<DeepPartial<U>>
-                            : T extends WeakSet<infer U> ? WeakSet<DeepPartial<U>>
-                                : T extends (infer U)[] ? true extends IsTuple<T>
-                                        ? { [K in keyof T]?: DeepPartial<T[K]> } : (DeepPartial<U>)[]
-                                    : T extends Promise<infer U> ? Promise<DeepPartial<U>>
-                                        : Partial<T>;
-
-/**
- * Make all properties in T required deeply
- */
-export type DeepRequired<T> =
-    T extends Builtin ? T
-        : T extends Map<infer K, infer V> ? Map<K, DeepRequired<V>>
-            : T extends ReadonlyMap<infer K, infer V> ? ReadonlyMap<K, DeepRequired<V>>
-                : T extends WeakMap<infer K, infer V> ? WeakMap<K, DeepRequired<V>>
-                    : T extends Set<infer U> ? Set<DeepRequired<U>>
-                        : T extends ReadonlySet<infer U> ? ReadonlySet<DeepRequired<U>>
-                            : T extends WeakSet<infer U> ? WeakSet<DeepRequired<U>>
-                                : T extends (infer U)[] ? true extends IsTuple<T>
-                                        ? { [K in keyof T]?: DeepRequired<T[K]> } : (DeepRequired<U>)[]
-                                    : T extends Promise<infer U> ? Promise<DeepRequired<U>>
-                                        : Required<T>;
-
-/**
- * Make all properties in T readonly deeply
- */
-export type DeepReadonly<T> =
-    T extends Builtin ? T
-        : T extends Map<infer K, infer V> ? Map<K, DeepReadonly<V>>
-            : T extends ReadonlyMap<infer K, infer V> ? ReadonlyMap<K, DeepReadonly<V>>
-                : T extends WeakMap<infer K, infer V> ? WeakMap<K, DeepReadonly<V>>
-                    : T extends Set<infer U> ? Set<DeepReadonly<U>>
-                        : T extends ReadonlySet<infer U> ? ReadonlySet<DeepReadonly<U>>
-                            : T extends WeakSet<infer U> ? WeakSet<DeepReadonly<U>>
-                                : T extends (infer U)[] ? true extends IsTuple<T>
-                                        ? { [K in keyof T]?: DeepReadonly<T[K]> } : (DeepReadonly<U>)[]
-                                    : T extends Promise<infer U> ? Promise<DeepReadonly<U>>
-                                        : Readonly<T>;
-
-/**
- * Make all properties in T writable deeply
- */
-export type DeepWritable<T> =
-    T extends Builtin ? T
-        : T extends Map<infer K, infer V> ? Map<K, DeepWritable<V>>
-            : T extends ReadonlyMap<infer K, infer V> ? ReadonlyMap<K, DeepWritable<V>>
-                : T extends WeakMap<infer K, infer V> ? WeakMap<K, DeepWritable<V>>
-                    : T extends Set<infer U> ? Set<DeepWritable<U>>
-                        : T extends ReadonlySet<infer U> ? ReadonlySet<DeepWritable<U>>
-                            : T extends WeakSet<infer U> ? WeakSet<DeepWritable<U>>
-                                : T extends (infer U)[] ? true extends IsTuple<T>
-                                        ? { [K in keyof T]?: DeepWritable<T[K]> } : (DeepWritable<U>)[]
-                                    : T extends Promise<infer U> ? Promise<DeepWritable<U>>
-                                        : Writable<T>;
-
-/**
- * Make all properties in T nullable deeply
- */
-export type DeepNullable<T> =
-    T extends Builtin ? T
-        : T extends Map<infer K, infer V> ? Map<K, DeepNullable<V>>
-            : T extends ReadonlyMap<infer K, infer V> ? ReadonlyMap<K, DeepNullable<V>>
-                : T extends WeakMap<infer K, infer V> ? WeakMap<K, DeepNullable<V>>
-                    : T extends Set<infer U> ? Set<DeepNullable<U>>
-                        : T extends ReadonlySet<infer U> ? ReadonlySet<DeepNullable<U>>
-                            : T extends WeakSet<infer U> ? WeakSet<DeepNullable<U>>
-                                : T extends (infer U)[] ? true extends IsTuple<T>
-                                        ? { [K in keyof T]?: DeepNullable<T[K]> } : (DeepNullable<U>)[]
-                                    : T extends Promise<infer U> ? Promise<DeepNullable<U>>
-                                        : T extends {}
-                                            ? { [K in keyof T]: DeepNullable<T[K]> }
-                                            : T | null | undefined;
-

package/lib/omit.d.ts

@@ -1,116 +1,27 @@
-/** Like Partial but recursive */
-import {Builtin} from './common';
-import {IsTuple} from './type-check';
-import {OptionalKeys, ReadonlyKeys, RequiredKeys, TypeKeys, WritableKeys} from './keys';
+import {JsonKeys, OptionalKeys, ReadonlyKeys, RequiredKeys, WritableKeys} from './keys';
 
 /**
- * Omit all optional properties in object type
+ * Omit all optional properties in T
  */
 export type OmitOptional<T> = Omit<T, OptionalKeys<T>>;
 
 /**
- * Omit all required properties in object type
+ * Omit all required properties in T
  */
 export type OmitRequired<T> = Omit<T, RequiredKeys<T>>;
 
 /**
- * Omit all readonly properties in object type
+ * Omit all readonly properties in T
  */
 export type OmitReadonly<T> = Omit<T, ReadonlyKeys<T>>;
 
-/**
- * Omit all writable properties in object type
- */
-export type OmitWritable<T> = Omit<T, WritableKeys<T>>;
-
-/**
- * Omit all properties of given type in object type
- */
-export type OmitType<T, S> = Omit<T, TypeKeys<T, S>>;
-
-
-/**
- * Omit all optional properties in T deeply
- */
-export type DeepOmitOptional<T> =
-    T extends Builtin ? T
-        : T extends Map<infer K, infer V> ? Map<K, DeepOmitOptional<V>>
-            : T extends ReadonlyMap<infer K, infer V> ? ReadonlyMap<K, DeepOmitOptional<V>>
-                : T extends WeakMap<infer K, infer V> ? WeakMap<K, DeepOmitOptional<V>>
-                    : T extends Set<infer U> ? Set<DeepOmitOptional<U>>
-                        : T extends ReadonlySet<infer U> ? ReadonlySet<DeepOmitOptional<U>>
-                            : T extends WeakSet<infer U> ? WeakSet<DeepOmitOptional<U>>
-                                : T extends (infer U)[] ? T extends IsTuple<T>
-                                        ? { [K in ReadonlyKeys<T>]?: DeepOmitOptional<T[K]> } : (DeepOmitOptional<U>)[]
-                                    : T extends Promise<infer U> ? Promise<DeepOmitOptional<U>>
-                                        : T extends {} ? { [K in ReadonlyKeys<T>]?: DeepOmitOptional<T[K]> }
-                                            : OmitOptional<T>;
-
-
-/**
- * Omit all non optional properties in T deeply
- */
-export type DeepOmitRequired<T> =
-    T extends Builtin ? T
-        : T extends Map<infer K, infer V> ? Map<K, DeepOmitRequired<V>>
-            : T extends ReadonlyMap<infer K, infer V> ? ReadonlyMap<K, DeepOmitRequired<V>>
-                : T extends WeakMap<infer K, infer V> ? WeakMap<K, DeepOmitRequired<V>>
-                    : T extends Set<infer U> ? Set<DeepOmitRequired<U>>
-                        : T extends ReadonlySet<infer U> ? ReadonlySet<DeepOmitRequired<U>>
-                            : T extends WeakSet<infer U> ? WeakSet<DeepOmitRequired<U>>
-                                : T extends (infer U)[] ? T extends IsTuple<T>
-                                        ? { [K in ReadonlyKeys<T>]?: DeepOmitRequired<T[K]> } : (DeepOmitRequired<U>)[]
-                                    : T extends Promise<infer U> ? Promise<DeepOmitRequired<U>>
-                                        : T extends {} ? { [K in ReadonlyKeys<T>]?: DeepOmitRequired<T[K]> }
-                                            : OmitRequired<T>;
 
 /**
- * Omit all readonly properties in T deeply
+ * Omit all writable properties in T
  */
-export type DeepOmitReadonly<T> =
-    T extends Builtin ? T
-        : T extends Map<infer K, infer V> ? Map<K, DeepOmitReadonly<V>>
-            : T extends ReadonlyMap<infer K, infer V> ? ReadonlyMap<K, DeepOmitReadonly<V>>
-                : T extends WeakMap<infer K, infer V> ? WeakMap<K, DeepOmitReadonly<V>>
-                    : T extends Set<infer U> ? Set<DeepOmitReadonly<U>>
-                        : T extends ReadonlySet<infer U> ? ReadonlySet<DeepOmitReadonly<U>>
-                            : T extends WeakSet<infer U> ? WeakSet<DeepOmitReadonly<U>>
-                                : T extends (infer U)[] ? T extends IsTuple<T>
-                                        ? { [K in ReadonlyKeys<T>]?: DeepOmitReadonly<T[K]> } : (DeepOmitReadonly<U>)[]
-                                    : T extends Promise<infer U> ? Promise<DeepOmitReadonly<U>>
-                                        : T extends {} ? { [K in ReadonlyKeys<T>]?: DeepOmitReadonly<T[K]> }
-                                            : OmitReadonly<T>;
-
-/**
- * Omit all non readonly properties in T deeply
- */
-export type DeepOmitWritable<T> =
-    T extends Builtin ? T
-        : T extends Map<infer K, infer V> ? Map<K, DeepOmitWritable<V>>
-            : T extends ReadonlyMap<infer K, infer V> ? ReadonlyMap<K, DeepOmitWritable<V>>
-                : T extends WeakMap<infer K, infer V> ? WeakMap<K, DeepOmitWritable<V>>
-                    : T extends Set<infer U> ? Set<DeepOmitWritable<U>>
-                        : T extends ReadonlySet<infer U> ? ReadonlySet<DeepOmitWritable<U>>
-                            : T extends WeakSet<infer U> ? WeakSet<DeepOmitWritable<U>>
-                                : T extends (infer U)[] ? T extends IsTuple<T>
-                                        ? { [K in WritableKeys<T>]?: DeepOmitWritable<T[K]> } : (DeepOmitWritable<U>)[]
-                                    : T extends Promise<infer U> ? Promise<DeepOmitWritable<U>>
-                                        : T extends {} ? { [K in WritableKeys<T>]?: DeepOmitWritable<T[K]> }
-                                            : OmitWritable<T>;
+export type OmitWritable<T> = Omit<T, WritableKeys<T>>;
 
 /**
- * Omit properties in given type in T deeply
+ * Omit all JSON friendly properties in T
  */
-export type DeepOmitType<T, S> =
-    T extends Builtin ? T
-        : T extends Map<infer K, infer V> ? Map<K, DeepOmitType<V, S>>
-            : T extends ReadonlyMap<infer K, infer V> ? ReadonlyMap<K, DeepOmitType<V, S>>
-                : T extends WeakMap<infer K, infer V> ? WeakMap<K, DeepOmitType<V, S>>
-                    : T extends Set<infer U> ? Set<DeepOmitType<U, S>>
-                        : T extends ReadonlySet<infer U> ? ReadonlySet<DeepOmitType<U, S>>
-                            : T extends WeakSet<infer U> ? WeakSet<DeepOmitType<U, S>>
-                                : T extends (infer U)[] ? T extends IsTuple<T>
-                                        ? { [K in ReadonlyKeys<T>]?: DeepOmitType<T[K], S> } : (DeepOmitType<U, S>)[]
-                                    : T extends Promise<infer U> ? Promise<DeepOmitType<U, S>>
-                                        : T extends {} ? { [K in ReadonlyKeys<T>]?: DeepOmitType<T[K], S> }
-                                            : OmitType<T, S>;
+export type OmitJson<T> = Omit<T, JsonKeys<T>>;

package/lib/pick.d.ts

@@ -1,120 +1,27 @@
-/** Like Partial but recursive */
-import {Builtin} from './common';
-import {IsTuple} from './type-check';
-import {OptionalKeys, ReadableKeys, ReadonlyKeys, RequiredKeys, TypeKeys, WritableKeys} from './keys';
+import {JsonKeys, OptionalKeys, ReadonlyKeys, RequiredKeys, WritableKeys} from './keys';
 
 /**
- * Pick all optional properties in object type
+ * Pick all optional properties in T
  */
 export type PickOptional<T> = Pick<T, OptionalKeys<T>>;
 
 /**
- * Pick all required properties in object type
+ * Pick all required properties in T
  */
 export type PickRequired<T> = Pick<T, RequiredKeys<T>>;
 
 /**
- * Pick all readonly properties in object type
+ * Pick all readonly properties in T
  */
 export type PickReadonly<T> = Pick<T, ReadonlyKeys<T>>;
 
-/**
- * Pick all readable properties in object type
- */
-export type PickReadable<T> = Pick<T, ReadableKeys<T>>;
 
 /**
- * Pick all writable properties in object type
+ * Pick all writable properties in T
  */
 export type PickWritable<T> = Pick<T, WritableKeys<T>>;
 
 /**
- * Pick all properties of given type in object type
- */
-export type PickType<T, S> = Pick<T, TypeKeys<T, S>>;
-
-/**
- * Pick all optional properties in T deeply
- */
-export type DeepPickOptional<T> =
-    T extends Builtin ? T
-        : T extends Map<infer K, infer V> ? Map<K, DeepPickOptional<V>>
-            : T extends ReadonlyMap<infer K, infer V> ? ReadonlyMap<K, DeepPickOptional<V>>
-                : T extends WeakMap<infer K, infer V> ? WeakMap<K, DeepPickOptional<V>>
-                    : T extends Set<infer U> ? Set<DeepPickOptional<U>>
-                        : T extends ReadonlySet<infer U> ? ReadonlySet<DeepPickOptional<U>>
-                            : T extends WeakSet<infer U> ? WeakSet<DeepPickOptional<U>>
-                                : T extends (infer U)[] ? T extends IsTuple<T>
-                                        ? { [K in ReadonlyKeys<T>]?: DeepPickOptional<T[K]> } : (DeepPickOptional<U>)[]
-                                    : T extends Promise<infer U> ? Promise<DeepPickOptional<U>>
-                                        : T extends {} ? { [K in ReadonlyKeys<T>]?: DeepPickOptional<T[K]> }
-                                            : PickOptional<T>;
-
-
-/**
- * Pick all non optional properties in T deeply
- */
-export type DeepPickRequired<T> =
-    T extends Builtin ? T
-        : T extends Map<infer K, infer V> ? Map<K, DeepPickRequired<V>>
-            : T extends ReadonlyMap<infer K, infer V> ? ReadonlyMap<K, DeepPickRequired<V>>
-                : T extends WeakMap<infer K, infer V> ? WeakMap<K, DeepPickRequired<V>>
-                    : T extends Set<infer U> ? Set<DeepPickRequired<U>>
-                        : T extends ReadonlySet<infer U> ? ReadonlySet<DeepPickRequired<U>>
-                            : T extends WeakSet<infer U> ? WeakSet<DeepPickRequired<U>>
-                                : T extends (infer U)[] ? T extends IsTuple<T>
-                                        ? { [K in ReadonlyKeys<T>]?: DeepPickRequired<T[K]> } : (DeepPickRequired<U>)[]
-                                    : T extends Promise<infer U> ? Promise<DeepPickRequired<U>>
-                                        : T extends {} ? { [K in ReadonlyKeys<T>]?: DeepPickRequired<T[K]> }
-                                            : PickRequired<T>;
-
-/**
- * Pick all readonly properties in T deeply
- */
-export type DeepPickReadonly<T> =
-    T extends Builtin ? T
-        : T extends Map<infer K, infer V> ? Map<K, DeepPickReadonly<V>>
-            : T extends ReadonlyMap<infer K, infer V> ? ReadonlyMap<K, DeepPickReadonly<V>>
-                : T extends WeakMap<infer K, infer V> ? WeakMap<K, DeepPickReadonly<V>>
-                    : T extends Set<infer U> ? Set<DeepPickReadonly<U>>
-                        : T extends ReadonlySet<infer U> ? ReadonlySet<DeepPickReadonly<U>>
-                            : T extends WeakSet<infer U> ? WeakSet<DeepPickReadonly<U>>
-                                : T extends (infer U)[] ? T extends IsTuple<T>
-                                        ? { [K in ReadonlyKeys<T>]?: DeepPickReadonly<T[K]> } : (DeepPickReadonly<U>)[]
-                                    : T extends Promise<infer U> ? Promise<DeepPickReadonly<U>>
-                                        : T extends {} ? { [K in ReadonlyKeys<T>]?: DeepPickReadonly<T[K]> }
-                                            : PickReadonly<T>;
-
-/**
- * Pick all non readonly properties in T deeply
- */
-export type DeepPickWritable<T> =
-    T extends Builtin ? T
-        : T extends Map<infer K, infer V> ? Map<K, DeepPickWritable<V>>
-            : T extends ReadonlyMap<infer K, infer V> ? ReadonlyMap<K, DeepPickWritable<V>>
-                : T extends WeakMap<infer K, infer V> ? WeakMap<K, DeepPickWritable<V>>
-                    : T extends Set<infer U> ? Set<DeepPickWritable<U>>
-                        : T extends ReadonlySet<infer U> ? ReadonlySet<DeepPickWritable<U>>
-                            : T extends WeakSet<infer U> ? WeakSet<DeepPickWritable<U>>
-                                : T extends (infer U)[] ? T extends IsTuple<T>
-                                        ? { [K in WritableKeys<T>]?: DeepPickWritable<T[K]> } : (DeepPickWritable<U>)[]
-                                    : T extends Promise<infer U> ? Promise<DeepPickWritable<U>>
-                                        : T extends {} ? { [K in WritableKeys<T>]?: DeepPickWritable<T[K]> }
-                                            : PickWritable<T>;
-
-/**
- * Pick properties in given type in T deeply
+ * Pick all JSON friendly properties (no symbols) in T
  */
-export type DeepPickType<T, S> =
-    T extends Builtin ? T
-        : T extends Map<infer K, infer V> ? Map<K, DeepPickType<V, S>>
-            : T extends ReadonlyMap<infer K, infer V> ? ReadonlyMap<K, DeepPickType<V, S>>
-                : T extends WeakMap<infer K, infer V> ? WeakMap<K, DeepPickType<V, S>>
-                    : T extends Set<infer U> ? Set<DeepPickType<U, S>>
-                        : T extends ReadonlySet<infer U> ? ReadonlySet<DeepPickType<U, S>>
-                            : T extends WeakSet<infer U> ? WeakSet<DeepPickType<U, S>>
-                                : T extends (infer U)[] ? T extends IsTuple<T>
-                                        ? { [K in ReadonlyKeys<T>]?: DeepPickType<T[K], S> } : (DeepPickType<U, S>)[]
-                                    : T extends Promise<infer U> ? Promise<DeepPickType<U, S>>
-                                        : T extends {} ? { [K in ReadonlyKeys<T>]?: DeepPickType<T[K], S> }
-                                            : PickType<T, S>;
+export type PickJson<T> = Pick<T, JsonKeys<T>>;

package/lib/type-check.d.ts

@@ -1,110 +1,160 @@
-import {NonObj} from './common';
+import {Primitive, Type} from './common';
 
-/**
- * Returns Y if typeof T is "never", N otherwise
- */
-export type IsExtends<T, U> = [T] extends [U] ? true : false;
+type NonObj = Primitive | Function;
 
 /**
- * Returns Y if typeof T is "never", N otherwise
+ * Returns Y if typeof T is "any", N otherwise
  */
-export type IfNever<T, Y, N = never> = [T] extends [never] ? Y : N;
+export type IfAny<T, Y = true, N = false> =
+    0 extends 1 & T ? Y : N;
 
 /**
- * Returns true if typeof T is "never", false otherwise
+ * Returns "Y" if "T" is "never", "N" otherwise
  */
-export type IsNever<T> = IfNever<T, true, false>;
+export type IfNever<T, Y = true, N = false> =
+    [T] extends [never] ? Y : N;
 
 /**
- * Returns Y if typeof T is "any", N otherwise
+ * Returns Y if T is undefined, N otherwise
  */
-export type IfAny<T, Y = T, N = never> = 0 extends (1 & T) ? Y : N;
+export type IfUndefined<T, Y = true, N = false> =
+    IfEquals<T, undefined, Y, N>;
 
 /**
- * Returns true if typeof T is "any", false otherwise
+ * Returns Y if typeof T is "unknown", N otherwise
  */
-export type IsAny<T> = IfAny<T, true, false>;
+export type IfUnknown<T, Y = true, N = false> =
+    IfEquals<T, unknown, Y, N>;
 
 /**
- * Returns Y if typeof T is "unknown", N otherwise
+ * Returns Y if typeof T is null, N otherwise
  */
-export type IfUnknown<T, Y, N = never> =
-    unknown extends T ?
-            IsAny<T> extends false
-                ? IfEmptyObject<T, N, Y>
-                : N
-            : N;
+export type IfNull<T, Y = true, N = false> =
+    IfEquals<T, null, Y, N>;
+
 /**
- * Returns true if typeof T is "unknown", false otherwise
+ * Returns Y if typeof T is null, N otherwise
  */
-export type IsUnknown<T> = IfUnknown<T, true, false>;
+export type IfNullish<T, Y = true, N = false> =
+    IfNever<T> extends true ? N
+        : T extends null ? Y
+            : T extends undefined ? Y : N;
+
 
 /**
  * Returns Y if typeof T is a tuple, N otherwise
  */
-export type IfTuple<T, Y = T, N = never> =
-    IsNever<T> extends true
-        ? N
-        : T extends any[]
+export type IfTuple<T, Y = true, N = false> =
+    IfEquals<T, [any]> extends true
+        ? T extends [any]
             ? number extends T['length'] ? N : Y
-            : N;
+            : N : N;
+export type IfTupleOrAny<T, Y = true, N = false> =
+    IfAny<T> extends true ? Y : IfTuple<T, Y, N>;
 
 /**
- * Returns true if typeof T is a tuple, false otherwise
+ * Returns Y if typeof T is "Primitive", N otherwise
  */
-export type IsTuple<T> = IfTuple<T, true, false>;
+export type IfPrimitive<T, Y = true, N = false> =
+    IfNever<T> extends true ? N :
+        IfClass<T> extends true ? N :
+            IfFunction<T> extends true ? N :
+                T extends Primitive ? Y :
+                    N;
 
-/**
- * Returns Y if typeof T is an object, N otherwise
- */
-export type IfObject<T, Y = T, N = never> =
-    IfNever<T, N,
-        T extends object
-            ? T extends NonObj | any[]
-                ? N
-                : Y
-            : N>;
+export type IfPrimitiveOrAny<T, Y = true, N = false> =
+    IfAny<T> extends true ? Y : IfPrimitive<T, Y, N>;
 
 /**
- * Returns true if typeof T is an object, false otherwise
+ * Returns Y if typeof T is JSON like, N otherwise
  */
-export type IsObject<T> = IfObject<T, true, false>;
+export type IfJson<T, Y = true, N = false> =
+    IfNull<T> extends true ? Y :
+        IfNever<T> extends true ? N :
+            IfUnknown<T> extends true ? N :
+                IfClass<T> extends true ? N :
+                    IfFunction<T> extends true ? N :
+                        IfUndefined<T> extends true ? N :
+                            T extends symbol ? N :
+                                T extends (infer U)[] ? IfJson<U> extends true ? Y : N
+                                    : Y;
+
+export type IfJsonOrAny<T, Y = true, N = false> =
+    IfAny<T> extends true ? Y : IfJson<T, Y, N>;
 
 /**
  * Returns Y if typeof T is an empty object, N otherwise
  */
-export type IfEmptyObject<T extends {}, Y = T, N = never> =
-    IsNever<T> extends true
-        ? N
-        : T extends object
-            ? keyof T extends never ? Y : N
-            : N
+export type IfEmptyObject<T, Y = true, N = false> =
+    IfEquals<T, {}, Y, N>;
 
 /**
- * Returns true if typeof T is an empty object, false otherwise
+ * Returns Y if typeof T is an object, N otherwise
  */
-export type IsEmptyObject<T extends {}> = IfEmptyObject<T, true, false>;
+export type IfObject<T, Y = true, N = false> =
+    IfNever<T> extends true ? N
+        : T extends object
+            ? T extends NonObj | any[]
+                ? N
+                : Y
+            : N;
 
+export type IfObjectOrAny<T, Y = true, N = false> =
+    IfAny<T> extends true ? Y : IfObject<T, Y, N>;
 
 /**
- * Returns Y if T1 is exactly same with T2, N otherwise
+ * Returns Y if typeof T is an empty object, N otherwise
  */
-type IfEquals<T1, T2, Y = T1, N = never> =
-    (<G>() => G extends T1 ? 1 : 2) extends (<G>() => G extends T2 ? 1 : 2) ? Y : N;
+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;
+
+export type IfFunctionOrAny<T, Y = true, N = false> =
+    IfAny<T> extends true ? Y : IfFunction<T, Y, N>;
 
 /**
- * Returns true if T1 is exactly same with T2, false otherwise
+ * Returns Y if typeof T is an empty object, N otherwise
  */
-export type IsEquals<T1, T2> = IfEquals<T1, T2, true, false>;
+export type IfClass<T, Y = true, N = false> =
+    IfNever<T> extends true ? N
+        : IfUndefined<T> extends true ? N
+            : IfNull<T> extends true ? N
+                : T extends Type ? Y
+                    : N;
+
+export type IfClassOrAny<T, Y = true, N = false> =
+    IfAny<T> extends true ? Y : IfClass<T, Y, N>;
 
 
 /**
- * Returns Y if T1 is exactly same with T2, N otherwise
+ * Returns "Y" if "T1" is exactly same with "T2", "N" otherwise
  */
-export type IfUndefined<T, Y = T, N = never> =
-    T extends undefined ? Y: N;
+type IfEquals<T1, T2, Y = true, N = false> =
+    (<G>() => G extends T1 ? 1 : 2) extends (<G>() => G extends T2 ? 1 : 2) ? Y : N;
 
 /**
- * Returns true if T is undefined type
- */
-export type IsUndefined<T> = IfUndefined<T, true, false>;
+ * Returns "Y" if type "T" matches "U", "N" otherwise
+ */
+export type IfCompatible<T1, T2, Y = true, N = false> =
+    IfUndefined<T1> extends true ? IfEquals<T1, T2, Y, N> : IfUndefined<T2> extends true ? N
+        : IfNever<T1> extends true ? IfEquals<T1, T2, Y, N> : IfNever<T2> extends true ? N
+            : IfNull<T1> extends true ? IfEquals<T1, T2, Y, N> : IfNull<T2> extends true ? N
+                : IfUnknown<T1> extends true ? Y : IfUnknown<T2> extends true ? Y
+                    : IfAny<T1> extends true ? Y : IfAny<T2> extends true ? Y
+                        : IfEmptyObject<T1> extends true ? IfObject<T2, Y, N>
+                            : IfEmptyObject<T2> extends true ? IfObject<T1, Y, N>
+                                : IfFunction<T1> extends true ? IfCompatibleFunction<T1, T2, Y, N>
+                                    : IfObject<T1> extends true ? [T1] extends [T2] ? Y : N
+                                        : [T1] extends [T2] ? Y
+                                            : IfPrimitive<T2> extends true ? [T2] extends [T1] ? Y
+                                                : N : N;
+
+type IfCompatibleFunction<T1, T2, Y = true, N = false> =
+    IfFunction<T1> extends false ? N
+        : IfFunction<T2> extends false ? N
+            : T1 extends T2
+                ? Y
+                : N;

package/package.json

@@ -12,14 +12,14 @@
     "lodash",
     "underscore"
   ],
-  "version": "0.0.3",
+  "version": "1.1.1",
   "types": "lib/index.d.ts",
   "repository": "git@github.com:panates/ts-gems.git",
   "author": "Eray Hanoglu <e.hanoglu@panates.com>",
   "license": "MIT",
   "scripts": {
-    "test:common": "jest --clearCache && jest --config=./test/jest.config.js",
-    "test:strict-null": "jest --clearCache && jest --config=./test/jest.strict-null.config.js",
+    "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",
     "release": "npm run test && npm publish"
   },
@@ -32,9 +32,10 @@
     "typescript": ">=4.0.0"
   },
   "devDependencies": {
-    "@types/jest": "^27.0.2",
-    "prettier": "^2.4.1",
-    "ts-jest": "^27.0.5",
-    "typescript": "^4.4.3"
+    "@types/jest": "^27.4.0",
+    "jest": "^27.4.7",
+    "prettier": "^2.5.1",
+    "ts-jest": "^27.1.3",
+    "typescript": "^4.5.5"
   }
 }