ts-gems 2.4.1 → 2.6.0

package/lib/deep-buildable.d.ts

@@ -0,0 +1,19 @@
+import { IsDeepExcluded } from './helpers.js';
+
+/**
+ * Combination of Partial and Writable but deeply
+ */
+export type DeepBuildable<T> = _DeepBuildable<T>;
+type _DeepBuildable<T> =
+    IsDeepExcluded<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> = _HighDeepBuildable<T>;
+type _HighDeepBuildable<T> =
+    T extends (infer U)[] ? _HighDeepBuildable<U>[]
+        : IsDeepExcluded<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

@@ -0,0 +1,21 @@
+import { DeepRequired, HighDeepRequired } from './deep-required.js';
+import { IsDeepExcluded } 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
+        : { [P in keyof T]: _DeepNullish<Exclude<T[P], undefined>> | null | undefined };
+
+
+/**
+ * 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>[]
+        : IsDeepExcluded<T> extends true ? T
+            : { [P in keyof T]: _HighDeepNullish<Exclude<T[P], undefined>> | null | undefined };
+

package/lib/deep-omit.d.ts

@@ -1,88 +1,76 @@
-import { Builtin } from './common';
-import { IfTuple } from './type-check';
-import { JsonKeys, OptionalKeys, ReadonlyKeys, RequiredKeys, WritableKeys } from './keys';
+import { IsDeepExcluded } from './helpers.js';
+import { OptionalKeys, ReadonlyKeys, RequiredKeys, WritableKeys } from './keys';
 
 /**
  * Omit all optional properties in T deeply
  */
 export type DeepOmitOptional<T> = _DeepOmitOptional<T>;
 type _DeepOmitOptional<T, K extends keyof T = Exclude<keyof T, OptionalKeys<T>>> =
-    T extends Builtin ? T
-        : T extends Promise<infer U> ? Promise<DeepOmitOptional<U>>
-            : T extends Map<infer K, infer V> ? Map<K, DeepOmitOptional<V>>
-                : T extends ReadonlyMap<infer K, infer V> ? ReadonlyMap<K, DeepOmitOptional<V>>
-                    : T extends WeakMap<infer K, infer V> ? WeakMap<K, DeepOmitOptional<V>>
-                        : T extends Set<infer U> ? Set<DeepOmitOptional<U>>
-                            : T extends ReadonlySet<infer U> ? ReadonlySet<DeepOmitOptional<U>>
-                                : T extends WeakSet<infer U> ? WeakSet<DeepOmitOptional<U>>
-                                    : IfTuple<T> extends true ? { [K in OptionalKeys<T>]?: DeepOmitOptional<T[K]> }
-                                        : T extends (infer U)[] ? DeepOmitOptional<U>[]
-                                            : { [P in K]: DeepOmitOptional<Exclude<T[P], undefined>> };
+    IsDeepExcluded<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> = _HighDeepOmitOptional<T>;
+type _HighDeepOmitOptional<T, K extends keyof T = Exclude<keyof T, OptionalKeys<T>>> =
+    T extends (infer U)[] ? _HighDeepOmitOptional<U>[]
+        : IsDeepExcluded<T> extends true ? T
+            : { [P in K]: _HighDeepOmitOptional<Exclude<T[P], undefined>> };
+
 
 /**
  * Omit all required properties in T deeply
  */
 export type DeepOmitRequired<T> = _DeepOmitRequired<T>;
 type _DeepOmitRequired<T, J extends keyof T = Exclude<keyof T, RequiredKeys<T>>> =
