zod 3.25.13 → 3.25.15

package/dist/v4/classic/tests/json.test.d.ts

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

package/dist/v4/classic/tests/json.test.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+// import * as z from "zod/v4";
+(0, vitest_1.test)(() => { });
+// test("overload types", () => {
+//   const schema = z.string().json();
+//   util.assertEqual<typeof schema, z.ZodString>(true);
+//   const schema2 = z.string().json(z.number());
+//   util.assertEqual<typeof schema2, z.ZodPipe<z.ZodTransform<any, string>, z.ZodNumber>>(true);
+//   const r2 = schema2.parse("12");
+//   util.assertEqual<number, typeof r2>(true);
+// });
+// test("parse string to json", async () => {
+//   const Env = z.object({
+//     myJsonConfig: z.string().jsonString(z.object({ foo: z.number() })),
+//     someOtherValue: z.string(),
+//   });
+//   expect(
+//     Env.parse({
+//       myJsonConfig: '{ "foo": 123 }',
+//       someOtherValue: "abc",
+//     })
+//   ).toEqual({
+//     myJsonConfig: { foo: 123 },
+//     someOtherValue: "abc",
+//   });
+//   const invalidValues = Env.safeParse({
+//     myJsonConfig: '{"foo": "not a number!"}',
+//     someOtherValue: null,
+//   });
+//   expect(JSON.parse(JSON.stringify(invalidValues))).toEqual({
+//     success: false,
+//     error: {
+//       name: "ZodError",
+//       issues: [
+//         {
+//           code: "invalid_type",
+//           expected: "number",
+//           input: "not a number!",
+//           received: "string",
+//           path: ["myJsonConfig", "foo"],
+//           message: "Expected number, received string",
+//         },
+//         {
+//           code: "invalid_type",
+//           expected: "string",
+//           input: null,
+//           received: "null",
+//           path: ["someOtherValue"],
+//           message: "Expected string, received null",
+//         },
+//       ],
+//     },
+//   });
+//   const invalidJsonSyntax = Env.safeParse({
+//     myJsonConfig: "This is not valid json",
+//     someOtherValue: null,
+//   });
+//   expect(JSON.parse(JSON.stringify(invalidJsonSyntax))).toMatchObject({
+//     success: false,
+//     error: {
+//       name: "ZodError",
+//       issues: [
+//         {
+//           code: "invalid_string",
+//           input: {
+//             _def: {
+//               catchall: {
+//                 _def: {
+//                   typeName: "ZodNever",
+//                 },
+//               },
+//               typeName: "ZodObject",
+//               unknownKeys: "strip",
+//             },
+//           },
+//           validation: "json",
+//           message: "Invalid json",
+//           path: ["myJsonConfig"],
+//         },
+//         {
+//           code: "invalid_type",
+//           expected: "string",
+//           input: null,
+//           received: "null",
+//           path: ["someOtherValue"],
+//           message: "Expected string, received null",
+//         },
+//       ],
+//     },
+//   });
+// });
+// test("no argument", () => {
+//   const schema = z.string().json();
+//   util.assertEqual<typeof schema, z.ZodString>(true);
+//   z.string().json().parse(`{}`);
+//   z.string().json().parse(`null`);
+//   z.string().json().parse(`12`);
+//   z.string().json().parse(`{ "test": "test"}`);
+//   expect(() => z.string().json().parse(`asdf`)).toThrow();
+//   expect(() => z.string().json().parse(`{ "test": undefined }`)).toThrow();
+//   expect(() => z.string().json().parse(`{ "test": 12n }`)).toThrow();
+//   expect(() => z.string().json().parse(`{ test: "test" }`)).toThrow();
+// });

package/dist/v4/classic/tests/lazy.test.d.ts

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

package/dist/v4/classic/tests/lazy.test.js

