npm - ts-gems - Versions diffs - 4.0.2 → 4.0.4 - Mend

ts-gems 4.0.2 → 4.0.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (13) hide show

package/lib/dto.d.ts CHANGED Viewed

@@ -4,24 +4,68 @@ import { DeeperPartial } from './partial.js';
 import { IfNever, IfTuple } from './type-check.js';
 /**
- * Returns the given type as a Data Transfer Object (DTO) interface, Removes symbol keys and function properties.
+ * Narrows T to a Data Transfer Object shape: a plain, serializable snapshot
+ * of T's data, safe to persist to a database, encode to JSON, or send over
+ * an API. It strips whatever only exists in a live JavaScript runtime and
+ * cannot survive that round-trip - function properties, and properties
+ * whose value or key is a symbol - recursively into nested objects, arrays,
+ * and tuples.
+ *
+ * DTO only removes those non-serializable members. It does not otherwise
+ * change a value's mutability, or a property's readonly/optional modifiers
+ * - "is this representable as plain data" is orthogonal to "is this
+ * mutable/readonly", which is the concern of the
+ * Mutable/Readonly/Partial/Required families instead. In particular, a
+ * `readonly T[]` property stays a `readonly T[]` after DTO - it is still
+ * perfectly serializable, so DTO has no reason to touch it.
+ *
  * @template T - The type of the data being transferred.
+ * @template X - An extra type unioned into every remaining property's
+ *   value, useful for tagging every field with a shared marker (e.g. a
+ *   sentinel for "field not selected"). See docs/api/dto.md.
  */
 export type DTO<T, X = never> = {
   [
     K in keyof T as K extends symbol
       ? never
       : IfNever<Exclude<NonNullable<T[K]>, Function | symbol>, never, K>
-  ]: IfTuple<NonNullable<T[K]>> extends true // Leave fixed-length tuples untouched
-    ? NonNullable<T[K] | X>
+  ]: IfTuple<NonNullable<T[K]>> extends true
+    ? DTOTuple<NonNullable<T[K]>, X>
     : NonNullable<T[K]> extends readonly (infer U)[] // Deep process arrays
-      ? DTO<U>[]
-      : // Do not deep process No-Deep values
-        IfNoDeepValue<NonNullable<T[K]>> extends true
-        ? NonNullable<T[K] | X>
-        : // Deep process objects
-          DTO<NonNullable<T[K] | X>>;
+      ? NonNullable<T[K]> extends any[]
+        ? DTO<U>[] // was a mutable array - stays mutable
+        : readonly DTO<U>[] // was a readonly array - DTO doesn't touch mutability
+      : DTOValue<T[K], X>;
 };
+type DTOValue<V, X> =
+  IfNoDeepValue<NonNullable<V>> extends true
+    ? NonNullable<V | X>
+    : DTO<NonNullable<V | X>>;
+type DTOTuple<T, X> = T extends readonly [infer Head, ...infer Rest]
+  ? IfNever<Exclude<NonNullable<Head>, Function | symbol>> extends true
+    ? DTOTuple<Rest, X>
+    : [DTOValue<Head, X>, ...DTOTuple<Rest, X>]
+  : [];
+/**
+ * `DTO<T, X>` with every property (including nested ones and array/tuple
+ * elements) made optional. For request bodies where the data is expected to
+ * be incomplete - a "create" endpoint where some fields have server-side
+ * defaults, or an "update" endpoint where the caller only sends the fields
+ * they want to change and omitting a key means "leave it as it is".
+ *
+ * See `PatchDTO` for the alternative where omitting a key and sending
+ * `null` are meant to mean different things.
+ */
 export type PartialDTO<T, X = never> = DeeperPartial<DTO<T, X>>;
+/**
+ * `DTO<T, X>` with every property (including nested ones and array/tuple
+ * elements) made optional and nullable. For "patch"-style update endpoints
+ * that need to distinguish "omit this key, leave the field unchanged" from
+ * "send `null` for this key, clear the field" - `PartialDTO` alone cannot
+ * express that second case since it never adds `null`.
+ */
 export type PatchDTO<T, X = never> = DeeperNullish<DTO<T, X>>;

package/lib/helpers.d.ts CHANGED Viewed

