zod 3.25.13 → 3.25.15

package/dist/{commonjs/v3 → v3}/index.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;
+};
 var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };

package/dist/v3/tests/all-errors.test.js

@@ -0,0 +1,147 @@
+"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 Test = z.object({
+    f1: z.number(),
+    f2: z.string().optional(),
+    f3: z.string().nullable(),
+    f4: z.array(z.object({ t: z.union([z.string(), z.boolean()]) })),
+});
+(0, vitest_1.test)("default flattened errors type inference", () => {
+    util_js_1.util.assertEqual(true);
+    util_js_1.util.assertEqual(false);
+});
+(0, vitest_1.test)("custom flattened errors type inference", () => {
+    util_js_1.util.assertEqual(false);
+    util_js_1.util.assertEqual(true);
+    util_js_1.util.assertEqual(false);
+});
+(0, vitest_1.test)("form errors type inference", () => {
+    util_js_1.util.assertEqual(true);
+});
+(0, vitest_1.test)(".flatten() type assertion", () => {
+    const parsed = Test.safeParse({});
+    const validFlattenedErrors = parsed.error.flatten(() => ({ message: "", code: 0 }));
+    // @ts-expect-error should fail assertion between `TestFlattenedErrors` and unmapped `flatten()`.
+    const invalidFlattenedErrors = parsed.error.flatten();
+    const validFormErrors = parsed.error.flatten();
+    // @ts-expect-error should fail assertion between `TestFormErrors` and mapped `flatten()`.
+    const invalidFormErrors = parsed.error.flatten(() => ({
+        message: "string",
+        code: 0,
+    }));
+    [validFlattenedErrors, invalidFlattenedErrors, validFormErrors, invalidFormErrors];
+});
+(0, vitest_1.test)(".formErrors type assertion", () => {
+    const parsed = Test.safeParse({});
+    const validFormErrors = parsed.error.formErrors;
+    // @ts-expect-error should fail assertion between `TestFlattenedErrors` and `.formErrors`.
+    const invalidFlattenedErrors = parsed.error.formErrors;
+    [validFormErrors, invalidFlattenedErrors];
+});
+(0, vitest_1.test)("all errors", () => {
+    const propertySchema = z.string();
+    const schema = z
+        .object({
+        a: propertySchema,
+        b: propertySchema,
+    })
+        .refine((val) => {
+        return val.a === val.b;
+    }, { message: "Must be equal" });
+    try {
+        schema.parse({
+            a: "asdf",
+            b: "qwer",
+        });
+    }
+    catch (error) {
+        if (error instanceof z.ZodError) {
+            (0, vitest_1.expect)(error.flatten()).toEqual({
+                formErrors: ["Must be equal"],
+                fieldErrors: {},
+            });
+        }
+    }
+    try {
+        schema.parse({
+            a: null,
+            b: null,
+        });
+    }
+    catch (_error) {
+        const error = _error;
+        (0, vitest_1.expect)(error.flatten()).toEqual({
+            formErrors: [],
+            fieldErrors: {
+                a: ["Expected string, received null"],
+                b: ["Expected string, received null"],
+            },
+        });
+        (0, vitest_1.expect)(error.flatten((iss) => iss.message.toUpperCase())).toEqual({
+            formErrors: [],
+            fieldErrors: {
+                a: ["EXPECTED STRING, RECEIVED NULL"],
+                b: ["EXPECTED STRING, RECEIVED NULL"],
+            },
+        });
+        // Test identity
+        (0, vitest_1.expect)(error.flatten((i) => i)).toEqual({
+            formErrors: [],
+            fieldErrors: {
+                a: [
+                    {
+                        code: "invalid_type",
+                        expected: "string",
+                        message: "Expected string, received null",
+                        path: ["a"],
+                        received: "null",
+                    },
+                ],
+                b: [
+                    {
+                        code: "invalid_type",
+                        expected: "string",
+                        message: "Expected string, received null",
+                        path: ["b"],
+                        received: "null",
+                    },
+                ],
+            },
+        });
+        // Test mapping
+        (0, vitest_1.expect)(error.flatten((i) => i.message.length)).toEqual({
+            formErrors: [],
+            fieldErrors: {
+                a: ["Expected string, received null".length],
+                b: ["Expected string, received null".length],
+            },
+        });
+    }
+});

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

