zod 3.25.13 → 3.25.15

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

@@ -0,0 +1,78 @@
+"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/v3"));
+const crazySchema = z.object({
+    tuple: z.tuple([
+        z.string().nullable().optional(),
+        z.number().nullable().optional(),
+        z.boolean().nullable().optional(),
+        z.null().nullable().optional(),
+        z.undefined().nullable().optional(),
+        z.literal("1234").nullable().optional(),
+    ]),
+    merged: z
+        .object({
+        k1: z.string().optional(),
+    })
+        .merge(z.object({ k1: z.string().nullable(), k2: z.number() })),
+    union: z.array(z.union([z.literal("asdf"), z.literal(12)])).nonempty(),
+    array: z.array(z.number()),
+    // sumTransformer: z.transformer(z.array(z.number()), z.number(), (arg) => {
+    //   return arg.reduce((a, b) => a + b, 0);
+    // }),
+    sumMinLength: z.array(z.number()).refine((arg) => arg.length > 5),
+    intersection: z.intersection(z.object({ p1: z.string().optional() }), z.object({ p1: z.number().optional() })),
+    enum: z.intersection(z.enum(["zero", "one"]), z.enum(["one", "two"])),
+    nonstrict: z.object({ points: z.number() }).nonstrict(),
+    numProm: z.promise(z.number()),
+    lenfun: z.function(z.tuple([z.string()]), z.boolean()),
+});
+// const asyncCrazySchema = crazySchema.extend({
+//   // async_transform: z.transformer(
+//   //   z.array(z.number()),
+//   //   z.number(),
+//   //   async (arg) => {
+//   //     return arg.reduce((a, b) => a + b, 0);
+//   //   }
+//   // ),
+//   async_refine: z.array(z.number()).refine(async (arg) => arg.length > 5),
+// });
+(0, vitest_1.test)("parse", () => {
+    crazySchema.parse({
+        tuple: ["asdf", 1234, true, null, undefined, "1234"],
+        merged: { k1: "asdf", k2: 12 },
+        union: ["asdf", 12, "asdf", 12, "asdf", 12],
+        array: [12, 15, 16],
+        // sumTransformer: [12, 15, 16],
+        sumMinLength: [12, 15, 16, 98, 24, 63],
+        intersection: {},
+        enum: "one",
+        nonstrict: { points: 1234 },
+        numProm: Promise.resolve(12),
+        lenfun: (x) => x.length,
+    });
+});

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

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

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

@@ -0,0 +1,51 @@
+"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)("passing validations", () => {
+    const example1 = z.custom((x) => typeof x === "number");
+    example1.parse(1234);
+    (0, vitest_1.expect)(() => example1.parse({})).toThrow();
+});
+(0, vitest_1.test)("string params", () => {
+    const example1 = z.custom((x) => typeof x !== "number", "customerr");
+    const result = example1.safeParse(1234);
+    (0, vitest_1.expect)(result.success).toEqual(false);
+    // @ts-ignore
+    (0, vitest_1.expect)(JSON.stringify(result.error).includes("customerr")).toEqual(true);
+});
+(0, vitest_1.test)("async validations", async () => {
+    const example1 = z.custom(async (x) => {
+        return typeof x === "number";
+    });
+    const r1 = await example1.safeParseAsync(1234);
+    (0, vitest_1.expect)(r1.success).toEqual(true);
+    (0, vitest_1.expect)(r1.data).toEqual(1234);
+    const r2 = await example1.safeParseAsync("asdf");
+    (0, vitest_1.expect)(r2.success).toEqual(false);
+    (0, vitest_1.expect)(r2.error.issues.length).toEqual(1);
+});

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

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

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

