zod 3.25.21 → 3.25.22

package/src/v4/mini/tests/assignability.test.ts

@@ -1,117 +0,0 @@
-import { test } from "vitest";
-
-import * as z from "zod/v4-mini";
-
-test("assignability", () => {
-  // $ZodString
-  z.string() satisfies z.core.$ZodString;
-
-  // $ZodNumber
-  z.number() satisfies z.core.$ZodNumber;
-
-  // $ZodBigInt
-  z.bigint() satisfies z.core.$ZodBigInt;
-
-  // $ZodBoolean
-  z.boolean() satisfies z.core.$ZodBoolean;
-
-  // $ZodDate
-  z.date() satisfies z.core.$ZodDate;
-
-  // $ZodSymbol
-  z.symbol() satisfies z.core.$ZodSymbol;
-
-  // $ZodUndefined
-  z.undefined() satisfies z.core.$ZodUndefined;
-
-  // $ZodNullable
-  z.nullable(z.string()) satisfies z.core.$ZodNullable;
-
-  // $ZodNull
-  z.null() satisfies z.core.$ZodNull;
-
-  // $ZodAny
-  z.any() satisfies z.core.$ZodAny;
-
-  // $ZodUnknown
-  z.unknown() satisfies z.core.$ZodUnknown;
-
-  // $ZodNever
-  z.never() satisfies z.core.$ZodNever;
-
-  // $ZodVoid
-  z.void() satisfies z.core.$ZodVoid;
-
-  // $ZodArray
-  z.array(z.string()) satisfies z.core.$ZodArray;
-
-  // $ZodObject
-  z.object({ key: z.string() }) satisfies z.core.$ZodObject;
-
-  // $ZodUnion
-  z.union([z.string(), z.number()]) satisfies z.core.$ZodUnion;
-
-  // $ZodIntersection
-  z.intersection(z.string(), z.number()) satisfies z.core.$ZodIntersection;
-
-  // $ZodTuple
-  z.tuple([z.string(), z.number()]) satisfies z.core.$ZodTuple;
-
-  // $ZodRecord
-  z.record(z.string(), z.number()) satisfies z.core.$ZodRecord;
-
-  // $ZodMap
-  z.map(z.string(), z.number()) satisfies z.core.$ZodMap;
-
-  // $ZodSet
-  z.set(z.string()) satisfies z.core.$ZodSet;
-
-  // $ZodLiteral
-  z.literal("example") satisfies z.core.$ZodLiteral;
-
-  // $ZodEnum
-  z.enum(["a", "b", "c"]) satisfies z.core.$ZodEnum;
-
-  // $ZodPromise
-  z.promise(z.string()) satisfies z.core.$ZodPromise;
-
-  // $ZodLazy
-  const lazySchema = z.lazy(() => z.string());
-  lazySchema satisfies z.core.$ZodLazy;
-
-  // $ZodOptional
-  z.optional(z.string()) satisfies z.core.$ZodOptional;
-
-  // $ZodDefault
-  z._default(z.string(), "default") satisfies z.core.$ZodDefault;
-
-  // $ZodTemplateLiteral
-  z.templateLiteral([z.literal("a"), z.literal("b")]) satisfies z.core.$ZodTemplateLiteral;
-
-  // $ZodCustom
-  z.custom<string>((val) => typeof val === "string") satisfies z.core.$ZodCustom;
-
-  // $ZodTransform
-  z.transform((val) => val as string) satisfies z.core.$ZodTransform;
-
-  // $ZodNonOptional
-  z.nonoptional(z.optional(z.string())) satisfies z.core.$ZodNonOptional;
-
-  // $ZodReadonly
-  z.readonly(z.object({ key: z.string() })) satisfies z.core.$ZodReadonly;
-
-  // $ZodNaN
-  z.nan() satisfies z.core.$ZodNaN;
-
-  // $ZodPipe
-  z.pipe(z.unknown(), z.number()) satisfies z.core.$ZodPipe;
-
-  // $ZodSuccess
-  z.success(z.string()) satisfies z.core.$ZodSuccess;
-
-  // $ZodCatch
-  z.catch(z.string(), "fallback") satisfies z.core.$ZodCatch;
-
-  // $ZodFile
-  z.file() satisfies z.core.$ZodFile;
-});

