zod 3.25.13 → 3.25.15

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

@@ -0,0 +1,68 @@
+"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
+const file_1 = require("@web-std/file");
+const vitest_1 = require("vitest");
+const z = __importStar(require("zod/v4"));
+const minCheck = z.file().min(5);
+const maxCheck = z.file().max(8);
+const mimeCheck = z.file().mime(["text/plain", "application/json"]);
+const originalFile = global.File;
+(0, vitest_1.beforeEach)(async () => {
+    if (!globalThis.File)
+        globalThis.File = file_1.File;
+});
+(0, vitest_1.afterEach)(() => {
+    if (globalThis.File !== originalFile) {
+        globalThis.File = originalFile;
+    }
+});
+(0, vitest_1.test)("passing validations", () => {
+    minCheck.parse(new File(["12345"], "test.txt"));
+    maxCheck.parse(new File(["12345678"], "test.txt"));
+    mimeCheck.parse(new File([""], "test.csv", { type: "text/plain" }));
+    (0, vitest_1.expect)(() => mimeCheck.parse(new File([""], "test.txt"))).toThrow();
+    (0, vitest_1.expect)(() => mimeCheck.parse(new File([""], "test.txt", { type: "text/csv" }))).toThrow();
+});
+(0, vitest_1.test)("failing validations", () => {
+    (0, vitest_1.expect)(() => minCheck.parse(new File(["1234"], "test.txt"))).toThrow();
+    (0, vitest_1.expect)(() => maxCheck.parse(new File(["123456789"], "test.txt"))).toThrow();
+    (0, vitest_1.expect)(() => mimeCheck.parse(new File([""], "test.csv"))).toThrow();
+    (0, vitest_1.expect)(() => mimeCheck.parse(new File([""], "test.csv", { type: "text/csv" }))).toThrow();
+});
+// test("min max getters", () => {
+//   expect(minCheck.minSize).toEqual(5);
+//   expect(minCheck.min(10).minSize).toEqual(10);
+//   expect(maxCheck.maxSize).toEqual(8);
+//   expect(maxCheck.max(6).maxSize).toEqual(6);
+// });
+// test("accept getter", () => {
+//   expect(mimeCheck.acceptedTypes).toEqual(["text/plain", "application/json"]);
+//   expect(mimeCheck.type(["text/plain", "application/xml"]).acceptedTypes).toEqual(["text/plain"]);
+// });
+// test("invalid mime types", () => {
+//   expect(() => z.file().type([".txt"])).toThrow();
+// });

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

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

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

@@ -0,0 +1,198 @@
+"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)("first party switch", () => {
+    const myType = z.string();
+    const def = myType._zod.def;
+    switch (def.type) {
+        case "string":
+            break;
+        case "number":
+            break;
+        case "bigint":
+            break;
+        case "boolean":
+            break;
+        case "date":
+            break;
+        case "symbol":
+            break;
+        case "undefined":
+            break;
+        case "null":
+            break;
+        case "any":
+            break;
+        case "unknown":
+            break;
+        case "never":
+            break;
+        case "void":
+            break;
+        case "array":
+            break;
+        case "object":
+            break;
+        case "union":
+            break;
+        case "intersection":
+            break;
+        case "tuple":
+            break;
+        case "record":
+            break;
+        case "map":
+            break;
+        case "set":
+            break;
+        case "literal":
+            break;
+        case "enum":
+            break;
+        case "promise":
+            break;
+        case "optional":
+            break;
+        case "nonoptional":
+            break;
+        case "nullable":
+            break;
+        case "default":
+            break;
+        case "prefault":
+            break;
+        case "template_literal":
+            break;
+        case "custom":
+            break;
+        case "transform":
+            break;
+        case "readonly":
+            break;
+        case "nan":
+            break;
+        case "pipe":
+            break;
+        case "success":
+            break;
+        case "catch":
+            break;
+        case "file":
+            break;
+        case "lazy":
+            break;
+        default:
+            (0, vitest_1.expectTypeOf)(def).toEqualTypeOf();
+    }
+});
+(0, vitest_1.test)("$ZodSchemaTypes", () => {
+    const type = "string";
+    switch (type) {
+        case "string":
+            break;
+        case "number":
+            break;
+        case "int":
+            break;
+        case "bigint":
+            break;
+        case "boolean":
+            break;
+        case "date":
+            break;
+        case "symbol":
+            break;
+        case "undefined":
+            break;
+        case "null":
+            break;
+        case "any":
+            break;
+        case "unknown":
+            break;
+        case "never":
+            break;
+        case "void":
+            break;
+        case "array":
+            break;
+        case "object":
+            break;
+        case "interface":
+            break;
+        case "union":
+            break;
+        case "intersection":
+            break;
+        case "tuple":
+            break;
+        case "record":
+            break;
+        case "map":
+            break;
+        case "set":
+            break;
+        case "literal":
+            break;
+        case "enum":
+            break;
+        case "promise":
+            break;
+        case "optional":
+            break;
+        case "nonoptional":
+            break;
+        case "nullable":
+            break;
+        case "default":
+            break;
+        case "prefault":
+            break;
+        case "template_literal":
+            break;
+        case "custom":
+            break;
+        case "transform":
+            break;
+        case "readonly":
+            break;
+        case "nan":
+            break;
+        case "pipe":
+            break;
+        case "success":
+            break;
+        case "catch":
+            break;
+        case "file":
+            break;
+        case "lazy":
+            break;
+        default:
+            (0, vitest_1.expectTypeOf)(type).toEqualTypeOf();
+    }
+});

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

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

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

