zod 3.25.13 → 3.25.15

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

@@ -0,0 +1,236 @@
+"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 util_js_1 = require("../helpers/util.js");
+const args1 = z.tuple([z.string()]);
+const returns1 = z.number();
+const func1 = z.function(args1, returns1);
+(0, vitest_1.test)("function parsing", () => {
+    const parsed = func1.parse((arg) => arg.length);
+    parsed("asdf");
+});
+(0, vitest_1.test)("parsed function fail 1", () => {
+    const parsed = func1.parse((x) => x);
+    (0, vitest_1.expect)(() => parsed("asdf")).toThrow();
+});
+(0, vitest_1.test)("parsed function fail 2", () => {
+    const parsed = func1.parse((x) => x);
+    (0, vitest_1.expect)(() => parsed(13)).toThrow();
+});
+(0, vitest_1.test)("function inference 1", () => {
+    util_js_1.util.assertEqual(true);
+});
+(0, vitest_1.test)("method parsing", () => {
+    const methodObject = z.object({
+        property: z.number(),
+        method: z.function().args(z.string()).returns(z.number()),
+    });
+    const methodInstance = {
+        property: 3,
+        method: function (s) {
+            return s.length + this.property;
+        },
+    };
+    const parsed = methodObject.parse(methodInstance);
+    (0, vitest_1.expect)(parsed.method("length=8")).toBe(11); // 8 length + 3 property
+});
+(0, vitest_1.test)("async method parsing", async () => {
+    const methodObject = z.object({
+        property: z.number(),
+        method: z.function().args(z.string()).returns(z.promise(z.number())),
+    });
+    const methodInstance = {
+        property: 3,
+        method: async function (s) {
+            return s.length + this.property;
+        },
+    };
+    const parsed = methodObject.parse(methodInstance);
+    (0, vitest_1.expect)(await parsed.method("length=8")).toBe(11); // 8 length + 3 property
+});
+(0, vitest_1.test)("args method", () => {
+    const t1 = z.function();
+    util_js_1.util.assertEqual(true);
+    const t2 = t1.args(z.string());
+    util_js_1.util.assertEqual(true);
+    const t3 = t2.returns(z.boolean());
+    util_js_1.util.assertEqual(true);
+});
+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(args2, returns2);
+(0, vitest_1.test)("function inference 2", () => {
+    util_js_1.util.assertEqual(true);
+});
+(0, vitest_1.test)("valid function run", () => {
+    const validFunc2Instance = func2.validate((_x) => {
+        return "adf";
+    });
+    const checker = () => {
+        validFunc2Instance({
+            f1: 21,
+            f2: "asdf",
+            f3: [true, false],
+        });
+    };
+    checker();
+});
+(0, vitest_1.test)("input validation error", () => {
+    const invalidFuncInstance = func2.validate((_x) => {
+        return "adf";
+    });
+    const checker = () => {
+        invalidFuncInstance("Invalid_input");
+    };
+    (0, vitest_1.expect)(checker).toThrow();
+});
+(0, vitest_1.test)("output validation error", () => {
+    const invalidFuncInstance = func2.validate((_x) => {
+        return ["this", "is", "not", "valid", "output"];
+    });
+    const checker = () => {
+        invalidFuncInstance({
+            f1: 21,
+            f2: "asdf",
+            f3: [true, false],
+        });
+    };
+    (0, vitest_1.expect)(checker).toThrow();
+});
+z.function(z.tuple([z.string()])).args()._def.args;
+(0, vitest_1.test)("special function error codes", () => {
+    const checker = z.function(z.tuple([z.string()]), z.boolean()).implement((arg) => {
+        return arg.length;
+    });
+    try {
+        checker("12");
+    }
+    catch (err) {
+        const zerr = err;
+        const first = zerr.issues[0];
+        if (first.code !== z.ZodIssueCode.invalid_return_type)
+            throw new Error();
+        (0, vitest_1.expect)(first.returnTypeError).toBeInstanceOf(z.ZodError);
+    }
+    try {
+        checker(12);
+    }
+    catch (err) {
+        const zerr = err;
+        const first = zerr.issues[0];
+        if (first.code !== z.ZodIssueCode.invalid_arguments)
+            throw new Error();
+        (0, vitest_1.expect)(first.argumentsError).toBeInstanceOf(z.ZodError);
+    }
+});
+(0, vitest_1.test)("function with async refinements", async () => {
+    const func = z
+        .function()
+        .args(z.string().refine(async (val) => val.length > 10))
+        .returns(z.promise(z.number().refine(async (val) => val > 10)))
+        .implement(async (val) => {
+        return val.length;
+    });
+    const results = [];
+    try {
+        await func("asdfasdf");
+        results.push("success");
+    }
+    catch (_err) {
+        results.push("fail");
+    }
+    try {
+        await func("asdflkjasdflkjsf");
+        results.push("success");
+    }
+    catch (_err) {
+        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()
+        .args(z.string().refine(async (val) => val.length > 10))
+        .returns(z.number().refine(async (val) => val > 10))
+        .implement((val) => {
+        return val.length;
+    });
+    const results = [];
+    try {
+        await func("asdasdfasdffasdf");
+        results.push("success");
+    }
+    catch (_err) {
+        results.push("fail");
+    }
+    (0, vitest_1.expect)(results).toEqual(["fail"]);
+});
+(0, vitest_1.test)("allow extra parameters", () => {
+    const maxLength5 = z
+        .function()
+        .args(z.string())
+        .returns(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);
+});
+(0, vitest_1.test)("params and returnType getters", () => {
+    const func = z.function().args(z.string()).returns(z.string());
+    func.parameters().items[0].parse("asdf");
+    func.returnType().parse("asdf");
+});
+(0, vitest_1.test)("inference with transforms", () => {
+    const funcSchema = z
+        .function()
+        .args(z.string().transform((val) => val.length))
+        .returns(z.object({ val: z.number() }));
+    const myFunc = funcSchema.implement((val) => {
+        return { val, extra: "stuff" };
+    });
+    myFunc("asdf");
+    util_js_1.util.assertEqual(true);
+});
+(0, vitest_1.test)("fallback to OuterTypeOfFunction", () => {
+    const funcSchema = z
+        .function()
+        .args(z.string().transform((val) => val.length))
+        .returns(z.object({ arg: z.number() }).transform((val) => val.arg));
+    const myFunc = funcSchema.implement((val) => {
+        return { arg: val, arg2: false };
+    });
+    util_js_1.util.assertEqual(true);
+});

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

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

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

@@ -0,0 +1,67 @@
+"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 util_js_1 = require("../helpers/util.js");
+(0, vitest_1.test)("generics", () => {
+    async function stripOuter(schema, data) {
+        return z
+            .object({
+            nested: schema, // as z.ZodTypeAny,
+        })
+            .transform((data) => {
+            return data.nested;
+        })
+            .parse({ nested: data });
+    }
+    const result = stripOuter(z.object({ a: z.string() }), { a: "asdf" });
+    util_js_1.util.assertEqual(true);
+});
+// test("assignability", () => {
+//   const createSchemaAndParse = <K extends string, VS extends z.ZodString>(
+//     key: K,
+//     valueSchema: VS,
+//     data: unknown
+//   ) => {
+//     const schema = z.object({
+//       [key]: valueSchema,
+//     } as { [k in K]: VS });
+//     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: "" });
+//   util.assertEqual<typeof parsed, { foo: string }>(true);
+// });
+(0, vitest_1.test)("nested no undefined", () => {
+    const inner = z.string().or(z.array(z.string()));
+    const outer = z.object({ inner });
+    z.util.assertEqual(true);
+    (0, vitest_1.expect)(outer.safeParse({ inner: undefined }).success).toEqual(false);
+});

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

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

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

@@ -0,0 +1,60 @@
+"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 util_js_1 = require("../helpers/util.js");
+(0, vitest_1.test)("instanceof", async () => {
+    class Test {
+    }
+    class Subtest extends Test {
+    }
+    class AbstractBar {
+        constructor(val) {
+            this.val = val;
+        }
+    }
+    class Bar extends AbstractBar {
+    }
+    const TestSchema = z.instanceof(Test);
+    const SubtestSchema = z.instanceof(Subtest);
+    const AbstractSchema = z.instanceof(AbstractBar);
+    const BarSchema = z.instanceof(Bar);
+    TestSchema.parse(new Test());
+    TestSchema.parse(new Subtest());
+    SubtestSchema.parse(new Subtest());
+    AbstractSchema.parse(new Bar("asdf"));
+    const bar = BarSchema.parse(new Bar("asdf"));
+    (0, vitest_1.expect)(bar.val).toEqual("asdf");
+    await (0, vitest_1.expect)(() => SubtestSchema.parse(new Test())).toThrow(/Input not instance of Subtest/);
+    await (0, vitest_1.expect)(() => TestSchema.parse(12)).toThrow(/Input not instance of Test/);
+    util_js_1.util.assertEqual(true);
+});
+(0, vitest_1.test)("instanceof fatal", () => {
+    const schema = z.instanceof(Date).refine((d) => d.toString());
+    const res = schema.safeParse(null);
+    (0, vitest_1.expect)(res.success).toBe(false);
+});

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

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

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

@@ -0,0 +1,111 @@
+"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"));
+(0, vitest_1.test)("object intersection", () => {
+    const BaseTeacher = z.object({
+        subjects: z.array(z.string()),
+    });
+    const HasID = z.object({ id: z.string() });
+    const Teacher = z.intersection(BaseTeacher.passthrough(), HasID); // BaseTeacher.merge(HasID);
+    const data = {
+        subjects: ["math"],
+        id: "asdfasdf",
+    };
+    (0, vitest_1.expect)(Teacher.parse(data)).toEqual(data);
+    (0, vitest_1.expect)(() => Teacher.parse({ subject: data.subjects })).toThrow();
+    (0, vitest_1.expect)(Teacher.parse({ ...data, extra: 12 })).toEqual({ ...data, extra: 12 });
+    (0, vitest_1.expect)(() => z.intersection(BaseTeacher.strict(), HasID).parse({ ...data, extra: 12 })).toThrow();
+});
+(0, vitest_1.test)("deep intersection", () => {
+    const Animal = z.object({
+        properties: z.object({
+            is_animal: z.boolean(),
+        }),
+    });
+    const Cat = z
+        .object({
+        properties: z.object({
+            jumped: z.boolean(),
+        }),
+    })
+        .and(Animal);
+    // const cat:Cat = 'asdf' as any;
+    const cat = Cat.parse({ properties: { is_animal: true, jumped: true } });
+    (0, vitest_1.expect)(cat.properties).toEqual({ is_animal: true, jumped: true });
+});
+(0, vitest_1.test)("deep intersection of arrays", async () => {
+    const Author = z.object({
+        posts: z.array(z.object({
+            post_id: z.number(),
+        })),
+    });
+    const Registry = z
+        .object({
+        posts: z.array(z.object({
+            title: z.string(),
+        })),
+    })
+        .and(Author);
+    const posts = [
+        { post_id: 1, title: "Novels" },
+        { post_id: 2, title: "Fairy tales" },
+    ];
+    const cat = Registry.parse({ posts });
+    (0, vitest_1.expect)(cat.posts).toEqual(posts);
+    const asyncCat = await Registry.parseAsync({ posts });
+    (0, vitest_1.expect)(asyncCat.posts).toEqual(posts);
+});
+(0, vitest_1.test)("invalid intersection types", async () => {
+    const numberIntersection = z.intersection(z.number(), z.number().transform((x) => x + 1));
+    const syncResult = numberIntersection.safeParse(1234);
+    (0, vitest_1.expect)(syncResult.success).toEqual(false);
+    if (!syncResult.success) {
+        (0, vitest_1.expect)(syncResult.error.issues[0].code).toEqual(z.ZodIssueCode.invalid_intersection_types);
+    }
+    const asyncResult = await numberIntersection.spa(1234);
+    (0, vitest_1.expect)(asyncResult.success).toEqual(false);
+    if (!asyncResult.success) {
+        (0, vitest_1.expect)(asyncResult.error.issues[0].code).toEqual(z.ZodIssueCode.invalid_intersection_types);
+    }
+});
+(0, vitest_1.test)("invalid array merge", async () => {
+    const stringArrInt = z.intersection(z.string().array(), z
+        .string()
+        .array()
+        .transform((val) => [...val, "asdf"]));
+    const syncResult = stringArrInt.safeParse(["asdf", "qwer"]);
+    (0, vitest_1.expect)(syncResult.success).toEqual(false);
+    if (!syncResult.success) {
+        (0, vitest_1.expect)(syncResult.error.issues[0].code).toEqual(z.ZodIssueCode.invalid_intersection_types);
+    }
+    const asyncResult = await stringArrInt.spa(["asdf", "qwer"]);
+    (0, vitest_1.expect)(asyncResult.success).toEqual(false);
+    if (!asyncResult.success) {
+        (0, vitest_1.expect)(asyncResult.error.issues[0].code).toEqual(z.ZodIssueCode.invalid_intersection_types);
+    }
+});

package/dist/{commonjs/v3 → v3}/tests/language-server.source.js

@@ -15,23 +15,13 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
+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 });
 exports.instanceOfTestOmit = exports.TestOmit = exports.instanceOfTestPick = exports.TestPick = exports.instanceOfTestPartial = exports.TestPartial = exports.instanceOfTestUnion = exports.TestUnion = exports.instanceOfTestMerge = exports.TestMerge = exports.instanceOfTest = exports.Test = exports.filePath = void 0;
 const z = __importStar(require("zod/v3"));

package/dist/v3/tests/language-server.test.d.ts

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