@@ -0,0 +1,49 @@
+"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 beforeBenchmarkDate = new Date(2022, 10, 4);
+const benchmarkDate = new Date(2022, 10, 5);
+const afterBenchmarkDate = new Date(2022, 10, 6);
+const minCheck = z.date().min(benchmarkDate);
+const maxCheck = z.date().max(benchmarkDate);
+(0, vitest_1.test)("passing validations", () => {
+    minCheck.parse(benchmarkDate);
+    minCheck.parse(afterBenchmarkDate);
+    maxCheck.parse(benchmarkDate);
+    maxCheck.parse(beforeBenchmarkDate);
+});
+(0, vitest_1.test)("failing validations", () => {
+    (0, vitest_1.expect)(() => minCheck.parse(beforeBenchmarkDate)).toThrow();
+    (0, vitest_1.expect)(() => maxCheck.parse(afterBenchmarkDate)).toThrow();
+});
+(0, vitest_1.test)("min max getters", () => {
+    (0, vitest_1.expect)(minCheck.minDate).toEqual(benchmarkDate);
+    (0, vitest_1.expect)(minCheck.min(afterBenchmarkDate).minDate).toEqual(afterBenchmarkDate);
+    (0, vitest_1.expect)(maxCheck.maxDate).toEqual(benchmarkDate);
+    (0, vitest_1.expect)(maxCheck.max(beforeBenchmarkDate).maxDate).toEqual(beforeBenchmarkDate);
+});

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

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

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