@@ -0,0 +1,185 @@
+"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 });
+const vitest_1 = require("vitest");
+const z = __importStar(require("zod/v4"));
+(0, vitest_1.test)("opt passthrough", () => {
+    const object = z.object({
+        a: z.lazy(() => z.string()),
+        b: z.lazy(() => z.string().optional()),
+        c: z.lazy(() => z.string().default("default")),
+    });
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+    const result = object.parse({
+        a: "hello",
+        b: undefined,
+    }, { jitless: true });
+    (0, vitest_1.expect)(result).toEqual({
+        a: "hello",
+        // b: undefined,
+        c: "default",
+    });
+    (0, vitest_1.expect)(z.lazy(() => z.string())._zod.optin).toEqual(undefined);
+    (0, vitest_1.expect)(z.lazy(() => z.string())._zod.optout).toEqual(undefined);
+    (0, vitest_1.expect)(z.lazy(() => z.string().optional())._zod.optin).toEqual("optional");
+    (0, vitest_1.expect)(z.lazy(() => z.string().optional())._zod.optout).toEqual("optional");
+    (0, vitest_1.expect)(z.lazy(() => z.string().default("asdf"))._zod.optin).toEqual("optional");
+    (0, vitest_1.expect)(z.lazy(() => z.string().default("asdf"))._zod.optout).toEqual(undefined);
+});
+//////////////   LAZY   //////////////
+(0, vitest_1.test)("schema getter", () => {
+    z.lazy(() => z.string()).parse("asdf");
+});
+(0, vitest_1.test)("lazy proxy", () => {
+    const schema = z.lazy(() => z.string())._zod.innerType.min(6);
+    schema.parse("123456");
+    (0, vitest_1.expect)(schema.safeParse("12345").success).toBe(false);
+});
+const testCategory = {
+    name: "I",
+    subcategories: [
+        {
+            name: "A",
+            subcategories: [
+                {
+                    name: "1",
+                    subcategories: [
+                        {
+                            name: "a",
+                            subcategories: [],
+                        },
+                    ],
+                },
+            ],
+        },
+    ],
+};
+(0, vitest_1.test)("recursion with z.lazy", () => {
+    const Category = z.lazy(() => z.object({
+        name: z.string(),
+        subcategories: z.array(Category),
+    }));
+    Category.parse(testCategory);
+});
+const linkedListExample = {
+    value: 1,
+    next: {
+        value: 2,
+        next: {
+            value: 3,
+            next: {
+                value: 4,
+                next: null,
+            },
+        },
+    },
+};
+(0, vitest_1.test)("recursive union wit z.lazy", () => {
+    const LinkedListSchema = z.lazy(() => z.union([
+        z.null(),
+        z.object({
+            value: z.number(),
+            next: LinkedListSchema,
+        }),
+    ]));
+    LinkedListSchema.parse(linkedListExample);
+});
+(0, vitest_1.test)("mutual recursion with lazy", () => {
+    const Alazy = z.lazy(() => z.object({
+        val: z.number(),
+        b: Blazy,
+    }));
+    const Blazy = z.lazy(() => z.object({
+        val: z.number(),
+        a: Alazy.optional(),
+    }));
+    const testData = {
+        val: 1,
+        b: {
+            val: 5,
+            a: {
+                val: 3,
+                b: {
+                    val: 4,
+                    a: {
+                        val: 2,
+                        b: {
+                            val: 1,
+                        },
+                    },
+                },
+            },
+        },
+    };
+    Alazy.parse(testData);
+    Blazy.parse(testData.b);
+    (0, vitest_1.expect)(() => Alazy.parse({ val: "asdf" })).toThrow();
+});
+// TODO
+(0, vitest_1.test)("mutual recursion with cyclical data", () => {
+    const a = { val: 1 };
+    const b = { val: 2 };
+    a.b = b;
+    b.a = a;
+});
+(0, vitest_1.test)("complicated self-recursion", () => {
+    const Category = z.object({
+        name: z.string(),
+        age: z.optional(z.number()),
+        get nullself() {
+            return Category.nullable();
+        },
+        get optself() {
+            return Category.optional();
+        },
+        get self() {
+            return Category;
+        },
+        get subcategories() {
+            return z.array(Category);
+        },
+        nested: z.object({
+            get sub() {
+                return Category;
+            },
+        }),
+    });
+});
+(0, vitest_1.test)("lazy initialization", () => {
+    const a = z.lazy(() => a).optional();
+    const b = z.lazy(() => b).nullable();
+    const c = z.lazy(() => c).default({});
+    const d = z.lazy(() => d).prefault({});
+    const e = z.lazy(() => e).nonoptional();
+    const f = z.lazy(() => f).catch({});
+    const g = z.lazy(() => z.object({ g })).readonly();
+    const baseCategorySchema = z.object({
+        name: z.string(),
+    });
+    const categorySchema = baseCategorySchema.extend({
+        subcategories: z.lazy(() => categorySchema.array()),
+    });
+});

package/dist/v4/classic/tests/literal.test.d.ts

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

package/dist/v4/classic/tests/literal.test.js

