ts-gems 2.9.2 → 3.0.0

package/lib/readonly.d.ts

@@ -0,0 +1,143 @@
+import { IfNoDeepValue } from './helpers';
+import { Or } from './logical.js';
+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>;
+
+/**
+ * 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>>
+};
+
+/**
+ * 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>>
+};
+
+
+/**
+ * Returns readonly keys of an object
+ */
+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]
+};
+
+/**
+ * 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]
+};
+
+
+/**
+ * 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>>
+};
+
+/**
+ * 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>>
+};
+
+/**
+ * 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>>
+};
+
+/**
+ * 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>>
+};

package/lib/required.d.ts

@@ -0,0 +1,145 @@
+import { IfNoDeepValue } from './helpers';
+import { Or } from './logical.js';
+import { OmitTypes } from './omit.js';
+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>;
+
+/**
+ * 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>>
+};
+
+
+/**
+ * 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>>
+};
+
+/**
+ * RequiredKeys
+ * @desc Returns required keys of an object
+ */
+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]
+};
+
+/**
+ * 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]
+};
+
+/**
+ * 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>>
+};
+
+/**
+ * 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>>
+};
+
+/**
+ * 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>>
+};
+
+/**
+ * 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>>
+};

package/lib/type-check.d.ts

@@ -1,4 +1,4 @@
-import { Primitive, Type } from './common';
+import { Primitive, Type } from './types';
 
 type NonObj = Primitive | Function;
 
@@ -20,10 +20,11 @@ export type IfNever<T, Y = true, N = false> =
 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> extends Y ? Y
-//         : undefined extends T ? Y : N;
-
+/**
+ * Returns "Y" if "T" is "never", "N" otherwise
+ */
+export type IfSymbol<T, Y = true, N = false> =
+    IfEquals<T, symbol, Y, N>;
 
 /**
  * Returns Y if typeof T is "unknown", N otherwise
@@ -62,30 +63,16 @@ export type IfTupleOrAny<T, Y = true, N = 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;
+        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>;
 
-/**
- * Returns Y if typeof T is JSON like, N otherwise
- */
-export type IfJson<T, Y = true, N = false> =
-    IfAny<T> extends true ? Y :
-        IfNull<T> extends true ? Y :
-            IfNever<T> extends true ? N :
-                T extends Function ? N :
-                    T extends symbol ? N :
-                        IfUndefined<T> extends true ? 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
  */
@@ -111,11 +98,9 @@ export type IfObjectOrAny<T, Y = true, N = false> =
  */
 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 Type ? 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>;
@@ -126,9 +111,7 @@ export type IfFunctionOrAny<T, Y = true, N = 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;
+            : T extends Type ? Y : N;
 
 export type IfClassOrAny<T, Y = true, N = false> =
     IfAny<T> extends true ? Y : IfClass<T, Y, N>;
@@ -137,16 +120,15 @@ export type IfClassOrAny<T, Y = true, N = false> =
 /**
  * Returns "Y" if "T1" is exactly same with "T2", "N" otherwise
  */
-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);
 
+type EqualsWrapped<T> = T extends infer R & {}
+    ? { [P in keyof R]: R[P] }
+    : never;
+
 /**
  * Returns "Y" if type "T" matches "U", "N" otherwise
  */

package/lib/{common.d.ts → types.d.ts}

@@ -29,22 +29,27 @@ export type Builtin = Primitive | Function | String | Number | Date | Error | Re
     URL | ReadableStream | WritableStream;
 
 /**
- * Maybe
- * @desc Type representing T | undefined
+ * Type
+ * @desc Represents constructor of type T
  */
-export type Maybe<T> = T | undefined;
+export interface Type<T = any> {
+  new(...args: any[]): T;
+}
 
 /**
- * Nullish
- * @desc Type representing [nullish values][https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-7.html#nullish-coalescing] in TypeScript: `null | undefined`
+ * Class
+ * @desc Represents Class constructor of type T
  */
-export type Nullish<T = null> = T | undefined | null;
+export type Class<Args extends any[] = any[], Instance = {}, Static = {}> =
+    (new(...args: Args) => Instance) & Static;
+
+
 
 /**
- * Falsy
- * @desc Type representing falsy values in TypeScript: `false | "" | 0 | null | undefined`
+ * Maybe
+ * @desc Type representing T | undefined
  */