@@ -0,0 +1,187 @@
+"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)("test", () => {
+    z;
+});
+// const fish = z.object({
+//   name: z.string(),
+//   props: z.object({
+//     color: z.string(),
+//     numScales: z.number(),
+//   }),
+// });
+// const nonStrict = z
+//   .object({
+//     name: z.string(),
+//     color: z.string(),
+//   })
+//   .nonstrict();
+// test('object pick type', () => {
+//   const modNonStrictFish = nonStrict.omit({ name: true });
+//   modNonStrictFish.parse({ color: 'asdf' });
+//   const bad1 = () => fish.pick({ props: { unknown: true } } as any);
+//   const bad2 = () => fish.omit({ name: true, props: { unknown: true } } as any);
+//   expect(bad1).toThrow();
+//   expect(bad2).toThrow();
+// });
+// test('f1', () => {
+//   const f1 = fish.pick(true);
+//   f1.parse({ name: 'a', props: { color: 'b', numScales: 3 } });
+// });
+// test('f2', () => {
+//   const f2 = fish.pick({ props: true });
+//   f2.parse({ props: { color: 'asdf', numScales: 1 } });
+//   const badcheck2 = () => f2.parse({ name: 'a', props: { color: 'b', numScales: 3 } } as any);
+//   expect(badcheck2).toThrow();
+// });
+// test('f3', () => {
+//   const f3 = fish.pick({ props: { color: true } });
+//   f3.parse({ props: { color: 'b' } });
+//   const badcheck3 = () => f3.parse({ name: 'a', props: { color: 'b', numScales: 3 } } as any);
+//   expect(badcheck3).toThrow();
+// });
+// test('f4', () => {
+//   const badcheck4 = () => fish.pick({ props: { color: true, unknown: true } });
+//   expect(badcheck4).toThrow();
+// });
+// test('f6', () => {
+//   const f6 = fish.omit({ props: true });
+//   const badcheck6 = () => f6.parse({ name: 'a', props: { color: 'b', numScales: 3 } } as any);
+//   f6.parse({ name: 'adsf' });
+//   expect(badcheck6).toThrow();
+// });
+// test('f7', () => {
+//   const f7 = fish.omit({ props: { color: true } });
+//   f7.parse({ name: 'a', props: { numScales: 3 } });
+//   const badcheck7 = () => f7.parse({ name: 'a', props: { color: 'b', numScales: 3 } } as any);
+//   expect(badcheck7).toThrow();
+// });
+// test('f8', () => {
+//   const badcheck8 = () => fish.omit({ props: { color: true, unknown: true } });
+//   expect(badcheck8).toThrow();
+// });
+// test('f9', () => {
+//   const f9 = nonStrict.pick(true);
+//   f9.parse({ name: 'a', color: 'asdf' });
+// });
+// test('f10', () => {
+//   const f10 = nonStrict.pick({ name: true });
+//   f10.parse({ name: 'a' });
+//   const val = f10.parse({ name: 'a', color: 'b' });
+//   expect(val).toEqual({ name: 'a' });
+// });
+// test('f12', () => {
+//   const badfcheck12 = () => nonStrict.omit({ color: true, asdf: true });
+//   expect(badfcheck12).toThrow();
+// });
+// test('array masking', () => {
+//   const fishArray = z.array(fish);
+//   const modFishArray = fishArray.pick({
+//     name: true,
+//     props: {
+//       numScales: true,
+//     },
+//   });
+//   modFishArray.parse([{ name: 'fish', props: { numScales: 12 } }]);
+//   const bad1 = () => modFishArray.parse([{ name: 'fish', props: { numScales: 12, color: 'asdf' } }] as any);
+//   expect(bad1).toThrow();
+// });
+// test('array masking', () => {
+//   const fishArray = z.array(fish);
+//   const fail = () =>
+//     fishArray.pick({
+//       name: true,
+//       props: {
+//         whatever: true,
+//       },
+//     } as any);
+//   expect(fail).toThrow();
+// });
+// test('array masking', () => {
+//   const fishArray = z.array(fish);
+//   const fail = () =>
+//     fishArray.omit({
+//       whateve: true,
+//     } as any);
+//   expect(fail).toThrow();
+// });
+// test('array masking', () => {
+//   const fishArray = z.array(fish);
+//   const modFishList = fishArray.omit({
+//     name: true,
+//     props: {
+//       color: true,
+//     },
+//   });
+//   modFishList.parse([{ props: { numScales: 12 } }]);
+//   const fail = () => modFishList.parse([{ name: 'hello', props: { numScales: 12 } }] as any);
+//   expect(fail).toThrow();
+// });
+// test('primitive array masking', () => {
+//   const fishArray = z.array(z.number());
+//   const fail = () => fishArray.pick({} as any);
+//   expect(fail).toThrow();
+// });
+// test('other array masking', () => {
+//   const fishArray = z.array(z.array(z.number()));
+//   const fail = () => fishArray.pick({} as any);
+//   expect(fail).toThrow();
+// });
+// test('invalid mask #1', () => {
+//   const fail = () => fish.pick(1 as any);
+//   expect(fail).toThrow();
+// });
+// test('invalid mask #2', () => {
+//   const fail = () => fish.pick([] as any);
+//   expect(fail).toThrow();
+// });
+// test('invalid mask #3', () => {
+//   const fail = () => fish.pick(false as any);
+//   expect(fail).toThrow();
+// });
+// test('invalid mask #4', () => {
+//   const fail = () => fish.pick('asdf' as any);
+//   expect(fail).toThrow();
+// });
+// test('invalid mask #5', () => {
+//   const fail = () => fish.omit(1 as any);
+//   expect(fail).toThrow();
+// });
+// test('invalid mask #6', () => {
+//   const fail = () => fish.omit([] as any);
+//   expect(fail).toThrow();
+// });
+// test('invalid mask #7', () => {
+//   const fail = () => fish.omit(false as any);
+//   expect(fail).toThrow();
+// });
+// test('invalid mask #8', () => {
+//   const fail = () => fish.omit('asdf' as any);
+//   expect(fail).toThrow();
+// });

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

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

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

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// @ts-ignore TS6133
+const vitest_1 = require("vitest");
+const v3_1 = require("zod/v3");
+const util_js_1 = require("../helpers/util.js");
+(0, vitest_1.test)("basic defaults", () => {
+    (0, vitest_1.expect)(v3_1.z.string().default("default").parse(undefined)).toBe("default");
+});
+(0, vitest_1.test)("default with transform", () => {
+    const stringWithDefault = v3_1.z
+        .string()
+        .transform((val) => val.toUpperCase())
+        .default("default");
+    (0, vitest_1.expect)(stringWithDefault.parse(undefined)).toBe("DEFAULT");
+    (0, vitest_1.expect)(stringWithDefault).toBeInstanceOf(v3_1.z.ZodDefault);
+    (0, vitest_1.expect)(stringWithDefault._def.innerType).toBeInstanceOf(v3_1.z.ZodEffects);
+    (0, vitest_1.expect)(stringWithDefault._def.innerType._def.schema).toBeInstanceOf(v3_1.z.ZodSchema);
+    util_js_1.util.assertEqual(true);
+    util_js_1.util.assertEqual(true);
+});
+(0, vitest_1.test)("default on existing optional", () => {
+    const stringWithDefault = v3_1.z.string().optional().default("asdf");
+    (0, vitest_1.expect)(stringWithDefault.parse(undefined)).toBe("asdf");
+    (0, vitest_1.expect)(stringWithDefault).toBeInstanceOf(v3_1.z.ZodDefault);
+    (0, vitest_1.expect)(stringWithDefault._def.innerType).toBeInstanceOf(v3_1.z.ZodOptional);
+    (0, vitest_1.expect)(stringWithDefault._def.innerType._def.innerType).toBeInstanceOf(v3_1.z.ZodString);
+    util_js_1.util.assertEqual(true);
+    util_js_1.util.assertEqual(true);
+});
+(0, vitest_1.test)("optional on default", () => {
+    const stringWithDefault = v3_1.z.string().default("asdf").optional();
+    util_js_1.util.assertEqual(true);
+    util_js_1.util.assertEqual(true);
+});
+(0, vitest_1.test)("complex chain example", () => {
+    const complex = v3_1.z
+        .string()
+        .default("asdf")
+        .transform((val) => val.toUpperCase())
+        .default("qwer")
+        .removeDefault()
+        .optional()
+        .default("asdfasdf");
+    (0, vitest_1.expect)(complex.parse(undefined)).toBe("ASDFASDF");
+});
+(0, vitest_1.test)("removeDefault", () => {
+    const stringWithRemovedDefault = v3_1.z.string().default("asdf").removeDefault();
+    util_js_1.util.assertEqual(true);
+});
+(0, vitest_1.test)("nested", () => {
+    const inner = v3_1.z.string().default("asdf");
+    const outer = v3_1.z.object({ inner }).default({
+        inner: undefined,
+    });
+    util_js_1.util.assertEqual(true);
+    util_js_1.util.assertEqual(true);
+    (0, vitest_1.expect)(outer.parse(undefined)).toEqual({ inner: "asdf" });
+    (0, vitest_1.expect)(outer.parse({})).toEqual({ inner: "asdf" });
+    (0, vitest_1.expect)(outer.parse({ inner: undefined })).toEqual({ inner: "asdf" });
+});
+(0, vitest_1.test)("chained defaults", () => {
+    const stringWithDefault = v3_1.z.string().default("inner").default("outer");
+    const result = stringWithDefault.parse(undefined);
+    (0, vitest_1.expect)(result).toEqual("outer");
+});
+(0, vitest_1.test)("factory", () => {
+    (0, vitest_1.expect)(v3_1.z.ZodDefault.create(v3_1.z.string(), { default: "asdf" }).parse(undefined)).toEqual("asdf");
+});
+(0, vitest_1.test)("native enum", () => {
+    let Fruits;
+    (function (Fruits) {
+        Fruits["apple"] = "apple";
+        Fruits["orange"] = "orange";
+    })(Fruits || (Fruits = {}));
+    const schema = v3_1.z.object({
+        fruit: v3_1.z.nativeEnum(Fruits).default(Fruits.apple),
+    });
+    (0, vitest_1.expect)(schema.parse({})).toEqual({ fruit: Fruits.apple });
+});
+(0, vitest_1.test)("enum", () => {
+    const schema = v3_1.z.object({
+        fruit: v3_1.z.enum(["apple", "orange"]).default("apple"),
+    });
+    (0, vitest_1.expect)(schema.parse({})).toEqual({ fruit: "apple" });
+});

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

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

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

