@kubb/plugin-ts 5.0.0-beta.30 → 5.0.0-beta.31

package/dist/index.js

@@ -804,6 +804,54 @@ function Type({ name, node, printer, enumType, enumTypeSuffix, enumKeyCasing, re
 }
 //#endregion
 //#region ../../internals/shared/src/operation.ts
+/**
+* Maps a content type to the PascalCase suffix used to name per-content-type variants
+* (e.g. `application/json` → `Json`, `application/xml` → `Xml`, `multipart/form-data` → `FormData`).
+*/
+function getContentTypeSuffix(contentType) {
+	const baseType = contentType.split(";")[0].trim();
+	if (baseType === "application/json") return "Json";
+	if (baseType === "multipart/form-data") return "FormData";
+	if (baseType === "application/x-www-form-urlencoded") return "FormUrlEncoded";
+	const parts = (baseType.split("/").pop() ?? baseType).split(/[^a-zA-Z0-9]+/).filter(Boolean);
+	if (parts.length === 0) return "Unknown";
+	return parts.map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
+/**
+* Appends a content-type suffix to a base name, keeping a trailing `Data` segment last
+* (e.g. `AddPetData` + `Json` → `AddPetJsonData`, `AddPetStatus200` + `Xml` → `AddPetStatus200Xml`).
+*/
+function getPerContentTypeName(baseName, suffix) {
+	if (baseName.endsWith("Data")) return suffix.endsWith("Data") ? baseName.slice(0, -4) + suffix : `${baseName.slice(0, -4)}${suffix}Data`;
+	return baseName + suffix;
+}
+/**
+* Resolves per-content-type variant names for a set of content entries, deduplicating suffix
+* collisions with a numeric counter. Entries without a schema are skipped. The returned `suffix` is
+* the final (possibly counter-augmented) value, so callers can derive parallel names in another
+* namespace (e.g. plugin-faker deriving the matching plugin-ts type name).
+*/
+function resolveContentTypeVariants(entries, baseName) {
+	const usedNames = /* @__PURE__ */ new Set();
+	return entries.filter((entry) => entry.schema).map((entry) => {
+		const baseSuffix = getContentTypeSuffix(entry.contentType);
+		let suffix = baseSuffix;
+		let name = getPerContentTypeName(baseName, suffix);
+		let counter = 2;
+		while (usedNames.has(name)) {
+			suffix = `${baseSuffix}${counter++}`;
+			name = getPerContentTypeName(baseName, suffix);
+		}
+		usedNames.add(name);
+		return {
+			name,
+			suffix,
+			schema: entry.schema,
+			keysToOmit: entry.keysToOmit,
+			contentType: entry.contentType
+		};
+	});
+}
 function getOperationParameters(node, options = {}) {
 	const params = ast.caseParams(node.parameters, options.paramsCasing);
 	return {
@@ -814,6 +862,39 @@ function getOperationParameters(node, options = {}) {
 	};
 }
 //#endregion
+//#region ../../internals/shared/src/group.ts
+/**
+* Builds the `group` config a Kubb plugin passes to `ctx.setOptions`, applying the
+* shared default naming so every plugin groups output consistently:
+*
+* - `path` groups use the second path segment (`/pet/findByStatus` → `pet`).
+* - other groups use `${camelCase(group)}${suffix}` (e.g. `petController`).
+*
+* Returns `null` when grouping is disabled, matching the per-plugin convention.
+*
+* @param group - The user-supplied group option, or `undefined` to disable grouping.
+* @param options.suffix - Appended to non-`path` group names, e.g. `'Controller'` or `'Requests'`.
+* @param options.honorName - When `true`, a user-provided `group.name` overrides the default namer.
+*
+* @example
+* ```ts
+* createGroupConfig(group, { suffix: 'Controller' })                  // plugin-ts, plugin-zod
+* createGroupConfig(group, { suffix: 'Controller', honorName: true }) // plugin-faker, plugin-client, …
+* createGroupConfig(group, { suffix: 'Requests', honorName: true })   // plugin-cypress, plugin-mcp
+* ```
+*/
+function createGroupConfig(group, options) {
+	if (!group) return null;
+	const defaultName = (ctx) => {
+		if (group.type === "path") return `${ctx.group.split("/")[1]}`;
+		return `${camelCase(ctx.group)}${options.suffix}`;
+	};
+	return {
+		...group,
+		name: options.honorName && group.name ? group.name : defaultName
+	};
+}
+//#endregion
 //#region src/utils.ts
 /**
 * Collects JSDoc annotation strings for a schema node.
@@ -935,7 +1016,7 @@ function buildResponses(node, { resolver }) {
 	});
 }
 function buildResponseUnion(node, { resolver }) {
-	const responsesWithSchema = node.responses.filter((res) => res.content?.[0]?.schema);
+	const responsesWithSchema = node.responses.filter((res) => res.content?.some((entry) => entry.schema));
 	if (responsesWithSchema.length === 0) return null;
 	return ast.createSchema({
 		type: "union",
@@ -1108,19 +1189,6 @@ const printerTs = ast.definePrinter((options) => {
 });
 //#endregion
 //#region src/generators/typeGenerator.tsx
-function getContentTypeSuffix(contentType) {
-	const baseType = contentType.split(";")[0].trim();
-	if (baseType === "application/json") return "Json";
-	if (baseType === "multipart/form-data") return "FormData";
-	if (baseType === "application/x-www-form-urlencoded") return "FormUrlEncoded";
-	const parts = (baseType.split("/").pop() ?? baseType).split(/[^a-zA-Z0-9]+/).filter(Boolean);
-	if (parts.length === 0) return "Unknown";
-	return parts.map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
-}
-function getPerContentTypeName(dataName, suffix) {
-	if (dataName.endsWith("Data")) return suffix.endsWith("Data") ? dataName.slice(0, -4) + suffix : `${dataName.slice(0, -4)}${suffix}Data`;
-	return dataName + suffix;
-}
 /**
 * Built-in generator for `@kubb/plugin-ts`. Emits one TypeScript file per
 * schema in the spec plus per-operation request, response, and parameter
@@ -1280,6 +1348,28 @@ const typeGenerator = defineGenerator({
 				printer: schemaPrinter
 			})] });
 		}
+		/**
+		* Emits an individual type per content type plus a union alias under `baseName`.
+		* Shared by the request body and multi-content-type responses.
+		*/
+		function buildContentTypeVariants(entries, baseName, decorate) {
+			const variants = resolveContentTypeVariants(entries, baseName);
+			const unionSchema = ast.createSchema({
+				type: "union",
+				members: variants.map((variant) => ast.createSchema({
+					type: "ref",
+					name: variant.name
+				}))
+			});
+			return /* @__PURE__ */ jsxs(Fragment, { children: [variants.map((variant) => renderSchemaType({
+				schema: decorate ? decorate(variant.schema) : variant.schema,
+				name: variant.name,
+				keysToOmit: variant.keysToOmit
+			})), renderSchemaType({
+				schema: unionSchema,
+				name: baseName
+			})] });
+		}
 		const paramTypes = params.map((param) => renderSchemaType({
 			schema: param.schema,
 			name: resolver.resolveParamName(node, param)
@@ -1299,44 +1389,22 @@ const typeGenerator = defineGenerator({
 					keysToOmit: entry.keysToOmit
 				});
 			}
-			const dataName = resolver.resolveDataName(node);
-			const usedNames = /* @__PURE__ */ new Set();
-			const individualItems = requestBodyContent.filter((entry) => entry.schema).map((entry) => {
-				const baseSuffix = getContentTypeSuffix(entry.contentType);
-				let individualName = getPerContentTypeName(dataName, baseSuffix);
-				let counter = 2;
-				while (usedNames.has(individualName)) individualName = getPerContentTypeName(dataName, `${baseSuffix}${counter++}`);
-				usedNames.add(individualName);
-				return {
-					name: individualName,
-					rendered: renderSchemaType({
-						schema: {
-							...entry.schema,
-							description: node.requestBody.description ?? entry.schema.description
-						},
-						name: individualName,
-						keysToOmit: entry.keysToOmit
-					})
-				};
-			});
-			const unionType = renderSchemaType({
-				schema: ast.createSchema({
-					type: "union",
-					members: individualItems.map((item) => ast.createSchema({
-						type: "ref",
-						name: item.name
-					}))
-				}),
-				name: dataName
-			});
-			return /* @__PURE__ */ jsxs(Fragment, { children: [individualItems.map((item) => item.rendered), unionType] });
+			return buildContentTypeVariants(requestBodyContent, resolver.resolveDataName(node), (schema) => ({
+				...schema,
+				description: node.requestBody.description ?? schema.description
+			}));
 		}
 		const requestType = buildRequestType();
-		const responseTypes = node.responses.map((res) => renderSchemaType({
-			schema: res.content?.[0]?.schema ?? null,
-			name: resolver.resolveResponseStatusName(node, res.statusCode),
-			keysToOmit: res.content?.[0]?.keysToOmit
-		}));
+		const responseTypes = node.responses.map((res) => {
+			const variants = (res.content ?? []).filter((entry) => entry.schema);
+			if (variants.length > 1) return buildContentTypeVariants(variants, resolver.resolveResponseStatusName(node, res.statusCode));
+			const primary = variants[0] ?? res.content?.[0];
+			return renderSchemaType({
+				schema: primary?.schema ?? null,
+				name: resolver.resolveResponseStatusName(node, res.statusCode),
+				keysToOmit: primary?.keysToOmit
+			});
+		});
 		const dataType = renderSchemaType({
 			schema: buildData({
 				...node,
@@ -1349,13 +1417,14 @@ const typeGenerator = defineGenerator({
 			name: resolver.resolveResponsesName(node)
 		});
 		function buildResponseType() {
-			if (!node.responses.some((res) => res.content?.[0]?.schema)) return null;
+			const hasSchema = (res) => (res.content ?? []).some((entry) => entry.schema);
+			if (!node.responses.some(hasSchema)) return null;
 			const responseName = resolver.resolveResponseName(node);
-			const responsesWithSchema = node.responses.filter((res) => res.content?.[0]?.schema);
-			if (new Set(responsesWithSchema.flatMap((res) => res.content?.[0]?.schema ? adapter.getImports(res.content[0].schema, (schemaName) => ({
+			const responsesWithSchema = node.responses.filter(hasSchema);
+			if (new Set(responsesWithSchema.flatMap((res) => (res.content ?? []).flatMap((entry) => entry.schema ? adapter.getImports(entry.schema, (schemaName) => ({
 				name: resolveImportName(schemaName),
 				path: ""
-			})).flatMap((imp) => Array.isArray(imp.name) ? imp.name : [imp.name]) : [])).has(responseName)) return null;
+			})).flatMap((imp) => Array.isArray(imp.name) ? imp.name : [imp.name]) : []))).has(responseName)) return null;
 			return renderSchemaType({
 				schema: {
 					...buildResponseUnion(node, { resolver }),
@@ -1499,13 +1568,7 @@ const pluginTs = definePlugin((options) => {
 		path: "types",
 		barrelType: "named"
 	}, group, exclude = [], include, override = [], enumType = "asConst", enumTypeSuffix = "Key", enumKeyCasing = "none", optionalType = "questionToken", arrayType = "array", syntaxType = "type", paramsCasing, printer, resolver: userResolver, transformer: userTransformer, generators: userGenerators = [] } = options;
-	const groupConfig = group ? {
-		...group,
-		name: (ctx) => {
-			if (group.type === "path") return `${ctx.group.split("/")[1]}`;
-			return `${camelCase(ctx.group)}Controller`;
-		}
-	} : null;
+	const groupConfig = createGroupConfig(group, { suffix: "Controller" });
 	return {
 		name: pluginTsName,
 		options,