@kubb/plugin-zod 5.9.0 → 5.9.1

package/dist/index.d.cts

@@ -343,7 +343,8 @@ type ResolverZod = Resolver & {
 type CompileOptions = {
   /**
    * Throw an error if any part of the schema cannot be compiled into flat JavaScript,
-   * preventing silent fallback to the standard interpreter.
+   * preventing silent fallback to the standard interpreter. A schema Zod refuses to
+   * compile, such as a coerced scalar or a `z.xor`, is left uncompiled.
    *
    * @default false
    */
@@ -513,6 +514,7 @@ declare global {
       typeName: string;
       type: string;
       zodPrinter: ReturnType<typeof printerZod> | ReturnType<typeof printerZodMini>;
+      zodDirectionalNodes: WeakMap<ast.SchemaNode, ast.SchemaNode | null>;
     }
   }
 }
@@ -571,5 +573,4 @@ export declare const pluginZod: import("@kubb/kit").PluginFactory<PluginZod>;
  * ```
  */
 export declare const resolverZod: ResolverZod;
-export { type CompileOptions, type PluginZod, type PrinterZodFactory, type PrinterZodMiniFactory, type PrinterZodMiniNodes, type PrinterZodMiniOptions, type PrinterZodNodes, type PrinterZodOptions, type ResolverZod, pluginZod as default };
-//# sourceMappingURL=index.d.cts.map
+export { type CompileOptions, type PluginZod, type PrinterZodFactory, type PrinterZodMiniFactory, type PrinterZodMiniNodes, type PrinterZodMiniOptions, type PrinterZodNodes, type PrinterZodOptions, type ResolverZod, pluginZod as default };

package/dist/index.d.ts

@@ -343,7 +343,8 @@ type ResolverZod = Resolver & {
 type CompileOptions = {
   /**
    * Throw an error if any part of the schema cannot be compiled into flat JavaScript,
-   * preventing silent fallback to the standard interpreter.
+   * preventing silent fallback to the standard interpreter. A schema Zod refuses to
+   * compile, such as a coerced scalar or a `z.xor`, is left uncompiled.
    *
    * @default false
    */
@@ -513,6 +514,7 @@ declare global {
       typeName: string;
       type: string;
       zodPrinter: ReturnType<typeof printerZod> | ReturnType<typeof printerZodMini>;
+      zodDirectionalNodes: WeakMap<ast.SchemaNode, ast.SchemaNode | null>;
     }
   }
 }
@@ -571,5 +573,4 @@ export declare const pluginZod: import("@kubb/kit").PluginFactory<PluginZod>;
  * ```
  */
 export declare const resolverZod: ResolverZod;
-export { type CompileOptions, type PluginZod, type PrinterZodFactory, type PrinterZodMiniFactory, type PrinterZodMiniNodes, type PrinterZodMiniOptions, type PrinterZodNodes, type PrinterZodOptions, type ResolverZod, pluginZod as default };
-//# sourceMappingURL=index.d.ts.map
+export { type CompileOptions, type PluginZod, type PrinterZodFactory, type PrinterZodMiniFactory, type PrinterZodMiniNodes, type PrinterZodMiniOptions, type PrinterZodNodes, type PrinterZodOptions, type ResolverZod, pluginZod as default };

package/dist/index.js

