ts-gems 2.7.2 → 2.7.4

package/lib/common.d.ts

@@ -24,8 +24,9 @@ type JsonType = BasicPrimitive | null | object | (BasicPrimitive | object)[]
  * @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;
+    Buffer | ArrayBuffer | Int8Array | Uint8Array | Uint8ClampedArray |
+    Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array |
+    URL | ReadableStream | WritableStream;
 
 /**
  * Maybe

package/lib/deep-buildable.d.ts

@@ -1,11 +1,11 @@
-import { IsDeepExcluded } from './helpers.js';
+import { IfNoDeepValue } from './helpers.js';
 
 /**
  * Combination of Partial and Writable but deeply
  */
 export type DeepBuildable<T> = _DeepBuildable<T>;
 type _DeepBuildable<T> =
-    IsDeepExcluded<T> extends true ? T
+    IfNoDeepValue<T> extends true ? T
         : { -readonly [P in keyof T]?: _DeepBuildable<Exclude<T[P], undefined>> };
 
 /**
@@ -14,6 +14,6 @@ type _DeepBuildable<T> =
 export type HighDeepBuildable<T> = _HighDeepBuildable<T>;
 type _HighDeepBuildable<T> =
     T extends (infer U)[] ? _HighDeepBuildable<U>[]
-        : IsDeepExcluded<T> extends true ? T
+        : IfNoDeepValue<T> extends true ? T
             : T extends (infer U)[] ? _HighDeepBuildable<U>[]
                 : { -readonly [P in keyof T]?: _HighDeepBuildable<Exclude<T[P], undefined>> };

package/lib/deep-nullish.d.ts

@@ -1,12 +1,12 @@
 import { DeepRequired, HighDeepRequired } from './deep-required.js';
-import { IsDeepExcluded } from './helpers.js';
+import { IfNoDeepValue } from './helpers.js';
 
 /**
  * Make all properties in T nullable deeply
  */
 export type DeepNullish<T> = _DeepNullish<DeepRequired<T>>;
 type _DeepNullish<T> =
-    IsDeepExcluded<T> extends true ? T
+    IfNoDeepValue<T> extends true ? T
         : { [P in keyof T]?: _DeepNullish<Exclude<T[P], undefined>> | null };
 
 
@@ -16,6 +16,6 @@ type _DeepNullish<T> =
 export type HighDeepNullish<T> = _HighDeepNullish<HighDeepRequired<T>>;
 type _HighDeepNullish<T> =
     T extends (infer U)[] ? _HighDeepNullish<U>[]
-        : IsDeepExcluded<T> extends true ? T
+        : IfNoDeepValue<T> extends true ? T
             : { [P in keyof T]?: _HighDeepNullish<Exclude<T[P], undefined>> | null };
 

package/lib/deep-omit.d.ts

@@ -1,4 +1,4 @@
-import { IsDeepExcluded } from './helpers.js';
+import { IfNoDeepValue } from './helpers.js';
 import { OptionalKeys, ReadonlyKeys, RequiredKeys, WritableKeys } from './keys';
 
 /**
@@ -6,7 +6,7 @@ import { OptionalKeys, ReadonlyKeys, RequiredKeys, WritableKeys } from './keys';
  */
 export type DeepOmitOptional<T> = _DeepOmitOptional<Exclude<T, undefined>>;
 type _DeepOmitOptional<T, K extends keyof T = Exclude<keyof T, OptionalKeys<T>>> =
-    IsDeepExcluded<T> extends true ? T
+    IfNoDeepValue<T> extends true ? T
         : { [P in K]-?: DeepOmitOptional<T[P]> };
 
 /**
@@ -15,7 +15,7 @@ type _DeepOmitOptional<T, K extends keyof T = Exclude<keyof T, OptionalKeys<T>>>
 export type HighDeepOmitOptional<T> = _HighDeepOmitOptional<Exclude<T, undefined>>;
 type _HighDeepOmitOptional<T, K extends keyof T = Exclude<keyof T, OptionalKeys<T>>> =
     T extends (infer U)[] ? HighDeepOmitOptional<U>[]
-        : IsDeepExcluded<T> extends true ? T
+        : IfNoDeepValue<T> extends true ? T
             : { [P in K]-?: HighDeepOmitOptional<T[P]> };
 
 
@@ -24,7 +24,7 @@ type _HighDeepOmitOptional<T, K extends keyof T = Exclude<keyof T, OptionalKeys<
  */
 export type DeepOmitRequired<T> = _DeepOmitRequired<Exclude<T, undefined>>;
 type _DeepOmitRequired<T, J extends keyof T = Exclude<keyof T, RequiredKeys<T>>> =