-    T extends Builtin ? T
-        : T extends Promise<infer U> ? Promise<DeepOmitRequired<U>>
-            : T extends Map<infer K, infer V> ? Map<K, DeepOmitRequired<V>>
-                : T extends ReadonlyMap<infer K, infer V> ? ReadonlyMap<K, DeepOmitRequired<V>>
-                    : T extends WeakMap<infer K, infer V> ? WeakMap<K, DeepOmitRequired<V>>
-                        : T extends Set<infer U> ? Set<DeepOmitRequired<U>>
-                            : T extends ReadonlySet<infer U> ? ReadonlySet<DeepOmitRequired<U>>
-                                : T extends WeakSet<infer U> ? WeakSet<DeepOmitRequired<U>>
-                                    : IfTuple<T> extends true ? { [K in OptionalKeys<T>]?: DeepOmitRequired<T[K]> }
-                                        : T extends (infer U)[] ? DeepOmitRequired<U>[]
-                                            : { [P in J]: DeepOmitRequired<Exclude<T[P], undefined>> };
+    IsDeepExcluded<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> = _HighDeepOmitRequired<T>;
+type _HighDeepOmitRequired<T, J extends keyof T = Exclude<keyof T, RequiredKeys<T>>> =
+    T extends (infer U)[] ? _HighDeepOmitRequired<U>[]
+        : IsDeepExcluded<T> extends true ? T
+            : { [P in J]: _HighDeepOmitRequired<Exclude<T[P], undefined>> };
+
 
 /**
  * Omit all readonly properties in T deeply
  */
 export type DeepOmitReadonly<T> = _DeepOmitReadonly<T>;
 type _DeepOmitReadonly<T, J extends keyof T = Exclude<keyof T, ReadonlyKeys<T>>> =
-    T extends Builtin ? T
-        : T extends Promise<infer U> ? Promise<DeepOmitReadonly<U>>
-            : T extends Map<infer K, infer V> ? Map<K, DeepOmitReadonly<V>>
-                : T extends ReadonlyMap<infer K, infer V> ? ReadonlyMap<K, DeepOmitReadonly<V>>
-                    : T extends WeakMap<infer K, infer V> ? WeakMap<K, DeepOmitReadonly<V>>
-                        : T extends Set<infer U> ? Set<DeepOmitReadonly<U>>
-                            : T extends ReadonlySet<infer U> ? ReadonlySet<DeepOmitReadonly<U>>
-                                : T extends WeakSet<infer U> ? WeakSet<DeepOmitReadonly<U>>
-                                    : IfTuple<T> extends true ? { [K in OptionalKeys<T>]?: DeepOmitReadonly<T[K]> }
-                                        : T extends (infer U)[] ? DeepOmitReadonly<U>[]
-                                            : { [P in J]: DeepOmitReadonly<Exclude<T[P], undefined>> };
+    IsDeepExcluded<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> = _HighDeepOmitReadonly<T>;
+type _HighDeepOmitReadonly<T, J extends keyof T = Exclude<keyof T, ReadonlyKeys<T>>> =
+    T extends (infer U)[] ? _HighDeepOmitReadonly<U>[]
+        : IsDeepExcluded<T> extends true ? T
+            : { [P in J]: _HighDeepOmitReadonly<Exclude<T[P], undefined>> };
+
 
 /**
  * Omit all writable properties in T deeply
  */
 export type DeepOmitWritable<T> = _DeepOmitWritable<T>
 type _DeepOmitWritable<T, K extends keyof T = Exclude<keyof T, WritableKeys<T>>> =
-    T extends Builtin ? T
-        : T extends Promise<infer U> ? Promise<DeepOmitWritable<U>>
-            : T extends Map<infer K, infer V> ? Map<K, DeepOmitWritable<V>>
-                : T extends ReadonlyMap<infer K, infer V> ? ReadonlyMap<K, DeepOmitWritable<V>>
-                    : T extends WeakMap<infer K, infer V> ? WeakMap<K, DeepOmitWritable<V>>
-                        : T extends Set<infer U> ? Set<DeepOmitWritable<U>>
-                            : T extends ReadonlySet<infer U> ? ReadonlySet<DeepOmitWritable<U>>
-                                : T extends WeakSet<infer U> ? WeakSet<DeepOmitWritable<U>>
-                                    : IfTuple<T> extends true ? { [K in OptionalKeys<T>]?: DeepOmitWritable<T[K]> }
-                                        : T extends (infer U)[] ? DeepOmitWritable<U>[]
-                                            : { [P in K]: DeepOmitWritable<Exclude<T[P], undefined>> }
+    IsDeepExcluded<T> extends true ? T
+        : { [P in K]: _DeepOmitWritable<Exclude<T[P], undefined>> }
+
 
 /**
- * Omit all JSON friendly properties in T deeply
+ * Omit all writable properties in T deeply including arrays
  */
