ts-gems 1.5.2 → 2.2.0

package/lib/common.d.ts

@@ -68,11 +68,11 @@ export type ElementType<T extends { [P in K & any]: any },
 
 
 /**
- * Class
+ * Type
  * @desc Represents constructor of type T
  */
 export interface Type<T = any> {
-    new(...args: any[]): T;
+  new(...args: any[]): T;
 }
 
 /**
@@ -81,3 +81,18 @@ export interface Type<T = any> {
  */
 export type Class<Args extends any[] = any[], Instance = {}, Static = {}> =
     (new(...args: Args) => Instance) & Static;
+
+/**
+ * NoUnion
+ * @desc Returns "never" if the type is union
+ */
+type NoUnion<T, U = T> = T extends U ? [U] extends [T] ? T : never : never;
+
+
+/**
+ * Opaque
+ * @desc Create unique type that can't be assigned to base type by accident.
+ */
+type Opaque<T, N extends string> = T & {
+  __type: N;
+}

package/lib/deep-pick.d.ts

@@ -1,4 +1,4 @@
-import {Builtin, Type} from './common';
+import {Builtin} from './common';
 import {IfClass, IfTuple} from './type-check';
 import {JsonKeys, OptionalKeys, ReadonlyKeys, RequiredKeys, WritableKeys} from './keys';
 
@@ -8,100 +8,159 @@ import {JsonKeys, OptionalKeys, ReadonlyKeys, RequiredKeys, WritableKeys} from '
 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>> };
+        : IfTuple<T> extends true ? T
+            : IfClass<T> extends true ? T
+                : T extends Promise<infer U> ? Promise<DeepPickOptional<U>>
+                    : T extends Map<any, any> ? T
+                        : T extends ReadonlyMap<any, any> ? T
+                            : T extends WeakMap<any, any> ? T
+                                : T extends Set<any> ? T
+                                    : T extends ReadonlySet<any> ? T
+                                        : T extends WeakSet<any> ? T
+                                            : T extends any[] ? T
+                                                : { [P in K]?: DeepPickOptional<Exclude<T[P], undefined>> };
 
 /**
- * Pick all required properties in T deeply
+ * Pick all optional properties in T deeply
+ */
+export type StrictDeepPickOptional<T> = _StrictDeepPickOptional<T>;
+type _StrictDeepPickOptional<T, K extends keyof T = OptionalKeys<T>> =
+    T extends Builtin ? T
+        : IfTuple<T> extends true ? T
+            : IfClass<T> extends true ? T
+                : T extends Promise<infer U> ? Promise<StrictDeepPickOptional<U>>
+                    : T extends Map<infer K, infer V> ? Map<K, StrictDeepPickOptional<V>>
+                        : T extends ReadonlyMap<infer K, infer V> ? ReadonlyMap<K, StrictDeepPickOptional<V>>
+                            : T extends WeakMap<infer K, infer V> ? WeakMap<K, StrictDeepPickOptional<V>>
+                                : T extends Set<infer U> ? Set<StrictDeepPickOptional<U>>
+                                    : T extends ReadonlySet<infer U> ? ReadonlySet<StrictDeepPickOptional<U>>
+                                        : T extends WeakSet<infer U> ? WeakSet<StrictDeepPickOptional<U>>
+                                            : T extends (infer U)[] ? StrictDeepPickOptional<U>[]
+                                                : { [P in K]?: StrictDeepPickOptional<Exclude<T[P], undefined>> };
+
+/**
+ * Pick all required properties in T deeply even in Maps, Sets etc
  */
 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>> };
