zod 3.25.13 → 3.25.15

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

@@ -0,0 +1,181 @@
+"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)("preprocess", () => {
+    const schema = z.preprocess((data) => [data], z.string().array());
+    const value = schema.parse("asdf");
+    (0, vitest_1.expect)(value).toEqual(["asdf"]);
+    util_js_1.util.assertEqual(true);
+});
+(0, vitest_1.test)("async preprocess", async () => {
+    const schema = z.preprocess(async (data) => [data], z.string().array());
+    const value = await schema.parseAsync("asdf");
+    (0, vitest_1.expect)(value).toEqual(["asdf"]);
+});
+(0, vitest_1.test)("preprocess ctx.addIssue with parse", () => {
+    (0, vitest_1.expect)(() => {
+        z.preprocess((data, ctx) => {
+            ctx.addIssue({
+                code: "custom",
+                message: `${data} is not one of our allowed strings`,
+            });
+            return data;
+        }, z.string()).parse("asdf");
+    }).toThrow(JSON.stringify([
+        {
+            code: "custom",
+            message: "asdf is not one of our allowed strings",
+            path: [],
+        },
+    ], null, 2));
+});
+(0, vitest_1.test)("preprocess ctx.addIssue non-fatal by default", () => {
+    try {
+        z.preprocess((data, ctx) => {
+            ctx.addIssue({
+                code: "custom",
+                message: `custom error`,
+            });
+            return data;
+        }, z.string()).parse(1234);
+    }
+    catch (err) {
+        z.ZodError.assert(err);
+        (0, vitest_1.expect)(err.issues.length).toEqual(2);
+    }
+});
+(0, vitest_1.test)("preprocess ctx.addIssue fatal true", () => {
+    try {
+        z.preprocess((data, ctx) => {
+            ctx.addIssue({
+                code: "custom",
+                message: `custom error`,
+                fatal: true,
+            });
+            return data;
+        }, z.string()).parse(1234);
+    }
+    catch (err) {
+        z.ZodError.assert(err);
+        (0, vitest_1.expect)(err.issues.length).toEqual(1);
+    }
+});
+(0, vitest_1.test)("async preprocess ctx.addIssue with parse", async () => {
+    const schema = z.preprocess(async (data, ctx) => {
+        ctx.addIssue({
+            code: "custom",
+            message: `custom error`,
+        });
+        return data;
+    }, z.string());
+    (0, vitest_1.expect)(schema.parseAsync("asdf")).rejects.toThrow(JSON.stringify([
+        {
+            code: "custom",
+            message: "custom error",
+            path: [],
+        },
+    ], null, 2));
+});
+(0, vitest_1.test)("preprocess ctx.addIssue with parseAsync", async () => {
+    const result = await z
+        .preprocess(async (data, ctx) => {
+        ctx.addIssue({
+            code: "custom",
+            message: `${data} is not one of our allowed strings`,
+        });
+        return data;
+    }, z.string())
+        .safeParseAsync("asdf");
+    (0, vitest_1.expect)(JSON.parse(JSON.stringify(result))).toEqual({
+        success: false,
+        error: {
+            issues: [
+                {
+                    code: "custom",
+                    message: "asdf is not one of our allowed strings",
+                    path: [],
+                },
+            ],
+            name: "ZodError",
+        },
+    });
+});
+(0, vitest_1.test)("z.NEVER in preprocess", () => {
+    const foo = z.preprocess((val, ctx) => {
+        if (!val) {
+            ctx.addIssue({ code: z.ZodIssueCode.custom, message: "bad" });
+            return z.NEVER;
+        }
+        return val;
+    }, z.number());
+    util_js_1.util.assertEqual(true);
+    const arg = foo.safeParse(undefined);
+    if (!arg.success) {
+        (0, vitest_1.expect)(arg.error.issues[0].message).toEqual("bad");
+    }
+});
+(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.success).toEqual(false);
+    if (!result.success) {
+        (0, vitest_1.expect)(result.error.issues.length).toEqual(2);
+        (0, vitest_1.expect)(result.error.issues[0].code).toEqual(z.ZodIssueCode.too_small);
+        (0, vitest_1.expect)(result.error.issues[1].code).toEqual(z.ZodIssueCode.too_small);
+    }
+});
+(0, vitest_1.test)("preprocess validates with sibling errors", () => {
+    (0, vitest_1.expect)(() => {
+        z.object({
+            // Must be first
+            missing: z.string().refine(() => false),
+            preprocess: z.preprocess((data) => data?.trim(), z.string().regex(/ asdf/)),
+        }).parse({ preprocess: " asdf" });
+    }).toThrow(JSON.stringify([
+        {
+            code: "invalid_type",
+            expected: "string",
+            received: "undefined",
+            path: ["missing"],
+            message: "Required",
+        },
+        {
+            validation: "regex",
+            code: "invalid_string",
+            message: "Invalid",
+            path: ["preprocess"],
+        },
+    ], null, 2));
+});

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

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

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

