openapi-typesafe-fetch 1.0.0-rc.4 → 1.0.0-rc.5

package/CHANGELOG.md

@@ -2,6 +2,59 @@
 
 This package is a fork of `openapi-fetch`. The entries above `0.17.0` are releases of openapi-typesafe-fetch; `0.17.0` and the entries below it are the upstream history up to the fork point (upstream commit `d46a319a`), with `openapi-fetch` versions.
 
+## 1.0.0-rc.5
+
+### Minor Changes
+
+- [#68](https://github.com/openapi-typesafe/openapi-typesafe/pull/68) [`0f0792b`](https://github.com/openapi-typesafe/openapi-typesafe/commit/0f0792b8efa4f5139653cd285455f7d6165ddb95) Thanks [@fedorello](https://github.com/fedorello)! - A `FormData`, `Blob`, `File` or `ReadableStream` body from `undici` or another realm (an iframe) is
+  sent as it is: the client told a body by `instanceof`, so it JSON-encoded one of another class as
+  `{}`. `createClient` takes a `FormData` class next to `Request`: a multipart body is built with it,
+  and a FormData body of another class is copied into one of it, since undici's `Request` read the
+  platform's FormData as the text `[object FormData]`. With undici, pass
+  `createClient({ fetch, Request, FormData })` from the package. An instance of the platform's own
+  global class is still sent as it is, so the FormData, Blob and URLSearchParams of React Native and
+  the Blob and File of jsdom 20 (Jest 29), which have no type tag or no `arrayBuffer`, keep working.
+
+- [#67](https://github.com/openapi-typesafe/openapi-typesafe/pull/67) [`fbaded2`](https://github.com/openapi-typesafe/openapi-typesafe/commit/fbaded241385d032d5b28d2c93d5e0a7d6ae292b) Thanks [@fedorello](https://github.com/fedorello)! - The client has a read-only `baseUrl`: the `baseUrl` option without its trailing slash, or `""`.
+
+### Patch Changes
+
+- [#68](https://github.com/openapi-typesafe/openapi-typesafe/pull/68) [`0f0792b`](https://github.com/openapi-typesafe/openapi-typesafe/commit/0f0792b8efa4f5139653cd285455f7d6165ddb95) Thanks [@fedorello](https://github.com/fedorello)! - An empty success body read with `parseAs: "text"`, `"blob"`, `"arrayBuffer"` or `"stream"` gives
+  `""`, an empty `Blob` or `ArrayBuffer`, or `response.body`, as its type says. A 204, an answer to
+  HEAD or a `Content-Length: 0` gave `undefined`, while the same empty body without a length gave
+  `""`. With the default `parseAs: "json"` an empty body is still `undefined`.
+
+- [#68](https://github.com/openapi-typesafe/openapi-typesafe/pull/68) [`0f0792b`](https://github.com/openapi-typesafe/openapi-typesafe/commit/0f0792b8efa4f5139653cd285455f7d6165ddb95) Thanks [@fedorello](https://github.com/fedorello)! - `params.header` values are written in the `simple` style, the only style OpenAPI has for headers:
+  a `Date` as ISO 8601 (it was local time), an array as `a,b` (it was `a, b`) and an object as
+  `role,admin` (it was `[object Object]`), not percent-encoded, also in the names. A nested object or
+  array inside one throws, as in the query. An empty array or object sends no header, and `null`
+  still removes one.
+
+- [#68](https://github.com/openapi-typesafe/openapi-typesafe/pull/68) [`0f0792b`](https://github.com/openapi-typesafe/openapi-typesafe/commit/0f0792b8efa4f5139653cd285455f7d6165ddb95) Thanks [@fedorello](https://github.com/fedorello)! - A form or multipart `Content-Type` with spaces or tabs before its parameters
+  (`application/x-www-form-urlencoded ; charset=utf-8`, RFC 9110 OWS) gives form data or `FormData`
+  again, in the runtime and in the result type of `defaultBodySerializer`; the object was sent as
+  JSON. The JSON check already took them.
+
+- [#68](https://github.com/openapi-typesafe/openapi-typesafe/pull/68) [`0f0792b`](https://github.com/openapi-typesafe/openapi-typesafe/commit/0f0792b8efa4f5139653cd285455f7d6165ddb95) Thanks [@fedorello](https://github.com/fedorello)! - `style` and `explode` of the `array` and `object` options of `QuerySerializerOptions` are optional,
+  and one left out takes the client's value, else its default (`form` or `deepObject`, exploded): a
+  request's `{ array: { explode: false } }` keeps the client's `style`. `onError` may return an
+  `Error` of another realm (an iframe, `node:vm`); it was rejected as not an error.
+
+- [#68](https://github.com/openapi-typesafe/openapi-typesafe/pull/68) [`0f0792b`](https://github.com/openapi-typesafe/openapi-typesafe/commit/0f0792b8efa4f5139653cd285455f7d6165ddb95) Thanks [@fedorello](https://github.com/fedorello)! - The query of a request whose path template has a fragment (`/docs#intro`) goes before the
+  fragment, joined with a query the template already has. It was added after the `#`, where it is
+  part of the fragment, so `fetch` never sent it.
+
+- [#75](https://github.com/openapi-typesafe/openapi-typesafe/pull/75) [`a74608e`](https://github.com/openapi-typesafe/openapi-typesafe/commit/a74608ec36b0a938594e0d0fac10c9fb222c1742) Thanks [@fedorello](https://github.com/fedorello)! - `Readable` and `Writable` find the `$Read` and `$Write` properties of an object with an index
+  signature (`additionalProperties`). The keys were read through the index signature, so no
+  property was marked: a request body required the `readOnly` `id`, and a response kept the
+  `writeOnly` password. The helper types that `--read-write-markers` writes are fixed the same way.
+
+- [#68](https://github.com/openapi-typesafe/openapi-typesafe/pull/68) [`0f0792b`](https://github.com/openapi-typesafe/openapi-typesafe/commit/0f0792b8efa4f5139653cd285455f7d6165ddb95) Thanks [@fedorello](https://github.com/fedorello)! - A response is typed as data or an error by the first digit of its status, as `response.ok` reads
+  it: a declared 205, 208 or 226 types `data` with its body, and a 419, a 3XX (read with
+  `redirect: "manual"`) or a 1XX types `error` with its body.
+  The types classified by two closed lists of statuses, `OkStatus` and `ErrorStatus`, which stay
+  exported. New helper types `SuccessStatusKey` and `ErrorStatusKey` name the statuses of each kind.
+
 ## 1.0.0-rc.4
 
 ### Minor Changes

package/README.md

@@ -1,7 +1,7 @@
 # openapi-typesafe-fetch
 
-A type-safe `fetch` client for types generated by [`openapi-typesafe`](../openapi-typesafe). About 9 kB minified
-(3.7 kB gzipped), no runtime dependencies, works in browsers, Node.js, Bun and Deno, and with React, Vue, Svelte or plain JavaScript.
+A type-safe `fetch` client for types generated by [`openapi-typesafe`](../openapi-typesafe). About 10.7 kB minified
+(4 kB gzipped), no runtime dependencies, works in browsers, Node.js, Bun and Deno, and with React, Vue, Svelte or plain JavaScript.
 
 A maintained, drop-in successor to `openapi-fetch` (see the [repository README](../../README.md)).
 

package/dist/helpers.d.cts

@@ -2,12 +2,32 @@
 type HttpMethod = "get" | "put" | "post" | "delete" | "options" | "head" | "patch" | "trace"
 /** OpenAPI 3.2: a safe, idempotent request with a body. */
  | "query";
-/** 2XX statuses */
+/**
+ * Some 2XX statuses, kept for code that names them. The client does not classify by this list: a
+ * status is a success or an error by its first digit (`SuccessStatusKey`, `ErrorStatusKey`).
+ */
 type OkStatus = 200 | 201 | 202 | 203 | 204 | 206 | 207 | "2XX";
-/** 4XX and 5XX statuses */
+/** Some 4XX and 5XX statuses and `default`, kept like `OkStatus`. */
 type ErrorStatus = 500 | 501 | 502 | 503 | 504 | 505 | 506 | 507 | 508 | 510 | 511 | "5XX" | 400 | 401 | 402 | 403 | 404 | 405 | 406 | 407 | 408 | 409 | 410 | 411 | 412 | 413 | 414 | 415 | 416 | 417 | 418 | 420 | 421 | 422 | 423 | 424 | 425 | 426 | 427 | 428 | 429 | 430 | 431 | 444 | 450 | 451 | 497 | 498 | 499 | "4XX" | "default";
+type StatusDigit = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
+/**
+ * The keys of a Response Object Map whose text matches a pattern. A generated map has numeric keys
+ * (`200`) and string ones (`"2XX"`, `"default"`), and a numeric literal matches no template
+ * literal type, so each key is matched by its text.
+ */
+type StatusKeysMatching<Keys, Pattern extends string> = Keys extends string | number ? `${Keys}` extends Pattern ? Keys : never : never;
+/**
+ * The success statuses of a Response Object Map: every 2XX one. A closed list of statuses left out
+ * the ones it did not name (205, 208, 226), and their bodies were typed as no data.
+ */
+type SuccessStatusKey<T> = StatusKeysMatching<keyof T, `2${StatusDigit}${StatusDigit}` | "2XX">;
+/**
+ * The error statuses of a Response Object Map: every 1XX, 3XX, 4XX and 5XX one, and `default`. The
+ * client returns each response that is not `ok` as `error`, also a 3XX with `redirect: "manual"`.
+ */
+type ErrorStatusKey<T> = StatusKeysMatching<keyof T, `${1 | 3 | 4 | 5}${StatusDigit}${StatusDigit}` | `${1 | 3 | 4 | 5}XX` | "default">;
 /** Get a union of OK Statuses */
-type OKStatusUnion<T> = FilterKeys<T, OkStatus>;
+type OKStatusUnion<T> = FilterKeys<T, SuccessStatusKey<T>>;
 /** Get first error status, in order */
 type FirstErrorStatus<T> = T extends {
     500: unknown;
@@ -178,7 +198,7 @@ type OperationRequestBodyContent<T> = FilterKeys<OperationRequestBodyMediaConten
  * Responses Object), so then it covers every success (upstream #1862). With a 2XX status declared,
  * `default` is left to the errors, as before.
  */
-type SuccessStatus<T> = [Extract<keyof T, OkStatus>] extends [never] ? "default" : OkStatus;
+type SuccessStatus<T> = [SuccessStatusKey<T>] extends [never] ? Extract<keyof T, "default"> : SuccessStatusKey<T>;
 /**
  * Return all 2XX responses from a Response Object Map, or `default` if it declares no 2XX one. For
  * a union of maps (a call with a union of paths), the union of each map's responses: `keyof` of a
@@ -190,10 +210,10 @@ type GetResponseContent<T extends Record<string | number, any>, Media extends Me
     [K in ResponseCode]: T[K]["content"] extends Record<string, any> ? FilterKeys<T[K]["content"], Media> extends never ? T[K]["content"] : FilterKeys<T[K]["content"], Media> : K extends keyof T ? T[K]["content"] : never;
 }[ResponseCode] : never;
 /**
- * Return all 5XX and 4XX responses (in that order) from a Response Object Map; for a union of maps,
- * the union of each map's responses, as `SuccessResponse`.
+ * Return all 1XX, 3XX, 4XX, 5XX and `default` responses from a Response Object Map; for a union
+ * of maps, the union of each map's responses, as `SuccessResponse`.
  */
-type ErrorResponse<T extends Record<string | number, any>, Media extends MediaType = MediaType> = T extends unknown ? GetResponseContent<T, Media, ErrorStatus> : never;
+type ErrorResponse<T extends Record<string | number, any>, Media extends MediaType = MediaType> = T extends unknown ? GetResponseContent<T, Media, ErrorStatusKey<T>> : never;
 /** Return first JSON-like 2XX response from a path + HTTP method */
 type SuccessResponseJSON<PathMethod extends Record<string | number, any>> = SuccessResponse<ResponseObjectMap<PathMethod>, `${string}/json`>;
 /** Return first JSON-like 5XX or 4XX response from a path + HTTP method */
@@ -258,10 +278,13 @@ type ReadWriteLeaf = ReadWritePrimitive | ((...args: never) => unknown);
  * `any` key is not marked either (`0 extends 1 & T[K]` is true only for `any`): a check on `any`
  * takes both branches, so `Readable` dropped the key and `Writable` typed it `undefined`. The
  * checks are not distributive (their check types are not type parameters), so `never` is seen.
+ * The keys are read by remapping, not as `{ ... }[keyof T]`: with an index signature (from
+ * `additionalProperties`) `keyof T` is `string`, which indexes the signature only, so no property
+ * was marked and `Writable` made a readOnly property a required `never`.
  */
-type ReadWriteMarkedKeys<T, Marker> = {
-    [K in keyof T]-?: 0 extends 1 & T[K] ? never : NonNullable<T[K]> extends never ? never : NonNullable<T[K]> extends Marker ? K : never;
-}[keyof T];
+type ReadWriteMarkedKeys<T, Marker> = keyof {
+    [K in keyof T as 0 extends 1 & T[K] ? never : NonNullable<T[K]> extends never ? never : NonNullable<T[K]> extends Marker ? K : never]: never;
+};
 /**
  * Resolve an array or a tuple element by element. An array uses `T[number]`, not `infer E`: for an
  * intersection of arrays (`allOf`) inference keeps one member and narrowing breaks (upstream
@@ -296,4 +319,4 @@ type Writable<T> = T extends $Read<any> ? never : T extends $Write<infer U> ? Wr
     [K in ReadWriteMarkedKeys<T, $Read<any>>]?: never;
 } : T;
 
-export type { $Read, $Write, ErrorResponse, ErrorResponseJSON, ErrorStatus, FilterKeys, FindRequiredKeys, FirstErrorStatus, GetResponseContent, GetValueWithDefault, HasRequiredKeys, HttpMethod, IsOperationRequestBodyOptional, JSONLike, MediaType, OKStatusUnion, OkStatus, OperationObject, OperationRequestBody, OperationRequestBodyContent, OperationRequestBodyMediaContent, PathItemObject, PathsWithMethod, Readable, RequestBodyJSON, RequiredKeysOf, ResponseContent, ResponseObjectMap, SuccessResponse, SuccessResponseJSON, Writable };
+export type { $Read, $Write, ErrorResponse, ErrorResponseJSON, ErrorStatus, ErrorStatusKey, FilterKeys, FindRequiredKeys, FirstErrorStatus, GetResponseContent, GetValueWithDefault, HasRequiredKeys, HttpMethod, IsOperationRequestBodyOptional, JSONLike, MediaType, OKStatusUnion, OkStatus, OperationObject, OperationRequestBody, OperationRequestBodyContent, OperationRequestBodyMediaContent, PathItemObject, PathsWithMethod, Readable, RequestBodyJSON, RequiredKeysOf, ResponseContent, ResponseObjectMap, SuccessResponse, SuccessResponseJSON, SuccessStatusKey, Writable };

package/dist/helpers.d.mts

@@ -2,12 +2,32 @@
 type HttpMethod = "get" | "put" | "post" | "delete" | "options" | "head" | "patch" | "trace"
 /** OpenAPI 3.2: a safe, idempotent request with a body. */
  | "query";
-/** 2XX statuses */
+/**
+ * Some 2XX statuses, kept for code that names them. The client does not classify by this list: a
+ * status is a success or an error by its first digit (`SuccessStatusKey`, `ErrorStatusKey`).
+ */
 type OkStatus = 200 | 201 | 202 | 203 | 204 | 206 | 207 | "2XX";
-/** 4XX and 5XX statuses */
+/** Some 4XX and 5XX statuses and `default`, kept like `OkStatus`. */
 type ErrorStatus = 500 | 501 | 502 | 503 | 504 | 505 | 506 | 507 | 508 | 510 | 511 | "5XX" | 400 | 401 | 402 | 403 | 404 | 405 | 406 | 407 | 408 | 409 | 410 | 411 | 412 | 413 | 414 | 415 | 416 | 417 | 418 | 420 | 421 | 422 | 423 | 424 | 425 | 426 | 427 | 428 | 429 | 430 | 431 | 444 | 450 | 451 | 497 | 498 | 499 | "4XX" | "default";
+type StatusDigit = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
+/**
+ * The keys of a Response Object Map whose text matches a pattern. A generated map has numeric keys
+ * (`200`) and string ones (`"2XX"`, `"default"`), and a numeric literal matches no template
+ * literal type, so each key is matched by its text.
+ */
+type StatusKeysMatching<Keys, Pattern extends string> = Keys extends string | number ? `${Keys}` extends Pattern ? Keys : never : never;
+/**
+ * The success statuses of a Response Object Map: every 2XX one. A closed list of statuses left out
+ * the ones it did not name (205, 208, 226), and their bodies were typed as no data.
+ */
+type SuccessStatusKey<T> = StatusKeysMatching<keyof T, `2${StatusDigit}${StatusDigit}` | "2XX">;
+/**
+ * The error statuses of a Response Object Map: every 1XX, 3XX, 4XX and 5XX one, and `default`. The
+ * client returns each response that is not `ok` as `error`, also a 3XX with `redirect: "manual"`.
+ */
+type ErrorStatusKey<T> = StatusKeysMatching<keyof T, `${1 | 3 | 4 | 5}${StatusDigit}${StatusDigit}` | `${1 | 3 | 4 | 5}XX` | "default">;
 /** Get a union of OK Statuses */
-type OKStatusUnion<T> = FilterKeys<T, OkStatus>;
+type OKStatusUnion<T> = FilterKeys<T, SuccessStatusKey<T>>;
 /** Get first error status, in order */
 type FirstErrorStatus<T> = T extends {
     500: unknown;
@@ -178,7 +198,7 @@ type OperationRequestBodyContent<T> = FilterKeys<OperationRequestBodyMediaConten
  * Responses Object), so then it covers every success (upstream #1862). With a 2XX status declared,
  * `default` is left to the errors, as before.
  */
-type SuccessStatus<T> = [Extract<keyof T, OkStatus>] extends [never] ? "default" : OkStatus;
+type SuccessStatus<T> = [SuccessStatusKey<T>] extends [never] ? Extract<keyof T, "default"> : SuccessStatusKey<T>;
 /**
  * Return all 2XX responses from a Response Object Map, or `default` if it declares no 2XX one. For
  * a union of maps (a call with a union of paths), the union of each map's responses: `keyof` of a
@@ -190,10 +210,10 @@ type GetResponseContent<T extends Record<string | number, any>, Media extends Me
     [K in ResponseCode]: T[K]["content"] extends Record<string, any> ? FilterKeys<T[K]["content"], Media> extends never ? T[K]["content"] : FilterKeys<T[K]["content"], Media> : K extends keyof T ? T[K]["content"] : never;
 }[ResponseCode] : never;
 /**
- * Return all 5XX and 4XX responses (in that order) from a Response Object Map; for a union of maps,
- * the union of each map's responses, as `SuccessResponse`.
+ * Return all 1XX, 3XX, 4XX, 5XX and `default` responses from a Response Object Map; for a union
+ * of maps, the union of each map's responses, as `SuccessResponse`.
  */
-type ErrorResponse<T extends Record<string | number, any>, Media extends MediaType = MediaType> = T extends unknown ? GetResponseContent<T, Media, ErrorStatus> : never;
+type ErrorResponse<T extends Record<string | number, any>, Media extends MediaType = MediaType> = T extends unknown ? GetResponseContent<T, Media, ErrorStatusKey<T>> : never;
 /** Return first JSON-like 2XX response from a path + HTTP method */
 type SuccessResponseJSON<PathMethod extends Record<string | number, any>> = SuccessResponse<ResponseObjectMap<PathMethod>, `${string}/json`>;
 /** Return first JSON-like 5XX or 4XX response from a path + HTTP method */
@@ -258,10 +278,13 @@ type ReadWriteLeaf = ReadWritePrimitive | ((...args: never) => unknown);
  * `any` key is not marked either (`0 extends 1 & T[K]` is true only for `any`): a check on `any`
  * takes both branches, so `Readable` dropped the key and `Writable` typed it `undefined`. The
  * checks are not distributive (their check types are not type parameters), so `never` is seen.
+ * The keys are read by remapping, not as `{ ... }[keyof T]`: with an index signature (from
+ * `additionalProperties`) `keyof T` is `string`, which indexes the signature only, so no property
+ * was marked and `Writable` made a readOnly property a required `never`.
  */
-type ReadWriteMarkedKeys<T, Marker> = {
-    [K in keyof T]-?: 0 extends 1 & T[K] ? never : NonNullable<T[K]> extends never ? never : NonNullable<T[K]> extends Marker ? K : never;
-}[keyof T];
+type ReadWriteMarkedKeys<T, Marker> = keyof {
+    [K in keyof T as 0 extends 1 & T[K] ? never : NonNullable<T[K]> extends never ? never : NonNullable<T[K]> extends Marker ? K : never]: never;
+};
 /**
  * Resolve an array or a tuple element by element. An array uses `T[number]`, not `infer E`: for an
  * intersection of arrays (`allOf`) inference keeps one member and narrowing breaks (upstream
@@ -296,4 +319,4 @@ type Writable<T> = T extends $Read<any> ? never : T extends $Write<infer U> ? Wr
     [K in ReadWriteMarkedKeys<T, $Read<any>>]?: never;
 } : T;
 
-export type { $Read, $Write, ErrorResponse, ErrorResponseJSON, ErrorStatus, FilterKeys, FindRequiredKeys, FirstErrorStatus, GetResponseContent, GetValueWithDefault, HasRequiredKeys, HttpMethod, IsOperationRequestBodyOptional, JSONLike, MediaType, OKStatusUnion, OkStatus, OperationObject, OperationRequestBody, OperationRequestBodyContent, OperationRequestBodyMediaContent, PathItemObject, PathsWithMethod, Readable, RequestBodyJSON, RequiredKeysOf, ResponseContent, ResponseObjectMap, SuccessResponse, SuccessResponseJSON, Writable };
+export type { $Read, $Write, ErrorResponse, ErrorResponseJSON, ErrorStatus, ErrorStatusKey, FilterKeys, FindRequiredKeys, FirstErrorStatus, GetResponseContent, GetValueWithDefault, HasRequiredKeys, HttpMethod, IsOperationRequestBodyOptional, JSONLike, MediaType, OKStatusUnion, OkStatus, OperationObject, OperationRequestBody, OperationRequestBodyContent, OperationRequestBodyMediaContent, PathItemObject, PathsWithMethod, Readable, RequestBodyJSON, RequiredKeysOf, ResponseContent, ResponseObjectMap, SuccessResponse, SuccessResponseJSON, SuccessStatusKey, Writable };

package/dist/helpers.d.ts

@@ -2,12 +2,32 @@
 type HttpMethod = "get" | "put" | "post" | "delete" | "options" | "head" | "patch" | "trace"
 /** OpenAPI 3.2: a safe, idempotent request with a body. */
  | "query";
-/** 2XX statuses */
+/**
+ * Some 2XX statuses, kept for code that names them. The client does not classify by this list: a
+ * status is a success or an error by its first digit (`SuccessStatusKey`, `ErrorStatusKey`).
+ */
 type OkStatus = 200 | 201 | 202 | 203 | 204 | 206 | 207 | "2XX";
-/** 4XX and 5XX statuses */
+/** Some 4XX and 5XX statuses and `default`, kept like `OkStatus`. */
 type ErrorStatus = 500 | 501 | 502 | 503 | 504 | 505 | 506 | 507 | 508 | 510 | 511 | "5XX" | 400 | 401 | 402 | 403 | 404 | 405 | 406 | 407 | 408 | 409 | 410 | 411 | 412 | 413 | 414 | 415 | 416 | 417 | 418 | 420 | 421 | 422 | 423 | 424 | 425 | 426 | 427 | 428 | 429 | 430 | 431 | 444 | 450 | 451 | 497 | 498 | 499 | "4XX" | "default";
+type StatusDigit = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
+/**
+ * The keys of a Response Object Map whose text matches a pattern. A generated map has numeric keys
+ * (`200`) and string ones (`"2XX"`, `"default"`), and a numeric literal matches no template
+ * literal type, so each key is matched by its text.
+ */
+type StatusKeysMatching<Keys, Pattern extends string> = Keys extends string | number ? `${Keys}` extends Pattern ? Keys : never : never;
+/**
+ * The success statuses of a Response Object Map: every 2XX one. A closed list of statuses left out
+ * the ones it did not name (205, 208, 226), and their bodies were typed as no data.
+ */
+type SuccessStatusKey<T> = StatusKeysMatching<keyof T, `2${StatusDigit}${StatusDigit}` | "2XX">;
+/**
+ * The error statuses of a Response Object Map: every 1XX, 3XX, 4XX and 5XX one, and `default`. The
+ * client returns each response that is not `ok` as `error`, also a 3XX with `redirect: "manual"`.
+ */
+type ErrorStatusKey<T> = StatusKeysMatching<keyof T, `${1 | 3 | 4 | 5}${StatusDigit}${StatusDigit}` | `${1 | 3 | 4 | 5}XX` | "default">;
 /** Get a union of OK Statuses */
-type OKStatusUnion<T> = FilterKeys<T, OkStatus>;
+type OKStatusUnion<T> = FilterKeys<T, SuccessStatusKey<T>>;
 /** Get first error status, in order */
 type FirstErrorStatus<T> = T extends {
     500: unknown;
@@ -178,7 +198,7 @@ type OperationRequestBodyContent<T> = FilterKeys<OperationRequestBodyMediaConten
  * Responses Object), so then it covers every success (upstream #1862). With a 2XX status declared,
  * `default` is left to the errors, as before.
  */
-type SuccessStatus<T> = [Extract<keyof T, OkStatus>] extends [never] ? "default" : OkStatus;
+type SuccessStatus<T> = [SuccessStatusKey<T>] extends [never] ? Extract<keyof T, "default"> : SuccessStatusKey<T>;
 /**
  * Return all 2XX responses from a Response Object Map, or `default` if it declares no 2XX one. For
  * a union of maps (a call with a union of paths), the union of each map's responses: `keyof` of a
@@ -190,10 +210,10 @@ type GetResponseContent<T extends Record<string | number, any>, Media extends Me
     [K in ResponseCode]: T[K]["content"] extends Record<string, any> ? FilterKeys<T[K]["content"], Media> extends never ? T[K]["content"] : FilterKeys<T[K]["content"], Media> : K extends keyof T ? T[K]["content"] : never;
 }[ResponseCode] : never;
 /**
- * Return all 5XX and 4XX responses (in that order) from a Response Object Map; for a union of maps,
- * the union of each map's responses, as `SuccessResponse`.
+ * Return all 1XX, 3XX, 4XX, 5XX and `default` responses from a Response Object Map; for a union
+ * of maps, the union of each map's responses, as `SuccessResponse`.
  */
-type ErrorResponse<T extends Record<string | number, any>, Media extends MediaType = MediaType> = T extends unknown ? GetResponseContent<T, Media, ErrorStatus> : never;
+type ErrorResponse<T extends Record<string | number, any>, Media extends MediaType = MediaType> = T extends unknown ? GetResponseContent<T, Media, ErrorStatusKey<T>> : never;
 /** Return first JSON-like 2XX response from a path + HTTP method */
 type SuccessResponseJSON<PathMethod extends Record<string | number, any>> = SuccessResponse<ResponseObjectMap<PathMethod>, `${string}/json`>;
 /** Return first JSON-like 5XX or 4XX response from a path + HTTP method */
@@ -258,10 +278,13 @@ type ReadWriteLeaf = ReadWritePrimitive | ((...args: never) => unknown);
  * `any` key is not marked either (`0 extends 1 & T[K]` is true only for `any`): a check on `any`
  * takes both branches, so `Readable` dropped the key and `Writable` typed it `undefined`. The
  * checks are not distributive (their check types are not type parameters), so `never` is seen.
+ * The keys are read by remapping, not as `{ ... }[keyof T]`: with an index signature (from
+ * `additionalProperties`) `keyof T` is `string`, which indexes the signature only, so no property
+ * was marked and `Writable` made a readOnly property a required `never`.
  */
-type ReadWriteMarkedKeys<T, Marker> = {
-    [K in keyof T]-?: 0 extends 1 & T[K] ? never : NonNullable<T[K]> extends never ? never : NonNullable<T[K]> extends Marker ? K : never;
-}[keyof T];
+type ReadWriteMarkedKeys<T, Marker> = keyof {
+    [K in keyof T as 0 extends 1 & T[K] ? never : NonNullable<T[K]> extends never ? never : NonNullable<T[K]> extends Marker ? K : never]: never;
+};
 /**
  * Resolve an array or a tuple element by element. An array uses `T[number]`, not `infer E`: for an
  * intersection of arrays (`allOf`) inference keeps one member and narrowing breaks (upstream
@@ -296,4 +319,4 @@ type Writable<T> = T extends $Read<any> ? never : T extends $Write<infer U> ? Wr
     [K in ReadWriteMarkedKeys<T, $Read<any>>]?: never;
 } : T;
 
-export type { $Read, $Write, ErrorResponse, ErrorResponseJSON, ErrorStatus, FilterKeys, FindRequiredKeys, FirstErrorStatus, GetResponseContent, GetValueWithDefault, HasRequiredKeys, HttpMethod, IsOperationRequestBodyOptional, JSONLike, MediaType, OKStatusUnion, OkStatus, OperationObject, OperationRequestBody, OperationRequestBodyContent, OperationRequestBodyMediaContent, PathItemObject, PathsWithMethod, Readable, RequestBodyJSON, RequiredKeysOf, ResponseContent, ResponseObjectMap, SuccessResponse, SuccessResponseJSON, Writable };
+export type { $Read, $Write, ErrorResponse, ErrorResponseJSON, ErrorStatus, ErrorStatusKey, FilterKeys, FindRequiredKeys, FirstErrorStatus, GetResponseContent, GetValueWithDefault, HasRequiredKeys, HttpMethod, IsOperationRequestBodyOptional, JSONLike, MediaType, OKStatusUnion, OkStatus, OperationObject, OperationRequestBody, OperationRequestBodyContent, OperationRequestBodyMediaContent, PathItemObject, PathsWithMethod, Readable, RequestBodyJSON, RequiredKeysOf, ResponseContent, ResponseObjectMap, SuccessResponse, SuccessResponseJSON, SuccessStatusKey, Writable };

package/dist/index.cjs

@@ -7,11 +7,18 @@ const DOT_SEGMENT_RE = /^\.\.?$/;
 const QUERY_OR_FRAGMENT_RE = /[?#]/;
 const JSON_MEDIA_TYPE_RE = /^[^/]+\/([^;]*\+)?json\s*(;|$)/i;
 const TEXT_MEDIA_TYPE_RE = /^text\//i;
-const FORM_MEDIA_TYPE_RE = /^application\/x-www-form-urlencoded(;|$)/i;
-const MULTIPART_MEDIA_TYPE_RE = /^multipart\/form-data(;|$)/i;
+const FORM_MEDIA_TYPE_RE = /^application\/x-www-form-urlencoded[ \t]*(;|$)/i;
+const MULTIPART_MEDIA_TYPE_RE = /^multipart\/form-data[ \t]*(;|$)/i;
 const NESTED_FORM_VALUE_MESSAGE = "Nested form values need your own `bodySerializer()`.";
 const BOUNDARY_PARAMETER_RE = /;\s*boundary=/i;
 const CLIENT_BUILT_FORM = Symbol.for("openapi-typesafe-fetch/form");
+const TYPE_TAG_START = "[object ".length;
+const TYPE_TAG_END = -1;
+const BLOB_CLASSES = ["Blob", "File"];
+const RAW_BODY_CLASSES = ["URLSearchParams", "ArrayBuffer"];
+const FORM_DATA_METHODS = ["append", "entries"];
+const BLOB_METHODS = ["arrayBuffer"];
+const STREAM_METHODS = ["getReader"];
 const supportsRequestInitExt = () => {
   return typeof process === "object" && process.versions?.undici;
 };
@@ -24,6 +31,7 @@ function createClient(clientOptions) {
   let {
     baseUrl = "",
     Request: CustomRequest = globalThis.Request,
+    FormData: CustomFormData = globalThis.FormData,
     fetch: baseFetch = globalThis.fetch,
     querySerializer: globalQuerySerializer,
     bodySerializer: globalBodySerializer,
@@ -56,12 +64,10 @@ function createClient(clientOptions) {
     }
     let querySerializer = typeof globalQuerySerializer === "function" ? globalQuerySerializer : createQuerySerializer(globalQuerySerializer);
     if (requestQuerySerializer) {
-      querySerializer = typeof requestQuerySerializer === "function" ? requestQuerySerializer : createQuerySerializer({
-        ...typeof globalQuerySerializer === "object" ? globalQuerySerializer : {},
-        ...requestQuerySerializer
-      });
+      querySerializer = typeof requestQuerySerializer === "function" ? requestQuerySerializer : createQuerySerializer(mergeQueryOptions(globalQuerySerializer, requestQuerySerializer));
     }
     const pathSerializer = requestPathSerializer || globalPathSerializer || defaultPathSerializer;
+    const headerParams = serializeHeaderParams(params.header);
     const serializedBody = body === void 0 ? void 0 : bodySerializer(
       body,
       // Note: we declare mergeHeaders() both here and below because it’s a bit of a
@@ -70,29 +76,30 @@ function createClient(clientOptions) {
       // content-type header. So we re-merge below, setting the content-type at the very
       // beginning to be overwritten. Lastly, based on the way headers work, it’s not a simple
       // “present-or-not” check because null intentionally un-sets headers.
-      mergeHeaders(baseHeaders, headers, params.header)
+      mergeHeaders(baseHeaders, headers, headerParams)
     );
+    const requestBody = isFormData(serializedBody) ? asFormDataOf(CustomFormData, serializedBody) : serializedBody;
     const finalHeaders = mergeHeaders(
       // with no body, we should not to set Content-Type
-      serializedBody === void 0 || // a raw body (FormData, Blob, ...) gets its Content-Type from the platform, or none
-      isRawBody(serializedBody) ? {} : {
+      requestBody === void 0 || // a raw body (FormData, Blob, ...) gets its Content-Type from the platform, or none
+      isRawBody(requestBody) ? {} : {
         "Content-Type": "application/json"
       },
       baseHeaders,
       headers,
-      params.header
+      headerParams
     );
-    if (isPlatformInstance(serializedBody, "FormData")) {
-      dropFormContentType(finalHeaders, serializedBody[CLIENT_BUILT_FORM] === true);
+    if (isFormData(requestBody)) {
+      dropFormContentType(finalHeaders, requestBody[CLIENT_BUILT_FORM] === true);
     }
     const finalMiddlewares = [...globalMiddlewares, ...requestMiddlewares];
     const requestInit = {
       redirect: "follow",
       // The Fetch standard requires `duplex: "half"` (its only value) for a stream body.
-      duplex: isStreamBody(serializedBody) ? "half" : void 0,
+      duplex: isStreamBody(requestBody) ? "half" : void 0,
       ...baseOptions,
       ...init,
-      body: serializedBody,
+      body: requestBody,
       headers: finalHeaders
     };
     let id;
@@ -169,7 +176,7 @@ function createClient(clientOptions) {
                   response = result;
                   break;
                 }
-                if (result instanceof Error) {
+                if (isError(result)) {
                   errorAfterMiddleware = result;
                   continue;
                 }
@@ -209,16 +216,10 @@ function createClient(clientOptions) {
         }
       }
     }
-    const contentLength = response.headers.get("Content-Length");
-    if (response.status === 204 || request.method === "HEAD" || contentLength === "0" && !response.headers.get("Transfer-Encoding")?.includes("chunked")) {
-      return response.ok ? { data: void 0, response } : { error: void 0, response };
-    }
-    if (response.ok) {
-      return { data: await readSuccessBody(response, parseAs), response };
-    }
-    return { error: await readErrorBody(response), response };
+    return readResult(response, parseAs, request.method);
   }
   return {
+    baseUrl,
     request(method, url, init) {
       return coreFetch(url, { ...init, method: method.toUpperCase() });
     },
@@ -364,6 +365,20 @@ function parseJSON(raw, response) {
     throw new SyntaxError(`${subject} is not JSON (${raw.length} characters); ${hint}`);
   }
 }
+function hasEmptyBody(response, method) {
+  const isDeclaredEmpty = response.headers.get("Content-Length") === "0" && !response.headers.get("Transfer-Encoding")?.includes("chunked");
+  return method === "HEAD" || isDeclaredEmpty;
+}
+async function readResult(response, parseAs, method) {
+  const isEmpty = hasEmptyBody(response, method);
+  if (!response.ok) {
+    return { error: isEmpty ? void 0 : await readErrorBody(response), response };
+  }
+  if (parseAs === "json" && isEmpty) {
+    return { data: void 0, response };
+  }
+  return { data: await readSuccessBody(response, parseAs), response };
+}
 async function readSuccessBody(response, parseAs) {
   if (parseAs === "stream") {
     return response.body;
@@ -395,7 +410,27 @@ function isDate(value) {
 function valueText(value) {
   return isDate(value) ? value.toISOString() : value;
 }
+const HEADER_PARAM_STYLE = { style: "simple", explode: false, allowReserved: true };
+function headerParamValue(value) {
+  if (value === null || typeof value !== "object" || isDate(value)) {
+    return valueText(value);
+  }
+  const serialize = Array.isArray(value) ? serializeArrayParam : serializeObjectParam;
+  return serialize("", value, HEADER_PARAM_STYLE) || void 0;
+}
+function serializeHeaderParams(header) {
+  if (!header || typeof header !== "object") {
+    return header;
+  }
+  const entries = Object.entries(header).map(([name, value]) => [name, headerParamValue(value)]);
+  return Object.fromEntries(entries);
+}
 function encodeValue(value, allowReserved) {
+  if (value && typeof value === "object" && !isDate(value)) {
+    throw new Error(
+      "Deeply-nested arrays/objects aren\u2019t supported. Provide your own `querySerializer()` to handle these."
+    );
+  }
   const text = valueText(value);
   return allowReserved === true ? text : encodeURIComponent(text);
 }
@@ -403,11 +438,6 @@ function serializePrimitiveParam(name, value, options) {
   if (value === void 0 || value === null) {
     return "";
   }
-  if (typeof value === "object" && !isDate(value)) {
-    throw new Error(
-      "Deeply-nested arrays/objects aren\u2019t supported. Provide your own `querySerializer()` to handle these."
-    );
-  }
   return `${name}=${encodeValue(value, options?.allowReserved)}`;
 }
 function joinExploded(values, style) {
@@ -418,7 +448,10 @@ function joinExploded(values, style) {
 function serializeUnexplodedObject(name, value, options) {
   const values = [];
   for (const k in value) {
-    values.push(encodeValue(k), encodeValue(value[k], options.allowReserved));
+    values.push(
+      encodeValue(k, options.allowReserved),
+      encodeValue(value[k], options.allowReserved)
+    );
   }
   const final = values.join(",");
   switch (options.style) {
@@ -492,17 +525,15 @@ function serializeQueryParam(name, value, options) {
   const allowReserved = options?.allowReserved || false;
   if (Array.isArray(value)) {
     return serializeArrayParam(name, value, {
-      style: "form",
-      explode: true,
-      ...options?.array,
+      style: options?.array?.style ?? "form",
+      explode: options?.array?.explode ?? true,
       allowReserved
     });
   }
   if (value && typeof value === "object" && !isDate(value)) {
     return serializeObjectParam(name, value, {
-      style: "deepObject",
-      explode: true,
-      ...options?.object,
+      style: options?.object?.style ?? "deepObject",
+      explode: options?.object?.explode ?? true,
       allowReserved
     });
   }
@@ -522,6 +553,15 @@ function createQuerySerializer(options) {
     return search.join("&");
   };
 }
+function mergeQueryOptions(clientOptions, requestOptions) {
+  const base = typeof clientOptions === "function" ? {} : clientOptions ?? {};
+  return {
+    ...base,
+    ...requestOptions,
+    array: { ...base.array, ...requestOptions.array },
+    object: { ...base.object, ...requestOptions.object }
+  };
+}
 function defaultPathSerializer(pathname, pathParams) {
   const matches = pathname.match(PATH_PARAM_RE);
   if (!matches) {
@@ -576,17 +616,41 @@ function checkSerializedPath(template, url) {
     throw new Error(`${problem} path segment in "${name}"`);
   }
 }
-function isPlatformInstance(value, name) {
+function typeTag(value) {
+  return Object.prototype.toString.call(value).slice(TYPE_TAG_START, TYPE_TAG_END);
+}
+function isClass(value, name, methods = []) {
   const type = globalThis[name];
-  return typeof type === "function" && value instanceof type;
+  return typeof type === "function" && value instanceof type || typeTag(value) === name && methods.every((method) => typeof value[method] === "function");
+}
+function isError(value) {
+  return isClass(value, "Error");
+}
+function isFormData(value) {
+  return isClass(value, "FormData", FORM_DATA_METHODS);
+}
+function isBlob(value) {
+  return BLOB_CLASSES.some((name) => isClass(value, name, BLOB_METHODS));
+}
+function isReadableStream(value) {
+  return isClass(value, "ReadableStream", STREAM_METHODS);
+}
+function asFormDataOf(FormDataClass, form) {
+  if (typeof FormDataClass !== "function" || form instanceof FormDataClass) {
+    return form;
+  }
+  const copy = new FormDataClass();
+  for (const [name, value] of form.entries()) {
+    copy.append(name, value);
+  }
+  copy[CLIENT_BUILT_FORM] = true;
+  return copy;
 }
 function isStreamBody(body) {
-  return isPlatformInstance(body, "ReadableStream") || typeof body?.[Symbol.asyncIterator] === "function";
+  return isReadableStream(body) || typeof body?.[Symbol.asyncIterator] === "function";
 }
 function isRawBody(body) {
-  return ["FormData", "Blob", "URLSearchParams", "ArrayBuffer"].some(
-    (name) => isPlatformInstance(body, name)
-  ) || ArrayBuffer.isView(body) || isStreamBody(body);
+  return isFormData(body) || isBlob(body) || RAW_BODY_CLASSES.some((name) => isClass(body, name)) || ArrayBuffer.isView(body) || isStreamBody(body);
 }
 function isNestedFormValue(value) {
   return value && typeof value === "object" && !isDate(value);
@@ -615,7 +679,7 @@ function multipartBody(body) {
   formData[CLIENT_BUILT_FORM] = true;
   for (const [name, value] of Object.entries(body)) {
     for (const item of formItems(value)) {
-      if (isPlatformInstance(item, "Blob")) {
+      if (isBlob(item)) {
         formData.append(name, item);
       } else if (isNestedFormValue(item)) {
         throw new Error(NESTED_FORM_VALUE_MESSAGE);
@@ -651,10 +715,14 @@ function createFinalURL(pathname, options) {
   if (search.startsWith("?")) {
     search = search.substring(1);
   }
-  if (search) {
-    finalURL += `${finalURL.includes("?") ? "&" : "?"}${search}`;
+  if (!search) {
+    return finalURL;
   }
-  return finalURL;
+  const hashIndex = finalURL.indexOf("#");
+  const fragmentStart = hashIndex === -1 ? finalURL.length : hashIndex;
+  const beforeFragment = finalURL.slice(0, fragmentStart);
+  const joiner = beforeFragment.includes("?") ? "&" : "?";
+  return `${beforeFragment}${joiner}${search}${finalURL.slice(fragmentStart)}`;
 }
 function mergeHeaders(...allHeaders) {
   const finalHeaders = new Headers();