@foundatiofx/fetchclient 1.1.1 → 1.2.0

package/esm/mod.js

@@ -1,7 +1,90 @@
 export { FetchClient } from "./src/FetchClient.js";
+export { FetchClientError } from "./src/FetchClientError.js";
+export { ResponsePromise } from "./src/ResponsePromise.js";
 export { ProblemDetails } from "./src/ProblemDetails.js";
 export { FetchClientCache, } from "./src/FetchClientCache.js";
 export { defaultInstance as defaultProviderInstance, FetchClientProvider, } from "./src/FetchClientProvider.js";
 export * from "./src/DefaultHelpers.js";
 export { CircuitBreaker, groupByDomain as circuitBreakerGroupByDomain, } from "./src/CircuitBreaker.js";
 export { CircuitBreakerMiddleware, CircuitOpenError, createCircuitBreakerMiddleware, createPerDomainCircuitBreakerMiddleware, } from "./src/CircuitBreakerMiddleware.js";
+export { createRetryMiddleware, RetryMiddleware, } from "./src/RetryMiddleware.js";
+export { createPerDomainRateLimitMiddleware, createRateLimitMiddleware, RateLimitError, RateLimitMiddleware, } from "./src/RateLimitMiddleware.js";
+export { groupByDomain as rateLimiterGroupByDomain, RateLimiter, } from "./src/RateLimiter.js";
+import { createRetryMiddleware } from "./src/RetryMiddleware.js";
+import { createPerDomainRateLimitMiddleware, createRateLimitMiddleware, } from "./src/RateLimitMiddleware.js";
+import { createCircuitBreakerMiddleware, createPerDomainCircuitBreakerMiddleware, } from "./src/CircuitBreakerMiddleware.js";
+import { deleteJSON, getJSON, patchJSON, postJSON, putJSON, useFetchClient, useMiddleware, } from "./src/DefaultHelpers.js";
+/**
+ * Convenience middleware factory functions for use with FetchClient.use()
+ *
+ * @example
+ * ```typescript
+ * import { FetchClient, middleware } from "@foundatiofx/fetchclient";
+ *
+ * const client = new FetchClient();
+ * client.use(
+ *   middleware.retry({ limit: 3 }),
+ *   middleware.rateLimit({ maxRequests: 100, windowSeconds: 60 }),
+ *   middleware.circuitBreaker({ failureThreshold: 5 })
+ * );
+ * ```
+ */
+export const middleware = {
+    /** Retry failed requests with exponential backoff and jitter */
+    retry: createRetryMiddleware,
+    /** Rate limit requests to prevent overwhelming servers */
+    rateLimit: createRateLimitMiddleware,
+    /** Per-domain rate limit (each domain tracked separately) */
+    perDomainRateLimit: createPerDomainRateLimitMiddleware,
+    /** Circuit breaker for fault tolerance */
+    circuitBreaker: createCircuitBreakerMiddleware,
+    /** Per-domain circuit breaker (each domain tracked separately) */
+    perDomainCircuitBreaker: createPerDomainCircuitBreakerMiddleware,
+};
+/**
+ * Default export for convenient access to all HTTP methods.
+ *
+ * @example
+ * ```typescript
+ * import fc from "@foundatiofx/fetchclient";
+ *
+ * // Configure middleware
+ * fc.use(fc.middleware.retry({ limit: 3 }));
+ *
+ * // Use JSON methods (recommended)
+ * const { data: user } = await fc.getJSON<User>("/api/user/1");
+ * const { data: created } = await fc.postJSON<User>("/api/users", { name: "Alice" });
+ *
+ * // Or use fluent API for other response types
+ * const html = await fc.get("/page").text();
+ * ```
+ */
+const fetchClient = {
+    /** Sends a GET request. Use `.json<T>()` for typed JSON response. */
+    get: (url, options) => useFetchClient().get(url, options),
+    /** Sends a POST request. Use `.json<T>()` for typed JSON response. */
+    post: (url, body, options) => useFetchClient().post(url, body, options),
+    /** Sends a PUT request. Use `.json<T>()` for typed JSON response. */
+    put: (url, body, options) => useFetchClient().put(url, body, options),
+    /** Sends a PATCH request. Use `.json<T>()` for typed JSON response. */
+    patch: (url, body, options) => useFetchClient().patch(url, body, options),
+    /** Sends a DELETE request. Use `.json<T>()` for typed JSON response. */
+    delete: (url, options) => useFetchClient().delete(url, options),
+    /** Sends a HEAD request. */
+    head: (url, options) => useFetchClient().head(url, options),
+    /** Sends a GET request and returns parsed JSON in response.data */
+    getJSON,
+    /** Sends a POST request and returns parsed JSON in response.data */
+    postJSON,
+    /** Sends a PUT request and returns parsed JSON in response.data */
+    putJSON,
+    /** Sends a PATCH request and returns parsed JSON in response.data */
+    patchJSON,
+    /** Sends a DELETE request and returns parsed JSON in response.data */
+    deleteJSON,
+    /** Adds middleware to the default provider */
+    use: useMiddleware,
+    /** Middleware factory functions */
+    middleware,
+};
+export default fetchClient;

