@superutils/fetch 1.1.7 → 1.2.0

package/README.md

@@ -13,7 +13,10 @@ This package enhances the native `fetch` API by providing a streamlined interfac
     - [`Method Specific Functions`](#methods)
     - [`fetch.get.deferred()`](#fetch-deferred): cancellable and debounced or throttled `fetch()`
     - [`fetch.post()`](#post): make post requests
-    - [`fetch.post.deferred()`](#post-deferred) cancellable and debounced or throttled `post()`
+    - [`fetch.post.deferred()`](#post-deferred): cancellable and debounced or throttled `post()`
+    - [`Retry`](#retry) Retry on request failure
+    - [`Timeout`](#timeout) Abort request on timeout
+    - [`Interceptors/Transformers`](#interceptors)
 
 ## Features
 
@@ -37,18 +40,14 @@ npm install @superutils/fetch
 
 ### `fetch(url, options)`
 
-Make a simple GET request. No need for `response.json()` or `result.data.theActualData` drilling.
+Use as a drop-in replacement to the built-in `fetch()`.
 
-```typescript
+```javascript
 import fetch from '@superutils/fetch'
 
-fetch('https://dummyjson.com/products/1', {
-	method: 'get', // default
-}).then(theActualData => console.log(theActualData))
-// Alternative:
-fetch
-	.get('https://dummyjson.com/products/1')
-	.then(theActualData => console.log(theActualData))
+fetch('https://dummyjson.com/products/1')
+	.then(response => response.json())
+	.then(console.log)
 ```
 
 <div id="methods"></div>
@@ -75,6 +74,16 @@ While `fetch()` provides access to all HTTP request methods by specifying it in
 - `fetch.post.deferred(...)`
 - `fetch.put.deferred(...)`
 
+All method specific functions by default return result parsed as JSON. No need for `response.json()` or `result.data.data` drilling.
+
+```javascript
+import fetch from '@superutils/fetch'
+
+fetch
+	.get('https://dummyjson.com/products/1')
+	.then(product => console.log({ product }))
+```
+
 <div id="fetch-deferred"></div>
 
 ### `fetch.get.deferred(deferOptions, defaultUrl, defaultOptions)`
@@ -268,3 +277,163 @@ fetch
 // Only the final call executes, 300ms after it was made (at the 400ms mark).
 // The token is refreshed only once, preventing redundant network requests.
 ```
+
+<div id="interceptors"></div>
+
+### Interceptors: intercept and/or transform request & result
+
+The following interceptor callbacks allow intercepting and/or transforming at different stages of the request.
+
+#### Interceptor types (executed in sequence):
+
+1. `request`: Request interceptors are executed before a HTTP request is made.
+    - To transform the URL simply return a new or modified URL.
+    - To transform `fetch` options simply modify the options parameter
+2. `response`: Response interceptors are executed after receiving a `fetch` Response regardless of the HTTP status code.
+3. `result`: Result interceptors are executed before returning the result. To transform the result simply return a new value.
+   PS: if the value of `options.as` is `FetchAs.response` (`"response"`), the value received in result will be a `Response` object.
+4. `error`: Error interceptors are executed when the request fails. Error can be transformed by returning a modified/new `FetchError`.
+
+#### Notes:
+
+- All interceptors can be either asynchronous or synchronous functions.
+- If an exception is raised while executing the interceptors, it will be gracefully ignored.
+- Value returned (transformed) by an interceptor will be carried over to the subsequent interceptor of the same type.
+- There are 2 category of interceptors:
+    - Local: interceptors provided when making a request.
+    - Global: intereptors that are executed application-wide on every request. Global interceptors can be added/accessed at `fetch.defaults.interceptors`. Global interceptors are always executed before local interceptors.
+
+    **Example: Add global request and error interceptors**
+
+    ```javascript
+    import fetch from '@superutils/fetch'
+
+    const { interceptors } = fetch.defaults
+    interceptors.request.push((url, options) => {
+    	// a headers to all requests make by the application
+    	options.headers.append('x-auth', 'token')
+    })
+
+    interceptors.error.push((err, url, options) => {
+    	// log whenever a request fails
+    	console.log('Error interceptor', err)
+    })
+    ```
+
+```javascript
+import fetch, { FetchError } from '@superutils/fetch'
+
+const interceptors = {
+	error: [
+		(err, url, options) => {
+			console.log('Request failed', err, url, options)
+			// return nothing/undefined to keep the error unchanged
+			// or return modified/new error
+			err.message = 'My custom error message!'
+			// or create a new FetchError by cloning it (make sure all the required properties are set correctly)
+			return err.clone('My custom error message!')
+		},
+	],
+	request: [
+		(url, options) => {
+			// add extra headers or modify request options here
+			options.headers.append('x-custom-header', 'some value')
+
+			// transform the URL by returning a modified URL
+			return url + '?param=value'
+		},
+	],
+	response: [
+		(response, url, options) => {
+			if (response.ok) return
+			console.log('request was successful', { url, options })
+
+			// You can transform the response by returning different `Response` object or even make a completely new HTTP reuqest.
+			// The subsequent response interceptors will receive the returned response
+			return fetch('https://dummyjson.com/products/1') // promise will be resolved automatically
+		},
+	],
+	result: [
+		(result, url, options) => {
+			const productId = Number(
+				new URL(url).pathname.split('/products/')[1],
+			)
+			if (options.method === 'get' && !Number.isNaN(productId)) {
+				result.title ??= 'Unknown title'
+			}
+			return result
+		},
+	],
+}
+fetch
+	.get('https://dummyjson.com/products/1', { interceptors })
+	.then(product => console.log({ product }))
+```
+
+<div id="retry"></div>
+
+### Retry
+
+The `retry` option provides a robust mechanism to automatically re-attempt failed requests, with support for both linear and exponential backoff strategies to gracefully handle transient network issues.
+
+```javascript
+import fetch from '@superutils/fetch'
+
+fetch.get('https://dummyjson.com/products/1', {
+	retry: 3, // Max number of retries.
+	retryBackOff: 'linear', // Backoff strategy: 'linear' or 'exponential'.
+	// Delay in milliseconds.
+	// - 'linear': Constant delay between each attempt.
+	// - 'exponential': Initial delay that doubles with each retry.
+	retryDelay: 300,
+	retryDelayJitter: true, // Add random delay to avoid thundering herd.
+	retryDelayJitterMax: 100, // Max jitter delay (ms).
+	retryIf: (response, retryCount, error) => {
+		console.log('Attempt #', retryCount + 1)
+		// re-attempt if status code not 200
+		return response.status !== 200
+	},
+})
+```
+
+<div id="timeout"></div>
+
+### Request Timeout
+
+A request can be automatically cancelled by simply providing a `timeout` duration in milliseconds. Internally, `fetch` uses an `AbortController` to cancel the request if it does not complete within the specified time.
+
+```javascript
+import fetch from '@superutils/fetch'
+
+fetch.get('https://dummyjson.com/products/1', {
+	timeout: 5000,
+})
+```
+
+<div id="fetch-as"></div>
+
+### Response Parsing
+
+By default, `fetch()` returns a `Response` object, making it a drop-in replacement for the built-in `fetch`.
+
+However, all method-specific functions (e.g., `fetch.get`, `fetch.post`, `fetch.get.deferred`) automatically parse and return the result as JSON.
+
+To retrieve the response in a different format (e.g., as text, a blob, or the raw `Response` object), set the `as` option to one of the following `FetchAs` values:
+
+- `FetchAs.json`
+- `FetchAs.text`
+- `FetchAs.blob`
+- `FetchAs.arrayBuffer`
+- `FetchAs.formData`
+- `FetchAs.bytes`
+- `FetchAs.response`
+
+> **Note:** When not using TypeScript, you can simply pass the string value (e.g., `'text'`, `'blob'`, `'response'`).
+
+```typescript
+import fetch, { FetchAs } from '@superutils/fetch'
+
+fetch.get('https://dummyjson.com/products/1', {
+	as: FetchAs.text,
+})
+```

package/dist/index.d.ts

@@ -1,7 +1,7 @@
-import { ValueOrPromise } from '@superutils/core';
 import * as _superutils_promise from '@superutils/promise';
 import { RetryOptions, IPromisE, DeferredAsyncOptions } from '@superutils/promise';
 export { DeferredAsyncOptions, ResolveError, ResolveIgnored } from '@superutils/promise';
+import { ValueOrPromise } from '@superutils/core';
 
 type FetchArgs<OmitMethod extends boolean = false> = [
     url: string | URL,
@@ -46,7 +46,7 @@ type FetchErrMsgs = {
 };
 /** Custom error message for fetch requests with more detailed info about the request URL, fetch options and response */
 declare class FetchError extends Error {
-    options?: FetchOptions;
+    options: FetchOptions;
     response?: Response;
     url: string | URL;
     constructor(message: string, options: {
@@ -55,6 +55,7 @@ declare class FetchError extends Error {
         response?: Response;
         url: string | URL;
     });
+    clone: (newMessage: string) => FetchError;
 }
 /**
  * Fetch error interceptor to be invoked whenever an exception occurs.
@@ -97,11 +98,10 @@ declare class FetchError extends Error {
  */
 type FetchInterceptorError = Interceptor<FetchError, FetchArgsInterceptor>;
 /**
- *
  * Fetch request interceptor to be invoked before making a fetch request.
  * This interceptor can also be used as a transformer:
  * 1. by returning an API URL (string/URL)
- * 2. by modifying the properties of the options object to be used before making the fetch request
+ * 2. by modifying the properties of the options parameter to be used before making the fetch request
  *
  * @example intercept and transform fetch request
  * ```typescript
@@ -119,7 +119,9 @@ type FetchInterceptorError = Interceptor<FetchError, FetchArgsInterceptor>;
  * })
  * ```
  */
-type FetchInterceptorRequest = Interceptor<FetchArgs[0], FetchArgsInterceptor>;
+type FetchInterceptorRequest = Interceptor<FetchArgs[0], [
+    FetchArgsInterceptor[1]
+]>;
 /**
  * Fetch response interceptor to be invoked before making a fetch request.
  *
@@ -187,7 +189,7 @@ type FetchInterceptorResponse = Interceptor<Response, FetchArgsInterceptor>;
  * })
  * ```
  */
-type FetchInterceptorResult = Interceptor<unknown, FetchArgsInterceptor>;
+type FetchInterceptorResult<Args extends unknown[] = FetchArgsInterceptor> = Interceptor<unknown, Args>;
 /**
  * All valid interceptors for fetch requests are:
  * ---
@@ -235,7 +237,7 @@ type FetchInterceptors = {
  * Fetch request options
  */
 type FetchOptions = RequestInit & FetchCustomOptions;
-type FetchOptionsDefaults = Omit<FetchOptionsInterceptor, 'method' | 'retryIf'>;
+type FetchOptionsDefaults = Omit<FetchOptionsInterceptor, 'as' | 'method' | 'retryIf'>;
 /**
  * Fetch options available to interceptors
  */
@@ -248,7 +250,7 @@ type FetchOptionsInterceptor = Omit<FetchOptions, 'as' | 'errMsgs' | 'intercepto
 /**
  * Result types for specific parsers ("as": FetchAs)
  */
-interface FetchResult<T> {
+type FetchResult<T> = {
     arrayBuffer: ArrayBuffer;
     blob: Blob;
     bytes: Uint8Array<ArrayBuffer>;
@@ -256,7 +258,7 @@ interface FetchResult<T> {
     json: T;
     text: string;
     response: Response;
-}
+};
 /**
  * Fetch retry options
  */
@@ -318,12 +320,218 @@ type PostOptions = Omit<FetchOptions, 'method'> & {
     method?: 'post' | 'put' | 'patch' | 'delete' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
 };
 
-declare const fetch$1: {
-    <T, TOptions extends FetchOptions = FetchOptions, TReturn = TOptions["as"] extends FetchAs ? FetchResult<T>[TOptions["as"]] : T>(url: string | URL, options?: TOptions): IPromisE<TReturn>;
+/** Create a method-specific fetch function attached with a `.deferred()` function */
+declare const createFetchMethodFunc: (method?: Pick<FetchOptions, "method">["method"]) => {
+    <T, TOptions extends FetchOptions = FetchOptions, TAs extends FetchAs = TOptions["as"] extends FetchAs ? TOptions["as"] : FetchAs.json, TReturn = FetchResult<T>[TAs]>(url: string | URL, options?: TOptions | undefined): _superutils_promise.IPromisE<T>;
+    deferred<ThisArg = unknown, Delay extends number = number, GlobalUrl = string | URL | undefined, CbArgs extends unknown[] = undefined extends GlobalUrl ? FetchArgs<true> : [options?: Omit<FetchOptions, "method"> | undefined]>(deferOptions?: _superutils_promise.DeferredAsyncOptions<ThisArg, Delay> | undefined, defaultUrl?: GlobalUrl | undefined, defaultOptions?: FetchOptions | undefined): <TResult = unknown>(...args: undefined extends GlobalUrl ? FetchArgs<false> : [options?: FetchOptions | undefined]) => _superutils_promise.IPromisE<TResult>;
+};
+
+/**
+ * Create a method-specific function for POST-like methods that automatically stringifies `data`
+ * and attached with a `.deferred()` function
+ */
+declare const createPostMethodFunc: (method?: Pick<PostOptions, "method">["method"]) => {
+    <T, Args extends PostArgs<true> = PostArgs<true>>(url: Args[0], data?: Args[1], options?: Args[2]): _superutils_promise.IPromisE<T>;
+    deferred<ThisArg, Delay extends number = number, GlobalUrl extends PostArgs[0] | undefined = undefined, GlobalData extends PostArgs[1] | undefined = undefined, CbArgs extends unknown[] = PostDeferredCbArgs<GlobalUrl, GlobalData, true>>(deferOptions?: _superutils_promise.DeferredAsyncOptions<ThisArg, Delay> | undefined, defaultUrl?: GlobalUrl | undefined, defaultData?: GlobalData | undefined, defaultOptions?: PostOptions | undefined): <TResult = unknown>(...args: PostDeferredCbArgs<GlobalUrl, GlobalData, false, PostArgs<false>, PostOptions | undefined, [url: string | URL, data: PostBody | (() => PostBody), options: PostOptions]>) => _superutils_promise.IPromisE<TResult>;
+};
+
+/**
+ * Extended `fetch` with timeout, retry, and other options. Automatically parses as JSON by default on success.
+ *
+ * @param url request URL
+ * @param options (optional) Standard `fetch` options extended with {@link FetchCustomOptions}.
+ * Default content type is 'application/json'
+ * @param options.as (optional) determines who to parse the result. Default: {@link FetchAs.json}
+ * @param options.method (optional) fetch method. Default: `'get'`
+ *
+ * @example Make a simple HTTP requests
+ * ```typescript
+ * import { fetch } from '@superutils/fetch'
+ *
+ * // no need for `response.json()` or `result.data.data` drilling
+ * fetch('https://dummyjson.com/products/1')
+ * 	   .then(product => console.log(product))
+ * ```
+ */
+declare const fetch: {
+    <T, TOptions extends FetchOptions = FetchOptions, TAs extends FetchAs = TOptions["as"] extends FetchAs ? TOptions["as"] : FetchAs.json, TReturn = FetchResult<T>[TAs]>(url: string | URL, options?: TOptions): IPromisE<TReturn>;
     /** Default fetch options */
     defaults: FetchOptionsDefaults;
 };
 
+/**
+ * Drop-in replacement for built-in `fetch()` with with timeout, retry etc options and Response as default return type.
+ *
+ * @param url request URL
+ * @param options (optional) Standard `fetch` options extended with {@link FetchCustomOptions}
+ * @param options.as (optional) determines who to parse the result. Default: {@link FetchAs.response}
+ * @param options.method (optional) fetch method. Default: `'get'`
+ *
+ * @example Make a simple HTTP requests
+ * ```typescript
+ * import { fetchResponse } from '@superutils/fetch'
+ *
+ * fetchResponse('https://dummyjson.com/products/1')
+ *     .then(response => response.json())
+ *     .then(console.log, console.error)
+ * ```
+ */
+declare const fetchResponse: <T = Response, TOptions extends FetchOptions = FetchOptions, TAs extends FetchAs = TOptions["as"] extends FetchAs ? TOptions["as"] : FetchAs.response, TReturn = FetchResult<T>[TAs]>(...args: Parameters<typeof fetch<T, TOptions, TAs, TReturn>>) => IPromisE<TReturn>;
+
+declare const _get: {
+    <T, TOptions extends FetchOptions = FetchOptions, TAs extends FetchAs = TOptions["as"] extends FetchAs ? TOptions["as"] : FetchAs.json, TReturn = FetchResult<T>[TAs]>(url: string | URL, options?: TOptions | undefined): _superutils_promise.IPromisE<T>;
+    deferred<ThisArg = unknown, Delay extends number = number, GlobalUrl = string | URL | undefined, CbArgs extends unknown[] = undefined extends GlobalUrl ? FetchArgs<true> : [options?: Omit<FetchOptions, "method"> | undefined]>(deferOptions?: _superutils_promise.DeferredAsyncOptions<ThisArg, Delay> | undefined, defaultUrl?: GlobalUrl | undefined, defaultOptions?: FetchOptions | undefined): <TResult = unknown>(...args: undefined extends GlobalUrl ? FetchArgs<false> : [options?: FetchOptions | undefined]) => _superutils_promise.IPromisE<TResult>;
+};
+declare const _head: {
+    <T, TOptions extends FetchOptions = FetchOptions, TAs extends FetchAs = TOptions["as"] extends FetchAs ? TOptions["as"] : FetchAs.json, TReturn = FetchResult<T>[TAs]>(url: string | URL, options?: TOptions | undefined): _superutils_promise.IPromisE<T>;
+    deferred<ThisArg = unknown, Delay extends number = number, GlobalUrl = string | URL | undefined, CbArgs extends unknown[] = undefined extends GlobalUrl ? FetchArgs<true> : [options?: Omit<FetchOptions, "method"> | undefined]>(deferOptions?: _superutils_promise.DeferredAsyncOptions<ThisArg, Delay> | undefined, defaultUrl?: GlobalUrl | undefined, defaultOptions?: FetchOptions | undefined): <TResult = unknown>(...args: undefined extends GlobalUrl ? FetchArgs<false> : [options?: FetchOptions | undefined]) => _superutils_promise.IPromisE<TResult>;
+};
+declare const _options: {
+    <T, TOptions extends FetchOptions = FetchOptions, TAs extends FetchAs = TOptions["as"] extends FetchAs ? TOptions["as"] : FetchAs.json, TReturn = FetchResult<T>[TAs]>(url: string | URL, options?: TOptions | undefined): _superutils_promise.IPromisE<T>;
+    deferred<ThisArg = unknown, Delay extends number = number, GlobalUrl = string | URL | undefined, CbArgs extends unknown[] = undefined extends GlobalUrl ? FetchArgs<true> : [options?: Omit<FetchOptions, "method"> | undefined]>(deferOptions?: _superutils_promise.DeferredAsyncOptions<ThisArg, Delay> | undefined, defaultUrl?: GlobalUrl | undefined, defaultOptions?: FetchOptions | undefined): <TResult = unknown>(...args: undefined extends GlobalUrl ? FetchArgs<false> : [options?: FetchOptions | undefined]) => _superutils_promise.IPromisE<TResult>;
+};
+declare const _delete: {
+    <T, Args extends PostArgs<true> = PostArgs<true>>(url: Args[0], data?: Args[1], options?: Args[2]): _superutils_promise.IPromisE<T>;
+    deferred<ThisArg, Delay extends number = number, GlobalUrl extends PostArgs[0] | undefined = undefined, GlobalData extends PostArgs[1] | undefined = undefined, CbArgs extends unknown[] = PostDeferredCbArgs<GlobalUrl, GlobalData, true>>(deferOptions?: _superutils_promise.DeferredAsyncOptions<ThisArg, Delay> | undefined, defaultUrl?: GlobalUrl | undefined, defaultData?: GlobalData | undefined, defaultOptions?: PostOptions | undefined): <TResult = unknown>(...args: PostDeferredCbArgs<GlobalUrl, GlobalData, false, PostArgs<false>, PostOptions | undefined, [url: string | URL, data: PostBody | (() => PostBody), options: PostOptions]>) => _superutils_promise.IPromisE<TResult>;
+};
+declare const _patch: {
+    <T, Args extends PostArgs<true> = PostArgs<true>>(url: Args[0], data?: Args[1], options?: Args[2]): _superutils_promise.IPromisE<T>;
+    deferred<ThisArg, Delay extends number = number, GlobalUrl extends PostArgs[0] | undefined = undefined, GlobalData extends PostArgs[1] | undefined = undefined, CbArgs extends unknown[] = PostDeferredCbArgs<GlobalUrl, GlobalData, true>>(deferOptions?: _superutils_promise.DeferredAsyncOptions<ThisArg, Delay> | undefined, defaultUrl?: GlobalUrl | undefined, defaultData?: GlobalData | undefined, defaultOptions?: PostOptions | undefined): <TResult = unknown>(...args: PostDeferredCbArgs<GlobalUrl, GlobalData, false, PostArgs<false>, PostOptions | undefined, [url: string | URL, data: PostBody | (() => PostBody), options: PostOptions]>) => _superutils_promise.IPromisE<TResult>;
+};
+declare const _post: {
+    <T, Args extends PostArgs<true> = PostArgs<true>>(url: Args[0], data?: Args[1], options?: Args[2]): _superutils_promise.IPromisE<T>;
+    deferred<ThisArg, Delay extends number = number, GlobalUrl extends PostArgs[0] | undefined = undefined, GlobalData extends PostArgs[1] | undefined = undefined, CbArgs extends unknown[] = PostDeferredCbArgs<GlobalUrl, GlobalData, true>>(deferOptions?: _superutils_promise.DeferredAsyncOptions<ThisArg, Delay> | undefined, defaultUrl?: GlobalUrl | undefined, defaultData?: GlobalData | undefined, defaultOptions?: PostOptions | undefined): <TResult = unknown>(...args: PostDeferredCbArgs<GlobalUrl, GlobalData, false, PostArgs<false>, PostOptions | undefined, [url: string | URL, data: PostBody | (() => PostBody), options: PostOptions]>) => _superutils_promise.IPromisE<TResult>;
+};
+declare const _put: {
+    <T, Args extends PostArgs<true> = PostArgs<true>>(url: Args[0], data?: Args[1], options?: Args[2]): _superutils_promise.IPromisE<T>;
+    deferred<ThisArg, Delay extends number = number, GlobalUrl extends PostArgs[0] | undefined = undefined, GlobalData extends PostArgs[1] | undefined = undefined, CbArgs extends unknown[] = PostDeferredCbArgs<GlobalUrl, GlobalData, true>>(deferOptions?: _superutils_promise.DeferredAsyncOptions<ThisArg, Delay> | undefined, defaultUrl?: GlobalUrl | undefined, defaultData?: GlobalData | undefined, defaultOptions?: PostOptions | undefined): <TResult = unknown>(...args: PostDeferredCbArgs<GlobalUrl, GlobalData, false, PostArgs<false>, PostOptions | undefined, [url: string | URL, data: PostBody | (() => PostBody), options: PostOptions]>) => _superutils_promise.IPromisE<TResult>;
+};
+type FetchWithMethods = typeof fetchResponse & {
+    /** Default options */
+    defaults: typeof fetch.defaults;
+    /** Make HTTP `DELETE` request, result automatically parsed as JSON */
+    delete: typeof _delete;
+    /** Make HTTP `GET` request, result automatically parsed as JSON */
+    get: typeof _get;
+    /** Make HTTP `HEAD` request, result automatically parsed as JSON */
+    head: typeof _head;
+    /** Make HTTP `OPTIONS` request, result automatically parsed as JSON */
+    options: typeof _options;
+    /** Make HTTP `PATCH` request, result automatically parsed as JSON */
+    patch: typeof _patch;
+    /** Make HTTP `POST` request, result automatically parsed as JSON */
+    post: typeof _post;
+    /** Make HTTP `PUT` request, result automatically parsed as JSON */
+    put: typeof _put;
+};
+/**
+ * A `fetch()` replacement that simplifies data fetching with automatic JSON parsing, request timeouts, retries,
+ * and handy interceptors that also work as transformers. It also includes deferred and throttled request
+ * capabilities for complex asynchronous control flows.
+ *
+ * Will reject promise if response status code is not 2xx (200 <= status < 300).
+ *
+ * ## Method Specific Functions
+ *
+ * While `fetch()` provides access to all HTTP request methods by specifying it in options (eg: `{ method: 'get' }`),
+ * for ease of use you can also use the following:
+ *
+ * - `fetch.delete(...)`
+ * - `fetch.get(...)`
+ * - `fetch.head(...)`
+ * - `fetch.options(...)`
+ * - `fetch.patch(...)`
+ * - `fetch.post(...)`
+ * - `fetch.put(...)`
+ *
+ * **Deferred variants:** To debounce/throttle requests.
+ *
+ * - `fetch.delete.deferred(...)`
+ * - `fetch.get.deferred(...)`
+ * - `fetch.head.deferred(...)`
+ * - `fetch.options.deferred(...)`
+ * - `fetch.patch.deferred(...)`
+ * - `fetch.post.deferred(...)`
+ * - `fetch.put.deferred(...)`
+ *
+ * @template T The type of the value that the `fetch` resolves to.
+ * @template TReturn Return value type.
+ *
+ * If `T` is not specified defaults to the following based on the value of `options.as`:
+ * - FetchAs.arrayBuffer: `ArrayBuffer`
+ * - FetchAs.blob: `Blob`
+ * - FetchAs.bytes: `Uint8Array<ArrayBuffer>`
+ * - FetchAs.formData: `FormData`
+ * - FetchAs.json: `unknown`
+ * - FetchAs.text: `string`
+ * - FetchAs.response: `Response`
+ * @param url
+ * @param options (optional) Standard `fetch` options extended with {@link FetchCustomOptions}
+ * @param options.as (optional) determines who to parse the result. Default: {@link FetchAs.response}
+ * @param options.headers (optional) request headers
+ * Default: `{ 'content-type': `'application/json' }` (unless changed in the fetch.defaults).
+ * @param options.method (optional) fetch method. Default: `'get'`
+ *
+ * Options' default values (excluding `as`, `method` and `retryIf`) can be configured to be EFFECTIVE GLOBALLY.
+ *
+ * ```typescript
+ * import fetch from '@superutils/fetch'
+ *
+ * fetch.defaults = {
+ *     errMsgs: {
+ *        invalidUrl: 'Invalid URL',
+ *        parseFailed: 'Failed to parse response as',
+ *        reqTimedout: 'Request timed out',
+ *        requestFailed: 'Request failed with status code:',
+ *     },
+ *     headers: new Headers([['content-type', 'application/json']]),
+ * 	   // Global/application-wide Interceptor & Transfermers
+ *     interceptors: {
+ *     	   error: [],
+ *     	   request: [],
+ *     	   response: [],
+ *     	   result: [],
+ *     },
+ *     timeout: 0,
+ *     //........
+ * }
+ * ```
+ *
+ * @property options.abortCtrl (optional) if not provided `AbortController` will be instantiated when `timeout` used.
+ * @property options.headers (optional) request headers. Default: `{ 'content-type' : 'application/json'}`
+ * @property options.interceptors (optional) request interceptor callbacks.  See {@link FetchInterceptors} for details.
+ * @property options.method (optional) Default: `"get"`
+ * @property options.timeout (optional) duration in milliseconds to abort the request if it takes longer.
+ * @property options.parse (optional) specify how to parse the result.
+ * Default: {@link FetchAs.json}
+ * For raw `Response` use {@link FetchAs.response}
+ *
+ * @example Drop-in replacement for built-in `fetch`
+ * ```typescript
+ * import fetch from '@superutils/fetch'
+ *
+ * fetch('https://dummyjson.com/products/1')
+ *     .then(response => response.json())
+ *     .then(console.log, console.error)
+ * ```
+ *
+ * @example Method specific function with JSON parsing by default
+ * ```typescript
+ * import fetch from '@superutils/fetch'
+ *
+ * // no need for `response.json()` or `result.data.data` drilling
+ * fetch.get('https://dummyjson.com/products/1')
+ *     .then(product => console.log(product))
+ * fetch.get('https://dummyjson.com/products/1')
+ *     .then(product => console.log(product))
+ *
+ *
+ * fetch.post('https://dummyjson.com/products/add', { title: 'Product title' })
+ *     .then(product => console.log(product))
+ * ```
+ */
+declare const fetchDefault: FetchWithMethods;
+
 /**
  * Creates a deferred/throttled version of {@link fetch}, powered by {@link PromisE.deferred}.
  * This is ideal for scenarios requiring advanced control over HTTP requests, such as debouncing search inputs,
@@ -521,140 +729,4 @@ declare function postDeferred<ThisArg, Delay = unknown, DefaultUrl extends PostA
  */
 declare const mergeFetchOptions: (...allOptions: FetchOptions[]) => FetchOptionsInterceptor;
 
-/** Create a method-specific fetch function attached with a `.deferred()` function */
-declare const createFetchMethodFunc: (method?: string) => {
-    <T>(url: string | URL, options?: Omit<FetchOptions, "method">): _superutils_promise.IPromisE<T>;
-    deferred<ThisArg = unknown, Delay extends number = number, GlobalUrl = string | URL | undefined, CbArgs extends unknown[] = undefined extends GlobalUrl ? FetchArgs<true> : [options?: Omit<FetchOptions, "method"> | undefined]>(deferOptions?: _superutils_promise.DeferredAsyncOptions<ThisArg, Delay> | undefined, defaultUrl?: GlobalUrl | undefined, defaultOptions?: FetchOptions | undefined): <TResult = unknown>(...args: undefined extends GlobalUrl ? FetchArgs<false> : [options?: FetchOptions | undefined]) => _superutils_promise.IPromisE<TResult>;
-};
-/** Create a method-specific function for POST-like methods and with a `.deferred()` function */
-declare const createPostMethodFunc: (method?: Pick<PostOptions, "method">["method"]) => {
-    <T, Args extends PostArgs<true> = PostArgs<true>>(url: Args[0], data?: Args[1], options?: Args[2]): _superutils_promise.IPromisE<T>;
-    deferred<ThisArg, Delay extends number = number, GlobalUrl extends PostArgs[0] | undefined = undefined, GlobalData extends PostArgs[1] | undefined = undefined, CbArgs extends unknown[] = PostDeferredCbArgs<GlobalUrl, GlobalData, true>>(deferOptions?: _superutils_promise.DeferredAsyncOptions<ThisArg, Delay> | undefined, defaultUrl?: GlobalUrl | undefined, defaultData?: GlobalData | undefined, defaultOptions?: PostOptions | undefined): <TResult = unknown>(...args: PostDeferredCbArgs<GlobalUrl, GlobalData, false, PostArgs<false>, PostOptions | undefined, [url: string | URL, data: PostBody | (() => PostBody), options: PostOptions]>) => _superutils_promise.IPromisE<TResult>;
-};
-declare const _get: {
-    <T>(url: string | URL, options?: Omit<FetchOptions, "method">): _superutils_promise.IPromisE<T>;
-    deferred<ThisArg = unknown, Delay extends number = number, GlobalUrl = string | URL | undefined, CbArgs extends unknown[] = undefined extends GlobalUrl ? FetchArgs<true> : [options?: Omit<FetchOptions, "method"> | undefined]>(deferOptions?: _superutils_promise.DeferredAsyncOptions<ThisArg, Delay> | undefined, defaultUrl?: GlobalUrl | undefined, defaultOptions?: FetchOptions | undefined): <TResult = unknown>(...args: undefined extends GlobalUrl ? FetchArgs<false> : [options?: FetchOptions | undefined]) => _superutils_promise.IPromisE<TResult>;
-};
-declare const _head: {
-    <T>(url: string | URL, options?: Omit<FetchOptions, "method">): _superutils_promise.IPromisE<T>;
-    deferred<ThisArg = unknown, Delay extends number = number, GlobalUrl = string | URL | undefined, CbArgs extends unknown[] = undefined extends GlobalUrl ? FetchArgs<true> : [options?: Omit<FetchOptions, "method"> | undefined]>(deferOptions?: _superutils_promise.DeferredAsyncOptions<ThisArg, Delay> | undefined, defaultUrl?: GlobalUrl | undefined, defaultOptions?: FetchOptions | undefined): <TResult = unknown>(...args: undefined extends GlobalUrl ? FetchArgs<false> : [options?: FetchOptions | undefined]) => _superutils_promise.IPromisE<TResult>;
-};
-declare const _options: {
-    <T>(url: string | URL, options?: Omit<FetchOptions, "method">): _superutils_promise.IPromisE<T>;
-    deferred<ThisArg = unknown, Delay extends number = number, GlobalUrl = string | URL | undefined, CbArgs extends unknown[] = undefined extends GlobalUrl ? FetchArgs<true> : [options?: Omit<FetchOptions, "method"> | undefined]>(deferOptions?: _superutils_promise.DeferredAsyncOptions<ThisArg, Delay> | undefined, defaultUrl?: GlobalUrl | undefined, defaultOptions?: FetchOptions | undefined): <TResult = unknown>(...args: undefined extends GlobalUrl ? FetchArgs<false> : [options?: FetchOptions | undefined]) => _superutils_promise.IPromisE<TResult>;
-};
-declare const _delete: {
-    <T, Args extends PostArgs<true> = PostArgs<true>>(url: Args[0], data?: Args[1], options?: Args[2]): _superutils_promise.IPromisE<T>;
-    deferred<ThisArg, Delay extends number = number, GlobalUrl extends PostArgs[0] | undefined = undefined, GlobalData extends PostArgs[1] | undefined = undefined, CbArgs extends unknown[] = PostDeferredCbArgs<GlobalUrl, GlobalData, true>>(deferOptions?: _superutils_promise.DeferredAsyncOptions<ThisArg, Delay> | undefined, defaultUrl?: GlobalUrl | undefined, defaultData?: GlobalData | undefined, defaultOptions?: PostOptions | undefined): <TResult = unknown>(...args: PostDeferredCbArgs<GlobalUrl, GlobalData, false, PostArgs<false>, PostOptions | undefined, [url: string | URL, data: PostBody | (() => PostBody), options: PostOptions]>) => _superutils_promise.IPromisE<TResult>;
-};
-declare const _patch: {
-    <T, Args extends PostArgs<true> = PostArgs<true>>(url: Args[0], data?: Args[1], options?: Args[2]): _superutils_promise.IPromisE<T>;
-    deferred<ThisArg, Delay extends number = number, GlobalUrl extends PostArgs[0] | undefined = undefined, GlobalData extends PostArgs[1] | undefined = undefined, CbArgs extends unknown[] = PostDeferredCbArgs<GlobalUrl, GlobalData, true>>(deferOptions?: _superutils_promise.DeferredAsyncOptions<ThisArg, Delay> | undefined, defaultUrl?: GlobalUrl | undefined, defaultData?: GlobalData | undefined, defaultOptions?: PostOptions | undefined): <TResult = unknown>(...args: PostDeferredCbArgs<GlobalUrl, GlobalData, false, PostArgs<false>, PostOptions | undefined, [url: string | URL, data: PostBody | (() => PostBody), options: PostOptions]>) => _superutils_promise.IPromisE<TResult>;
-};
-declare const _post: {
-    <T, Args extends PostArgs<true> = PostArgs<true>>(url: Args[0], data?: Args[1], options?: Args[2]): _superutils_promise.IPromisE<T>;
-    deferred<ThisArg, Delay extends number = number, GlobalUrl extends PostArgs[0] | undefined = undefined, GlobalData extends PostArgs[1] | undefined = undefined, CbArgs extends unknown[] = PostDeferredCbArgs<GlobalUrl, GlobalData, true>>(deferOptions?: _superutils_promise.DeferredAsyncOptions<ThisArg, Delay> | undefined, defaultUrl?: GlobalUrl | undefined, defaultData?: GlobalData | undefined, defaultOptions?: PostOptions | undefined): <TResult = unknown>(...args: PostDeferredCbArgs<GlobalUrl, GlobalData, false, PostArgs<false>, PostOptions | undefined, [url: string | URL, data: PostBody | (() => PostBody), options: PostOptions]>) => _superutils_promise.IPromisE<TResult>;
-};
-declare const _put: {
-    <T, Args extends PostArgs<true> = PostArgs<true>>(url: Args[0], data?: Args[1], options?: Args[2]): _superutils_promise.IPromisE<T>;
-    deferred<ThisArg, Delay extends number = number, GlobalUrl extends PostArgs[0] | undefined = undefined, GlobalData extends PostArgs[1] | undefined = undefined, CbArgs extends unknown[] = PostDeferredCbArgs<GlobalUrl, GlobalData, true>>(deferOptions?: _superutils_promise.DeferredAsyncOptions<ThisArg, Delay> | undefined, defaultUrl?: GlobalUrl | undefined, defaultData?: GlobalData | undefined, defaultOptions?: PostOptions | undefined): <TResult = unknown>(...args: PostDeferredCbArgs<GlobalUrl, GlobalData, false, PostArgs<false>, PostOptions | undefined, [url: string | URL, data: PostBody | (() => PostBody), options: PostOptions]>) => _superutils_promise.IPromisE<TResult>;
-};
-/**
- * @function fetch
- *
- * A `fetch()` replacement that simplifies data fetching with automatic JSON parsing, request timeouts, retries,
- * and handy interceptors that also work as transformers. It also includes deferred and throttled request
- * capabilities for complex asynchronous control flows.
- *
- * Will reject promise if response status code is not 2xx (200 <= status < 300).
- *
- * ## Method Specific Functions
- *
- * While `fetch()` provides access to all HTTP request methods by specifying it in options (eg: `{ method: 'get' }`),
- * for ease of use you can also use the following:
- *
- * - `fetch.delete(...)`
- * - `fetch.get(...)`
- * - `fetch.head(...)`
- * - `fetch.options(...)`
- * - `fetch.patch(...)`
- * - `fetch.post(...)`
- * - `fetch.put(...)`
- *
- * **Deferred variants:** To debounce/throttle requests.
- *
- * - `fetch.delete.deferred(...)`
- * - `fetch.get.deferred(...)`
- * - `fetch.head.deferred(...)`
- * - `fetch.options.deferred(...)`
- * - `fetch.patch.deferred(...)`
- * - `fetch.post.deferred(...)`
- * - `fetch.put.deferred(...)`
- *
- * @template T The type of the value that the `fetch` resolves to.
- * @template TReturn Return value type.
- *
- * If `T` is not specified defaults to the following based on the value of `options.as`:
- * - FetchAs.arrayBuffer: `ArrayBuffer`
- * - FetchAs.blob: `Blob`
- * - FetchAs.bytes: `Uint8Array<ArrayBuffer>`
- * - FetchAs.formData: `FormData`
- * - FetchAs.json: `unknown`
- * - FetchAs.text: `string`
- * - FetchAs.response: `Response`
- * @param url
- * @param options (optional) all built-in `fetch()` options such as "method", "headers" and the additionals below.
- *
- * Options' default values (excluding `method` and `retryIf`) can be configured to be EFFECTIVE GLOBALLY.
- *
- * ```typescript
- * import fetch from '@superutils/fetch'
- *
- * fetch.defaults = {
- *     as: FetchAs.json,
- *     errMsgs: {
- *        invalidUrl: 'Invalid URL',
- *        parseFailed: 'Failed to parse response as',
- *        reqTimedout: 'Request timed out',
- *        requestFailed: 'Request failed with status code:',
- *     },
- *     headers: new Headers([['content-type', 'application/json']]),
- *     interceptors: {
- *     	   error: [],
- *     	   request: [],
- *     	   response: [],
- *     	   result: [],
- *     },
- *     timeout: 0,
- *     //........
- * }
- * ```
- *
- * @property options.abortCtrl (optional) if not provided `AbortController` will be instantiated when `timeout` used.
- * @property options.headers (optional) request headers. Default: `{ 'content-type' : 'application/json'}`
- * @property options.interceptors (optional) request interceptor callbacks.  See {@link FetchInterceptors} for details.
- * @property options.method (optional) Default: `"get"`
- * @property options.timeout (optional) duration in milliseconds to abort the request if it takes longer.
- * @property options.parse (optional) specify how to parse the result.
- * Default: {@link FetchAs.json}
- * For raw `Response` use {@link FetchAs.response}
- *
- * @example Make a simple HTTP requests
- * ```typescript
- * import { fetch } from '@superutils/fetch'
- *
- * // no need for `response.json()` or `result.data.theActualData` drilling
- * fetch('https://dummyjson.com/products/1').then(theActualData => console.log(theActualData))
- * ```
- */
-declare const fetch: typeof fetch$1 & {
-    delete: typeof _delete;
-    get: typeof _get;
-    head: typeof _head;
-    options: typeof _options;
-    patch: typeof _patch;
-    post: typeof _post;
-    put: typeof _put;
-};
-
-export { type FetchArgs, type FetchArgsInterceptor, FetchAs, type FetchCustomOptions, type FetchDeferredArgs, type FetchErrMsgs, FetchError, type FetchInterceptorError, type FetchInterceptorRequest, type FetchInterceptorResponse, type FetchInterceptorResult, type FetchInterceptors, type FetchOptions, type FetchOptionsDefaults, type FetchOptionsInterceptor, type FetchResult, type FetchRetryOptions, type Interceptor, type PostArgs, type PostBody, type PostDeferredCbArgs, type PostOptions, createFetchMethodFunc, createPostMethodFunc, fetch as default, fetch, fetchDeferred, mergeFetchOptions, postDeferred };
+export { type FetchArgs, type FetchArgsInterceptor, FetchAs, type FetchCustomOptions, type FetchDeferredArgs, type FetchErrMsgs, FetchError, type FetchInterceptorError, type FetchInterceptorRequest, type FetchInterceptorResponse, type FetchInterceptorResult, type FetchInterceptors, type FetchOptions, type FetchOptionsDefaults, type FetchOptionsInterceptor, type FetchResult, type FetchRetryOptions, type FetchWithMethods, type Interceptor, type PostArgs, type PostBody, type PostDeferredCbArgs, type PostOptions, createFetchMethodFunc, createPostMethodFunc, fetchDefault as default, fetch, fetchDeferred, fetchResponse, mergeFetchOptions, postDeferred };

package/dist/index.js

@@ -1,7 +1,6 @@
 // src/fetch.ts
 import {
   fallbackIfFails as fallbackIfFails2,
-  isEmpty as isEmpty2,
   isFn as isFn2,
   isPositiveNumber,
   isPromise,
@@ -28,27 +27,22 @@ var executeInterceptors_default = executeInterceptors;
 import PromisE from "@superutils/promise";
 import { isPositiveInteger } from "@superutils/core";
 var getResponse = async (...[url, options = {}]) => {
+  const fetchFunc = globalThis.fetch;
+  if (!isPositiveInteger(options.retry)) return fetchFunc(url, options);
   let attemptCount = 0;
-  const doFetch = async () => {
-    attemptCount++;
-    return globalThis.fetch(url, options).catch(
-      (err) => err.message === "Failed to fetch" ? (
-        // catch network errors to allow retries
-        new Response(null, {
-          status: 0,
-          statusText: "Network Error"
-        })
-      ) : Promise.reject(err)
-    );
-  };
-  if (!isPositiveInteger(options.retry)) return doFetch();
-  const response = PromisE.retry(doFetch, {
-    ...options,
-    retryIf: async (res, count) => {
-      var _a;
-      return (res == null ? void 0 : res.ok) === false || await ((_a = options == null ? void 0 : options.retryIf) == null ? void 0 : _a.call(options, res, count)) === true;
+  const response = PromisE.retry(
+    () => {
+      attemptCount++;
+      return fetchFunc(url, options);
+    },
+    {
+      ...options,
+      retryIf: async (res, count) => {
+        var _a;
+        return (res == null ? void 0 : res.ok) === false || await ((_a = options == null ? void 0 : options.retryIf) == null ? void 0 : _a.call(options, res, count)) === true;
+      }
     }
-  }).catch(
+  ).catch(
     (err) => Promise.reject(
       new Error(`Request failed after attempt #${attemptCount}`, {
         cause: err
@@ -114,9 +108,15 @@ var FetchAs = /* @__PURE__ */ ((FetchAs2) => {
   FetchAs2["text"] = "text";
   return FetchAs2;
 })(FetchAs || {});
-var FetchError = class extends Error {
+var FetchError = class _FetchError extends Error {
   constructor(message, options) {
     super(message, { cause: options.cause });
+    this.clone = (newMessage) => new _FetchError(newMessage, {
+      cause: this.cause,
+      options: this.options,
+      response: this.response,
+      url: this.url
+    });
     this.name = "FetchError";
     this.options = options.options;
     this.response = options.response;
@@ -129,17 +129,18 @@ var fetch = (url, options = {}) => {
   let abortCtrl;
   let timeoutId;
   const promise = new PromisE2(async (resolve, reject) => {
-    var _a, _b;
+    var _a, _b, _c, _d;
     const _options2 = mergeFetchOptions_default(fetch.defaults, options);
-    if (isEmpty2(_options2.method)) _options2.method = "get";
+    (_a = _options2.as) != null ? _a : _options2.as = "json" /* json */;
+    (_b = _options2.method) != null ? _b : _options2.method = "get";
     const errorInterceptors = [..._options2.interceptors.error];
     const requestInterceptors = [..._options2.interceptors.request];
     const responseInterceptors = [..._options2.interceptors.response];
     const resultInterceptors = [..._options2.interceptors.result];
-    url = await executeInterceptors_default(url, requestInterceptors, url, _options2);
+    url = await executeInterceptors_default(url, requestInterceptors, _options2);
     const { as: parseAs, errMsgs, timeout } = _options2;
     if (isPositiveNumber(timeout)) {
-      (_a = _options2.abortCtrl) != null ? _a : _options2.abortCtrl = new AbortController();
+      (_c = _options2.abortCtrl) != null ? _c : _options2.abortCtrl = new AbortController();
       timeoutId = setTimeout(() => {
         var _a2;
         return (_a2 = _options2.abortCtrl) == null ? void 0 : _a2.abort();
@@ -161,14 +162,14 @@ var fetch = (url, options = {}) => {
       const { status = 0 } = response;
       const isSuccess = status >= 200 && status < 300;
       if (!isSuccess) {
+        const fallbackMsg = `${errMsgs.requestFailed} ${status}`;
         const jsonError = await fallbackIfFails2(
           // try to parse error response as json first
           () => response.json(),
           [],
-          // fallback to text if json parsing fails
-          `Request failed with status code: ${status}`
+          void 0
         );
-        const message = (jsonError == null ? void 0 : jsonError.message) || `${errMsgs.requestFailed} ${status}.`;
+        const message = (jsonError == null ? void 0 : jsonError.message) || fallbackMsg;
         throw new Error(`${message}`.replace("Error: ", ""), {
           cause: jsonError
         });
@@ -181,23 +182,23 @@ var fetch = (url, options = {}) => {
             `${errMsgs.parseFailed} ${parseAs}. ${err == null ? void 0 : err.message}`,
             { cause: err }
           );
-          return globalThis.Promise.reject(err);
+          return Promise.reject(err);
         };
         result = parseFunc.bind(response)();
         if (isPromise(result)) result = result.catch(handleErr);
-        result = await executeInterceptors_default(
-          result,
-          resultInterceptors,
-          url,
-          _options2
-        );
       }
+      result = await executeInterceptors_default(
+        result,
+        resultInterceptors,
+        url,
+        _options2
+      );
       resolve(result);
     } catch (err) {
       const errX = err;
       const msg = (errX == null ? void 0 : errX.name) === "AbortError" ? errMsgs.reqTimedout : err == null ? void 0 : err.message;
       let error = new FetchError(msg, {
-        cause: (_b = errX == null ? void 0 : errX.cause) != null ? _b : err,
+        cause: (_d = errX == null ? void 0 : errX.cause) != null ? _d : err,
         response: errResponse,
         options: _options2,
         url
@@ -216,7 +217,6 @@ var fetch = (url, options = {}) => {
   return promise;
 };
 fetch.defaults = {
-  as: "json" /* json */,
   errMsgs: {
     invalidUrl: "Invalid URL",
     parseFailed: "Failed to parse response as",
@@ -237,6 +237,7 @@ fetch.defaults = {
     response: [],
     result: []
   },
+  /** Request timeout duration in milliseconds. Default: `0` */
   timeout: 0
 };
 var fetch_default = fetch;
@@ -263,25 +264,37 @@ function fetchDeferred(deferOptions = {}, defaultUrl, defaultOptions) {
 }
 var fetchDeferred_default = fetchDeferred;
 
-// src/postDeferred.ts
-import PromisE4 from "@superutils/promise";
+// src/createFetchMethodFunc.ts
+var createFetchMethodFunc = (method = "get") => {
+  const methodFunc = (...args) => {
+    var _a;
+    (_a = args[1]) != null ? _a : args[1] = {};
+    args[1].method = method;
+    return fetch_default(...args);
+  };
+  methodFunc.deferred = (...args) => {
+    var _a;
+    (_a = args[2]) != null ? _a : args[2] = {};
+    args[2].method = method;
+    return fetchDeferred_default(...args);
+  };
+  return methodFunc;
+};
+var createFetchMethodFunc_default = createFetchMethodFunc;
 
 // src/post.ts
 import { isFn as isFn3, isStr } from "@superutils/core";
 function post(...[url = "", data, options = {}]) {
-  return fetch_default(
-    url,
-    mergeFetchOptions_default(
-      {
-        method: "post",
-        body: isStr(data) ? data : JSON.stringify(isFn3(data) ? data() : data)
-      },
-      options
-    )
-  );
+  var _a;
+  (_a = options.method) != null ? _a : options.method = "post";
+  return fetch_default(url, {
+    ...options,
+    body: isStr(data) ? data : JSON.stringify(isFn3(data) ? data() : data)
+  });
 }
 
 // src/postDeferred.ts
+import PromisE4 from "@superutils/promise";
 function postDeferred(deferOptions = {}, defaultUrl, defaultData, defaultOptions) {
   let _abortCtrl;
   const doPost = (...args) => {
@@ -304,21 +317,7 @@ function postDeferred(deferOptions = {}, defaultUrl, defaultData, defaultOptions
 }
 var postDeferred_default = postDeferred;
 
-// src/index.ts
-var createFetchMethodFunc = (method = "get") => {
-  const methodFunc = (url, options) => {
-    options != null ? options : options = {};
-    options.method = method;
-    return fetch_default(url, options);
-  };
-  methodFunc.deferred = (...args) => {
-    var _a;
-    (_a = args[2]) != null ? _a : args[2] = {};
-    args[2].method = method;
-    return fetchDeferred_default(...args);
-  };
-  return methodFunc;
-};
+// src/createPostMethodFunc.ts
 var createPostMethodFunc = (method = "post") => {
   const methodFunc = (url, data, options) => {
     options != null ? options : options = {};
@@ -333,22 +332,45 @@ var createPostMethodFunc = (method = "post") => {
   };
   return methodFunc;
 };
-var _get = createFetchMethodFunc("get");
-var _head = createFetchMethodFunc("head");
-var _options = createFetchMethodFunc("options");
-var _delete = createPostMethodFunc("delete");
-var _patch = createPostMethodFunc("patch");
-var _post = createPostMethodFunc("post");
-var _put = createPostMethodFunc("put");
-var fetch2 = fetch_default;
-fetch2.delete = _delete;
-fetch2.get = _get;
-fetch2.head = _head;
-fetch2.options = _options;
-fetch2.patch = _patch;
-fetch2.post = _post;
-fetch2.put = _put;
-var index_default = fetch2;
+var createPostMethodFunc_default = createPostMethodFunc;
+
+// src/fetchResponse.ts
+var fetchResponse = (...args) => {
+  var _a, _b, _c;
+  (_a = args[1]) != null ? _a : args[1] = {};
+  (_c = (_b = args[1]).as) != null ? _c : _b.as = "response" /* response */;
+  return fetch_default(...args);
+};
+var fetchResponse_default = fetchResponse;
+
+// src/fetchDefault.ts
+var _get = createFetchMethodFunc_default("get");
+var _head = createFetchMethodFunc_default("head");
+var _options = createFetchMethodFunc_default("options");
+var _delete = createPostMethodFunc_default("delete");
+var _patch = createPostMethodFunc_default("patch");
+var _post = createPostMethodFunc_default("post");
+var _put = createPostMethodFunc_default("put");
+var fetchDefault = fetchResponse_default;
+Object.defineProperty(fetchDefault, "defaults", {
+  get() {
+    return fetch_default.defaults;
+  },
+  set(newDefaults) {
+    fetch_default.defaults = newDefaults;
+  }
+});
+fetchDefault.delete = _delete;
+fetchDefault.get = _get;
+fetchDefault.head = _head;
+fetchDefault.options = _options;
+fetchDefault.patch = _patch;
+fetchDefault.post = _post;
+fetchDefault.put = _put;
+var fetchDefault_default = fetchDefault;
+
+// src/index.ts
+var index_default = fetchDefault_default;
 export {
   FetchAs,
   FetchError,
@@ -357,8 +379,9 @@ export {
   createFetchMethodFunc,
   createPostMethodFunc,
   index_default as default,
-  fetch2 as fetch,
+  fetch,
   fetchDeferred,
+  fetchResponse,
   mergeFetchOptions,
   postDeferred
 };

package/package.json

@@ -45,5 +45,5 @@
 	"sideEffects": false,
 	"type": "module",
 	"types": "dist/index.d.ts",
-	"version": "1.1.7"
+	"version": "1.2.0"
 }