@@ -4,32 +4,31 @@ import { Builtin } from './types.js';
 /**
  * Returns true if T is excluded from deep operations
  */
-export type IfNoDeepValue<T> =
-  IfAny<T> extends true
-    ? true
-    : T extends Builtin
+export type IfNoDeepValue<T> = T extends Builtin
+  ? true
+  : IfAny<T> extends true
+    ? T
+    : IfTuple<T> extends true
       ? true
-      : IfTuple<T> extends true
+      : T extends Function
         ? true
-        : T extends Function
+        : IfClass<T> extends true
           ? true
-          : IfClass<T> extends true
+          : T extends Map<any, any>
             ? true
-            : T extends Map<any, any>
+            : T extends ReadonlyMap<any, any>
               ? true
-              : T extends ReadonlyMap<any, any>
+              : T extends WeakMap<any, any>
                 ? true
-                : T extends WeakMap<any, any>
+                : T extends Set<any>
                   ? true
-                  : T extends Set<any>
+                  : T extends ReadonlySet<any>
                     ? true
-                    : T extends ReadonlySet<any>
+                    : T extends WeakSet<any>
                       ? true
-                      : T extends WeakSet<any>
+                      : T extends readonly any[]
                         ? true
-                        : T extends readonly any[]
-                          ? true
-                          : false;
+                        : false;
 /**
  * ValuesOf

package/lib/mutable.d.ts CHANGED Viewed

@@ -40,10 +40,11 @@ export type DeepMutable<T> = {
 export type DeeperMutable<T> = {
   -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]
+  ]: IfTuple<NonNullable<T[K]>> extends true // Deep process tuples positionally
+    ? DeeperMutableTuple<NonNullable<T[K]>>
     : NonNullable<T[K]> extends readonly (infer U)[] // Deep process arrays
-      ? null extends T[K] // Preserve a `| null` member lost by NonNullable above
+      ? // Always mutable - that is DeeperMutable's whole purpose
+        null extends T[K]
         ? DeeperMutable<U>[] | null
         : DeeperMutable<U>[]
       : // Do not deep process No-Deep values
@@ -53,6 +54,15 @@ export type DeeperMutable<T> = {
           DeeperMutable<Exclude<T[K], undefined>>;
 };
+type DeeperMutableTuple<T> = T extends readonly [infer Head, ...infer Rest]
+  ? [
+      IfNoDeepValue<NonNullable<Head>> extends true
+        ? Head
+        : DeeperMutable<NonNullable<Head>>,
+      ...DeeperMutableTuple<Rest>,
+    ]
+  : [];
 /**
  * Returns mutable keys of an object
  */

package/lib/non-nullable.d.ts CHANGED Viewed

@@ -2,7 +2,7 @@ import { IfNoDeepValue } from './helpers.js';
 import { IfNever, IfNull, IfTuple } from './type-check.js';
 /**
- * Exclude null and undefined from T
+ * Exclude null and undefined from T deeply
  */
 export type UnNullish<T> = {
   [
@@ -43,13 +43,24 @@ export type DeeperUnNullish<T> = {
       never,
       IfNull<Exclude<T[K], undefined>, never, K>
     >
-  ]: IfTuple<NonNullable<T[K]>> extends true // Leave fixed-length tuples untouched
-    ? NonNullable<T[K]>
+  ]: IfTuple<NonNullable<T[K]>> extends true // Deep process tuples positionally
+    ? DeeperUnNullishTuple<NonNullable<T[K]>>
     : NonNullable<NonNullable<T[K]>> extends readonly (infer U)[]
-      ? DeeperUnNullish<U>[]
+      ? NonNullable<T[K]> extends any[]
+        ? DeeperUnNullish<U>[] // was mutable - UnNullish doesn't touch mutability
+        : readonly DeeperUnNullish<U>[] // was readonly - preserve that
       : // Do not deep process No-Deep values
         IfNoDeepValue<NonNullable<T[K]>> extends true
         ? NonNullable<T[K]>
         : // Deep process objects
           DeeperUnNullish<NonNullable<T[K]>>;
 };
+type DeeperUnNullishTuple<T> = T extends readonly [infer Head, ...infer Rest]
+  ? [
+      IfNoDeepValue<NonNullable<Head>> extends true
+        ? NonNullable<Head>
+        : DeeperUnNullish<NonNullable<Head>>,
+      ...DeeperUnNullishTuple<Rest>,
+    ]
+  : [];

