zod 3.25.13 → 3.25.15

package/dist/v3/tests/refine.test.js

@@ -0,0 +1,279 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// @ts-ignore TS6133
+const vitest_1 = require("vitest");
+const z = __importStar(require("zod/v3"));
+const ZodError_js_1 = require("../ZodError.js");
+const util_js_1 = require("../helpers/util.js");
+(0, vitest_1.test)("refinement", () => {
+    const obj1 = z.object({
+        first: z.string(),
+        second: z.string(),
+    });
+    const obj2 = obj1.partial().strict();
+    const obj3 = obj2.refine((data) => data.first || data.second, "Either first or second should be filled in.");
+    (0, vitest_1.expect)(obj1 === obj2).toEqual(false);
+    (0, vitest_1.expect)(obj2 === obj3).toEqual(false);
+    (0, vitest_1.expect)(() => obj1.parse({})).toThrow();
+    (0, vitest_1.expect)(() => obj2.parse({ third: "adsf" })).toThrow();
+    (0, vitest_1.expect)(() => obj3.parse({})).toThrow();
+    obj3.parse({ first: "a" });
+    obj3.parse({ second: "a" });
+    obj3.parse({ first: "a", second: "a" });
+});
+(0, vitest_1.test)("refinement 2", () => {
+    const validationSchema = z
+        .object({
+        email: z.string().email(),
+        password: z.string(),
+        confirmPassword: z.string(),
+    })
+        .refine((data) => data.password === data.confirmPassword, "Both password and confirmation must match");
+    (0, vitest_1.expect)(() => validationSchema.parse({
+        email: "aaaa@gmail.com",
+        password: "aaaaaaaa",
+        confirmPassword: "bbbbbbbb",
+    })).toThrow();
+});
+(0, vitest_1.test)("refinement type guard", () => {
+    const validationSchema = z.object({
+        a: z.string().refine((s) => s === "a"),
+    });
+    util_js_1.util.assertEqual(false);
+    util_js_1.util.assertEqual(true);
+    util_js_1.util.assertEqual(true);
+    util_js_1.util.assertEqual(false);
+});
+(0, vitest_1.test)("refinement Promise", async () => {
+    const validationSchema = z
+        .object({
+        email: z.string().email(),
+        password: z.string(),
+        confirmPassword: z.string(),
+    })
+        .refine((data) => Promise.resolve().then(() => data.password === data.confirmPassword), "Both password and confirmation must match");
+    await validationSchema.parseAsync({
+        email: "aaaa@gmail.com",
+        password: "password",
+        confirmPassword: "password",
+    });
+});
+(0, vitest_1.test)("custom path", async () => {
+    const result = await z
+        .object({
+        password: z.string(),
+        confirm: z.string(),
+    })
+        .refine((data) => data.confirm === data.password, { path: ["confirm"] })
+        .spa({ password: "asdf", confirm: "qewr" });
+    (0, vitest_1.expect)(result.success).toEqual(false);
+    if (!result.success) {
+        (0, vitest_1.expect)(result.error.issues[0].path).toEqual(["confirm"]);
+    }
+});
+(0, vitest_1.test)("use path in refinement context", async () => {
+    const noNested = z.string()._refinement((_val, ctx) => {
+        if (ctx.path.length > 0) {
+            ctx.addIssue({
+                code: ZodError_js_1.ZodIssueCode.custom,
+                message: `schema cannot be nested. path: ${ctx.path.join(".")}`,
+            });
+            return false;
+        }
+        else {
+            return true;
+        }
+    });
+    const data = z.object({
+        foo: noNested,
+    });
+    const t1 = await noNested.spa("asdf");
+    const t2 = await data.spa({ foo: "asdf" });
+    (0, vitest_1.expect)(t1.success).toBe(true);
+    (0, vitest_1.expect)(t2.success).toBe(false);
+    if (t2.success === false) {
+        (0, vitest_1.expect)(t2.error.issues[0].message).toEqual("schema cannot be nested. path: foo");
+    }
+});
+(0, vitest_1.test)("superRefine", () => {
+    const Strings = z.array(z.string()).superRefine((val, ctx) => {
+        if (val.length > 3) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.too_big,
+                maximum: 3,
+                type: "array",
+                inclusive: true,
+                exact: true,
+                message: "Too many items 😡",
+            });
+        }
+        if (val.length !== new Set(val).size) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: `No duplicates allowed.`,
+            });
+        }
+    });
+    const result = Strings.safeParse(["asfd", "asfd", "asfd", "asfd"]);
+    (0, vitest_1.expect)(result.success).toEqual(false);
+    if (!result.success)
+        (0, vitest_1.expect)(result.error.issues.length).toEqual(2);
+    Strings.parse(["asfd", "qwer"]);
+});
+(0, vitest_1.test)("superRefine async", async () => {
+    const Strings = z.array(z.string()).superRefine(async (val, ctx) => {
+        if (val.length > 3) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.too_big,
+                maximum: 3,
+                type: "array",
+                inclusive: true,
+                exact: true,
+                message: "Too many items 😡",
+            });
+        }
+        if (val.length !== new Set(val).size) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: `No duplicates allowed.`,
+            });
+        }
+    });
+    const result = await Strings.safeParseAsync(["asfd", "asfd", "asfd", "asfd"]);
+    (0, vitest_1.expect)(result.success).toEqual(false);
+    if (!result.success)
+        (0, vitest_1.expect)(result.error.issues.length).toEqual(2);
+    Strings.parseAsync(["asfd", "qwer"]);
+});
+(0, vitest_1.test)("superRefine - type narrowing", () => {
+    const schema = z
+        .object({
+        type: z.string(),
+        age: z.number(),
+    })
+        .nullable()
+        .superRefine((arg, ctx) => {
+        if (!arg) {
+            // still need to make a call to ctx.addIssue
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: "cannot be null",
+                fatal: true,
+            });
+            return false;
+        }
+        return true;
+    });
+    util_js_1.util.assertEqual(true);
+    (0, vitest_1.expect)(schema.safeParse({ type: "test", age: 0 }).success).toEqual(true);
+    (0, vitest_1.expect)(schema.safeParse(null).success).toEqual(false);
+});
+(0, vitest_1.test)("chained mixed refining types", () => {
+    const schema = z
+        .object({
+        first: z.string(),
+        second: z.number(),
+        third: z.boolean(),
+    })
+        .nullable()
+        .refine((arg) => !!arg?.third)
+        .superRefine((arg, ctx) => {
+        util_js_1.util.assertEqual(true);
+        if (arg.first !== "bob") {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: "`first` property must be `bob`",
+            });
+            return false;
+        }
+        return true;
+    })
+        .refine((arg) => {
+        util_js_1.util.assertEqual(true);
+        return arg.second === 33;
+    });
+    util_js_1.util.assertEqual(true);
+});
+(0, vitest_1.test)("get inner type", () => {
+    z.string()
+        .refine(() => true)
+        .innerType()
+        .parse("asdf");
+});
+(0, vitest_1.test)("chained refinements", () => {
+    const objectSchema = z
+        .object({
+        length: z.number(),
+        size: z.number(),
+    })
+        .refine(({ length }) => length > 5, {
+        path: ["length"],
+        message: "length greater than 5",
+    })
+        .refine(({ size }) => size > 7, {
+        path: ["size"],
+        message: "size greater than 7",
+    });
+    const r1 = objectSchema.safeParse({
+        length: 4,
+        size: 9,
+    });
+    (0, vitest_1.expect)(r1.success).toEqual(false);
+    if (!r1.success)
+        (0, vitest_1.expect)(r1.error.issues.length).toEqual(1);
+    const r2 = objectSchema.safeParse({
+        length: 4,
+        size: 3,
+    });
+    (0, vitest_1.expect)(r2.success).toEqual(false);
+    if (!r2.success)
+        (0, vitest_1.expect)(r2.error.issues.length).toEqual(2);
+});
+(0, vitest_1.test)("fatal superRefine", () => {
+    const Strings = z
+        .string()
+        .superRefine((val, ctx) => {
+        if (val === "") {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: "foo",
+                fatal: true,
+            });
+        }
+    })
+        .superRefine((val, ctx) => {
+        if (val !== " ") {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: "bar",
+            });
+        }
+    });
+    const result = Strings.safeParse("");
+    (0, vitest_1.expect)(result.success).toEqual(false);
+    if (!result.success)
+        (0, vitest_1.expect)(result.error.issues.length).toEqual(1);
+});

