zod 3.13.2 → 3.14.0

package/README.md

@@ -10,23 +10,19 @@
 <a href="./src/__tests__" rel="nofollow"><img src="./coverage.svg" alt="coverage"></a>
 <a href="https://discord.gg/KaSRdyX2vc" rel="nofollow"><img src="https://img.shields.io/discord/893487829802418277?label=Discord&logo=discord&logoColor=white" alt="discord server"></a>
 </p>
-<p align="center">
-by <a href="https://twitter.com/colinhacks">@colinhacks</a>
-</p>
 
-> Hi! Colin here, creator of Zod. I hope you find it easy to use and powerful enough for all your use cases. If you have any issues or suggestions, please [open an issue](https://github.com/colinhacks/zod/issues/new)!
->
-> If you like typesafety, check out my other library [tRPC](https://trpc.io). It works in concert with Zod to provide a seamless way to build end-to-end typesafe APIs without GraphQL or code generation — just TypeScript.
->
-> Colin (AKA [@colinhacks](https://twitter.com/colinhacks))
-
-<h3 align="center">
-    <a href="https://discord.gg/RcG33DQJdf">💬 Chat on Discord</a>
-    ·
-    <a href="https://zod.js.org/">📝 Explore the Docs</a>
-    ·
-    <a href="https://www.npmjs.com/package/zod">✨ Install Zod</a>
-</h3>
+<div align="center">
+  <a href="https://discord.gg/RcG33DQJdf">Discord</a>
+  <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
+  <a href="https://www.npmjs.com/package/zod">NPM</a>
+  <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
+  <a href="https://github.com/colinhacks/zod/issues/new">Issues</a>
+  <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
+  <a href="https://twitter.com/colinhacks">@colinhacks</a>
+  <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
+  <a href="https://trpc.io">tRPC</a>
+  <br />
+</div>
 
 <br/>
 
@@ -34,6 +30,10 @@ These docs have been translated into [Chinese](./README_ZH.md).
 
 # Table of contents
 
+<!-- The full documentation is available both on the [official documentation site](https://zod.js.org/) (recommended) and in `README.md`.
+
+### Go to [zod.js.org](https://zod.js.org) >> -->
+
 - [What is Zod](#what-is-zod)
 - [Installation](#installation)
 - [Ecosystem](#ecosystem)
@@ -114,7 +114,7 @@ Zod is designed to be as developer-friendly as possible. The goal is to eliminat
 Some other great aspects:
 
 - Zero dependencies
-- Works in Node.js and browsers (including IE 11)
+- Works in Node.js and all modern browsers
 - Tiny: 8kb minified + zipped
 - Immutable: methods (i.e. `.optional()`) return a new instance
 - Concise, chainable interface
@@ -246,6 +246,7 @@ There are a growing number of tools that are built atop or support Zod natively!
 
 - [`react-hook-form`](https://github.com/react-hook-form/resolvers#zod): A first-party Zod resolver for React Hook Form
 - [`zod-formik-adapter`](https://github.com/robertLichtnow/zod-formik-adapter): A community-maintained Formik adapter for Zod
+- [`react-zorm`](https://github.com/esamattis/react-zorm): Standalone `<form>` generation and validation for React using Zod
 
 # Basic usage
 
@@ -427,26 +428,25 @@ const isActive = z.boolean({
 ```
 
 ## Dates
+
 z.date() accepts a date, not a date string
+
 ```ts
-z.date().safeParse( new Date() ) // success: true
-z.date().safeParse( '2022-01-12T00:00:00.000Z' ) // success: false
+z.date().safeParse(new Date()); // success: true
+z.date().safeParse("2022-01-12T00:00:00.000Z"); // success: false
 ```
 
 To allow for dates or date strings, you can use preprocess
+
 ```ts
-const dateSchema = z.preprocess(
-    arg => {
-        if ( typeof arg == 'string' || arg instanceof Date )
-            return new Date( arg )
-    },
-    z.date()
-)
-type DateSchema = z.infer<typeof dateSchema>
+const dateSchema = z.preprocess((arg) => {
+  if (typeof arg == "string" || arg instanceof Date) return new Date(arg);
+}, z.date());
+type DateSchema = z.infer<typeof dateSchema>;
 // type DateSchema = Date
 
-dateSchema.safeParse( new Date( '1/12/22' ) ) // success: true
-dateSchema.safeParse( '2022-01-12T00:00:00.000Z' ) // success: true
+dateSchema.safeParse(new Date("1/12/22")); // success: true
+dateSchema.safeParse("2022-01-12T00:00:00.000Z"); // success: true
 ```
 
 ## Zod enums
@@ -556,6 +556,12 @@ FruitEnum.parse(3); // passes
 FruitEnum.parse("Cantaloupe"); // fails
 ```
 
+You can access the underlying object with the `.enum` property:
+
+```ts
+FruitEnum.enum.Apple; // "apple"
+```
+
 ## Optionals
 
 You can make any schema optional with `z.optional()`:

package/lib/ZodError.js

@@ -1,58 +1,7 @@
 "use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-var __values = (this && this.__values) || function(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
-        }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-};
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.setErrorMap = exports.overrideErrorMap = exports.defaultErrorMap = exports.ZodError = exports.quotelessJson = exports.ZodIssueCode = void 0;
-var util_1 = require("./helpers/util");
+const util_1 = require("./helpers/util");
 exports.ZodIssueCode = util_1.util.arrayToEnum([
     "invalid_type",
     "custom",
@@ -69,238 +18,194 @@ exports.ZodIssueCode = util_1.util.arrayToEnum([
     "invalid_intersection_types",
     "not_multiple_of",
 ]);
-var quotelessJson = function (obj) {
-    var json = JSON.stringify(obj, null, 2);
+const quotelessJson = (obj) => {
+    const json = JSON.stringify(obj, null, 2);
     return json.replace(/"([^"]+)":/g, "$1:");
 };
 exports.quotelessJson = quotelessJson;
-var ZodError = /** @class */ (function (_super) {
-    __extends(ZodError, _super);
-    function ZodError(issues) {
-        var _newTarget = this.constructor;
-        var _this = _super.call(this) || this;
-        _this.issues = [];
-        _this.format = function () {
-            var fieldErrors = { _errors: [] };
-            var processError = function (error) {
-                var e_1, _a;
-                try {
-                    for (var _b = __values(error.issues), _c = _b.next(); !_c.done; _c = _b.next()) {
-                        var issue = _c.value;
-                        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 {
-                            var curr = fieldErrors;
-                            var i = 0;
-                            while (i < issue.path.length) {
-                                var el = issue.path[i];
-                                var terminal = i === issue.path.length - 1;
-                                if (!terminal) {
-                                    if (typeof el === "string") {
-                                        curr[el] = curr[el] || { _errors: [] };
-                                    }
-                                    else if (typeof el === "number") {
-                                        var errorArray = [];
-                                        errorArray._errors = [];
-                                        curr[el] = curr[el] || errorArray;
-                                    }
-                                }
-                                else {
+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: [] };
-                                    curr[el]._errors.push(issue.message);
                                 }
-                                curr = curr[el];
-                                i++;
+                                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++;
                         }
                     }
                 }
-                catch (e_1_1) { e_1 = { error: e_1_1 }; }
-                finally {
-                    try {
-                        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-                    }
-                    finally { if (e_1) throw e_1.error; }
-                }
             };
-            processError(_this);
+            processError(this);
             return fieldErrors;
         };
-        _this.addIssue = function (sub) {
-            _this.issues = __spreadArray(__spreadArray([], __read(_this.issues), false), [sub], false);
+        this.addIssue = (sub) => {
+            this.issues = [...this.issues, sub];
         };
-        _this.addIssues = function (subs) {
-            if (subs === void 0) { subs = []; }
-            _this.issues = __spreadArray(__spreadArray([], __read(_this.issues), false), __read(subs), false);
+        this.addIssues = (subs = []) => {
+            this.issues = [...this.issues, ...subs];
         };
-        var actualProto = _newTarget.prototype;
+        const actualProto = new.target.prototype;
         if (Object.setPrototypeOf) {
             // eslint-disable-next-line ban/ban
-            Object.setPrototypeOf(_this, actualProto);
+            Object.setPrototypeOf(this, actualProto);
         }
         else {
-            _this.__proto__ = actualProto;
+            this.__proto__ = actualProto;
         }
-        _this.name = "ZodError";
-        _this.issues = issues;
-        return _this;
+        this.name = "ZodError";
+        this.issues = issues;
+    }
+    get errors() {
+        return this.issues;
     }
-    Object.defineProperty(ZodError.prototype, "errors", {
-        get: function () {
-            return this.issues;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    ZodError.prototype.toString = function () {
+    toString() {
         return this.message;
-    };
-    Object.defineProperty(ZodError.prototype, "message", {
-        get: function () {
-            return JSON.stringify(this.issues, null, 2);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(ZodError.prototype, "isEmpty", {
-        get: function () {
-            return this.issues.length === 0;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    ZodError.prototype.flatten = function (mapper) {
-        var e_2, _a;
-        if (mapper === void 0) { mapper = function (issue) { return issue.message; }; }
-        var fieldErrors = {};
-        var formErrors = [];
-        try {
-            for (var _b = __values(this.issues), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var sub = _c.value;
-                if (sub.path.length > 0) {
-                    fieldErrors[sub.path[0]] = fieldErrors[sub.path[0]] || [];
-                    fieldErrors[sub.path[0]].push(mapper(sub));
-                }
-                else {
-                    formErrors.push(mapper(sub));
-                }
+    }
+    get message() {
+        return JSON.stringify(this.issues, null, 2);
+    }
+    get isEmpty() {
+        return this.issues.length === 0;
+    }
+    flatten(mapper = (issue) => issue.message) {
+        const fieldErrors = {};
+        const formErrors = [];
+        for (const sub of this.issues) {
+            if (sub.path.length > 0) {
+                fieldErrors[sub.path[0]] = fieldErrors[sub.path[0]] || [];
+                fieldErrors[sub.path[0]].push(mapper(sub));
             }
-        }
-        catch (e_2_1) { e_2 = { error: e_2_1 }; }
-        finally {
-            try {
-                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            else {
+                formErrors.push(mapper(sub));
             }
-            finally { if (e_2) throw e_2.error; }
         }
-        return { formErrors: formErrors, fieldErrors: fieldErrors };
-    };
-    Object.defineProperty(ZodError.prototype, "formErrors", {
-        get: function () {
-            return this.flatten();
-        },
-        enumerable: false,
-        configurable: true
-    });
-    ZodError.create = function (issues) {
-        var error = new ZodError(issues);
-        return error;
-    };
-    return ZodError;
-}(Error));
+        return { formErrors, fieldErrors };
+    }
+    get formErrors() {
+        return this.flatten();
+    }
+}
 exports.ZodError = ZodError;
-var defaultErrorMap = function (issue, _ctx) {
-    var message;
+ZodError.create = (issues) => {
+    const error = new ZodError(issues);
+    return error;
+};
+const defaultErrorMap = (issue, _ctx) => {
+    let message;
     switch (issue.code) {
         case exports.ZodIssueCode.invalid_type:
             if (issue.received === "undefined") {
                 message = "Required";
             }
             else {
-                message = "Expected ".concat(issue.expected, ", received ").concat(issue.received);
+                message = `Expected ${issue.expected}, received ${issue.received}`;
             }
             break;
         case exports.ZodIssueCode.unrecognized_keys:
-            message = "Unrecognized key(s) in object: ".concat(issue.keys
-                .map(function (k) { return "'".concat(k, "'"); })
-                .join(", "));
+            message = `Unrecognized key(s) in object: ${issue.keys
+                .map((k) => `'${k}'`)
+                .join(", ")}`;
             break;
         case exports.ZodIssueCode.invalid_union:
-            message = "Invalid input";
+            message = `Invalid input`;
             break;
         case exports.ZodIssueCode.invalid_union_discriminator:
-            message = "Invalid discriminator value. Expected ".concat(issue.options
-                .map(function (val) { return (typeof val === "string" ? "'".concat(val, "'") : val); })
-                .join(" | "));
+            message = `Invalid discriminator value. Expected ${issue.options
+                .map((val) => (typeof val === "string" ? `'${val}'` : val))
+                .join(" | ")}`;
             break;
         case exports.ZodIssueCode.invalid_enum_value:
-            message = "Invalid enum value. Expected ".concat(issue.options
-                .map(function (val) { return (typeof val === "string" ? "'".concat(val, "'") : val); })
-                .join(" | "));
+            message = `Invalid enum value. Expected ${issue.options
+                .map((val) => (typeof val === "string" ? `'${val}'` : val))
+                .join(" | ")}`;
             break;
         case exports.ZodIssueCode.invalid_arguments:
-            message = "Invalid function arguments";
+            message = `Invalid function arguments`;
             break;
         case exports.ZodIssueCode.invalid_return_type:
-            message = "Invalid function return type";
+            message = `Invalid function return type`;
             break;
         case exports.ZodIssueCode.invalid_date:
-            message = "Invalid date";
+            message = `Invalid date`;
             break;
         case exports.ZodIssueCode.invalid_string:
             if (issue.validation !== "regex")
-                message = "Invalid ".concat(issue.validation);
+                message = `Invalid ${issue.validation}`;
             else
                 message = "Invalid";
             break;
         case exports.ZodIssueCode.too_small:
             if (issue.type === "array")
-                message = "Array must contain ".concat(issue.inclusive ? "at least" : "more than", " ").concat(issue.minimum, " element(s)");
+                message = `Array must contain ${issue.inclusive ? `at least` : `more than`} ${issue.minimum} element(s)`;
             else if (issue.type === "string")
-                message = "String must contain ".concat(issue.inclusive ? "at least" : "over", " ").concat(issue.minimum, " character(s)");
+                message = `String must contain ${issue.inclusive ? `at least` : `over`} ${issue.minimum} character(s)`;
             else if (issue.type === "number")
-                message = "Number must be greater than ".concat(issue.inclusive ? "or equal to " : "").concat(issue.minimum);
+                message = `Number must be greater than ${issue.inclusive ? `or equal to ` : ``}${issue.minimum}`;
             else
                 message = "Invalid input";
             break;
         case exports.ZodIssueCode.too_big:
             if (issue.type === "array")
-                message = "Array must contain ".concat(issue.inclusive ? "at most" : "less than", " ").concat(issue.maximum, " element(s)");
+                message = `Array must contain ${issue.inclusive ? `at most` : `less than`} ${issue.maximum} element(s)`;
             else if (issue.type === "string")
-                message = "String must contain ".concat(issue.inclusive ? "at most" : "under", " ").concat(issue.maximum, " character(s)");
+                message = `String must contain ${issue.inclusive ? `at most` : `under`} ${issue.maximum} character(s)`;
             else if (issue.type === "number")
-                message = "Number must be less than ".concat(issue.inclusive ? "or equal to " : "").concat(issue.maximum);
+                message = `Number must be less than ${issue.inclusive ? `or equal to ` : ``}${issue.maximum}`;
             else
                 message = "Invalid input";
             break;
         case exports.ZodIssueCode.custom:
-            message = "Invalid input";
+            message = `Invalid input`;
             break;
         case exports.ZodIssueCode.invalid_intersection_types:
-            message = "Intersection results could not be merged";
+            message = `Intersection results could not be merged`;
             break;
         case exports.ZodIssueCode.not_multiple_of:
-            message = "Number must be a multiple of ".concat(issue.multipleOf);
+            message = `Number must be a multiple of ${issue.multipleOf}`;
             break;
         default:
             message = _ctx.defaultError;
             util_1.util.assertNever(issue);
     }
-    return { message: message };
+    return { message };
 };
 exports.defaultErrorMap = defaultErrorMap;
 exports.overrideErrorMap = exports.defaultErrorMap;
-var setErrorMap = function (map) {
+const setErrorMap = (map) => {
     exports.overrideErrorMap = map;
 };
 exports.setErrorMap = setErrorMap;

package/lib/benchmarks/discriminatedUnion.js

@@ -3,76 +3,76 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-var benchmark_1 = __importDefault(require("benchmark"));
-var index_1 = require("../index");
-var doubleSuite = new benchmark_1.default.Suite("z.discriminatedUnion: double");
-var manySuite = new benchmark_1.default.Suite("z.discriminatedUnion: many");
-var aSchema = index_1.z.object({
+const benchmark_1 = __importDefault(require("benchmark"));
+const index_1 = require("../index");
+const doubleSuite = new benchmark_1.default.Suite("z.discriminatedUnion: double");
+const manySuite = new benchmark_1.default.Suite("z.discriminatedUnion: many");
+const aSchema = index_1.z.object({
     type: index_1.z.literal("a"),
 });
-var objA = {
+const objA = {
     type: "a",
 };
-var bSchema = index_1.z.object({
+const bSchema = index_1.z.object({
     type: index_1.z.literal("b"),
 });
-var objB = {
+const objB = {
     type: "b",
 };
-var cSchema = index_1.z.object({
+const cSchema = index_1.z.object({
     type: index_1.z.literal("c"),
 });
-var objC = {
+const objC = {
     type: "c",
 };
-var dSchema = index_1.z.object({
+const dSchema = index_1.z.object({
     type: index_1.z.literal("d"),
 });
-var double = index_1.z.discriminatedUnion("type", [aSchema, bSchema]);
-var many = index_1.z.discriminatedUnion("type", [aSchema, bSchema, cSchema, dSchema]);
+const double = index_1.z.discriminatedUnion("type", [aSchema, bSchema]);
+const many = index_1.z.discriminatedUnion("type", [aSchema, bSchema, cSchema, dSchema]);
 doubleSuite
-    .add("valid: a", function () {
+    .add("valid: a", () => {
     double.parse(objA);
 })
-    .add("valid: b", function () {
+    .add("valid: b", () => {
     double.parse(objB);
 })
-    .add("invalid: null", function () {
+    .add("invalid: null", () => {
     try {
         double.parse(null);
     }
     catch (err) { }
 })
-    .add("invalid: wrong shape", function () {
+    .add("invalid: wrong shape", () => {
     try {
         double.parse(objC);
     }
     catch (err) { }
 })
-    .on("cycle", function (e) {
-    console.log("".concat(doubleSuite.name, ": ").concat(e.target));
+    .on("cycle", (e) => {
+    console.log(`${doubleSuite.name}: ${e.target}`);
 });
 manySuite
-    .add("valid: a", function () {
+    .add("valid: a", () => {
     many.parse(objA);
 })
-    .add("valid: c", function () {
+    .add("valid: c", () => {
     many.parse(objC);
 })
-    .add("invalid: null", function () {
+    .add("invalid: null", () => {
     try {
         many.parse(null);
     }
     catch (err) { }
 })
-    .add("invalid: wrong shape", function () {
+    .add("invalid: wrong shape", () => {
     try {
         many.parse({ type: "unknown" });
     }
     catch (err) { }
 })
-    .on("cycle", function (e) {
-    console.log("".concat(manySuite.name, ": ").concat(e.target));
+    .on("cycle", (e) => {
+    console.log(`${manySuite.name}: ${e.target}`);
 });
 exports.default = {
     suites: [doubleSuite, manySuite],