-    IsDeepExcluded<T> extends true ? T
+    IfNoDeepValue<T> extends true ? T
         : { [P in J]?: DeepOmitRequired<Exclude<T[P], undefined>> };
 
 
@@ -34,7 +34,7 @@ type _DeepOmitRequired<T, J extends keyof T = Exclude<keyof T, RequiredKeys<T>>>
 export type HighDeepOmitRequired<T> = _HighDeepOmitRequired<Exclude<T, undefined>>;
 type _HighDeepOmitRequired<T, J extends keyof T = Exclude<keyof T, RequiredKeys<T>>> =
     T extends (infer U)[] ? HighDeepOmitRequired<U>[]
-        : IsDeepExcluded<T> extends true ? T
+        : IfNoDeepValue<T> extends true ? T
             : { [P in J]?: HighDeepOmitRequired<Exclude<T[P], undefined>> };
 
 
@@ -43,7 +43,7 @@ type _HighDeepOmitRequired<T, J extends keyof T = Exclude<keyof T, RequiredKeys<
  */
 export type DeepOmitReadonly<T> = _DeepOmitReadonly<Exclude<T, undefined>>;
 type _DeepOmitReadonly<T, J extends keyof T = Exclude<keyof T, ReadonlyKeys<T>>> =
-    IsDeepExcluded<T> extends true ? T
+    IfNoDeepValue<T> extends true ? T
         : { [P in J]: DeepOmitReadonly<T[P]> };
 
 
@@ -53,7 +53,7 @@ type _DeepOmitReadonly<T, J extends keyof T = Exclude<keyof T, ReadonlyKeys<T>>>
 export type HighDeepOmitReadonly<T> = _HighDeepOmitReadonly<Exclude<T, undefined>>;
 type _HighDeepOmitReadonly<T, J extends keyof T = Exclude<keyof T, ReadonlyKeys<T>>> =
     T extends (infer U)[] ? HighDeepOmitReadonly<U>[]
-        : IsDeepExcluded<T> extends true ? T
+        : IfNoDeepValue<T> extends true ? T
             : { [P in J]: HighDeepOmitReadonly<T[P]> };
 
 
@@ -62,7 +62,7 @@ type _HighDeepOmitReadonly<T, J extends keyof T = Exclude<keyof T, ReadonlyKeys<
  */
 export type DeepOmitWritable<T> = _DeepOmitWritable<Exclude<T, undefined>>
 type _DeepOmitWritable<T, K extends keyof T = Exclude<keyof T, WritableKeys<T>>> =
-    IsDeepExcluded<T> extends true ? T
+    IfNoDeepValue<T> extends true ? T
         : { readonly [P in K]: DeepOmitWritable<T[P]> }
 
 
@@ -72,5 +72,5 @@ type _DeepOmitWritable<T, K extends keyof T = Exclude<keyof T, WritableKeys<T>>>
 export type HighDeepOmitWritable<T> = _HighDeepOmitWritable<Exclude<T, undefined>>
 type _HighDeepOmitWritable<T, K extends keyof T = Exclude<keyof T, WritableKeys<T>>> =
     T extends (infer U)[] ? HighDeepOmitWritable<U>[]
-        : IsDeepExcluded<T> extends true ? T
+        : IfNoDeepValue<T> extends true ? T
             : { readonly [P in K]: HighDeepOmitWritable<T[P]> }

package/lib/deep-partial.d.ts

@@ -1,11 +1,11 @@
-import { IsDeepExcluded } from './helpers.js';
+import { IfNoDeepValue } from './helpers.js';
 
 /**
  * Partial but deeply
  */
 export type DeepPartial<T> = _DeepPartial<T>;
 type _DeepPartial<T> =
-    IsDeepExcluded<T> extends true ? T
+    IfNoDeepValue<T> extends true ? T
         : { [P in keyof T]?: _DeepPartial<Exclude<T[P], undefined>> };
 
 /**
@@ -14,5 +14,5 @@ type _DeepPartial<T> =
 export type HighDeepPartial<T> = _HighDeepPartial<T>;
 type _HighDeepPartial<T> =
     T extends (infer U)[] ? _HighDeepPartial<U>[]
-        : IsDeepExcluded<T> extends true ? T
+        : IfNoDeepValue<T> extends true ? T
             : { [P in keyof T]?: _HighDeepPartial<Exclude<T[P], undefined>> };

package/lib/deep-pick.d.ts

@@ -1,4 +1,4 @@
-import { IsDeepExcluded } from './helpers.js';
+import { IfNoDeepValue } from './helpers.js';
 import { JsonKeys, OptionalKeys, ReadonlyKeys, RequiredKeys, WritableKeys } from './keys';
 
 /**
@@ -6,7 +6,7 @@ import { JsonKeys, OptionalKeys, ReadonlyKeys, RequiredKeys, WritableKeys } from
  */
 export type DeepPickOptional<T> = _DeepPickOptional<Exclude<T, undefined>>;
 type _DeepPickOptional<T, K extends keyof T = OptionalKeys<T>> =