package/lib/nullish.d.ts CHANGED Viewed

@@ -27,16 +27,27 @@ export type DeepNullish<T> = {
 export type DeeperNullish<T> = {
   [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] | null
+  > extends true // Deep process tuples positionally
+    ? DeeperNullishTuple<NonNullable<T[K]>> | null
     : NonNullable<
           // Deep process arrays
           T[K]
         > extends readonly (infer U)[]
-      ? DeeperNullish<U>[] | null
+      ? NonNullable<T[K]> extends any[]
+        ? DeeperNullish<U>[] | null // was mutable - DeeperNullish doesn't touch mutability
+        : readonly DeeperNullish<U>[] | null // was readonly - preserve that
       : // Do not deep process No-Deep values
         IfNoDeepValue<NonNullable<T[K]>> extends true
         ? T[K] | null
         : // Deep process objects
           DeeperNullish<NonNullable<T[K]>> | null;
 };
+type DeeperNullishTuple<T> = T extends readonly [infer Head, ...infer Rest]
+  ? [
+      IfNoDeepValue<NonNullable<Head>> extends true
+        ? Head
+        : DeeperNullish<NonNullable<Head>>,
+      ...DeeperNullishTuple<Rest>,
+    ]
+  : [];

package/lib/omit-never.d.ts CHANGED Viewed

@@ -43,18 +43,32 @@ export type DeepOmitNever<T> = {
 export type DeeperOmitNever<T> = {
   [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]
+  > extends true // Deep process tuples positionally
+    ? DeeperOmitNeverTuple<NonNullable<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>[]
+      ? NonNullable<T[K]> extends any[]
+        ? // was mutable - DeeperOmitNever doesn't touch mutability
+          null extends T[K]
+          ? DeeperOmitNever<U>[] | null
+          : DeeperOmitNever<U>[]
+        : null extends T[K] // was readonly - preserve that
+          ? readonly DeeperOmitNever<U>[] | null
+          : readonly 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>>;
 };
+type DeeperOmitNeverTuple<T> = T extends readonly [infer Head, ...infer Rest]
+  ? [
+      IfNoDeepValue<NonNullable<Head>> extends true
+        ? Head
+        : DeeperOmitNever<NonNullable<Head>>,
+      ...DeeperOmitNeverTuple<Rest>,
+    ]
+  : [];

package/lib/omit-undefined.d.ts CHANGED Viewed

@@ -27,15 +27,32 @@ export type DeepOmitUndefined<T> = {
 export type DeeperOmitUndefined<T> = {
   [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]
+  > extends true // Deep process tuples positionally
+    ? DeeperOmitUndefinedTuple<NonNullable<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>[]
+      ? NonNullable<T[K]> extends any[]
+        ? // was mutable - DeeperOmitUndefined doesn't touch mutability
+          null extends T[K]
+          ? DeeperOmitUndefined<U>[] | null
+          : DeeperOmitUndefined<U>[]
+        : null extends T[K] // was readonly - preserve that
+          ? readonly DeeperOmitUndefined<U>[] | null
+          : readonly 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>>;
 };
+type DeeperOmitUndefinedTuple<T> = T extends readonly [
+  infer Head,
+  ...infer Rest,
+]
+  ? [
+      IfNoDeepValue<NonNullable<Head>> extends true
+        ? Head
+        : DeeperOmitUndefined<NonNullable<Head>>,
+      ...DeeperOmitUndefinedTuple<Rest>,
+    ]
+  : [];

package/lib/omit.d.ts CHANGED Viewed

@@ -54,17 +54,31 @@ export type DeepOmitTypes<T, X> = {
 export type DeeperOmitTypes<T, 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>
+  > extends true // Deep process tuples positionally
+    ? DeeperOmitTypesTuple<NonNullable<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>[]
+      ? NonNullable<T[K]> extends any[]
+        ? // was mutable - DeeperOmitTypes doesn't touch mutability
+          null extends T[K]
+          ? DeeperOmitTypes<U, X>[] | null
+          : DeeperOmitTypes<U, X>[]
+        : null extends T[K] // was readonly - preserve that
+          ? readonly DeeperOmitTypes<U, X>[] | null
+          : readonly 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>;
 };
+type DeeperOmitTypesTuple<T, X> = T extends readonly [infer Head, ...infer Rest]
+  ? [
+      IfNoDeepValue<NonNullable<Head>> extends true
+        ? Exclude<Head, X>
+        : DeeperOmitTypes<NonNullable<Head>, X>,
+      ...DeeperOmitTypesTuple<Rest, X>,
+    ]
+  : [];

package/lib/partial.d.ts CHANGED Viewed

@@ -34,12 +34,20 @@ export type DeepPartial<T> = {
 export type DeeperPartial<T> = {
   [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>[]
+  > extends true // Deep process tuples positionally
+    ? DeeperPartialTuple<NonNullable<T[K]>>
+    : NonNullable<
+          // Deep process arrays
+          T[K]
+        > extends readonly (infer U)[]
+      ? NonNullable<T[K]> extends any[]
+        ? // was mutable - DeeperPartial doesn't touch mutability
+          null extends T[K]
+          ? DeeperPartial<U>[] | null
+          : DeeperPartial<U>[]
+        : null extends T[K] // was readonly - preserve that
+          ? readonly DeeperPartial<U>[] | null
+          : readonly DeeperPartial<U>[]
       : // Do not deep process No-Deep values
         IfNoDeepValue<Exclude<T[K], undefined>> extends true
         ? T[K]
@@ -47,6 +55,15 @@ export type DeeperPartial<T> = {
           DeeperPartial<Exclude<T[K], undefined>>;
 };
+type DeeperPartialTuple<T> = T extends readonly [infer Head, ...infer Rest]
+  ? [
+      IfNoDeepValue<NonNullable<Head>> extends true
+        ? Head
+        : DeeperPartial<NonNullable<Head>>,
+      ...DeeperPartialTuple<Rest>,
+    ]
+  : [];
 /**
  * OptionalKeys
  * @desc Returns optional keys of an object

package/lib/readonly.d.ts CHANGED Viewed

@@ -26,12 +26,12 @@ export type DeepReadonly<T> = {
 export type DeeperReadonly<T> = {
   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]
+  ]: IfTuple<NonNullable<T[K]>> extends true // Deep process tuples positionally
+    ? readonly [...DeeperReadonlyTuple<NonNullable<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>[]
+        ? readonly DeeperReadonly<U>[] | null // Always readonly - that is DeeperReadonly's whole purpose
+        : readonly DeeperReadonly<U>[]
       : // Do not deep process No-Deep values
         IfNoDeepValue<Exclude<T[K], undefined>> extends true
         ? T[K]
@@ -39,6 +39,15 @@ export type DeeperReadonly<T> = {
           DeeperReadonly<Exclude<T[K], undefined>>;
 };
+type DeeperReadonlyTuple<T> = T extends readonly [infer Head, ...infer Rest]
+  ? [
+      IfNoDeepValue<NonNullable<Head>> extends true
+        ? Head
+        : DeeperReadonly<NonNullable<Head>>,
+      ...DeeperReadonlyTuple<Rest>,
+    ]
+  : [];
 /**
  * Returns readonly keys of an object
  */
@@ -127,12 +136,17 @@ export type DeeperPickReadonly<T> = {
     > extends true
       ? never
       : K
-  ]: IfTuple<NonNullable<T[K]>> extends true // Leave fixed-length tuples untouched
-    ? T[K]
+  ]: IfTuple<NonNullable<T[K]>> extends true // Deep process tuples positionally
+    ? DeeperPickReadonlyTuple<NonNullable<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>[]
+      ? NonNullable<T[K]> extends any[]
+        ? // was mutable - DeeperPickReadonly doesn't touch mutability, unlike DeeperReadonly
+          null extends T[K]
+          ? DeeperPickReadonly<U>[] | null
+          : DeeperPickReadonly<U>[]
+        : null extends T[K] // was readonly - preserve that
+          ? readonly DeeperPickReadonly<U>[] | null
+          : readonly DeeperPickReadonly<U>[]
       : // Do not deep process No-Deep values
         IfNoDeepValue<Exclude<T[K], undefined>> extends true
         ? T[K]
@@ -140,6 +154,15 @@ export type DeeperPickReadonly<T> = {
           DeeperPickReadonly<Exclude<T[K], undefined>>;
 };
+type DeeperPickReadonlyTuple<T> = T extends readonly [infer Head, ...infer Rest]
+  ? [
+      IfNoDeepValue<NonNullable<Head>> extends true
+        ? Head
+        : DeeperPickReadonly<NonNullable<Head>>,
+      ...DeeperPickReadonlyTuple<Rest>,
+    ]
+  : [];
 /**
  * Pick all readonly properties in T deeply including arrays
  */
@@ -153,15 +176,29 @@ export type DeeperOmitReadonly<T> = {
     > extends true
       ? never
       : K
-  ]: IfTuple<NonNullable<T[K]>> extends true // Leave fixed-length tuples untouched
-    ? T[K]
+  ]: IfTuple<NonNullable<T[K]>> extends true // Deep process tuples positionally
+    ? DeeperOmitReadonlyTuple<NonNullable<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>[]
+      ? NonNullable<T[K]> extends any[]
+        ? // was mutable - DeeperOmitReadonly doesn't touch mutability, unlike DeeperReadonly
+          null extends T[K]
+          ? DeeperOmitReadonly<U>[] | null
+          : DeeperOmitReadonly<U>[]
+        : null extends T[K] // was readonly - preserve that
+          ? readonly DeeperOmitReadonly<U>[] | null
+          : readonly 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>>;
 };
+type DeeperOmitReadonlyTuple<T> = T extends readonly [infer Head, ...infer Rest]
+  ? [
+      IfNoDeepValue<NonNullable<Head>> extends true
+        ? Head
+        : DeeperOmitReadonly<NonNullable<Head>>,
+      ...DeeperOmitReadonlyTuple<Rest>,
+    ]
+  : [];

package/lib/required.d.ts CHANGED Viewed

@@ -26,12 +26,17 @@ export type DeepRequired<T> = {
 export type DeeperRequired<T> = {
   [K in keyof T as IfNever<Exclude<T[K], undefined>, never, K>]-?: IfTuple<
     NonNullable<T[K]>
-  > extends true // Leave fixed-length tuples untouched
-    ? Exclude<T[K], undefined>
+  > extends true // Deep process tuples positionally
+    ? DeeperRequiredTuple<NonNullable<T[K]>>
     : NonNullable<T[K]> extends readonly (infer U)[] // Deep process arrays
-      ? null extends T[K] // Preserve a `| null` member lost by NonNullable above
-        ? DeeperRequired<U>[] | null
-        : DeeperRequired<U>[]
+      ? NonNullable<T[K]> extends any[]
+        ? // was mutable - DeeperRequired doesn't touch mutability
+          null extends T[K]
+          ? DeeperRequired<U>[] | null
+          : DeeperRequired<U>[]
+        : null extends T[K] // was readonly - preserve that
+          ? readonly DeeperRequired<U>[] | null
+          : readonly DeeperRequired<U>[]
       : // Do not deep process No-Deep values
         IfNoDeepValue<Exclude<T[K], undefined>> extends true
         ? Exclude<T[K], undefined>
@@ -39,6 +44,15 @@ export type DeeperRequired<T> = {
           DeeperRequired<Exclude<T[K], undefined>>;
 };
+type DeeperRequiredTuple<T> = T extends readonly [infer Head, ...infer Rest]
+  ? [
+      IfNoDeepValue<NonNullable<Head>> extends true
+        ? Exclude<Head, undefined>
+        : DeeperRequired<NonNullable<Head>>,
+      ...DeeperRequiredTuple<Rest>,
+    ]
+  : [];
 /**
  * RequiredKeys
  * @desc Returns required keys of an object
@@ -128,12 +142,17 @@ export type DeeperPickRequired<T> = {
     > extends true
       ? never
       : K
-  ]: IfTuple<NonNullable<T[K]>> extends true // Leave fixed-length tuples untouched
-    ? T[K]
+  ]: IfTuple<NonNullable<T[K]>> extends true // Deep process tuples positionally
+    ? DeeperPickRequiredTuple<NonNullable<T[K]>>
     : NonNullable<T[K]> extends readonly (infer U)[] // Deep process arrays
-      ? null extends T[K] // Preserve a `| null` member lost by NonNullable above
-        ? DeeperPickRequired<U>[] | null
-        : DeeperPickRequired<U>[]
+      ? NonNullable<T[K]> extends any[]
+        ? // was mutable - DeeperPickRequired doesn't touch mutability
+          null extends T[K]
+          ? DeeperPickRequired<U>[] | null
+          : DeeperPickRequired<U>[]
+        : null extends T[K] // was readonly - preserve that
+          ? readonly DeeperPickRequired<U>[] | null
+          : readonly DeeperPickRequired<U>[]
       : // Do not deep process No-Deep values
         IfNoDeepValue<Exclude<T[K], undefined>> extends true
         ? T[K]
@@ -141,6 +160,15 @@ export type DeeperPickRequired<T> = {
           DeeperPickRequired<Exclude<T[K], undefined>>;
 };
+type DeeperPickRequiredTuple<T> = T extends readonly [infer Head, ...infer Rest]
+  ? [
+      IfNoDeepValue<NonNullable<Head>> extends true
+        ? Head
+        : DeeperPickRequired<NonNullable<Head>>,
+      ...DeeperPickRequiredTuple<Rest>,
+    ]
+  : [];
 /**
  * Omit all required properties in T deeply including arrays
  */
@@ -154,15 +182,29 @@ export type DeeperOmitRequired<T> = {
     > extends true
       ? never
       : K
-  ]: IfTuple<NonNullable<T[K]>> extends true // Leave fixed-length tuples untouched
-    ? T[K]
+  ]: IfTuple<NonNullable<T[K]>> extends true // Deep process tuples positionally
+    ? DeeperOmitRequiredTuple<NonNullable<T[K]>>
     : NonNullable<T[K]> extends readonly (infer U)[] // Deep process arrays
-      ? null extends T[K] // Preserve a `| null` member lost by NonNullable above
-        ? DeeperOmitRequired<U>[] | null
-        : DeeperOmitRequired<U>[]
+      ? NonNullable<T[K]> extends any[]
+        ? // was mutable - DeeperOmitRequired doesn't touch mutability
+          null extends T[K]
+          ? DeeperOmitRequired<U>[] | null
+          : DeeperOmitRequired<U>[]
+        : null extends T[K] // was readonly - preserve that
+          ? readonly DeeperOmitRequired<U>[] | null
+          : readonly DeeperOmitRequired<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)
           DeeperOmitRequired<Exclude<T[K], undefined>>;
 };
+type DeeperOmitRequiredTuple<T> = T extends readonly [infer Head, ...infer Rest]
+  ? [
+      IfNoDeepValue<NonNullable<Head>> extends true
+        ? Head
+        : DeeperOmitRequired<NonNullable<Head>>,
+      ...DeeperOmitRequiredTuple<Rest>,
+    ]
+  : [];

package/lib/type-check.d.ts CHANGED Viewed

@@ -57,6 +57,7 @@ export type IfTuple<T, Y = true, N = false> =
           ? N
           : Y
         : N;
 export type IfTupleOrAny<T, Y = true, N = false> =
   IfAny<T> extends true ? Y : IfTuple<T, Y, N>;
@@ -127,14 +128,6 @@ export type IfClassOrAny<T, Y = true, N = false> =
 /**
  * Returns "Y" if "T1" is exactly same with "T2", "N" otherwise
- *
- * The `IfObject<T1> | IfObject<T2>` check below looks like it should be
- * `Or<IfObject<T1>, IfObject<T2>>` (this file's usual pattern), but it is
- * not a bug: it deliberately only takes the EqualsWrapped/object-safe path
- * when BOTH sides are objects. Wrapping a non-object side (e.g. `string`)
- * in `EqualsWrapped` maps over its own keys instead of comparing it as
- * itself, which gives wrong answers - switching this to `Or` breaks
- * multiple cases in test/type-check.spec.ts's `IfEquals` suite.
  */
 export type IfEquals<T1, T2, Y = true, N = false> =
   IfObject<T1> | IfObject<T2> extends true

package/package.json CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "name": "ts-gems",
   "description": "Valuable typing extensions for TypeScript",
-  "version": "4.0.2",
+  "version": "4.0.4",
   "license": "MIT",
   "type": "module",
   "module": "./lib/index.js",