zod 4.1.12 → 4.1.13

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

@@ -252,11 +252,19 @@ class JSONSchemaGenerator {
                     }
                     case "union": {
                         const json = _json;
+                        // Discriminated unions use oneOf (exactly one match) instead of anyOf (one or more matches)
+                        // because the discriminator field ensures mutual exclusivity between options in JSON Schema
+                        const isDiscriminated = def.discriminator !== undefined;
                         const options = def.options.map((x, i) => this.process(x, {
                             ...params,
-                            path: [...params.path, "anyOf", i],
+                            path: [...params.path, isDiscriminated ? "oneOf" : "anyOf", i],
                         }));
-                        json.anyOf = options;
+                        if (isDiscriminated) {
+                            json.oneOf = options;
+                        }
+                        else {
+                            json.anyOf = options;
+                        }
                         break;
                     }
                     case "intersection": {
@@ -821,100 +829,55 @@ function isTransforming(_schema, _ctx) {
     if (ctx.seen.has(_schema))
         return false;
     ctx.seen.add(_schema);
-    const schema = _schema;
-    const def = schema._zod.def;
-    switch (def.type) {
-        case "string":
-        case "number":
-        case "bigint":
-        case "boolean":
-        case "date":
-        case "symbol":
-        case "undefined":
-        case "null":
-        case "any":
-        case "unknown":
-        case "never":
-        case "void":
-        case "literal":
-        case "enum":
-        case "nan":
-        case "file":
-        case "template_literal":
-            return false;
-        case "array": {
-            return isTransforming(def.element, ctx);
-        }
-        case "object": {
-            for (const key in def.shape) {
-                if (isTransforming(def.shape[key], ctx))
-                    return true;
-            }
-            return false;
-        }
-        case "union": {
-            for (const option of def.options) {
-                if (isTransforming(option, ctx))
-                    return true;
-            }
-            return false;
-        }
-        case "intersection": {
-            return isTransforming(def.left, ctx) || isTransforming(def.right, ctx);
-        }
-        case "tuple": {
-            for (const item of def.items) {
-                if (isTransforming(item, ctx))
-                    return true;
-            }
-            if (def.rest && isTransforming(def.rest, ctx))
+    const def = _schema._zod.def;
+    if (def.type === "transform")
+        return true;
+    if (def.type === "array")
+        return isTransforming(def.element, ctx);
+    if (def.type === "set")
+        return isTransforming(def.valueType, ctx);
+    if (def.type === "lazy")
+        return isTransforming(def.getter(), ctx);
+    if (def.type === "promise" ||
+        def.type === "optional" ||
+        def.type === "nonoptional" ||
+        def.type === "nullable" ||
+        def.type === "readonly" ||
+        def.type === "default" ||
+        def.type === "prefault") {
+        return isTransforming(def.innerType, ctx);
+    }
+    if (def.type === "intersection") {
+        return isTransforming(def.left, ctx) || isTransforming(def.right, ctx);
+    }
+    if (def.type === "record" || def.type === "map") {
+        return isTransforming(def.keyType, ctx) || isTransforming(def.valueType, ctx);
+    }
+    if (def.type === "pipe") {
+        return isTransforming(def.in, ctx) || isTransforming(def.out, ctx);
+    }
+    if (def.type === "object") {
+        for (const key in def.shape) {
+            if (isTransforming(def.shape[key], ctx))
                 return true;
-            return false;
-        }
-        case "record": {
-            return isTransforming(def.keyType, ctx) || isTransforming(def.valueType, ctx);
         }
-        case "map": {
-            return isTransforming(def.keyType, ctx) || isTransforming(def.valueType, ctx);
-        }
-        case "set": {
-            return isTransforming(def.valueType, ctx);
-        }
-        // inner types
-        case "promise":
-        case "optional":
-        case "nonoptional":
-        case "nullable":
-        case "readonly":
-            return isTransforming(def.innerType, ctx);
-        case "lazy":
-            return isTransforming(def.getter(), ctx);
-        case "default": {
-            return isTransforming(def.innerType, ctx);
-        }
-        case "prefault": {
-            return isTransforming(def.innerType, ctx);
+        return false;
+    }
+    if (def.type === "union") {
+        for (const option of def.options) {
+            if (isTransforming(option, ctx))
+                return true;
         }
-        case "custom": {
-            return false;
+        return false;
+    }
+    if (def.type === "tuple") {
+        for (const item of def.items) {
+            if (isTransforming(item, ctx))
+                return true;
         }
-        case "transform": {
+        if (def.rest && isTransforming(def.rest, ctx))
             return true;
-        }
-        case "pipe": {
-            return isTransforming(def.in, ctx) || isTransforming(def.out, ctx);
-        }
-        case "success": {
-            return false;
-        }
-        case "catch": {
-            return false;
-        }
-        case "function": {
-            return false;
-        }
-        default:
-            def;
+        return false;
     }
-    throw new Error(`Unknown schema type: ${def.type}`);
+    return false;
 }

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

@@ -248,11 +248,19 @@ export class JSONSchemaGenerator {
                     }
                     case "union": {
                         const json = _json;
+                        // Discriminated unions use oneOf (exactly one match) instead of anyOf (one or more matches)
+                        // because the discriminator field ensures mutual exclusivity between options in JSON Schema
+                        const isDiscriminated = def.discriminator !== undefined;
                         const options = def.options.map((x, i) => this.process(x, {
                             ...params,
-                            path: [...params.path, "anyOf", i],
+                            path: [...params.path, isDiscriminated ? "oneOf" : "anyOf", i],
                         }));
-                        json.anyOf = options;
+                        if (isDiscriminated) {
+                            json.oneOf = options;
+                        }
+                        else {
+                            json.anyOf = options;
+                        }
                         break;
                     }
                     case "intersection": {
@@ -816,100 +824,55 @@ function isTransforming(_schema, _ctx) {
     if (ctx.seen.has(_schema))
         return false;
     ctx.seen.add(_schema);
-    const schema = _schema;
-    const def = schema._zod.def;
-    switch (def.type) {
-        case "string":
-        case "number":
-        case "bigint":
-        case "boolean":
-        case "date":
-        case "symbol":
-        case "undefined":
-        case "null":
-        case "any":
-        case "unknown":
-        case "never":
-        case "void":
-        case "literal":
-        case "enum":
-        case "nan":
-        case "file":
-        case "template_literal":
-            return false;
-        case "array": {
-            return isTransforming(def.element, ctx);
-        }
-        case "object": {
-            for (const key in def.shape) {
-                if (isTransforming(def.shape[key], ctx))
-                    return true;
-            }
-            return false;
-        }
-        case "union": {
-            for (const option of def.options) {
-                if (isTransforming(option, ctx))
-                    return true;
-            }
-            return false;
-        }
-        case "intersection": {
-            return isTransforming(def.left, ctx) || isTransforming(def.right, ctx);
-        }
-        case "tuple": {
-            for (const item of def.items) {
-                if (isTransforming(item, ctx))
-                    return true;
-            }
-            if (def.rest && isTransforming(def.rest, ctx))
+    const def = _schema._zod.def;
+    if (def.type === "transform")
+        return true;
+    if (def.type === "array")
+        return isTransforming(def.element, ctx);
+    if (def.type === "set")
+        return isTransforming(def.valueType, ctx);
+    if (def.type === "lazy")
+        return isTransforming(def.getter(), ctx);
+    if (def.type === "promise" ||
+        def.type === "optional" ||
+        def.type === "nonoptional" ||
+        def.type === "nullable" ||
+        def.type === "readonly" ||
+        def.type === "default" ||
+        def.type === "prefault") {
+        return isTransforming(def.innerType, ctx);
+    }
+    if (def.type === "intersection") {
+        return isTransforming(def.left, ctx) || isTransforming(def.right, ctx);
+    }
+    if (def.type === "record" || def.type === "map") {
+        return isTransforming(def.keyType, ctx) || isTransforming(def.valueType, ctx);
+    }
+    if (def.type === "pipe") {
+        return isTransforming(def.in, ctx) || isTransforming(def.out, ctx);
+    }
+    if (def.type === "object") {
+        for (const key in def.shape) {
+            if (isTransforming(def.shape[key], ctx))
                 return true;
-            return false;
-        }
-        case "record": {
-            return isTransforming(def.keyType, ctx) || isTransforming(def.valueType, ctx);
         }
-        case "map": {
-            return isTransforming(def.keyType, ctx) || isTransforming(def.valueType, ctx);
-        }
-        case "set": {
-            return isTransforming(def.valueType, ctx);
-        }
-        // inner types
-        case "promise":
-        case "optional":
-        case "nonoptional":
-        case "nullable":
-        case "readonly":
-            return isTransforming(def.innerType, ctx);
-        case "lazy":
-            return isTransforming(def.getter(), ctx);
-        case "default": {
-            return isTransforming(def.innerType, ctx);
-        }
-        case "prefault": {
-            return isTransforming(def.innerType, ctx);
+        return false;
+    }
+    if (def.type === "union") {
+        for (const option of def.options) {
+            if (isTransforming(option, ctx))
+                return true;
         }
-        case "custom": {
-            return false;
+        return false;
+    }
+    if (def.type === "tuple") {
+        for (const item of def.items) {
+            if (isTransforming(item, ctx))
+                return true;
         }
-        case "transform": {
+        if (def.rest && isTransforming(def.rest, ctx))
             return true;
-        }
-        case "pipe": {
-            return isTransforming(def.in, ctx) || isTransforming(def.out, ctx);
-        }
-        case "success": {
-            return false;
-        }
-        case "catch": {
-            return false;
-        }
-        case "function": {
-            return false;
-        }
-        default:
-            def;
+        return false;
     }
-    throw new Error(`Unknown schema type: ${def.type}`);
+    return false;
 }

package/v4/core/util.cjs

@@ -22,6 +22,7 @@ exports.getElementAtPath = getElementAtPath;
 exports.promiseAllObject = promiseAllObject;
 exports.randomString = randomString;
 exports.esc = esc;
+exports.slugify = slugify;
 exports.isObject = isObject;
 exports.isPlainObject = isPlainObject;
 exports.shallowClone = shallowClone;
@@ -190,6 +191,14 @@ function randomString(length = 10) {
 function esc(str) {
     return JSON.stringify(str);
 }
+function slugify(input) {
+    return input
+        .toLowerCase()
+        .trim()
+        .replace(/[^\w\s-]/g, "")
+        .replace(/[\s_-]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+}
 exports.captureStackTrace = ("captureStackTrace" in Error ? Error.captureStackTrace : (..._args) => { });
 function isObject(data) {
     return typeof data === "object" && data !== null && !Array.isArray(data);
@@ -215,6 +224,8 @@ function isPlainObject(o) {
     const ctor = o.constructor;
     if (ctor === undefined)
         return true;
+    if (typeof ctor !== "function")
+        return true;
     // modified prototype
     const prot = ctor.prototype;
     if (isObject(prot) === false)

package/v4/core/util.d.cts

@@ -133,6 +133,7 @@ export declare function promiseAllObject<T extends object>(promisesObj: T): Prom
 }>;
 export declare function randomString(length?: number): string;
 export declare function esc(str: string): string;
+export declare function slugify(input: string): string;
 export declare const captureStackTrace: (targetObject: object, constructorOpt?: Function) => void;
 export declare function isObject(data: any): data is Record<PropertyKey, unknown>;
 export declare const allowsEval: {

package/v4/core/util.d.ts

@@ -133,6 +133,7 @@ export declare function promiseAllObject<T extends object>(promisesObj: T): Prom
 }>;
 export declare function randomString(length?: number): string;
 export declare function esc(str: string): string;
+export declare function slugify(input: string): string;
 export declare const captureStackTrace: (targetObject: object, constructorOpt?: Function) => void;
 export declare function isObject(data: any): data is Record<PropertyKey, unknown>;
 export declare const allowsEval: {

package/v4/core/util.js

@@ -135,6 +135,14 @@ export function randomString(length = 10) {
 export function esc(str) {
     return JSON.stringify(str);
 }
+export function slugify(input) {
+    return input
+        .toLowerCase()
+        .trim()
+        .replace(/[^\w\s-]/g, "")
+        .replace(/[\s_-]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+}
 export const captureStackTrace = ("captureStackTrace" in Error ? Error.captureStackTrace : (..._args) => { });
 export function isObject(data) {
     return typeof data === "object" && data !== null && !Array.isArray(data);
@@ -160,6 +168,8 @@ export function isPlainObject(o) {
     const ctor = o.constructor;
     if (ctor === undefined)
         return true;
+    if (typeof ctor !== "function")
+        return true;
     // modified prototype
     const prot = ctor.prototype;
     if (isObject(prot) === false)

package/v4/core/versions.cjs

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

package/v4/core/versions.js

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

package/v4/locales/en.cjs

@@ -78,6 +78,7 @@ const error = () => {
         duration: "ISO duration",
         ipv4: "IPv4 address",
         ipv6: "IPv6 address",
+        mac: "MAC address",
         cidrv4: "IPv4 range",
         cidrv6: "IPv6 range",
         base64: "base64-encoded string",

package/v4/locales/en.js

@@ -50,6 +50,7 @@ const error = () => {
         duration: "ISO duration",
         ipv4: "IPv4 address",
         ipv6: "IPv6 address",
+        mac: "MAC address",
         cidrv4: "IPv4 range",
         cidrv6: "IPv6 range",
         base64: "base64-encoded string",