-export type DeepOmitJson<T> = _DeepOmitJson<T>
-type _DeepOmitJson<T, K extends keyof T = Exclude<keyof T, JsonKeys<T>>> =
-    T extends Builtin ? T
-        : T extends Promise<infer U> ? Promise<DeepOmitJson<U>>
-            : T extends Map<infer K, infer V> ? Map<K, DeepOmitJson<V>>
-                : T extends ReadonlyMap<infer K, infer V> ? ReadonlyMap<K, DeepOmitJson<V>>
-                    : T extends WeakMap<infer K, infer V> ? WeakMap<K, DeepOmitJson<V>>
-                        : T extends Set<infer U> ? Set<DeepOmitJson<U>>
-                            : T extends ReadonlySet<infer U> ? ReadonlySet<DeepOmitJson<U>>
-                                : T extends WeakSet<infer U> ? WeakSet<DeepOmitJson<U>>
-                                    : IfTuple<T> extends true ? { [K in OptionalKeys<T>]?: DeepOmitJson<T[K]> }
-                                        : T extends (infer U)[] ? DeepOmitJson<U>[]
-                                            : { [P in K]: DeepOmitJson<Exclude<T[P], undefined>> };
+export type HighDeepOmitWritable<T> = _HighDeepOmitWritable<T>
+type _HighDeepOmitWritable<T, K extends keyof T = Exclude<keyof T, WritableKeys<T>>> =
+    T extends (infer U)[] ? _HighDeepOmitWritable<U>[]
+        : IsDeepExcluded<T> extends true ? T
+            : { [P in K]: _HighDeepOmitWritable<Exclude<T[P], undefined>> }

package/lib/deep-partial.d.ts

@@ -0,0 +1,18 @@
+import { IsDeepExcluded } from './helpers.js';
+
+/**
+ * Partial but deeply
+ */
+export type DeepPartial<T> = _DeepPartial<T>;
+type _DeepPartial<T> =
+    IsDeepExcluded<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>[]
+        : IsDeepExcluded<T> extends true ? T
+            : { [P in keyof T]?: _HighDeepPartial<Exclude<T[P], undefined>> };

package/lib/deep-pick.d.ts

@@ -1,5 +1,4 @@
-import { Builtin } from './common';
-import { IfClass, IfTuple } from './type-check';
+import { IsDeepExcluded } from './helpers.js';
 import { JsonKeys, OptionalKeys, ReadonlyKeys, RequiredKeys, WritableKeys } from './keys';
 
 /**
@@ -7,72 +6,36 @@ 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
-        : 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>> };
+    IsDeepExcluded<T> extends true ? T
+        : { [P in K]?: _DeepPickOptional<Exclude<T[P], undefined>> };
 
 /**
- * Pick all optional properties in T deeply
+ * Pick all optional properties in T deeply including arrays
  */
-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>> };
+export type HighDeepPickOptional<T> = _HighDeepPickOptional<T>;
+type _HighDeepPickOptional<T, K extends keyof T = OptionalKeys<T>> =
+    T extends (infer U)[] ? _HighDeepPickOptional<U>[]
+        : IsDeepExcluded<T> extends true ? T
+            : { [P in K]?: _HighDeepPickOptional<Exclude<T[P], undefined>> };
+
 
 /**
- * Pick all required properties in T deeply even in Maps, Sets etc
+ * Pick all required properties in T deeply
  */
 export type DeepPickRequired<T> = _DeepPickRequired<T>;
 type _DeepPickRequired<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<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>> };
+    IsDeepExcluded<T> extends true ? T
+        : { [P in J]-?: DeepPickRequired<Exclude<T[P], undefined>> };
+
 
 /**
- * Pick all required properties in T deeply even in Maps, Sets etc
+ * Pick all required properties in T deeply including arrays
  */
