zod 3.25.13 → 3.25.15

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

@@ -0,0 +1,125 @@
+"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 fish = z.object({
+    name: z.string(),
+    age: z.number(),
+    nested: z.object({}),
+});
+(0, vitest_1.test)("pick type inference", () => {
+    const nameonlyFish = fish.pick({ name: true });
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+});
+(0, vitest_1.test)("pick parse - success", () => {
+    const nameonlyFish = fish.pick({ name: true });
+    nameonlyFish.parse({ name: "bob" });
+    // @ts-expect-error checking runtime picks `name` only.
+    const anotherNameonlyFish = fish.pick({ name: true, age: false });
+    anotherNameonlyFish.parse({ name: "bob" });
+});
+(0, vitest_1.test)("pick parse - fail", () => {
+    fish.pick({ name: true }).parse({ name: "12" });
+    fish.pick({ name: true }).parse({ name: "bob", age: 12 });
+    fish.pick({ age: true }).parse({ age: 12 });
+    const nameonlyFish = fish.pick({ name: true }).strict();
+    const bad1 = () => nameonlyFish.parse({ name: 12 });
+    const bad2 = () => nameonlyFish.parse({ name: "bob", age: 12 });
+    const bad3 = () => nameonlyFish.parse({ age: 12 });
+    // @ts-expect-error checking runtime picks `name` only.
+    const anotherNameonlyFish = fish.pick({ name: true, age: false }).strict();
+    const bad4 = () => anotherNameonlyFish.parse({ name: "bob", age: 12 });
+    (0, vitest_1.expect)(bad1).toThrow();
+    (0, vitest_1.expect)(bad2).toThrow();
+    (0, vitest_1.expect)(bad3).toThrow();
+    (0, vitest_1.expect)(bad4).toThrow();
+});
+(0, vitest_1.test)("pick - remove optional", () => {
+    const schema = z.object({ a: z.string(), b: z.string().optional() });
+    (0, vitest_1.expect)("a" in schema._zod.def.shape).toEqual(true);
+    (0, vitest_1.expect)("b" in schema._zod.def.shape).toEqual(true);
+    const picked = schema.pick({ a: true });
+    (0, vitest_1.expect)("a" in picked._zod.def.shape).toEqual(true);
+    (0, vitest_1.expect)("b" in picked._zod.def.shape).toEqual(false);
+});
+(0, vitest_1.test)("omit type inference", () => {
+    const nonameFish = fish.omit({ name: true });
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+});
+(0, vitest_1.test)("omit parse - success", () => {
+    const nonameFish = fish.omit({ name: true });
+    nonameFish.parse({ age: 12, nested: {} });
+    // @ts-expect-error checking runtime omits `name` only.
+    const anotherNonameFish = fish.omit({ name: true, age: false });
+    anotherNonameFish.parse({ age: 12, nested: {} });
+});
+(0, vitest_1.test)("omit parse - fail", () => {
+    const nonameFish = fish.omit({ name: true });
+    const bad1 = () => nonameFish.parse({ name: 12 });
+    const bad2 = () => nonameFish.parse({ age: 12 });
+    const bad3 = () => nonameFish.parse({});
+    // @ts-expect-error checking runtime omits `name` only.
+    const anotherNonameFish = fish.omit({ name: true, age: false });
+    const bad4 = () => anotherNonameFish.parse({ nested: {} });
+    (0, vitest_1.expect)(bad1).toThrow();
+    (0, vitest_1.expect)(bad2).toThrow();
+    (0, vitest_1.expect)(bad3).toThrow();
+    (0, vitest_1.expect)(bad4).toThrow();
+});
+(0, vitest_1.test)("omit - remove optional", () => {
+    const schema = z.object({ a: z.string(), b: z.string().optional() });
+    (0, vitest_1.expect)("a" in schema._zod.def.shape).toEqual(true);
+    const omitted = schema.omit({ a: true });
+    (0, vitest_1.expect)("a" in omitted._zod.def.shape).toEqual(false);
+});
+(0, vitest_1.test)("nonstrict inference", () => {
+    const laxfish = fish.pick({ name: true }).catchall(z.any());
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+});
+(0, vitest_1.test)("nonstrict parsing - pass", () => {
+    const laxfish = fish.passthrough().pick({ name: true });
+    laxfish.parse({ name: "asdf", whatever: "asdf" });
+    laxfish.parse({ name: "asdf", age: 12, nested: {} });
+});
+(0, vitest_1.test)("nonstrict parsing - fail", () => {
+    const laxfish = fish.passthrough().pick({ name: true });
+    const bad = () => laxfish.parse({ whatever: "asdf" });
+    (0, vitest_1.expect)(bad).toThrow();
+});
+(0, vitest_1.test)("pick/omit/required/partial - do not allow unknown keys", () => {
+    const schema = z.object({
+        name: z.string(),
+        age: z.number(),
+    });
+    // @ts-expect-error
+    (0, vitest_1.expect)(() => schema.pick({ $unknown: true })).toThrow();
+    // @ts-expect-error
+    (0, vitest_1.expect)(() => schema.omit({ $unknown: true })).toThrow();
+    // @ts-expect-error
+    (0, vitest_1.expect)(() => schema.required({ $unknown: true })).toThrow();
+    // @ts-expect-error
+    (0, vitest_1.expect)(() => schema.partial({ $unknown: true })).toThrow();
+});

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

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

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

