@kubb/plugin-fetch 5.13.0 → 5.13.1

package/dist/index.cjs

@@ -133,22 +133,65 @@ function getEventStream(node) {
 	const content = getEventStreamContent(node);
 	return content ? content.stream?.shape ?? "data" : null;
 }
+function baseContentType(contentType) {
+	return contentType.split(";")[0].trim().toLowerCase();
+}
+function isJsonContentType(baseType) {
+	return baseType === "application/json" || baseType.endsWith("+json") || baseType === "text/json";
+}
 /**
-* Derives the default `responseType` for an operation from its primary success response.
+* Parser for one response content entry.
 *
-* Returns a value only when that response declares a single non-JSON content type. `text/event-stream` maps to
-* `'stream'`, `application/octet-stream`, `application/pdf`, `image/*`, `audio/*` and `video/*` map to `'blob'`, and
-* other `text/*` to `'text'`. Otherwise `undefined`, leaving the runtime client's `Content-Type` auto-detection in charge.
+* JSON stays unset so the runtime detects it. `text/event-stream` is a stream. A binary schema
+* (`format: binary` / `contentMediaType`) is a blob even when the media type is not a well-known
+* binary type. Other `text/*` is text, and `application/octet-stream`, `application/pdf`,
+* `image/*`, `audio/*`, and `video/*` are blobs.
 */
-function getResponseType(node) {
-	const baseType = getPrimarySuccessContentType(node);
+function responseTypeForContent(contentType, schema) {
+	const baseType = baseContentType(contentType);
 	if (!baseType) return void 0;
-	if (baseType === "application/json" || baseType.endsWith("+json") || baseType === "text/json") return void 0;
+	if (isJsonContentType(baseType)) return void 0;
 	if (baseType === "text/event-stream") return "stream";
+	if (schema?.type === "blob") return "blob";
 	if (baseType.startsWith("text/")) return "text";
 	if (baseType === "application/octet-stream" || baseType === "application/pdf" || /^(image|audio|video)\//.test(baseType)) return "blob";
 }
 /**
+* Derives the default `responseType` string for an operation from its primary success response.
+*
+* One content type uses {@link responseTypeForContent}. Several content types that all use the same
+* parser collapse to that string, so a call can keep `responseType: 'blob'`. Mixed parsers return
+* `undefined`; {@link getResponseTypeMap} carries the per-type choice.
+*/
+function getResponseType(node) {
+	const entries = getPrimarySuccessResponse(node)?.content ?? [];
+	if (entries.length === 0) return void 0;
+	const responseTypes = entries.map((entry) => responseTypeForContent(entry.contentType, entry.schema));
+	const first = responseTypes[0];
+	if (!first) return void 0;
+	if (responseTypes.every((responseType) => responseType === first)) return first;
+}
+/**
+* Maps each base content type of a primary success response to its parser when those parsers differ.
+*
+* Keys are lowercased and stripped of parameters. JSON entries are kept as `'json'` so a catch-all
+* entry cannot claim a JSON response. Returns `undefined` when {@link getResponseType} already
+* covers the response with one string, or when no content type needs a parser other than JSON.
+* The runtime matches the response `Content-Type` against this map instead of guessing from the media type.
+*/
+function getResponseTypeMap(node) {
+	if (getResponseType(node)) return void 0;
+	const entries = getPrimarySuccessResponse(node)?.content ?? [];
+	if (entries.length <= 1) return void 0;
+	const map = {};
+	for (const entry of entries) {
+		const baseType = baseContentType(entry.contentType);
+		const responseType = responseTypeForContent(entry.contentType, entry.schema) ?? (isJsonContentType(baseType) ? "json" : void 0);
+		if (baseType && responseType) map[baseType] = responseType;
+	}
+	return Object.values(map).some((responseType) => responseType !== "json") ? map : void 0;
+}
+/**
 * Which of the grouped request options an operation carries.
 */
 function getRequestGroups(node) {
@@ -835,6 +878,17 @@ function buildStyles({ node }) {
 }
 // ../../internals/client/src/builders/callConfig.ts
 /**
+* `responseType` baked into a call. One parser is a string. Several parsers become a map from content
+* type to parser so the runtime can choose from the response `Content-Type`.
+*/
+function buildResponseTypeLiteral(node) {
+	const responseType = getResponseType(node);
+	if (responseType) return `responseType: '${responseType}'`;
+	const responseTypes = getResponseTypeMap(node);
+	if (!responseTypes) return null;
+	return `responseType: { ${Object.entries(responseTypes).map(([contentType, type]) => `${JSON.stringify(contentType)}: '${type}'`).join(", ")} }`;
+}
+/**
 * Builds the call config literal a generated operation forwards to the client, shared by the standalone
 * functions and the SDK methods. The `throwOnError` fallback is applied after the `...config` spread.
 *
@@ -861,7 +915,6 @@ function buildCallConfig({ node, validatorHooks, security, throwOnErrorDefault,
 		"error"
 	]);
 	const { literal: contentTypeLiteral, merge: mergeContentType } = buildContentType({ node });
-	const responseType = getResponseType(node);
 	return {
 		callConfig: `{ ${[
 			`method: '${node.method.toUpperCase()}'`,
@@ -870,7 +923,7 @@ function buildCallConfig({ node, validatorHooks, security, throwOnErrorDefault,
 			stylesLiteral ? `styles: ${stylesLiteral}` : null,
 			validatorLiteral,
 			contentTypeLiteral,
-			responseType ? `responseType: '${responseType}'` : null,
+			buildResponseTypeLiteral(node),
 			"...config",
 			`throwOnError: config.throwOnError ?? ${throwOnErrorDefault}`
 		].filter(Boolean).join(", ")} }`,
@@ -1676,7 +1729,7 @@ var compatibility = {
 	"node": ">=22.22"
 };
 // package.json
-var version = "5.13.0";
+var version = "5.13.1";
 // src/plugin.ts
 /**
 * Canonical plugin name for `@kubb/plugin-fetch`. Used for driver lookups and cross-plugin