zod 4.0.3 → 4.0.5

package/package.json

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

package/src/v4/classic/compat.ts

@@ -65,3 +65,6 @@ export type {
 
 /** Included for Zod 3 compatibility */
 export type ZodRawShape = core.$ZodShape;
+
+/** @deprecated Do not use. Stub definition, only included for zod-to-json-schema compatibility. */
+export enum ZodFirstPartyTypeKind {}

package/src/v4/classic/schemas.ts

@@ -61,7 +61,8 @@ export interface ZodType<
 
   // refinements
   refine(check: (arg: core.output<this>) => unknown | Promise<unknown>, params?: string | core.$ZodCustomParams): this;
-  /** @deprecated Use `.check()` instead. */
+  /** @deprecated Use [`.check()`](https://zod.dev/api?id=check) instead.
+   */
   superRefine(
     refinement: (arg: core.output<this>, ctx: RefinementCtx<core.output<this>>) => void | Promise<void>
   ): this;
@@ -1074,17 +1075,7 @@ export interface ZodObject<
   ): ZodObject<util.Extend<Shape, U>, Config>;
 
   /**
-   * @deprecated Use spread syntax and the `.shape` property to combine two object schemas:
-   *
-   * ```ts
-   * const A = z.object({ a: z.string() });
-   * const B = z.object({ b: z.number() });
-   *
-   * const C = z.object({
-   *    ...A.shape,
-   *    ...B.shape
-   * });
-   * ```
+   * @deprecated Use [`A.extend(B.shape)`](https://zod.dev/api?id=extend) instead.
    */
   merge<U extends ZodObject>(other: U): ZodObject<util.Extend<Shape, U["shape"]>, U["_zod"]["config"]>;
 

package/src/v4/classic/tests/discriminated-unions.test.ts

@@ -617,3 +617,32 @@ test("readonly literal discriminator", () => {
     discUnion.parse({ type: "c", a: "hello" });
   }).toThrow();
 });
+
+test("pipes", () => {
+  const schema = z
+    .object({
+      type: z.literal("foo"),
+    })
+    .transform((s) => ({ ...s, v: 2 }));
+
+  expect(schema._zod.propValues).toMatchInlineSnapshot(`
+    {
+      "type": Set {
+        "foo",
+      },
+    }
+  `);
+
+  const schema2 = z.object({
+    type: z.literal("bar"),
+  });
+
+  const combinedSchema = z.discriminatedUnion("type", [schema, schema2], {
+    unionFallback: false,
+  });
+
+  combinedSchema.parse({
+    type: "foo",
+    v: 2,
+  });
+});

package/src/v4/core/schemas.ts

