zod 3.21.2 → 3.21.3

package/README.md

@@ -2394,6 +2394,58 @@ z.string()
 
 The `.pipe()` method returns a `ZodPipeline` instance.
 
+#### You can use `.pipe()` to fix common issues with `z.coerce`.
+
+You can constrain the input to types that work well with your chosen coercion. Then use `.pipe()` to apply the coercion.
+
+without constrained input:
+```ts
+const toDate = z.coerce.date()
+
+// works intuitively
+console.log(toDate.safeParse('2023-01-01').success) // true
+
+// might not be what you want
+console.log(toDate.safeParse(null).success) // true
+```
+
+with constrained input:
+```ts
+const datelike = z.union([z.number(), z.string(), z.date()])
+const datelikeToDate = datelike.pipe(z.coerce.date())
+
+// still works intuitively
+console.log(datelikeToDate.safeParse('2023-01-01').success) // true
+
+// more likely what you want
+console.log(datelikeToDate.safeParse(null).success) // false
+```
+
+You can also use this technique to avoid coercions that throw uncaught errors.
+
+without constrained input:
+```ts
+const toBigInt = z.coerce.bigint()
+
+// works intuitively
+console.log( toBigInt.safeParse( '42' ) ) // true
+
+// probably not what you want
+console.log( toBigInt.safeParse( null ) ) // throws uncaught error
+```
+
+with constrained input:
+```ts
+const toNumber = z.number().or( z.string() ).pipe( z.coerce.number() )
+const toBigInt = z.bigint().or( toNumber ).pipe( z.coerce.bigint() )
+
+// still works intuitively
+console.log( toBigInt.safeParse( '42' ).success ) // true
+
+// error handled by zod, more likely what you want
+console.log( toBigInt.safeParse( null ).success ) // false
+```
+
 ## Guides and concepts
 
 ### Type inference

package/lib/index.mjs

@@ -3463,10 +3463,6 @@ class ZodEffects extends ZodType {
                     path: ctx.path,
                     parent: ctx,
                 });
-                // if (base.status === "aborted") return INVALID;
-                // if (base.status === "dirty") {
-                //   return { status: "dirty", value: base.value };
-                // }
                 if (!isValid(base))
                     return base;
                 const result = effect.transform(base.value, checkCtx);
@@ -3481,10 +3477,6 @@ class ZodEffects extends ZodType {
                     .then((base) => {
                     if (!isValid(base))
                         return base;
-                    // if (base.status === "aborted") return INVALID;
-                    // if (base.status === "dirty") {
-                    //   return { status: "dirty", value: base.value };
-                    // }
                     return Promise.resolve(effect.transform(base.value, checkCtx)).then((result) => ({ status: status.value, value: result }));
                 });
             }

package/lib/index.umd.js

@@ -3469,10 +3469,6 @@
                         path: ctx.path,
                         parent: ctx,
                     });
-                    // if (base.status === "aborted") return INVALID;
-                    // if (base.status === "dirty") {
-                    //   return { status: "dirty", value: base.value };
-                    // }
                     if (!isValid(base))
                         return base;
                     const result = effect.transform(base.value, checkCtx);
@@ -3487,10 +3483,6 @@
                         .then((base) => {
                         if (!isValid(base))
                             return base;
-                        // if (base.status === "aborted") return INVALID;
-                        // if (base.status === "dirty") {
-                        //   return { status: "dirty", value: base.value };
-                        // }
                         return Promise.resolve(effect.transform(base.value, checkCtx)).then((result) => ({ status: status.value, value: result }));
                     });
                 }

package/lib/types.d.ts

@@ -477,9 +477,6 @@ export declare type PassthroughType<T extends UnknownKeysParam> = T extends "pas
 } : unknown;
 export declare type deoptional<T extends ZodTypeAny> = T extends ZodOptional<infer U> ? deoptional<U> : T extends ZodNullable<infer U> ? ZodNullable<deoptional<U>> : T;
 export declare type SomeZodObject = ZodObject<ZodRawShape, UnknownKeysParam, ZodTypeAny>;
-export declare type objectKeyMask<Obj> = {
-    [k in keyof Obj]?: true;
-};
 export declare type noUnrecognized<Obj extends object, Shape extends object> = {
     [k in keyof Obj]: k extends keyof Shape ? Obj[k] : never;
 };
@@ -502,19 +499,27 @@ export declare class ZodObject<T extends ZodRawShape, UnknownKeys extends Unknow
         [k in Key]: Schema;
     }, UnknownKeys, Catchall>;
     catchall<Index extends ZodTypeAny>(index: Index): ZodObject<T, UnknownKeys, Index>;
-    pick<Mask extends objectKeyMask<T>>(mask: noUnrecognized<Mask, T>): ZodObject<Pick<T, Extract<keyof T, keyof Mask>>, UnknownKeys, Catchall>;
-    omit<Mask extends objectKeyMask<T>>(mask: noUnrecognized<Mask, objectKeyMask<T>>): ZodObject<Omit<T, keyof Mask>, UnknownKeys, Catchall>;
+    pick<Mask extends {
+        [k in keyof T]?: true;
+    }>(mask: Mask): ZodObject<Pick<T, Extract<keyof T, keyof Mask>>, UnknownKeys, Catchall>;
+    omit<Mask extends {
+        [k in keyof T]?: true;
+    }>(mask: Mask): ZodObject<Omit<T, keyof Mask>, UnknownKeys, Catchall>;
     deepPartial(): partialUtil.DeepPartial<this>;
     partial(): ZodObject<{
         [k in keyof T]: ZodOptional<T[k]>;
     }, UnknownKeys, Catchall>;
-    partial<Mask extends objectKeyMask<T>>(mask: noUnrecognized<Mask, objectKeyMask<T>>): ZodObject<objectUtil.noNever<{
+    partial<Mask extends {
+        [k in keyof T]?: true;
+    }>(mask: Mask): ZodObject<objectUtil.noNever<{
         [k in keyof T]: k extends keyof Mask ? ZodOptional<T[k]> : T[k];
     }>, UnknownKeys, Catchall>;
     required(): ZodObject<{
         [k in keyof T]: deoptional<T[k]>;
     }, UnknownKeys, Catchall>;
-    required<Mask extends objectKeyMask<T>>(mask: noUnrecognized<Mask, objectKeyMask<T>>): ZodObject<objectUtil.noNever<{
+    required<Mask extends {
+        [k in keyof T]?: true;
+    }>(mask: Mask): ZodObject<objectUtil.noNever<{
         [k in keyof T]: k extends keyof Mask ? deoptional<T[k]> : T[k];
     }>, UnknownKeys, Catchall>;
     keyof(): ZodEnum<enumUtil.UnionToTupleString<keyof T>>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zod",
-  "version": "3.21.2",
+  "version": "3.21.3",
   "author": "Colin McDonnell <colin@colinhacks.com>",
   "repository": {
     "type": "git",