zod 3.25.13 → 3.25.15

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

@@ -0,0 +1,402 @@
+"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.describe)("basic refinement functionality", () => {
+    (0, vitest_1.test)("should create a new schema instance when refining", () => {
+        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.test)("should validate according to refinement logic", () => {
+        const schema = z
+            .object({
+            first: z.string(),
+            second: z.string(),
+        })
+            .partial()
+            .strict()
+            .refine((data) => data.first || data.second, "Either first or second should be filled in.");
+        // Should fail on empty object
+        (0, vitest_1.expect)(() => schema.parse({})).toThrow();
+        // Should pass with first property
+        (0, vitest_1.expect)(schema.parse({ first: "a" })).toEqual({ first: "a" });
+        // Should pass with second property
+        (0, vitest_1.expect)(schema.parse({ second: "a" })).toEqual({ second: "a" });
+        // Should pass with both properties
+        (0, vitest_1.expect)(schema.parse({ first: "a", second: "a" })).toEqual({ first: "a", second: "a" });
+    });
+    (0, vitest_1.test)("should validate strict mode correctly", () => {
+        const schema = z
+            .object({
+            first: z.string(),
+            second: z.string(),
+        })
+            .partial()
+            .strict();
+        // Should throw on extra properties
+        (0, vitest_1.expect)(() => schema.parse({ third: "adsf" })).toThrow();
+    });
+});
+(0, vitest_1.describe)("refinement with custom error messages", () => {
+    (0, vitest_1.test)("should use custom error message when validation fails", () => {
+        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");
+        const result = validationSchema.safeParse({
+            email: "aaaa@gmail.com",
+            password: "aaaaaaaa",
+            confirmPassword: "bbbbbbbb",
+        });
+        (0, vitest_1.expect)(result.success).toEqual(false);
+        if (!result.success) {
+            (0, vitest_1.expect)(result.error.issues[0].message).toEqual("Both password and confirmation must match");
+        }
+    });
+});
+(0, vitest_1.describe)("async refinements", () => {
+    (0, vitest_1.test)("should support async refinement functions", 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");
+        // Should pass with matching passwords
+        const validData = {
+            email: "aaaa@gmail.com",
+            password: "password",
+            confirmPassword: "password",
+        };
+        await (0, vitest_1.expect)(validationSchema.parseAsync(validData)).resolves.toEqual(validData);
+        // Should fail with non-matching passwords
+        await (0, vitest_1.expect)(validationSchema.parseAsync({
+            email: "aaaa@gmail.com",
+            password: "password",
+            confirmPassword: "different",
+        })).rejects.toThrow();
+    });
+});
+(0, vitest_1.describe)("early termination options", () => {
+    (0, vitest_1.test)("should abort early with continue: false", () => {
+        const schema = z
+            .string()
+            .superRefine((val, ctx) => {
+            if (val.length < 2) {
+                ctx.addIssue({
+                    code: "custom",
+                    message: "BAD",
+                    continue: false,
+                });
+            }
+        })
+            .refine((_) => false);
+        const result = schema.safeParse("");
+        (0, vitest_1.expect)(result.success).toEqual(false);
+        if (!result.success) {
+            (0, vitest_1.expect)(result.error.issues.length).toEqual(1);
+            (0, vitest_1.expect)(result.error.issues[0].message).toEqual("BAD");
+        }
+    });
+    (0, vitest_1.test)("should abort early with fatal: true", () => {
+        const schema = z
+            .string()
+            .superRefine((val, ctx) => {
+            if (val.length < 2) {
+                ctx.addIssue({
+                    code: "custom",
+                    fatal: true,
+                    message: "BAD",
+                });
+            }
+        })
+            .refine((_) => false);
+        const result = schema.safeParse("");
+        (0, vitest_1.expect)(result.success).toEqual(false);
+        if (!result.success) {
+            (0, vitest_1.expect)(result.error.issues.length).toEqual(1);
+            (0, vitest_1.expect)(result.error.issues[0].message).toEqual("BAD");
+        }
+    });
+    (0, vitest_1.test)("should abort early with abort flag", () => {
+        const schema = z
+            .string()
+            .refine((_) => false, { abort: true })
+            .refine((_) => false);
+        const result = schema.safeParse("");
+        (0, vitest_1.expect)(result.success).toEqual(false);
+        if (!result.success) {
+            (0, vitest_1.expect)(result.error.issues.length).toEqual(1);
+        }
+    });
+});
+(0, vitest_1.describe)("custom error paths", () => {
+    (0, vitest_1.test)("should use custom path in error message", async () => {
+        const result = await z
+            .object({ password: z.string(), confirm: z.string() })
+            .refine((data) => data.confirm === data.password, { path: ["confirm"] })
+            .safeParse({ 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.describe)("superRefine functionality", () => {
+    (0, vitest_1.test)("should support multiple validation rules", () => {
+        const Strings = z.array(z.string()).superRefine((val, ctx) => {
+            if (val.length > 3) {
+                ctx.addIssue({
+                    input: val,
+                    code: "too_big",
+                    origin: "array",
+                    maximum: 3,
+                    inclusive: true,
+                    exact: true,
+                    message: "Too many items 😡",
+                });
+            }
+            if (val.length !== new Set(val).size) {
+                ctx.addIssue({
+                    input: val,
+                    code: "custom",
+                    message: `No duplicates allowed.`,
+                });
+            }
+        });
+        // Should fail with too many items and duplicates
+        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);
+            (0, vitest_1.expect)(result.error.issues[0].message).toEqual("Too many items 😡");
+            (0, vitest_1.expect)(result.error.issues[1].message).toEqual("No duplicates allowed.");
+        }
+        // Should pass with valid input
+        const validArray = ["asfd", "qwer"];
+        (0, vitest_1.expect)(Strings.parse(validArray)).toEqual(validArray);
+    });
+    (0, vitest_1.test)("should support async superRefine", async () => {
+        const Strings = z.array(z.string()).superRefine(async (val, ctx) => {
+            if (val.length > 3) {
+                ctx.addIssue({
+                    input: val,
+                    code: "too_big",
+                    origin: "array",
+                    maximum: 3,
+                    inclusive: true,
+                    message: "Too many items 😡",
+                });
+            }
+            if (val.length !== new Set(val).size) {
+                ctx.addIssue({
+                    input: val,
+                    code: "custom",
+                    message: `No duplicates allowed.`,
+                });
+            }
+        });
+        // Should fail with too many items and duplicates
+        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);
+        }
+        // Should pass with valid input
+        const validArray = ["asfd", "qwer"];
+        await (0, vitest_1.expect)(Strings.parseAsync(validArray)).resolves.toEqual(validArray);
+    });
+    (0, vitest_1.test)("should accept string as shorthand for custom error message", () => {
+        const schema = z.string().superRefine((_, ctx) => {
+            ctx.addIssue("bad stuff");
+        });
+        const result = schema.safeParse("asdf");
+        (0, vitest_1.expect)(result.success).toEqual(false);
+        if (!result.success) {
+            (0, vitest_1.expect)(result.error.issues).toHaveLength(1);
+            (0, vitest_1.expect)(result.error.issues[0].message).toEqual("bad stuff");
+        }
+    });
+    (0, vitest_1.test)("should respect fatal flag in superRefine", () => {
+        const schema = z
+            .string()
+            .superRefine((val, ctx) => {
+            if (val === "") {
+                ctx.addIssue({
+                    input: val,
+                    code: "custom",
+                    message: "foo",
+                    fatal: true,
+                });
+            }
+        })
+            .superRefine((val, ctx) => {
+            if (val !== " ") {
+                ctx.addIssue({
+                    input: val,
+                    code: "custom",
+                    message: "bar",
+                });
+            }
+        });
+        const result = schema.safeParse("");
+        (0, vitest_1.expect)(result.success).toEqual(false);
+        if (!result.success) {
+            (0, vitest_1.expect)(result.error.issues.length).toEqual(1);
+            (0, vitest_1.expect)(result.error.issues[0].message).toEqual("foo");
+        }
+    });
+});
+(0, vitest_1.describe)("chained refinements", () => {
+    (0, vitest_1.test)("should collect all validation errors when appropriate", () => {
+        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",
+        });
+        // Should fail with one error
+        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);
+            (0, vitest_1.expect)(r1.error.issues[0].path).toEqual(["length"]);
+        }
+        // Should fail with two errors
+        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);
+        }
+        // Should pass with valid input
+        const validData = {
+            length: 6,
+            size: 8,
+        };
+        (0, vitest_1.expect)(objectSchema.parse(validData)).toEqual(validData);
+    });
+});
+// Commented tests can be uncommented once type-checking issues are resolved
+/*
+describe("type refinement", () => {
+  test("refinement type guard", () => {
+    const validationSchema = z.object({
+      a: z.string().refine((s): s is "a" => s === "a"),
+    });
+    type Input = z.input<typeof validationSchema>;
+    type Schema = z.infer<typeof validationSchema>;
+
+    expectTypeOf<Input["a"]>().not.toEqualTypeOf<"a">();
+    expectTypeOf<Input["a"]>().toEqualTypeOf<string>();
+
+    expectTypeOf<Schema["a"]>().toEqualTypeOf<"a">();
+    expectTypeOf<Schema["a"]>().not.toEqualTypeOf<string>();
+  });
+
+  test("superRefine - type narrowing", () => {
+    type NarrowType = { type: string; age: number };
+    const schema = z
+      .object({
+        type: z.string(),
+        age: z.number(),
+      })
+      .nullable()
+      .superRefine((arg, ctx): arg is NarrowType => {
+        if (!arg) {
+          // still need to make a call to ctx.addIssue
+          ctx.addIssue({
+            input: arg,
+            code: "custom",
+            message: "cannot be null",
+            fatal: true,
+          });
+          return false;
+        }
+        return true;
+      });
+
+    expectTypeOf<z.infer<typeof schema>>().toEqualTypeOf<NarrowType>();
+
+    expect(schema.safeParse({ type: "test", age: 0 }).success).toEqual(true);
+    expect(schema.safeParse(null).success).toEqual(false);
+  });
+
+  test("chained mixed refining types", () => {
+    type firstRefinement = { first: string; second: number; third: true };
+    type secondRefinement = { first: "bob"; second: number; third: true };
+    type thirdRefinement = { first: "bob"; second: 33; third: true };
+    const schema = z
+      .object({
+        first: z.string(),
+        second: z.number(),
+        third: z.boolean(),
+      })
+      .nullable()
+      .refine((arg): arg is firstRefinement => !!arg?.third)
+      .superRefine((arg, ctx): arg is secondRefinement => {
+        expectTypeOf<typeof arg>().toEqualTypeOf<firstRefinement>();
+        if (arg.first !== "bob") {
+          ctx.addIssue({
+            input: arg,
+            code: "custom",
+            message: "`first` property must be `bob`",
+          });
+          return false;
+        }
+        return true;
+      })
+      .refine((arg): arg is thirdRefinement => {
+        expectTypeOf<typeof arg>().toEqualTypeOf<secondRefinement>();
+        return arg.second === 33;
+      });
+
+    expectTypeOf<z.infer<typeof schema>>().toEqualTypeOf<thirdRefinement>();
+  });
+});
+*/

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

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

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