+        : IfTuple<T> extends true ? T
+            : IfClass<T> extends true ? T
+                : T extends Promise<infer U> ? Promise<DeepPickRequired<U>>
+                    : T extends Map<any, any> ? T
+                        : T extends ReadonlyMap<any, any> ? T
+                            : T extends WeakMap<any, any> ? T
+                                : T extends Set<any> ? T
+                                    : T extends ReadonlySet<any> ? T
+                                        : T extends WeakSet<any> ? T
+                                            : T extends any[] ? T
+                                                : { [P in J]-?: DeepPickRequired<Exclude<T[P], undefined>> };
+
+/**
+ * Pick all required properties in T deeply even in Maps, Sets etc
+ */
+export type StrictDeepPickRequired<T> = _StrictDeepPickRequired<T>;
+type _StrictDeepPickRequired<T, J extends keyof T = RequiredKeys<T>> =
+    T extends Builtin ? T
+        : IfTuple<T> extends true ? T
+            : IfClass<T> extends true ? T
+                : T extends Promise<infer U> ? Promise<StrictDeepPickRequired<U>>
+                    : T extends Map<infer K, infer V> ? Map<K, StrictDeepPickRequired<V>>
+                        : T extends ReadonlyMap<infer K, infer V> ? ReadonlyMap<K, StrictDeepPickRequired<V>>
+                            : T extends WeakMap<infer K, infer V> ? WeakMap<K, StrictDeepPickRequired<V>>
+                                : T extends Set<infer U> ? Set<StrictDeepPickRequired<U>>
+                                    : T extends ReadonlySet<infer U> ? ReadonlySet<StrictDeepPickRequired<U>>
+                                        : T extends WeakSet<infer U> ? WeakSet<StrictDeepPickRequired<U>>
+                                            : T extends (infer U)[] ? StrictDeepPickRequired<U>[]
+                                                : { [P in J]-?: StrictDeepPickRequired<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>> =
+type _DeepPickReadonly<T, K 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>> };
+        : IfTuple<T> extends true ? T
+            : IfClass<T> extends true ? T
+                : T extends Promise<infer U> ? Promise<DeepPickReadonly<U>>
+                    : T extends Map<any, any> ? T
+                        : T extends ReadonlyMap<any, any> ? T
+                            : T extends WeakMap<any, any> ? T
+                                : T extends Set<any> ? T
+                                    : T extends ReadonlySet<any> ? T
+                                        : T extends WeakSet<any> ? T
+                                            : T extends any[] ? T
+                                                : { [P in K]: DeepPickReadonly<Exclude<T[P], undefined>> };
+
+/**
+ * Pick all readonly properties in T deeply even in Maps, Sets etc
+ */
+export type StrictDeepPickReadonly<T> = _StrictDeepPickReadonly<T>;
+type _StrictDeepPickReadonly<T, J extends keyof T = ReadonlyKeys<T>> =
+    T extends Builtin ? T
+        // : IfTuple<T> extends true ? T
+        // : IfClass<T> extends true ? T
+        : T extends Promise<infer U> ? Promise<StrictDeepPickReadonly<U>>
+            : T extends Map<infer K, infer V> ? Map<K, StrictDeepPickReadonly<V>>
+                : T extends ReadonlyMap<infer K, infer V> ? ReadonlyMap<K, StrictDeepPickReadonly<V>>
+                    : T extends WeakMap<infer K, infer V> ? WeakMap<K, StrictDeepPickReadonly<V>>
+                        : T extends Set<infer U> ? Set<StrictDeepPickReadonly<U>>
+                            : T extends ReadonlySet<infer U> ? ReadonlySet<StrictDeepPickReadonly<U>>
+                                : T extends WeakSet<infer U> ? WeakSet<StrictDeepPickReadonly<U>>
+                                    : T extends (infer U)[] ? StrictDeepPickReadonly<U>[]
+                                        : { [P in J]: StrictDeepPickReadonly<Exclude<T[P], undefined>> };
 
 /**
  * Pick all writable properties in T deeply
  */