@@ -0,0 +1,47 @@
+"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)("check any inference", () => {
+    const t1 = z.any();
+    t1.optional();
+    t1.nullable();
+    util_js_1.util.assertEqual(true);
+});
+(0, vitest_1.test)("check unknown inference", () => {
+    const t1 = z.unknown();
+    t1.optional();
+    t1.nullable();
+    util_js_1.util.assertEqual(true);
+});
+(0, vitest_1.test)("check never inference", () => {
+    const t1 = z.never();
+    (0, vitest_1.expect)(() => t1.parse(undefined)).toThrow();
+    (0, vitest_1.expect)(() => t1.parse("asdf")).toThrow();
+    (0, vitest_1.expect)(() => t1.parse(null)).toThrow();
+});

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

@@ -0,0 +1,80 @@
+"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 minTwo = z.string().array().min(2);
+const maxTwo = z.string().array().max(2);
+const justTwo = z.string().array().length(2);
+const intNum = z.string().array().nonempty();
+const nonEmptyMax = z.string().array().nonempty().max(2);
+util_js_1.util.assertEqual(true);
+util_js_1.util.assertEqual(true);
+(0, vitest_1.test)("passing validations", () => {
+    minTwo.parse(["a", "a"]);
+    minTwo.parse(["a", "a", "a"]);
+    maxTwo.parse(["a", "a"]);
+    maxTwo.parse(["a"]);
+    justTwo.parse(["a", "a"]);
+    intNum.parse(["a"]);
+    nonEmptyMax.parse(["a"]);
+});
+(0, vitest_1.test)("failing validations", () => {
+    (0, vitest_1.expect)(() => minTwo.parse(["a"])).toThrow();
+    (0, vitest_1.expect)(() => maxTwo.parse(["a", "a", "a"])).toThrow();
+    (0, vitest_1.expect)(() => justTwo.parse(["a"])).toThrow();
+    (0, vitest_1.expect)(() => justTwo.parse(["a", "a", "a"])).toThrow();
+    (0, vitest_1.expect)(() => intNum.parse([])).toThrow();
+    (0, vitest_1.expect)(() => nonEmptyMax.parse([])).toThrow();
+    (0, vitest_1.expect)(() => nonEmptyMax.parse(["a", "a", "a"])).toThrow();
+});
+(0, vitest_1.test)("parse empty array in nonempty", () => {
+    (0, vitest_1.expect)(() => z
+        .array(z.string())
+        .nonempty()
+        .parse([])).toThrow();
+});
+(0, vitest_1.test)("get element", () => {
+    justTwo.element.parse("asdf");
+    (0, vitest_1.expect)(() => justTwo.element.parse(12)).toThrow();
+});
+(0, vitest_1.test)("continue parsing despite array size error", () => {
+    const schema = z.object({
+        people: z.string().array().min(2),
+    });
+    const result = schema.safeParse({
+        people: [123],
+    });
+    (0, vitest_1.expect)(result.success).toEqual(false);
+    if (!result.success) {
+        (0, vitest_1.expect)(result.error.issues.length).toEqual(2);
+    }
+});
+(0, vitest_1.test)("parse should fail given sparse array", () => {
+    const schema = z.array(z.string()).nonempty().min(1).max(3);
+    (0, vitest_1.expect)(() => schema.parse(new Array(3))).toThrow();
+});

package/dist/v3/tests/async-parsing.test.d.ts

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

package/dist/v3/tests/async-parsing.test.js