@@ -0,0 +1,94 @@
+"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 });
+const vitest_1 = require("vitest");
+const z = __importStar(require("zod/v4"));
+const literalTuna = z.literal("tuna");
+const literalTunaCustomMessage = z.literal("tuna", {
+    message: "That's not a tuna",
+});
+const literalFortyTwo = z.literal(42);
+const literalTrue = z.literal(true);
+(0, vitest_1.test)("passing validations", () => {
+    literalTuna.parse("tuna");
+    literalFortyTwo.parse(42);
+    literalTrue.parse(true);
+});
+(0, vitest_1.test)("failing validations", () => {
+    (0, vitest_1.expect)(() => literalTuna.parse("shark")).toThrow();
+    (0, vitest_1.expect)(() => literalFortyTwo.parse(43)).toThrow();
+    (0, vitest_1.expect)(() => literalTrue.parse(false)).toThrow();
+});
+(0, vitest_1.test)("invalid_literal should have `input` field with data", () => {
+    const data = "shark";
+    const result = literalTuna.safeParse(data);
+    const issue = result.error.issues[0];
+    (0, vitest_1.expect)(issue.code).toBe("invalid_value");
+    (0, vitest_1.expect)(issue).toMatchInlineSnapshot(`
+    {
+      "code": "invalid_value",
+      "message": "Invalid input: expected "tuna"",
+      "path": [],
+      "values": [
+        "tuna",
+      ],
+    }
+  `);
+});
+(0, vitest_1.test)("invalid_literal should return default message", () => {
+    const data = "shark";
+    const result = literalTuna.safeParse(data);
+    const issue = result.error.issues[0];
+    (0, vitest_1.expect)(issue.message).toEqual(`Invalid input: expected \"tuna\"`);
+});
+(0, vitest_1.test)("invalid_literal should return custom message", () => {
+    const data = "shark";
+    const result = literalTunaCustomMessage.safeParse(data);
+    const issue = result.error.issues[0];
+    (0, vitest_1.expect)(issue.message).toEqual(`That's not a tuna`);
+});
+(0, vitest_1.test)("literal default error message", () => {
+    const result = z.literal("Tuna").safeParse("Trout");
+    (0, vitest_1.expect)(result.success).toEqual(false);
+    (0, vitest_1.expect)(result.error.issues.length).toEqual(1);
+    (0, vitest_1.expect)(result.error).toMatchInlineSnapshot(`
+    [ZodError: [
+      {
+        "code": "invalid_value",
+        "values": [
+          "Tuna"
+        ],
+        "path": [],
+        "message": "Invalid input: expected \\"Tuna\\""
+      }
+    ]]
+  `);
+});
+(0, vitest_1.test)("literal bigint default error message", () => {
+    const result = z.literal(BigInt(12)).safeParse(BigInt(13));
+    (0, vitest_1.expect)(result.success).toBe(false);
+    (0, vitest_1.expect)(result.error.issues.length).toEqual(1);
+    (0, vitest_1.expect)(result.error.issues[0].message).toEqual(`Invalid input: expected 12n`);
+});

package/dist/v4/classic/tests/map.test.d.ts

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

package/dist/v4/classic/tests/map.test.js

