zod 3.17.5 → 3.17.8

package/README.md

@@ -313,6 +313,7 @@ There are a growing number of tools that are built atop or support Zod natively!
 - [`prisma-zod-generator`](https://github.com/omar-dulaimi/prisma-zod-generator): Emit Zod schemas from your Prisma schema.
 - [`prisma-trpc-generator`](https://github.com/omar-dulaimi/prisma-trpc-generator): Emit fully implemented tRPC routers and their validation schemas using Zod.
 - [`nestjs-graphql-zod`](https://github.com/incetarik/nestjs-graphql-zod): Generates NestJS GraphQL model classes from Zod schemas dynamically and provides GraphQL method decorators working with Zod schemas.
+- [`zod-xlsx`](https://github.com/sidwebworks/zod-xlsx): A xlsx based resource validator using Zod schemas.
 - [`remix-domains`](https://github.com/SeasonedSoftware/remix-domains/): Improves end-to-end type safety in [Remix](https://remix.run/) by leveraging Zod to parse the framework's inputs such as FormData, URLSearchParams, etc.
 
 #### Form integrations
@@ -351,7 +352,7 @@ pnpm add zod          # pnpm
 
 ### 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:
+Unlike Node, Deno relies on direct URL imports instead of a package manager like NPM. Zod is available on [deno.land/x](https://deno.land/x). The latest version can be imported like so:
 
 ```ts
 import { z } from "https://deno.land/x/zod/mod.ts";
@@ -360,7 +361,7 @@ 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"
+import { z } from "https://deno.land/x/zod@v3.16.1/mod.ts";
 ```
 
 > The rest of this README assumes you are using npm and importing directly from the `"zod"` package.
@@ -438,7 +439,7 @@ const tru = z.literal(true);
 tuna.value; // "tuna"
 ```
 
-> Currently there is no support for Date or bigint literals in Zod. If you have a use case for this feature, please file an issue.
+> Currently there is no support for Date literals in Zod. If you have a use case for this feature, please file an issue.
 
 ## Strings
 
@@ -549,14 +550,32 @@ const isActive = z.boolean({
 
 ## Dates
 
-z.date() accepts a date, not a date string
+Use z.date() to validate `Date` instances.
 
 ```ts
 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
+You can customize certain error messages when creating a boolean schema.
+
+```ts
+const myDateSchema = z.date({
+  required_error: "Please select a date and time",
+  invalid_type_error: "That's not a date!",
+});
+```
+
+Zod provides a handful of date-specific validations.
+
+```ts
+z.date().min(new Date("1900-01-01"), { message: "Too old" });
+z.date().max(new Date(), { message: "Too young!" });
+```
+
+**Supporting date strings**
+
+To write a schema that accepts either a `Date` or a date string, use (`z.preprocess`)[#preprocess].
 
 ```ts
 const dateSchema = z.preprocess((arg) => {

package/lib/ZodError.d.ts

@@ -81,13 +81,13 @@ export interface ZodTooSmallIssue extends ZodIssueBase {
     code: typeof ZodIssueCode.too_small;
     minimum: number;
     inclusive: boolean;
-    type: "array" | "string" | "number" | "set";
+    type: "array" | "string" | "number" | "set" | "date";
 }
 export interface ZodTooBigIssue extends ZodIssueBase {
     code: typeof ZodIssueCode.too_big;
     maximum: number;
     inclusive: boolean;
-    type: "array" | "string" | "number" | "set";
+    type: "array" | "string" | "number" | "set" | "date";
 }
 export interface ZodInvalidIntersectionTypesIssue extends ZodIssueBase {
     code: typeof ZodIssueCode.invalid_intersection_types;
@@ -150,8 +150,8 @@ export declare type ZodErrorMap = typeof defaultErrorMap;
 export declare const defaultErrorMap: (issue: ZodIssueOptionalMessage, _ctx: ErrorMapCtx) => {
     message: string;
 };
-export declare let overrideErrorMap: (issue: ZodIssueOptionalMessage, _ctx: ErrorMapCtx) => {
+export declare function setErrorMap(map: ZodErrorMap): void;
+export declare function getErrorMap(): (issue: ZodIssueOptionalMessage, _ctx: ErrorMapCtx) => {
     message: string;
 };
-export declare const setErrorMap: (map: ZodErrorMap) => void;
 export {};

package/lib/ZodError.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.setErrorMap = exports.overrideErrorMap = exports.defaultErrorMap = exports.ZodError = exports.quotelessJson = exports.ZodIssueCode = void 0;
+exports.getErrorMap = exports.setErrorMap = 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",
@@ -101,7 +102,7 @@ class ZodError extends Error {
         return this.message;
     }
     get message() {
-        return JSON.stringify(this.issues, null, 2);
+        return JSON.stringify(this.issues, parseUtil_1.jsonStringifyReplacer, 2);
     }
     get isEmpty() {
         return this.issues.length === 0;
@@ -141,7 +142,7 @@ const defaultErrorMap = (issue, _ctx) => {
             }
             break;
         case exports.ZodIssueCode.invalid_literal:
-            message = `Invalid literal value, expected ${JSON.stringify(issue.expected)}`;
+            message = `Invalid literal value, expected ${JSON.stringify(issue.expected, parseUtil_1.jsonStringifyReplacer)}`;
             break;
         case exports.ZodIssueCode.unrecognized_keys:
             message = `Unrecognized key(s) in object: ${util_1.util.joinValues(issue.keys, ", ")}`;
@@ -190,6 +191,8 @@ const defaultErrorMap = (issue, _ctx) => {
                 message = `String must contain ${issue.inclusive ? `at least` : `over`} ${issue.minimum} character(s)`;
             else if (issue.type === "number")
                 message = `Number must be greater than ${issue.inclusive ? `or equal to ` : ``}${issue.minimum}`;
+            else if (issue.type === "date")
+                message = `Date must be greater than ${issue.inclusive ? `or equal to ` : ``}${new Date(issue.minimum)}`;
             else
                 message = "Invalid input";
             break;
@@ -200,6 +203,8 @@ const defaultErrorMap = (issue, _ctx) => {
                 message = `String must contain ${issue.inclusive ? `at most` : `under`} ${issue.maximum} character(s)`;
             else if (issue.type === "number")
                 message = `Number must be less than ${issue.inclusive ? `or equal to ` : ``}${issue.maximum}`;
+            else if (issue.type === "date")
+                message = `Date must be smaller than ${issue.inclusive ? `or equal to ` : ``}${new Date(issue.maximum)}`;
             else
                 message = "Invalid input";
             break;
@@ -219,8 +224,12 @@ const defaultErrorMap = (issue, _ctx) => {
     return { message };
 };
 exports.defaultErrorMap = defaultErrorMap;
-exports.overrideErrorMap = exports.defaultErrorMap;
-const setErrorMap = (map) => {
-    exports.overrideErrorMap = map;
-};
+let overrideErrorMap = exports.defaultErrorMap;
+function setErrorMap(map) {
+    overrideErrorMap = map;
+}
 exports.setErrorMap = setErrorMap;
+function getErrorMap() {
+    return overrideErrorMap;
+}
+exports.getErrorMap = getErrorMap;

package/lib/helpers/parseUtil.d.ts

@@ -76,3 +76,4 @@ export declare const isAborted: (x: ParseReturnType<any>) => x is INVALID;
 export declare const isDirty: <T>(x: ParseReturnType<T>) => x is OK<T> | DIRTY<T>;
 export declare const isValid: <T>(x: ParseReturnType<T>) => x is OK<T> | DIRTY<T>;
 export declare const isAsync: <T>(x: ParseReturnType<T>) => x is AsyncParseReturnType<T>;
+export declare const jsonStringifyReplacer: (_: string, value: any) => any;

package/lib/helpers/parseUtil.js

@@ -1,6 +1,6 @@
 "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 = void 0;
+exports.jsonStringifyReplacer = 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 makeIssue = (params) => {
     const { data, path, errorMaps, issueData } = params;
@@ -33,7 +33,7 @@ function addIssueToContext(ctx, issueData) {
         errorMaps: [
             ctx.common.contextualErrorMap,
             ctx.schemaErrorMap,
-            ZodError_1.overrideErrorMap,
+            ZodError_1.getErrorMap(),
             ZodError_1.defaultErrorMap,
         ].filter((x) => !!x),
     });
@@ -108,3 +108,10 @@ const isValid = (x) => x.status === "valid";
 exports.isValid = isValid;
 const isAsync = (x) => typeof Promise !== undefined && x instanceof Promise;
 exports.isAsync = isAsync;
+const jsonStringifyReplacer = (_, value) => {
+    if (typeof value === "bigint") {
+        return value.toString();
+    }
+    return value;
+};
+exports.jsonStringifyReplacer = jsonStringifyReplacer;

package/lib/helpers/util.d.ts

@@ -1,5 +1,6 @@
 export declare namespace util {
     type AssertEqual<T, Expected> = [T] extends [Expected] ? [Expected] extends [T] ? true : false : false;
+    function assertEqual<A, B>(_cond: AssertEqual<A, B>): void;
     function assertNever(_x: never): never;
     type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
     type OmitKeys<T, K extends string> = Pick<T, Exclude<keyof T, K>>;

package/lib/helpers/util.js

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getParsedType = exports.ZodParsedType = exports.util = void 0;
 var util;
 (function (util) {
+    function assertEqual(_cond) { }
+    util.assertEqual = assertEqual;
     function assertNever(_x) {
         throw new Error();
     }

package/lib/index.mjs

@@ -1,5 +1,7 @@
 var util;
 (function (util) {
+    function assertEqual(_cond) { }
+    util.assertEqual = assertEqual;
     function assertNever(_x) {
         throw new Error();
     }
@@ -215,7 +217,7 @@ class ZodError extends Error {
         return this.message;
     }
     get message() {
-        return JSON.stringify(this.issues, null, 2);
+        return JSON.stringify(this.issues, jsonStringifyReplacer, 2);
     }
     get isEmpty() {
         return this.issues.length === 0;
@@ -254,7 +256,7 @@ const defaultErrorMap = (issue, _ctx) => {
             }
             break;
         case ZodIssueCode.invalid_literal:
-            message = `Invalid literal value, expected ${JSON.stringify(issue.expected)}`;
+            message = `Invalid literal value, expected ${JSON.stringify(issue.expected, jsonStringifyReplacer)}`;
             break;
         case ZodIssueCode.unrecognized_keys:
             message = `Unrecognized key(s) in object: ${util.joinValues(issue.keys, ", ")}`;
@@ -303,6 +305,8 @@ const defaultErrorMap = (issue, _ctx) => {
                 message = `String must contain ${issue.inclusive ? `at least` : `over`} ${issue.minimum} character(s)`;
             else if (issue.type === "number")
                 message = `Number must be greater than ${issue.inclusive ? `or equal to ` : ``}${issue.minimum}`;
+            else if (issue.type === "date")
+                message = `Date must be greater than ${issue.inclusive ? `or equal to ` : ``}${new Date(issue.minimum)}`;
             else
                 message = "Invalid input";
             break;
@@ -313,6 +317,8 @@ const defaultErrorMap = (issue, _ctx) => {
                 message = `String must contain ${issue.inclusive ? `at most` : `under`} ${issue.maximum} character(s)`;
             else if (issue.type === "number")
                 message = `Number must be less than ${issue.inclusive ? `or equal to ` : ``}${issue.maximum}`;
+            else if (issue.type === "date")
+                message = `Date must be smaller than ${issue.inclusive ? `or equal to ` : ``}${new Date(issue.maximum)}`;
             else
                 message = "Invalid input";
             break;
@@ -332,9 +338,12 @@ const defaultErrorMap = (issue, _ctx) => {
     return { message };
 };
 let overrideErrorMap = defaultErrorMap;
-const setErrorMap = (map) => {
+function setErrorMap(map) {
     overrideErrorMap = map;
-};
+}
+function getErrorMap() {
+    return overrideErrorMap;
+}
 
 const makeIssue = (params) => {
     const { data, path, errorMaps, issueData } = params;
@@ -366,7 +375,7 @@ function addIssueToContext(ctx, issueData) {
         errorMaps: [
             ctx.common.contextualErrorMap,
             ctx.schemaErrorMap,
-            overrideErrorMap,
+            getErrorMap(),
             defaultErrorMap,
         ].filter((x) => !!x),
     });
@@ -433,6 +442,12 @@ const isAborted = (x) => x.status === "aborted";
 const isDirty = (x) => x.status === "dirty";
 const isValid = (x) => x.status === "valid";
 const isAsync = (x) => typeof Promise !== undefined && x instanceof Promise;
+const jsonStringifyReplacer = (_, value) => {
+    if (typeof value === "bigint") {
+        return value.toString();
+    }
+    return value;
+};
 
 var errorUtil;
 (function (errorUtil) {
@@ -1220,14 +1235,88 @@ class ZodDate extends ZodType {
             });
             return INVALID;
         }
+        const status = new ParseStatus();
+        let ctx = undefined;
+        for (const check of this._def.checks) {
+            if (check.kind === "min") {
+                if (input.data.getTime() < check.value) {
+                    ctx = this._getOrReturnCtx(input, ctx);
+                    addIssueToContext(ctx, {
+                        code: ZodIssueCode.too_small,
+                        message: check.message,
+                        inclusive: true,
+                        minimum: check.value,
+                        type: "date",
+                    });
+                    status.dirty();
+                }
+            }
+            else if (check.kind === "max") {
+                if (input.data.getTime() > check.value) {
+                    ctx = this._getOrReturnCtx(input, ctx);
+                    addIssueToContext(ctx, {
+                        code: ZodIssueCode.too_big,
+                        message: check.message,
+                        inclusive: true,
+                        maximum: check.value,
+                        type: "date",
+                    });
+                    status.dirty();
+                }
+            }
+            else {
+                util.assertNever(check);
+            }
+        }
         return {
-            status: "valid",
+            status: status.value,
             value: new Date(input.data.getTime()),
         };
     }
+    _addCheck(check) {
+        return new ZodDate({
+            ...this._def,
+            checks: [...this._def.checks, check],
+        });
+    }
+    min(minDate, message) {
+        return this._addCheck({
+            kind: "min",
+            value: minDate.getTime(),
+            message: errorUtil.toString(message),
+        });
+    }
+    max(maxDate, message) {
+        return this._addCheck({
+            kind: "max",
+            value: maxDate.getTime(),
+            message: errorUtil.toString(message),
+        });
+    }
+    get minDate() {
+        let min = null;
+        for (const ch of this._def.checks) {
+            if (ch.kind === "min") {
+                if (min === null || ch.value > min)
+                    min = ch.value;
+            }
+        }
+        return min != null ? new Date(min) : null;
+    }
+    get maxDate() {
+        let max = null;
+        for (const ch of this._def.checks) {
+            if (ch.kind === "max") {
+                if (max === null || ch.value < max)
+                    max = ch.value;
+            }
+        }
+        return max != null ? new Date(max) : null;
+    }
 }
 ZodDate.create = (params) => {
     return new ZodDate({
+        checks: [],
         typeName: ZodFirstPartyTypeKind.ZodDate,
         ...processCreateParams(params),
     });
@@ -2303,7 +2392,7 @@ class ZodFunction extends ZodType {
                 errorMaps: [
                     ctx.common.contextualErrorMap,
                     ctx.schemaErrorMap,
-                    overrideErrorMap,
+                    getErrorMap(),
                     defaultErrorMap,
                 ].filter((x) => !!x),
                 issueData: {
@@ -2319,7 +2408,7 @@ class ZodFunction extends ZodType {
                 errorMaps: [
                     ctx.common.contextualErrorMap,
                     ctx.schemaErrorMap,
-                    overrideErrorMap,
+                    getErrorMap(),
                     defaultErrorMap,
                 ].filter((x) => !!x),
                 issueData: {
@@ -2883,6 +2972,7 @@ var mod = /*#__PURE__*/Object.freeze({
     isDirty: isDirty,
     isValid: isValid,
     isAsync: isAsync,
+    jsonStringifyReplacer: jsonStringifyReplacer,
     ZodType: ZodType,
     ZodString: ZodString,
     ZodNumber: ZodNumber,
@@ -2963,8 +3053,8 @@ var mod = /*#__PURE__*/Object.freeze({
     quotelessJson: quotelessJson,
     ZodError: ZodError,
     defaultErrorMap: defaultErrorMap,
-    get overrideErrorMap () { return overrideErrorMap; },
-    setErrorMap: setErrorMap
+    setErrorMap: setErrorMap,
+    getErrorMap: getErrorMap
 });
 
-export { DIRTY, EMPTY_PATH, INVALID, OK, ParseStatus, ZodType as Schema, ZodAny, ZodArray, ZodBigInt, ZodBoolean, ZodDate, ZodDefault, ZodDiscriminatedUnion, ZodEffects, ZodEnum, ZodError, ZodFirstPartyTypeKind, ZodFunction, ZodIntersection, ZodIssueCode, ZodLazy, ZodLiteral, ZodMap, ZodNaN, ZodNativeEnum, ZodNever, ZodNull, ZodNullable, ZodNumber, ZodObject, ZodOptional, ZodParsedType, ZodPromise, ZodRecord, ZodType as ZodSchema, ZodSet, ZodString, ZodEffects as ZodTransformer, ZodTuple, ZodType, ZodUndefined, ZodUnion, ZodUnknown, ZodVoid, addIssueToContext, anyType as any, arrayType as array, bigIntType as bigint, booleanType as boolean, custom, dateType as date, mod as default, defaultErrorMap, discriminatedUnionType as discriminatedUnion, effectsType as effect, enumType as enum, functionType as function, getParsedType, instanceOfType as instanceof, intersectionType as intersection, isAborted, isAsync, isDirty, isValid, late, lazyType as lazy, literalType as literal, makeIssue, mapType as map, nanType as nan, nativeEnumType as nativeEnum, neverType as never, nullType as null, nullableType as nullable, numberType as number, objectType as object, objectUtil, oboolean, onumber, optionalType as optional, ostring, overrideErrorMap, preprocessType as preprocess, promiseType as promise, quotelessJson, recordType as record, setType as set, setErrorMap, strictObjectType as strictObject, stringType as string, effectsType as transformer, tupleType as tuple, undefinedType as undefined, unionType as union, unknownType as unknown, voidType as void, mod as z };
+export { DIRTY, EMPTY_PATH, INVALID, OK, ParseStatus, ZodType as Schema, ZodAny, ZodArray, ZodBigInt, ZodBoolean, ZodDate, ZodDefault, ZodDiscriminatedUnion, ZodEffects, ZodEnum, ZodError, ZodFirstPartyTypeKind, ZodFunction, ZodIntersection, ZodIssueCode, ZodLazy, ZodLiteral, ZodMap, ZodNaN, ZodNativeEnum, ZodNever, ZodNull, ZodNullable, ZodNumber, ZodObject, ZodOptional, ZodParsedType, ZodPromise, ZodRecord, ZodType as ZodSchema, ZodSet, ZodString, ZodEffects as ZodTransformer, ZodTuple, ZodType, ZodUndefined, ZodUnion, ZodUnknown, ZodVoid, addIssueToContext, anyType as any, arrayType as array, bigIntType as bigint, booleanType as boolean, custom, dateType as date, mod as default, defaultErrorMap, discriminatedUnionType as discriminatedUnion, effectsType as effect, enumType as enum, functionType as function, getErrorMap, getParsedType, instanceOfType as instanceof, intersectionType as intersection, isAborted, isAsync, isDirty, isValid, jsonStringifyReplacer, late, lazyType as lazy, literalType as literal, makeIssue, mapType as map, nanType as nan, nativeEnumType as nativeEnum, neverType as never, nullType as null, nullableType as nullable, numberType as number, objectType as object, objectUtil, oboolean, onumber, optionalType as optional, ostring, preprocessType as preprocess, promiseType as promise, quotelessJson, recordType as record, setType as set, setErrorMap, strictObjectType as strictObject, stringType as string, effectsType as transformer, tupleType as tuple, undefinedType as undefined, unionType as union, unknownType as unknown, voidType as void, mod as z };

package/lib/index.umd.js

@@ -6,6 +6,8 @@
 
     var util;
     (function (util) {
+        function assertEqual(_cond) { }
+        util.assertEqual = assertEqual;
         function assertNever(_x) {
             throw new Error();
         }
@@ -221,7 +223,7 @@
             return this.message;
         }
         get message() {
-            return JSON.stringify(this.issues, null, 2);
+            return JSON.stringify(this.issues, jsonStringifyReplacer, 2);
         }
         get isEmpty() {
             return this.issues.length === 0;
@@ -260,7 +262,7 @@
                 }
                 break;
             case ZodIssueCode.invalid_literal:
-                message = `Invalid literal value, expected ${JSON.stringify(issue.expected)}`;
+                message = `Invalid literal value, expected ${JSON.stringify(issue.expected, jsonStringifyReplacer)}`;
                 break;
             case ZodIssueCode.unrecognized_keys:
                 message = `Unrecognized key(s) in object: ${util.joinValues(issue.keys, ", ")}`;
@@ -309,6 +311,8 @@
                     message = `String must contain ${issue.inclusive ? `at least` : `over`} ${issue.minimum} character(s)`;
                 else if (issue.type === "number")
                     message = `Number must be greater than ${issue.inclusive ? `or equal to ` : ``}${issue.minimum}`;
+                else if (issue.type === "date")
+                    message = `Date must be greater than ${issue.inclusive ? `or equal to ` : ``}${new Date(issue.minimum)}`;
                 else
                     message = "Invalid input";
                 break;
@@ -319,6 +323,8 @@
                     message = `String must contain ${issue.inclusive ? `at most` : `under`} ${issue.maximum} character(s)`;
                 else if (issue.type === "number")
                     message = `Number must be less than ${issue.inclusive ? `or equal to ` : ``}${issue.maximum}`;
+                else if (issue.type === "date")
+                    message = `Date must be smaller than ${issue.inclusive ? `or equal to ` : ``}${new Date(issue.maximum)}`;
                 else
                     message = "Invalid input";
                 break;
@@ -337,10 +343,13 @@
         }
         return { message };
     };
-    exports.overrideErrorMap = defaultErrorMap;
-    const setErrorMap = (map) => {
-        exports.overrideErrorMap = map;
-    };
+    let overrideErrorMap = defaultErrorMap;
+    function setErrorMap(map) {
+        overrideErrorMap = map;
+    }
+    function getErrorMap() {
+        return overrideErrorMap;
+    }
 
     const makeIssue = (params) => {
         const { data, path, errorMaps, issueData } = params;
@@ -372,7 +381,7 @@
             errorMaps: [
                 ctx.common.contextualErrorMap,
                 ctx.schemaErrorMap,
-                exports.overrideErrorMap,
+                getErrorMap(),
                 defaultErrorMap,
             ].filter((x) => !!x),
         });
@@ -439,6 +448,12 @@
     const isDirty = (x) => x.status === "dirty";
     const isValid = (x) => x.status === "valid";
     const isAsync = (x) => typeof Promise !== undefined && x instanceof Promise;
+    const jsonStringifyReplacer = (_, value) => {
+        if (typeof value === "bigint") {
+            return value.toString();
+        }
+        return value;
+    };
 
     var errorUtil;
     (function (errorUtil) {
@@ -1226,14 +1241,88 @@
                 });
                 return INVALID;
             }
+            const status = new ParseStatus();
+            let ctx = undefined;
+            for (const check of this._def.checks) {
+                if (check.kind === "min") {
+                    if (input.data.getTime() < check.value) {
+                        ctx = this._getOrReturnCtx(input, ctx);
+                        addIssueToContext(ctx, {
+                            code: ZodIssueCode.too_small,
+                            message: check.message,
+                            inclusive: true,
+                            minimum: check.value,
+                            type: "date",
+                        });
+                        status.dirty();
+                    }
+                }
+                else if (check.kind === "max") {
+                    if (input.data.getTime() > check.value) {
+                        ctx = this._getOrReturnCtx(input, ctx);
+                        addIssueToContext(ctx, {
+                            code: ZodIssueCode.too_big,
+                            message: check.message,
+                            inclusive: true,
+                            maximum: check.value,
+                            type: "date",
+                        });
+                        status.dirty();
+                    }
+                }
+                else {
+                    util.assertNever(check);
+                }
+            }
             return {
-                status: "valid",
+                status: status.value,
                 value: new Date(input.data.getTime()),
             };
         }
+        _addCheck(check) {
+            return new ZodDate({
+                ...this._def,
+                checks: [...this._def.checks, check],
+            });
+        }
+        min(minDate, message) {
+            return this._addCheck({
+                kind: "min",
+                value: minDate.getTime(),
+                message: errorUtil.toString(message),
+            });
+        }
+        max(maxDate, message) {
+            return this._addCheck({
+                kind: "max",
+                value: maxDate.getTime(),
+                message: errorUtil.toString(message),
+            });
+        }
+        get minDate() {
+            let min = null;
+            for (const ch of this._def.checks) {
+                if (ch.kind === "min") {
+                    if (min === null || ch.value > min)
+                        min = ch.value;
+                }
+            }
+            return min != null ? new Date(min) : null;
+        }
+        get maxDate() {
+            let max = null;
+            for (const ch of this._def.checks) {
+                if (ch.kind === "max") {
+                    if (max === null || ch.value < max)
+                        max = ch.value;
+                }
+            }
+            return max != null ? new Date(max) : null;
+        }
     }
     ZodDate.create = (params) => {
         return new ZodDate({
+            checks: [],
             typeName: exports.ZodFirstPartyTypeKind.ZodDate,
             ...processCreateParams(params),
         });
@@ -2309,7 +2398,7 @@
                     errorMaps: [
                         ctx.common.contextualErrorMap,
                         ctx.schemaErrorMap,
-                        exports.overrideErrorMap,
+                        getErrorMap(),
                         defaultErrorMap,
                     ].filter((x) => !!x),
                     issueData: {
@@ -2325,7 +2414,7 @@
                     errorMaps: [
                         ctx.common.contextualErrorMap,
                         ctx.schemaErrorMap,
-                        exports.overrideErrorMap,
+                        getErrorMap(),
                         defaultErrorMap,
                     ].filter((x) => !!x),
                     issueData: {
@@ -2889,6 +2978,7 @@
         isDirty: isDirty,
         isValid: isValid,
         isAsync: isAsync,
+        jsonStringifyReplacer: jsonStringifyReplacer,
         ZodType: ZodType,
         ZodString: ZodString,
         ZodNumber: ZodNumber,
@@ -2969,8 +3059,8 @@
         quotelessJson: quotelessJson,
         ZodError: ZodError,
         defaultErrorMap: defaultErrorMap,
-        get overrideErrorMap () { return exports.overrideErrorMap; },
-        setErrorMap: setErrorMap
+        setErrorMap: setErrorMap,
+        getErrorMap: getErrorMap
     });
 
     exports.DIRTY = DIRTY;
@@ -3029,6 +3119,7 @@
     exports.effect = effectsType;
     exports["enum"] = enumType;
     exports["function"] = functionType;
+    exports.getErrorMap = getErrorMap;
     exports.getParsedType = getParsedType;
     exports["instanceof"] = instanceOfType;
     exports.intersection = intersectionType;
@@ -3036,6 +3127,7 @@
     exports.isAsync = isAsync;
     exports.isDirty = isDirty;
     exports.isValid = isValid;
+    exports.jsonStringifyReplacer = jsonStringifyReplacer;
     exports.late = late;
     exports.lazy = lazyType;
     exports.literal = literalType;

package/lib/types.d.ts

@@ -214,11 +214,26 @@ export declare class ZodBoolean extends ZodType<boolean, ZodBooleanDef> {
     _parse(input: ParseInput): ParseReturnType<boolean>;
     static create: (params?: RawCreateParams) => ZodBoolean;
 }
+declare type ZodDateCheck = {
+    kind: "min";
+    value: number;
+    message?: string;
+} | {
+    kind: "max";
+    value: number;
+    message?: string;
+};
 export interface ZodDateDef extends ZodTypeDef {
+    checks: ZodDateCheck[];
     typeName: ZodFirstPartyTypeKind.ZodDate;
 }
 export declare class ZodDate extends ZodType<Date, ZodDateDef> {
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+    _addCheck(check: ZodDateCheck): ZodDate;
+    min(minDate: Date, message?: errorUtil.ErrMessage): ZodDate;
+    max(maxDate: Date, message?: errorUtil.ErrMessage): ZodDate;
+    get minDate(): Date | null;
+    get maxDate(): Date | null;
     static create: (params?: RawCreateParams) => ZodDate;
 }
 export interface ZodUndefinedDef extends ZodTypeDef {
@@ -518,9 +533,9 @@ export declare class ZodFunction<Args extends ZodTuple<any, any>, Returns extend
     returnType(): Returns;
     args<Items extends Parameters<typeof ZodTuple["create"]>[0]>(...items: Items): ZodFunction<ZodTuple<Items, ZodUnknown>, Returns>;
     returns<NewReturnType extends ZodType<any, any>>(returnType: NewReturnType): ZodFunction<Args, NewReturnType>;
-    implement<F extends InnerTypeOfFunction<Args, Returns>>(func: F): F;
+    implement<F extends InnerTypeOfFunction<Args, Returns>>(func: F): ReturnType<F> extends Returns["_output"] ? (...args: Args["_input"]) => ReturnType<F> : OuterTypeOfFunction<Args, Returns>;
     strictImplement(func: InnerTypeOfFunction<Args, Returns>): InnerTypeOfFunction<Args, Returns>;
-    validate: <F extends InnerTypeOfFunction<Args, Returns>>(func: F) => F;
+    validate: <F extends InnerTypeOfFunction<Args, Returns>>(func: F) => ReturnType<F> extends Returns["_output"] ? (...args: Args["_input"]) => ReturnType<F> : OuterTypeOfFunction<Args, Returns>;
     static create: <T extends ZodTuple<any, any> = ZodTuple<[], ZodUnknown>, U extends ZodTypeAny = ZodUnknown>(args?: T | undefined, returns?: U | undefined, params?: RawCreateParams) => ZodFunction<T, U>;
 }
 export interface ZodLazyDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {

package/lib/types.js

@@ -793,15 +793,89 @@ class ZodDate extends ZodType {
             });
             return parseUtil_1.INVALID;
         }
+        const status = new parseUtil_1.ParseStatus();
+        let ctx = undefined;
+        for (const check of this._def.checks) {
+            if (check.kind === "min") {
+                if (input.data.getTime() < check.value) {
+                    ctx = this._getOrReturnCtx(input, ctx);
+                    parseUtil_1.addIssueToContext(ctx, {
+                        code: ZodError_1.ZodIssueCode.too_small,
+                        message: check.message,
+                        inclusive: true,
+                        minimum: check.value,
+                        type: "date",
+                    });
+                    status.dirty();
+                }
+            }
+            else if (check.kind === "max") {
+                if (input.data.getTime() > check.value) {
+                    ctx = this._getOrReturnCtx(input, ctx);
+                    parseUtil_1.addIssueToContext(ctx, {
+                        code: ZodError_1.ZodIssueCode.too_big,
+                        message: check.message,
+                        inclusive: true,
+                        maximum: check.value,
+                        type: "date",
+                    });
+                    status.dirty();
+                }
+            }
+            else {
+                util_1.util.assertNever(check);
+            }
+        }
         return {
-            status: "valid",
+            status: status.value,
             value: new Date(input.data.getTime()),
         };
     }
+    _addCheck(check) {
+        return new ZodDate({
+            ...this._def,
+            checks: [...this._def.checks, check],
+        });
+    }
+    min(minDate, message) {
+        return this._addCheck({
+            kind: "min",
+            value: minDate.getTime(),
+            message: errorUtil_1.errorUtil.toString(message),
+        });
+    }
+    max(maxDate, message) {
+        return this._addCheck({
+            kind: "max",
+            value: maxDate.getTime(),
+            message: errorUtil_1.errorUtil.toString(message),
+        });
+    }
+    get minDate() {
+        let min = null;
+        for (const ch of this._def.checks) {
+            if (ch.kind === "min") {
+                if (min === null || ch.value > min)
+                    min = ch.value;
+            }
+        }
+        return min != null ? new Date(min) : null;
+    }
+    get maxDate() {
+        let max = null;
+        for (const ch of this._def.checks) {
+            if (ch.kind === "max") {
+                if (max === null || ch.value < max)
+                    max = ch.value;
+            }
+        }
+        return max != null ? new Date(max) : null;
+    }
 }
 exports.ZodDate = ZodDate;
 ZodDate.create = (params) => {
     return new ZodDate({
+        checks: [],
         typeName: ZodFirstPartyTypeKind.ZodDate,
         ...processCreateParams(params),
     });
@@ -1893,7 +1967,7 @@ class ZodFunction extends ZodType {
                 errorMaps: [
                     ctx.common.contextualErrorMap,
                     ctx.schemaErrorMap,
-                    ZodError_1.overrideErrorMap,
+                    ZodError_1.getErrorMap(),
                     ZodError_1.defaultErrorMap,
                 ].filter((x) => !!x),
                 issueData: {
@@ -1909,7 +1983,7 @@ class ZodFunction extends ZodType {
                 errorMaps: [
                     ctx.common.contextualErrorMap,
                     ctx.schemaErrorMap,
-                    ZodError_1.overrideErrorMap,
+                    ZodError_1.getErrorMap(),
                     ZodError_1.defaultErrorMap,
                 ].filter((x) => !!x),
                 issueData: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zod",
-  "version": "3.17.5",
+  "version": "3.17.8",
   "description": "TypeScript-first schema declaration and validation library with static type inference",
   "main": "./lib/index.js",
   "types": "./index.d.ts",