ts-gems 3.12.0 → 4.0.1

package/lib/omit-never.d.ts

@@ -1,5 +1,5 @@
 import { IfNoDeepValue } from './helpers.js';
-import { IfNever } from './type-check.js';
+import { IfNever, IfTuple } from './type-check.js';
 
 /**
  * OmitNever<T> is a type that omits all properties with a value of type "never".
@@ -30,25 +30,31 @@ export type OmitNever<T> = {
 export type DeepOmitNever<T> = {
   [K in keyof T as IfNever<Exclude<T[K], undefined>, never, K>]: IfNoDeepValue<
     // Do not deep process No-Deep values
-    NonNullable<T[K]>
+    Exclude<T[K], undefined>
   > extends true
     ? T[K]
-    : // Deep process objects
-      DeepOmitNever<NonNullable<T[K]>>;
+    : // Deep process objects (Exclude, not NonNullable - preserves a `| null` member)
+      DeepOmitNever<Exclude<T[K], undefined>>;
 };
 
 /**
  * Omit all "never" and "undefined" properties in T deeply including arrays
  */
 export type DeeperOmitNever<T> = {
-  [K in keyof T as IfNever<Exclude<T[K], undefined>, never, K>]: NonNullable<
-    // Deep process arrays
-    T[K]
-  > extends (infer U)[]
-    ? DeeperOmitNever<U>[]
-    : // Do not deep process No-Deep values
-      IfNoDeepValue<NonNullable<T[K]>> extends true
-      ? T[K]
-      : // Deep process objects
-        DeeperOmitNever<NonNullable<T[K]>>;
+  [K in keyof T as IfNever<Exclude<T[K], undefined>, never, K>]: IfTuple<
+    NonNullable<T[K]>
+  > extends true // Leave fixed-length tuples untouched
+    ? T[K]
+    : NonNullable<
+          // Deep process arrays
+          T[K]
+        > extends readonly (infer U)[]
+      ? null extends T[K] // Preserve a `| null` member lost by NonNullable above
+        ? DeeperOmitNever<U>[] | null
+        : DeeperOmitNever<U>[]
+      : // Do not deep process No-Deep values
+        IfNoDeepValue<Exclude<T[K], undefined>> extends true
+        ? T[K]
+        : // Deep process objects (Exclude, not NonNullable - preserves a `| null` member)
+          DeeperOmitNever<Exclude<T[K], undefined>>;
 };

package/lib/omit-undefined.d.ts

@@ -1,5 +1,5 @@
 import { IfNoDeepValue } from './helpers.js';
-import { IfNever } from './type-check.js';
+import { IfNever, IfTuple } from './type-check.js';
 
 /**
  * OmitUndefined<T> is a type that omits all properties with a value of type "undefined".
@@ -25,13 +25,17 @@ export type DeepOmitUndefined<T> = {
  * Omit all "never" and "undefined" properties in T deeply including arrays
  */
 export type DeeperOmitUndefined<T> = {
-  [K in keyof T as IfNever<Exclude<T[K], undefined>, never, K>]: NonNullable<
-    T[K]
-  > extends (infer U)[] // Deep process arrays
-    ? DeeperOmitUndefined<U>[]
-    : // Do not deep process No-Deep values
-      IfNoDeepValue<NonNullable<T[K]>> extends true
-      ? T[K]
-      : // Deep process objects
-        DeeperOmitUndefined<NonNullable<T[K]>>;
+  [K in keyof T as IfNever<Exclude<T[K], undefined>, never, K>]: IfTuple<
+    NonNullable<T[K]>
+  > extends true // Leave fixed-length tuples untouched
+    ? T[K]
+    : NonNullable<T[K]> extends readonly (infer U)[] // Deep process arrays
+      ? null extends T[K] // Preserve a `| null` member lost by NonNullable above
+        ? DeeperOmitUndefined<U>[] | null
+        : DeeperOmitUndefined<U>[]
+      : // Do not deep process No-Deep values
+        IfNoDeepValue<Exclude<T[K], undefined>> extends true
+        ? T[K]
+        : // Deep process objects (Exclude, not NonNullable - preserves a `| null` member)
+          DeeperOmitUndefined<Exclude<T[K], undefined>>;
 };

package/lib/omit.d.ts

@@ -1,27 +1,38 @@
 import { IfNoDeepValue } from './helpers.js';
 import { Or } from './logical.js';
