zod 3.14.2 → 3.14.5

package/lib/index.mjs

@@ -49,6 +49,7 @@ var util;
 
 const ZodIssueCode = util.arrayToEnum([
     "invalid_type",
+    "invalid_literal",
     "custom",
     "invalid_union",
     "invalid_union_discriminator",
@@ -71,51 +72,6 @@ class ZodError extends Error {
     constructor(issues) {
         super();
         this.issues = [];
-        this.format = () => {
-            const fieldErrors = { _errors: [] };
-            const processError = (error) => {
-                for (const issue of error.issues) {
-                    if (issue.code === "invalid_union") {
-                        issue.unionErrors.map(processError);
-                    }
-                    else if (issue.code === "invalid_return_type") {
-                        processError(issue.returnTypeError);
-                    }
-                    else if (issue.code === "invalid_arguments") {
-                        processError(issue.argumentsError);
-                    }
-                    else if (issue.path.length === 0) {
-                        fieldErrors._errors.push(issue.message);
-                    }
-                    else {
-                        let curr = fieldErrors;
-                        let i = 0;
-                        while (i < issue.path.length) {
-                            const el = issue.path[i];
-                            const terminal = i === issue.path.length - 1;
-                            if (!terminal) {
-                                if (typeof el === "string") {
-                                    curr[el] = curr[el] || { _errors: [] };
-                                }
-                                else if (typeof el === "number") {
-                                    const errorArray = [];
-                                    errorArray._errors = [];
-                                    curr[el] = curr[el] || errorArray;
-                                }
-                            }
-                            else {
-                                curr[el] = curr[el] || { _errors: [] };
-                                curr[el]._errors.push(issue.message);
-                            }
-                            curr = curr[el];
-                            i++;
-                        }
-                    }
-                }
-            };
-            processError(this);
-            return fieldErrors;
-        };
         this.addIssue = (sub) => {
             this.issues = [...this.issues, sub];
         };
@@ -136,6 +92,55 @@ class ZodError extends Error {
     get errors() {
         return this.issues;
     }
+    format(_mapper) {
+        const mapper = _mapper ||
+            function (issue) {
+                return issue.message;
+            };
+        const fieldErrors = { _errors: [] };
+        const processError = (error) => {
+            for (const issue of error.issues) {
+                if (issue.code === "invalid_union") {
+                    issue.unionErrors.map(processError);
+                }
+                else if (issue.code === "invalid_return_type") {
+                    processError(issue.returnTypeError);
+                }
+                else if (issue.code === "invalid_arguments") {
+                    processError(issue.argumentsError);
+                }
+                else if (issue.path.length === 0) {
+                    fieldErrors._errors.push(mapper(issue));
+                }
+                else {
+                    let curr = fieldErrors;
+                    let i = 0;
+                    while (i < issue.path.length) {
+                        const el = issue.path[i];
+                        const terminal = i === issue.path.length - 1;
+                        if (!terminal) {
+                            if (typeof el === "string") {
+                                curr[el] = curr[el] || { _errors: [] };
+                            }
+                            else if (typeof el === "number") {
+                                const errorArray = [];
+                                errorArray._errors = [];
+                                curr[el] = curr[el] || errorArray;
+                            }
+                        }
+                        else {
+                            curr[el] = curr[el] || { _errors: [] };
+                            curr[el]._errors.push(mapper(issue));
+                        }
+                        curr = curr[el];
+                        i++;
+                    }
+                }
+            }
+        };
+        processError(this);
+        return fieldErrors;
+    }
     toString() {
         return this.message;
     }
@@ -178,6 +183,9 @@ const defaultErrorMap = (issue, _ctx) => {
                 message = `Expected ${issue.expected}, received ${issue.received}`;
             }
             break;
+        case ZodIssueCode.invalid_literal:
+            message = `Invalid literal value, expected ${JSON.stringify(issue.expected)}`;
+            break;
         case ZodIssueCode.unrecognized_keys:
             message = `Unrecognized key(s) in object: ${issue.keys
                 .map((k) => `'${k}'`)
@@ -419,6 +427,17 @@ var errorUtil;
     errorUtil.toString = (message) => typeof message === "string" ? message : message === null || message === void 0 ? void 0 : message.message;
 })(errorUtil || (errorUtil = {}));
 
+class ParseInputLazyPath {
+    constructor(parent, value, path, key) {
+        this.parent = parent;
+        this.data = value;
+        this._path = path;
+        this._key = key;
+    }
+    get path() {
+        return this._path.concat(this._key);
+    }
+}
 const handleResult = (ctx, result) => {
     if (isValid(result)) {
         return { success: true, data: result.value };
@@ -475,8 +494,8 @@ class ZodType {
         this.transform = this.transform.bind(this);
         this.default = this.default.bind(this);
         this.describe = this.describe.bind(this);
-        this.isOptional = this.isOptional.bind(this);
         this.isNullable = this.isNullable.bind(this);
+        this.isOptional = this.isOptional.bind(this);
     }
     get description() {
         return this._def.description;
@@ -530,7 +549,6 @@ class ZodType {
             common: {
                 issues: [],
                 async: (_a = params === null || params === void 0 ? void 0 : params.async) !== null && _a !== void 0 ? _a : false,
-                typeCache: typeof Map !== "undefined" ? new Map() : undefined,
                 contextualErrorMap: params === null || params === void 0 ? void 0 : params.errorMap,
             },
             path: (params === null || params === void 0 ? void 0 : params.path) || [],
@@ -554,7 +572,6 @@ class ZodType {
                 issues: [],
                 contextualErrorMap: params === null || params === void 0 ? void 0 : params.errorMap,
                 async: true,
-                typeCache: typeof Map !== "undefined" ? new Map() : undefined,
             },
             path: (params === null || params === void 0 ? void 0 : params.path) || [],
             schemaErrorMap: this._def.errorMap,
@@ -1308,21 +1325,13 @@ class ZodArray extends ZodType {
         }
         if (ctx.common.async) {
             return Promise.all(ctx.data.map((item, i) => {
-                return def.type._parseAsync({
-                    parent: ctx,
-                    path: [...ctx.path, i],
-                    data: item,
-                });
+                return def.type._parseAsync(new ParseInputLazyPath(ctx, item, ctx.path, i));
             })).then((result) => {
                 return ParseStatus.mergeArray(status, result);
             });
         }
         const result = ctx.data.map((item, i) => {
-            return def.type._parseSync({
-                parent: ctx,
-                path: [...ctx.path, i],
-                data: item,
-            });
+            return def.type._parseSync(new ParseInputLazyPath(ctx, item, ctx.path, i));
         });
         return ParseStatus.mergeArray(status, result);
     }
@@ -1442,19 +1451,19 @@ class ZodObject extends ZodType {
         }
         const { status, ctx } = this._processInputParams(input);
         const { shape, keys: shapeKeys } = this._getCached();
-        const dataKeys = util.objectKeys(ctx.data);
-        const extraKeys = dataKeys.filter((k) => !shapeKeys.includes(k));
+        const extraKeys = [];
+        for (const key in ctx.data) {
+            if (!shapeKeys.includes(key)) {
+                extraKeys.push(key);
+            }
+        }
         const pairs = [];
         for (const key of shapeKeys) {
             const keyValidator = shape[key];
             const value = ctx.data[key];
             pairs.push({
                 key: { status: "valid", value: key },
-                value: keyValidator._parse({
-                    parent: ctx,
-                    data: value,
-                    path: [...ctx.path, key],
-                }),
+                value: keyValidator._parse(new ParseInputLazyPath(ctx, value, ctx.path, key)),
                 alwaysSet: key in ctx.data,
             });
         }
@@ -1489,7 +1498,7 @@ class ZodObject extends ZodType {
                 const value = ctx.data[key];
                 pairs.push({
                     key: { status: "valid", value: key },
-                    value: catchall._parse({ parent: ctx, path: [...ctx.path, key], data: value } //, ctx.child(key), value, getParsedType(value)
+                    value: catchall._parse(new ParseInputLazyPath(ctx, value, ctx.path, key) //, ctx.child(key), value, getParsedType(value)
                     ),
                     alwaysSet: key in ctx.data,
                 });
@@ -1985,11 +1994,7 @@ class ZodTuple extends ZodType {
             const schema = this._def.items[itemIndex] || this._def.rest;
             if (!schema)
                 return null;
-            return schema._parse({
-                data: item,
-                path: [...ctx.path, itemIndex],
-                parent: ctx,
-            });
+            return schema._parse(new ParseInputLazyPath(ctx, item, ctx.path, itemIndex));
         })
             .filter((x) => !!x); // filter nulls
         if (ctx.common.async) {
@@ -2041,16 +2046,8 @@ class ZodRecord extends ZodType {
         const valueType = this._def.valueType;
         for (const key in ctx.data) {
             pairs.push({
-                key: keyType._parse({
-                    data: key,
-                    path: [...ctx.path, key],
-                    parent: ctx,
-                }),
-                value: valueType._parse({
-                    data: ctx.data[key],
-                    path: [...ctx.path, key],
-                    parent: ctx,
-                }),
+                key: keyType._parse(new ParseInputLazyPath(ctx, key, ctx.path, key)),
+                value: valueType._parse(new ParseInputLazyPath(ctx, ctx.data[key], ctx.path, key)),
             });
         }
         if (ctx.common.async) {
@@ -2095,16 +2092,8 @@ class ZodMap extends ZodType {
         const valueType = this._def.valueType;
         const pairs = [...ctx.data.entries()].map(([key, value], index) => {
             return {
-                key: keyType._parse({
-                    data: key,
-                    path: [...ctx.path, index, "key"],
-                    parent: ctx,
-                }),
-                value: valueType._parse({
-                    data: value,
-                    path: [...ctx.path, index, "value"],
-                    parent: ctx,
-                }),
+                key: keyType._parse(new ParseInputLazyPath(ctx, key, ctx.path, [index, "key"])),
+                value: valueType._parse(new ParseInputLazyPath(ctx, value, ctx.path, [index, "value"])),
             };
         });
         if (ctx.common.async) {
@@ -2197,7 +2186,7 @@ class ZodSet extends ZodType {
             }
             return { status: status.value, value: parsedSet };
         }
-        const elements = [...ctx.data.values()].map((item, i) => valueType._parse({ data: item, path: [...ctx.path, i], parent: ctx }));
+        const elements = [...ctx.data.values()].map((item, i) => valueType._parse(new ParseInputLazyPath(ctx, item, ctx.path, i)));
         if (ctx.common.async) {
             return Promise.all(elements).then((elements) => finalizeSet(elements));
         }
@@ -2375,9 +2364,8 @@ class ZodLiteral extends ZodType {
         if (input.data !== this._def.value) {
             const ctx = this._getOrReturnCtx(input);
             addIssueToContext(ctx, {
-                code: ZodIssueCode.invalid_type,
-                expected: getParsedType(this._def.value),
-                received: ctx.parsedType,
+                code: ZodIssueCode.invalid_literal,
+                expected: this._def.value,
             });
             return INVALID;
         }