@@ -0,0 +1,385 @@
+"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 Mocker_js_1 = require("./Mocker.js");
+const literalStringSchema = z.literal("asdf");
+const literalNumberSchema = z.literal(12);
+const literalBooleanSchema = z.literal(true);
+const literalBigIntSchema = z.literal(BigInt(42));
+const MySymbol = Symbol("stuff");
+const literalSymbolSchema = z.literal(MySymbol);
+const stringSchema = z.string();
+const numberSchema = z.number();
+const bigintSchema = z.bigint();
+const booleanSchema = z.boolean();
+const dateSchema = z.date();
+const symbolSchema = z.symbol();
+const nullSchema = z.null();
+const undefinedSchema = z.undefined();
+const stringSchemaOptional = z.string().optional();
+const stringSchemaNullable = z.string().nullable();
+const numberSchemaOptional = z.number().optional();
+const numberSchemaNullable = z.number().nullable();
+const bigintSchemaOptional = z.bigint().optional();
+const bigintSchemaNullable = z.bigint().nullable();
+const booleanSchemaOptional = z.boolean().optional();
+const booleanSchemaNullable = z.boolean().nullable();
+const dateSchemaOptional = z.date().optional();
+const dateSchemaNullable = z.date().nullable();
+const symbolSchemaOptional = z.symbol().optional();
+const symbolSchemaNullable = z.symbol().nullable();
+const val = new Mocker_js_1.Mocker();
+(0, vitest_1.test)("literal string correct", () => {
+    (0, vitest_1.expect)(literalStringSchema.parse("asdf")).toBe("asdf");
+});
+(0, vitest_1.test)("literal string incorrect", () => {
+    const f = () => literalStringSchema.parse("not_asdf");
+    (0, vitest_1.expect)(f).toThrow();
+});
+(0, vitest_1.test)("literal string number", () => {
+    const f = () => literalStringSchema.parse(123);
+    (0, vitest_1.expect)(f).toThrow();
+});
+(0, vitest_1.test)("literal string boolean", () => {
+    const f = () => literalStringSchema.parse(true);
+    (0, vitest_1.expect)(f).toThrow();
+});
+(0, vitest_1.test)("literal string boolean", () => {
+    const f = () => literalStringSchema.parse(true);
+    (0, vitest_1.expect)(f).toThrow();
+});
+(0, vitest_1.test)("literal string object", () => {
+    const f = () => literalStringSchema.parse({});
+    (0, vitest_1.expect)(f).toThrow();
+});
+(0, vitest_1.test)("literal number correct", () => {
+    (0, vitest_1.expect)(literalNumberSchema.parse(12)).toBe(12);
+});
+(0, vitest_1.test)("literal number incorrect", () => {
+    const f = () => literalNumberSchema.parse(13);
+    (0, vitest_1.expect)(f).toThrow();
+});
+(0, vitest_1.test)("literal number number", () => {
+    const f = () => literalNumberSchema.parse(val.string);
+    (0, vitest_1.expect)(f).toThrow();
+});
+(0, vitest_1.test)("literal number boolean", () => {
+    const f = () => literalNumberSchema.parse(val.boolean);
+    (0, vitest_1.expect)(f).toThrow();
+});
+(0, vitest_1.test)("literal number object", () => {
+    const f = () => literalStringSchema.parse({});
+    (0, vitest_1.expect)(f).toThrow();
+});
+(0, vitest_1.test)("literal boolean correct", () => {
+    (0, vitest_1.expect)(literalBooleanSchema.parse(true)).toBe(true);
+});
+(0, vitest_1.test)("literal boolean incorrect", () => {
+    const f = () => literalBooleanSchema.parse(false);
+    (0, vitest_1.expect)(f).toThrow();
+});
+(0, vitest_1.test)("literal boolean number", () => {
+    const f = () => literalBooleanSchema.parse("asdf");
+    (0, vitest_1.expect)(f).toThrow();
+});
+(0, vitest_1.test)("literal boolean boolean", () => {
+    const f = () => literalBooleanSchema.parse(123);
+    (0, vitest_1.expect)(f).toThrow();
+});
+(0, vitest_1.test)("literal boolean object", () => {
+    const f = () => literalBooleanSchema.parse({});
+    (0, vitest_1.expect)(f).toThrow();
+});
+(0, vitest_1.test)("literal bigint correct", () => {
+    (0, vitest_1.expect)(literalBigIntSchema.parse(BigInt(42))).toBe(BigInt(42));
+});
+(0, vitest_1.test)("literal bigint incorrect", () => {
+    const f = () => literalBigIntSchema.parse(BigInt(43));
+    (0, vitest_1.expect)(f).toThrow();
+});
+(0, vitest_1.test)("literal bigint number", () => {
+    const f = () => literalBigIntSchema.parse("asdf");
+    (0, vitest_1.expect)(f).toThrow();
+});
+(0, vitest_1.test)("literal bigint boolean", () => {
+    const f = () => literalBigIntSchema.parse(123);
+    (0, vitest_1.expect)(f).toThrow();
+});
+(0, vitest_1.test)("literal bigint object", () => {
+    const f = () => literalBigIntSchema.parse({});
+    (0, vitest_1.expect)(f).toThrow();
+});
+(0, vitest_1.test)("literal symbol", () => {
+    util_js_1.util.assertEqual(true);
+    literalSymbolSchema.parse(MySymbol);
+    (0, vitest_1.expect)(() => literalSymbolSchema.parse(Symbol("asdf"))).toThrow();
+});
+(0, vitest_1.test)("parse stringSchema string", () => {
+    stringSchema.parse(val.string);
+});
+(0, vitest_1.test)("parse stringSchema number", () => {
+    const f = () => stringSchema.parse(val.number);
+    (0, vitest_1.expect)(f).toThrow();
+});
+(0, vitest_1.test)("parse stringSchema boolean", () => {
+    const f = () => stringSchema.parse(val.boolean);
+    (0, vitest_1.expect)(f).toThrow();
+});
+(0, vitest_1.test)("parse stringSchema undefined", () => {
+    const f = () => stringSchema.parse(val.undefined);
+    (0, vitest_1.expect)(f).toThrow();
+});
+(0, vitest_1.test)("parse stringSchema null", () => {
+    const f = () => stringSchema.parse(val.null);
+    (0, vitest_1.expect)(f).toThrow();
+});
+(0, vitest_1.test)("parse numberSchema string", () => {
+    const f = () => numberSchema.parse(val.string);
+    (0, vitest_1.expect)(f).toThrow();
+});
+(0, vitest_1.test)("parse numberSchema number", () => {
+    numberSchema.parse(val.number);
+});
+(0, vitest_1.test)("parse numberSchema bigint", () => {
+    const f = () => numberSchema.parse(val.bigint);
+    (0, vitest_1.expect)(f).toThrow();
+});
+(0, vitest_1.test)("parse numberSchema boolean", () => {
+    const f = () => numberSchema.parse(val.boolean);
+    (0, vitest_1.expect)(f).toThrow();
+});
+(0, vitest_1.test)("parse numberSchema undefined", () => {
+    const f = () => numberSchema.parse(val.undefined);
+    (0, vitest_1.expect)(f).toThrow();
+});
+(0, vitest_1.test)("parse numberSchema null", () => {
+    const f = () => numberSchema.parse(val.null);
+    (0, vitest_1.expect)(f).toThrow();
+});
+(0, vitest_1.test)("parse bigintSchema string", () => {
+    const f = () => bigintSchema.parse(val.string);
+    (0, vitest_1.expect)(f).toThrow();
+});
+(0, vitest_1.test)("parse bigintSchema number", () => {
+    const f = () => bigintSchema.parse(val.number);
+    (0, vitest_1.expect)(f).toThrow();
+});
+(0, vitest_1.test)("parse bigintSchema bigint", () => {
+    bigintSchema.parse(val.bigint);
+});
+(0, vitest_1.test)("parse bigintSchema boolean", () => {
+    const f = () => bigintSchema.parse(val.boolean);
+    (0, vitest_1.expect)(f).toThrow();
+});
+(0, vitest_1.test)("parse bigintSchema undefined", () => {
+    const f = () => bigintSchema.parse(val.undefined);
+    (0, vitest_1.expect)(f).toThrow();
+});
+(0, vitest_1.test)("parse bigintSchema null", () => {
+    const f = () => bigintSchema.parse(val.null);
+    (0, vitest_1.expect)(f).toThrow();
+});
+(0, vitest_1.test)("parse booleanSchema string", () => {
+    const f = () => booleanSchema.parse(val.string);
+    (0, vitest_1.expect)(f).toThrow();
+});
+(0, vitest_1.test)("parse booleanSchema number", () => {
+    const f = () => booleanSchema.parse(val.number);
+    (0, vitest_1.expect)(f).toThrow();
+});
+(0, vitest_1.test)("parse booleanSchema boolean", () => {
+    booleanSchema.parse(val.boolean);
+});
+(0, vitest_1.test)("parse booleanSchema undefined", () => {
+    const f = () => booleanSchema.parse(val.undefined);
+    (0, vitest_1.expect)(f).toThrow();
+});
+(0, vitest_1.test)("parse booleanSchema null", () => {
+    const f = () => booleanSchema.parse(val.null);
+    (0, vitest_1.expect)(f).toThrow();
+});
+// ==============
+(0, vitest_1.test)("parse dateSchema string", () => {
+    const f = () => dateSchema.parse(val.string);
+    (0, vitest_1.expect)(f).toThrow();
+});
+(0, vitest_1.test)("parse dateSchema number", () => {
+    const f = () => dateSchema.parse(val.number);
+    (0, vitest_1.expect)(f).toThrow();
+});
+(0, vitest_1.test)("parse dateSchema boolean", () => {
+    const f = () => dateSchema.parse(val.boolean);
+    (0, vitest_1.expect)(f).toThrow();
+});
+(0, vitest_1.test)("parse dateSchema date", () => {
+    dateSchema.parse(val.date);
+});
+(0, vitest_1.test)("parse dateSchema undefined", () => {
+    const f = () => dateSchema.parse(val.undefined);
+    (0, vitest_1.expect)(f).toThrow();
+});
+(0, vitest_1.test)("parse dateSchema null", () => {
+    const f = () => dateSchema.parse(val.null);
+    (0, vitest_1.expect)(f).toThrow();
+});
+(0, vitest_1.test)("parse dateSchema invalid date", async () => {
+    try {
+        await dateSchema.parseAsync(new Date("invalid"));
+    }
+    catch (err) {
+        (0, vitest_1.expect)(err.issues[0].code).toEqual(z.ZodIssueCode.invalid_date);
+    }
+});
+// ==============
+(0, vitest_1.test)("parse symbolSchema string", () => {
+    const f = () => symbolSchema.parse(val.string);
+    (0, vitest_1.expect)(f).toThrow();
+});
+(0, vitest_1.test)("parse symbolSchema number", () => {
+    const f = () => symbolSchema.parse(val.number);
+    (0, vitest_1.expect)(f).toThrow();
+});
+(0, vitest_1.test)("parse symbolSchema boolean", () => {
+    const f = () => symbolSchema.parse(val.boolean);
+    (0, vitest_1.expect)(f).toThrow();
+});
+(0, vitest_1.test)("parse symbolSchema date", () => {
+    const f = () => symbolSchema.parse(val.date);
+    (0, vitest_1.expect)(f).toThrow();
+});
+(0, vitest_1.test)("parse symbolSchema symbol", () => {
+    symbolSchema.parse(val.symbol);
+});
+(0, vitest_1.test)("parse symbolSchema undefined", () => {
+    const f = () => symbolSchema.parse(val.undefined);
+    (0, vitest_1.expect)(f).toThrow();
+});
+(0, vitest_1.test)("parse symbolSchema null", () => {
+    const f = () => symbolSchema.parse(val.null);
+    (0, vitest_1.expect)(f).toThrow();
+});
+// ==============
+(0, vitest_1.test)("parse undefinedSchema string", () => {
+    const f = () => undefinedSchema.parse(val.string);
+    (0, vitest_1.expect)(f).toThrow();
+});
+(0, vitest_1.test)("parse undefinedSchema number", () => {
+    const f = () => undefinedSchema.parse(val.number);
+    (0, vitest_1.expect)(f).toThrow();
+});
+(0, vitest_1.test)("parse undefinedSchema boolean", () => {
+    const f = () => undefinedSchema.parse(val.boolean);
+    (0, vitest_1.expect)(f).toThrow();
+});
+(0, vitest_1.test)("parse undefinedSchema undefined", () => {
+    undefinedSchema.parse(val.undefined);
+});
+(0, vitest_1.test)("parse undefinedSchema null", () => {
+    const f = () => undefinedSchema.parse(val.null);
+    (0, vitest_1.expect)(f).toThrow();
+});
+(0, vitest_1.test)("parse nullSchema string", () => {
+    const f = () => nullSchema.parse(val.string);
+    (0, vitest_1.expect)(f).toThrow();
+});
+(0, vitest_1.test)("parse nullSchema number", () => {
+    const f = () => nullSchema.parse(val.number);
+    (0, vitest_1.expect)(f).toThrow();
+});
+(0, vitest_1.test)("parse nullSchema boolean", () => {
+    const f = () => nullSchema.parse(val.boolean);
+    (0, vitest_1.expect)(f).toThrow();
+});
+(0, vitest_1.test)("parse nullSchema undefined", () => {
+    const f = () => nullSchema.parse(val.undefined);
+    (0, vitest_1.expect)(f).toThrow();
+});
+(0, vitest_1.test)("parse nullSchema null", () => {
+    nullSchema.parse(val.null);
+});
+(0, vitest_1.test)("primitive inference", () => {
+    util_js_1.util.assertEqual(true);
+    util_js_1.util.assertEqual(true);
+    util_js_1.util.assertEqual(true);
+    util_js_1.util.assertEqual(true);
+    util_js_1.util.assertEqual(true);
+    util_js_1.util.assertEqual(true);
+    util_js_1.util.assertEqual(true);
+    util_js_1.util.assertEqual(true);
+    util_js_1.util.assertEqual(true);
+    util_js_1.util.assertEqual(true);
+    util_js_1.util.assertEqual(true);
+    util_js_1.util.assertEqual(true);
+    util_js_1.util.assertEqual(true);
+    util_js_1.util.assertEqual(true);
+    util_js_1.util.assertEqual(true);
+    util_js_1.util.assertEqual(true);
+    util_js_1.util.assertEqual(true);
+    util_js_1.util.assertEqual(true);
+    util_js_1.util.assertEqual(true);
+    util_js_1.util.assertEqual(true);
+    util_js_1.util.assertEqual(true);
+    util_js_1.util.assertEqual(true);
+    util_js_1.util.assertEqual(true);
+    util_js_1.util.assertEqual(true);
+    // [
+    //   literalStringSchemaTest,
+    //   literalNumberSchemaTest,
+    //   literalBooleanSchemaTest,
+    //   literalBigIntSchemaTest,
+    //   stringSchemaTest,
+    //   numberSchemaTest,
+    //   bigintSchemaTest,
+    //   booleanSchemaTest,
+    //   dateSchemaTest,
+    //   symbolSchemaTest,
+    //   nullSchemaTest,
+    //   undefinedSchemaTest,
+    //   stringSchemaOptionalTest,
+    //   stringSchemaNullableTest,
+    //   numberSchemaOptionalTest,
+    //   numberSchemaNullableTest,
+    //   bigintSchemaOptionalTest,
+    //   bigintSchemaNullableTest,
+    //   booleanSchemaOptionalTest,
+    //   booleanSchemaNullableTest,
+    //   dateSchemaOptionalTest,
+    //   dateSchemaNullableTest,
+    //   symbolSchemaOptionalTest,
+    //   symbolSchemaNullableTest,
+    // ];
+});
+(0, vitest_1.test)("get literal value", () => {
+    (0, vitest_1.expect)(literalStringSchema.value).toEqual("asdf");
+});
+(0, vitest_1.test)("optional convenience method", () => {
+    z.ostring().parse(undefined);
+    z.onumber().parse(undefined);
+    z.oboolean().parse(undefined);
+});

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

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

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

