zod 3.16.0 → 3.17.2

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

@@ -14,7 +14,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/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, type ZodErrorMap, type 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 || [])];

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.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 || [])];
@@ -709,10 +709,14 @@ class ZodString extends ZodType {
             ...errorUtil.errToObj(message),
         });
         /**
-         * Deprecated.
-         * Use z.string().min(1) instead.
+         * @deprecated Use z.string().min(1) instead.
+         * @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 };
     }
@@ -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 {
@@ -2721,9 +2734,15 @@ ZodNaN.create = (params) => {
         ...processCreateParams(params),
     });
 };
-const custom = (check, params) => {
+const custom = (check, params = {}, fatal) => {
     if (check)
-        return ZodAny.create().refine(check, params);
+        return ZodAny.create().superRefine((data, ctx) => {
+            if (!check(data)) {
+                const p = typeof params === "function" ? params(data) : params;
+                const p2 = typeof p === "string" ? { message: p } : p;
+                ctx.addIssue({ code: "custom", ...p2, fatal });
+            }
+        });
     return ZodAny.create();
 };
 const late = {
@@ -2765,7 +2784,7 @@ var ZodFirstPartyTypeKind;
 })(ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {}));
 const instanceOfType = (cls, params = {
     message: `Input not instance of ${cls.name}`,
-}) => custom((data) => data instanceof cls, params);
+}) => custom((data) => data instanceof cls, params, true);
 const stringType = ZodString.create;
 const numberType = ZodNumber.create;
 const nanType = ZodNaN.create;
@@ -2804,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,