-export type Falsy = false | '' | 0 | null | undefined;
+export type Maybe<T> = T | undefined;
 
 
 export type Awaited<T> = T extends PromiseLike<infer U> ? U : T;
@@ -68,39 +73,3 @@ export type PropertyType<T, K extends keyof T> = T[K];
  */
 export type ElementType<T extends { [P in K & any]: any },
     K extends keyof T | number> = T[K];
-
-
-/**
- * Type
- * @desc Represents constructor of type T
- */
-export interface Type<T = any> {
-  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;
-
-/**
- * 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.
- */
-declare namespace Symbols {
-  export const base: unique symbol;
-  export const brand: unique symbol;
-}
-type Opaque<T, N extends string> = T & {
-  readonly [Symbols.base]: N;
-  readonly [Symbols.brand]: N;
-}

package/package.json

@@ -12,7 +12,7 @@
     "lodash",
     "underscore"
   ],
-  "version": "2.9.2",
+  "version": "3.0.0",
   "types": "lib/index.d.ts",
   "main": "lib/index.js",
   "module": "lib/index.js",

package/lib/deep-buildable.d.ts

@@ -1,20 +0,0 @@
-import { DeepOmitNever, HighDeepOmitNever } from './deep-omit.js';
-import { IfNoDeepValue } from './helpers.js';
-
-/**
- * Combination of Partial and Writable but deeply
- */
-export type DeepBuildable<T> = DeepOmitNever<_DeepBuildable<T>>;
-type _DeepBuildable<T> =
-    IfNoDeepValue<T> extends true ? T
-        : { -readonly [P in keyof T]?: _DeepBuildable<Exclude<T[P], undefined>> };
-
-/**
- * Combination of Partial and Writable but deeply including arrays
- */
-export type HighDeepBuildable<T> = HighDeepOmitNever<_HighDeepBuildable<T>>;
-type _HighDeepBuildable<T> =
-    T extends (infer U)[] ? _HighDeepBuildable<U>[]
-        : 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,21 +0,0 @@
-import { DeepRequired, HighDeepRequired } from './deep-required.js';
-import { IfNoDeepValue } from './helpers.js';
-
-/**
- * Make all properties in T nullable deeply
- */
-export type DeepNullish<T> = _DeepNullish<DeepRequired<T>>;
-type _DeepNullish<T> =
-    IfNoDeepValue<T> extends true ? T
-        : { [P in keyof T]?: _DeepNullish<Exclude<T[P], undefined>> | null };
-
-
-/**
- * Make all properties in T nullable deeply including arrays
- */
-export type HighDeepNullish<T> = _HighDeepNullish<HighDeepRequired<T>>;
-type _HighDeepNullish<T> =
-    T extends (infer U)[] ? _HighDeepNullish<U>[]
-        : IfNoDeepValue<T> extends true ? T
-            : { [P in keyof T]?: _HighDeepNullish<Exclude<T[P], undefined>> | null };
-

package/lib/deep-omit.d.ts