@@ -0,0 +1,219 @@
+"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 args1 = z.tuple([z.string()]);
+const returns1 = z.number();
+const func1 = z.function({
+    input: args1,
+    output: returns1,
+});
+(0, vitest_1.test)("function parsing", () => {
+    const parsed = func1.implement((arg) => arg.length);
+    const result = parsed("asdf");
+    (0, vitest_1.expect)(result).toBe(4);
+});
+(0, vitest_1.test)("parsed function fail 1", () => {
+    // @ts-expect-error
+    const parsed = func1.implement((x) => x);
+    (0, vitest_1.expect)(() => parsed("asdf")).toThrow();
+});
+(0, vitest_1.test)("parsed function fail 2", () => {
+    // @ts-expect-error
+    const parsed = func1.implement((x) => x);
+    (0, vitest_1.expect)(() => parsed(13)).toThrow();
+});
+(0, vitest_1.test)("function inference 1", () => {
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+});
+// test("method parsing", () => {
+//   const methodObject = z.object({
+//     property: z.number(),
+//     method: z
+//       .function()
+//       .input(z.tuple([z.string()]))
+//       .output(z.number()),
+//   });
+//   const methodInstance = {
+//     property: 3,
+//     method: function (s: string) {
+//       return s.length + this.property;
+//     },
+//   };
+//   const parsed = methodObject.parse(methodInstance);
+//   expect(parsed.method("length=8")).toBe(11); // 8 length + 3 property
+// });
+// test("async method parsing", async () => {
+//   const methodObject = z.object({
+//     property: z.number(),
+//     method: z.function().input(z.string()).output(z.promise(z.number())),
+//   });
+//   const methodInstance = {
+//     property: 3,
+//     method: async function (s: string) {
+//       return s.length + this.property;
+//     },
+//   };
+//   const parsed = methodObject.parse(methodInstance);
+//   expect(await parsed.method("length=8")).toBe(11); // 8 length + 3 property
+// });
+(0, vitest_1.test)("args method", () => {
+    const t1 = z.function();
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+    const t2args = z.tuple([z.string()], z.unknown());
+    const t2 = t1.input(t2args);
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+    const t3 = t2.output(z.boolean());
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+});
+const args2 = z.tuple([
+    z.object({
+        f1: z.number(),
+        f2: z.string().nullable(),
+        f3: z.array(z.boolean().optional()).optional(),
+    }),
+]);
+const returns2 = z.union([z.string(), z.number()]);
+const func2 = z.function({
+    input: args2,
+    output: returns2,
+});
+(0, vitest_1.test)("function inference 2", () => {
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+});
+(0, vitest_1.test)("valid function run", () => {
+    const validFunc2Instance = func2.implement((_x) => {
+        _x.f2;
+        _x.f3[0];
+        return "adf";
+    });
+    validFunc2Instance({
+        f1: 21,
+        f2: "asdf",
+        f3: [true, false],
+    });
+});
+(0, vitest_1.test)("input validation error", () => {
+    const schema = z.function({
+        input: z.tuple([z.string()]),
+        output: z.void(),
+    });
+    const fn = schema.implement(() => 1234);
+    const checker = () => fn();
+    try {
+        checker();
+    }
+    catch (e) {
+        (0, vitest_1.expect)(e.issues).toMatchInlineSnapshot(`
+      [
+        {
+          "code": "invalid_type",
+          "expected": "string",
+          "message": "Invalid input: expected string, received undefined",
+          "path": [
+            0,
+          ],
+        },
+      ]
+    `);
+    }
+});
+(0, vitest_1.test)("output validation error", () => {
+    const schema = z.function({
+        input: z.tuple([]),
+        output: z.string(),
+    });
+    const fn = schema.implement(() => 1234);
+    try {
+        fn();
+    }
+    catch (e) {
+        (0, vitest_1.expect)(e.issues).toMatchInlineSnapshot(`
+      [
+        {
+          "code": "invalid_type",
+          "expected": "string",
+          "message": "Invalid input: expected string, received number",
+          "path": [],
+        },
+      ]
+    `);
+    }
+});
+(0, vitest_1.test)("function with async refinements", async () => {
+    const schema = z
+        .function()
+        .input([z.string().refine(async (val) => val.length > 10)])
+        .output(z.promise(z.number().refine(async (val) => val > 10)));
+    const func = schema.implementAsync(async (val) => {
+        return val.length;
+    });
+    const results = [];
+    try {
+        await func("asdfasdf");
+        results.push("success");
+    }
+    catch (_) {
+        results.push("fail");
+    }
+    try {
+        await func("asdflkjasdflkjsf");
+        results.push("success");
+    }
+    catch (_) {
+        results.push("fail");
+    }
+    (0, vitest_1.expect)(results).toEqual(["fail", "success"]);
+});
+(0, vitest_1.test)("non async function with async refinements should fail", async () => {
+    const func = z
+        .function()
+        .input([z.string().refine(async (val) => val.length > 10)])
+        .output(z.number().refine(async (val) => val > 10))
+        .implement((val) => {
+        return val.length;
+    });
+    const results = [];
+    try {
+        await func("asdasdfasdffasdf");
+        results.push("success");
+    }
+    catch (_) {
+        results.push("fail");
+    }
+    (0, vitest_1.expect)(results).toEqual(["fail"]);
+});
+(0, vitest_1.test)("extra parameters with rest", () => {
+    const maxLength5 = z
+        .function()
+        .input([z.string()], z.unknown())
+        .output(z.boolean())
+        .implement((str, _arg, _qewr) => {
+        return str.length <= 5;
+    });
+    const filteredList = ["apple", "orange", "pear", "banana", "strawberry"].filter(maxLength5);
+    (0, vitest_1.expect)(filteredList.length).toEqual(2);
+});

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

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

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

