zod 3.16.0 → 3.17.2

package/lib/index.umd.js

@@ -58,6 +58,70 @@
         }
         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",
@@ -265,70 +329,6 @@
         exports.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 || [])];
@@ -715,10 +715,14 @@
                 ...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);
@@ -822,6 +826,12 @@
                         status.dirty();
                     }
                 }
+                else if (check.kind === "trim") {
+                    input.data = input.data.trim();
+                }
+                else {
+                    util.assertNever(check);
+                }
             }
             return { status: status.value, value: input.data };
         }
@@ -1599,7 +1609,9 @@
         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,
@@ -2388,10 +2400,11 @@
             ...processCreateParams(params),
         });
     };
-    function createZodEnum(values) {
+    function createZodEnum(values, params) {
         return new ZodEnum({
             values: values,
             typeName: exports.ZodFirstPartyTypeKind.ZodEnum,
+            ...processCreateParams(params),
         });
     }
     class ZodEnum extends ZodType {
@@ -2727,9 +2740,15 @@
             ...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 = {
@@ -2771,7 +2790,7 @@
     })(exports.ZodFirstPartyTypeKind || (exports.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;
@@ -2810,8 +2829,8 @@
 
     var mod = /*#__PURE__*/Object.freeze({
         __proto__: null,
-        ZodParsedType: ZodParsedType,
         getParsedType: getParsedType,
+        ZodParsedType: ZodParsedType,
         makeIssue: makeIssue,
         EMPTY_PATH: EMPTY_PATH,
         addIssueToContext: addIssueToContext,

package/lib/types.d.ts

@@ -102,6 +102,9 @@ declare type ZodStringCheck = {
     kind: "regex";
     regex: RegExp;
     message?: string;
+} | {
+    kind: "trim";
+    message?: string;
 };
 export interface ZodStringDef extends ZodTypeDef {
     checks: ZodStringCheck[];
@@ -120,10 +123,11 @@ export declare class ZodString extends ZodType<string, ZodStringDef> {
     max(maxLength: number, message?: errorUtil.ErrMessage): ZodString;
     length(len: number, message?: errorUtil.ErrMessage): ZodString;
     /**
-     * Deprecated.
-     * Use z.string().min(1) instead.
+     * @deprecated Use z.string().min(1) instead.
+     * @see {@link ZodString.min}
      */
     nonempty: (message?: errorUtil.ErrMessage | undefined) => ZodString;
+    trim: () => ZodString;
     get isEmail(): boolean;
     get isURL(): boolean;
     get isUUID(): boolean;
@@ -530,8 +534,8 @@ export interface ZodEnumDef<T extends EnumValues = EnumValues> extends ZodTypeDe
 declare type Writeable<T> = {
     -readonly [P in keyof T]: T[P];
 };
-declare function createZodEnum<U extends string, T extends Readonly<[U, ...U[]]>>(values: T): ZodEnum<Writeable<T>>;
-declare function createZodEnum<U extends string, T extends [U, ...U[]]>(values: T): ZodEnum<T>;
+declare function createZodEnum<U extends string, T extends Readonly<[U, ...U[]]>>(values: T, params?: RawCreateParams): ZodEnum<Writeable<T>>;
+declare function createZodEnum<U extends string, T extends [U, ...U[]]>(values: T, params?: RawCreateParams): ZodEnum<T>;
 export declare class ZodEnum<T extends [string, ...string[]]> extends ZodType<T[number], ZodEnumDef<T>> {
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
     get options(): T;
@@ -625,7 +629,7 @@ export declare class ZodNaN extends ZodType<number, ZodNaNDef> {
     _parse(input: ParseInput): ParseReturnType<any>;
     static create: (params?: RawCreateParams) => ZodNaN;
 }
-export declare const custom: <T>(check?: ((data: unknown) => any) | undefined, params?: Parameters<ZodTypeAny["refine"]>[1]) => ZodType<T, ZodTypeDef, T>;
+export declare const custom: <T>(check?: ((data: unknown) => any) | undefined, params?: Parameters<ZodTypeAny["refine"]>[1], fatal?: boolean | undefined) => ZodType<T, ZodTypeDef, T>;
 export { ZodType as Schema, ZodType as ZodSchema };
 export declare const late: {
     object: <T extends ZodRawShape>(shape: () => T, params?: RawCreateParams) => ZodObject<T, "strip", ZodTypeAny, { [k_1 in keyof objectUtil.addQuestionMarks<{ [k in keyof T]: T[k]["_output"]; }>]: objectUtil.addQuestionMarks<{ [k in keyof T]: T[k]["_output"]; }>[k_1]; }, { [k_3 in keyof objectUtil.addQuestionMarks<{ [k_2 in keyof T]: T[k_2]["_input"]; }>]: objectUtil.addQuestionMarks<{ [k_2 in keyof T]: T[k_2]["_input"]; }>[k_3]; }>;