@@ -1,94 +0,0 @@
-import { IfNoDeepValue } from './helpers.js';
-import { OptionalKeys, ReadonlyKeys, RequiredKeys, WritableKeys } from './keys';
-
-/**
- * Omit all optional properties in T deeply
- */
-export type DeepOmitOptional<T> = DeepOmitNever<_DeepOmitOptional<T>>;
-type _DeepOmitOptional<T, K extends keyof T = Exclude<keyof T, OptionalKeys<T>>> =
-    IfNoDeepValue<T> extends true ? T
-        : { [P in K]-?: _DeepOmitOptional<Exclude<T[P], undefined>> };
-
-/**
- * Omit all optional properties in T deeply including arrays
- */
-export type HighDeepOmitOptional<T> = HighDeepOmitNever<_HighDeepOmitOptional<T>>;
-type _HighDeepOmitOptional<T, K extends keyof T = Exclude<keyof T, OptionalKeys<T>>> =
-    T extends (infer U)[] ? _HighDeepOmitOptional<U>[]
-        : IfNoDeepValue<T> extends true ? T
-            : { [P in K]-?: _HighDeepOmitOptional<Exclude<T[P], undefined>> };
-
-
-/**
- * Omit all required properties in T deeply
- */
-export type DeepOmitRequired<T> = DeepOmitNever<_DeepOmitRequired<T>>;
-type _DeepOmitRequired<T, J extends keyof T = Exclude<keyof T, RequiredKeys<T>>> =
-    IfNoDeepValue<T> extends true ? T
-        : { [P in J]?: _DeepOmitRequired<Exclude<T[P], undefined>> };
-
-
-/**
- * Omit all required properties in T deeply including arrays
- */
-export type HighDeepOmitRequired<T> = HighDeepOmitNever<_HighDeepOmitRequired<T>>;
-type _HighDeepOmitRequired<T, J extends keyof T = Exclude<keyof T, RequiredKeys<T>>> =
-    T extends (infer U)[] ? _HighDeepOmitRequired<U>[]
-        : IfNoDeepValue<T> extends true ? T
-            : { [P in J]?: _HighDeepOmitRequired<Exclude<T[P], undefined>> };
-
-
-/**
- * Omit all readonly properties in T deeply
- */
-export type DeepOmitReadonly<T> = DeepOmitNever<_DeepOmitReadonly<Exclude<T, undefined>>>;
-type _DeepOmitReadonly<T, J extends keyof T = Exclude<keyof T, ReadonlyKeys<T>>> =
-    IfNoDeepValue<T> extends true ? T
-        : { [P in J]: _DeepOmitReadonly<Exclude<T[P], undefined>> };
-
-
-/**
- * Omit all readonly properties in T deeply including arrays
- */
-export type HighDeepOmitReadonly<T> = HighDeepOmitNever<_HighDeepOmitReadonly<T>>;
-type _HighDeepOmitReadonly<T, J extends keyof T = Exclude<keyof T, ReadonlyKeys<T>>> =
-    T extends (infer U)[] ? _HighDeepOmitReadonly<U>[]
-        : IfNoDeepValue<T> extends true ? T
-            : { [P in J]: _HighDeepOmitReadonly<Exclude<T[P], undefined>> };
-
-
-/**
- * Omit all writable properties in T deeply
- */
-export type DeepOmitWritable<T> = DeepOmitNever<_DeepOmitWritable<T>>
-type _DeepOmitWritable<T, K extends keyof T = Exclude<keyof T, WritableKeys<T>>> =
-    IfNoDeepValue<T> extends true ? T
-        : { readonly [P in K]: _DeepOmitWritable<Exclude<T[P], undefined>> }
-
-
-/**
- * Omit all writable properties in T deeply including arrays
- */
-export type HighDeepOmitWritable<T> = HighDeepOmitNever<_HighDeepOmitWritable<T>>
-type _HighDeepOmitWritable<T, K extends keyof T = Exclude<keyof T, WritableKeys<T>>> =
-    T extends (infer U)[] ? _HighDeepOmitWritable<U>[]
-        : IfNoDeepValue<T> extends true ? T
-            : { readonly [P in K]: _HighDeepOmitWritable<Exclude<T[P], undefined>> }
-
-/**
- * Omit all "never" and "undefined" properties in T deeply
- */
-export type DeepOmitNever<T> = _DeepOmitNever<T>
-type _DeepOmitNever<T> =
-    IfNoDeepValue<T> extends true ? T
-        : { [P in keyof T as (Exclude<T[P], undefined> extends never ? never : P)]: _DeepOmitNever<Exclude<T[P], undefined>> }
-
-
-/**
- * Omit all "never" and "undefined" properties in T deeply including arrays
- */
-export type HighDeepOmitNever<T> = _HighDeepOmitNever<T>
-type _HighDeepOmitNever<T> =
-    T extends (infer U)[] ? _HighDeepOmitNever<U>[]
-        : IfNoDeepValue<T> extends true ? T
-            : { [P in keyof T as (Exclude<T[P], undefined> extends never ? never : P)]: _HighDeepOmitNever<Exclude<T[P], undefined>> }

package/lib/deep-partial.d.ts

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