ts-gems 3.3.0 → 3.5.0

package/lib/pick.d.ts

@@ -1,75 +1,76 @@
 import { Or } from './logical.js';
 import { OmitFunctions } from './omit';
-import { IfAny, IfEmptyObject, IfFunction, IfNever, IfUnknown } from './type-check';
+import {
+  IfAny,
+  IfEmptyObject,
+  IfFunction,
+  IfNever,
+  IfUnknown,
+} from './type-check';
 
 /**
  * From T, pick a set of properties whose keys are in the union K,
  * while preserving strict type checking.
  */
 export type StrictPick<T, X extends keyof T> = {
-  [K in keyof T as (
-      Or<
-          // Omit never keys
-          IfNever<Exclude<T[K], undefined>>,
-          // Omit X
-          K extends X ? false : true
-      > extends true ? never : K
-      )]: T[K]
+  [K in keyof T as Or<
+    // Omit never keys
+    IfNever<Exclude<T[K], undefined>>,
+    // Omit X
+    K extends X ? false : true
+  > extends true
+    ? never
+    : K]: T[K];
 };
 
 /**
  * Pick all function properties in T
  */
 export type PickFunctions<T> = {
-  [K in keyof T as (
-      Or<
-          // Omit never keys
-          IfNever<Exclude<T[K], undefined>>,
-          // Omit non functions
-          IfFunction<Exclude<T[K], undefined>, false, true>
-      > extends true ? never : K
-      )]: T[K]
+  [K in keyof T as Or<
+    // Omit never keys
+    IfNever<Exclude<T[K], undefined>>,
+    // Omit non functions
+    IfFunction<Exclude<T[K], undefined>, false, true>
+  > extends true
+    ? never
+    : K]: T[K];
 };
 
-
 /**
  * Pick all function properties in T
  */
 export type PickTypes<T, X> = {
-  [K in keyof T as (
-      Or<
-          // Omit never keys
-          IfNever<Exclude<T[K], undefined>>,
-          // Omit types which not exists in X
-          T[K] extends X ? false :
-              X extends T[K] ? false : true
-      > extends true ? never : K
-      )]: T[K]
+  [K in keyof T as Or<
+    // Omit never keys
+    IfNever<Exclude<T[K], undefined>>,
+    // Omit types which not exists in X
+    T[K] extends X ? false : X extends T[K] ? false : true
+  > extends true
+    ? never
+    : K]: T[K];
 };
 
-
 /**
  * Pick all function properties in T
  */
 export type StrictPickTypes<T, X> = {
-  [K in keyof T as (
-      Or<
-          // Omit never keys
-          IfNever<Exclude<T[K], undefined>>,
-          // Omit unknown
-          IfUnknown<T[K]>,
-          // Omit any
-          IfAny<T[K]>,
-          // Omit {}
-          IfEmptyObject<T[K]>,
-          // Omit types which not exists in X
-          T[K] extends X ? false :
-              X extends T[K] ? false : true
-      > extends true ? never : K
-      )]: T[K]
+  [K in keyof T as Or<
+    // Omit never keys
+    IfNever<Exclude<T[K], undefined>>,
+    // Omit unknown
+    IfUnknown<T[K]>,
+    // Omit any
+    IfAny<T[K]>,
+    // Omit {}
+    IfEmptyObject<T[K]>,
+    // Omit types which not exists in X
+    T[K] extends X ? false : X extends T[K] ? false : true
+  > extends true
+    ? never
+    : K]: T[K];
 };
 
-
 /**
  * @desc Returns Function keys of an object
  */
@@ -80,7 +81,6 @@ export type FunctionKeys<T> = keyof PickFunctions<T>;
  */
 export type NonFunctionKeys<T> = keyof OmitFunctions<T>;
 
-
 /**
  * @desc Returns keys that match given type
  */
@@ -90,4 +90,3 @@ export type KeysOfTypes<T, X> = keyof PickTypes<T, X>;
  * @desc Returns keys that equals given type
  */
 export type StrictKeysOfTypes<T, X> = keyof StrictPickTypes<T, X>;
-

package/lib/readonly.d.ts

@@ -5,33 +5,40 @@ import { IfEquals, IfNever } from './type-check';
 /**
  * Marks given keys as readonly
  */
