ts-gems 3.3.0 → 3.4.0

package/lib/type-check.d.ts

@@ -5,150 +5,190 @@ type NonObj = Primitive | Function;
 /**
  * Returns Y if typeof T is "any", N otherwise
  */
-export type IfAny<T, Y = true, N = false> =
-    0 extends 1 & T ? Y : N;
+export type IfAny<T, Y = true, N = false> = 0 extends 1 & T ? Y : N;
 
 /**
  * Returns "Y" if "T" is "never", "N" otherwise
  */
-export type IfNever<T, Y = true, N = false> =
-    [T] extends [never] ? Y : N;
+export type IfNever<T, Y = true, N = false> = [T] extends [never] ? Y : N;
 
 /**
  * Returns Y if T is undefined, N otherwise
  */
-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>;
 
 /**
  * Returns "Y" if "T" is "never", "N" otherwise
  */
-export type IfSymbol<T, Y = true, N = false> =
-    IfEquals<T, symbol, Y, N>;
+export type IfSymbol<T, Y = true, N = false> = IfEquals<T, symbol, Y, N>;
 
 /**
  * Returns Y if typeof T is "unknown", N otherwise
  */
-export type IfUnknown<T, Y = true, N = false> =
-    IfEquals<T, unknown, Y, N>;
+export type IfUnknown<T, Y = true, N = false> = IfEquals<T, unknown, Y, N>;
 
 /**
  * Returns Y if typeof T is null, N otherwise
  */
-export type IfNull<T, Y = true, N = false> =
-    IfEquals<T, null, Y, N>;
+export type IfNull<T, Y = true, N = false> = IfEquals<T, null, Y, N>;
 
 /**
  * Returns Y if typeof T is null, N otherwise
  */
 export type IfNullish<T, Y = true, N = false> =
-    IfNever<T> extends true ? N
-        : T extends null ? Y
-            : T extends undefined ? Y : N;
-
+  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 = true, N = false> =
-    IfEquals<T, [any]> extends true
-        ? T extends [any]
-            ? number extends T['length'] ? N : Y
-            : N : N;
+  IfEquals<T, [any]> extends true
+    ? T extends [any]
+      ? number extends T['length']
+        ? N
+        : Y
+      : N
+    : N;
 export type IfTupleOrAny<T, Y = true, N = false> =
-    IfAny<T> extends true ? Y : IfTuple<T, Y, N>;
+  IfAny<T> extends true ? Y : IfTuple<T, Y, N>;
 
 /**
  * Returns Y if typeof T is "Primitive", N otherwise
  */
 export type IfPrimitive<T, Y = true, N = false> =
-    IfNever<T> extends true ? N :
-        IfNull<T> extends true ? Y :
-            IfUndefined<T> extends true ? Y :
-                IfClass<T> extends true ? N :
-                    IfFunction<T> extends true ? N :
-                        T extends Primitive ? Y :
-                            N;
+  IfNever<T> extends true
+    ? N
+    : IfNull<T> extends true
+      ? Y
+      : IfUndefined<T> extends true
+        ? Y
+        : IfClass<T> extends true
+          ? N
+          : IfFunction<T> extends true
+            ? N
+            : T extends Primitive
+              ? Y
+              : N;
 
 export type IfPrimitiveOrAny<T, Y = true, N = false> =
-    IfAny<T> extends true ? Y : IfPrimitive<T, Y, N>;
+  IfAny<T> extends true ? Y : IfPrimitive<T, Y, N>;
 
 /**
  * Returns Y if typeof T is an empty object, N otherwise
  */
-export type IfEmptyObject<T, Y = true, N = false> =
-    IfEquals<T, {}, Y, N>;
+export type IfEmptyObject<T, Y = true, N = false> = IfEquals<T, {}, Y, N>;
 
 /**
  * Returns Y if typeof T is an object, N otherwise
  */
 export type IfObject<T, Y = true, N = false> =
-    IfNever<T> extends true ? N
-        : T extends object
-            ? T extends NonObj | any[]
-                ? N
-                : Y
-            : N;
+  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>;
+  IfAny<T> extends true ? Y : IfObject<T, Y, N>;
 
 /**
  * Returns Y if typeof T is an empty object, N otherwise
  */
 export type IfFunction<T, Y = true, N = false> =
-    IfNever<T> extends true ? N
-        : T extends Type ? N
-            : T extends Function ? Y
-                : N;
+  IfNever<T> extends true ? 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>;
+  IfAny<T> extends true ? Y : IfFunction<T, Y, N>;
 
 /**
  * Returns Y if typeof T is a constructor type, N otherwise
  */
 export type IfClass<T, Y = true, N = false> =
-    IfNever<T> extends true ? N
-        : IfUndefined<T> extends true ? N
-            : T extends Type ? Y : N;
+  IfNever<T> extends true
+    ? N
+    : IfUndefined<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>;
-
+  IfAny<T> extends true ? Y : IfClass<T, Y, N>;
 
 /**
  * Returns "Y" if "T1" is exactly same with "T2", "N" otherwise
  */
 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);
+  | 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;
 
 type EqualsWrapped<T> = T extends infer R & {}