@@ -0,0 +1,51 @@
+"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 description = "a description";
+(0, vitest_1.test)("passing `description` to schema should add a description", () => {
+    (0, vitest_1.expect)(z.string({ description }).description).toEqual(description);
+    (0, vitest_1.expect)(z.number({ description }).description).toEqual(description);
+    (0, vitest_1.expect)(z.boolean({ description }).description).toEqual(description);
+});
+(0, vitest_1.test)("`.describe` should add a description", () => {
+    (0, vitest_1.expect)(z.string().describe(description).description).toEqual(description);
+    (0, vitest_1.expect)(z.number().describe(description).description).toEqual(description);
+    (0, vitest_1.expect)(z.boolean().describe(description).description).toEqual(description);
+});
+(0, vitest_1.test)("description should carry over to chained schemas", () => {
+    const schema = z.string({ description });
+    (0, vitest_1.expect)(schema.description).toEqual(description);
+    (0, vitest_1.expect)(schema.optional().description).toEqual(description);
+    (0, vitest_1.expect)(schema.optional().nullable().default("default").description).toEqual(description);
+});
+(0, vitest_1.test)("description should not carry over to chained array schema", () => {
+    const schema = z.string().describe(description);
+    (0, vitest_1.expect)(schema.description).toEqual(description);
+    (0, vitest_1.expect)(schema.array().description).toEqual(undefined);
+    (0, vitest_1.expect)(z.array(schema).description).toEqual(undefined);
+});

package/dist/v3/tests/discriminated-unions.test.d.ts

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