@@ -2039,7 +2039,7 @@ export const $ZodDiscriminatedUnion: core.$constructor<$ZodDiscriminatedUnion> =
       const opts = def.options as $ZodTypeDiscriminable[];
       const map: Map<util.Primitive, $ZodType> = new Map();
       for (const o of opts) {
-        const values = o._zod.propValues[def.discriminator];
+        const values = o._zod.propValues?.[def.discriminator];
         if (!values || values.size === 0)
           throw new Error(`Invalid discriminated union option at index "${def.options.indexOf(o)}"`);
         for (const v of values) {
@@ -3429,6 +3429,7 @@ export interface $ZodPipeInternals<A extends SomeType = $ZodType, B extends Some
   values: A["_zod"]["values"];
   optin: A["_zod"]["optin"];
   optout: B["_zod"]["optout"];
+  propValues: A["_zod"]["propValues"];
 }
 
 export interface $ZodPipe<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodType {
@@ -3440,6 +3441,7 @@ export const $ZodPipe: core.$constructor<$ZodPipe> = /*@__PURE__*/ core.$constru
   util.defineLazy(inst._zod, "values", () => def.in._zod.values);
   util.defineLazy(inst._zod, "optin", () => def.in._zod.optin);
   util.defineLazy(inst._zod, "optout", () => def.out._zod.optout);
+  util.defineLazy(inst._zod, "propValues", () => def.in._zod.propValues);
 
   inst._zod.parse = (payload, ctx) => {
     const left = def.in._zod.run(payload, ctx);

package/src/v4/core/versions.ts

@@ -1,5 +1,5 @@
 export const version = {
   major: 4,
   minor: 0,
-  patch: 3 as number,
+  patch: 5 as number,
 } as const;

package/v4/classic/compat.cjs

@@ -24,7 +24,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.config = exports.$brand = exports.ZodIssueCode = void 0;
+exports.ZodFirstPartyTypeKind = exports.config = exports.$brand = exports.ZodIssueCode = void 0;
 exports.setErrorMap = setErrorMap;
 exports.getErrorMap = getErrorMap;
 const core = __importStar(require("../core/index.cjs"));
@@ -55,3 +55,7 @@ function setErrorMap(map) {
 function getErrorMap() {
     return core.config().customError;
 }
+/** @deprecated Do not use. Stub definition, only included for zod-to-json-schema compatibility. */
+var ZodFirstPartyTypeKind;
+(function (ZodFirstPartyTypeKind) {
+})(ZodFirstPartyTypeKind || (exports.ZodFirstPartyTypeKind = ZodFirstPartyTypeKind = {}));

package/v4/classic/compat.d.cts

@@ -45,3 +45,6 @@ ZodType as ZodSchema,
 ZodType as Schema, };
 /** Included for Zod 3 compatibility */
 export type ZodRawShape = core.$ZodShape;
+/** @deprecated Do not use. Stub definition, only included for zod-to-json-schema compatibility. */
+export declare enum ZodFirstPartyTypeKind {
+}

package/v4/classic/compat.d.ts

@@ -45,3 +45,6 @@ ZodType as ZodSchema,
 ZodType as Schema, };
 /** Included for Zod 3 compatibility */
 export type ZodRawShape = core.$ZodShape;
+/** @deprecated Do not use. Stub definition, only included for zod-to-json-schema compatibility. */
+export declare enum ZodFirstPartyTypeKind {
+}

package/v4/classic/compat.js

@@ -25,3 +25,7 @@ export function setErrorMap(map) {
 export function getErrorMap() {
     return core.config().customError;
 }
+/** @deprecated Do not use. Stub definition, only included for zod-to-json-schema compatibility. */
+export var ZodFirstPartyTypeKind;
+(function (ZodFirstPartyTypeKind) {
+})(ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {}));

package/v4/classic/schemas.d.cts

@@ -25,7 +25,8 @@ export interface ZodType<out Output = unknown, out Input = unknown, out Internal
     safeParseAsync(data: unknown, params?: core.ParseContext<core.$ZodIssue>): Promise<parse.ZodSafeParseResult<core.output<this>>>;
     spa: (data: unknown, params?: core.ParseContext<core.$ZodIssue>) => Promise<parse.ZodSafeParseResult<core.output<this>>>;
     refine(check: (arg: core.output<this>) => unknown | Promise<unknown>, params?: string | core.$ZodCustomParams): this;
-    /** @deprecated Use `.check()` instead. */
+    /** @deprecated Use [`.check()`](https://zod.dev/api?id=check) instead.
+     */
     superRefine(refinement: (arg: core.output<this>, ctx: RefinementCtx<core.output<this>>) => void | Promise<void>): this;
     overwrite(fn: (x: core.output<this>) => core.output<this>): this;
     optional(): ZodOptional<this>;
@@ -416,17 +417,7 @@ out Shape extends core.$ZodShape = core.$ZodLooseShape, out Config extends core.
     strip(): ZodObject<Shape, core.$strip>;
     extend<U extends core.$ZodLooseShape & Partial<Record<keyof Shape, core.SomeType>>>(shape: U): ZodObject<util.Extend<Shape, U>, Config>;
     /**
-     * @deprecated Use spread syntax and the `.shape` property to combine two object schemas:
-     *
-     * ```ts
-     * const A = z.object({ a: z.string() });
-     * const B = z.object({ b: z.number() });
-     *
-     * const C = z.object({
-     *    ...A.shape,
-     *    ...B.shape
-     * });
-     * ```
+     * @deprecated Use [`A.extend(B.shape)`](https://zod.dev/api?id=extend) instead.
      */
     merge<U extends ZodObject>(other: U): ZodObject<util.Extend<Shape, U["shape"]>, U["_zod"]["config"]>;
     pick<M extends util.Mask<keyof Shape>>(mask: M): ZodObject<util.Flatten<Pick<Shape, Extract<keyof Shape, keyof M>>>, Config>;

package/v4/classic/schemas.d.ts

@@ -25,7 +25,8 @@ export interface ZodType<out Output = unknown, out Input = unknown, out Internal
     safeParseAsync(data: unknown, params?: core.ParseContext<core.$ZodIssue>): Promise<parse.ZodSafeParseResult<core.output<this>>>;
     spa: (data: unknown, params?: core.ParseContext<core.$ZodIssue>) => Promise<parse.ZodSafeParseResult<core.output<this>>>;
     refine(check: (arg: core.output<this>) => unknown | Promise<unknown>, params?: string | core.$ZodCustomParams): this;
-    /** @deprecated Use `.check()` instead. */
+    /** @deprecated Use [`.check()`](https://zod.dev/api?id=check) instead.
+     */
     superRefine(refinement: (arg: core.output<this>, ctx: RefinementCtx<core.output<this>>) => void | Promise<void>): this;
     overwrite(fn: (x: core.output<this>) => core.output<this>): this;
     optional(): ZodOptional<this>;
@@ -416,17 +417,7 @@ out Shape extends core.$ZodShape = core.$ZodLooseShape, out Config extends core.
     strip(): ZodObject<Shape, core.$strip>;
     extend<U extends core.$ZodLooseShape & Partial<Record<keyof Shape, core.SomeType>>>(shape: U): ZodObject<util.Extend<Shape, U>, Config>;
     /**
-     * @deprecated Use spread syntax and the `.shape` property to combine two object schemas:
-     *
-     * ```ts
-     * const A = z.object({ a: z.string() });
-     * const B = z.object({ b: z.number() });
-     *
-     * const C = z.object({
-     *    ...A.shape,
-     *    ...B.shape
-     * });
-     * ```
+     * @deprecated Use [`A.extend(B.shape)`](https://zod.dev/api?id=extend) instead.
      */
     merge<U extends ZodObject>(other: U): ZodObject<util.Extend<Shape, U["shape"]>, U["_zod"]["config"]>;
     pick<M extends util.Mask<keyof Shape>>(mask: M): ZodObject<util.Flatten<Pick<Shape, Extract<keyof Shape, keyof M>>>, Config>;

package/v4/core/schemas.cjs

@@ -984,7 +984,7 @@ core.$constructor("$ZodDiscriminatedUnion", (inst, def) => {
         const opts = def.options;
         const map = new Map();
         for (const o of opts) {
-            const values = o._zod.propValues[def.discriminator];
+            const values = o._zod.propValues?.[def.discriminator];
             if (!values || values.size === 0)
                 throw new Error(`Invalid discriminated union option at index "${def.options.indexOf(o)}"`);
             for (const v of values) {
@@ -1617,6 +1617,7 @@ exports.$ZodPipe = core.$constructor("$ZodPipe", (inst, def) => {
     util.defineLazy(inst._zod, "values", () => def.in._zod.values);
     util.defineLazy(inst._zod, "optin", () => def.in._zod.optin);
     util.defineLazy(inst._zod, "optout", () => def.out._zod.optout);
+    util.defineLazy(inst._zod, "propValues", () => def.in._zod.propValues);
     inst._zod.parse = (payload, ctx) => {
         const left = def.in._zod.run(payload, ctx);
         if (left instanceof Promise) {

package/v4/core/schemas.d.cts

@@ -935,6 +935,7 @@ export interface $ZodPipeInternals<A extends SomeType = $ZodType, B extends Some
     values: A["_zod"]["values"];
     optin: A["_zod"]["optin"];
     optout: B["_zod"]["optout"];
+    propValues: A["_zod"]["propValues"];
 }
 export interface $ZodPipe<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodType {
     _zod: $ZodPipeInternals<A, B>;

package/v4/core/schemas.d.ts

@@ -935,6 +935,7 @@ export interface $ZodPipeInternals<A extends SomeType = $ZodType, B extends Some
     values: A["_zod"]["values"];
     optin: A["_zod"]["optin"];
     optout: B["_zod"]["optout"];
+    propValues: A["_zod"]["propValues"];
 }
 export interface $ZodPipe<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodType {
     _zod: $ZodPipeInternals<A, B>;

package/v4/core/schemas.js

@@ -953,7 +953,7 @@ core.$constructor("$ZodDiscriminatedUnion", (inst, def) => {
         const opts = def.options;
         const map = new Map();
         for (const o of opts) {
-            const values = o._zod.propValues[def.discriminator];
+            const values = o._zod.propValues?.[def.discriminator];
             if (!values || values.size === 0)
                 throw new Error(`Invalid discriminated union option at index "${def.options.indexOf(o)}"`);
             for (const v of values) {
@@ -1586,6 +1586,7 @@ export const $ZodPipe = /*@__PURE__*/ core.$constructor("$ZodPipe", (inst, def)
     util.defineLazy(inst._zod, "values", () => def.in._zod.values);
     util.defineLazy(inst._zod, "optin", () => def.in._zod.optin);
     util.defineLazy(inst._zod, "optout", () => def.out._zod.optout);
+    util.defineLazy(inst._zod, "propValues", () => def.in._zod.propValues);
     inst._zod.parse = (payload, ctx) => {
         const left = def.in._zod.run(payload, ctx);
         if (left instanceof Promise) {

package/v4/core/versions.cjs

@@ -4,5 +4,5 @@ exports.version = void 0;
 exports.version = {
     major: 4,
     minor: 0,
-    patch: 3,
+    patch: 5,
 };

package/v4/core/versions.js

@@ -1,5 +1,5 @@
 export const version = {
     major: 4,
     minor: 0,
-    patch: 3,
+    patch: 5,
 };