@@ -0,0 +1,193 @@
+"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 });
+const vitest_1 = require("vitest");
+const z = __importStar(require("zod/v4"));
+const stringMap = z.map(z.string(), z.string());
+(0, vitest_1.test)("type inference", () => {
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+});
+(0, vitest_1.test)("valid parse", () => {
+    const result = stringMap.safeParse(new Map([
+        ["first", "foo"],
+        ["second", "bar"],
+    ]));
+    (0, vitest_1.expect)(result.success).toEqual(true);
+    (0, vitest_1.expect)(result.data).toMatchInlineSnapshot(`
+    Map {
+      "first" => "foo",
+      "second" => "bar",
+    }
+  `);
+});
+(0, vitest_1.test)("valid parse async", async () => {
+    const asyncMap = z.map(z.string().refine(async () => false, "bad key"), z.string().refine(async () => false, "bad value"));
+    const result = await asyncMap.safeParseAsync(new Map([["first", "foo"]]));
+    (0, vitest_1.expect)(result.success).toEqual(false);
+    (0, vitest_1.expect)(result.error).toMatchInlineSnapshot(`
+    [ZodError: [
+      {
+        "code": "custom",
+        "path": [
+          "first"
+        ],
+        "message": "bad key"
+      },
+      {
+        "code": "custom",
+        "path": [
+          "first"
+        ],
+        "message": "bad value"
+      }
+    ]]
+  `);
+});
+(0, vitest_1.test)("throws when a Set is given", () => {
+    const result = stringMap.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("invalid_type");
+    }
+});
+(0, vitest_1.test)("throws when the given map has invalid key and invalid input", () => {
+    const result = stringMap.safeParse(new Map([[42, Symbol()]]));
+    (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).toMatchInlineSnapshot(`
+      [ZodError: [
+        {
+          "expected": "string",
+          "code": "invalid_type",
+          "path": [
+            42
+          ],
+          "message": "Invalid input: expected string, received number"
+        },
+        {
+          "expected": "string",
+          "code": "invalid_type",
+          "path": [
+            42
+          ],
+          "message": "Invalid input: expected string, received symbol"
+        }
+      ]]
+    `);
+    }
+});
+(0, vitest_1.test)("throws when the given map has multiple invalid entries", () => {
+    // const result = stringMap.safeParse(new Map([[42, Symbol()]]));
+    const result = stringMap.safeParse(new Map([
+        [1, "foo"],
+        ["bar", 2],
+    ]));
+    // const result = stringMap.safeParse(new Map([[42, Symbol()]]));
+    (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).toMatchInlineSnapshot(`
+      [
+        {
+          "code": "invalid_type",
+          "expected": "string",
+          "message": "Invalid input: expected string, received number",
+          "path": [
+            1,
+          ],
+        },
+        {
+          "code": "invalid_type",
+          "expected": "string",
+          "message": "Invalid input: expected string, received number",
+          "path": [
+            "bar",
+          ],
+        },
+      ]
+    `);
+    }
+});
+(0, vitest_1.test)("dirty", async () => {
+    const map = z.map(z.string().refine((val) => val === val.toUpperCase(), {
+        message: "Keys must be uppercase",
+    }), z.string());
+    const result = await map.spa(new Map([
+        ["first", "foo"],
+        ["second", "bar"],
+    ]));
+    (0, vitest_1.expect)(result.success).toEqual(false);
+    if (!result.success) {
+        (0, vitest_1.expect)(result.error.issues.length).toEqual(2);
+        (0, vitest_1.expect)(result.error).toMatchInlineSnapshot(`
+      [ZodError: [
+        {
+          "code": "custom",
+          "path": [
+            "first"
+          ],
+          "message": "Keys must be uppercase"
+        },
+        {
+          "code": "custom",
+          "path": [
+            "second"
+          ],
+          "message": "Keys must be uppercase"
+        }
+      ]]
+    `);
+    }
+});
+(0, vitest_1.test)("map with object keys", () => {
+    const map = z.map(z.object({
+        name: z.string(),
+        age: z.number(),
+    }), z.string());
+    const data = new Map([
+        [{ name: "John", age: 30 }, "foo"],
+        [{ name: "Jane", age: 25 }, "bar"],
+    ]);
+    const result = map.safeParse(data);
+    (0, vitest_1.expect)(result.success).toEqual(true);
+    (0, vitest_1.expect)(result.data).toEqual(data);
+    const badData = new Map([["bad", "foo"]]);
+    const badResult = map.safeParse(badData);
+    (0, vitest_1.expect)(badResult.success).toEqual(false);
+    (0, vitest_1.expect)(badResult.error).toMatchInlineSnapshot(`
+    [ZodError: [
+      {
+        "expected": "object",
+        "code": "invalid_type",
+        "path": [
+          "bad"
+        ],
+        "message": "Invalid input: expected object, received string"
+      }
+    ]]
+  `);
+});

package/dist/v4/classic/tests/nan.test.d.ts

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

package/dist/v4/classic/tests/nan.test.js

@@ -0,0 +1,42 @@
+"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 });
+const vitest_1 = require("vitest");
+const z = __importStar(require("zod/v4"));
+const schema = z.nan();
+(0, vitest_1.test)("passing validations", () => {
+    schema.parse(Number.NaN);
+    schema.parse(Number("Not a number"));
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+});
+(0, vitest_1.test)("failing validations", () => {
+    (0, vitest_1.expect)(() => schema.parse(5)).toThrow();
+    (0, vitest_1.expect)(() => schema.parse("John")).toThrow();
+    (0, vitest_1.expect)(() => schema.parse(true)).toThrow();
+    (0, vitest_1.expect)(() => schema.parse(null)).toThrow();
+    (0, vitest_1.expect)(() => schema.parse(undefined)).toThrow();
+    (0, vitest_1.expect)(() => schema.parse({})).toThrow();
+    (0, vitest_1.expect)(() => schema.parse([])).toThrow();
+});

package/dist/v4/classic/tests/nested-refine.test.d.ts

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