zod 3.25.44 → 3.25.46

package/dist/cjs/v4/core/schemas.js

@@ -935,6 +935,7 @@ core.$constructor("$ZodDiscriminatedUnion", (inst, def) => {
         const propValues = {};
         for (const option of def.options) {
             const pv = option._zod.propValues;
+            console.dir(pv, { depth: null });
             if (!pv || Object.keys(pv).length === 0)
                 throw new Error(`Invalid discriminated union option at index "${def.options.indexOf(option)}"`);
             for (const [k, v] of Object.entries(pv)) {
@@ -952,6 +953,8 @@ core.$constructor("$ZodDiscriminatedUnion", (inst, def) => {
         const map = new Map();
         for (const o of opts) {
             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) {
                 if (map.has(v)) {
                     throw new Error(`Duplicate discriminator value "${String(v)}"`);
@@ -1338,10 +1341,7 @@ function handleSetResult(result, final) {
 }
 exports.$ZodEnum = core.$constructor("$ZodEnum", (inst, def) => {
     exports.$ZodType.init(inst, def);
-    const numericValues = Object.values(def.entries).filter((v) => typeof v === "number");
-    const values = Object.entries(def.entries)
-        .filter(([k, _]) => numericValues.indexOf(+k) === -1)
-        .map(([_, v]) => v);
+    const values = util.getEnumValues(def.entries);
     inst._zod.values = new Set(values);
     inst._zod.pattern = new RegExp(`^(${values
         .filter((k) => util.propertyKeyTypes.has(typeof k))

package/dist/cjs/v4/core/to-json-schema.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.JSONSchemaGenerator = void 0;
 exports.toJSONSchema = toJSONSchema;
 const registries_js_1 = require("./registries.js");
+const util_js_1 = require("./util.js");
 class JSONSchemaGenerator {
     constructor(params) {
         this.counter = 0;
@@ -322,7 +323,13 @@ class JSONSchemaGenerator {
                 }
                 case "enum": {
                     const json = _json;
-                    json.enum = Object.values(def.entries);
+                    const values = (0, util_js_1.getEnumValues)(def.entries);
+                    // Number enums can have both string and number values
+                    if (values.every((v) => typeof v === "number"))
+                        json.type = "number";
+                    if (values.every((v) => typeof v === "string"))
+                        json.type = "string";
+                    json.enum = values;
                     break;
                 }
                 case "literal": {

package/dist/cjs/v4/core/util.js

@@ -6,7 +6,7 @@ exports.assertNotEqual = assertNotEqual;
 exports.assertIs = assertIs;
 exports.assertNever = assertNever;
 exports.assert = assert;
-exports.getValidEnumValues = getValidEnumValues;
+exports.getEnumValues = getEnumValues;
 exports.joinValues = joinValues;
 exports.jsonStringifyReplacer = jsonStringifyReplacer;
 exports.cached = cached;
@@ -54,13 +54,12 @@ function assertNever(_x) {
     throw new Error();
 }
 function assert(_) { }
-function getValidEnumValues(obj) {
-    const validKeys = Object.keys(obj).filter((k) => typeof obj[obj[k]] !== "number");
-    const filtered = {};
-    for (const k of validKeys) {
-        filtered[k] = obj[k];
-    }
-    return Object.values(filtered);
+function getEnumValues(entries) {
+    const numericValues = Object.values(entries).filter((v) => typeof v === "number");
+    const values = Object.entries(entries)
+        .filter(([k, _]) => numericValues.indexOf(+k) === -1)
+        .map(([_, v]) => v);
+    return values;
 }
 function joinValues(array, separator = "|") {
     return array.map((val) => stringifyPrimitive(val)).join(separator);

package/dist/esm/v4/core/schemas.js

@@ -904,6 +904,7 @@ core.$constructor("$ZodDiscriminatedUnion", (inst, def) => {
         const propValues = {};
         for (const option of def.options) {
             const pv = option._zod.propValues;
+            console.dir(pv, { depth: null });
             if (!pv || Object.keys(pv).length === 0)
                 throw new Error(`Invalid discriminated union option at index "${def.options.indexOf(option)}"`);
             for (const [k, v] of Object.entries(pv)) {
@@ -921,6 +922,8 @@ core.$constructor("$ZodDiscriminatedUnion", (inst, def) => {
         const map = new Map();
         for (const o of opts) {
             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) {
                 if (map.has(v)) {
                     throw new Error(`Duplicate discriminator value "${String(v)}"`);
@@ -1307,10 +1310,7 @@ function handleSetResult(result, final) {
 }
 export const $ZodEnum = /*@__PURE__*/ core.$constructor("$ZodEnum", (inst, def) => {
     $ZodType.init(inst, def);
-    const numericValues = Object.values(def.entries).filter((v) => typeof v === "number");
-    const values = Object.entries(def.entries)
-        .filter(([k, _]) => numericValues.indexOf(+k) === -1)
-        .map(([_, v]) => v);
+    const values = util.getEnumValues(def.entries);
     inst._zod.values = new Set(values);
     inst._zod.pattern = new RegExp(`^(${values
         .filter((k) => util.propertyKeyTypes.has(typeof k))

package/dist/esm/v4/core/to-json-schema.js

@@ -1,4 +1,5 @@
 import { $ZodRegistry, globalRegistry } from "./registries.js";
+import { getEnumValues } from "./util.js";
 export class JSONSchemaGenerator {
     constructor(params) {
         this.counter = 0;
@@ -318,7 +319,13 @@ export class JSONSchemaGenerator {
                 }
                 case "enum": {
                     const json = _json;
-                    json.enum = Object.values(def.entries);
+                    const values = getEnumValues(def.entries);
+                    // Number enums can have both string and number values
+                    if (values.every((v) => typeof v === "number"))
+                        json.type = "number";
+                    if (values.every((v) => typeof v === "string"))
+                        json.type = "string";
+                    json.enum = values;
                     break;
                 }
                 case "literal": {

package/dist/esm/v4/core/util.js

@@ -10,13 +10,12 @@ export function assertNever(_x) {
     throw new Error();
 }
 export function assert(_) { }
-export function getValidEnumValues(obj) {
-    const validKeys = Object.keys(obj).filter((k) => typeof obj[obj[k]] !== "number");
-    const filtered = {};
-    for (const k of validKeys) {
-        filtered[k] = obj[k];
-    }
-    return Object.values(filtered);
+export function getEnumValues(entries) {
+    const numericValues = Object.values(entries).filter((v) => typeof v === "number");
+    const values = Object.entries(entries)
+        .filter(([k, _]) => numericValues.indexOf(+k) === -1)
+        .map(([_, v]) => v);
+    return values;
 }
 export function joinValues(array, separator = "|") {
     return array.map((val) => stringifyPrimitive(val)).join(separator);

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

@@ -49,7 +49,9 @@ export interface $ZodTypeInternals<out O = unknown, out I = unknown> {
     /** @internal Indicates that a schema output type should be considered optional inside objects.
      * @default Required
      */
+    /** @internal */
     optin?: "optional" | undefined;
+    /** @internal */
     optout?: "optional" | undefined;
     /** @internal The set of literal values that will pass validation. Must be an exhaustive set. Used to determine optionality in z.record().
      *
@@ -515,7 +517,7 @@ export interface $ZodObjectDef<Shape extends $ZodShape = $ZodShape> extends $Zod
 }
 export interface $ZodObjectInternals<
 /** @ts-ignore Cast variance */
-out Shape extends Readonly<$ZodShape> = Readonly<$ZodShape>, out Config extends $ZodObjectConfig = $ZodObjectConfig> extends $ZodTypeInternals<any, any> {
+out Shape extends Readonly<$ZodShape> = Readonly<$ZodShape>, out Config extends $ZodObjectConfig = $ZodObjectConfig> extends $ZodTypeInternals<$InferObjectOutputFallback<Shape, Config["out"]>, $InferObjectInputFallback<Shape, Config["in"]>> {
     def: $ZodObjectDef<Shape>;
     config: Config;
     isst: errors.$ZodIssueInvalidType | errors.$ZodIssueUnrecognizedKeys;
@@ -534,6 +536,12 @@ type OptionalInSchema = {
         optin: "optional";
     };
 };
+export type $InferObjectOutputFallback<T extends $ZodLooseShape, Extra extends Record<string, unknown>> = string extends keyof T ? object : keyof (T & Extra) extends never ? Record<string, never> : util.Prettify<{
+    -readonly [k in keyof T]: core.output<T[k]>;
+} & Extra>;
+export type $InferObjectInputFallback<T extends $ZodLooseShape, Extra extends Record<string, unknown>> = string extends keyof T ? object : keyof (T & Extra) extends never ? Record<string, never> : util.Prettify<{
+    -readonly [k in keyof T]: core.input<T[k]>;
+} & Extra>;
 export type $InferObjectOutput<T extends $ZodLooseShape, Extra extends Record<string, unknown>> = string extends keyof T ? object : keyof (T & Extra) extends never ? Record<string, never> : util.Prettify<{
     -readonly [k in keyof T as T[k] extends OptionalOutSchema ? never : k]: core.output<T[k]>;
 } & {
@@ -655,8 +663,8 @@ export interface $ZodRecordDef extends $ZodTypeDef {
     keyType: $ZodRecordKey;
     valueType: $ZodType;
 }
-type $InferZodRecordOutput<Key extends $ZodRecordKey = $ZodRecordKey, Value extends $ZodType = $ZodType> = undefined extends Key["_zod"]["values"] ? string extends Key["_zod"]["output"] ? Record<Key["_zod"]["output"], core.output<Value>> : number extends Key["_zod"]["output"] ? Record<Key["_zod"]["output"], core.output<Value>> : symbol extends Key["_zod"]["output"] ? Record<Key["_zod"]["output"], core.output<Value>> : Partial<Record<Key["_zod"]["output"], core.output<Value>>> : Record<Key["_zod"]["output"], core.output<Value>>;
-type $InferZodRecordInput<Key extends $ZodRecordKey = $ZodRecordKey, Value extends $ZodType = $ZodType> = undefined extends Key["_zod"]["values"] ? string extends Key["_zod"]["input"] ? Record<Key["_zod"]["input"], Value["_zod"]["input"]> : number extends Key["_zod"]["input"] ? Record<Key["_zod"]["input"], Value["_zod"]["input"]> : symbol extends Key["_zod"]["input"] ? Record<Key["_zod"]["input"], Value["_zod"]["input"]> : Partial<Record<Key["_zod"]["input"], Value["_zod"]["input"]>> : Record<Key["_zod"]["input"], Value["_zod"]["input"]>;
+export type $InferZodRecordOutput<Key extends $ZodRecordKey = $ZodRecordKey, Value extends $ZodType = $ZodType> = undefined extends Key["_zod"]["values"] ? string extends core.output<Key> ? Record<core.output<Key>, core.output<Value>> : number extends core.output<Key> ? Record<core.output<Key>, core.output<Value>> : symbol extends core.output<Key> ? Record<core.output<Key>, core.output<Value>> : Partial<Record<core.output<Key>, core.output<Value>>> : Record<core.output<Key>, core.output<Value>>;
+export type $InferZodRecordInput<Key extends $ZodRecordKey = $ZodRecordKey, Value extends $ZodType = $ZodType> = undefined extends Key["_zod"]["values"] ? string extends core.input<Key> ? Record<core.input<Key>, core.input<Value>> : number extends core.input<Key> ? Record<core.input<Key>, core.input<Value>> : symbol extends core.input<Key> ? Record<core.input<Key>, core.input<Value>> : Partial<Record<core.input<Key>, core.input<Value>>> : Record<core.input<Key>, core.input<Value>>;
 export interface $ZodRecordInternals<Key extends $ZodRecordKey = $ZodRecordKey, Value extends $ZodType = $ZodType> extends $ZodTypeInternals<$InferZodRecordOutput<Key, Value>, $InferZodRecordInput<Key, Value>> {
     def: $ZodRecordDef;
     isst: errors.$ZodIssueInvalidType | errors.$ZodIssueInvalidKey<Record<PropertyKey, unknown>>;

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

@@ -111,7 +111,7 @@ export declare function assertNotEqual<A, B>(val: AssertNotEqual<A, B>): AssertN
 export declare function assertIs<T>(_arg: T): void;
 export declare function assertNever(_x: never): never;
 export declare function assert<T>(_: any): asserts _ is T;
-export declare function getValidEnumValues(obj: any): any;
+export declare function getEnumValues(entries: EnumLike): EnumValue[];
 export declare function joinValues<T extends Primitive[]>(array: T, separator?: string): string;
 export declare function jsonStringifyReplacer(_: string, value: any): any;
 export declare function cached<T>(getter: () => T): {

package/package.json

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