-export type ReadonlySome<T, K extends keyof T> = Readonly<Pick<T, K>> & Omit<T, K>;
+export type ReadonlySome<T, K extends keyof T> = Readonly<Pick<T, K>> &
+  Omit<T, K>;
 
 /**
  * Make all properties in T readonly deeply
  */
 export type DeepReadonly<T> = {
-  readonly [K in keyof T as (IfNever<Exclude<T[K], undefined>, never, K>)]:
-  // Do not deep process No-Deep values
-  IfNoDeepValue<Exclude<T[K], undefined>> extends true ? T[K]
-      // Deep process objects
-      : DeepReadonly<Exclude<T[K], undefined>>
+  readonly [K in keyof T as IfNever<
+    Exclude<T[K], undefined>,
+    never,
+    K
+  >]: IfNoDeepValue<Exclude<T[K], undefined>> extends true // Do not deep process No-Deep values
+    ? T[K]
+    : // Deep process objects
+      DeepReadonly<Exclude<T[K], undefined>>;
 };
 
 /**
  * Make all properties in T readonly deeply
  */
 export type DeeperReadonly<T> = {
-  readonly [K in keyof T as (IfNever<Exclude<T[K], undefined>, never, K>)]:
-  // Deep process arrays
-  Exclude<T[K], undefined> extends (infer U)[] ? DeeperReadonly<U>[]
-      // Do not deep process No-Deep values
-      : IfNoDeepValue<Exclude<T[K], undefined>> extends true ? T[K]
-          // Deep process objects
-          : DeeperReadonly<Exclude<T[K], undefined>>
+  readonly [K in keyof T as IfNever<
+    Exclude<T[K], undefined>,
+    never,
+    K
+  >]: Exclude<T[K], undefined> extends (infer U)[] // Deep process arrays
+    ? DeeperReadonly<U>[]
+    : // Do not deep process No-Deep values
+      IfNoDeepValue<Exclude<T[K], undefined>> extends true
+      ? T[K]
+      : // Deep process objects
+        DeeperReadonly<Exclude<T[K], undefined>>;
 };
 
-
 /**
  * Returns readonly keys of an object
  */
@@ -41,103 +48,100 @@ export type ReadonlyKeys<T> = keyof PickReadonly<T>;
  * Pick all readonly properties in T
  */
 export type PickReadonly<T> = {
-  [K in keyof T as (
-      Or<
-          // Omit never keys
-          IfNever<Exclude<T[K], undefined>>,
-          // Omit required
-          IfEquals<{ [Q in K]: T[K] }, { readonly [Q in K]: T[K] }, false, true>
-      > extends true ? never : K
-      )]: T[K]
+  [K in keyof T as Or<
+    // Omit never keys
+    IfNever<Exclude<T[K], undefined>>,
+    // Omit required
+    IfEquals<{ [Q in K]: T[K] }, { readonly [Q in K]: T[K] }, false, true>
+  > extends true
+    ? never
+    : K]: T[K];
 };
 
 /**
  * Omit all readonly properties in T
  */
 export type OmitReadonly<T> = {
-  [K in keyof T as (
-      Or<
-          // Omit never keys
-          IfNever<Exclude<T[K], undefined>>,
-          // Omit required
-          IfEquals<{ [Q in K]: T[K] }, { readonly [Q in K]: T[K] }>
-      > extends true ? never : K
-      )]: T[K]
+  [K in keyof T as Or<
+    // Omit never keys
+    IfNever<Exclude<T[K], undefined>>,
+    // Omit required
+    IfEquals<{ [Q in K]: T[K] }, { readonly [Q in K]: T[K] }>
+  > extends true
+    ? never
+    : K]: T[K];
 };
 