@@ -0,0 +1,92 @@
+"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)("string to number pipe", () => {
+    const schema = z.string().transform(Number).pipe(z.number());
+    (0, vitest_1.expect)(schema.parse("1234")).toEqual(1234);
+});
+(0, vitest_1.test)("string to number pipe async", async () => {
+    const schema = z
+        .string()
+        .transform(async (val) => Number(val))
+        .pipe(z.number());
+    (0, vitest_1.expect)(await schema.parseAsync("1234")).toEqual(1234);
+});
+(0, vitest_1.test)("string with default fallback", () => {
+    const stringWithDefault = z
+        .pipe(z.transform((v) => (v === "none" ? undefined : v)), z.string())
+        .catch("default");
+    (0, vitest_1.expect)(stringWithDefault.parse("ok")).toBe("ok");
+    (0, vitest_1.expect)(stringWithDefault.parse(undefined)).toBe("default");
+    (0, vitest_1.expect)(stringWithDefault.parse("none")).toBe("default");
+    (0, vitest_1.expect)(stringWithDefault.parse(15)).toBe("default");
+});
+(0, vitest_1.test)("continue on non-fatal errors", () => {
+    const schema = z
+        .string()
+        .refine((c) => c === "1234", "A")
+        .transform((val) => Number(val))
+        .refine((c) => c === 1234, "B");
+    schema.parse("1234");
+    (0, vitest_1.expect)(schema.safeParse("4321")).toMatchInlineSnapshot(`
+    {
+      "error": [ZodError: [
+      {
+        "code": "custom",
+        "path": [],
+        "message": "A"
+      },
+      {
+        "code": "custom",
+        "path": [],
+        "message": "B"
+      }
+    ]],
+      "success": false,
+    }
+  `);
+});
+(0, vitest_1.test)("break on fatal errors", () => {
+    const schema = z
+        .string()
+        .refine((c) => c === "1234", { message: "A", abort: true })
+        .transform((val) => Number(val))
+        .refine((c) => c === 1234, "B");
+    schema.parse("1234");
+    (0, vitest_1.expect)(schema.safeParse("4321")).toMatchInlineSnapshot(`
+    {
+      "error": [ZodError: [
+      {
+        "code": "custom",
+        "path": [],
+        "message": "A"
+      }
+    ]],
+      "success": false,
+    }
+  `);
+});

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

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

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

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const v4_1 = require("zod/v4");
+(0, vitest_1.test)("basic prefault", () => {
+    const a = v4_1.z.prefault(v4_1.z.string().trim(), "  default  ");
+    (0, vitest_1.expect)(a).toBeInstanceOf(v4_1.z.ZodPrefault);
+    (0, vitest_1.expect)(a.parse("  asdf  ")).toEqual("asdf");
+    (0, vitest_1.expect)(a.parse(undefined)).toEqual("default");
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+});
+(0, vitest_1.test)("prefault inside object", () => {
+    // test optinality
+    const a = v4_1.z.object({
+        name: v4_1.z.string().optional(),
+        age: v4_1.z.number().default(1234),
+        email: v4_1.z.string().prefault("1234"),
+    });
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+});

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

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

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