@@ -0,0 +1,155 @@
+"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)("globalRegistry", () => {
+    const reg = z.registry();
+    const a = z.string();
+    reg.add(a);
+    (0, vitest_1.expect)(reg.has(a)).toEqual(true);
+    reg.remove(a);
+    (0, vitest_1.expect)(reg.has(a)).toEqual(false);
+    a.register(z.globalRegistry, { field: "sup" });
+    (0, vitest_1.expect)(z.globalRegistry.has(a)).toEqual(true);
+    (0, vitest_1.expect)(z.globalRegistry.get(a)).toEqual({ field: "sup" });
+    z.globalRegistry.remove(a);
+    (0, vitest_1.expect)(z.globalRegistry.has(a)).toEqual(false);
+});
+(0, vitest_1.test)("z.registry", () => {
+    const fieldRegistry = z.registry();
+    const a = z.string();
+    fieldRegistry.add(a, { name: "hello", description: "world" });
+    const a_meta = fieldRegistry.get(a);
+    (0, vitest_1.expect)(a_meta).toEqual({ name: "hello", description: "world" });
+    fieldRegistry.remove(a);
+    (0, vitest_1.expect)(fieldRegistry.has(a)).toEqual(false);
+    (0, vitest_1.expect)(fieldRegistry.get(a)).toEqual(undefined);
+});
+(0, vitest_1.test)("z.registry no metadata", () => {
+    const fieldRegistry = z.registry();
+    const a = z.string();
+    fieldRegistry.add(a);
+    fieldRegistry.add(z.number());
+    (0, vitest_1.expect)(fieldRegistry.get(a)).toEqual(undefined);
+    (0, vitest_1.expect)(fieldRegistry.has(a)).toEqual(true);
+});
+(0, vitest_1.test)("z.registry with schema constraints", () => {
+    const fieldRegistry = z.registry();
+    const a = z.string();
+    fieldRegistry.add(a, { name: "hello", description: "world" });
+    // @ts-expect-error
+    fieldRegistry.add(z.number(), { name: "test" });
+    // @ts-expect-error
+    z.number().register(fieldRegistry, { name: "test", description: "test" });
+});
+// test("z.namedRegistry", () => {
+//   const namedReg = z
+//     .namedRegistry<{ name: string; description: string }>()
+//     .add(z.string(), { name: "hello", description: "world" })
+//     .add(z.number(), { name: "number", description: "number" });
+//   expect(namedReg.get("hello")).toEqual({
+//     name: "hello",
+//     description: "world",
+//   });
+//   expect(namedReg.has("hello")).toEqual(true);
+//   expect(namedReg.get("number")).toEqual({
+//     name: "number",
+//     description: "number",
+//   });
+//   // @ts-expect-error
+//   namedReg.get("world");
+//   // @ts-expect-error
+//   expect(namedReg.get("world")).toEqual(undefined);
+//   const hello = namedReg.get("hello");
+//   expect(hello).toEqual({ name: "hello", description: "world" });
+//   expectTypeOf<typeof hello>().toEqualTypeOf<{
+//     name: "hello";
+//     description: "world";
+//   }>();
+//   expectTypeOf<typeof namedReg.items>().toEqualTypeOf<{
+//     hello: { name: "hello"; description: "world" };
+//     number: { name: "number"; description: "number" };
+//   }>();
+// });
+(0, vitest_1.test)("output type in registry meta", () => {
+    const reg = z.registry();
+    const a = z.string();
+    reg.add(a, { out: "asdf" });
+    // @ts-expect-error
+    reg.add(a, 1234);
+    (0, vitest_1.expectTypeOf)(reg.get(a)).toEqualTypeOf();
+});
+(0, vitest_1.test)("output type in registry meta - objects and arrays", () => {
+    const reg = z.registry();
+    const a = z.string();
+    reg.add(a, { name: "hello", examples: ["world"] });
+    // @ts-expect-error
+    reg.add(a, { name: "hello", examples: "world" });
+    (0, vitest_1.expectTypeOf)(reg.get(a)).toEqualTypeOf();
+});
+(0, vitest_1.test)("input type in registry meta", () => {
+    const reg = z.registry();
+    const a = z.pipe(z.number(), z.transform(String));
+    reg.add(a, { in: 1234 });
+    // @ts-expect-error
+    reg.add(a, "1234");
+    (0, vitest_1.expectTypeOf)(reg.get(a)).toEqualTypeOf();
+});
+(0, vitest_1.test)("input type in registry meta - objects and arrays", () => {
+    const reg = z.registry();
+    const a = z.pipe(z.number(), z.transform(String));
+    reg.add(a, { name: "hello", examples: [1234] });
+    // @ts-expect-error
+    reg.add(a, { name: "hello", examples: "world" });
+    (0, vitest_1.expectTypeOf)(reg.get(a)).toEqualTypeOf();
+});
+(0, vitest_1.test)(".meta method", () => {
+    const a1 = z.string();
+    const a2 = a1.meta({ name: "hello" });
+    (0, vitest_1.expect)(a1.meta()).toEqual(undefined);
+    (0, vitest_1.expect)(a2.meta()).toEqual({ name: "hello" });
+    (0, vitest_1.expect)(a1 === a2).toEqual(false);
+});
+(0, vitest_1.test)(".meta metadata does not bubble up", () => {
+    const a1 = z.string().meta({ name: "hello" });
+    const a2 = a1.optional();
+    (0, vitest_1.expect)(a1.meta()).toEqual({ name: "hello" });
+    (0, vitest_1.expect)(a2.meta()).toEqual(undefined);
+});
+(0, vitest_1.test)(".describe", () => {
+    const a1 = z.string();
+    const a2 = a1.describe("Hello");
+    (0, vitest_1.expect)(a1.description).toEqual(undefined);
+    (0, vitest_1.expect)(a2.description).toEqual("Hello");
+});
+(0, vitest_1.test)("inherit across clone", () => {
+    const A = z.string().meta({ a: true });
+    (0, vitest_1.expect)(A.meta()).toEqual({ a: true });
+    const B = A.meta({ b: true });
+    (0, vitest_1.expect)(B.meta()).toEqual({ a: true, b: true });
+    const C = B.describe("hello");
+    (0, vitest_1.expect)(C.meta()).toEqual({ a: true, b: true, description: "hello" });
+});

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

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