@@ -0,0 +1,381 @@
+"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"));
+/// string
+const stringSchema = z.string();
+(0, vitest_1.test)("string async parse", async () => {
+    const goodData = "XXX";
+    const badData = 12;
+    const goodResult = await stringSchema.safeParseAsync(goodData);
+    (0, vitest_1.expect)(goodResult.success).toBe(true);
+    if (goodResult.success)
+        (0, vitest_1.expect)(goodResult.data).toEqual(goodData);
+    const badResult = await stringSchema.safeParseAsync(badData);
+    (0, vitest_1.expect)(badResult.success).toBe(false);
+    if (!badResult.success)
+        (0, vitest_1.expect)(badResult.error).toBeInstanceOf(z.ZodError);
+});
+/// number
+const numberSchema = z.number();
+(0, vitest_1.test)("number async parse", async () => {
+    const goodData = 1234.2353;
+    const badData = "1234";
+    const goodResult = await numberSchema.safeParseAsync(goodData);
+    (0, vitest_1.expect)(goodResult.success).toBe(true);
+    if (goodResult.success)
+        (0, vitest_1.expect)(goodResult.data).toEqual(goodData);
+    const badResult = await numberSchema.safeParseAsync(badData);
+    (0, vitest_1.expect)(badResult.success).toBe(false);
+    if (!badResult.success)
+        (0, vitest_1.expect)(badResult.error).toBeInstanceOf(z.ZodError);
+});
+/// bigInt
+const bigIntSchema = z.bigint();
+(0, vitest_1.test)("bigInt async parse", async () => {
+    const goodData = BigInt(145);
+    const badData = 134;
+    const goodResult = await bigIntSchema.safeParseAsync(goodData);
+    (0, vitest_1.expect)(goodResult.success).toBe(true);
+    if (goodResult.success)
+        (0, vitest_1.expect)(goodResult.data).toEqual(goodData);
+    const badResult = await bigIntSchema.safeParseAsync(badData);
+    (0, vitest_1.expect)(badResult.success).toBe(false);
+    if (!badResult.success)
+        (0, vitest_1.expect)(badResult.error).toBeInstanceOf(z.ZodError);
+});
+/// boolean
+const booleanSchema = z.boolean();
+(0, vitest_1.test)("boolean async parse", async () => {
+    const goodData = true;
+    const badData = 1;
+    const goodResult = await booleanSchema.safeParseAsync(goodData);
+    (0, vitest_1.expect)(goodResult.success).toBe(true);
+    if (goodResult.success)
+        (0, vitest_1.expect)(goodResult.data).toEqual(goodData);
+    const badResult = await booleanSchema.safeParseAsync(badData);
+    (0, vitest_1.expect)(badResult.success).toBe(false);
+    if (!badResult.success)
+        (0, vitest_1.expect)(badResult.error).toBeInstanceOf(z.ZodError);
+});
+/// date
+const dateSchema = z.date();
+(0, vitest_1.test)("date async parse", async () => {
+    const goodData = new Date();
+    const badData = new Date().toISOString();
+    const goodResult = await dateSchema.safeParseAsync(goodData);
+    (0, vitest_1.expect)(goodResult.success).toBe(true);
+    if (goodResult.success)
+        (0, vitest_1.expect)(goodResult.data).toEqual(goodData);
+    const badResult = await dateSchema.safeParseAsync(badData);
+    (0, vitest_1.expect)(badResult.success).toBe(false);
+    if (!badResult.success)
+        (0, vitest_1.expect)(badResult.error).toBeInstanceOf(z.ZodError);
+});
+/// undefined
+const undefinedSchema = z.undefined();
+(0, vitest_1.test)("undefined async parse", async () => {
+    const goodData = undefined;
+    const badData = "XXX";
+    const goodResult = await undefinedSchema.safeParseAsync(goodData);
+    (0, vitest_1.expect)(goodResult.success).toBe(true);
+    if (goodResult.success)
+        (0, vitest_1.expect)(goodResult.data).toEqual(undefined);
+    const badResult = await undefinedSchema.safeParseAsync(badData);
+    (0, vitest_1.expect)(badResult.success).toBe(false);
+    if (!badResult.success)
+        (0, vitest_1.expect)(badResult.error).toBeInstanceOf(z.ZodError);
+});
+/// null
+const nullSchema = z.null();
+(0, vitest_1.test)("null async parse", async () => {
+    const goodData = null;
+    const badData = undefined;
+    const goodResult = await nullSchema.safeParseAsync(goodData);
+    (0, vitest_1.expect)(goodResult.success).toBe(true);
+    if (goodResult.success)
+        (0, vitest_1.expect)(goodResult.data).toEqual(goodData);
+    const badResult = await nullSchema.safeParseAsync(badData);
+    (0, vitest_1.expect)(badResult.success).toBe(false);
+    if (!badResult.success)
+        (0, vitest_1.expect)(badResult.error).toBeInstanceOf(z.ZodError);
+});
+/// any
+const anySchema = z.any();
+(0, vitest_1.test)("any async parse", async () => {
+    const goodData = [{}];
+    // const badData = 'XXX';
+    const goodResult = await anySchema.safeParseAsync(goodData);
+    (0, vitest_1.expect)(goodResult.success).toBe(true);
+    if (goodResult.success)
+        (0, vitest_1.expect)(goodResult.data).toEqual(goodData);
+    // const badResult = await anySchema.safeParseAsync(badData);
+    // expect(badResult.success).toBe(false);
+    // if (!badResult.success) expect(badResult.error).toBeInstanceOf(z.ZodError);
+});
+/// unknown
+const unknownSchema = z.unknown();
+(0, vitest_1.test)("unknown async parse", async () => {
+    const goodData = ["asdf", 124, () => { }];
+    // const badData = 'XXX';
+    const goodResult = await unknownSchema.safeParseAsync(goodData);
+    (0, vitest_1.expect)(goodResult.success).toBe(true);
+    if (goodResult.success)
+        (0, vitest_1.expect)(goodResult.data).toEqual(goodData);
+    // const badResult = await unknownSchema.safeParseAsync(badData);
+    // expect(badResult.success).toBe(false);
+    // if (!badResult.success) expect(badResult.error).toBeInstanceOf(z.ZodError);
+});
+/// void
+const voidSchema = z.void();
+(0, vitest_1.test)("void async parse", async () => {
+    const goodData = undefined;
+    const badData = 0;
+    const goodResult = await voidSchema.safeParseAsync(goodData);
+    (0, vitest_1.expect)(goodResult.success).toBe(true);
+    if (goodResult.success)
+        (0, vitest_1.expect)(goodResult.data).toEqual(goodData);
+    const badResult = await voidSchema.safeParseAsync(badData);
+    (0, vitest_1.expect)(badResult.success).toBe(false);
+    if (!badResult.success)
+        (0, vitest_1.expect)(badResult.error).toBeInstanceOf(z.ZodError);
+});
+/// array
+const arraySchema = z.array(z.string());
+(0, vitest_1.test)("array async parse", async () => {
+    const goodData = ["XXX"];
+    const badData = "XXX";
+    const goodResult = await arraySchema.safeParseAsync(goodData);
+    (0, vitest_1.expect)(goodResult.success).toBe(true);
+    if (goodResult.success)
+        (0, vitest_1.expect)(goodResult.data).toEqual(goodData);
+    const badResult = await arraySchema.safeParseAsync(badData);
+    (0, vitest_1.expect)(badResult.success).toBe(false);
+    if (!badResult.success)
+        (0, vitest_1.expect)(badResult.error).toBeInstanceOf(z.ZodError);
+});
+/// object
+const objectSchema = z.object({ string: z.string() });
+(0, vitest_1.test)("object async parse", async () => {
+    const goodData = { string: "XXX" };
+    const badData = { string: 12 };
+    const goodResult = await objectSchema.safeParseAsync(goodData);
+    (0, vitest_1.expect)(goodResult.success).toBe(true);
+    if (goodResult.success)
+        (0, vitest_1.expect)(goodResult.data).toEqual(goodData);
+    const badResult = await objectSchema.safeParseAsync(badData);
+    (0, vitest_1.expect)(badResult.success).toBe(false);
+    if (!badResult.success)
+        (0, vitest_1.expect)(badResult.error).toBeInstanceOf(z.ZodError);
+});
+/// union
+const unionSchema = z.union([z.string(), z.undefined()]);
+(0, vitest_1.test)("union async parse", async () => {
+    const goodData = undefined;
+    const badData = null;
+    const goodResult = await unionSchema.safeParseAsync(goodData);
+    (0, vitest_1.expect)(goodResult.success).toBe(true);
+    if (goodResult.success)
+        (0, vitest_1.expect)(goodResult.data).toEqual(goodData);
+    const badResult = await unionSchema.safeParseAsync(badData);
+    (0, vitest_1.expect)(badResult.success).toBe(false);
+    if (!badResult.success)
+        (0, vitest_1.expect)(badResult.error).toBeInstanceOf(z.ZodError);
+});
+/// record
+const recordSchema = z.record(z.object({}));
+(0, vitest_1.test)("record async parse", async () => {
+    const goodData = { adsf: {}, asdf: {} };
+    const badData = [{}];
+    const goodResult = await recordSchema.safeParseAsync(goodData);
+    (0, vitest_1.expect)(goodResult.success).toBe(true);
+    if (goodResult.success)
+        (0, vitest_1.expect)(goodResult.data).toEqual(goodData);
+    const badResult = await recordSchema.safeParseAsync(badData);
+    (0, vitest_1.expect)(badResult.success).toBe(false);
+    if (!badResult.success)
+        (0, vitest_1.expect)(badResult.error).toBeInstanceOf(z.ZodError);
+});
+/// function
+const functionSchema = z.function();
+(0, vitest_1.test)("function async parse", async () => {
+    const goodData = () => { };
+    const badData = "XXX";
+    const goodResult = await functionSchema.safeParseAsync(goodData);
+    (0, vitest_1.expect)(goodResult.success).toBe(true);
+    if (goodResult.success)
+        (0, vitest_1.expect)(typeof goodResult.data).toEqual("function");
+    const badResult = await functionSchema.safeParseAsync(badData);
+    (0, vitest_1.expect)(badResult.success).toBe(false);
+    if (!badResult.success)
+        (0, vitest_1.expect)(badResult.error).toBeInstanceOf(z.ZodError);
+});
+/// literal
+const literalSchema = z.literal("asdf");
+(0, vitest_1.test)("literal async parse", async () => {
+    const goodData = "asdf";
+    const badData = "asdff";
+    const goodResult = await literalSchema.safeParseAsync(goodData);
+    (0, vitest_1.expect)(goodResult.success).toBe(true);
+    if (goodResult.success)
+        (0, vitest_1.expect)(goodResult.data).toEqual(goodData);
+    const badResult = await literalSchema.safeParseAsync(badData);
+    (0, vitest_1.expect)(badResult.success).toBe(false);
+    if (!badResult.success)
+        (0, vitest_1.expect)(badResult.error).toBeInstanceOf(z.ZodError);
+});
+/// enum
+const enumSchema = z.enum(["fish", "whale"]);
+(0, vitest_1.test)("enum async parse", async () => {
+    const goodData = "whale";
+    const badData = "leopard";
+    const goodResult = await enumSchema.safeParseAsync(goodData);
+    (0, vitest_1.expect)(goodResult.success).toBe(true);
+    if (goodResult.success)
+        (0, vitest_1.expect)(goodResult.data).toEqual(goodData);
+    const badResult = await enumSchema.safeParseAsync(badData);
+    (0, vitest_1.expect)(badResult.success).toBe(false);
+    if (!badResult.success)
+        (0, vitest_1.expect)(badResult.error).toBeInstanceOf(z.ZodError);
+});
+/// nativeEnum
+var nativeEnumTest;
+(function (nativeEnumTest) {
+    nativeEnumTest["asdf"] = "qwer";
+})(nativeEnumTest || (nativeEnumTest = {}));
+// @ts-ignore
+const nativeEnumSchema = z.nativeEnum(nativeEnumTest);
+(0, vitest_1.test)("nativeEnum async parse", async () => {
+    const goodData = nativeEnumTest.asdf;
+    const badData = "asdf";
+    const goodResult = await nativeEnumSchema.safeParseAsync(goodData);
+    (0, vitest_1.expect)(goodResult.success).toBe(true);
+    if (goodResult.success)
+        (0, vitest_1.expect)(goodResult.data).toEqual(goodData);
+    const badResult = await nativeEnumSchema.safeParseAsync(badData);
+    (0, vitest_1.expect)(badResult.success).toBe(false);
+    if (!badResult.success)
+        (0, vitest_1.expect)(badResult.error).toBeInstanceOf(z.ZodError);
+});
+/// promise
+const promiseSchema = z.promise(z.number());
+(0, vitest_1.test)("promise async parse good", async () => {
+    const goodData = Promise.resolve(123);
+    const goodResult = await promiseSchema.safeParseAsync(goodData);
+    (0, vitest_1.expect)(goodResult.success).toBe(true);
+    if (goodResult.success) {
+        (0, vitest_1.expect)(goodResult.data).toBeInstanceOf(Promise);
+        const data = await goodResult.data;
+        (0, vitest_1.expect)(data).toEqual(123);
+        // expect(goodResult.data).resolves.toEqual(124);
+        // return goodResult.data;
+    }
+    else {
+        throw new Error("success should be true");
+    }
+});
+(0, vitest_1.test)("promise async parse bad", async () => {
+    const badData = Promise.resolve("XXX");
+    const badResult = await promiseSchema.safeParseAsync(badData);
+    (0, vitest_1.expect)(badResult.success).toBe(true);
+    if (badResult.success) {
+        await (0, vitest_1.expect)(badResult.data).rejects.toBeInstanceOf(z.ZodError);
+    }
+    else {
+        throw new Error("success should be true");
+    }
+});
+(0, vitest_1.test)("async validation non-empty strings", async () => {
+    const base = z.object({
+        hello: z.string().refine((x) => x && x.length > 0),
+        foo: z.string().refine((x) => x && x.length > 0),
+    });
+    const testval = { hello: "", foo: "" };
+    const result1 = base.safeParse(testval);
+    const result2 = base.safeParseAsync(testval);
+    const r1 = result1;
+    await result2.then((r2) => {
+        if (r1.success === false && r2.success === false)
+            (0, vitest_1.expect)(r1.error.issues.length).toBe(r2.error.issues.length); // <--- r1 has length 2, r2 has length 1
+    });
+});
+(0, vitest_1.test)("async validation multiple errors 1", async () => {
+    const base = z.object({
+        hello: z.string(),
+        foo: z.number(),
+    });
+    const testval = { hello: 3, foo: "hello" };
+    const result1 = base.safeParse(testval);
+    const result2 = base.safeParseAsync(testval);
+    const r1 = result1;
+    await result2.then((r2) => {
+        if (r1.success === false && r2.success === false)
+            (0, vitest_1.expect)(r2.error.issues.length).toBe(r1.error.issues.length);
+    });
+});
+(0, vitest_1.test)("async validation multiple errors 2", async () => {
+    const base = (is_async) => z.object({
+        hello: z.string(),
+        foo: z.object({
+            bar: z.number().refine(is_async ? async () => false : () => false),
+        }),
+    });
+    const testval = { hello: 3, foo: { bar: 4 } };
+    const result1 = base().safeParse(testval);
+    const result2 = base(true).safeParseAsync(testval);
+    const r1 = result1;
+    await result2.then((r2) => {
+        if (r1.success === false && r2.success === false)
+            (0, vitest_1.expect)(r2.error.issues.length).toBe(r1.error.issues.length);
+    });
+});
+(0, vitest_1.test)("ensure early async failure prevents follow-up refinement checks", async () => {
+    let count = 0;
+    const base = z.object({
+        hello: z.string(),
+        foo: z
+            .number()
+            .refine(async () => {
+            count++;
+            return true;
+        })
+            .refine(async () => {
+            count++;
+            return true;
+        }, "Good"),
+    });
+    const testval = { hello: "bye", foo: 3 };
+    const result = await base.safeParseAsync(testval);
+    if (result.success === false) {
+        (0, vitest_1.expect)(result.error.issues.length).toBe(1);
+        (0, vitest_1.expect)(count).toBe(1);
+    }
+    // await result.then((r) => {
+    //   if (r.success === false) expect(r.error.issues.length).toBe(1);
+    //   expect(count).toBe(2);
+    // });
+});