package/src/v4/mini/tests/brand.test.ts

@@ -1,51 +0,0 @@
-import { expectTypeOf, test } from "vitest";
-import * as z from "../index.js";
-
-test("branded types", () => {
-  const mySchema = z
-    .object({
-      name: z.string(),
-    })
-    .brand<"superschema">();
-
-  // simple branding
-  type MySchema = z.infer<typeof mySchema>;
-  // Using true for type equality assertion
-  expectTypeOf<MySchema>().toEqualTypeOf<{ name: string } & z.$brand<"superschema">>();
-
-  const doStuff = (arg: MySchema) => arg;
-  doStuff(z.parse(mySchema, { name: "hello there" }));
-
-  // inheritance
-  const extendedSchema = mySchema.brand<"subschema">();
-  type ExtendedSchema = z.infer<typeof extendedSchema>;
-  expectTypeOf<ExtendedSchema>().toEqualTypeOf<{ name: string } & z.$brand<"superschema"> & z.$brand<"subschema">>();
-
-  doStuff(z.parse(extendedSchema, { name: "hello again" }));
-
-  // number branding
-  const numberSchema = z.number().brand<42>();
-  type NumberSchema = z.infer<typeof numberSchema>;
-  expectTypeOf<NumberSchema>().toEqualTypeOf<number & { [z.$brand]: { 42: true } }>();
-
-  // symbol branding
-  const MyBrand: unique symbol = Symbol("hello");
-  type MyBrand = typeof MyBrand;
-  const symbolBrand = z.number().brand<"sup">().brand<typeof MyBrand>();
-  type SymbolBrand = z.infer<typeof symbolBrand>;
-  // number & { [z.$brand]: { sup: true, [MyBrand]: true } }
-  expectTypeOf<SymbolBrand>().toEqualTypeOf<number & z.$brand<"sup"> & z.$brand<MyBrand>>();
-
-  // keeping brands out of input types
-  const age = z.number().brand<"age">();
-  type Age1 = z.infer<typeof age>;
-  type AgeInput1 = z.input<typeof age>;
-
-  // Using not for type inequality assertion
-  expectTypeOf<AgeInput1>().not.toEqualTypeOf<Age1>();
-  expectTypeOf<number>().toEqualTypeOf<AgeInput1>();
-  expectTypeOf<number & z.$brand<"age">>().toEqualTypeOf<Age1>();
-
-  // @ts-expect-error
-  doStuff({ name: "hello there!" });
-});

package/src/v4/mini/tests/checks.test.ts