-
 /**
  * Pick all readonly properties in T deeply
  */
 export type DeepPickReadonly<T> = {
-  [K in keyof T as (
-      Or<
-          // Omit never keys
-          IfNever<Exclude<T[K], undefined>>,
-          // Omit required
-          IfEquals<{ [Q in K]: T[K] }, { readonly [Q in K]: T[K] }, false, true>
-      > extends true ? never : K
-      )]:
-  // Do not deep process No-Deep values
-  IfNoDeepValue<Exclude<T[K], undefined>> extends true ? T[K]
-      // Deep process objects
-      : DeepPickReadonly<Exclude<T[K], undefined>>
+  [K in keyof T as Or<
+    // Omit never keys
+    IfNever<Exclude<T[K], undefined>>,
+    // Omit required
+    IfEquals<{ [Q in K]: T[K] }, { readonly [Q in K]: T[K] }, false, true>
+  > extends true
+    ? never
+    : K]: IfNoDeepValue<Exclude<T[K], undefined>> extends true // Do not deep process No-Deep values
+    ? T[K]
+    : // Deep process objects
+      DeepPickReadonly<Exclude<T[K], undefined>>;
 };
 
 /**
  * Pick all readonly properties in T deeply
  */
 export type DeepOmitReadonly<T> = {
-  [K in keyof T as (
-      Or<
-          // Omit never keys
-          IfNever<Exclude<T[K], undefined>>,
-          // Omit required
-          IfEquals<{ [Q in K]: T[K] }, { readonly [Q in K]: T[K] }>
-      > extends true ? never : K
-      )]:
-  // Do not deep process No-Deep values
-  IfNoDeepValue<Exclude<T[K], undefined>> extends true ? T[K]
-      // Deep process objects
-      : DeepOmitReadonly<Exclude<T[K], undefined>>
+  [K in keyof T as Or<
+    // Omit never keys
+    IfNever<Exclude<T[K], undefined>>,
+    // Omit required
+    IfEquals<{ [Q in K]: T[K] }, { readonly [Q in K]: T[K] }>
+  > extends true
+    ? never
+    : K]: IfNoDeepValue<Exclude<T[K], undefined>> extends true // Do not deep process No-Deep values
+    ? T[K]
+    : // Deep process objects
+      DeepOmitReadonly<Exclude<T[K], undefined>>;
 };
 
 /**
  * Pick all readonly properties in T deeply including arrays
  */
 export type DeeperPickReadonly<T> = {
-  [K in keyof T as (
-      Or<
-          // Omit never keys
-          IfNever<Exclude<T[K], undefined>>,
-          // Omit required
-          IfEquals<{ [Q in K]: T[K] }, { readonly [Q in K]: T[K] }, false, true>
-      > extends true ? never : K
-      )]:
-  // Deep process arrays
-  Exclude<T[K], undefined> extends (infer U)[] ? DeeperPickReadonly<U>[]
-      // Do not deep process No-Deep values
-      : IfNoDeepValue<Exclude<T[K], undefined>> extends true ? T[K]
-          // Deep process objects
-          : DeeperPickReadonly<Exclude<T[K], undefined>>
+  [K in keyof T as Or<
+    // Omit never keys
+    IfNever<Exclude<T[K], undefined>>,
+    // Omit required
+    IfEquals<{ [Q in K]: T[K] }, { readonly [Q in K]: T[K] }, false, true>
+  > extends true
+    ? never
+    : K]: Exclude<T[K], undefined> extends (infer U)[] // Deep process arrays
+    ? DeeperPickReadonly<U>[]
+    : // Do not deep process No-Deep values
+      IfNoDeepValue<Exclude<T[K], undefined>> extends true
+      ? T[K]
+      : // Deep process objects
+        DeeperPickReadonly<Exclude<T[K], undefined>>;
 };
 
 /**
  * Pick all readonly properties in T deeply including arrays
  */
 export type DeeperOmitReadonly<T> = {
-  [K in keyof T as (
-      Or<
-          // Omit never keys
-          IfNever<Exclude<T[K], undefined>>,
-          // Omit required
-          IfEquals<{ [Q in K]: T[K] }, { readonly [Q in K]: T[K] }>
-      > extends true ? never : K
-      )]:
-  // Deep process arrays
-  Exclude<T[K], undefined> extends (infer U)[] ? DeeperOmitReadonly<U>[]
-      // Do not deep process No-Deep values
-      : IfNoDeepValue<Exclude<T[K], undefined>> extends true ? T[K]
-          // Deep process objects
-          : DeeperOmitReadonly<Exclude<T[K], undefined>>
+  [K in keyof T as Or<
+    // Omit never keys
+    IfNever<Exclude<T[K], undefined>>,
+    // Omit required
+    IfEquals<{ [Q in K]: T[K] }, { readonly [Q in K]: T[K] }>
+  > extends true
+    ? never
+    : K]: Exclude<T[K], undefined> extends (infer U)[] // Deep process arrays
+    ? DeeperOmitReadonly<U>[]
+    : // Do not deep process No-Deep values
+      IfNoDeepValue<Exclude<T[K], undefined>> extends true
+      ? T[K]
+      : // Deep process objects
+        DeeperOmitReadonly<Exclude<T[K], undefined>>;
 };

package/lib/required.d.ts

@@ -6,31 +6,41 @@ import { IfEquals, IfNever } from './type-check';
 /**
  * Marks given keys as required
  */
