ts-gems 4.0.0 → 4.0.2

package/docs/api/omit.md

@@ -9,10 +9,11 @@ convention](../api.md#the-deep--deeper-convention) for `DeepOmitTypes`/
 
 ## `StrictOmit<T, X>`
 
-Like the built-in `Omit<T, K>`, but also drops any remaining key whose value
-type is `never` (after stripping `undefined`) — symmetric with
-[`StrictPick`](pick.md#strictpickt-x), so picking and omitting the same key
-set never disagree about `never`-typed properties.
+Like the built-in `Omit<T, K>`, but `X` is constrained to `keyof T`, so a
+typo in the key you're omitting is a compile error instead of a silent
+no-op. Unlike [`StrictPick`](pick.md#strictpickt-x), it does **not** also
+drop `never`-typed keys — only the key(s) named in `X` are removed, by
+identity, regardless of their value type.
 
 ```ts
 import type { StrictOmit } from 'ts-gems';
@@ -24,7 +25,7 @@ interface Row {
 }
 
 type Result = StrictOmit<Row, 'b'>;
-// { a?: number } - `c` is dropped too, it's `never`
+// { a?: number; c: never } - only `b` is removed
 ```
 
 ## `OmitFunctions<T>`

package/docs/api/pick.md

@@ -7,9 +7,11 @@ See [Omit](omit.md) for the inverse operations.
 
 ## `StrictPick<T, X>`
 
-Like the built-in `Pick<T, K>`, but also drops any selected key whose value
-type is `never` (after stripping `undefined`) — consistent with how the rest
-of the library treats `never`-typed properties as "absent".
+Like the built-in `Pick<T, K>`, but `X` is constrained to `keyof T`, so a
+typo in the key you're picking is a compile error instead of silently
+producing `never`. It only selects by key identity — it does **not** also
+drop `never`-typed keys, so it stays correct when `T` is still an open
+generic type parameter (e.g. used inside another generic function).
 
 ```ts
 import type { StrictPick } from 'ts-gems';
@@ -21,7 +23,7 @@ interface Row {
 }
 
 type Result = StrictPick<Row, 'a' | 'c'>;
-// { a?: number } - `c` is dropped, it's `never`
+// { a?: number; c: never } - both named keys are kept
 ```
 
 ## `PickFunctions<T>`

package/docs/api.md

@@ -1,10 +1,10 @@
 <!--
 docs-baseline
-git-commit: bfe8777ee92aea1e8cacecfa8f68e297d4235c19
-package-version: 4.0.0
+git-commit: 27bbe999f45fa24fe4e1d7d32d5639defa285bdc
+package-version: 4.0.1
 date: 2026-09-09
 verified-against: lib/
-diff-command: git diff bfe8777ee92aea1e8cacecfa8f68e297d4235c19..HEAD -- lib/
+diff-command: git diff 27bbe999f45fa24fe4e1d7d32d5639defa285bdc..HEAD -- lib/
 -->
 
 <p align="center">
@@ -98,6 +98,19 @@ type ReadonlyConfig = DeeperReadonly<Config>;
 // }
 ```
 
+A **nullable** object or array property (`SomeObject | null`) still gets
+recursed into — `null` is a leaf on its own, but it is preserved as a
+separate union member alongside the transformed object/array, not lost:
+
+```ts
+type Config = {
+  server: { host: string } | null;
+};
+
+type ReadonlyConfig = DeeperReadonly<Config>;
+// { readonly server: { readonly host: string } | null }
+```
+
 ## Naming patterns used across pages
 
 - **`Pick*` / `Omit*`** — select or remove properties matching some criterion

package/lib/mutable.d.ts

@@ -30,8 +30,8 @@ export type DeepMutable<T> = {
     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
-      DeepMutable<NonNullable<T[K]>>;
+    : // Deep process objects (Exclude, not NonNullable - preserves a `| null` member)
+      DeepMutable<Exclude<T[K], undefined>>;
 };
 
 /**
@@ -43,12 +43,14 @@ export type DeeperMutable<T> = {
   ]: IfTuple<NonNullable<T[K]>> extends true // Leave fixed-length tuples untouched
     ? T[K]
     : NonNullable<T[K]> extends readonly (infer U)[] // Deep process arrays
-      ? DeeperMutable<U>[]
+      ? null extends T[K] // Preserve a `| null` member lost by NonNullable above
+        ? DeeperMutable<U>[] | null
+        : DeeperMutable<U>[]
       : // Do not deep process No-Deep values
-        IfNoDeepValue<NonNullable<T[K]>> extends true
+        IfNoDeepValue<Exclude<T[K], undefined>> extends true
         ? T[K]
-        : // Deep process objects
-          DeeperMutable<NonNullable<T[K]>>;
+        : // Deep process objects (Exclude, not NonNullable - preserves a `| null` member)
+          DeeperMutable<Exclude<T[K], undefined>>;
 };
 
 /**

package/lib/omit-never.d.ts

@@ -30,11 +30,11 @@ 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>>;
 };
 
 /**
@@ -49,10 +49,12 @@ export type DeeperOmitNever<T> = {
           // Deep process arrays
           T[K]
         > extends readonly (infer U)[]
-      ? DeeperOmitNever<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<NonNullable<T[K]>> extends true
+        IfNoDeepValue<Exclude<T[K], undefined>> extends true
         ? T[K]
-        : // Deep process objects
-          DeeperOmitNever<NonNullable<T[K]>>;
+        : // Deep process objects (Exclude, not NonNullable - preserves a `| null` member)
+          DeeperOmitNever<Exclude<T[K], undefined>>;
 };

package/lib/omit-undefined.d.ts

@@ -30,10 +30,12 @@ export type DeeperOmitUndefined<T> = {
   > extends true // Leave fixed-length tuples untouched
     ? T[K]
     : NonNullable<T[K]> extends readonly (infer U)[] // Deep process arrays
-      ? DeeperOmitUndefined<U>[]
+      ? 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<NonNullable<T[K]>> extends true
+        IfNoDeepValue<Exclude<T[K], undefined>> extends true
         ? T[K]
-        : // Deep process objects
-          DeeperOmitUndefined<NonNullable<T[K]>>;
+        : // Deep process objects (Exclude, not NonNullable - preserves a `| null` member)
+          DeeperOmitUndefined<Exclude<T[K], undefined>>;
 };

package/lib/omit.d.ts

@@ -7,16 +7,7 @@ import { IfFunction, IfNever, IfTuple } from './type-check.js';
  * while preserving strict type checking.
  */
 export type StrictOmit<T, X extends keyof T> = {
-  [
-    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];
+  [K in keyof T as K extends X ? never : K]: T[K];
 };
 
 /**
@@ -53,8 +44,8 @@ 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
     ? 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>;
 };
 
 /**
@@ -69,9 +60,11 @@ export type DeeperOmitTypes<T, X> = {
           // Deep process arrays // Do not deep process No-Deep values
           T[K]
         > extends readonly (infer U)[]
-      ? DeeperOmitTypes<U, X>[]
-      : IfNoDeepValue<NonNullable<T[K]>> extends true
+      ? 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
-          DeeperOmitTypes<NonNullable<T[K]>, X>;
+        : // Deep process objects (Exclude, not NonNullable - preserves a `| null` member)
+          DeeperOmitTypes<Exclude<T[K], undefined>, X>;
 };

package/lib/partial.d.ts

@@ -24,8 +24,8 @@ 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>>;
 };
 
 /**
@@ -37,12 +37,14 @@ export type DeeperPartial<T> = {
   > extends true // Leave fixed-length tuples untouched
     ? T[K]
     : NonNullable<T[K]> extends readonly (infer U)[] // Deep process arrays
-      ? DeeperPartial<U>[]
+      ? 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<NonNullable<T[K]>> extends true
+        IfNoDeepValue<Exclude<T[K], undefined>> extends true
         ? T[K]
-        : // Deep process objects
-          DeeperPartial<NonNullable<T[K]>>;
+        : // Deep process objects (Exclude, not NonNullable - preserves a `| null` member)
+          DeeperPartial<Exclude<T[K], undefined>>;
 };
 
 /**

package/lib/pick.d.ts

@@ -13,16 +13,7 @@ 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 K extends X ? K : never]: T[K];
 };
 
 /**

package/lib/readonly.d.ts

@@ -29,7 +29,9 @@ export type DeeperReadonly<T> = {
   ]: IfTuple<NonNullable<T[K]>> extends true // Leave fixed-length tuples untouched
     ? T[K]
     : NonNullable<T[K]> extends readonly (infer U)[] // Deep process arrays
-      ? DeeperReadonly<U>[]
+      ? 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]
@@ -87,10 +89,10 @@ export type DeepPickReadonly<T> = {
     > extends true
       ? never
       : K
-  ]: IfNoDeepValue<NonNullable<T[K]>> extends true // Do not deep process No-Deep values
+  ]: 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>>;
 };
 
 /**
@@ -106,10 +108,10 @@ export type DeepOmitReadonly<T> = {
     > extends true
       ? never
       : K
-  ]: IfNoDeepValue<NonNullable<T[K]>> extends true // Do not deep process No-Deep values
+  ]: 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>>;
 };
 
 /**
@@ -128,12 +130,14 @@ export type DeeperPickReadonly<T> = {
   ]: IfTuple<NonNullable<T[K]>> extends true // Leave fixed-length tuples untouched
     ? T[K]
     : NonNullable<T[K]> extends readonly (infer U)[] // Deep process arrays
-      ? DeeperPickReadonly<U>[]
+      ? 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<NonNullable<T[K]>> extends true
+        IfNoDeepValue<Exclude<T[K], undefined>> extends true
         ? T[K]
-        : // Deep process objects
-          DeeperPickReadonly<NonNullable<T[K]>>;
+        : // Deep process objects (Exclude, not NonNullable - preserves a `| null` member)
+          DeeperPickReadonly<Exclude<T[K], undefined>>;
 };
 
 /**
@@ -152,10 +156,12 @@ export type DeeperOmitReadonly<T> = {
   ]: IfTuple<NonNullable<T[K]>> extends true // Leave fixed-length tuples untouched
     ? T[K]
     : NonNullable<T[K]> extends readonly (infer U)[] // Deep process arrays
-      ? DeeperOmitReadonly<U>[]
+      ? 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<NonNullable<T[K]>> extends true
+        IfNoDeepValue<Exclude<T[K], undefined>> extends true
         ? T[K]
-        : // Deep process objects
-          DeeperOmitReadonly<NonNullable<T[K]>>;
+        : // Deep process objects (Exclude, not NonNullable - preserves a `| null` member)
+          DeeperOmitReadonly<Exclude<T[K], undefined>>;
 };

package/lib/required.d.ts

@@ -1,15 +1,11 @@
 import { IfNoDeepValue } from './helpers.js';
 import { Or } from './logical.js';
-import { OmitTypes } from './omit.js';
 import { IfEquals, IfNever, IfTuple } from './type-check.js';
 
 /**
  * Marks given keys as required
  */
-export type RequiredSome<T, K extends keyof T> = OmitTypes<
-  Required<Pick<T, K>>,
-  null
-> &
+export type RequiredSome<T, K extends keyof T> = Required<Pick<T, K>> &
   Omit<T, K>;
 
 /**
@@ -20,8 +16,8 @@ export type DeepRequired<T> = {
     K in keyof T as IfNever<Exclude<T[K], undefined>, never, K>
   ]-?: IfNoDeepValue<Exclude<T[K], undefined>> extends true // Do not deep process No-Deep values
     ? Exclude<T[K], undefined>
-    : // Deep process objects
-      DeepRequired<NonNullable<T[K]>>;
+    : // Deep process objects (Exclude, not NonNullable - preserves a `| null` member)
+      DeepRequired<Exclude<T[K], undefined>>;
 };
 
 /**
@@ -33,12 +29,14 @@ export type DeeperRequired<T> = {
   > extends true // Leave fixed-length tuples untouched
     ? Exclude<T[K], undefined>
     : NonNullable<T[K]> extends readonly (infer U)[] // Deep process arrays
-      ? DeeperRequired<U>[]
+      ? null extends T[K] // Preserve a `| null` member lost by NonNullable above
+        ? DeeperRequired<U>[] | null
+        : DeeperRequired<U>[]
       : // Do not deep process No-Deep values
-        IfNoDeepValue<NonNullable<T[K]>> extends true
+        IfNoDeepValue<Exclude<T[K], undefined>> extends true
         ? Exclude<T[K], undefined>
-        : // Deep process objects
-          DeeperRequired<NonNullable<T[K]>>;
+        : // Deep process objects (Exclude, not NonNullable - preserves a `| null` member)
+          DeeperRequired<Exclude<T[K], undefined>>;
 };
 
 /**
@@ -92,10 +90,10 @@ export type DeepPickRequired<T> = {
     > extends true
       ? never
       : K
-  ]: IfNoDeepValue<NonNullable<T[K]>> extends true // Do not deep process No-Deep values
+  ]: IfNoDeepValue<Exclude<T[K], undefined>> extends true // Do not deep process No-Deep values
     ? T[K]
-    : // Deep process objects
-      DeepPickRequired<NonNullable<T[K]>>;
+    : // Deep process objects (Exclude, not NonNullable - preserves a `| null` member)
+      DeepPickRequired<Exclude<T[K], undefined>>;
 };
 
 /**
@@ -111,10 +109,10 @@ export type DeepOmitRequired<T> = {
     > extends true
       ? never
       : K
-  ]?: IfNoDeepValue<NonNullable<T[K]>> extends true // Do not deep process No-Deep values
+  ]?: IfNoDeepValue<Exclude<T[K], undefined>> extends true // Do not deep process No-Deep values
     ? T[K]
-    : // Deep process objects
-      DeepOmitRequired<NonNullable<T[K]>>;
+    : // Deep process objects (Exclude, not NonNullable - preserves a `| null` member)
+      DeepOmitRequired<Exclude<T[K], undefined>>;
 };
 
 /**
@@ -133,12 +131,14 @@ export type DeeperPickRequired<T> = {
   ]: IfTuple<NonNullable<T[K]>> extends true // Leave fixed-length tuples untouched
     ? T[K]
     : NonNullable<T[K]> extends readonly (infer U)[] // Deep process arrays
-      ? DeeperPickRequired<U>[]
+      ? null extends T[K] // Preserve a `| null` member lost by NonNullable above
+        ? DeeperPickRequired<U>[] | null
+        : DeeperPickRequired<U>[]
       : // Do not deep process No-Deep values
-        IfNoDeepValue<NonNullable<T[K]>> extends true
+        IfNoDeepValue<Exclude<T[K], undefined>> extends true
         ? T[K]
-        : // Deep process objects
-          DeeperPickRequired<NonNullable<T[K]>>;
+        : // Deep process objects (Exclude, not NonNullable - preserves a `| null` member)
+          DeeperPickRequired<Exclude<T[K], undefined>>;
 };
 
 /**
@@ -157,10 +157,12 @@ export type DeeperOmitRequired<T> = {
   ]: IfTuple<NonNullable<T[K]>> extends true // Leave fixed-length tuples untouched
     ? T[K]
     : NonNullable<T[K]> extends readonly (infer U)[] // Deep process arrays
-      ? DeeperOmitRequired<U>[]
+      ? null extends T[K] // Preserve a `| null` member lost by NonNullable above
+        ? DeeperOmitRequired<U>[] | null
+        : DeeperOmitRequired<U>[]
       : // Do not deep process No-Deep values
-        IfNoDeepValue<NonNullable<T[K]>> extends true
+        IfNoDeepValue<Exclude<T[K], undefined>> extends true
         ? T[K]
-        : // Deep process objects
-          DeeperOmitRequired<NonNullable<T[K]>>;
+        : // Deep process objects (Exclude, not NonNullable - preserves a `| null` member)
+          DeeperOmitRequired<Exclude<T[K], undefined>>;
 };

package/lib/type-check.d.ts

@@ -127,6 +127,14 @@ 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

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