-    IsDeepExcluded<T> extends true ? T
+    IfNoDeepValue<T> extends true ? T
         : { [P in K]?: DeepPickOptional<T[P]> };
 
 /**
@@ -15,7 +15,7 @@ type _DeepPickOptional<T, K extends keyof T = OptionalKeys<T>> =
 export type HighDeepPickOptional<T> = _HighDeepPickOptional<Exclude<T, undefined>>;
 type _HighDeepPickOptional<T, K extends keyof T = OptionalKeys<T>> =
     T extends (infer U)[] ? HighDeepPickOptional<U>[]
-        : IsDeepExcluded<T> extends true ? T
+        : IfNoDeepValue<T> extends true ? T
             : { [P in K]?: HighDeepPickOptional<T[P]> };
 
 
@@ -24,7 +24,7 @@ type _HighDeepPickOptional<T, K extends keyof T = OptionalKeys<T>> =
  */
 export type DeepPickRequired<T> = _DeepPickRequired<Exclude<T, undefined>>;
 type _DeepPickRequired<T, J extends keyof T = RequiredKeys<T>> =
-    IsDeepExcluded<T> extends true ? T
+    IfNoDeepValue<T> extends true ? T
         : { [P in J]-?: DeepPickRequired<T[P]> };
 
 
@@ -34,7 +34,7 @@ type _DeepPickRequired<T, J extends keyof T = RequiredKeys<T>> =
 export type HighDeepPickRequired<T> = _HighDeepPickRequired<Exclude<T, undefined>>;
 type _HighDeepPickRequired<T, J extends keyof T = RequiredKeys<T>> =
     T extends (infer U)[] ? HighDeepPickRequired<U>[]
-        : IsDeepExcluded<T> extends true ? T
+        : IfNoDeepValue<T> extends true ? T
             : { [P in J]-?: HighDeepPickRequired<T[P]> };
 
 
@@ -43,7 +43,7 @@ type _HighDeepPickRequired<T, J extends keyof T = RequiredKeys<T>> =
  */
 export type DeepPickReadonly<T> = _DeepPickReadonly<Exclude<T, undefined>>;
 type _DeepPickReadonly<T, K extends keyof T = ReadonlyKeys<T>> =
-    IsDeepExcluded<T> extends true ? T
+    IfNoDeepValue<T> extends true ? T
         : { [P in K]: DeepPickReadonly<T[P]> };
 
 /**
@@ -52,7 +52,7 @@ type _DeepPickReadonly<T, K extends keyof T = ReadonlyKeys<T>> =
 export type HighDeepPickReadonly<T> = _HighDeepPickReadonly<Exclude<T, undefined>>;
 type _HighDeepPickReadonly<T, K extends keyof T = ReadonlyKeys<T>> =
     T extends (infer U)[] ? HighDeepPickReadonly<U>[]
-        : IsDeepExcluded<T> extends true ? T
+        : IfNoDeepValue<T> extends true ? T
             : { [P in K]: HighDeepPickReadonly<T[P]> };
 
 
@@ -61,7 +61,7 @@ type _HighDeepPickReadonly<T, K extends keyof T = ReadonlyKeys<T>> =
  */
 export type DeepPickWritable<T> = _DeepPickWritable<Exclude<T, undefined>>;
 type _DeepPickWritable<T, K extends keyof T = WritableKeys<T>> =