package/dist/v3/tests/safeparse.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/v3/tests/safeparse.test.js

@@ -0,0 +1,46 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// @ts-ignore TS6133
+const vitest_1 = require("vitest");
+const z = __importStar(require("zod/v3"));
+const stringSchema = z.string();
+(0, vitest_1.test)("safeparse fail", () => {
+    const safe = stringSchema.safeParse(12);
+    (0, vitest_1.expect)(safe.success).toEqual(false);
+    (0, vitest_1.expect)(safe.error).toBeInstanceOf(z.ZodError);
+});
+(0, vitest_1.test)("safeparse pass", () => {
+    const safe = stringSchema.safeParse("12");
+    (0, vitest_1.expect)(safe.success).toEqual(true);
+    (0, vitest_1.expect)(safe.data).toEqual("12");
+});
+(0, vitest_1.test)("safeparse unexpected error", () => {
+    (0, vitest_1.expect)(() => stringSchema
+        .refine((data) => {
+        throw new Error(data);
+    })
+        .safeParse("12")).toThrow();
+});

package/dist/v3/tests/set.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/v3/tests/set.test.js

@@ -0,0 +1,144 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// @ts-ignore TS6133
+const vitest_1 = require("vitest");
+const z = __importStar(require("zod/v3"));
+const v3_1 = require("zod/v3");
+const util_js_1 = require("../helpers/util.js");
+const stringSet = z.set(z.string());
+const minTwo = z.set(z.string()).min(2);
+const maxTwo = z.set(z.string()).max(2);
+const justTwo = z.set(z.string()).size(2);
+const nonEmpty = z.set(z.string()).nonempty();
+const nonEmptyMax = z.set(z.string()).nonempty().max(2);
+(0, vitest_1.test)("type inference", () => {
+    util_js_1.util.assertEqual(true);
+});
+(0, vitest_1.test)("valid parse", () => {
+    const result = stringSet.safeParse(new Set(["first", "second"]));
+    (0, vitest_1.expect)(result.success).toEqual(true);
+    if (result.success) {
+        (0, vitest_1.expect)(result.data.has("first")).toEqual(true);
+        (0, vitest_1.expect)(result.data.has("second")).toEqual(true);
+        (0, vitest_1.expect)(result.data.has("third")).toEqual(false);
+    }
+    (0, vitest_1.expect)(() => {
+        minTwo.parse(new Set(["a", "b"]));
+        minTwo.parse(new Set(["a", "b", "c"]));
+        maxTwo.parse(new Set(["a", "b"]));
+        maxTwo.parse(new Set(["a"]));
+        justTwo.parse(new Set(["a", "b"]));
+        nonEmpty.parse(new Set(["a"]));
+        nonEmptyMax.parse(new Set(["a"]));
+    }).not.toThrow();
+});
+(0, vitest_1.test)("valid parse async", async () => {
+    const result = await stringSet.spa(new Set(["first", "second"]));
+    (0, vitest_1.expect)(result.success).toEqual(true);
+    if (result.success) {
+        (0, vitest_1.expect)(result.data.has("first")).toEqual(true);
+        (0, vitest_1.expect)(result.data.has("second")).toEqual(true);
+        (0, vitest_1.expect)(result.data.has("third")).toEqual(false);
+    }
+    const asyncResult = await stringSet.safeParse(new Set(["first", "second"]));
+    (0, vitest_1.expect)(asyncResult.success).toEqual(true);
+    if (asyncResult.success) {
+        (0, vitest_1.expect)(asyncResult.data.has("first")).toEqual(true);
+        (0, vitest_1.expect)(asyncResult.data.has("second")).toEqual(true);
+        (0, vitest_1.expect)(asyncResult.data.has("third")).toEqual(false);
+    }
+});
+(0, vitest_1.test)("valid parse: size-related methods", () => {
+    (0, vitest_1.expect)(() => {
+        minTwo.parse(new Set(["a", "b"]));
+        minTwo.parse(new Set(["a", "b", "c"]));
+        maxTwo.parse(new Set(["a", "b"]));
+        maxTwo.parse(new Set(["a"]));
+        justTwo.parse(new Set(["a", "b"]));
+        nonEmpty.parse(new Set(["a"]));
+        nonEmptyMax.parse(new Set(["a"]));
+    }).not.toThrow();
+    const sizeZeroResult = stringSet.parse(new Set());
+    (0, vitest_1.expect)(sizeZeroResult.size).toBe(0);
+    const sizeTwoResult = minTwo.parse(new Set(["a", "b"]));
+    (0, vitest_1.expect)(sizeTwoResult.size).toBe(2);
+});
+(0, vitest_1.test)("failing when parsing empty set in nonempty ", () => {
+    const result = nonEmpty.safeParse(new Set());
+    (0, vitest_1.expect)(result.success).toEqual(false);
+    if (result.success === false) {
+        (0, vitest_1.expect)(result.error.issues.length).toEqual(1);
+        (0, vitest_1.expect)(result.error.issues[0].code).toEqual(v3_1.ZodIssueCode.too_small);
+    }
+});
+(0, vitest_1.test)("failing when set is smaller than min() ", () => {
+    const result = minTwo.safeParse(new Set(["just_one"]));
+    (0, vitest_1.expect)(result.success).toEqual(false);
+    if (result.success === false) {
+        (0, vitest_1.expect)(result.error.issues.length).toEqual(1);
+        (0, vitest_1.expect)(result.error.issues[0].code).toEqual(v3_1.ZodIssueCode.too_small);
+    }
+});
+(0, vitest_1.test)("failing when set is bigger than max() ", () => {
+    const result = maxTwo.safeParse(new Set(["one", "two", "three"]));
+    (0, vitest_1.expect)(result.success).toEqual(false);
+    if (result.success === false) {
+        (0, vitest_1.expect)(result.error.issues.length).toEqual(1);
+        (0, vitest_1.expect)(result.error.issues[0].code).toEqual(v3_1.ZodIssueCode.too_big);
+    }
+});
+(0, vitest_1.test)("doesn’t throw when an empty set is given", () => {
+    const result = stringSet.safeParse(new Set([]));
+    (0, vitest_1.expect)(result.success).toEqual(true);
+});
+(0, vitest_1.test)("throws when a Map is given", () => {
+    const result = stringSet.safeParse(new Map([]));
+    (0, vitest_1.expect)(result.success).toEqual(false);
+    if (result.success === false) {
+        (0, vitest_1.expect)(result.error.issues.length).toEqual(1);
+        (0, vitest_1.expect)(result.error.issues[0].code).toEqual(v3_1.ZodIssueCode.invalid_type);
+    }
+});
+(0, vitest_1.test)("throws when the given set has invalid input", () => {
+    const result = stringSet.safeParse(new Set([Symbol()]));
+    (0, vitest_1.expect)(result.success).toEqual(false);
+    if (result.success === false) {
+        (0, vitest_1.expect)(result.error.issues.length).toEqual(1);
+        (0, vitest_1.expect)(result.error.issues[0].code).toEqual(v3_1.ZodIssueCode.invalid_type);
+        (0, vitest_1.expect)(result.error.issues[0].path).toEqual([0]);
+    }
+});
+(0, vitest_1.test)("throws when the given set has multiple invalid entries", () => {
+    const result = stringSet.safeParse(new Set([1, 2]));
+    (0, vitest_1.expect)(result.success).toEqual(false);
+    if (result.success === false) {
+        (0, vitest_1.expect)(result.error.issues.length).toEqual(2);
+        (0, vitest_1.expect)(result.error.issues[0].code).toEqual(v3_1.ZodIssueCode.invalid_type);
+        (0, vitest_1.expect)(result.error.issues[0].path).toEqual([0]);
+        (0, vitest_1.expect)(result.error.issues[1].code).toEqual(v3_1.ZodIssueCode.invalid_type);
+        (0, vitest_1.expect)(result.error.issues[1].path).toEqual([1]);
+    }
+});