-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>> };
+export type HighDeepPickRequired<T> = _HighDeepPickRequired<T>;
+type _HighDeepPickRequired<T, J extends keyof T = RequiredKeys<T>> =
+    T extends (infer U)[] ? _HighDeepPickRequired<U>[]
+        : IsDeepExcluded<T> extends true ? T
+            : { [P in J]-?: _HighDeepPickRequired<Exclude<T[P], undefined>> };
 
 
 /**
@@ -80,87 +43,42 @@ type _StrictDeepPickRequired<T, J extends keyof T = RequiredKeys<T>> =
  */
 export type DeepPickReadonly<T> = _DeepPickReadonly<T>;
 type _DeepPickReadonly<T, K 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<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>> };
+    IsDeepExcluded<T> extends true ? T
+        : { [P in K]: DeepPickReadonly<Exclude<T[P], undefined>> };
 
 /**
- * Pick all readonly properties in T deeply even in Maps, Sets etc
+ * Pick all readonly properties in T deeply including arrays
  */
-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>> };
+export type HighDeepPickReadonly<T> = _HighDeepPickReadonly<T>;
+type _HighDeepPickReadonly<T, K extends keyof T = ReadonlyKeys<T>> =
+    T extends (infer U)[] ? _HighDeepPickReadonly<U>[]
+        : IsDeepExcluded<T> extends true ? T
+            : { [P in K]: _HighDeepPickReadonly<Exclude<T[P], undefined>> };
+
 
 /**
  * Pick all writable properties in T deeply
  */
 export type DeepPickWritable<T> = _DeepPickWritable<T>;
 type _DeepPickWritable<T, K extends keyof T = WritableKeys<T>> =
-    T extends Builtin ? T
-        : 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>> };
+    IsDeepExcluded<T> extends true ? T
+        : { [P in K]: DeepPickWritable<Exclude<T[P], undefined>> };
 
 /**
- * Pick all writable properties in T deeply even in Maps, Sets etc
+ * Pick all writable properties in T deeply including arrays
  */
-export type StrictDeepPickWritable<T> = _StrictDeepPickWritable<T>
-type _StrictDeepPickWritable<T, K extends keyof T = WritableKeys<T>> =
-    T extends Builtin ? T
-        : 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>> }
+export type HighDeepPickWritable<T> = _HighDeepPickWritable<T>;
+type _HighDeepPickWritable<T, K extends keyof T = WritableKeys<T>> =
+    T extends (infer U)[] ? _HighDeepPickWritable<U>[]
+        : IsDeepExcluded<T> extends true ? T
+            : { [P in K]: _HighDeepPickWritable<Exclude<T[P], undefined>> };
+
 
 /**
  * Pick all JSON friendly properties in T deeply
  */
 export type DeepPickJson<T> = _DeepPickJson<T>
 type _DeepPickJson<T, Keys extends keyof T = JsonKeys<T>> =
-    T extends Builtin ? T
-        : 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>> };
+    T extends (infer U)[] ? _DeepPickJson<U>[]
+        : IsDeepExcluded<T> extends true ? T
+            : { [P in Keys]: DeepPickJson<Exclude<T[P], undefined>> };

package/lib/deep-readonly.d.ts

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

package/lib/deep-required.d.ts

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

package/lib/deep-writable.d.ts

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

package/lib/helpers.d.ts

@@ -0,0 +1,19 @@
+import { Builtin } from './common.js';
+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> =
+    T extends Builtin ? true
+        : IfTuple<T> extends true ? true
+            : IfClass<T> extends true ? true
+                : T extends Map<any, any> ? true
+                    : T extends ReadonlyMap<any, any> ? true
+                        : T extends WeakMap<any, any> ? true
+                            : T extends Set<any> ? true
+                                : T extends ReadonlySet<any> ? true
+                                    : T extends WeakSet<any> ? true
+                                        : T extends any[] ? true
+                                            : false;

package/lib/index.d.ts

@@ -2,8 +2,13 @@ export * from "./common";
 export * from "./keys";
 export * from "./type-check";
 export * from "./modify";
-export * from "./deep-pick";
+export * from "./deep-buildable";
+export * from "./deep-nullish";
 export * from "./deep-omit";
-export * from "./deep-modify";
+export * from "./deep-partial";
+export * from "./deep-pick";
+export * from "./deep-readonly";
+export * from "./deep-required";
+export * from "./deep-writable";
 export * from "./pick";
 export * from "./omit";

package/lib/modify.d.ts