-export type DeepPickWritable<T> = _DeepPickWritable<T>
+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]> }
-                                        : IfClass<T> extends true ? DeepPickWritable<Type<T>>
-                                            : T extends (infer U)[] ? DeepPickWritable<U>[]
-                                                : { [P in K]: DeepPickWritable<Exclude<T[P], undefined>> }
+        : IfTuple<T> extends true ? T
+            : IfClass<T> extends true ? T
+                : T extends Promise<infer U> ? Promise<DeepPickWritable<U>>
+                    : T extends Map<any, any> ? T
+                        : T extends ReadonlyMap<any, any> ? T
+                            : T extends WeakMap<any, any> ? T
+                                : T extends Set<any> ? T
+                                    : T extends ReadonlySet<any> ? T
+                                        : T extends WeakSet<any> ? T
+                                            : T extends any[] ? T
+                                                : { [P in K]: DeepPickWritable<Exclude<T[P], undefined>> };
 
 /**
- * Pick all JSON friendly properties in T deeply
+ * Pick all writable properties in T deeply even in Maps, Sets etc
  */
-export type DeepPickJson<T> = _DeepPickJson<T>
-type _DeepPickJson<T, Keys extends keyof T = JsonKeys<T>> =
+export type StrictDeepPickWritable<T> = _StrictDeepPickWritable<T>
+type _StrictDeepPickWritable<T, K extends keyof T = WritableKeys<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 Keys]: DeepPickJson<Exclude<T[P], undefined>> };
-
+        : IfTuple<T> extends true ? T
+            : IfClass<T> extends true ? T
+                : T extends Promise<infer U> ? Promise<StrictDeepPickWritable<U>>
+                    : T extends Map<infer K, infer V> ? Map<K, StrictDeepPickWritable<V>>
+                        : T extends ReadonlyMap<infer K, infer V> ? ReadonlyMap<K, StrictDeepPickWritable<V>>
+                            : T extends WeakMap<infer K, infer V> ? WeakMap<K, StrictDeepPickWritable<V>>
+                                : T extends Set<infer U> ? Set<StrictDeepPickWritable<U>>
+                                    : T extends ReadonlySet<infer U> ? ReadonlySet<StrictDeepPickWritable<U>>
+                                        : T extends WeakSet<infer U> ? WeakSet<StrictDeepPickWritable<U>>
+                                            : T extends (infer U)[] ? StrictDeepPickWritable<U>[]
+                                                : { -readonly [P in K]: StrictDeepPickWritable<Exclude<T[P], undefined>> }
 
 /**
  * Pick all JSON friendly properties in T deeply
  */
-export type DeepPickWritableJson<T> = _DeepPickWritableJson<T>
-type _DeepPickWritableJson<T, Keys extends keyof T = Exclude<JsonKeys<T>, ReadonlyKeys<T>>> =
+export type DeepPickJson<T> = _DeepPickJson<T>
+type _DeepPickJson<T, Keys extends keyof T = JsonKeys<T>> =
     T extends Builtin ? T
-        : T extends Promise<infer U> ? Promise<DeepPickWritableJson<U>>
-            : T extends Map<infer K, infer V> ? Map<K, DeepPickWritableJson<V>>
-                : T extends ReadonlyMap<infer K, infer V> ? ReadonlyMap<K, DeepPickWritableJson<V>>
-                    : T extends WeakMap<infer K, infer V> ? WeakMap<K, DeepPickWritableJson<V>>
-                        : T extends Set<infer U> ? Set<DeepPickWritableJson<U>>
-                            : T extends ReadonlySet<infer U> ? ReadonlySet<DeepPickWritableJson<U>>
-                                : T extends WeakSet<infer U> ? WeakSet<DeepPickWritableJson<U>>
-                                    : IfTuple<T> extends true ? { [K in OptionalKeys<T>]?: DeepPickWritableJson<T[K]> }
-                                        : T extends (infer U)[] ? DeepPickWritableJson<U>[]
-                                            : { [P in Keys]: DeepPickWritableJson<Exclude<T[P], undefined>> };
+        : IfTuple<T> extends true ? T
+            : IfClass<T> extends true ? T
+                : T extends Promise<infer U> ? Promise<DeepPickJson<U>>
+                    : T extends Map<any, any> ? T
+                        : T extends ReadonlyMap<any, any> ? T
+                            : T extends WeakMap<any, any> ? T
+                                : T extends Set<any> ? T
+                                    : T extends ReadonlySet<any> ? T
+                                        : T extends WeakSet<any> ? T
+                                            : T extends any[] ? T
+                                                : { [P in Keys]: DeepPickJson<Exclude<T[P], undefined>> };