-export type RequiredSome<T, K extends keyof T> = OmitTypes<Required<Pick<T, K>>, null> & Omit<T, K>;
+export type RequiredSome<T, K extends keyof T> = OmitTypes<
+  Required<Pick<T, K>>,
+  null
+> &
+  Omit<T, K>;
 
 /**
  * Make all properties in T required deeply
  */
 export type DeepRequired<T> = {
-  [K in keyof T as (IfNever<Exclude<T[K], undefined>, never, K>)]-?:
-  // Do not deep process No-Deep values
-  IfNoDeepValue<Exclude<T[K], undefined>> extends true ? Exclude<T[K], undefined>
-      // Deep process objects
-      : DeepRequired<Exclude<T[K], undefined>>
+  [K in keyof T as IfNever<
+    Exclude<T[K], undefined>,
+    never,
+    K
+  >]-?: IfNoDeepValue<Exclude<T[K], undefined>> extends true // Do not deep process No-Deep values
+    ? Exclude<T[K], undefined>
+    : // Deep process objects
+      DeepRequired<Exclude<T[K], undefined>>;
 };
 
-
 /**
  * Make all properties in T required deeply including arrays
  */
 export type DeeperRequired<T> = {
-  [K in keyof T as (IfNever<Exclude<T[K], undefined>, never, K>)]-?:
-  // Deep process arrays
-  Exclude<T[K], undefined> extends (infer U)[] ? DeeperRequired<U>[]
-      // Do not deep process No-Deep values
-      : IfNoDeepValue<Exclude<T[K], undefined>> extends true ? Exclude<T[K], undefined>
-          // Deep process objects
-          : DeepRequired<Exclude<T[K], undefined>>
+  [K in keyof T as IfNever<Exclude<T[K], undefined>, never, K>]-?: Exclude<
+    // Deep process arrays
+    T[K],
+    undefined
+  > extends (infer U)[]
+    ? DeeperRequired<U>[]
+    : // Do not deep process No-Deep values
+      IfNoDeepValue<Exclude<T[K], undefined>> extends true
+      ? Exclude<T[K], undefined>
+      : // Deep process objects
+        DeepRequired<Exclude<T[K], undefined>>;
 };
 
 /**
@@ -39,107 +49,104 @@ export type DeeperRequired<T> = {
  */
 export type RequiredKeys<T> = keyof PickRequired<T>;
 