package/dist/v3/tests/standard-schema.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/v3/tests/standard-schema.test.js

@@ -0,0 +1,102 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// import type { StandardSchemaV1 } from "@standard-schema/spec";
+// @ts-ignore TS6133
+const vitest_1 = require("vitest");
+const z = __importStar(require("zod/v3"));
+const util_js_1 = require("../helpers/util.js");
+(0, vitest_1.test)("assignability", () => {
+    const _s1 = z.string();
+    const _s2 = z.string();
+    const _s3 = z.string();
+    const _s4 = z.string();
+    [_s1, _s2, _s3, _s4];
+});
+(0, vitest_1.test)("type inference", () => {
+    const stringToNumber = z.string().transform((x) => x.length);
+    util_js_1.util.assertEqual(true);
+    util_js_1.util.assertEqual(true);
+});
+(0, vitest_1.test)("valid parse", () => {
+    const schema = z.string();
+    const result = schema["~standard"].validate("hello");
+    if (result instanceof Promise) {
+        throw new Error("Expected sync result");
+    }
+    (0, vitest_1.expect)(result.issues).toEqual(undefined);
+    if (result.issues) {
+        throw new Error("Expected no issues");
+    }
+    else {
+        (0, vitest_1.expect)(result.value).toEqual("hello");
+    }
+});
+(0, vitest_1.test)("invalid parse", () => {
+    const schema = z.string();
+    const result = schema["~standard"].validate(1234);
+    if (result instanceof Promise) {
+        throw new Error("Expected sync result");
+    }
+    (0, vitest_1.expect)(result.issues).toBeDefined();
+    if (!result.issues) {
+        throw new Error("Expected issues");
+    }
+    (0, vitest_1.expect)(result.issues.length).toEqual(1);
+    (0, vitest_1.expect)(result.issues[0].path).toEqual([]);
+});
+(0, vitest_1.test)("valid parse async", async () => {
+    const schema = z.string().refine(async () => true);
+    const _result = schema["~standard"].validate("hello");
+    if (_result instanceof Promise) {
+        const result = await _result;
+        (0, vitest_1.expect)(result.issues).toEqual(undefined);
+        if (result.issues) {
+            throw new Error("Expected no issues");
+        }
+        else {
+            (0, vitest_1.expect)(result.value).toEqual("hello");
+        }
+    }
+    else {
+        throw new Error("Expected async result");
+    }
+});
+(0, vitest_1.test)("invalid parse async", async () => {
+    const schema = z.string().refine(async () => false);
+    const _result = schema["~standard"].validate("hello");
+    if (_result instanceof Promise) {
+        const result = await _result;
+        (0, vitest_1.expect)(result.issues).toBeDefined();
+        if (!result.issues) {
+            throw new Error("Expected issues");
+        }
+        (0, vitest_1.expect)(result.issues.length).toEqual(1);
+        (0, vitest_1.expect)(result.issues[0].path).toEqual([]);
+    }
+    else {
+        throw new Error("Expected async result");
+    }
+});

package/dist/v3/tests/string.test.d.ts

@@ -0,0 +1 @@
+export {};