@@ -1,144 +0,0 @@
-import { expect, test } from "vitest";
-import * as z from "../index.js";
-
-// lt;
-test("z.lt", () => {
-  const a = z.number().check(z.lt(10));
-  expect(z.safeParse(a, 9).success).toEqual(true);
-  expect(z.safeParse(a, 9).data).toEqual(9);
-  expect(z.safeParse(a, 10).success).toEqual(false);
-});
-
-// lte;
-test("z.lte", () => {
-  const a = z.number().check(z.lte(10));
-  expect(z.safeParse(a, 10).success).toEqual(true);
-  expect(z.safeParse(a, 10).data).toEqual(10);
-  expect(z.safeParse(a, 11).success).toEqual(false);
-});
-
-// min;
-test("z.max", () => {
-  const a = z.number().check(z.maximum(10));
-  expect(z.safeParse(a, 10).success).toEqual(true);
-  expect(z.safeParse(a, 10).data).toEqual(10);
-  expect(z.safeParse(a, 11).success).toEqual(false);
-});
-
-// gt;
-test("z.gt", () => {
-  const a = z.number().check(z.gt(10));
-  expect(z.safeParse(a, 11).success).toEqual(true);
-  expect(z.safeParse(a, 11).data).toEqual(11);
-  expect(z.safeParse(a, 10).success).toEqual(false);
-});
-
-// gte;
-test("z.gte", () => {
-  const a = z.number().check(z.gte(10));
-  expect(z.safeParse(a, 10).success).toEqual(true);
-  expect(z.safeParse(a, 10).data).toEqual(10);
-  expect(z.safeParse(a, 9).success).toEqual(false);
-});
-
-// min;
-test("z.min", () => {
-  const a = z.number().check(z.minimum(10));
-  expect(z.safeParse(a, 10).success).toEqual(true);
-  expect(z.safeParse(a, 10).data).toEqual(10);
-  expect(z.safeParse(a, 9).success).toEqual(false);
-});
-
-// maxSize;
-test("z.maxLength", () => {
-  const a = z.array(z.string()).check(z.maxLength(3));
-  expect(z.safeParse(a, ["a", "b", "c"]).success).toEqual(true);
-  expect(z.safeParse(a, ["a", "b", "c", "d"]).success).toEqual(false);
-});
-
-// minSize;
-test("z.minLength", () => {
-  const a = z.array(z.string()).check(z.minLength(3));
-  expect(z.safeParse(a, ["a", "b"]).success).toEqual(false);
-  expect(z.safeParse(a, ["a", "b", "c"]).success).toEqual(true);
-});
-
-// size;
-test("z.length", () => {
-  const a = z.array(z.string()).check(z.length(3));
-  expect(z.safeParse(a, ["a", "b"]).success).toEqual(false);
-  expect(z.safeParse(a, ["a", "b", "c"]).success).toEqual(true);
-  expect(z.safeParse(a, ["a", "b", "c", "d"]).success).toEqual(false);
-});
-
-// regex;
-test("z.regex", () => {
-  const a = z.string().check(z.regex(/^aaa$/));
-  expect(z.safeParse(a, "aaa")).toMatchObject({ success: true, data: "aaa" });
-  expect(z.safeParse(a, "aa")).toMatchObject({ success: false });
-});
-
-// includes;
-test("z.includes", () => {
-  const a = z.string().check(z.includes("asdf"));
-  z.parse(a, "qqqasdfqqq");
-  z.parse(a, "asdf");
-  z.parse(a, "qqqasdf");
-  z.parse(a, "asdfqqq");
-  expect(z.safeParse(a, "qqq")).toMatchObject({ success: false });
-});
-
-// startsWith;
-test("z.startsWith", () => {
-  const a = z.string().check(z.startsWith("asdf"));
-  z.parse(a, "asdf");
-  z.parse(a, "asdfqqq");
-  expect(z.safeParse(a, "qqq")).toMatchObject({ success: false });
-});
-
-// endsWith;
-test("z.endsWith", () => {
-  const a = z.string().check(z.endsWith("asdf"));
-  z.parse(a, "asdf");
-  z.parse(a, "qqqasdf");
-  expect(z.safeParse(a, "asdfqqq")).toMatchObject({ success: false });
-});
-
-// lowercase;
-test("z.lowercase", () => {
-  const a = z.string().check(z.lowercase());
-  z.parse(a, "asdf");
-  expect(z.safeParse(a, "ASDF")).toMatchObject({ success: false });
-});
-
-// uppercase;
-test("z.uppercase", () => {
-  const a = z.string().check(z.uppercase());
-  z.parse(a, "ASDF");
-  expect(z.safeParse(a, "asdf")).toMatchObject({ success: false });
-});
-
-// filename;
-// fileType;
-// overwrite;
-test("z.overwrite", () => {
-  const a = z.string().check(z.overwrite((val) => val.toUpperCase()));
-  expect(z.safeParse(a, "asdf")).toMatchObject({ data: "ASDF" });
-});
-
-// normalize;
-// trim;
-// toLowerCase;
-// toUpperCase;
-// property
-
-test("abort early", () => {
-  const schema = z.string().check(
-    z.refine((val) => val.length > 1),
-    z.refine((val) => val.length > 2, { abort: true }),
-    z.refine((val) => val.length > 3)
-  );
-  const data = "";
-  const result = z.safeParse(schema, data);
-  expect(result.error!.issues.length).toEqual(2);
-});

package/src/v4/mini/tests/computed.test.ts