@@ -0,0 +1,72 @@
+"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"));
+function nest(schema) {
+    return z.object({
+        nested: schema,
+    });
+}
+(0, vitest_1.test)("generics", () => {
+    const a = nest(z.object({ a: z.string() }));
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+    const b = nest(z.object({ a: z.string().optional() }));
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+});
+(0, vitest_1.test)("generics with optional", () => {
+    async function stripOuter(schema, data) {
+        return z
+            .object({
+            nested: schema.optional(),
+        })
+            .transform((data) => {
+            return data.nested;
+        })
+            .parse({ nested: data });
+    }
+    const result = stripOuter(z.object({ a: z.string() }), { a: "asdf" });
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+});
+// test("assignability", () => {
+//   const createSchemaAndParse = <K extends string, VS extends z.ZodString>(key: K, valueSchema: VS, data: unknown) => {
+//     const schema = z.object({
+//       [key]: valueSchema,
+//     });
+//     // return { [key]: valueSchema };
+//     const parsed = schema.parse(data);
+//     return parsed;
+//     // const inferred: z.infer<z.ZodObject<{ [k in K]: VS }>> = parsed;
+//     // return inferred;
+//   };
+//   const parsed = createSchemaAndParse("foo", z.string(), { foo: "" });
+//   expectTypeOf<typeof parsed>().toEqualTypeOf<{ foo: string }>();
+// });
+(0, vitest_1.test)("nested no undefined", () => {
+    const inner = z.string().or(z.array(z.string()));
+    const outer = z.object({ inner });
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+    (0, vitest_1.expect)(outer.safeParse({ inner: undefined }).success).toEqual(false);
+});

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

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