zod 3.16.1 → 3.17.3

package/README.md

@@ -47,6 +47,8 @@
   - [Sponsors](#sponsors)
   - [Ecosystem](#ecosystem)
 - [Installation](#installation)
+  - [Node](#node)
+  - [Deno](#deno)
 - [Basic usage](#basic-usage)
 - [Primitives](#primitives)
 - [Literals](#literals)
@@ -288,30 +290,47 @@ There are a growing number of tools that are built atop or support Zod natively!
 
 ## Installation
 
+### Requirements
+
+- TypeScript 4.1+!
+- You must enable `strict` mode in your `tsconfig.json`. This is a best practice for all TypeScript projects.
+
+  ```ts
+  // tsconfig.json
+  {
+    // ...
+    "compilerOptions": {
+      // ...
+      "strict": true
+    }
+  }
+  ```
+
+### Node/NPM
+
 To install Zod v3:
 
 ```sh
-npm install zod
+npm install zod       # npm
+yarn add zod          # yarn
+pnpm add zod          # pnpm
 ```
 
-⚠️ IMPORTANT: You must enable `strict` mode in your `tsconfig.json`. This is a best practice for all TypeScript projects.
+### Deno
+
+Unlike Node, Deno relies on direct URL imports instead of a package manager like NPM. Zod is available on [deno.land/x](deno.land/x). The latest version can be imported like so:
 
 ```ts
-// tsconfig.json
-{
-  // ...
-  "compilerOptions": {
-    // ...
-    "strict": true
-  }
-}
+import { z } from "https://deno.land/x/zod/mod.ts";
+```
+
+You can also specify a particular version:
+
+```ts
+import { z } from from "https://deno.land/x/zod@v3.16.1/mod.ts"
 ```
 
-> **TypeScript requirements**
->
-> - Zod 3.x requires TypeScript 4.1+
-> - Zod 2.x requires TypeScript 3.7+
-> - Zod 1.x requires TypeScript 3.3+
+> The rest of this README assumes you are using NPM and importing directly from the `"zod"` package.
 
 ## Basic usage
 
@@ -402,6 +421,9 @@ z.string().uuid();
 z.string().cuid();
 z.string().regex(regex);
 
+// trim whitespace
+z.string().trim();
+
 // deprecated, equivalent to .min(1)
 z.string().nonempty();
 

package/lib/ZodError.d.ts

@@ -1,7 +1,6 @@
 import type { TypeOf, ZodType } from ".";
-import { ZodParsedType } from "./helpers/parseUtil";
 import { Primitive } from "./helpers/typeAliases";
-import { util } from "./helpers/util";
+import { util, ZodParsedType } from "./helpers/util";
 declare type allKeys<T> = T extends any ? keyof T : never;
 export declare type inferFlattenedErrors<T extends ZodType<any, any, any>, U = string> = typeToFlattenedError<TypeOf<T>, U>;
 export declare type typeToFlattenedError<T, U = string> = {

package/lib/ZodError.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.setErrorMap = exports.overrideErrorMap = exports.defaultErrorMap = exports.ZodError = exports.quotelessJson = exports.ZodIssueCode = void 0;
-const parseUtil_1 = require("./helpers/parseUtil");
 const util_1 = require("./helpers/util");
 exports.ZodIssueCode = util_1.util.arrayToEnum([
     "invalid_type",
@@ -134,7 +133,7 @@ const defaultErrorMap = (issue, _ctx) => {
     let message;
     switch (issue.code) {
         case exports.ZodIssueCode.invalid_type:
-            if (issue.received === parseUtil_1.ZodParsedType.undefined) {
+            if (issue.received === util_1.ZodParsedType.undefined) {
                 message = "Required";
             }
             else {

package/lib/external.d.ts

@@ -1,4 +1,5 @@
 export * from "./helpers/parseUtil";
 export * from "./helpers/typeAliases";
+export { getParsedType, ZodParsedType } from "./helpers/util";
 export * from "./types";
 export * from "./ZodError";

package/lib/external.js

@@ -1,11 +1,7 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -14,7 +10,11 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZodParsedType = exports.getParsedType = void 0;
 __exportStar(require("./helpers/parseUtil"), exports);
 __exportStar(require("./helpers/typeAliases"), exports);
+var util_1 = require("./helpers/util");
+Object.defineProperty(exports, "getParsedType", { enumerable: true, get: function () { return util_1.getParsedType; } });
+Object.defineProperty(exports, "ZodParsedType", { enumerable: true, get: function () { return util_1.ZodParsedType; } });
 __exportStar(require("./types"), exports);
 __exportStar(require("./ZodError"), exports);

package/lib/helpers/errorUtil.d.ts

@@ -2,8 +2,12 @@ export declare namespace errorUtil {
     type ErrMessage = string | {
         message?: string;
     };
-    const errToObj: (message?: ErrMessage | undefined) => {
+    const errToObj: (message?: string | {
+        message?: string | undefined;
+    } | undefined) => {
         message?: string | undefined;
     };
-    const toString: (message?: ErrMessage | undefined) => string | undefined;
+    const toString: (message?: string | {
+        message?: string | undefined;
+    } | undefined) => string | undefined;
 }

package/lib/helpers/parseUtil.d.ts

@@ -1,28 +1,5 @@
-import { IssueData, ZodErrorMap, ZodIssue } from "../ZodError";
-export declare const ZodParsedType: {
-    function: "function";
-    number: "number";
-    string: "string";
-    nan: "nan";
-    integer: "integer";
-    float: "float";
-    boolean: "boolean";
-    date: "date";
-    bigint: "bigint";
-    symbol: "symbol";
-    undefined: "undefined";
-    null: "null";
-    array: "array";
-    object: "object";
-    unknown: "unknown";
-    promise: "promise";
-    void: "void";
-    never: "never";
-    map: "map";
-    set: "set";
-};
-export declare type ZodParsedType = keyof typeof ZodParsedType;
-export declare const getParsedType: (data: any) => ZodParsedType;
+import type { IssueData, ZodErrorMap, ZodIssue } from "../ZodError";
+import type { ZodParsedType } from "./util";
 export declare const makeIssue: (params: {
     data: any;
     path: (string | number)[];

package/lib/helpers/parseUtil.js

@@ -1,73 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isAsync = exports.isValid = exports.isDirty = exports.isAborted = exports.OK = exports.DIRTY = exports.INVALID = exports.ParseStatus = exports.addIssueToContext = exports.EMPTY_PATH = exports.makeIssue = exports.getParsedType = exports.ZodParsedType = void 0;
+exports.isAsync = exports.isValid = exports.isDirty = exports.isAborted = exports.OK = exports.DIRTY = exports.INVALID = exports.ParseStatus = exports.addIssueToContext = exports.EMPTY_PATH = exports.makeIssue = void 0;
 const ZodError_1 = require("../ZodError");
-const util_1 = require("./util");
-exports.ZodParsedType = util_1.util.arrayToEnum([
-    "string",
-    "nan",
-    "number",
-    "integer",
-    "float",
-    "boolean",
-    "date",
-    "bigint",
-    "symbol",
-    "function",
-    "undefined",
-    "null",
-    "array",
-    "object",
-    "unknown",
-    "promise",
-    "void",
-    "never",
-    "map",
-    "set",
-]);
-const getParsedType = (data) => {
-    const t = typeof data;
-    switch (t) {
-        case "undefined":
-            return exports.ZodParsedType.undefined;
-        case "string":
-            return exports.ZodParsedType.string;
-        case "number":
-            return isNaN(data) ? exports.ZodParsedType.nan : exports.ZodParsedType.number;
-        case "boolean":
-            return exports.ZodParsedType.boolean;
-        case "function":
-            return exports.ZodParsedType.function;
-        case "bigint":
-            return exports.ZodParsedType.bigint;
-        case "object":
-            if (Array.isArray(data)) {
-                return exports.ZodParsedType.array;
-            }
-            if (data === null) {
-                return exports.ZodParsedType.null;
-            }
-            if (data.then &&
-                typeof data.then === "function" &&
-                data.catch &&
-                typeof data.catch === "function") {
-                return exports.ZodParsedType.promise;
-            }
-            if (typeof Map !== "undefined" && data instanceof Map) {
-                return exports.ZodParsedType.map;
-            }
-            if (typeof Set !== "undefined" && data instanceof Set) {
-                return exports.ZodParsedType.set;
-            }
-            if (typeof Date !== "undefined" && data instanceof Date) {
-                return exports.ZodParsedType.date;
-            }
-            return exports.ZodParsedType.object;
-        default:
-            return exports.ZodParsedType.unknown;
-    }
-};
-exports.getParsedType = getParsedType;
 const makeIssue = (params) => {
     const { data, path, errorMaps, issueData } = params;
     const fullPath = [...path, ...(issueData.path || [])];
@@ -92,7 +26,7 @@ const makeIssue = (params) => {
 exports.makeIssue = makeIssue;
 exports.EMPTY_PATH = [];
 function addIssueToContext(ctx, issueData) {
-    const issue = (0, exports.makeIssue)({
+    const issue = exports.makeIssue({
         issueData: issueData,
         data: ctx.data,
         path: ctx.path,
@@ -100,7 +34,7 @@ function addIssueToContext(ctx, issueData) {
             ctx.common.contextualErrorMap,
             ctx.schemaErrorMap,
             ZodError_1.overrideErrorMap,
-            ZodError_1.defaultErrorMap, // then global default map
+            ZodError_1.defaultErrorMap,
         ].filter((x) => !!x),
     });
     ctx.common.issues.push(issue);

package/lib/helpers/util.d.ts

@@ -17,3 +17,27 @@ export declare namespace util {
     const isInteger: NumberConstructor["isInteger"];
     function joinValues<T extends any[]>(array: T, separator?: string): string;
 }
+export declare const ZodParsedType: {
+    function: "function";
+    number: "number";
+    string: "string";
+    nan: "nan";
+    integer: "integer";
+    float: "float";
+    boolean: "boolean";
+    date: "date";
+    bigint: "bigint";
+    symbol: "symbol";
+    undefined: "undefined";
+    null: "null";
+    array: "array";
+    object: "object";
+    unknown: "unknown";
+    promise: "promise";
+    void: "void";
+    never: "never";
+    map: "map";
+    set: "set";
+};
+export declare type ZodParsedType = keyof typeof ZodParsedType;
+export declare const getParsedType: (data: any) => ZodParsedType;

package/lib/helpers/util.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.util = void 0;
+exports.getParsedType = exports.ZodParsedType = exports.util = void 0;
 var util;
 (function (util) {
     function assertNever(_x) {
@@ -55,3 +55,68 @@ var util;
     }
     util.joinValues = joinValues;
 })(util = exports.util || (exports.util = {}));
+exports.ZodParsedType = util.arrayToEnum([
+    "string",
+    "nan",
+    "number",
+    "integer",
+    "float",
+    "boolean",
+    "date",
+    "bigint",
+    "symbol",
+    "function",
+    "undefined",
+    "null",
+    "array",
+    "object",
+    "unknown",
+    "promise",
+    "void",
+    "never",
+    "map",
+    "set",
+]);
+const getParsedType = (data) => {
+    const t = typeof data;
+    switch (t) {
+        case "undefined":
+            return exports.ZodParsedType.undefined;
+        case "string":
+            return exports.ZodParsedType.string;
+        case "number":
+            return isNaN(data) ? exports.ZodParsedType.nan : exports.ZodParsedType.number;
+        case "boolean":
+            return exports.ZodParsedType.boolean;
+        case "function":
+            return exports.ZodParsedType.function;
+        case "bigint":
+            return exports.ZodParsedType.bigint;
+        case "object":
+            if (Array.isArray(data)) {
+                return exports.ZodParsedType.array;
+            }
+            if (data === null) {
+                return exports.ZodParsedType.null;
+            }
+            if (data.then &&
+                typeof data.then === "function" &&
+                data.catch &&
+                typeof data.catch === "function") {
+                return exports.ZodParsedType.promise;
+            }
+            if (typeof Map !== "undefined" && data instanceof Map) {
+                return exports.ZodParsedType.map;
+            }
+            if (typeof Set !== "undefined" && data instanceof Set) {
+                return exports.ZodParsedType.set;
+            }
+            if (typeof Date !== "undefined" && data instanceof Date) {
+                return exports.ZodParsedType.date;
+            }
+            return exports.ZodParsedType.object;
+        default:
+            return exports.ZodParsedType.unknown;
+    }
+};
+exports.getParsedType = getParsedType;

package/lib/index.js

@@ -1,11 +1,7 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];

package/lib/index.mjs

@@ -52,6 +52,70 @@ var util;
     }
     util.joinValues = joinValues;
 })(util || (util = {}));
+const ZodParsedType = util.arrayToEnum([
+    "string",
+    "nan",
+    "number",
+    "integer",
+    "float",
+    "boolean",
+    "date",
+    "bigint",
+    "symbol",
+    "function",
+    "undefined",
+    "null",
+    "array",
+    "object",
+    "unknown",
+    "promise",
+    "void",
+    "never",
+    "map",
+    "set",
+]);
+const getParsedType = (data) => {
+    const t = typeof data;
+    switch (t) {
+        case "undefined":
+            return ZodParsedType.undefined;
+        case "string":
+            return ZodParsedType.string;
+        case "number":
+            return isNaN(data) ? ZodParsedType.nan : ZodParsedType.number;
+        case "boolean":
+            return ZodParsedType.boolean;
+        case "function":
+            return ZodParsedType.function;
+        case "bigint":
+            return ZodParsedType.bigint;
+        case "object":
+            if (Array.isArray(data)) {
+                return ZodParsedType.array;
+            }
+            if (data === null) {
+                return ZodParsedType.null;
+            }
+            if (data.then &&
+                typeof data.then === "function" &&
+                data.catch &&
+                typeof data.catch === "function") {
+                return ZodParsedType.promise;
+            }
+            if (typeof Map !== "undefined" && data instanceof Map) {
+                return ZodParsedType.map;
+            }
+            if (typeof Set !== "undefined" && data instanceof Set) {
+                return ZodParsedType.set;
+            }
+            if (typeof Date !== "undefined" && data instanceof Date) {
+                return ZodParsedType.date;
+            }
+            return ZodParsedType.object;
+        default:
+            return ZodParsedType.unknown;
+    }
+};
 
 const ZodIssueCode = util.arrayToEnum([
     "invalid_type",
@@ -259,70 +323,6 @@ const setErrorMap = (map) => {
     overrideErrorMap = map;
 };
 
-const ZodParsedType = util.arrayToEnum([
-    "string",
-    "nan",
-    "number",
-    "integer",
-    "float",
-    "boolean",
-    "date",
-    "bigint",
-    "symbol",
-    "function",
-    "undefined",
-    "null",
-    "array",
-    "object",
-    "unknown",
-    "promise",
-    "void",
-    "never",
-    "map",
-    "set",
-]);
-const getParsedType = (data) => {
-    const t = typeof data;
-    switch (t) {
-        case "undefined":
-            return ZodParsedType.undefined;
-        case "string":
-            return ZodParsedType.string;
-        case "number":
-            return isNaN(data) ? ZodParsedType.nan : ZodParsedType.number;
-        case "boolean":
-            return ZodParsedType.boolean;
-        case "function":
-            return ZodParsedType.function;
-        case "bigint":
-            return ZodParsedType.bigint;
-        case "object":
-            if (Array.isArray(data)) {
-                return ZodParsedType.array;
-            }
-            if (data === null) {
-                return ZodParsedType.null;
-            }
-            if (data.then &&
-                typeof data.then === "function" &&
-                data.catch &&
-                typeof data.catch === "function") {
-                return ZodParsedType.promise;
-            }
-            if (typeof Map !== "undefined" && data instanceof Map) {
-                return ZodParsedType.map;
-            }
-            if (typeof Set !== "undefined" && data instanceof Set) {
-                return ZodParsedType.set;
-            }
-            if (typeof Date !== "undefined" && data instanceof Date) {
-                return ZodParsedType.date;
-            }
-            return ZodParsedType.object;
-        default:
-            return ZodParsedType.unknown;
-    }
-};
 const makeIssue = (params) => {
     const { data, path, errorMaps, issueData } = params;
     const fullPath = [...path, ...(issueData.path || [])];
@@ -354,7 +354,7 @@ function addIssueToContext(ctx, issueData) {
             ctx.common.contextualErrorMap,
             ctx.schemaErrorMap,
             overrideErrorMap,
-            defaultErrorMap, // then global default map
+            defaultErrorMap,
         ].filter((x) => !!x),
     });
     ctx.common.issues.push(issue);
@@ -713,6 +713,10 @@ class ZodString extends ZodType {
          * @see {@link ZodString.min}
          */
         this.nonempty = (message) => this.min(1, errorUtil.errToObj(message));
+        this.trim = () => new ZodString({
+            ...this._def,
+            checks: [...this._def.checks, { kind: "trim" }],
+        });
     }
     _parse(input) {
         const parsedType = this._getType(input);
@@ -816,6 +820,12 @@ class ZodString extends ZodType {
                     status.dirty();
                 }
             }
+            else if (check.kind === "trim") {
+                input.data = input.data.trim();
+            }
+            else {
+                util.assertNever(check);
+            }
         }
         return { status: status.value, value: input.data };
     }
@@ -1378,7 +1388,7 @@ var objectUtil;
     objectUtil.mergeShapes = (first, second) => {
         return {
             ...first,
-            ...second, // second overwrites first
+            ...second,
         };
     };
 })(objectUtil || (objectUtil = {}));
@@ -1593,7 +1603,9 @@ class ZodObject extends ZodType {
     pick(mask) {
         const shape = {};
         util.objectKeys(mask).map((key) => {
-            shape[key] = this.shape[key];
+            // only add to shape if key corresponds to an element of the current shape
+            if (this.shape[key])
+                shape[key] = this.shape[key];
         });
         return new ZodObject({
             ...this._def,
@@ -2382,10 +2394,11 @@ ZodLiteral.create = (value, params) => {
         ...processCreateParams(params),
     });
 };
-function createZodEnum(values) {
+function createZodEnum(values, params) {
     return new ZodEnum({
         values: values,
         typeName: ZodFirstPartyTypeKind.ZodEnum,
+        ...processCreateParams(params),
     });
 }
 class ZodEnum extends ZodType {
@@ -2810,8 +2823,8 @@ const oboolean = () => booleanType().optional();
 
 var mod = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    ZodParsedType: ZodParsedType,
     getParsedType: getParsedType,
+    ZodParsedType: ZodParsedType,
     makeIssue: makeIssue,
     EMPTY_PATH: EMPTY_PATH,
     addIssueToContext: addIssueToContext,