@@ -29,3 +29,8 @@ export type ReadonlySome<T, K extends keyof T> = Readonly<Pick<T, K>> & Omit<T,
  * Marks given keys as writable
  */
 export type WritableSome<T, K extends keyof T> = Writable<Pick<T, K>> & Omit<T, K>;
+
+/**
+ * Merges two types without merging types of elements.
+ */
+export type Combine<A, B> = A & Exclude<B, keyof A>;

package/package.json

@@ -12,7 +12,7 @@
     "lodash",
     "underscore"
   ],
-  "version": "2.4.1",
+  "version": "2.6.0",
   "types": "lib/index.d.ts",
   "main": "lib/index.js",
   "module": "lib/index.js",
@@ -32,10 +32,10 @@
     "lib/"
   ],
   "devDependencies": {
-    "@types/jest": "^29.5.3",
-    "eslint": "^8.45.0",
-    "jest": "^29.6.1",
+    "@types/jest": "^29.5.4",
+    "eslint": "^8.49.0",
+    "jest": "^29.7.0",
     "ts-jest": "^29.1.1",
-    "typescript": "^5.1.6"
+    "typescript": "^5.2.2"
   }
 }

package/lib/deep-modify.d.ts

@@ -1,106 +0,0 @@
-import { Builtin } from './common';
-import { IfTuple } from './type-check';
-import { OptionalKeys } from './keys';
-
-/**
- * Partial but deeply
- */
-export type DeepPartial<T> = _DeepPartial<T>;
-type _DeepPartial<T> =
-    T extends Builtin ? T
-        : T extends Promise<infer U> ? Promise<DeepPartial<U>>
-            : T extends Map<infer K, infer V> ? Map<K, DeepPartial<V>>
-                : T extends ReadonlyMap<infer K, infer V> ? ReadonlyMap<K, DeepPartial<V>>
-                    : T extends WeakMap<infer K, infer V> ? WeakMap<K, DeepPartial<V>>
-                        : T extends Set<infer U> ? Set<DeepPartial<U>>
-                            : T extends ReadonlySet<infer U> ? ReadonlySet<DeepPartial<U>>
-                                : T extends WeakSet<infer U> ? WeakSet<DeepPartial<U>>
-                                    : IfTuple<T> extends true ? { [K in OptionalKeys<T>]?: DeepPartial<T[K]> }
-                                        : T extends (infer U)[] ? DeepPartial<U>[]
-                                            : { [P in keyof T]?: DeepPartial<Exclude<T[P], undefined>> };
-
-/**
- * Combination of Partial and Writable but deeply
- */
-export type DeepBuildable<T> = _DeepBuildable<T>;
-type _DeepBuildable<T> =
-    T extends Builtin ? T
-        : T extends Promise<infer U> ? Promise<DeepBuildable<U>>
-            : T extends Map<infer K, infer V> ? Map<K, DeepBuildable<V>>
-                : T extends ReadonlyMap<infer K, infer V> ? ReadonlyMap<K, DeepBuildable<V>>
-                    : T extends WeakMap<infer K, infer V> ? WeakMap<K, DeepBuildable<V>>
-                        : T extends Set<infer U> ? Set<DeepBuildable<U>>
-                            : T extends ReadonlySet<infer U> ? ReadonlySet<DeepBuildable<U>>
-                                : T extends WeakSet<infer U> ? WeakSet<DeepBuildable<U>>
-                                    : IfTuple<T> extends true ? { [K in OptionalKeys<T>]?: DeepBuildable<T[K]> }
-                                        : T extends (infer U)[] ? DeepBuildable<U>[]
-                                            : { -readonly [P in keyof T]?: DeepBuildable<Exclude<T[P], undefined>> };
-
-/**
- * Make all properties in T required deeply
- */
-export type DeepRequired<T> = _DeepRequired<T>;
-type _DeepRequired<T> =
-    T extends Builtin ? T
-        : T extends Promise<infer U> ? Promise<DeepRequired<U>>
-            : T extends Map<infer K, infer V> ? Map<K, DeepRequired<V>>
-                : T extends ReadonlyMap<infer K, infer V> ? ReadonlyMap<K, DeepRequired<V>>
-                    : T extends WeakMap<infer K, infer V> ? WeakMap<K, DeepRequired<V>>
-                        : T extends Set<infer U> ? Set<DeepRequired<U>>
-                            : T extends ReadonlySet<infer U> ? ReadonlySet<DeepRequired<U>>
-                                : T extends WeakSet<infer U> ? WeakSet<DeepRequired<U>>
-                                    : IfTuple<T> extends true ? { [K in OptionalKeys<T>]?: DeepRequired<T[K]> }
-                                        : T extends (infer U)[] ? DeepRequired<U>[]
-                                            : { [P in keyof T]-?: DeepRequired<Exclude<T[P], undefined>> };
-
-
-/**
- * Make all properties in T readonly deeply
- */
-export type DeepReadonly<T> = _DeepReadonly<T>;
-type _DeepReadonly<T> =
-    T extends Builtin ? T
-        : T extends Promise<infer U> ? Promise<DeepReadonly<U>>
-            : T extends Map<infer K, infer V> ? Map<K, DeepReadonly<V>>
-                : T extends ReadonlyMap<infer K, infer V> ? ReadonlyMap<K, DeepReadonly<V>>
-                    : T extends WeakMap<infer K, infer V> ? WeakMap<K, DeepReadonly<V>>
-                        : T extends Set<infer U> ? Set<DeepReadonly<U>>
-                            : T extends ReadonlySet<infer U> ? ReadonlySet<DeepReadonly<U>>
-                                : T extends WeakSet<infer U> ? WeakSet<DeepReadonly<U>>
-                                    : IfTuple<T> extends true ? { [K in OptionalKeys<T>]?: DeepReadonly<T[K]> }
-                                        : T extends (infer U)[] ? DeepReadonly<U>[]
-                                            : { readonly [P in keyof T]: DeepReadonly<Exclude<T[P], undefined>> };
-
-/**
- * Make all properties in T writable deeply
- */
-export type DeepWritable<T> = _DeepWritable<T>;
-type _DeepWritable<T> =
-    T extends Builtin ? T
-        : T extends Promise<infer U> ? Promise<DeepWritable<U>>
-            : T extends Map<infer K, infer V> ? Map<K, DeepWritable<V>>
-                : T extends ReadonlyMap<infer K, infer V> ? ReadonlyMap<K, DeepWritable<V>>
-                    : T extends WeakMap<infer K, infer V> ? WeakMap<K, DeepWritable<V>>
-                        : T extends Set<infer U> ? Set<DeepWritable<U>>
-                            : T extends ReadonlySet<infer U> ? ReadonlySet<DeepWritable<U>>
-                                : T extends WeakSet<infer U> ? WeakSet<DeepWritable<U>>
-                                    : IfTuple<T> extends true ? { [K in OptionalKeys<T>]?: DeepWritable<T[K]> }
-                                        : T extends (infer U)[] ? DeepWritable<U>[]
-                                            : { -readonly [P in keyof T]: DeepWritable<Exclude<T[P], undefined>> };
-
-/**
- * Make all properties in T nullable deeply
- */
-export type DeepNullish<T> = _DeepNullish<DeepRequired<T>>;
-type _DeepNullish<T> =
-    T extends Builtin ? T | null | undefined
-        : T extends Promise<infer U> ? Promise<DeepNullish<U>>
-            : T extends Map<infer K, infer V> ? Map<K, DeepNullish<V>>
-                : T extends ReadonlyMap<infer K, infer V> ? ReadonlyMap<K, DeepNullish<V>>
-                    : T extends WeakMap<infer K, infer V> ? WeakMap<K, DeepNullish<V>>
-                        : T extends Set<infer U> ? Set<DeepNullish<U>>
-                            : T extends ReadonlySet<infer U> ? ReadonlySet<DeepNullish<U>>
-                                : T extends WeakSet<infer U> ? WeakSet<DeepNullish<U>>
-                                    : IfTuple<T> extends true ? { [K in OptionalKeys<T>]?: DeepNullish<T[K]> }
-                                        : T extends (infer U)[] ? DeepNullish<U>[] | null | undefined
-                                            : { [P in keyof T]: DeepNullish<Exclude<T[P], undefined>> | null | undefined };