@kubb/plugin-zod 5.3.0-canary.20260924T115534 → 5.3.0

package/dist/index.d.ts

@@ -328,6 +328,15 @@ type ResolverZod = Resolver & {
     options(node: ast.OperationNode): string;
   };
 };
+type CompileOptions = {
+  /**
+   * Throw an error if any part of the schema cannot be compiled into flat JavaScript,
+   * preventing silent fallback to the standard interpreter.
+   *
+   * @default false
+   */
+  strict?: boolean;
+};
 /**
  * Where the generated Zod schemas are written and how they are exported, plus the optional
  * `group` strategy. The `group` option organizes `output.mode: 'directory'` output into per-tag or per-path subdirectories.
@@ -398,6 +407,18 @@ type Options = OutputOptions & {
    * @default 'literal'
    */
   regexType?: 'literal' | 'constructor';
+  /**
+   * Wrap generated schemas with `z.compile(...)` to enable Zod's hyperoptimized
+   * fast-path validation logic.
+   *
+   * Set to `true` or pass `{ strict: true }` to enforce that schemas compile into
+   * flat JavaScript without silently degrading to the standard interpreter.
+   *
+   * @default false
+   * @note Only compatible with Zod v4.5.0 or above.
+   * @see https://zod.dev/blog/introducing-z-compile
+   */
+  compile?: boolean | CompileOptions;
   /**
    * Switch to Zod Mini's functional API for better tree-shaking. Also defaults
    * `importPath` to `'zod/mini'`.
@@ -453,6 +474,7 @@ type ResolvedOptions = {
   coercion: NonNullable<Options['coercion']>;
   guidType: NonNullable<Options['guidType']>;
   regexType: NonNullable<Options['regexType']>;
+  compile: NonNullable<Options['compile']>;
   mini: NonNullable<Options['mini']>;
   typeGuards: NonNullable<Options['typeGuards']>;
   printer: Options['printer'];
@@ -527,5 +549,5 @@ export declare const pluginZod: (options?: Options | undefined) => import("kubb/
  */
 export declare const resolverZod: ResolverZod;
 //#endregion
-export { type PluginZod, type PrinterZodFactory, type PrinterZodMiniFactory, type PrinterZodMiniNodes, type PrinterZodMiniOptions, type PrinterZodNodes, type PrinterZodOptions, type ResolverZod, pluginZod as default };
+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

package/dist/index.js

@@ -734,71 +734,6 @@ function mapSchemaItems(node, transform) {
 	}));
 }
 //#endregion
