@kubb/plugin-fetch 5.13.0 → 5.13.1

package/docs/guides/serialization.md

@@ -61,6 +61,12 @@ stays a string, and a binary type becomes a `Blob`. The negotiated media type is
 `contentType`, so a `switch (result.contentType)` narrows `data` for an operation that returns
 more than one.
 
+When that success response declares several content types that do not share one parser, the
+generated call sets `responseType` to a map from content type to parser, for example
+`{ 'audio/mpeg': 'blob', 'text/event-stream': 'stream' }`. The runtime matches the response
+`Content-Type` against the map, including a `type/*` wildcard, before the media-type heuristic.
+A schema with `format: binary` is a blob even when the media type is not a well-known binary type.
+
 To decode a media type the runtime does not handle, register a codec's `deserialize` for it.
 `deserialize` receives the raw body and the content type and returns the parsed value. It runs
 before validation, so the schema checks the parsed value:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/plugin-fetch",
-  "version": "5.13.0",
+  "version": "5.13.1",
   "description": "Generate a slim, type-safe HTTP client with Kubb based on the native Fetch api.",
   "keywords": [
     "api-client",
@@ -81,7 +81,7 @@
   },
   "dependencies": {
     "@kubb/kit": "^5.16.0",
-    "@kubb/plugin-client": "^5.10.0",
+    "@kubb/plugin-client": "^5.11.0",
     "@kubb/plugin-ts": "^5.4.1",
     "@kubb/plugin-zod": "^5.8.2",
     "@kubb/renderer-jsx": "^5.16.0"

package/templates/client.ts

@@ -1,4 +1,12 @@
-import { createClientCore, getResponseContentType, type ResponseType, type Transport, type TransportResult } from './core.ts'
+import {
+  createClientCore,
+  getResponseContentType,
+  resolveResponseType,
+  type ResponseType,
+  type ResponseTypeMap,
+  type Transport,
+  type TransportResult,
+} from './core.ts'
 import { isJsonMediaType } from './serializers.ts'
 import * as core from './core.ts'
 
@@ -35,24 +43,16 @@ export const ResponseError = core.ResponseError as {
   prototype: core.ResponseError<unknown, NativeRequest, NativeResponse>
 }
 
-function detectResponseType(contentType: string | null): ResponseType | undefined {
-  if (!contentType) return undefined
-  if (contentType.includes('text/event-stream')) return 'stream'
-  if (contentType.includes('application/json') || contentType.includes('text/json')) return 'json'
-  if (contentType.includes('text/')) return 'text'
-  if (contentType.includes('image/') || contentType.includes('application/octet-stream')) return 'blob'
-  return undefined
-}
-
-async function parseResponse(response: Response, responseType?: ResponseType): Promise<unknown> {
+async function parseResponse(response: Response, responseType?: ResponseType | ResponseTypeMap): Promise<unknown> {
   if (response.status === 204 || response.status === 205 || response.status === 304 || !response.body) {
     return undefined
   }
 
   const contentType = response.headers.get('Content-Type')
   // A server may answer a streamed operation with JSON, or with an error body: both are decoded by their content type. Any other streamed success body stays a stream.
-  const detected = responseType === 'stream' && (!response.ok || isJsonMediaType(contentType)) ? undefined : responseType
-  switch (detected ?? detectResponseType(contentType)) {
+  const resolved = resolveResponseType(responseType, contentType)
+  const detected = resolved === 'stream' && (!response.ok || isJsonMediaType(contentType)) ? resolveResponseType(undefined, contentType) : resolved
+  switch (detected) {
     case 'text':
     case 'document':
       return response.text()