@@ -1,36 +0,0 @@
-import { expect, test } from "vitest";
-import * as z from "zod/v4-mini";
-import { util as zc } from "zod/v4/core";
-
-test("min/max", () => {
-  const a = z.number().check(z.minimum(5), z.minimum(6), z.minimum(7), z.maximum(10), z.maximum(11), z.maximum(12));
-
-  expect(a._zod.bag.minimum).toEqual(7);
-  expect(a._zod.bag.maximum).toEqual(10);
-});
-
-test("multipleOf", () => {
-  const b = z.number().check(z.multipleOf(5));
-  expect(b._zod.bag.multipleOf).toEqual(5);
-});
-
-test("int64 format", () => {
-  const c = z.int64();
-  expect(c._zod.bag.format).toEqual("int64");
-  expect(c._zod.bag.minimum).toEqual(zc.BIGINT_FORMAT_RANGES.int64[0]);
-  expect(c._zod.bag.maximum).toEqual(zc.BIGINT_FORMAT_RANGES.int64[1]);
-});
-
-test("int32 format", () => {
-  const d = z.int32();
-  expect(d._zod.bag.format).toEqual("int32");
-  expect(d._zod.bag.minimum).toEqual(zc.NUMBER_FORMAT_RANGES.int32[0]);
-  expect(d._zod.bag.maximum).toEqual(zc.NUMBER_FORMAT_RANGES.int32[1]);
-});
-
-test("array size", () => {
-  const e = z.array(z.string()).check(z.length(5));
-  expect(e._zod.bag.length).toEqual(5);
-  expect(e._zod.bag.minimum).toEqual(5);
-  expect(e._zod.bag.maximum).toEqual(5);
-});

package/src/v4/mini/tests/error.test.ts

@@ -1,22 +0,0 @@
-import { expect, test } from "vitest";
-import * as z from "zod/v4-mini";
-
-test("no locale by default", () => {
-  const result = z.safeParse(z.string(), 12);
-  expect(result.success).toEqual(false);
-  expect(result.error!.issues.length).toEqual(1);
-  expect(result.error!.issues[0].message).toEqual("Invalid input");
-});
-
-test("error inheritance", () => {
-  const e1 = z.string().safeParse(123).error!;
-  expect(e1).toBeInstanceOf(z.core.$ZodError);
-  // expect(e1).not.toBeInstanceOf(Error);
-
-  try {
-    z.string().parse(123);
-  } catch (e2) {
-    expect(e2).toBeInstanceOf(z.core.$ZodRealError);
-    expect(e2).toBeInstanceOf(Error);
-  }
-});

package/src/v4/mini/tests/functions.test.ts

@@ -1,43 +0,0 @@
-import { expect, test } from "vitest";
-// import * as z from "zod/v4/core";
-
-test("z.function", () => {
-  expect(true).toEqual(true);
-});
-
-// test("z.function", () => {
-//   const a = z.function({
-//     args: z.tuple([z.string()]),
-//     returns: z.string(),
-//   });
-
-//   const myFunc = a.implement((name: string | number) => `Hello, ${name}!`);
-
-//   expect(myFunc("world")).toEqual("Hello, world!");
-//   expect(() => myFunc(123 as any)).toThrow();
-
-//   // this won't run
-//   () => {
-//     // @ts-expect-error
-//     const r = myFunc(123);
-//     expectTypeOf(r).toEqualTypeOf<string>();
-//   };
-// });
-
-// test("z.function async", async () => {
-//   const b = z.function({
-//     args: z.tuple([z.string()]).$check(async (_) => {}),
-//     returns: z.string().$check(async (_) => {}),
-//   });
-//   const myFuncAsync = b.implementAsync(async (name) => `Hello, ${name}!`);
-
-//   expect(await myFuncAsync("world")).toEqual("Hello, world!");
-//   expect(myFuncAsync(123 as any)).rejects.toThrow();
-
-//   // this won't run
-//   () => {
-//     // @ts-expect-error
-//     const r = myFuncAsync(123);
-//     expectTypeOf(r).toEqualTypeOf<Promise<string>>();
-//   };
-// });