@@ -767,78 +767,6 @@ function createCasedFile(caseLast) {
 function getCircularNames(ctx) {
 	return ctx.memo("circularNames:set", () => ast.graph.getCircularNames(ctx.driver.inputNode?.schemas ?? []));
 }
-// src/components/Zod.tsx
-function Zod({ name, node, printer, inferTypeName, inferKind = "infer", typeGuards, isName, assertName, mini, cyclic, compile }) {
-	const output = printer.print(node);
-	const printerImports = printer.drainImports();
-	if (!output) return;
-	const needsAnnotation = cyclic && node.type !== "object";
-	const isAlias = ast.ref.isAlias(node, printer.options.keysToOmit);
-	const isCyclic = Boolean(cyclic || printer.options.cyclicSchemas && ast.graph.containsCircular(node, { circularSchemas: printer.options.cyclicSchemas }));
-	const value = Boolean(compile) && !isAlias && !isCyclic ? typeof compile === "object" && compile.strict ? `z.compile(${output}, { strict: true })` : `z.compile(${output})` : output;
-	const targetType = inferTypeName ?? `z.infer<typeof ${name}>`;
-	const shouldGenerateIs = isName && (typeof typeGuards === "object" ? typeGuards.is ?? true : Boolean(typeGuards));
-	const shouldGenerateAssert = assertName && (typeof typeGuards === "object" ? typeGuards.assert ?? true : Boolean(typeGuards));
-	return /* @__PURE__ */ jsxs(Fragment, { children: [
-		printerImports.map((imp) => /* @__PURE__ */ jsx(File.Import, {
-			name: imp.name,
-			path: imp.path,
-			root: imp.root,
-			isTypeOnly: imp.isTypeOnly,
-			isNameSpace: imp.isNameSpace
-		}, [
-			name,
-			imp.path,
-			imp.name
-		].join("-"))),
-		/* @__PURE__ */ jsx(File.Source, {
-			name,
-			isExportable: true,
-			isIndexable: true,
-			children: /* @__PURE__ */ jsx(Const, {
-				export: true,
-				name,
-				type: needsAnnotation ? mini ? "z.ZodMiniType" : "z.ZodType" : void 0,
-				children: value
-			})
-		}),
-		inferTypeName && /* @__PURE__ */ jsx(File.Source, {
-			name: inferTypeName,
-			isExportable: true,
-			isIndexable: true,
-			isTypeOnly: true,
-			children: /* @__PURE__ */ jsx(Type, {
-				export: true,
-				name: inferTypeName,
-				children: `z.${inferKind}<typeof ${name}>`
-			})
-		}),
-		shouldGenerateIs && /* @__PURE__ */ jsx(File.Source, {
-			name: isName,
-			isExportable: true,
-			isIndexable: true,
-			children: /* @__PURE__ */ jsx(Const, {
-				export: true,
-				name: isName,
-				JSDoc: { comments: [`Type guard for {@link ${name}}`] },
-				children: mini ? `(data: unknown): data is ${targetType} => z.validate(${name}, data)` : `(data: unknown): data is ${targetType} => ${name}.validate(data)`
-			})
-		}),
-		shouldGenerateAssert && /* @__PURE__ */ jsx(File.Source, {
-			name: assertName,
-			isExportable: true,
-			isIndexable: true,
-			children: /* @__PURE__ */ jsx(Function, {
-				export: true,
-				name: assertName,
-				params: "data: unknown",
-				returnType: `asserts data is ${targetType}`,
-				JSDoc: { comments: [`Asserter for {@link ${name}}`, "@throws {z.ZodError} If data is invalid"] },
-				children: mini ? `if (!z.validate(${name}, data)) {\n  z.parse(${name}, data)\n}` : `if (!${name}.validate(data)) {\n  ${name}.parse(data)\n}`
-			})
-		})
-	] });
-}
 // src/utils.ts
 /**
 * Returns `true` when the given coercion option enables coercion for the specified type.
@@ -1331,6 +1259,40 @@ function hasCoercedDiscriminator({ member, propertyName, options }) {
 		})?.coerce;
 	});
 }
+/**
+* Whether `z.compile(schema, { strict: true })` throws for the node. Zod runs an unsupported schema below an object
+* property or an array, tuple or record item on its runtime parser, so only a coerced scalar or a `z.xor` that compiles
+* inline with the root throws: the node itself, or one reached through refs and union or intersection members.
+* `siblings` resolves a generated ref, which names another schema of the same file and carries no target.
+*
+* Mirrors the built-in handlers, so a type with a `printer.nodes` override is judged as if it printed the built-in output.
+*/
+function throwsOnStrictCompile({ node, options, siblings, seen = /* @__PURE__ */ new Set() }) {
+	if (!node || seen.has(node)) return false;
+	seen.add(node);
+	const throws = (child) => throwsOnStrictCompile({
+		node: child,
+		options,
+		siblings,
+		seen
+	});
+	switch (node.type) {
+		case ast.schema.types.ref: return throws(node.schema ?? (node.ref || !node.name ? void 0 : siblings?.get(node.name)));
+		case ast.schema.types.union:
+			if (node.strategy === "one" && options.oneOfType === "xor") return true;
+			return !!getLiteralUnion({
+				node,
+				options
+			})?.coerce || (node.members ?? []).some(throws);
+		case ast.schema.types.intersection: return (node.members ?? []).some(throws);
+		case ast.schema.types.bigint: return true;
+		case ast.schema.types.string: return shouldCoerce(options.coercion, "strings");
+		case ast.schema.types.number:
+		case ast.schema.types.integer: return shouldCoerce(options.coercion, "numbers");
+		case ast.schema.types.date: return node.representation === "date" && options.direction !== "encode" && shouldCoerce(options.coercion, "dates");
+		default: return false;
+	}
+}
 function hasPlainDiscriminator({ member, propertyName }) {
 	const schemas = ast.schema.findProperties({
 		node: member,
@@ -1594,6 +1556,111 @@ function withInputChecks(nodes) {
 	};
 	return Object.fromEntries(Object.values(ast.schema.types).flatMap(wrapHandler));
 }
+// src/components/Zod.tsx
+/**
+* Whether the schema reaches a circular schema through its refs. `containsCircular` reads the refs the node holds,
+* while Zod refuses to compile a cycle anywhere below the root. A generated ref carries no target, so `siblings` resolves it.
+*/
+function reachesCycle({ node, siblings, cyclicSchemas, seen = /* @__PURE__ */ new Set() }) {
+	if (!cyclicSchemas?.size || seen.has(node)) return false;
+	seen.add(node);
+	return ast.schema.find(node, {
+		followRefs: true,
+		predicate(schema) {
+			if (schema.type !== ast.schema.types.ref) return false;
+			const name = ast.ref.getName(schema);
+			if (name && cyclicSchemas.has(name)) return true;
+			const sibling = schema.ref || !schema.name ? void 0 : siblings?.get(schema.name);
+			return !!sibling && reachesCycle({
+				node: sibling,
+				siblings,
+				cyclicSchemas,
+				seen
+			});
+		}
+	}) !== void 0;
+}
+function Zod({ name, node, printer, inferTypeName, inferKind = "infer", typeGuards, isName, assertName, mini, cyclic, compile, siblings }) {
+	const output = printer.print(node);
+	const printerImports = printer.drainImports();
+	if (!output) return;
+	const needsAnnotation = cyclic && node.type !== "object";
+	const isAlias = ast.ref.isAlias(node, printer.options.keysToOmit);
+	const isCyclic = Boolean(cyclic || printer.options.cyclicSchemas && ast.graph.containsCircular(node, { circularSchemas: printer.options.cyclicSchemas }));
+	const isStrict = typeof compile === "object" && Boolean(compile.strict);
+	const throwsOnCompile = isStrict && (throwsOnStrictCompile({
+		node,
+		options: printer.options,
+		siblings
+	}) || reachesCycle({
+		node,
+		siblings,
+		cyclicSchemas: printer.options.cyclicSchemas
+	}));
+	const value = Boolean(compile) && !isAlias && !isCyclic && !throwsOnCompile ? isStrict ? `z.compile(${output}, { strict: true })` : `z.compile(${output})` : output;
+	const targetType = inferTypeName ?? `z.infer<typeof ${name}>`;
+	const shouldGenerateIs = isName && (typeof typeGuards === "object" ? typeGuards.is ?? true : Boolean(typeGuards));
+	const shouldGenerateAssert = assertName && (typeof typeGuards === "object" ? typeGuards.assert ?? true : Boolean(typeGuards));
+	return /* @__PURE__ */ jsxs(Fragment, { children: [
+		printerImports.map((imp) => /* @__PURE__ */ jsx(File.Import, {
+			name: imp.name,
+			path: imp.path,
+			root: imp.root,
+			isTypeOnly: imp.isTypeOnly,
+			isNameSpace: imp.isNameSpace
+		}, [
+			name,
+			imp.path,
+			imp.name
+		].join("-"))),
+		/* @__PURE__ */ jsx(File.Source, {
+			name,
+			isExportable: true,
+			isIndexable: true,
+			children: /* @__PURE__ */ jsx(Const, {
+				export: true,
+				name,
+				type: needsAnnotation ? mini ? "z.ZodMiniType" : "z.ZodType" : void 0,
+				children: value
+			})
+		}),
+		inferTypeName && /* @__PURE__ */ jsx(File.Source, {
+			name: inferTypeName,
+			isExportable: true,
+			isIndexable: true,
+			isTypeOnly: true,
+			children: /* @__PURE__ */ jsx(Type, {
+				export: true,
+				name: inferTypeName,
+				children: `z.${inferKind}<typeof ${name}>`
+			})
+		}),
+		shouldGenerateIs && /* @__PURE__ */ jsx(File.Source, {
+			name: isName,
+			isExportable: true,
+			isIndexable: true,
+			children: /* @__PURE__ */ jsx(Const, {
+				export: true,
+				name: isName,
+				JSDoc: { comments: [`Type guard for {@link ${name}}`] },
+				children: mini ? `(data: unknown): data is ${targetType} => z.validate(${name}, data)` : `(data: unknown): data is ${targetType} => ${name}.validate(data)`
+			})
+		}),
+		shouldGenerateAssert && /* @__PURE__ */ jsx(File.Source, {
+			name: assertName,
+			isExportable: true,
+			isIndexable: true,
+			children: /* @__PURE__ */ jsx(Function, {
+				export: true,
+				name: assertName,
+				params: "data: unknown",
+				returnType: `asserts data is ${targetType}`,
+				JSDoc: { comments: [`Asserter for {@link ${name}}`, "@throws {z.ZodError} If data is invalid"] },
+				children: mini ? `if (!z.validate(${name}, data)) {\n  z.parse(${name}, data)\n}` : `if (!${name}.validate(data)) {\n  ${name}.parse(data)\n}`
+			})
+		})
+	] });
+}
 // src/printers/printerZod.ts
 function strictOneOfMember(member, node, cyclicSchemas) {
 	if (node.type === ast.schema.types.ref) {
@@ -1714,10 +1781,19 @@ function containsDirectionalNode({ node, printerOptions }) {
 			node: schema,
 			printerOptions
 		}),
-		followRefs: true
+		followRefs: true,
+		cache: getDirectionalCache(printerOptions)
 	}) !== void 0;
 }
 /**
+* The `find` cache for {@link containsDirectionalNode}, one per plugin per build and per option set
+* the probe reads. A `printer.nodes` override has no string key, so it searches without a cache.
+*/
+function getDirectionalCache({ resolver, nodes, coercion, dateType }) {
+	if (!resolver || nodes) return void 0;
+	return resolver.memo(`zodDirectionalNodes:${shouldCoerce(coercion, "dates")}:${dateType}`, () => /* @__PURE__ */ new WeakMap());
+}
+/**
 * Names of the `$ref` schemas the generator should route to their input (encode) variant.
 */
 function collectDirectionalRefNames({ node, printerOptions }) {
@@ -2083,8 +2159,10 @@ const zodGenerator = defineGenerator({
 			cyclicSchemas: getCircularNames(ctx),
 			nodes: printer?.nodes
 		};
+		const siblings = /* @__PURE__ */ new Map();
 		function renderSchemaEntry({ schema, name, keysToOmit, direction = "decode" }) {
 			if (!schema) return null;
+			siblings.set(name, schema);
 			const directionalRefNames = direction === "encode" && !mini ? new Set(collectDirectionalRefNames({
 				node: schema,
 				printerOptions
@@ -2116,7 +2194,8 @@ const zodGenerator = defineGenerator({
 				inferTypeName: inferred ? resolver.schema.type(name) : null,
 				inferKind: aliasKind(inferred, direction),
 				cyclic: false,
-				compile
+				compile,
+				siblings
 			})] });
 		}
 		function buildContentTypeVariants(entries, baseName, decorate, direction) {
@@ -2297,7 +2376,7 @@ var compatibility = {
 	"node": ">=22.22"
 };
 // package.json
-var version = "5.9.0";
+var version = "5.9.1";
 // src/resolvers/resolverZod.ts
 /**
 * Default resolver used by `@kubb/plugin-zod`. Decides the names and file