@@ -0,0 +1,273 @@
+"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)("preprocess", () => {
+    const schema = z.preprocess((data) => [data], z.string().array());
+    const value = schema.parse("asdf");
+    (0, vitest_1.expect)(value).toEqual(["asdf"]);
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+});
+(0, vitest_1.test)("async preprocess", async () => {
+    const schema = z.preprocess(async (data) => {
+        return [data];
+    }, z.string().array());
+    const value = await schema.safeParseAsync("asdf");
+    (0, vitest_1.expect)(value.data).toEqual(["asdf"]);
+    (0, vitest_1.expect)(value).toMatchInlineSnapshot(`
+    {
+      "data": [
+        "asdf",
+      ],
+      "success": true,
+    }
+  `);
+});
+(0, vitest_1.test)("ctx.addIssue accepts string", () => {
+    const schema = z.preprocess((_, ctx) => {
+        ctx.addIssue("bad stuff");
+    }, z.string());
+    const result = schema.safeParse("asdf");
+    (0, vitest_1.expect)(result.error.issues).toHaveLength(1);
+    (0, vitest_1.expect)(result).toMatchInlineSnapshot(`
+    {
+      "error": [ZodError: [
+      {
+        "message": "bad stuff",
+        "code": "custom",
+        "path": []
+      }
+    ]],
+      "success": false,
+    }
+  `);
+});
+(0, vitest_1.test)("preprocess ctx.addIssue with parse", () => {
+    const a = z.preprocess((data, ctx) => {
+        ctx.addIssue({
+            input: data,
+            code: "custom",
+            message: `${data} is not one of our allowed strings`,
+        });
+        return data;
+    }, z.string());
+    const result = a.safeParse("asdf");
+    // expect(result.error!.toJSON()).toContain("not one of our allowed strings");
+    (0, vitest_1.expect)(result.error.issues).toHaveLength(1);
+    (0, vitest_1.expect)(result).toMatchInlineSnapshot(`
+    {
+      "error": [ZodError: [
+      {
+        "code": "custom",
+        "message": "asdf is not one of our allowed strings",
+        "path": []
+      }
+    ]],
+      "success": false,
+    }
+  `);
+});
+(0, vitest_1.test)("preprocess ctx.addIssue non-fatal by default", () => {
+    const schema = z.preprocess((data, ctx) => {
+        ctx.addIssue({
+            code: "custom",
+            message: `custom error`,
+        });
+        return data;
+    }, z.string());
+    const result = schema.safeParse(1234);
+    (0, vitest_1.expect)(result.error.issues).toHaveLength(2);
+    (0, vitest_1.expect)(result).toMatchInlineSnapshot(`
+    {
+      "error": [ZodError: [
+      {
+        "code": "custom",
+        "message": "custom error",
+        "path": []
+      },
+      {
+        "expected": "string",
+        "code": "invalid_type",
+        "path": [],
+        "message": "Invalid input: expected string, received number"
+      }
+    ]],
+      "success": false,
+    }
+  `);
+});
+(0, vitest_1.test)("preprocess ctx.addIssue fatal true", () => {
+    const schema = z.preprocess((data, ctx) => {
+        ctx.addIssue({
+            input: data,
+            code: "custom",
+            origin: "custom",
+            message: `custom error`,
+            fatal: true,
+        });
+        return data;
+    }, z.string());
+    const result = schema.safeParse(1234);
+    (0, vitest_1.expect)(result.error.issues).toHaveLength(1);
+    (0, vitest_1.expect)(result).toMatchInlineSnapshot(`
+    {
+      "error": [ZodError: [
+      {
+        "code": "custom",
+        "origin": "custom",
+        "message": "custom error",
+        "fatal": true,
+        "path": []
+      }
+    ]],
+      "success": false,
+    }
+  `);
+});
+(0, vitest_1.test)("async preprocess ctx.addIssue with parseAsync", async () => {
+    const schema = z.preprocess(async (data, ctx) => {
+        ctx.addIssue({
+            input: data,
+            code: "custom",
+            message: `${data} is not one of our allowed strings`,
+        });
+        return data;
+    }, z.string());
+    const result = await schema.safeParseAsync("asdf");
+    (0, vitest_1.expect)(result.error.issues).toHaveLength(1);
+    (0, vitest_1.expect)(result).toMatchInlineSnapshot(`
+    {
+      "error": [ZodError: [
+      {
+        "code": "custom",
+        "message": "asdf is not one of our allowed strings",
+        "path": []
+      }
+    ]],
+      "success": false,
+    }
+  `);
+});
+(0, vitest_1.test)("z.NEVER in preprocess", () => {
+    const foo = z.preprocess((val, ctx) => {
+        if (!val) {
+            ctx.addIssue({ input: val, code: "custom", message: "bad" });
+            return z.NEVER;
+        }
+        return val;
+    }, z.number());
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+    const result = foo.safeParse(undefined);
+    (0, vitest_1.expect)(result.error.issues).toHaveLength(2);
+    (0, vitest_1.expect)(result).toMatchInlineSnapshot(`
+    {
+      "error": [ZodError: [
+      {
+        "code": "custom",
+        "message": "bad",
+        "path": []
+      },
+      {
+        "expected": "number",
+        "code": "invalid_type",
+        "path": [],
+        "message": "Invalid input: expected number, received object"
+      }
+    ]],
+      "success": false,
+    }
+  `);
+});
+(0, vitest_1.test)("preprocess as the second property of object", () => {
+    const schema = z.object({
+        nonEmptyStr: z.string().min(1),
+        positiveNum: z.preprocess((v) => Number(v), z.number().positive()),
+    });
+    const result = schema.safeParse({
+        nonEmptyStr: "",
+        positiveNum: "",
+    });
+    (0, vitest_1.expect)(result.error.issues).toHaveLength(2);
+    (0, vitest_1.expect)(result).toMatchInlineSnapshot(`
+    {
+      "error": [ZodError: [
+      {
+        "origin": "string",
+        "code": "too_small",
+        "minimum": 1,
+        "path": [
+          "nonEmptyStr"
+        ],
+        "message": "Too small: expected string to have >1 characters"
+      },
+      {
+        "origin": "number",
+        "code": "too_small",
+        "minimum": 0,
+        "inclusive": false,
+        "path": [
+          "positiveNum"
+        ],
+        "message": "Too small: expected number to be >0"
+      }
+    ]],
+      "success": false,
+    }
+  `);
+});
+(0, vitest_1.test)("preprocess validates with sibling errors", () => {
+    const schema = z.object({
+        missing: z.string().refine(() => false),
+        preprocess: z.preprocess((data) => data?.trim(), z.string().regex(/ asdf/)),
+    });
+    const result = schema.safeParse({ preprocess: " asdf" });
+    (0, vitest_1.expect)(result.error.issues).toHaveLength(2);
+    (0, vitest_1.expect)(result).toMatchInlineSnapshot(`
+    {
+      "error": [ZodError: [
+      {
+        "expected": "string",
+        "code": "invalid_type",
+        "path": [
+          "missing"
+        ],
+        "message": "Invalid input: expected string, received undefined"
+      },
+      {
+        "origin": "string",
+        "code": "invalid_format",
+        "format": "regex",
+        "pattern": "/ asdf/",
+        "path": [
+          "preprocess"
+        ],
+        "message": "Invalid string: must match pattern / asdf/"
+      }
+    ]],
+      "success": false,
+    }
+  `);
+});

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

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