-    ? { [P in keyof R]: R[P] }
-    : never;
+  ? { [P in keyof R]: R[P] }
+  : never;
 
 /**
  * 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;
+  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;
+  IfFunction<T1> extends false
+    ? N
+    : IfFunction<T2> extends false
+      ? N
+      : T1 extends T2
+        ? Y
+        : N;

package/lib/types.d.ts

@@ -13,11 +13,13 @@ declare global {
 
     cancel(reason?: any): Promise<void>;
 
-    getReader(options: { mode: "byob" }): ReadableStreamBYOBReader;
+    getReader(options: { mode: 'byob' }): ReadableStreamBYOBReader;
 
     getReader(): ReadableStreamDefaultReader<R>;
 
-    getReader(options?: ReadableStreamGetReaderOptions): ReadableStreamReader<R>;
+    getReader(
+      options?: ReadableStreamGetReaderOptions,
+    ): ReadableStreamReader<R>;
   }
 
   export interface WritableStream<W = any> {
@@ -35,7 +37,6 @@ declare global {
  */
 type BasicPrimitive = number | string | boolean;
 
-
 /**
  * Primitive
  * @desc Type representing [`Primitive`](https://developer.mozilla.org/en-US/docs/Glossary/Primitive) types
@@ -47,33 +48,52 @@ export type Primitive = BasicPrimitive | null | bigint | symbol | undefined;
  * JsonTypes
  * @desc Type representing JSON types in TypeScript
  */
-type JsonType = BasicPrimitive | null | object | (BasicPrimitive | object)[]
-
+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 |
-    Buffer | ArrayBuffer | Int8Array | Uint8Array | Uint8ClampedArray |
-    Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array |
-    URL | ReadableStream | WritableStream;
+export type Builtin =
+  | Primitive
+  | Function
+  | String
+  | Number
+  | Date
+  | Error
+  | RegExp
+  | Buffer
+  | ArrayBuffer
+  | Int8Array
+  | Uint8Array
+  | Uint8ClampedArray
+  | Int16Array
+  | Uint16Array
+  | Int32Array
+  | Uint32Array
+  | Float32Array
+  | Float64Array
+  | URL
+  | ReadableStream
+  | WritableStream;
 
 /**
  * Type
  * @desc Represents constructor of type T
  */
 export interface Type<T = any> {
-  new(...args: any[]): T;
+  new (...args: any[]): 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 Class<
+  Args extends any[] = any[],
+  Instance = {},
+  Static = {},
+> = (new (...args: Args) => Instance) & Static;
 
 /**
  * Maybe
@@ -87,18 +107,15 @@ export type Maybe<T> = T | undefined;
  */
 export type Nullish<T = null> = T | undefined | null;
 
-
 export type Awaited<T> = T extends PromiseLike<infer U> ? U : T;
 
-
 export type Thunk<T> = T | (() => T);
-export type ThunkAsync<T> = Thunk<T> | (() => Promise<T>)
+export type ThunkAsync<T> = Thunk<T> | (() => Promise<T>);
 export type TypeThunk<T = any> = Thunk<Type<T>>;
 export type TypeThunkAsync<T = any> = ThunkAsync<Type<T>>;
 
 export type MaybePromise<T> = T | Promise<T>;
 
-
 /**
  * PropertyType
  * @desc Returns the type of property at a given key `K`
@@ -109,5 +126,7 @@ 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];
+export type ElementType<
+  T extends { [P in K & any]: any },
+  K extends keyof T | number,
+> = T[K];

package/package.json

@@ -12,18 +12,20 @@
     "lodash",
     "underscore"
   ],
-  "version": "3.3.0",
+  "version": "3.4.0",
+  "type": "module",
+  "module": "lib/index.mjs",
+  "main": "lib/index.cjs",
   "types": "lib/index.d.ts",
-  "main": "lib/index.js",
-  "module": "lib/index.js",
   "repository": "git@github.com:panates/ts-gems.git",
   "author": "Eray Hanoglu <e.hanoglu@panates.com>",
   "license": "MIT",
   "scripts": {
     "compile": "tsc -b tsconfig.json",
     "lint": "eslint --no-error-on-unmatched-pattern",
-    "test:common": "jest --clearCache && jest --config=./jest.config.js",
-    "test:nostrict": "jest --clearCache && jest --config=./jest.nostrict.config.js",
+    "format": "prettier . --write --log-level=warn",
+    "test:common": "jest --clearCache && jest --config=./jest.config.mjs",
+    "test:nostrict": "jest --clearCache && jest --config=./jest.nostrict.config.mjs",
     "test": "npm run test:common && npm run test:nostrict"
   },
   "files": [
@@ -33,8 +35,15 @@
   ],
   "devDependencies": {
     "@types/jest": "^29.5.12",
-    "eslint": "^9.0.0",
+    "eslint": "^8.57.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-import": "^2.29.1",
+    "eslint-plugin-prettier": "^5.1.3",
+    "eslint-plugin-security": "^3.0.0",
+    "eslint-plugin-simple-import-sort": "^12.1.0",
+    "eslint-plugin-unused-imports": "^3.1.0",
     "jest": "^29.7.0",
+    "prettier": "^3.2.5",
     "ts-jest": "^29.1.2",
     "typescript": "^5.4.5"
   }