-import { IfFunction, IfNever } from './type-check.js';
+import { IfFunction, IfNever, IfTuple } from './type-check.js';
 
 /**
  * Construct a type with the properties of T except for those in type K,
  * while preserving strict type checking.
  */
 export type StrictOmit<T, X extends keyof T> = {
-  [K in keyof T as K extends X ? never : K]: T[K];
+  [
+    K in keyof T as Or<
+      // Omit never keys
+      IfNever<Exclude<T[K], undefined>>,
+      // Omit X
+      K extends X ? true : false
+    > extends true
+      ? never
+      : K
+  ]: T[K];
 };
 
 /**
  * Omit all function properties in T
  */
 export type OmitFunctions<T> = {
-  [K in keyof T as Or<
-    // Omit never keys
-    IfNever<Exclude<T[K], undefined>>,
-    // Omit functions
-    IfFunction<NonNullable<T[K]>>
-  > extends true
-    ? never
-    : K]: T[K];
+  [
+    K in keyof T as Or<
+      // Omit never keys
+      IfNever<Exclude<T[K], undefined>>,
+      // Omit functions
+      IfFunction<NonNullable<T[K]>>
+    > extends true
+      ? never
+      : K
+  ]: T[K];
 };
 
 /**
@@ -38,31 +49,31 @@ export type OmitTypes<T, X> = {
  * Omit all function properties in T
  */
 export type DeepOmitTypes<T, X> = {
-  [K in keyof T as IfNever<
-    Exclude<T[K], undefined | X>,
-    never,
-    K
-  >]: IfNoDeepValue<Exclude<T[K], undefined>> extends true // Do not deep process No-Deep values
+  [
+    K in keyof T as IfNever<Exclude<T[K], undefined | X>, never, K>
+  ]: IfNoDeepValue<Exclude<T[K], undefined>> extends true // Do not deep process No-Deep values
     ? Exclude<T[K], X>
-    : // Deep process objects
-      DeepOmitTypes<NonNullable<T[K]>, X>;
+    : // Deep process objects (Exclude, not NonNullable - preserves a `| null` member)
+      DeepOmitTypes<Exclude<T[K], undefined>, X>;
 };
 
 /**
  * Omit all function properties in T deeply including arrays
  */
 export type DeeperOmitTypes<T, X> = {
-  [K in keyof T as IfNever<
-    Exclude<T[K], undefined | X>,
-    never,
-    K
-  >]: NonNullable<
-    // Deep process arrays // Do not deep process No-Deep values
-    T[K]
-  > extends (infer U)[]
-    ? DeeperOmitTypes<U, X>[]
-    : IfNoDeepValue<NonNullable<T[K]>> extends true
-      ? Exclude<T[K], X>
-      : // Deep process objects
-        DeeperOmitTypes<NonNullable<T[K]>, X>;
+  [K in keyof T as IfNever<Exclude<T[K], undefined | X>, never, K>]: IfTuple<
+    NonNullable<T[K]>
+  > extends true // Leave fixed-length tuples untouched
+    ? Exclude<T[K], X>
+    : NonNullable<
+          // Deep process arrays // Do not deep process No-Deep values
+          T[K]
+        > extends readonly (infer U)[]
+      ? null extends T[K] // Preserve a `| null` member lost by NonNullable above
+        ? DeeperOmitTypes<U, X>[] | null
+        : DeeperOmitTypes<U, X>[]
+      : IfNoDeepValue<Exclude<T[K], undefined>> extends true
+        ? Exclude<T[K], X>
+        : // Deep process objects (Exclude, not NonNullable - preserves a `| null` member)
+          DeeperOmitTypes<Exclude<T[K], undefined>, X>;
 };

package/lib/partial.d.ts

@@ -7,7 +7,7 @@ import {
   OmitRequired,
   PickRequired,
 } from './required.js';