package/lib/modify.d.ts

@@ -2,10 +2,30 @@
  * Make all properties in T writable
  */
 export type Writable<T> = {
-    -readonly [P in keyof T]: T[P];
+  -readonly [P in keyof T]: T[P];
 };
 
 /**
  * Combination of Partial and Writable
  */
 export type Buildable<T> = Partial<Writable<T>>;
+
+/**
+ * Marks given keys as optional
+ */
+export type PartialSome<T, K extends keyof T> = Partial<Pick<T, K>> & Omit<T, K>;
+
+/**
+ * Marks given keys as required
+ */
+export type RequiredSome<T, K extends keyof T> = Required<Pick<T, K>> & Omit<T, K>;
+
+/**
+ * Marks given keys as readonly
+ */
+export type ReadonlySome<T, K extends keyof T> = Readonly<Pick<T, K>> & Omit<T, K>;
+
+/**
+ * Marks given keys as writable
+ */
+export type WritableSome<T, K extends keyof T> = Writable<Pick<T, K>> & Omit<T, K>;

package/lib/omit.d.ts

@@ -1,5 +1,7 @@
 import {JsonKeys, OptionalKeys, ReadonlyKeys, RequiredKeys, WritableKeys} from './keys';
 
+export type StrictOmit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
+
 /**
  * Omit all optional properties in T
  */

package/lib/type-check.d.ts

@@ -115,7 +115,7 @@ export type IfFunctionOrAny<T, Y = true, N = false> =
     IfAny<T> extends true ? Y : IfFunction<T, Y, N>;
 
 /**
- * Returns Y if typeof T is an empty object, N otherwise
+ * Returns Y if typeof T is a constructor type, N otherwise
  */
 export type IfClass<T, Y = true, N = false> =
     IfNever<T> extends true ? N
@@ -131,8 +131,15 @@ export type IfClassOrAny<T, Y = true, N = false> =
 /**
  * Returns "Y" if "T1" is exactly same with "T2", "N" otherwise
  */
-type IfEquals<T1, T2, Y = true, N = false> =
-    (<G>() => G extends T1 ? 1 : 2) extends (<G>() => G extends T2 ? 1 : 2) ? Y : N;
+type EqualsWrapped<T> = T extends infer R & {}
+    ? {
+      [P in keyof R]: R[P]
+    }
+    : never
+export type IfEquals<T1, T2, Y = true, N = false> =
+        IfObject<T1> | IfObject<T2> extends true
+    ? ((<G>() => G extends EqualsWrapped<T1> ? 1 : 2) extends (<G>() => G extends EqualsWrapped<T2> ? 1 : 2) ? Y : N)
+    : ((<G>() => G extends T1 ? 1 : 2) extends (<G>() => G extends T2 ? 1 : 2) ? Y : N);
 
 /**
  * Returns "Y" if type "T" matches "U", "N" otherwise

package/package.json

@@ -12,7 +12,7 @@
     "lodash",
     "underscore"
   ],
-  "version": "1.5.2",
+  "version": "2.2.0",
   "types": "lib/index.d.ts",
   "repository": "git@github.com:panates/ts-gems.git",
   "author": "Eray Hanoglu <e.hanoglu@panates.com>",
@@ -33,10 +33,10 @@
     "typescript": ">=4.0.0"
   },
   "devDependencies": {
-    "@types/jest": "^27.4.0",
-    "jest": "^27.4.7",
-    "prettier": "^2.5.1",
-    "ts-jest": "^27.1.3",
-    "typescript": "^4.5.5"
+    "@types/jest": "^28.1.4",
+    "eslint": "^8.19.0",
+    "jest": "^28.1.2",
+    "ts-jest": "^28.0.5",
+    "typescript": "^4.7.4"
   }
 }