-//#region src/components/Zod.tsx
-function Zod({ name, node, printer, inferTypeName, typeGuards, isName, assertName, mini, cyclic }) {
-	const output = printer.print(node);
-	if (!output) return;
-	const needsAnnotation = cyclic && node.type !== "object";
-	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: [
-		/* @__PURE__ */ jsx(File.Source, {
-			name,
-			isExportable: true,
-			isIndexable: true,
-			children: /* @__PURE__ */ jsx(Const, {
-				export: true,
-				name,
-				type: needsAnnotation ? "z.ZodType" : void 0,
-				children: output
-			})
-		}),
-		inferTypeName && /* @__PURE__ */ jsx(File.Source, {
-			name: inferTypeName,
-			isExportable: true,
-			isIndexable: true,
-			isTypeOnly: true,
-			children: /* @__PURE__ */ jsx(Type, {
-				export: true,
-				name: inferTypeName,
-				children: `z.infer<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}`
-			})
-		})
-	] });
-}
-//#endregion
-//#region src/constants.ts
-/**
-* Import paths that use a namespace import (`import * as z from '...'`).
-* All other import paths use a named import (`import { z } from '...'`).
-*/
-const ZOD_NAMESPACE_IMPORTS = /* @__PURE__ */ new Set(["zod", "zod/mini"]);
-//#endregion
 //#region src/utils.ts
 /**
 * Returns `true` when the given coercion option enables coercion for the specified type.
@@ -817,6 +752,16 @@ function isPlainInlineObject(node) {
 	return node.type === "object" && !node.nullable && !node.optional && !node.nullish && node.additionalProperties === void 0 && !node.patternProperties;
 }
 /**
+* Whether the node is a bare reference schema (a `$ref` with no modifiers, descriptions, or omit keys).
+* Bare references resolve directly to another schema variable and should not be re-wrapped in `z.compile(...)`.
+*/
+function isBareRef(node, keysToOmit) {
+	const ref = ast.narrowSchema(node, "ref");
+	if (!ref) return false;
+	const meta = syncSchemaRef(ref);
+	return !meta.nullable && !meta.optional && !meta.nullish && meta.default === void 0 && !meta.description && !meta.examples?.length && !keysToOmit?.length;
+}
+/**
 * Whether a node renders as a bare Zod object — one that accepts `.extend(…)` and can be a
 * `z.discriminatedUnion` option. Covers object nodes, `$ref`s that resolve to (or are still
 * unresolved) objects, single-member unions of an object, and object-composable `allOf`.
@@ -1063,6 +1008,74 @@ function buildGroupedParamsSchema({ params, optional }) {
 	});
 }
 //#endregion
+//#region src/components/Zod.tsx
+function Zod({ name, node, printer, inferTypeName, typeGuards, isName, assertName, mini, cyclic, compile }) {
+	const output = printer.print(node);
+	if (!output) return;
+	const needsAnnotation = cyclic && node.type !== "object";
+	const isBare = isBareRef(node, printer.options.keysToOmit);
+	const isCyclic = Boolean(cyclic || printer.options.cyclicSchemas && containsCircularRef(node, { circularSchemas: printer.options.cyclicSchemas }));
+	const value = Boolean(compile) && !isBare && !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: [
+		/* @__PURE__ */ jsx(File.Source, {
+			name,
+			isExportable: true,
+			isIndexable: true,
+			children: /* @__PURE__ */ jsx(Const, {
+				export: true,
+				name,
+				type: needsAnnotation ? "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.infer<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}`
+			})
+		})
+	] });
+}
+//#endregion
+//#region src/constants.ts
+/**
+* Import paths that use a namespace import (`import * as z from '...'`).
+* All other import paths use a named import (`import { z } from '...'`).
+*/
+const ZOD_NAMESPACE_IMPORTS = /* @__PURE__ */ new Set(["zod", "zod/mini"]);
+//#endregion
 //#region src/printers/printerZod.ts
 /**
 * A `oneOf` member that is an inline object is exhaustive, so it prints as a strict object.
@@ -1775,7 +1788,7 @@ const zodGenerator = defineGenerator({
 	renderer: jsxRenderer,
 	schema(node, ctx) {
 		const { adapter, config, resolver, root } = ctx;
-		const { output, coercion, guidType, regexType, mini, inferred, typeGuards, importPath, group, printer } = ctx.options;
+		const { output, coercion, guidType, regexType, compile, mini, inferred, typeGuards, importPath, group, printer } = ctx.options;
 		const dateType = getOasAdapter(adapter).options.dateType;
 		if (!node.name) return;
 		const isZodImport = ZOD_NAMESPACE_IMPORTS.has(importPath);
@@ -1891,7 +1904,8 @@ const zodGenerator = defineGenerator({
 					isName,
 					assertName,
 					mini,
-					cyclic: cyclicSchemas.has(node.name)
+					cyclic: cyclicSchemas.has(node.name),
+					compile
 				}),
 				hasDirectionalNode && stdPrinters && /* @__PURE__ */ jsx(Zod, {
 					name: resolver.schema.inputName(node.name),
@@ -1902,7 +1916,8 @@ const zodGenerator = defineGenerator({
 					isName: typeGuards ? resolver.schema.isName(resolver.schema.inputName(node.name)) : null,
 					assertName: typeGuards ? resolver.schema.assertName(resolver.schema.inputName(node.name)) : null,
 					mini,
-					cyclic: cyclicSchemas.has(node.name)
+					cyclic: cyclicSchemas.has(node.name),
+					compile
 				})
 			]
 		});
@@ -1910,7 +1925,7 @@ const zodGenerator = defineGenerator({
 	operation(node, ctx) {
 		if (!ast.isHttpOperationNode(node)) return null;
 		const { adapter, config, resolver, root } = ctx;
-		const { output, coercion, guidType, regexType, mini, inferred, importPath, group, printer } = ctx.options;
+		const { output, coercion, guidType, regexType, compile, mini, inferred, importPath, group, printer } = ctx.options;
 		const dateType = getOasAdapter(adapter).options.dateType;
 		const isZodImport = ZOD_NAMESPACE_IMPORTS.has(importPath);
 		const meta = { file: resolver.file({
@@ -1989,7 +2004,8 @@ const zodGenerator = defineGenerator({
 				node: schema,
 				printer: schemaPrinter,
 				inferTypeName,
-				cyclic: false
+				cyclic: false,
+				compile
 			})] });
 		}
 		function buildContentTypeVariants(entries, baseName, decorate, direction) {
@@ -2236,7 +2252,7 @@ const pluginZod = definePlugin((options) => {
 	const { output = {
 		path: "zod",
 		barrel: { type: "named" }
-	}, group, exclude = [], include, override = [], mini = false, guidType = "uuid", regexType = "literal", importPath = mini ? "zod/mini" : "zod", coercion = false, inferred = false, typeGuards = false, printer, resolver: userResolver, macros: userMacros } = options;
+	}, group, exclude = [], include, override = [], compile = false, mini = false, guidType = "uuid", regexType = "literal", importPath = mini ? "zod/mini" : "zod", coercion = false, inferred = false, typeGuards = false, printer, resolver: userResolver, macros: userMacros } = options;
 	const groupConfig = createGroupConfig(group);
 	return {
 		name: pluginZodName,
@@ -2253,6 +2269,7 @@ const pluginZod = definePlugin((options) => {
 				inferred,
 				guidType,
 				regexType,
+				compile,
 				mini,
 				typeGuards,
 				printer