-import { IfNever } from './type-check.js';
+import { IfNever, IfTuple } from './type-check.js';
 
 /**
  * Marks given keys as optional
@@ -24,24 +24,27 @@ export type DeepPartial<T> = {
     Exclude<T[K], undefined>
   > extends true
     ? T[K]
-    : // Deep process objects
-      DeepPartial<NonNullable<T[K]>>;
+    : // Deep process objects (Exclude, not NonNullable - preserves a `| null` member)
+      DeepPartial<Exclude<T[K], undefined>>;
 };
 
 /**
  * Partial but deeply including arrays
  */
 export type DeeperPartial<T> = {
-  [K in keyof T as IfNever<Exclude<T[K], undefined>, never, K>]?: NonNullable<
-    // Deep process arrays
-    T[K]
-  > extends (infer U)[]
-    ? DeeperPartial<U>[]
-    : // Do not deep process No-Deep values
-      IfNoDeepValue<NonNullable<T[K]>> extends true
-      ? T[K]
-      : // Deep process objects
-        DeeperPartial<NonNullable<T[K]>>;
+  [K in keyof T as IfNever<Exclude<T[K], undefined>, never, K>]?: IfTuple<
+    NonNullable<T[K]>
+  > extends true // Leave fixed-length tuples untouched
+    ? T[K]
+    : NonNullable<T[K]> extends readonly (infer U)[] // Deep process arrays
+      ? null extends T[K] // Preserve a `| null` member lost by NonNullable above
+        ? DeeperPartial<U>[] | null
+        : DeeperPartial<U>[]
+      : // Do not deep process No-Deep values
+        IfNoDeepValue<Exclude<T[K], undefined>> extends true
+        ? T[K]
+        : // Deep process objects (Exclude, not NonNullable - preserves a `| null` member)
+          DeeperPartial<Exclude<T[K], undefined>>;
 };
 
 /**

package/lib/pick.d.ts

@@ -13,62 +13,70 @@ import {
  * 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<NonNullable<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 non functions
+      IfFunction<NonNullable<T[K]>, 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];
 };
 
 /**

package/lib/readonly.d.ts

@@ -1,6 +1,6 @@
 import { IfNoDeepValue } from './helpers.js';
 import { Or } from './logical.js';
-import { IfEquals, IfNever } from './type-check.js';
+import { IfEquals, IfNever, IfTuple } from './type-check.js';
 
 /**
  * Marks given keys as readonly
@@ -12,11 +12,9 @@ export type ReadonlySome<T, K extends keyof T> = Readonly<Pick<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
-  >]: IfNoDeepValue<Exclude<T[K], undefined>> extends true // Do not deep process No-Deep values
+  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>>;
@@ -26,17 +24,19 @@ export type DeepReadonly<T> = {
  * Make all properties in T readonly deeply
  */
 export type DeeperReadonly<T> = {
-  readonly [K in keyof T as IfNever<
-    Exclude<T[K], undefined>,
-    never,
-    K
-  >]: NonNullable<T[K]> 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>>;
+  readonly [
+    K in keyof T as IfNever<Exclude<T[K], undefined>, never, K>
+  ]: IfTuple<NonNullable<T[K]>> extends true // Leave fixed-length tuples untouched
+    ? T[K]
+    : NonNullable<T[K]> extends readonly (infer U)[] // Deep process arrays
+      ? null extends T[K] // Preserve a `| null` member lost by NonNullable above
+        ? DeeperReadonly<U>[] | null
+        : 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>>;
 };
 
 /**
@@ -48,100 +48,120 @@ 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]: IfNoDeepValue<NonNullable<T[K]>> extends true // Do not deep process No-Deep values
+  [
+    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<NonNullable<T[K]>>;
+    : // Deep process objects (Exclude, not NonNullable - preserves a `| null` member)
+      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<NonNullable<T[K]>>,
-    // Omit required
-    IfEquals<{ [Q in K]: T[K] }, { readonly [Q in K]: T[K] }>
-  > extends true
-    ? never
-    : K]: IfNoDeepValue<NonNullable<T[K]>> extends true // Do not deep process No-Deep values
+  [
+    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<NonNullable<T[K]>>;
+    : // Deep process objects (Exclude, not NonNullable - preserves a `| null` member)
+      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]: NonNullable<T[K]> extends (infer U)[] // Deep process arrays
-    ? DeeperPickReadonly<U>[]
-    : // Do not deep process No-Deep values
-      IfNoDeepValue<NonNullable<T[K]>> extends true
-      ? T[K]
-      : // Deep process objects
-        DeeperPickReadonly<NonNullable<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
+  ]: IfTuple<NonNullable<T[K]>> extends true // Leave fixed-length tuples untouched
+    ? T[K]
+    : NonNullable<T[K]> extends readonly (infer U)[] // Deep process arrays
+      ? null extends T[K] // Preserve a `| null` member lost by NonNullable above
+        ? DeeperPickReadonly<U>[] | null
+        : DeeperPickReadonly<U>[]
+      : // Do not deep process No-Deep values
+        IfNoDeepValue<Exclude<T[K], undefined>> extends true
+        ? T[K]
+        : // Deep process objects (Exclude, not NonNullable - preserves a `| null` member)
+          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]: NonNullable<T[K]> extends (infer U)[] // Deep process arrays
-    ? DeeperOmitReadonly<U>[]
-    : // Do not deep process No-Deep values
-      IfNoDeepValue<NonNullable<T[K]>> extends true
-      ? T[K]
-      : // Deep process objects
-        DeeperOmitReadonly<NonNullable<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
+  ]: IfTuple<NonNullable<T[K]>> extends true // Leave fixed-length tuples untouched
+    ? T[K]
+    : NonNullable<T[K]> extends readonly (infer U)[] // Deep process arrays
+      ? null extends T[K] // Preserve a `| null` member lost by NonNullable above
+        ? DeeperOmitReadonly<U>[] | null
+        : DeeperOmitReadonly<U>[]
+      : // Do not deep process No-Deep values
+        IfNoDeepValue<Exclude<T[K], undefined>> extends true
+        ? T[K]
+        : // Deep process objects (Exclude, not NonNullable - preserves a `| null` member)
+          DeeperOmitReadonly<Exclude<T[K], undefined>>;
 };