package/esm/src/DefaultHelpers.js

@@ -11,7 +11,7 @@ export function useFetchClient(options) {
  * Sends a GET request to the specified URL using the default client and provider and returns the response as JSON.
  * @param url - The URL to send the GET request to.
  * @param options - Optional request options.
- * @returns A promise that resolves to the response as JSON.
+ * @returns A promise that resolves to the response with parsed JSON in `data`.
  */
 export function getJSON(url, options) {
     return useFetchClient().getJSON(url, options);
@@ -23,7 +23,7 @@ export function getJSON(url, options) {
  * @param {string} url - The URL to send the request to.
  * @param {object | string | FormData} [body] - The JSON payload or form data to send with the request.
  * @param {RequestOptions} [options] - Additional options for the request.
- * @returns {Promise<FetchClientResponse<T>>} - A promise that resolves to the response data.
+ * @returns A promise that resolves to the response with parsed JSON in `data`.
  */
 export function postJSON(url, body, options) {
     return useFetchClient().postJSON(url, body, options);
@@ -35,7 +35,7 @@ export function postJSON(url, body, options) {
  * @param {string} url - The URL to send the request to.
  * @param {object | string} [body] - The JSON payload to send with the request.
  * @param {RequestOptions} [options] - Additional options for the request.
- * @returns {Promise<FetchClientResponse<T>>} - A promise that resolves to the response data.
+ * @returns A promise that resolves to the response with parsed JSON in `data`.
  */
 export function putJSON(url, body, options) {
     return useFetchClient().putJSON(url, body, options);
@@ -47,7 +47,7 @@ export function putJSON(url, body, options) {
  * @param {string} url - The URL to send the request to.
  * @param {object | string} [body] - The JSON payload to send with the request.
  * @param {RequestOptions} [options] - Additional options for the request.
- * @returns {Promise<FetchClientResponse<T>>} - A promise that resolves to the response data.
+ * @returns A promise that resolves to the response with parsed JSON in `data`.
  */
 export function patchJSON(url, body, options) {
     return useFetchClient().patchJSON(url, body, options);
@@ -58,7 +58,7 @@ export function patchJSON(url, body, options) {
  * @template T - The type of the response data.
  * @param {string} url - The URL to send the request to.
  * @param {RequestOptions} [options] - Additional options for the request.
- * @returns {Promise<FetchClientResponse<T>>} - A promise that resolves to the response data.
+ * @returns A promise that resolves to the response with parsed JSON in `data`.
  */
 export function deleteJSON(url, options) {
     return useFetchClient().deleteJSON(url, options);

package/esm/src/FetchClient.js

@@ -4,6 +4,8 @@ import { parseLinkHeader } from "./LinkHeader.js";
 import { FetchClientProvider } from "./FetchClientProvider.js";
 import { getCurrentProvider } from "./DefaultHelpers.js";
 import { ObjectEvent } from "./ObjectEvent.js";
+import { ResponsePromise } from "./ResponsePromise.js";
+import { FetchClientError } from "./FetchClientError.js";
 /**
  * Represents a client for making HTTP requests using the Fetch API.
  */
@@ -100,24 +102,27 @@ export class FetchClient {
      *
      * @param url - The URL to send the GET request to.
      * @param options - The optional request options.
-     * @returns A promise that resolves to the response of the GET request.
+     * @returns A ResponsePromise that resolves to the response. Can use `.json<T>()` for typed JSON.
      */
-    async get(url, options) {
-        options = {
+    get(url, options) {
+        const mergedOptions = {
             ...this.options.defaultRequestOptions,
             ...options,
         };
-        const response = await this.fetchInternal(url, options, this.buildRequestInit("GET", undefined, options));
-        return response;
+        const responsePromise = this.fetchInternal(url, mergedOptions, this.buildRequestInit("GET", undefined, mergedOptions));
+        return new ResponsePromise(responsePromise, mergedOptions);
     }
     /**
      * Sends a GET request to the specified URL and returns the response as JSON.
+     * The response will have the parsed JSON in `response.data`.
+     *
      * @param url - The URL to send the GET request to.
      * @param options - Optional request options.
-     * @returns A promise that resolves to the response as JSON.
+     * @returns A promise that resolves to the response with parsed JSON in `data`.
      */
-    getJSON(url, options) {
-        return this.get(url, this.buildJsonRequestOptions(options));
+    async getJSON(url, options) {
+        const mergedOptions = this.buildJsonRequestOptions(options);
+        return await this.get(url, mergedOptions);
     }
     /**
      * Sends a POST request to the specified URL.
@@ -125,107 +130,127 @@ export class FetchClient {
      * @param url - The URL to send the request to.
      * @param body - The request body, can be an object, a string, or FormData.
      * @param options - Additional options for the request.
-     * @returns A promise that resolves to a FetchClientResponse object.
+     * @returns A ResponsePromise that resolves to the response. Can use `.json<T>()` for typed JSON.
      */
-    async post(url, body, options) {
-        options = {
+    post(url, body, options) {
+        const mergedOptions = {
             ...this.options.defaultRequestOptions,
             ...options,
         };
-        const response = await this.fetchInternal(url, options, this.buildRequestInit("POST", body, options));
-        return response;
+        const responsePromise = this.fetchInternal(url, mergedOptions, this.buildRequestInit("POST", body, mergedOptions));
+        return new ResponsePromise(responsePromise, mergedOptions);
     }
     /**
      * Sends a POST request with JSON payload to the specified URL.
+     * The response will have the parsed JSON in `response.data`.
      *
      * @template T - The type of the response data.
      * @param {string} url - The URL to send the request to.
      * @param {object | string | FormData} [body] - The JSON payload or form data to send with the request.
      * @param {RequestOptions} [options] - Additional options for the request.
-     * @returns {Promise<FetchClientResponse<T>>} - A promise that resolves to the response data.
+     * @returns A promise that resolves to the response with parsed JSON in `data`.
      */
-    postJSON(url, body, options) {
-        return this.post(url, body, this.buildJsonRequestOptions(options));
+    async postJSON(url, body, options) {
+        return await this.post(url, body, this.buildJsonRequestOptions(options));
     }
     /**
      * Sends a PUT request to the specified URL with the given body and options.
      * @param url - The URL to send the request to.
      * @param body - The request body, can be an object, a string, or FormData.
      * @param options - The request options.
-     * @returns A promise that resolves to a FetchClientResponse object.
+     * @returns A ResponsePromise that resolves to the response. Can use `.json<T>()` for typed JSON.
      */
-    async put(url, body, options) {
-        options = {
+    put(url, body, options) {
+        const mergedOptions = {
             ...this.options.defaultRequestOptions,
             ...options,
         };
-        const response = await this.fetchInternal(url, options, this.buildRequestInit("PUT", body, options));
-        return response;
+        const responsePromise = this.fetchInternal(url, mergedOptions, this.buildRequestInit("PUT", body, mergedOptions));
+        return new ResponsePromise(responsePromise, mergedOptions);
     }
     /**
      * Sends a PUT request with JSON payload to the specified URL.
+     * The response will have the parsed JSON in `response.data`.
      *
      * @template T - The type of the response data.
      * @param {string} url - The URL to send the request to.
      * @param {object | string} [body] - The JSON payload to send with the request.
      * @param {RequestOptions} [options] - Additional options for the request.
-     * @returns {Promise<FetchClientResponse<T>>} - A promise that resolves to the response data.
+     * @returns A promise that resolves to the response with parsed JSON in `data`.
      */
-    putJSON(url, body, options) {
-        return this.put(url, body, this.buildJsonRequestOptions(options));
+    async putJSON(url, body, options) {
+        return await this.put(url, body, this.buildJsonRequestOptions(options));
     }
     /**
      * Sends a PATCH request to the specified URL with the provided body and options.
      * @param url - The URL to send the PATCH request to.
      * @param body - The body of the request. It can be an object, a string, or FormData.
      * @param options - The options for the request.
-     * @returns A Promise that resolves to the response of the PATCH request.
+     * @returns A ResponsePromise that resolves to the response. Can use `.json<T>()` for typed JSON.
      */
-    async patch(url, body, options) {
-        options = {
+    patch(url, body, options) {
+        const mergedOptions = {
             ...this.options.defaultRequestOptions,
             ...options,
         };
-        const response = await this.fetchInternal(url, options, this.buildRequestInit("PATCH", body, options));
-        return response;
+        const responsePromise = this.fetchInternal(url, mergedOptions, this.buildRequestInit("PATCH", body, mergedOptions));
+        return new ResponsePromise(responsePromise, mergedOptions);
     }
     /**
      * Sends a PATCH request with JSON payload to the specified URL.
+     * The response will have the parsed JSON in `response.data`.
      *
      * @template T - The type of the response data.
      * @param {string} url - The URL to send the request to.
      * @param {object | string} [body] - The JSON payload to send with the request.
      * @param {RequestOptions} [options] - Additional options for the request.
-     * @returns {Promise<FetchClientResponse<T>>} - A promise that resolves to the response data.
+     * @returns A promise that resolves to the response with parsed JSON in `data`.
      */
-    patchJSON(url, body, options) {
-        return this.patch(url, body, this.buildJsonRequestOptions(options));
+    async patchJSON(url, body, options) {
+        return await this.patch(url, body, this.buildJsonRequestOptions(options));
     }
     /**
      * Sends a DELETE request to the specified URL.
      *
      * @param url - The URL to send the DELETE request to.
      * @param options - The options for the request.
-     * @returns A promise that resolves to a `FetchClientResponse` object.
+     * @returns A ResponsePromise that resolves to the response. Can use `.json<T>()` for typed JSON.
      */
-    async delete(url, options) {
-        options = {
+    delete(url, options) {
+        const mergedOptions = {
             ...this.options.defaultRequestOptions,
             ...options,
         };
-        const response = await this.fetchInternal(url, options, this.buildRequestInit("DELETE", undefined, options));
-        return response;
+        const responsePromise = this.fetchInternal(url, mergedOptions, this.buildRequestInit("DELETE", undefined, mergedOptions));
+        return new ResponsePromise(responsePromise, mergedOptions);
     }
     /**
      * Sends a DELETE request with JSON payload to the specified URL.
+     * The response will have the parsed JSON in `response.data`.
      *
      * @template T - The type of the response data.
      * @param {string} url - The URL to send the request to.
      * @param {RequestOptions} [options] - Additional options for the request.
-     * @returns {Promise<FetchClientResponse<T>>} - A promise that resolves to the response data.
+     * @returns A promise that resolves to the response with parsed JSON in `data`.
      */
-    deleteJSON(url, options) {
-        return this.delete(url, this.buildJsonRequestOptions(options));
+    async deleteJSON(url, options) {
+        return await this.delete(url, this.buildJsonRequestOptions(options));
+    }
+    /**
+     * Sends a HEAD request to the specified URL.
+     * HEAD requests are identical to GET requests but without the response body.
+     *
+     * @param url - The URL to send the HEAD request to.
+     * @param options - The optional request options.
+     * @returns A ResponsePromise that resolves to the response.
+     */
+    head(url, options) {
+        const mergedOptions = {
+            ...this.options.defaultRequestOptions,
+            ...options,
+        };
+        const responsePromise = this.fetchInternal(url, mergedOptions, this.buildRequestInit("HEAD", undefined, mergedOptions));
+        return new ResponsePromise(responsePromise, mergedOptions);
     }
     async validate(data, options) {
         if (typeof data !== "object" ||
@@ -540,6 +565,6 @@ export class FetchClient {
         response.problem.status = response.status;
         response.problem.title = `Unexpected status code: ${response.status}`;
         response.problem.setErrorMessage(response.problem.title);
-        throw response;
+        throw new FetchClientError(response);
     }
 }

package/esm/src/FetchClientError.js

@@ -0,0 +1,73 @@
+/**
+ * Error wrapper for non-2xx responses.
+ * Exposes the underlying response for compatibility and debugging.
+ */
+export class FetchClientError extends Error {
+    response;
+    constructor(response, message) {
+        super(message ??
+            response.problem?.title ??
+            `Unexpected status code: ${response.status}`);
+        this.name = "FetchClientError";
+        this.response = response;
+    }
+    get status() {
+        return this.response.status;
+    }
+    get statusText() {
+        return this.response.statusText;
+    }
+    get ok() {
+        return this.response.ok;
+    }
+    get headers() {
+        return this.response.headers;
+    }
+    get url() {
+        return this.response.url;
+    }
+    get redirected() {
+        return this.response.redirected;
+    }
+    get type() {
+        return this.response.type;
+    }
+    get body() {
+        return this.response.body;
+    }
+    get bodyUsed() {
+        return this.response.bodyUsed;
+    }
+    get data() {
+        return this.response.data;
+    }
+    get problem() {
+        return this.response.problem;
+    }
+    get meta() {
+        return this.response.meta;
+    }
+    json() {
+        return this.response.json();
+    }
+    text() {
+        return this.response.text();
+    }
+    arrayBuffer() {
+        return this.response.arrayBuffer();
+    }
+    blob() {
+        return this.response.blob();
+    }
+    formData() {
+        return this.response.formData();
+    }
+    // @ts-ignore: New in Deno 1.44
+    bytes() {
+        // @ts-ignore: New in Deno 1.44
+        return this.response.bytes();
+    }
+    clone() {
+        return this.response.clone();
+    }
+}

package/esm/src/FetchClientProvider.js

@@ -6,6 +6,7 @@ import { RateLimitMiddleware, } from "./RateLimitMiddleware.js";
 import { groupByDomain } from "./RateLimiter.js";
 import { CircuitBreakerMiddleware, } from "./CircuitBreakerMiddleware.js";
 import { groupByDomain as circuitBreakerGroupByDomain, } from "./CircuitBreaker.js";
+import { RetryMiddleware, } from "./RetryMiddleware.js";
 /**
  * Represents a provider for creating instances of the FetchClient class with shared default options and cache.
  */
@@ -17,6 +18,8 @@ export class FetchClientProvider {
     #rateLimitMiddlewareFunc;
     #circuitBreakerMiddleware;
     #circuitBreakerMiddlewareFunc;
+    #retryMiddleware;
+    #retryMiddlewareFunc;
     #counter = new Counter();
     #onLoading = new ObjectEvent();
     /**
@@ -250,6 +253,27 @@ export class FetchClientProvider {
             this.#options.middleware = this.#options.middleware?.filter((m) => m !== middlewareFunc);
         }
     }
+    /**
+     * Enables automatic retry for failed requests.
+     * Retries are performed with exponential backoff and jitter.
+     * @param options - The retry configuration options.
+     */
+    useRetry(options) {
+        this.#retryMiddleware = new RetryMiddleware(options);
+        this.#retryMiddlewareFunc = this.#retryMiddleware.middleware();
+        this.useMiddleware(this.#retryMiddlewareFunc);
+    }
+    /**
+     * Removes the retry middleware from all FetchClient instances created by this provider.
+     */
+    removeRetry() {
+        const middlewareFunc = this.#retryMiddlewareFunc;
+        this.#retryMiddleware = undefined;
+        this.#retryMiddlewareFunc = undefined;
+        if (middlewareFunc) {
+            this.#options.middleware = this.#options.middleware?.filter((m) => m !== middlewareFunc);
+        }
+    }
 }
 const provider = new FetchClientProvider();
 export const defaultInstance = provider;

package/esm/src/RateLimitMiddleware.js

@@ -1,5 +1,5 @@
 import { ProblemDetails } from "./ProblemDetails.js";
-import { buildRateLimitHeader, buildRateLimitPolicyHeader, RateLimiter, } from "./RateLimiter.js";
+import { buildRateLimitHeader, buildRateLimitPolicyHeader, groupByDomain, RateLimiter, } from "./RateLimiter.js";
 /**
  * Rate limiting error thrown when requests exceed the rate limit.
  */
@@ -113,3 +113,37 @@ export class RateLimitMiddleware {
         };
     }
 }
+/**
+ * Creates a rate limit middleware with the given options.
+ *
+ * @example
+ * ```typescript
+ * const client = new FetchClient();
+ * client.use(createRateLimitMiddleware({
+ *   maxRequests: 100,
+ *   windowSeconds: 60,
+ * }));
+ * ```
+ */
+export function createRateLimitMiddleware(options) {
+    return new RateLimitMiddleware(options).middleware();
+}
+/**
+ * Creates a per-domain rate limit middleware where each domain is tracked separately.
+ *
+ * @example
+ * ```typescript
+ * const client = new FetchClient();
+ * client.use(createPerDomainRateLimitMiddleware({
+ *   maxRequests: 100,
+ *   windowSeconds: 60,
+ * }));
+ * // api.example.com and api.other.com will have separate rate limits
+ * ```
+ */
+export function createPerDomainRateLimitMiddleware(options) {
+    return new RateLimitMiddleware({
+        ...options,
+        getGroupFunc: groupByDomain,
+    }).middleware();
+}

package/esm/src/ResponsePromise.js

@@ -0,0 +1,163 @@
+/**
+ * A promise that resolves to a FetchClientResponse with additional helper methods
+ * for parsing the response body. This allows for a fluent API similar to ky:
+ *
+ * @example
+ * ```typescript
+ * // Await to get the full response
+ * const response = await client.get("/api/users");
+ *
+ * // Or use helper methods for direct access to parsed body
+ * const users = await client.get("/api/users").json<User[]>();
+ * const html = await client.get("/page").text();
+ * const file = await client.get("/file").blob();
+ * ```
+ */
+export class ResponsePromise {
+    #responsePromise;
+    #options;
+    constructor(responsePromise, options) {
+        this.#responsePromise = responsePromise;
+        this.#options = options;
+    }
+    /**
+     * Implements PromiseLike interface so the ResponsePromise can be awaited.
+     */
+    then(onfulfilled, onrejected) {
+        return this.#responsePromise.then(onfulfilled, onrejected);
+    }
+    /**
+     * Catches any errors from the response promise.
+     */
+    catch(onrejected) {
+        return this.#responsePromise.catch(onrejected);
+    }
+    /**
+     * Executes a callback when the promise settles (fulfilled or rejected).
+     */
+    finally(onfinally) {
+        return this.#responsePromise.finally(onfinally);
+    }
+    /**
+     * Parses the response body as JSON.
+     *
+     * If the response was already parsed as JSON (via getJSON, postJSON, etc.),
+     * returns the parsed data directly. Otherwise, parses the response body.
+     *
+     * @template TJson - The expected type of the JSON response
+     * @returns A promise that resolves to the parsed JSON
+     *
+     * @example
+     * ```typescript
+     * const user = await client.get("/api/user/1").json<User>();
+     * ```
+     */
+    async json() {
+        const response = await this.#responsePromise;
+        // If the response already has parsed data (from getJSON, etc.), return it
+        if (response.data !== null && response.data !== undefined) {
+            return response.data;
+        }
+        // Otherwise, parse the response body as JSON
+        const data = await response.json();
+        // Apply reviver and date parsing if options are set
+        if (this.#options?.reviver || this.#options?.shouldParseDates) {
+            return this.#reviveJson(data);
+        }
+        return data;
+    }
+    /**
+     * Returns the response body as text.
+     *
+     * @returns A promise that resolves to the response text
+     *
+     * @example
+     * ```typescript
+     * const html = await client.get("/page").text();
+     * ```
+     */
+    async text() {
+        const response = await this.#responsePromise;
+        return response.text();
+    }
+    /**
+     * Returns the response body as a Blob.
+     *
+     * @returns A promise that resolves to the response as a Blob
+     *
+     * @example
+     * ```typescript
+     * const imageBlob = await client.get("/image.png").blob();
+     * ```
+     */
+    async blob() {
+        const response = await this.#responsePromise;
+        return response.blob();
+    }
+    /**
+     * Returns the response body as an ArrayBuffer.
+     *
+     * @returns A promise that resolves to the response as an ArrayBuffer
+     *
+     * @example
+     * ```typescript
+     * const buffer = await client.get("/file").arrayBuffer();
+     * ```
+     */
+    async arrayBuffer() {
+        const response = await this.#responsePromise;
+        return response.arrayBuffer();
+    }
+    /**
+     * Returns the response body as FormData.
+     *
+     * @returns A promise that resolves to the response as FormData
+     *
+     * @example
+     * ```typescript
+     * const formData = await client.get("/form").formData();
+     * ```
+     */
+    async formData() {
+        const response = await this.#responsePromise;
+        return response.formData();
+    }
+    #reviveJson(data) {
+        if (data === null || data === undefined) {
+            return data;
+        }
+        if (Array.isArray(data)) {
+            return data.map((item) => this.#reviveJson(item));
+        }
+        if (typeof data === "object") {
+            const result = {};
+            for (const [key, value] of Object.entries(data)) {
+                result[key] = this.#reviveValue(key, this.#reviveJson(value));
+            }
+            return result;
+        }
+        return this.#reviveValue("", data);
+    }
+    #reviveValue(key, value) {
+        let revivedValue = value;
+        if (this.#options?.reviver) {
+            revivedValue = this.#options.reviver.call(this, key, revivedValue);
+        }
+        if (this.#options?.shouldParseDates) {
+            revivedValue = this.#tryParseDate(revivedValue);
+        }
+        return revivedValue;
+    }
+    #tryParseDate(value) {
+        if (typeof value !== "string") {
+            return value;
+        }
+        if (/^\d{4}-\d{2}-\d{2}/.test(value)) {
+            const date = new Date(value);
+            if (!isNaN(date.getTime())) {
+                return date;
+            }
+        }
+        return value;
+    }
+}