@@ -0,0 +1,98 @@
+"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 promSchema = z.promise(z.object({
+    name: z.string(),
+    age: z.number(),
+}));
+(0, vitest_1.test)("promise inference", () => {
+    util_js_1.util.assertEqual(true);
+});
+(0, vitest_1.test)("promise parsing success", async () => {
+    const pr = promSchema.parse(Promise.resolve({ name: "Bobby", age: 10 }));
+    (0, vitest_1.expect)(pr).toBeInstanceOf(Promise);
+    const result = await pr;
+    (0, vitest_1.expect)(typeof result).toBe("object");
+    (0, vitest_1.expect)(typeof result.age).toBe("number");
+    (0, vitest_1.expect)(typeof result.name).toBe("string");
+});
+(0, vitest_1.test)("promise parsing success 2", () => {
+    const fakePromise = {
+        then() {
+            return this;
+        },
+        catch() {
+            return this;
+        },
+    };
+    promSchema.parse(fakePromise);
+});
+(0, vitest_1.test)("promise parsing fail", async () => {
+    const bad = promSchema.parse(Promise.resolve({ name: "Bobby", age: "10" }));
+    // return await expect(bad).resolves.toBe({ name: 'Bobby', age: '10' });
+    return await (0, vitest_1.expect)(bad).rejects.toBeInstanceOf(z.ZodError);
+    // done();
+});
+(0, vitest_1.test)("promise parsing fail 2", async () => {
+    const failPromise = promSchema.parse(Promise.resolve({ name: "Bobby", age: "10" }));
+    await (0, vitest_1.expect)(failPromise).rejects.toBeInstanceOf(z.ZodError);
+    // done();/z
+});
+(0, vitest_1.test)("promise parsing fail", () => {
+    const bad = () => promSchema.parse({ then: () => { }, catch: {} });
+    (0, vitest_1.expect)(bad).toThrow();
+});
+// test('sync promise parsing', () => {
+//   expect(() => z.promise(z.string()).parse(Promise.resolve('asfd'))).toThrow();
+// });
+const asyncFunction = z.function(z.tuple([]), promSchema);
+(0, vitest_1.test)("async function pass", async () => {
+    const validatedFunction = asyncFunction.implement(async () => {
+        return { name: "jimmy", age: 14 };
+    });
+    await (0, vitest_1.expect)(validatedFunction()).resolves.toEqual({
+        name: "jimmy",
+        age: 14,
+    });
+});
+(0, vitest_1.test)("async function fail", async () => {
+    const validatedFunction = asyncFunction.implement(() => {
+        return Promise.resolve("asdf");
+    });
+    await (0, vitest_1.expect)(validatedFunction()).rejects.toBeInstanceOf(z.ZodError);
+});
+(0, vitest_1.test)("async promise parsing", () => {
+    const res = z.promise(z.number()).parseAsync(Promise.resolve(12));
+    (0, vitest_1.expect)(res).toBeInstanceOf(Promise);
+});
+(0, vitest_1.test)("resolves", () => {
+    const foo = z.literal("foo");
+    const res = z.promise(foo);
+    (0, vitest_1.expect)(res.unwrap()).toEqual(foo);
+});

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

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