-
 /**
  * Pick all required properties in T
  */
 export type PickRequired<T> = {
-  [K in keyof T as (
-      Or<
-          // Omit never keys
-          IfNever<Exclude<T[K], undefined>>,
-          // Omit optional
-          IfEquals<{ [Q in K]: T[K] }, { [Q in K]?: T[K] }>
-      > extends true ? never : K
-      )]: T[K]
+  [K in keyof T as Or<
+    // Omit never keys
+    IfNever<Exclude<T[K], undefined>>,
+    // Omit optional
+    IfEquals<{ [Q in K]: T[K] }, { [Q in K]?: T[K] }>
+  > extends true
+    ? never
+    : K]: T[K];
 };
 
 /**
  * Pick all required properties in T
  */
 export type OmitRequired<T> = {
-  [K in keyof T as (
-      Or<
-          // Omit never keys
-          IfNever<Exclude<T[K], undefined>>,
-          // Omit optional
-          IfEquals<{ [Q in K]: T[K] }, { [Q in K]?: T[K] }, false, true>
-      > extends true ? never : K
-      )]: T[K]
+  [K in keyof T as Or<
+    // Omit never keys
+    IfNever<Exclude<T[K], undefined>>,
+    // Omit optional
+    IfEquals<{ [Q in K]: T[K] }, { [Q in K]?: T[K] }, false, true>
+  > extends true
+    ? never
+    : K]: T[K];
 };
 
 /**
  * Pick all required properties in T deeply
  */
 export type DeepPickRequired<T> = {
-  [K in keyof T as (
-      Or<
-          // Omit never keys
-          IfNever<Exclude<T[K], undefined>>,
-          // Omit optional
-          IfEquals<{ [Q in K]: T[K] }, { [Q in K]?: T[K] }>
-      > extends true ? never : K
-      )]:
-  // Do not deep process No-Deep values
-  IfNoDeepValue<Exclude<T[K], undefined>> extends true ? T[K]
-      // Deep process objects
-      : DeepPickRequired<Exclude<T[K], undefined>>
+  [K in keyof T as Or<
+    // Omit never keys
+    IfNever<Exclude<T[K], undefined>>,
+    // Omit optional
+    IfEquals<{ [Q in K]: T[K] }, { [Q in K]?: T[K] }>
+  > extends true
+    ? never
+    : K]: IfNoDeepValue<Exclude<T[K], undefined>> extends true // Do not deep process No-Deep values
+    ? T[K]
+    : // Deep process objects
+      DeepPickRequired<Exclude<T[K], undefined>>;
 };
 
 /**
  * Omit all required properties in T deeply
  */
 export type DeepOmitRequired<T> = {
-  [K in keyof T as (
-      Or<
-          // Omit never keys
-          IfNever<Exclude<T[K], undefined>>,
-          // Omit required
-          IfEquals<{ [Q in K]: T[K] }, { [Q in K]-?: T[K] }>
-      > extends true ? never : K
-      )]?:
-  // Do not deep process No-Deep values
-  IfNoDeepValue<Exclude<T[K], undefined>> extends true ? T[K]
-      // Deep process objects
-      : DeepOmitRequired<Exclude<T[K], undefined>>
+  [K in keyof T as Or<
+    // Omit never keys
+    IfNever<Exclude<T[K], undefined>>,
+    // Omit required
+    IfEquals<{ [Q in K]: T[K] }, { [Q in K]-?: T[K] }>
+  > extends true
+    ? never
+    : K]?: IfNoDeepValue<Exclude<T[K], undefined>> extends true // Do not deep process No-Deep values
+    ? T[K]
+    : // Deep process objects
+      DeepOmitRequired<Exclude<T[K], undefined>>;
 };
 
 /**
  * Pick all required properties in T deeply including arrays
  */
 export type DeeperPickRequired<T> = {
-  [K in keyof T as (
-      Or<
-          // Omit never keys
-          IfNever<Exclude<T[K], undefined>>,
-          // Omit required
-          IfEquals<{ [Q in K]: T[K] }, { [Q in K]?: T[K] }>
-      > extends true ? never : K
-      )]:
-  // Deep process arrays
-  Exclude<T[K], undefined> extends (infer U)[] ? DeeperPickRequired<U>[]
-      // Do not deep process No-Deep values
-      : IfNoDeepValue<Exclude<T[K], undefined>> extends true ? T[K]
-          // Deep process objects
-          : DeeperPickRequired<Exclude<T[K], undefined>>
+  [K in keyof T as Or<
+    // Omit never keys
+    IfNever<Exclude<T[K], undefined>>,
+    // Omit required
+    IfEquals<{ [Q in K]: T[K] }, { [Q in K]?: T[K] }>
+  > extends true
+    ? never
+    : K]: Exclude<T[K], undefined> extends (infer U)[] // Deep process arrays
+    ? DeeperPickRequired<U>[]
+    : // Do not deep process No-Deep values
+      IfNoDeepValue<Exclude<T[K], undefined>> extends true
+      ? T[K]
+      : // Deep process objects
+        DeeperPickRequired<Exclude<T[K], undefined>>;
 };
 
 /**
  * Omit all required properties in T deeply including arrays
  */
 export type DeeperOmitRequired<T> = {
-  [K in keyof T as (
-      Or<
-          // Omit never keys
-          IfNever<Exclude<T[K], undefined>>,
-          // Omit required
-          IfEquals<{ [Q in K]: T[K] }, { [Q in K]-?: T[K] }>
-      > extends true ? never : K
-      )]:
-  // Deep process arrays
-  Exclude<T[K], undefined> extends (infer U)[] ? DeeperOmitRequired<U>[]
-      // Do not deep process No-Deep values
-      : IfNoDeepValue<Exclude<T[K], undefined>> extends true ? T[K]
-          // Deep process objects
-          : DeeperOmitRequired<Exclude<T[K], undefined>>
+  [K in keyof T as Or<
+    // Omit never keys
+    IfNever<Exclude<T[K], undefined>>,
+    // Omit required
+    IfEquals<{ [Q in K]: T[K] }, { [Q in K]-?: T[K] }>
+  > extends true
+    ? never
+    : K]: Exclude<T[K], undefined> extends (infer U)[] // Deep process arrays
+    ? DeeperOmitRequired<U>[]
+    : // Do not deep process No-Deep values
+      IfNoDeepValue<Exclude<T[K], undefined>> extends true
+      ? T[K]
+      : // Deep process objects
+        DeeperOmitRequired<Exclude<T[K], undefined>>;
 };