-    IsDeepExcluded<T> extends true ? T
+    IfNoDeepValue<T> extends true ? T
         : { [P in K]: DeepPickWritable<T[P]> };
 
 /**
@@ -70,7 +70,7 @@ type _DeepPickWritable<T, K extends keyof T = WritableKeys<T>> =
 export type HighDeepPickWritable<T> = _HighDeepPickWritable<Exclude<T, undefined>>;
 type _HighDeepPickWritable<T, K extends keyof T = WritableKeys<T>> =
     T extends (infer U)[] ? HighDeepPickWritable<U>[]
-        : IsDeepExcluded<T> extends true ? T
+        : IfNoDeepValue<T> extends true ? T
             : { [P in K]: HighDeepPickWritable<T[P]> };
 
 
@@ -80,5 +80,5 @@ type _HighDeepPickWritable<T, K extends keyof T = WritableKeys<T>> =
 export type DeepPickJson<T> = _DeepPickJson<Exclude<T, undefined>>;
 type _DeepPickJson<T, Keys extends keyof T = JsonKeys<T>> =
     T extends (infer U)[] ? DeepPickJson<U>[]
-        : IsDeepExcluded<T> extends true ? T
+        : IfNoDeepValue<T> extends true ? T
             : { [P in Keys]: DeepPickJson<T[P]> };

package/lib/deep-readonly.d.ts

@@ -1,11 +1,11 @@
-import { IsDeepExcluded } from './helpers.js';
+import { IfNoDeepValue } from './helpers.js';
 
 /**
  * Make all properties in T readonly deeply
  */
 export type DeepReadonly<T> = _DeepReadonly<T>;
 type _DeepReadonly<T> =
-    IsDeepExcluded<T> extends true ? T
+    IfNoDeepValue<T> extends true ? T
         : { readonly [P in keyof T]: _DeepReadonly<T[P]> };
 
 /**
@@ -14,6 +14,6 @@ type _DeepReadonly<T> =
 export type HighDeepReadonly<T> = _HighDeepReadonly<T>;
 type _HighDeepReadonly<T> =
     T extends (infer U)[] ? _HighDeepReadonly<U>[]
-        : IsDeepExcluded<T> extends true ? T
+        : IfNoDeepValue<T> extends true ? T
             : { readonly [P in keyof T]: _HighDeepReadonly<T[P]> };
 

package/lib/deep-required.d.ts

@@ -1,11 +1,11 @@
-import { IsDeepExcluded } from './helpers.js';
+import { IfNoDeepValue } from './helpers.js';
 
 /**
  * Make all properties in T required deeply
  */
 export type DeepRequired<T> = _DeepRequired<T>;
 type _DeepRequired<T> =
-    IsDeepExcluded<T> extends true ? T
+    IfNoDeepValue<T> extends true ? T
         : { [P in keyof T]-?: _DeepRequired<Exclude<T[P], undefined>> };
 
 
@@ -15,5 +15,5 @@ type _DeepRequired<T> =
 export type HighDeepRequired<T> = _HighDeepRequired<T>;
 type _HighDeepRequired<T> =
     T extends (infer U)[] ? _HighDeepRequired<U>[]
-        : IsDeepExcluded<T> extends true ? T
+        : IfNoDeepValue<T> extends true ? T
             : { [P in keyof T]-?: _HighDeepRequired<Exclude<T[P], undefined>> };

package/lib/deep-writable.d.ts

@@ -1,11 +1,11 @@
-import { IsDeepExcluded } from './helpers.js';
+import { IfNoDeepValue } from './helpers.js';
 
 /**
  * Make all properties in T writable deeply
  */
 export type DeepWritable<T> = _DeepWritable<T>;
 type _DeepWritable<T> =
-    IsDeepExcluded<T> extends true ? T
+    IfNoDeepValue<T> extends true ? T
         : { -readonly [P in keyof T]: _DeepWritable<T[P]> };
 
 
@@ -15,5 +15,5 @@ type _DeepWritable<T> =
 export type HighDeepWritable<T> = _HighDeepWritable<T>;
 type _HighDeepWritable<T> =
     T extends (infer U)[] ? _HighDeepWritable<U>[]
-        : IsDeepExcluded<T> extends true ? T
+        : IfNoDeepValue<T> extends true ? T
             : { -readonly [P in keyof T]: _HighDeepWritable<T[P]> };

package/lib/helpers.d.ts

@@ -4,8 +4,8 @@ import { IfClass, IfTuple } from './type-check.js';
 /**
  * Returns true if T is excluded from deep operations
  */
-export type IsDeepExcluded<T> = _IsHighDeepObject<T>;
-type _IsHighDeepObject<T> =
+export type IfNoDeepValue<T> = _IfNoDeepValue<T>
+type _IfNoDeepValue<T> =
     T extends Builtin ? true
         : IfTuple<T> extends true ? true
             : IfClass<T> extends true ? true

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
@@ -52,56 +56,57 @@ type _JsonKeys<T, J = Required<T>> = ValuesOf<{
       : IfNull<J[K]> extends true ? K
           : IfJson<Exclude<J[K], undefined>> extends true ? K
               : never
-
 }>;
 
 /**
  * @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.4",
   "types": "lib/index.d.ts",
   "main": "lib/index.js",
   "module": "lib/index.js",