zod 3.25.18 → 3.25.21

package/dist/cjs/v4/classic/tests/index.test.js

@@ -594,15 +594,16 @@ const z = __importStar(require("zod/v4"));
     (0, vitest_1.expect)(() => z.parse(e, 123)).toThrow();
 });
 // this returns both a schema and a check
-(0, vitest_1.test)("z.custom", () => {
+(0, vitest_1.test)("z.custom schema", () => {
     const a = z.custom((val) => {
         return typeof val === "string";
     });
     (0, vitest_1.expect)(z.parse(a, "hello")).toEqual("hello");
     (0, vitest_1.expect)(() => z.parse(a, 123)).toThrow();
-    const b = z.string().check(z.custom((val) => val.length > 3));
-    (0, vitest_1.expect)(z.parse(b, "hello")).toEqual("hello");
-    (0, vitest_1.expect)(() => z.parse(b, "hi")).toThrow();
+});
+(0, vitest_1.test)("z.custom check", () => {
+    // @ts-expect-error Inference not possible, use z.refine()
+    z.date().check(z.custom((val) => val.getTime() > 0));
 });
 (0, vitest_1.test)("z.check", () => {
     // this is a more flexible version of z.custom that accepts an arbitrary _parse logic

package/dist/types/v4/classic/schemas.d.ts

@@ -631,7 +631,7 @@ export interface ZodCustom<O = unknown, I = unknown> extends ZodType {
 }
 export declare const ZodCustom: core.$constructor<ZodCustom>;
 export declare function check<O = unknown>(fn: core.CheckFn<O>, params?: string | core.$ZodCustomParams): core.$ZodCheck<O>;
-export declare function custom<O = unknown, I = O>(fn?: (data: O) => unknown, _params?: string | core.$ZodCustomParams | undefined): ZodCustom<O, I>;
+export declare function custom<O>(fn?: (data: unknown) => unknown, _params?: string | core.$ZodCustomParams | undefined): ZodCustom<O, O>;
 export declare function refine<T>(fn: (arg: NoInfer<T>) => util.MaybeAsync<unknown>, _params?: string | core.$ZodCustomParams): core.$ZodCheck<T>;
 export declare function superRefine<T>(fn: (arg: T, payload: RefinementCtx<T>) => void | Promise<void>, params?: string | core.$ZodCustomParams): core.$ZodCheck<T>;
 type ZodInstanceOfParams = core.Params<ZodCustom, core.$ZodIssueCustom, "type" | "check" | "checks" | "fn" | "abort" | "error" | "params" | "path">;

package/dist/types/v4/core/errors.d.ts

@@ -67,7 +67,7 @@ export interface $ZodIssueInvalidValue<Input = unknown> extends $ZodIssueBase {
     readonly input: Input;
 }
 export interface $ZodIssueCustom extends $ZodIssueBase {
-    readonly code?: "custom";
+    readonly code: "custom";
     readonly params?: Record<string, any> | undefined;
     readonly input: unknown;
 }
@@ -96,6 +96,7 @@ export interface $ZodIssueStringIncludes extends $ZodIssueInvalidStringFormat {
 }
 export type $ZodStringFormatIssues = $ZodIssueStringCommonFormats | $ZodIssueStringInvalidRegex | $ZodIssueStringInvalidJWT | $ZodIssueStringStartsWith | $ZodIssueStringEndsWith | $ZodIssueStringIncludes;
 export type $ZodIssue = $ZodIssueInvalidType | $ZodIssueTooBig | $ZodIssueTooSmall | $ZodIssueInvalidStringFormat | $ZodIssueNotMultipleOf | $ZodIssueUnrecognizedKeys | $ZodIssueInvalidUnion | $ZodIssueInvalidKey | $ZodIssueInvalidElement | $ZodIssueInvalidValue | $ZodIssueCustom;
+export type $ZodIssueCode = $ZodIssue["code"];
 export type $ZodRawIssue<T extends $ZodIssueBase = $ZodIssue> = T extends any ? RawIssue<T> : never;
 type RawIssue<T extends $ZodIssueBase> = util.Flatten<util.MakePartial<T, "message" | "path"> & {
     /** The input data */

package/dist/types/v4/core/schemas.d.ts

@@ -723,7 +723,9 @@ export interface $ZodLiteral<T extends util.Primitive = util.Primitive> extends
     _zod: $ZodLiteralInternals<T>;
 }
 export declare const $ZodLiteral: core.$constructor<$ZodLiteral>;
-interface File {
+declare global {
+    interface File {
+    }
 }
 export interface $ZodFileDef extends $ZodTypeDef {
     type: "file";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zod",
-  "version": "3.25.18",
+  "version": "3.25.21",
   "type": "module",
   "author": "Colin McDonnell <zod@colinhacks.com>",
   "description": "TypeScript-first schema declaration and validation library with static type inference",

package/src/v4/classic/schemas.ts

@@ -1962,10 +1962,10 @@ export function check<O = unknown>(fn: core.CheckFn<O>, params?: string | core.$
   return ch;
 }
 
-export function custom<O = unknown, I = O>(
-  fn?: (data: O) => unknown,
+export function custom<O>(
+  fn?: (data: unknown) => unknown,
   _params?: string | core.$ZodCustomParams | undefined
-): ZodCustom<O, I> {
+): ZodCustom<O, O> {
   return core._custom(ZodCustom, fn ?? (() => true), _params) as any;
 }
 

package/src/v4/classic/tests/error-utils.test.ts

@@ -1,6 +1,8 @@
 import { expect, expectTypeOf, test } from "vitest";
 import * as z from "zod/v4";
 
+declare const iss: z.core.$ZodIssueCode;
+
 const Test = z.object({
   f1: z.number(),
   f2: z.string().optional(),

package/src/v4/classic/tests/index.test.ts

@@ -706,17 +706,17 @@ test("z.templateLiteral", () => {
 });
 
 // this returns both a schema and a check
-test("z.custom", () => {
+test("z.custom schema", () => {
   const a = z.custom((val) => {
     return typeof val === "string";
   });
   expect(z.parse(a, "hello")).toEqual("hello");
   expect(() => z.parse(a, 123)).toThrow();
+});
 
-  const b = z.string().check(z.custom((val) => val.length > 3));
-
-  expect(z.parse(b, "hello")).toEqual("hello");
-  expect(() => z.parse(b, "hi")).toThrow();
+test("z.custom check", () => {
+  // @ts-expect-error Inference not possible, use z.refine()
+  z.date().check(z.custom((val) => val.getTime() > 0));
 });
 
 test("z.check", () => {

package/src/v4/core/errors.ts

@@ -86,7 +86,7 @@ export interface $ZodIssueInvalidValue<Input = unknown> extends $ZodIssueBase {
 }
 
 export interface $ZodIssueCustom extends $ZodIssueBase {
-  readonly code?: "custom";
+  readonly code: "custom";
   readonly params?: Record<string, any> | undefined;
   readonly input: unknown;
 }
@@ -149,6 +149,8 @@ export type $ZodIssue =
   | $ZodIssueInvalidValue
   | $ZodIssueCustom;
 
+export type $ZodIssueCode = $ZodIssue["code"];
+
 export type $ZodRawIssue<T extends $ZodIssueBase = $ZodIssue> = T extends any ? RawIssue<T> : never;
 type RawIssue<T extends $ZodIssueBase> = util.Flatten<
   util.MakePartial<T, "message" | "path"> & {

package/src/v4/core/schemas.ts

@@ -2865,7 +2865,10 @@ export const $ZodLiteral: core.$constructor<$ZodLiteral> = /*@__PURE__*/ core.$c
 //////////////////////////////////////////
 
 // provide a fallback in case the File interface isn't provided in the environment
-interface File {}
+declare global {
+  interface File {}
+}
+
 export interface $ZodFileDef extends $ZodTypeDef {
   type: "file";
 }